Datasets:

---

CM

/

codexglue_code2text_ruby

like 1

[ "def", "require_module_to_base", "file", "=", "File", ".", "open", "(", "\"#{@target_dir}/app/apis/#{@project_name}/base.rb\"", ",", "\"r+\"", ")", "file", ".", "each", "do", "|", "line", "|", "while", "line", "==", "\"require_relative './modules/#{@module_name}_apis'\\n\"", "do", "$stdout", ".", "puts", "\"\\e[33mModule already mounted.\\e[0m\"", "return", "true", "end", "end", "File", ".", "open", "(", "\"#{@target_dir}/app/apis/#{@project_name}/base.rb\"", ",", "\"r+\"", ")", "do", "|", "f", "|", "pos", "=", "f", ".", "pos", "rest", "=", "f", ".", "read", "f", ".", "seek", "pos", "f", ".", "write", "(", "\"require_relative './modules/\"", ")", "f", ".", "write", "(", "@module_name", ")", "f", ".", "write", "(", "\"_apis'\\n\"", ")", "f", ".", "write", "(", "rest", ")", "end", "return", "false", "end" ]

[ "=", "begin", "Checks", "whether", "the", "module", "is", "already", "mounted", "and", "if", "not", "then", "configures", "for", "mounting", ".", "=", "end" ]

[ "def", "copy_module", "src", "=", "\"#{@gem_path}/lib/modules/#{@module_name}/#{@module_name}_apis.rb\"", "dest", "=", "\"#{@target_dir}/app/apis/#{@project_name}/modules\"", "presence", "=", "File", ".", "exists?", "(", "\"#{dest}/#{@module_name}_apis.rb\"", ")", "?", "true", ":", "false", "FileUtils", ".", "mkdir", "dest", "unless", "File", ".", "exists?", "(", "dest", ")", "FileUtils", ".", "cp", "(", "src", ",", "dest", ")", "unless", "presence", "configure_module_files", "$stdout", ".", "puts", "\"\\e[1;32m \\tcreate\\e[0m\\tapp/apis/#{@project_name}/modules/#{@module_name}_apis.rb\"", "unless", "presence", "end" ]

[ "=", "begin", "Function", "to", "copy", "the", "module", "of", "interest", "to", "project", "location", ".", "=", "end" ]

[ "def", "create_migrations_and_models", "src", "=", "\"#{@gem_path}/lib/modules/migrations\"", "dest", "=", "\"#{@target_dir}/db/migrate\"", "copy_files", "(", "src", ",", "dest", ",", "AUTH_MIGRATE", ")", "if", "@module_name", "==", "\"oauth\"", "copy_files", "(", "src", ",", "dest", ",", "OAUTH_MIGRATE", ")", "end", "src_path", "=", "\"#{@gem_path}/lib/modules/models\"", "dest_path", "=", "\"#{@target_dir}/app/models\"", "copy_files", "(", "src_path", ",", "dest_path", ",", "AUTH_MODELS", ")", "if", "@module_name", "==", "\"oauth\"", "copy_files", "(", "src_path", ",", "dest_path", ",", "OAUTH_MODELS", ")", "end", "end" ]

[ "=", "begin", "Function", "to", "create", "the", "necessary", "migrations", "and", "models", ".", "=", "end" ]

[ "def", "copy_files", "(", "src", ",", "dest", ",", "module_model", ")", "module_model", ".", "each", "do", "|", "file", "|", "presence", "=", "File", ".", "exists?", "(", "\"#{dest}/#{file}\"", ")", "?", "true", ":", "false", "unless", "presence", "FileUtils", ".", "cp", "(", "\"#{src}/#{file}\"", ",", "dest", ")", "path", "=", "if", "dest", ".", "include?", "\"app\"", "then", "\"app/models\"", "else", "\"db/migrate\"", "end", "$stdout", ".", "puts", "\"\\e[1;32m \\tcreate\\e[0m\\t#{path}/#{file}\"", "end", "end", "end" ]

[ "=", "begin", "Function", "to", "copy", "the", "module", "files", "to", "project", "location", ".", "=", "end" ]

[ "def", "configure_module_files", "source", "=", "\"#{@target_dir}/app/apis/#{@project_name}/modules/#{@module_name}_apis.rb\"", "application_module", "=", "@project_name", ".", "split", "(", "'_'", ")", ".", "map", "(", ":capitalize", ")", "*", "''", "file", "=", "File", ".", "read", "(", "source", ")", "replace", "=", "file", ".", "gsub", "(", "/", "/", ",", "\"module #{application_module}\"", ")", "File", ".", "open", "(", "source", ",", "\"w\"", ")", "{", "|", "f", "|", "f", ".", "puts", "replace", "}", "end" ]

[ "=", "begin", "Function", "to", "configure", "the", "module", "files", ".", "=", "end" ]

[ "def", "add_gems", "file", "=", "File", ".", "open", "(", "\"#{@target_dir}/Gemfile\"", ",", "\"r+\"", ")", "file", ".", "each", "do", "|", "line", "|", "while", "line", "==", "\"gem 'oauth2'\\n\"", "do", "return", "end", "end", "File", ".", "open", "(", "\"#{@target_dir}/Gemfile\"", ",", "\"a+\"", ")", "do", "|", "f", "|", "f", ".", "write", "(", "\"gem 'multi_json'\\ngem 'oauth2'\\ngem 'songkick-oauth2-provider'\\ngem 'ruby_regex'\\ngem 'oauth'\\n\"", ")", "end", "$stdout", ".", "puts", "\"\\e[1;35m \\tGemfile\\e[0m\\tgem 'multi_json'\\n\\t\\tgem 'oauth2'\n\\t\\tgem 'songkick-oauth2-provider'\\n\\t\\tgem 'ruby_regex'\\n\\t\\tgem 'oauth'\\n\"", "$stdout", ".", "puts", "\"\\e[1;32m \\trun\\e[0m\\tbundle install\"", "system", "(", "\"bundle install\"", ")", "end" ]

[ "=", "begin", "Function", "to", "add", "the", "module", "dependency", "gems", "to", "project", "Gemfile", ".", "=", "end" ]

[ "def", "unmount_module", "path", "=", "\"#{@target_dir}/app/apis/#{@project_name}\"", "temp_file", "=", "\"#{path}/tmp.rb\"", "source", "=", "\"#{path}/base.rb\"", "delete_file", "=", "\"#{path}/modules/#{@module_name}_apis.rb\"", "File", ".", "open", "(", "temp_file", ",", "\"w\"", ")", "do", "|", "out_file", "|", "File", ".", "foreach", "(", "source", ")", "do", "|", "line", "|", "unless", "line", "==", "\"require_relative './modules/#{@module_name}_apis'\\n\"", "out_file", ".", "puts", "line", "unless", "line", "==", "\"\\t\\tmount #{@module_class}\\n\"", "end", "end", "FileUtils", ".", "mv", "(", "temp_file", ",", "source", ")", "end", "if", "File", ".", "exists?", "(", "delete_file", ")", "FileUtils", ".", "rm", "(", "delete_file", ")", "$stdout", ".", "puts", "\"\\e[1;35m\\tunmounted\\e[0m\\t#{@module_class}\"", "$stdout", ".", "puts", "\"\\e[1;31m\\tdelete\\e[0m\\t\\tapp/apis/#{@project_name}/modules/#{@module_name}_apis.rb\"", "else", "$stdout", ".", "puts", "\"\\e[33mModule already unmounted.\\e[0m\"", "end", "end" ]

[ "=", "begin", "Unmounts", "the", "modules", "by", "removing", "the", "respective", "module", "files", ".", "=", "end" ]

[ "def", "rule", "(", "field", ",", "definition", ")", "field", "=", "field", ".", "to_sym", "rules", "[", "field", "]", "=", "[", "]", "if", "rules", "[", "field", "]", ".", "nil?", "begin", "if", "definition", ".", "respond_to?", "(", ":each_pair", ")", "add_parameterized_rules", "(", "field", ",", "definition", ")", "elsif", "definition", ".", "respond_to?", "(", ":each", ")", "definition", ".", "each", "do", "|", "item", "|", "if", "item", ".", "respond_to?", "(", ":each_pair", ")", "add_parameterized_rules", "(", "field", ",", "item", ")", "else", "add_single_rule", "(", "field", ",", "item", ")", "end", "end", "else", "add_single_rule", "(", "field", ",", "definition", ")", "end", "rescue", "NameError", "=>", "e", "raise", "InvalidRule", ".", "new", "(", "e", ")", "end", "self", "end" ]

[ "Define", "a", "rule", "for", "this", "object" ]

[ "def", "valid?", "valid", "=", "true", "rules", ".", "each_pair", "do", "|", "field", ",", "rules", "|", "if", "!", "@obj", ".", "respond_to?", "(", "field", ")", "raise", "InvalidKey", ",", "\"cannot validate non-existent field '#{field}'\"", "end", "rules", ".", "each", "do", "|", "r", "|", "if", "!", "r", ".", "valid_value?", "(", "@obj", ".", "send", "(", "field", ")", ")", "valid", "=", "false", "errors", "[", "field", "]", "=", "{", ":rule", "=>", "r", ".", "error_key", ",", ":params", "=>", "r", ".", "params", "}", "break", "end", "end", "end", "@valid", "=", "valid", "end" ]

[ "Determines", "if", "this", "object", "is", "valid", ".", "When", "a", "rule", "fails", "for", "a", "field", "this", "will", "stop", "processing", "further", "rules", ".", "In", "this", "way", "you", "ll", "only", "get", "one", "error", "per", "field" ]

[ "def", "add_single_rule", "(", "field", ",", "key_or_klass", ",", "params", "=", "nil", ")", "klass", "=", "if", "key_or_klass", ".", "respond_to?", "(", ":new", ")", "key_or_klass", "else", "get_rule_class_by_name", "(", "key_or_klass", ")", "end", "args", "=", "[", "params", "]", ".", "compact", "rule", "=", "klass", ".", "new", "(", "args", ")", "rule", ".", "obj", "=", "@obj", "if", "rule", ".", "respond_to?", "(", ":obj=", ")", "rules", "[", "field", "]", "<<", "rule", "end" ]

[ "Adds", "a", "single", "rule", "to", "this", "object" ]

[ "def", "add_parameterized_rules", "(", "field", ",", "rules", ")", "rules", ".", "each_pair", "do", "|", "key", ",", "params", "|", "add_single_rule", "(", "field", ",", "key", ",", "params", ")", "end", "end" ]

[ "Adds", "a", "set", "of", "parameterized", "rules", "to", "this", "object" ]

[ "def", "get_rule_class_by_name", "(", "klass", ")", "klass", "=", "camelize", "(", "klass", ")", "Validation", "::", "Rule", ".", "const_get", "(", "klass", ")", "rescue", "NameError", "=>", "e", "raise", "InvalidRule", ".", "new", "(", "e", ")", "end" ]

[ "Resolves", "the", "specified", "rule", "name", "to", "a", "rule", "class" ]

[ "def", "camelize", "(", "term", ")", "string", "=", "term", ".", "to_s", "string", "=", "string", ".", "sub", "(", "/", "\\d", "/", ")", "{", "$&", ".", "capitalize", "}", "string", ".", "gsub", "(", "/", "\\/", "\\d", "/i", ")", "{", "$2", ".", "capitalize", "}", ".", "gsub", "(", "'/'", ",", "'::'", ")", "end" ]

[ "Converts", "a", "symbol", "to", "a", "class", "name", "taken", "from", "rails" ]

[ "def", "remember_validation_metadata", "(", "validation_type", ",", "*", "attr_names", ")", "configuration", "=", "attr_names", ".", "last", ".", "is_a?", "(", "::", "Hash", ")", "?", "attr_names", ".", "pop", ":", "{", "}", "self", ".", "validations", "||=", "[", "]", "attr_names", ".", "flatten", ".", "each", "do", "|", "attr_name", "|", "self", ".", "validations", "<<", "::", "ActiveRecord", "::", "Reflection", "::", "MacroReflection", ".", "new", "(", "validation_type", ",", "attr_name", ".", "to_sym", ",", "configuration", ",", "self", ")", "end", "end" ]

[ "Store", "validation", "info", "for", "easy", "and", "fast", "access", "." ]

[ "def", "element", "(", "name", ",", "selector", ",", "options", "=", "{", "}", ")", "define_singleton_method", "(", "name", ")", "{", "Element", ".", "new", "(", "selector", ",", "options", ".", "merge", "(", ":base_element", "=>", "self", ")", ")", "}", "end" ]

[ "Creates", "an", "element" ]

[ "def", "create_base_dirs", "BASE_DIR", ".", "each", "do", "|", "dir", "|", "FileUtils", ".", "mkdir", "\"#{@project_name}/#{dir}\"", "$stdout", ".", "puts", "\"\\e[1;32m \\tcreate\\e[0m\\t#{dir}\"", "end", "FileUtils", ".", "mkdir", "\"#{@project_name}/app/apis/#{@project_name}\"", "$stdout", ".", "puts", "\"\\e[1;32m \\tcreate\\e[0m\\tapp/apis/#{@project_name}\"", "end" ]

[ "=", "begin", "Creates", "the", "application", "base", "directories", ".", "=", "end" ]

[ "def", "create_api_module", "File", ".", "open", "(", "\"#{@project_name}/app/apis/#{@project_name}/base.rb\"", ",", "\"w\"", ")", "do", "|", "f", "|", "f", ".", "write", "(", "'module '", ")", "f", ".", "puts", "(", "@module_name", ")", "f", ".", "write", "(", "\"\\tclass Base < Grape::API\\n\\tend\\nend\"", ")", "end", "$stdout", ".", "puts", "\"\\e[1;32m \\tcreate\\e[0m\\tapp/apis/#{@project_name}/base.rb\"", "end" ]

[ "=", "begin", "Function", "to", "create", "the", "API", "modules", ".", "=", "end" ]

[ "def", "config_server", "file", "=", "File", ".", "open", "(", "\"#{@project_name}/server.rb\"", ",", "\"r+\"", ")", "file", ".", "each", "do", "|", "line", "|", "while", "line", "==", "\" def response(env)\\n\"", "do", "pos", "=", "file", ".", "pos", "rest", "=", "file", ".", "read", "file", ".", "seek", "pos", "file", ".", "write", "(", "\"\\t::\"", ")", "file", ".", "write", "(", "@module_name", ")", "file", ".", "write", "(", "\"::Base.call(env)\\n\"", ")", "file", ".", "write", "(", "rest", ")", "$stdout", ".", "puts", "\"\\e[1;35m \\tconfig\\e[0m\\tserver.rb\"", "return", "end", "end", "end" ]

[ "=", "begin", "Function", "to", "configure", "the", "Goliath", "server", ".", "=", "end" ]

[ "def", "copy_files_to_target", "COMMON_RAMMER_FILES", ".", "each", "do", "|", "file", "|", "source", "=", "File", ".", "join", "(", "\"#{@gem_path}/lib/modules/common/\"", ",", "file", ")", "FileUtils", ".", "cp", "(", "source", ",", "\"#{@project_name}\"", ")", "$stdout", ".", "puts", "\"\\e[1;32m \\tcreate\\e[0m\\t#{file}\"", "end", "end" ]

[ "=", "begin", "Function", "to", "copy", "the", "template", "files", "project", "location", ".", "=", "end" ]

[ "def", "create_model_file", "dir", "=", "\"/app/models/#{@scaffold_name}.rb\"", "unless", "File", ".", "exists?", "(", "File", ".", "join", "(", "Dir", ".", "pwd", ",", "dir", ")", ")", "File", ".", "join", "(", "Dir", ".", "pwd", ",", "dir", ")", "source", "=", "\"#{@gem_path}/lib/modules/scaffold/model.rb\"", "FileUtils", ".", "cp", "(", "source", ",", "File", ".", "join", "(", "Dir", ".", "pwd", ",", "dir", ")", ")", "config_model", "@valid", "=", "true", "$stdout", ".", "puts", "\"\\e[1;32m \\tcreate\\e[0m\\t#{dir}\"", "else", "$stdout", ".", "puts", "\"\\e[1;31mError:\\e[0m Model named #{@scaffold_name} already exists, aborting.\"", "end", "end" ]

[ "=", "begin", "Generates", "the", "model", "file", "with", "CRED", "functionality", ".", "=", "end" ]

[ "def", "create_migration", "migration_version", "=", "Time", ".", "now", ".", "to_i", "dir", "=", "\"/db/migrate/#{migration_version}_create_#{@scaffold_name}s.rb\"", "unless", "File", ".", "exists?", "(", "File", ".", "join", "(", "Dir", ".", "pwd", ",", "dir", ")", ")", "source", "=", "\"#{@gem_path}/lib/modules/scaffold/migration.rb\"", "FileUtils", ".", "cp", "(", "source", ",", "File", ".", "join", "(", "Dir", ".", "pwd", ",", "dir", ")", ")", "config_migration", "(", "migration_version", ")", "$stdout", ".", "puts", "\"\\e[1;32m \\tcreate\\e[0m\\t#{dir}\"", "end", "end" ]

[ "=", "begin", "Generates", "migration", "files", "for", "the", "scaffold", ".", "=", "end" ]

[ "def", "config_migration", "(", "migration_version", ")", "source", "=", "\"#{Dir.pwd}/db/migrate/#{migration_version}_create_#{@scaffold_name}s.rb\"", "modify_content", "(", "source", ",", "'CreateMigration'", ",", "\"Create#{@model_class}s\"", ")", "modify_content", "(", "source", ",", "'migration'", ",", "\"#{@scaffold_name}s\"", ")", "@arguments", ".", "each", "do", "|", "value", "|", "@attributes", "<<", "value", ".", "split", "(", "':'", ")", ".", "first", "@data_types", "<<", "value", ".", "split", "(", "':'", ")", ".", "last", "end", "attribute_data_types", "=", "@data_types", ".", "reverse", "@attributes", ".", "reverse", ".", "each_with_index", "do", "|", "value", ",", "index", "|", "add_attributes", "(", "source", ",", "value", ",", "attribute_data_types", "[", "index", "]", ")", "end", "end" ]

[ "=", "begin", "Configures", "the", "migration", "file", "with", "the", "required", "user", "input", ".", "=", "end" ]

[ "def", "add_attributes", "(", "source", ",", "attribute", ",", "data_type", ")", "file", "=", "File", ".", "open", "(", "source", ",", "\"r+\"", ")", "file", ".", "each", "do", "|", "line", "|", "while", "line", "==", "\" create_table :#{@scaffold_name}s do |t|\\n\"", "do", "pos", "=", "file", ".", "pos", "rest", "=", "file", ".", "read", "file", ".", "seek", "pos", "file", ".", "write", "(", "\" t.#{data_type} :#{attribute}\\n\"", ")", "file", ".", "write", "(", "rest", ")", "break", "end", "end", "end" ]

[ "=", "begin", "Edits", "the", "migration", "file", "with", "the", "user", "specified", "model", "attributes", ".", "=", "end" ]

[ "def", "enable_apis", "dir", "=", "\"/app/apis/#{@project_name}/#{@scaffold_name}s/base_apis.rb\"", "base_dir", "=", "\"#{Dir.pwd}/app/apis/#{@project_name}/#{@scaffold_name}s\"", "unless", "File", ".", "exists?", "(", "File", ".", "join", "(", "Dir", ".", "pwd", ",", "dir", ")", ")", "FileUtils", ".", "mkdir", "base_dir", "unless", "File", ".", "exists?", "(", "base_dir", ")", "source", "=", "\"#{@gem_path}/lib/modules/scaffold/base_apis.rb\"", "FileUtils", ".", "cp", "(", "source", ",", "File", ".", "join", "(", "Dir", ".", "pwd", ",", "dir", ")", ")", "config_apis", "$stdout", ".", "puts", "\"\\e[1;32m \\tcreate\\e[0m\\t#{dir}\"", "mount_apis", "end", "end" ]

[ "=", "begin", "Generates", "the", "api", "file", "with", "CRED", "functionality", "apis", "enabled", ".", "=", "end" ]

[ "def", "config_apis", "source", "=", "\"#{Dir.pwd}/app/apis/#{@project_name}/#{@scaffold_name}s/base_apis.rb\"", "content", "=", "[", "'AppName'", ",", "'ScaffoldName'", ",", "'Model'", ",", "'model'", "]", "replacement", "=", "[", "\"#{@project_class}\"", ",", "\"#{model_class}s\"", ",", "\"#{model_class}\"", ",", "\"#{@scaffold_name}\"", "]", "for", "i", "in", "0", "..", "3", "do", "modify_content", "(", "source", ",", "content", "[", "i", "]", ",", "replacement", "[", "i", "]", ")", "end", "end" ]

[ "=", "begin", "Configures", "the", "api", "file", "with", "respect", "to", "the", "user", "input", ".", "=", "end" ]

[ "def", "mount_apis", "require_apis_to_base", "mount_class", "=", "\"::#{@project_class}::#{@model_class}s::BaseApis\"", "file", "=", "File", ".", "open", "(", "\"#{Dir.pwd}/app/apis/#{@project_name}/base.rb\"", ",", "\"r+\"", ")", "file", ".", "each", "do", "|", "line", "|", "while", "line", "==", "\"\\tclass Base < Grape::API\\n\"", "do", "pos", "=", "file", ".", "pos", "rest", "=", "file", ".", "read", "file", ".", "seek", "pos", "file", ".", "write", "(", "\"\\t\\tmount \"", ")", "file", ".", "puts", "(", "mount_class", ")", "file", ".", "write", "(", "rest", ")", "break", "end", "end", "$stdout", ".", "puts", "\"\\e[1;35m\\tmounted\\e[0m\\t#{mount_class}\"", "end" ]

[ "=", "begin", "Mounts", "the", "scaffold", "apis", "onto", "the", "application", ".", "=", "end" ]

[ "def", "require_apis_to_base", "File", ".", "open", "(", "\"#{Dir.pwd}/app/apis/#{@project_name}/base.rb\"", ",", "\"r+\"", ")", "do", "|", "f", "|", "pos", "=", "f", ".", "pos", "rest", "=", "f", ".", "read", "f", ".", "seek", "pos", "f", ".", "write", "(", "\"require_relative '#{@scaffold_name}s/base_apis'\\n\"", ")", "f", ".", "write", "(", "rest", ")", "end", "end" ]

[ "=", "begin", "Configures", "for", "mounting", "the", "scaffold", "apis", ".", "=", "end" ]

[ "def", "to_underscore", "(", "value", ")", "underscore_value", "=", "value", ".", "gsub", "(", "/", "/", ",", "'/'", ")", ".", "gsub", "(", "/", "/", ",", "'\\1_\\2'", ")", ".", "gsub", "(", "/", "\\d", "/", ",", "'\\1_\\2'", ")", ".", "tr", "(", "\"-\"", ",", "\"_\"", ")", ".", "downcase", "return", "underscore_value", "end" ]

[ "=", "begin", "Converts", "the", "string", "into", "snake", "case", "format", ".", "=", "end" ]

[ "def", "knows_block", "(", "blockhash", ")", "return", "true", "if", "@chain", ".", "include?", "(", "blockhash", ")", "@block_queue", ".", "queue", ".", "any?", "{", "|", "(", "block", ",", "proto", ")", "|", "block", ".", "header", ".", "full_hash", "==", "blockhash", "}", "end" ]

[ "if", "block", "is", "in", "chain", "or", "in", "queue" ]

[ "def", "load!", "(", "path", ",", "environment", "=", "nil", ")", "require", "'yaml'", "environment", "||=", "Rails", ".", "env", "conf", "=", "YAML", ".", "load", "(", "File", ".", "new", "(", "path", ")", ".", "read", ")", ".", "with_indifferent_access", "[", "environment", "]", "load_configuration", "(", "conf", ")", "end" ]

[ "called", "in", "railtie" ]

[ "def", "chunk", "(", "str", ")", "raise", "ArgumentError", ",", "'str must be a String'", "unless", "str", ".", "is_a?", "(", "String", ")", "tokens", "=", "tokenizer", ".", "tokenize", "(", "str", ")", "pos_tags", "=", "pos_tagger", ".", "tag", "(", "tokens", ")", ".", "to_ary", "chunks", "=", "j_instance", ".", "chunk", "(", "tokens", ".", "to_java", "(", ":String", ")", ",", "pos_tags", ".", "to_java", "(", ":String", ")", ")", ".", "to_ary", "build_chunks", "(", "chunks", ",", "tokens", ",", "pos_tags", ")", "end" ]

[ "Initializes", "new", "instance", "of", "Chunker" ]

[ "def", "generate_greeklish_words", "(", "greek_words", ")", "@greeklish_list", ".", "clear", "greek_words", ".", "each", "do", "|", "greek_word", "|", "@per_word_greeklish", ".", "clear", "initial_token", "=", "greek_word", "digraphs", ".", "each_key", "do", "|", "key", "|", "greek_word", "=", "greek_word", ".", "gsub", "(", "key", ",", "digraphs", "[", "key", "]", ")", "end", "# Convert it back to array of characters. The iterations of each", "# character will take place through this array.", "input_token", "=", "greek_word", ".", "split", "(", "/", "/", ")", "# Iterate through the characters of the token and generate", "# greeklish words.", "input_token", ".", "each", "do", "|", "greek_char", "|", "add_character", "(", "conversions", "[", "greek_char", "]", ")", "end", "@greeklish_list", "<<", "per_word_greeklish", ".", "flatten", "end", "@greeklish_list", ".", "flatten", "end" ]

[ "Gets", "a", "list", "of", "greek", "words", "and", "generates", "the", "greeklish", "version", "of", "each", "word", "." ]

[ "def", "detect", "(", "str", ")", "raise", "ArgumentError", ",", "'str must be a String'", "unless", "str", ".", "is_a?", "(", "String", ")", "j_instance", ".", "sentDetect", "(", "str", ")", ".", "to_ary", "end" ]

[ "Detects", "sentences", "in", "a", "string" ]

[ "def", "pos_detect", "(", "str", ")", "raise", "ArgumentError", ",", "'str must be a String'", "unless", "str", ".", "is_a?", "(", "String", ")", "j_instance", ".", "sentPosDetect", "(", "str", ")", ".", "map", "do", "|", "span", "|", "OpenNlp", "::", "Util", "::", "Span", ".", "new", "(", "span", ".", "getStart", ",", "span", ".", "getEnd", ")", "end", "end" ]

[ "Detects", "sentences", "in", "a", "string", "and", "returns", "array", "of", "spans" ]

[ "def", "generate_greek_variants", "(", "token_string", ")", "# clear the list from variations of the previous greek token", "@greek_words", ".", "clear", "# add the initial greek token in the greek words", "@greek_words", "<<", "token_string", "# Find the first matching suffix and generate the variants", "# of this word.", "SUFFIX_STRINGS", ".", "each", "do", "|", "suffix", "|", "if", "(", "token_string", ".", "end_with?", "(", "suffix", "[", "0", "]", ")", ")", "# Add to greek_words the tokens with the desired suffixes", "generate_more_greek_words", "(", "token_string", ",", "suffix", "[", "0", "]", ")", "break", "end", "end", "greek_words", "end" ]

[ "This", "method", "generates", "the", "greek", "variants", "of", "the", "greek", "token", "that", "receives", "." ]

[ "def", "detect", "(", "tokens", ")", "raise", "ArgumentError", ",", "'tokens must be an instance of Array'", "unless", "tokens", ".", "is_a?", "(", "Array", ")", "j_instance", ".", "find", "(", "tokens", ".", "to_java", "(", ":String", ")", ")", ".", "to_ary", "end" ]

[ "Detects", "names", "for", "provided", "array", "of", "tokens" ]

[ "def", "receive_newblock", "(", "proto", ",", "t_block", ",", "chain_difficulty", ")", "logger", ".", "debug", "'newblock'", ",", "proto", ":", "proto", ",", "block", ":", "t_block", ",", "chain_difficulty", ":", "chain_difficulty", ",", "client", ":", "proto", ".", "peer", ".", "remote_client_version", "if", "@chain", ".", "include?", "(", "t_block", ".", "header", ".", "full_hash", ")", "raise", "AssertError", ",", "'chain difficulty mismatch'", "unless", "chain_difficulty", "==", "@chain", ".", "get", "(", "t_block", ".", "header", ".", "full_hash", ")", ".", "chain_difficulty", "end", "@protocols", "[", "proto", "]", "=", "chain_difficulty", "if", "@chainservice", ".", "knows_block", "(", "t_block", ".", "header", ".", "full_hash", ")", "logger", ".", "debug", "'known block'", "return", "end", "expected_difficulty", "=", "@chain", ".", "head", ".", "chain_difficulty", "+", "t_block", ".", "header", ".", "difficulty", "if", "chain_difficulty", ">=", "@chain", ".", "head", ".", "chain_difficulty", "# broadcast duplicates filtering is done in chainservice", "logger", ".", "debug", "'sufficient difficulty, broadcasting'", ",", "client", ":", "proto", ".", "peer", ".", "remote_client_version", "@chainservice", ".", "broadcast_newblock", "t_block", ",", "chain_difficulty", ",", "proto", "else", "age", "=", "@chain", ".", "head", ".", "number", "-", "t_block", ".", "header", ".", "number", "logger", ".", "debug", "\"low difficulty\"", ",", "client", ":", "proto", ".", "peer", ".", "remote_client_version", ",", "chain_difficulty", ":", "chain_difficulty", ",", "expected_difficulty", ":", "expected_difficulty", ",", "block_age", ":", "age", "if", "age", ">", "MAX_NEWBLOCK_AGE", "logger", ".", "debug", "'newblock is too old, not adding'", ",", "block_age", ":", "age", ",", "max_age", ":", "MAX_NEWBLOCK_AGE", "return", "end", "end", "if", "@chainservice", ".", "knows_block", "(", "t_block", ".", "header", ".", "prevhash", ")", "logger", ".", "debug", "'adding block'", "@chainservice", ".", "add_block", "t_block", ",", "proto", "else", "logger", ".", "debug", "'missing parent'", "if", "@synctask", "logger", ".", "debug", "'existing task, discarding'", "else", "@synctask", "=", "SyncTask", ".", "new", "self", ",", "proto", ",", "t_block", ".", "header", ".", "full_hash", ",", "chain_difficulty", "end", "end", "end" ]

[ "Called", "if", "there", "s", "a", "newblock", "announced", "on", "the", "network", "." ]

[ "def", "receive_status", "(", "proto", ",", "blockhash", ",", "chain_difficulty", ")", "logger", ".", "debug", "'status received'", ",", "proto", ":", "proto", ",", "chain_difficulty", ":", "chain_difficulty", "@protocols", "[", "proto", "]", "=", "chain_difficulty", "if", "@chainservice", ".", "knows_block", "(", "blockhash", ")", "||", "@synctask", "logger", ".", "debug", "'existing task or known hash, discarding'", "return", "end", "if", "@force_sync", "blockhash", ",", "difficulty", "=", "force_sync", "logger", ".", "debug", "'starting forced synctask'", ",", "blockhash", ":", "Utils", ".", "encode_hex", "(", "blockhash", ")", "@synctask", "=", "SyncTask", ".", "new", "self", ",", "proto", ",", "blockhash", ",", "difficulty", "elsif", "chain_difficulty", ">", "@chain", ".", "head", ".", "chain_difficulty", "logger", ".", "debug", "'sufficient difficulty'", "@synctask", "=", "SyncTask", ".", "new", "self", ",", "proto", ",", "blockhash", ",", "chain_difficulty", "end", "rescue", "logger", ".", "debug", "$!", "logger", ".", "debug", "$!", ".", "backtrace", "[", "0", ",", "10", "]", ".", "join", "(", "\"\\n\"", ")", "end" ]

[ "Called", "if", "a", "new", "peer", "is", "connected", "." ]

[ "def", "receive_newblockhashes", "(", "proto", ",", "newblockhashes", ")", "logger", ".", "debug", "'received newblockhashes'", ",", "num", ":", "newblockhashes", ".", "size", ",", "proto", ":", "proto", "newblockhashes", "=", "newblockhashes", ".", "select", "{", "|", "h", "|", "!", "@chainservice", ".", "knows_block", "(", "h", ")", "}", "known", "=", "@protocols", ".", "include?", "(", "proto", ")", "if", "!", "known", "||", "newblockhashes", ".", "empty?", "||", "@synctask", "logger", ".", "debug", "'discarding'", ",", "known", ":", "known", ",", "synctask", ":", "syncing?", ",", "num", ":", "newblockhashes", ".", "size", "return", "end", "if", "newblockhashes", ".", "size", "!=", "1", "logger", ".", "warn", "'supporting only one newblockhash'", ",", "num", ":", "newblockhashes", ".", "size", "end", "blockhash", "=", "newblockhashes", "[", "0", "]", "logger", ".", "debug", "'starting synctask for newblockhashes'", ",", "blockhash", ":", "Utils", ".", "encode_hex", "(", "blockhash", ")", "@synctask", "=", "SyncTask", ".", "new", "self", ",", "proto", ",", "blockhash", ",", "0", ",", "true", "end" ]

[ "No", "way", "to", "check", "if", "this", "really", "an", "interesting", "block", "at", "this", "point", ".", "Might", "lead", "to", "an", "amplification", "attack", "need", "to", "track", "this", "proto", "and", "judge", "usefulness", "." ]

[ "def", "api_eval", "(", "expr_str", ")", "body", "=", "[", "\"ver:\\\"#{@haystack_version}\\\"\"", "]", "body", "<<", "\"expr\"", "body", "<<", "'\"'", "+", "expr_str", "+", "'\"'", "res", "=", "self", ".", "connection", ".", "post", "(", "'eval'", ")", "do", "|", "req", "|", "req", ".", "headers", "[", "'Content-Type'", "]", "=", "'text/plain'", "req", ".", "body", "=", "body", ".", "join", "(", "\"\\n\"", ")", "end", "JSON", ".", "parse!", "res", ".", "body", "end" ]

[ "this", "function", "will", "post", "expr_str", "exactly", "as", "encoded" ]

[ "def", "equip_point_meta", "begin", "equips", "=", "read", "(", "{", "filter", ":", "'\"equip\"'", "}", ")", "[", "'rows'", "]", "puts", "equips", "equips", ".", "map!", "do", "|", "eq", "|", "eq", ".", "delete", "(", "'disMacro'", ")", "eq", "[", "'description'", "]", "=", "eq", "[", "'id'", "]", ".", "match", "(", "/", "\\$", "/", ")", "[", "1", "]", "eq", "[", "'id'", "]", "=", "eq", "[", "'id'", "]", ".", "match", "(", "/", "\\-", "/", ")", "[", "1", "]", "eq", "[", "'points'", "]", "=", "[", "]", "read", "(", "{", "filter", ":", "\"\\\"point and equipRef==#{eq['id']}\\\"\"", "}", ")", "[", "'rows'", "]", ".", "each", "do", "|", "p", "|", "p", ".", "delete", "(", "'analytics'", ")", "p", ".", "delete", "(", "'disMacro'", ")", "p", ".", "delete", "(", "'csvUnit'", ")", "p", ".", "delete", "(", "'csvColumn'", ")", "p", ".", "delete", "(", "'equipRef'", ")", "p", ".", "delete", "(", "'point'", ")", "p", ".", "delete", "(", "'siteRef'", ")", "p", "[", "'id'", "]", "=", "p", "[", "'id'", "]", ".", "match", "(", "/", "\\-", "/", ")", "[", "1", "]", "p", "[", "'name'", "]", "=", "p", "[", "'navName'", "]", "p", ".", "delete", "(", "'navName'", ")", "eq", "[", "'points'", "]", "<<", "p", "end", "eq", "end", "rescue", "Exception", "=>", "e", "puts", "\"error: #{e}\"", "nil", "end", "end" ]

[ "return", "meta", "data", "for", "all", "equip", "with", "related", "points" ]

[ "def", "parse", "(", "text", ")", "raise", "ArgumentError", ",", "'passed text must be a String'", "unless", "text", ".", "is_a?", "(", "String", ")", "text", ".", "empty?", "?", "{", "}", ":", "parse_tokens", "(", "tokenizer", ".", "tokenize", "(", "text", ")", ",", "text", ")", "end" ]

[ "Initializes", "new", "instance", "of", "Parser" ]

[ "def", "parse", "(", "response", ")", "if", "response", ".", "is_a?", "Hash", "response", ".", "each_with_object", "(", "{", "}", ")", "do", "|", "(", "key", ",", "value", ")", ",", "new_hash", "|", "new_hash", "[", "camel_case_to_snake_case", "(", "key", ")", ".", "to_sym", "]", "=", "parse", "(", "value", ")", "end", "elsif", "response", ".", "is_a?", "Array", "response", ".", "map", "{", "|", "item", "|", "parse", "item", "}", "else", "response", "end", "end" ]

[ "Parses", "the", "specified", "value", "that", "was", "returned", "from", "a", "call", "to", "the", "IG", "Markets", "API", "." ]

[ "def", "categorize", "(", "str", ")", "raise", "ArgumentError", ",", "'str param must be a String'", "unless", "str", ".", "is_a?", "(", "String", ")", "outcomes", "=", "j_instance", ".", "categorize", "(", "str", ")", "j_instance", ".", "getBestCategory", "(", "outcomes", ")", "end" ]

[ "Categorizes", "a", "string", "passed", "as", "parameter", "to", "one", "of", "the", "categories" ]

[ "def", "data", "{", "text", ":", "@page", ".", "description", ",", "type", ":", ":file", ",", "li_attr", ":", "list_attributes", ",", "data", ":", "{", "id", ":", "@page", ".", "id", ",", "url", ":", "@context", ".", "edit_translation_backend_page_path", "(", "@page", ",", "Udongo", ".", "config", ".", "i18n", ".", "app", ".", "default_locale", ")", ",", "delete_url", ":", "@context", ".", "backend_page_path", "(", "@page", ",", "format", ":", ":json", ")", ",", "deletable", ":", "@page", ".", "deletable?", ",", "draggable", ":", "@page", ".", "draggable?", ",", "update_position_url", ":", "@context", ".", "tree_drag_and_drop_backend_page_path", "(", "@page", ")", ",", "visible", ":", "@page", ".", "visible?", ",", "toggle_visibility_url", ":", "@context", ".", "toggle_visibility_backend_page_path", "(", "@page", ",", "format", ":", ":json", ")", "}", ",", "children", ":", "[", "]", "# This gets filled through Udongo::Pages::Tree", "}", "end" ]

[ "Context", "should", "contain", "accessible", "routes", "." ]

[ "def", "identify_greek_word", "(", "input", ")", "input", ".", "each_char", "do", "|", "char", "|", "if", "(", "!", "GREEK_CHARACTERS", ".", "include?", "(", "char", ")", ")", "return", "false", "end", "end", "true", "end" ]

[ "Identifies", "words", "with", "only", "Greek", "lowercase", "characters", "." ]

[ "def", "close", "(", "options", "=", "{", "}", ")", "options", "[", ":deal_id", "]", "=", "deal_id", "options", "[", ":direction", "]", "=", "{", "buy", ":", ":sell", ",", "sell", ":", ":buy", "}", ".", "fetch", "(", "direction", ")", "options", "[", ":size", "]", "||=", "size", "model", "=", "PositionCloseAttributes", ".", "build", "options", "model", ".", "validate", "body", "=", "RequestBodyFormatter", ".", "format", "model", "@dealing_platform", ".", "session", ".", "delete", "(", "'positions/otc'", ",", "body", ")", ".", "fetch", ":deal_reference", "end" ]

[ "Closes", "this", "position", ".", "If", "called", "with", "no", "options", "then", "this", "position", "will", "be", "fully", "closed", "at", "current", "market", "prices", "partial", "closes", "and", "greater", "control", "over", "the", "close", "conditions", "can", "be", "achieved", "by", "using", "the", "relevant", "options", "." ]

[ "def", "update", "(", "new_attributes", ")", "new_attributes", "=", "{", "limit_level", ":", "limit_level", ",", "stop_level", ":", "stop_level", ",", "trailing_stop", ":", "trailing_stop?", ",", "trailing_stop_distance", ":", "trailing_stop_distance", ",", "trailing_stop_increment", ":", "trailing_step", "}", ".", "merge", "new_attributes", "unless", "new_attributes", "[", ":trailing_stop", "]", "new_attributes", "[", ":trailing_stop_distance", "]", "=", "new_attributes", "[", ":trailing_stop_increment", "]", "=", "nil", "end", "body", "=", "RequestBodyFormatter", ".", "format", "PositionUpdateAttributes", ".", "new", "(", "new_attributes", ")", "@dealing_platform", ".", "session", ".", "put", "(", "\"positions/otc/#{deal_id}\"", ",", "body", ",", "API_V2", ")", ".", "fetch", "(", ":deal_reference", ")", "end" ]

[ "Updates", "this", "position", ".", "No", "attributes", "are", "mandatory", "and", "any", "attributes", "not", "specified", "will", "be", "kept", "at", "their", "current", "value", "." ]

[ "def", "encoded_public_key", "=", "(", "encoded_public_key", ")", "self", ".", "public_key", "=", "OpenSSL", "::", "PKey", "::", "RSA", ".", "new", "Base64", ".", "strict_decode64", "encoded_public_key", "end" ]

[ "Initializes", "this", "password", "encryptor", "with", "the", "specified", "encoded", "public", "key", "and", "timestamp", "." ]

[ "def", "encrypt", "(", "password", ")", "encoded_password", "=", "Base64", ".", "strict_encode64", "\"#{password}|#{time_stamp}\"", "encrypted_password", "=", "public_key", ".", "public_encrypt", "encoded_password", "Base64", ".", "strict_encode64", "encrypted_password", "end" ]

[ "Encrypts", "a", "password", "using", "this", "encryptor", "s", "public", "key", "and", "time", "stamp", "which", "must", "have", "been", "set", "prior", "to", "calling", "this", "method", "." ]

[ "def", "is_typography_selector?", "(", "node", ")", "node", ".", "is_a?", "(", "Sass", "::", "Tree", "::", "RuleNode", ")", "&&", "node", ".", "rule", "[", "0", "]", ".", "start_with?", "(", "\"%f-\"", ")", "rescue", "false", "end" ]

[ "determines", "if", "node", "is", "a", "placeholder", "selector", "starting", "widht", "the", "%f", "-", "convention", "for", "typography", "rulesets" ]

[ "def", "coinbase", "cb_hex", "=", "(", "app", ".", "config", "[", ":pow", "]", "||", "{", "}", ")", "[", ":coinbase_hex", "]", "if", "cb_hex", "raise", "ValueError", ",", "'coinbase must be String'", "unless", "cb_hex", ".", "is_a?", "(", "String", ")", "begin", "cb", "=", "Utils", ".", "decode_hex", "Utils", ".", "remove_0x_head", "(", "cb_hex", ")", "rescue", "TypeError", "raise", "ValueError", ",", "'invalid coinbase'", "end", "else", "accts", "=", "accounts_with_address", "return", "DEFAULT_COINBASE", "if", "accts", ".", "empty?", "cb", "=", "accts", "[", "0", "]", ".", "address", "end", "raise", "ValueError", ",", "'wrong coinbase length'", "if", "cb", ".", "size", "!=", "20", "if", "config", "[", ":accounts", "]", "[", ":must_include_coinbase", "]", "raise", "ValueError", ",", "'no account for coinbase'", "if", "!", "@accounts", ".", "map", "(", ":address", ")", ".", "include?", "(", "cb", ")", "end", "cb", "end" ]

[ "Return", "the", "address", "that", "should", "be", "used", "as", "coinbase", "for", "new", "blocks", "." ]

[ "def", "add_account", "(", "account", ",", "store", "=", "true", ",", "include_address", "=", "true", ",", "include_id", "=", "true", ")", "logger", ".", "info", "\"adding account\"", ",", "account", ":", "account", "if", "account", ".", "uuid", "&&", "@accounts", ".", "any?", "{", "|", "acct", "|", "acct", ".", "uuid", "==", "account", ".", "uuid", "}", "logger", ".", "error", "'could not add account (UUID collision)'", ",", "uuid", ":", "account", ".", "uuid", "raise", "ValueError", ",", "'Could not add account (UUID collision)'", "end", "if", "store", "raise", "ValueError", ",", "'Cannot store account without path'", "if", "account", ".", "path", ".", "nil?", "if", "File", ".", "exist?", "(", "account", ".", "path", ")", "logger", ".", "error", "'File does already exist'", ",", "path", ":", "account", ".", "path", "raise", "IOError", ",", "'File does already exist'", "end", "raise", "AssertError", "if", "@accounts", ".", "any?", "{", "|", "acct", "|", "acct", ".", "path", "==", "account", ".", "path", "}", "begin", "directory", "=", "File", ".", "dirname", "account", ".", "path", "FileUtils", ".", "mkdir_p", "(", "directory", ")", "unless", "File", ".", "exist?", "(", "directory", ")", "File", ".", "open", "(", "account", ".", "path", ",", "'w'", ")", "do", "|", "f", "|", "f", ".", "write", "account", ".", "dump", "(", "include_address", ",", "include_id", ")", "end", "rescue", "IOError", "=>", "e", "logger", ".", "error", "\"Could not write to file\"", ",", "path", ":", "account", ".", "path", ",", "message", ":", "e", ".", "to_s", "raise", "e", "end", "end", "@accounts", ".", "push", "account", "@accounts", ".", "sort_by!", "{", "|", "acct", "|", "acct", ".", "path", ".", "to_s", "}", "end" ]

[ "Add", "an", "account", "." ]

[ "def", "update_account", "(", "account", ",", "new_password", ",", "include_address", "=", "true", ",", "include_id", "=", "true", ")", "raise", "ValueError", ",", "\"Account not managed by account service\"", "unless", "@accounts", ".", "include?", "(", "account", ")", "raise", "ValueError", ",", "\"Cannot update locked account\"", "if", "account", ".", "locked?", "raise", "ValueError", ",", "'Account not stored on disk'", "unless", "account", ".", "path", "logger", ".", "debug", "\"creating new account\"", "new_account", "=", "Account", ".", "create", "new_password", ",", "account", ".", "privkey", ",", "account", ".", "uuid", ",", "account", ".", "path", "backup_path", "=", "account", ".", "path", "+", "'~'", "i", "=", "1", "while", "File", ".", "exist?", "(", "backup_path", ")", "backup_path", "=", "backup_path", "[", "0", ",", "backup_path", ".", "rindex", "(", "'~'", ")", "+", "1", "]", "+", "i", ".", "to_s", "i", "+=", "1", "end", "raise", "AssertError", "if", "File", ".", "exist?", "(", "backup_path", ")", "logger", ".", "info", "'moving old keystore file to backup location'", ",", "from", ":", "account", ".", "path", ",", "to", ":", "backup_path", "begin", "FileUtils", ".", "mv", "account", ".", "path", ",", "backup_path", "rescue", "logger", ".", "error", "\"could not backup keystore, stopping account update\"", ",", "from", ":", "account", ".", "path", ",", "to", ":", "backup_path", "raise", "$!", "end", "raise", "AssertError", "unless", "File", ".", "exist?", "(", "backup_path", ")", "raise", "AssertError", "if", "File", ".", "exist?", "(", "new_account", ".", "path", ")", "account", ".", "path", "=", "backup_path", "@accounts", ".", "delete", "account", "begin", "add_account", "new_account", ",", "include_address", ",", "include_id", "rescue", "logger", ".", "error", "'adding new account failed, recovering from backup'", "FileUtils", ".", "mv", "backup_path", ",", "new_account", ".", "path", "account", ".", "path", "=", "new_account", ".", "path", "@accounts", ".", "push", "account", "@accounts", ".", "sort_by!", "{", "|", "acct", "|", "acct", ".", "path", ".", "to_s", "}", "raise", "$!", "end", "raise", "AssertError", "unless", "File", ".", "exist?", "(", "new_account", ".", "path", ")", "logger", ".", "info", "\"deleting backup of old keystore\"", ",", "path", ":", "backup_path", "begin", "FileUtils", ".", "rm", "backup_path", "rescue", "logger", ".", "error", "'failed to delete no longer needed backup of old keystore'", ",", "path", ":", "account", ".", "path", "raise", "$!", "end", "account", ".", "keystore", "=", "new_account", ".", "keystore", "account", ".", "path", "=", "new_account", ".", "path", "@accounts", ".", "push", "account", "@accounts", ".", "delete", "new_account", "@accounts", ".", "sort_by!", "{", "|", "acct", "|", "acct", ".", "path", ".", "to_s", "}", "logger", ".", "debug", "\"account update successful\"", "end" ]

[ "Replace", "the", "password", "of", "an", "account", "." ]

[ "def", "find", "(", "identifier", ")", "identifier", "=", "identifier", ".", "downcase", "if", "identifier", "=~", "/", "\\A", "\\z", "/", "# uuid", "return", "get_by_id", "(", "identifier", ")", "end", "begin", "address", "=", "Address", ".", "new", "(", "identifier", ")", ".", "to_bytes", "raise", "AssertError", "unless", "address", ".", "size", "==", "20", "return", "self", "[", "address", "]", "rescue", "# do nothing", "end", "index", "=", "identifier", ".", "to_i", "raise", "ValueError", ",", "'Index must be 1 or greater'", "if", "index", "<=", "0", "raise", "KeyError", "if", "index", ">", "@accounts", ".", "size", "@accounts", "[", "index", "-", "1", "]", "end" ]

[ "Find", "an", "account", "by", "either", "its", "address", "its", "id", "or", "its", "index", "as", "string", "." ]

[ "def", "get_by_id", "(", "id", ")", "accts", "=", "@accounts", ".", "select", "{", "|", "acct", "|", "acct", ".", "uuid", "==", "id", "}", "if", "accts", ".", "size", "==", "0", "raise", "KeyError", ",", "\"account with id #{id} unknown\"", "elsif", "accts", ".", "size", ">", "1", "logger", ".", "warn", "\"multiple accounts with same UUID found\"", ",", "uuid", ":", "id", "end", "accts", "[", "0", "]", "end" ]

[ "Return", "the", "account", "with", "a", "given", "id", "." ]

[ "def", "get_by_address", "(", "address", ")", "raise", "ArgumentError", ",", "'address must be 20 bytes'", "unless", "address", ".", "size", "==", "20", "accts", "=", "@accounts", ".", "select", "{", "|", "acct", "|", "acct", ".", "address", "==", "address", "}", "if", "accts", ".", "size", "==", "0", "raise", "KeyError", ",", "\"account not found by address #{Utils.encode_hex(address)}\"", "elsif", "accts", ".", "size", ">", "1", "logger", ".", "warn", "\"multiple accounts with same address found\"", ",", "address", ":", "Utils", ".", "encode_hex", "(", "address", ")", "end", "accts", "[", "0", "]", "end" ]

[ "Get", "an", "account", "by", "its", "address", "." ]

[ "def", "to_h", "attributes", ".", "each_with_object", "(", "{", "}", ")", "do", "|", "(", "key", ",", "value", ")", ",", "hash", "|", "hash", "[", "key", "]", "=", "if", "value", ".", "is_a?", "Model", "value", ".", "to_h", "else", "value", "end", "end", "end" ]

[ "Compares", "this", "model", "to", "another", "the", "attributes", "and", "class", "must", "match", "for", "them", "to", "be", "considered", "equal", "." ]

[ "def", "sign_in", "(", "username", ",", "password", ",", "api_key", ",", "platform", ")", "session", ".", "username", "=", "username", "session", ".", "password", "=", "password", "session", ".", "api_key", "=", "api_key", "session", ".", "platform", "=", "platform", "result", "=", "session", ".", "sign_in", "@client_account_summary", "=", "instantiate_models", "ClientAccountSummary", ",", "result", "end" ]

[ "Signs", "in", "to", "the", "IG", "Markets", "Dealing", "Platform", "either", "the", "live", "platform", "or", "the", "demo", "platform", "." ]

[ "def", "colored_currency", "(", "amount", ",", "currency_name", ")", "return", "''", "unless", "amount", "color", "=", "amount", "<", "0", "?", ":red", ":", ":green", "ColorizedString", "[", "currency", "(", "amount", ",", "currency_name", ")", "]", ".", "colorize", "color", "end" ]

[ "Returns", "a", "formatted", "string", "for", "the", "specified", "currency", "amount", "and", "currency", "and", "colors", "it", "red", "for", "negative", "values", "and", "green", "for", "positive", "values", ".", "Two", "decimal", "places", "are", "used", "for", "all", "currencies", "except", "the", "Japanese", "Yen", "." ]

[ "def", "snake_case_to_camel_case", "(", "value", ")", "pieces", "=", "value", ".", "to_s", ".", "split", "'_'", "(", "pieces", ".", "first", "+", "pieces", "[", "1", "..", "-", "1", "]", ".", "map", "(", ":capitalize", ")", ".", "join", ")", ".", "to_sym", "end" ]

[ "Takes", "a", "string", "or", "symbol", "that", "uses", "snake", "case", "and", "converts", "it", "to", "a", "camel", "case", "symbol", "." ]

[ "def", "dump", "(", "include_address", "=", "true", ",", "include_id", "=", "true", ")", "h", "=", "{", "}", "h", "[", ":crypto", "]", "=", "@keystore", "[", ":crypto", "]", "h", "[", ":version", "]", "=", "@keystore", "[", ":version", "]", "h", "[", ":address", "]", "=", "Utils", ".", "encode_hex", "address", "if", "include_address", "&&", "address", "h", "[", ":id", "]", "=", "uuid", "if", "include_id", "&&", "uuid", "JSON", ".", "dump", "(", "h", ")", "end" ]

[ "Dump", "the", "keystore", "for", "later", "disk", "storage", "." ]

[ "def", "sign_tx", "(", "tx", ")", "if", "privkey", "logger", ".", "info", "\"signing tx\"", ",", "tx", ":", "tx", ",", "account", ":", "self", "tx", ".", "sign", "privkey", "else", "raise", "ValueError", ",", "\"Locked account cannot sign tx\"", "end", "end" ]

[ "Sign", "a", "Transaction", "with", "the", "private", "key", "of", "this", "account", "." ]

[ "def", "detect_unstratified", "missing_populations", "=", "[", "]", "# populations are keyed off of values rather than the codes", "existing_populations", "=", "@populations", ".", "map", "{", "|", "p", "|", "p", ".", "values", ".", "join", "(", "'-'", ")", "}", ".", "uniq", "@populations", ".", "each", "do", "|", "population", "|", "keys", "=", "population", ".", "keys", "-", "[", "'STRAT'", ",", "'stratification'", "]", "missing_populations", "|=", "[", "population", ".", "values_at", "(", "keys", ")", ".", "compact", ".", "join", "(", "'-'", ")", "]", "end", "missing_populations", "-=", "existing_populations", "# reverse the order and prepend them to @populations", "missing_populations", ".", "reverse", ".", "each", "do", "|", "population", "|", "p", "=", "{", "}", "population", ".", "split", "(", "'-'", ")", ".", "each", "do", "|", "code", "|", "p", "[", "code", ".", "split", "(", "'_'", ")", ".", "first", "]", "=", "code", "end", "@populations", ".", "unshift", "p", "end", "end" ]

[ "Detects", "missing", "unstratified", "populations", "from", "the", "generated" ]

[ "def", "put", "(", "localpath", ",", "destpath", ")", "create", "(", "destpath", ")", "{", "|", "dest", "|", "Kernel", ".", "open", "(", "localpath", ")", "{", "|", "source", "|", "# read 1 MB at a time", "while", "record", "=", "source", ".", "read", "(", "1048576", ")", "dest", ".", "write", "(", "record", ")", "end", "}", "}", "end" ]

[ "copy", "local", "file", "to", "remote" ]

[ "def", "get", "(", "remotepath", ",", "destpath", ")", "Kernel", ".", "open", "(", "destpath", ",", "'w'", ")", "{", "|", "dest", "|", "readchunks", "(", "remotepath", ")", "{", "|", "chunk", "|", "dest", ".", "write", "chunk", "}", "}", "end" ]

[ "copy", "remote", "file", "to", "local" ]

[ "def", "readchunks", "(", "path", ",", "chunksize", "=", "1048576", ")", "open", "(", "path", ")", "{", "|", "source", "|", "size", "=", "source", ".", "length", "index", "=", "0", "while", "index", "<", "size", "yield", "source", ".", "read", "(", "index", ",", "chunksize", ")", "index", "+=", "chunksize", "end", "}", "end" ]

[ "yeild", "chunksize", "of", "path", "one", "chunk", "at", "a", "time" ]

[ "def", "tokenize", "(", "str", ")", "raise", "ArgumentError", ",", "'str must be a String'", "unless", "str", ".", "is_a?", "(", "String", ")", "j_instance", ".", "tokenize", "(", "str", ")", ".", "to_ary", "end" ]

[ "Tokenizes", "a", "string" ]

[ "def", "tag", "(", "tokens", ")", "!", "tokens", ".", "is_a?", "(", "Array", ")", "&&", "!", "tokens", ".", "is_a?", "(", "String", ")", "&&", "raise", "(", "ArgumentError", ",", "'tokens must be an instance of String or Array'", ")", "j_instance", ".", "tag", "(", "tokens", ".", "to_java", "(", ":String", ")", ")", "end" ]

[ "Adds", "tags", "to", "tokens", "passed", "as", "argument" ]

[ "def", "reload", "self", ".", "attributes", "=", "@dealing_platform", ".", "account", ".", "all", ".", "detect", "{", "|", "a", "|", "a", ".", "account_id", "==", "account_id", "}", ".", "attributes", "end" ]

[ "Reloads", "this", "account", "s", "attributes", "by", "re", "-", "querying", "the", "IG", "Markets", "API", "." ]

[ "def", "only", "(", "fields", ",", "fields_with_base", "=", "nil", ")", "q", "=", "{", "}", "if", "[", "Array", ",", "String", "]", ".", "include?", "(", "fields_with_base", ".", "class", ")", "fields_with_base", "=", "[", "fields_with_base", "]", "if", "fields_with_base", ".", "class", "==", "String", "q", "[", "fields", ".", "to_sym", "]", "=", "fields_with_base", "else", "fields", "=", "[", "fields", "]", "if", "fields", ".", "class", "==", "String", "q", "=", "{", "BASE", ":", "fields", "}", "end", "@query", "[", ":only", "]", "=", "q", "self", "end" ]

[ "Specifies", "an", "array", "of", "only", "keys", "in", "BASE", "object", "that", "would", "be", "included", "in", "the", "response", "." ]

[ "def", "update", "(", "new_attributes", ")", "existing_attributes", "=", "{", "good_till_date", ":", "good_till_date", ",", "level", ":", "order_level", ",", "limit_distance", ":", "limit_distance", ",", "stop_distance", ":", "stop_distance", ",", "time_in_force", ":", "time_in_force", ",", "type", ":", "order_type", "}", "model", "=", "WorkingOrderUpdateAttributes", ".", "new", "existing_attributes", ",", "new_attributes", "model", ".", "validate", "body", "=", "RequestBodyFormatter", ".", "format", "model", "@dealing_platform", ".", "session", ".", "put", "(", "\"workingorders/otc/#{deal_id}\"", ",", "body", ",", "API_V2", ")", ".", "fetch", "(", ":deal_reference", ")", "end" ]

[ "Updates", "this", "working", "order", ".", "No", "attributes", "are", "mandatory", "and", "any", "attributes", "not", "specified", "will", "be", "kept", "at", "their", "current", "values", "." ]

[ "def", "add_color", "(", "node", ",", "key", "=", "nil", ")", "key", "||=", "node", ".", "expr", ".", "to_s", "self", ".", "colors", "[", "key", "]", "||=", "{", ":variables", "=>", "[", "]", ",", ":alternate_values", "=>", "[", "]", "}", "self", ".", "colors", "[", "key", "]", "[", ":variables", "]", "<<", "node", ".", "name", "self", ".", "colors", "[", "key", "]", "[", ":alternate_values", "]", "|=", "(", "[", "node", ".", "expr", ".", "to_sass", ",", "node", ".", "expr", ".", "inspect", "]", "-", "[", "key", "]", ")", "end" ]

[ "add", "found", "color", "to" ]

[ "def", "apply_layout", "(", "env", ",", "content", ",", "opts", ")", "if", "layout", "=", "env", "[", "'layout'", "]", "layout", ".", "format", "=", "opts", "[", ":format", "]", "layout", ".", "content", "=", "content", "layout", ".", "template_name", "=", "opts", "[", ":layout", "]", "if", "layout", ".", "template_name?", "(", "opts", "[", ":layout", "]", ",", "opts", ")", "layout", "else", "content", "end", "end" ]

[ "Apply", "the", "layout", "if", "it", "exists" ]

[ "def", "read", "(", "addr", ",", "num_elements", ",", "**", "options", ")", "mem_io", "(", ":read", ")", "{", "|", "io", "|", "io", ".", "read", "(", "num_elements", ",", "from", ":", "MemoryIO", "::", "Util", ".", "safe_eval", "(", "addr", ",", "bases", ")", ",", "**", "options", ")", "}", "end" ]

[ "Read", "from", "process", "s", "memory", "." ]

[ "def", "write", "(", "addr", ",", "objects", ",", "**", "options", ")", "mem_io", "(", ":write", ")", "{", "|", "io", "|", "io", ".", "write", "(", "objects", ",", "from", ":", "MemoryIO", "::", "Util", ".", "safe_eval", "(", "addr", ",", "bases", ")", ",", "**", "options", ")", "}", "end" ]

[ "Write", "objects", "at", "+", "addr", "+", "." ]

[ "def", "netrc_path", "unencrypted", "=", "Netrc", ".", "default_path", "encrypted", "=", "unencrypted", "+", "'.gpg'", "if", "File", ".", "exists?", "(", "encrypted", ")", "encrypted", "else", "unencrypted", "end", "end" ]

[ "Returns", "the", "path", "to", "the", ".", "netrc", "file", "containing", "the", "Turbot", "host", "s", "entry", "with", "the", "user", "s", "email", "address", "and", "API", "key", "." ]

[ "def", "open_netrc", "begin", "Netrc", ".", "read", "(", "netrc_path", ")", "rescue", "Netrc", "::", "Error", "=>", "e", "error", "e", ".", "message", "end", "end" ]

[ "Reads", "a", ".", "netrc", "file", "." ]

[ "def", "save_netrc_entry", "(", "email_address", ",", "api_key", ")", "netrc", "=", "open_netrc", "netrc", "[", "\"api.#{host}\"", "]", "=", "[", "email_address", ",", "api_key", "]", "netrc", ".", "save", "end" ]

[ "Saves", "the", "user", "s", "email", "address", "and", "AP", "key", "to", "the", "Turbot", "host", "s", "entry", "in", "the", ".", "netrc", "file", "." ]

[ "def", "seed_from_dump", "id", "target_path", "=", "File", ".", "expand_path", "(", "\"../../fixtures/trunk-#{id}.dump\"", ",", "__FILE__", ")", "raise", "\"Dump #{id} could not be found.\"", "unless", "File", ".", "exists?", "target_path", "puts", "\"Restoring #{ENV['RACK_ENV']} database from #{target_path}\"", "# Ensure we're starting from a clean DB.", "system", "\"dropdb trunk_cocoapods_org_test\"", "system", "\"createdb trunk_cocoapods_org_test\"", "# Restore the DB.", "command", "=", "\"pg_restore --no-privileges --clean --no-acl --no-owner -h localhost -d trunk_cocoapods_org_test #{target_path}\"", "puts", "\"Executing:\"", "puts", "command", "puts", "result", "=", "system", "command", "if", "result", "puts", "\"Database #{ENV['RACK_ENV']} restored from #{target_path}\"", "else", "warn", "\"Database #{ENV['RACK_ENV']} restored from #{target_path} with some errors.\"", "# exit 1", "end", "end" ]

[ "Seed", "the", "database", "from", "a", "downloaded", "dump", "." ]

[ "def", "dump_prod", "id", "target_path", "=", "File", ".", "expand_path", "(", "\"../../fixtures/trunk-#{id}.dump\"", ",", "__FILE__", ")", "puts", "\"Dumping production database from Heroku (works only if you have access to the database)\"", "command", "=", "\"curl -o #{target_path} \\`heroku pg:backups public-url #{id} -a cocoapods-trunk-service\\`\"", "puts", "\"Executing command:\"", "puts", "command", "result", "=", "system", "command", "if", "result", "puts", "\"Production database snapshot #{id} dumped into #{target_path}\"", "else", "raise", "\"Could not dump #{id} from production database.\"", "end", "end" ]

[ "Dump", "the", "production", "DB", "." ]

[ "def", "try_function", "(", "name", ",", "params", ",", "returns", ",", "options", "=", "{", "}", ",", "&", "def_block", ")", "begin", "function", "name", ",", "params", ",", "returns", ",", "options", ",", "def_block", "rescue", "Win", "::", "Errors", "::", "NotFoundError", "\"This platform does not support function #{name}\"", "end", "end" ]

[ "Try", "to", "define", "platform", "-", "specific", "function", "rescue", "error", "return", "message" ]

[ "def", "define_api", "(", "name", ",", "camel_name", ",", "effective_names", ",", "params", ",", "returns", ",", "options", ")", "params", ",", "returns", "=", "generate_signature", "(", "params", ".", "dup", ",", "returns", ")", "ffi_lib", "(", "ffi_libraries", ".", "map", "(", ":name", ")", "<<", "options", "[", ":dll", "]", ")", "if", "options", "[", ":dll", "]", "libs", "=", "ffi_libraries", ".", "map", "(", ":name", ")", "alternative", "=", "options", ".", "delete", "(", ":alternative", ")", "# Function may have alternative signature", "effective_name", "=", "if", "alternative", "alt_params", ",", "alt_returns", ",", "condition", "=", "generate_signature", "(", "alternative", ")", "api", "=", "function", "name", ",", "params", ",", "returns", ",", "options", ".", "merge", "(", "camel_only", ":", "true", ",", "camel_name", ":", "\"#{camel_name}Original\"", ")", "alt_api", "=", "function", "name", ",", "alt_params", ",", "alt_returns", ",", "options", ".", "merge", "(", "camel_only", ":", "true", ",", "camel_name", ":", "\"#{camel_name}Alternative\"", ")", "define_method", "camel_name", "do", "|", "*", "args", "|", "(", "condition", "[", "args", "]", "?", "alt_api", ":", "api", ")", ".", "call", "(", "args", ")", "end", "module_function", "camel_name", "public", "camel_name", "api", ".", "effective_name", "else", "effective_names", ".", "inject", "(", "nil", ")", "do", "|", "func", ",", "effective_name", "|", "func", "||", "begin", "# Try to attach basic CamelCase method via FFI", "attach_function", "(", "camel_name", ",", "effective_name", ",", "params", ".", "dup", ",", "returns", ")", "effective_name", "rescue", "FFI", "::", "NotFoundError", "nil", "end", "end", "end", "raise", "Win", "::", "Errors", "::", "NotFoundError", ".", "new", "(", "name", ",", "libs", ")", "unless", "effective_name", "# Create API object that holds information about defined and effective function names, params, etc.", "# This object is further used by enhanced snake_case method to reflect on underlying API and", "# intelligently call it.", "API", ".", "new", "(", "namespace", ",", "camel_name", ",", "effective_name", ",", "params", ",", "returns", ",", "libs", ")", "end" ]

[ "Defines", "CamelCase", "method", "calling", "Win32", "API", "function", "and", "associated", "API", "object" ]

[ "def", "recursively_find_and_replace_command_substitutions", "(", "input", ")", "input", "=", "input", ".", "dup", "Parser", ".", "each_command_substitution_for", "(", "input", ")", "do", "|", "substitution_result", ",", "start_position", ",", "end_position", "|", "debug_log", "\"found command substitution at position=#{(start_position..end_position)} #{substitution_result.inspect}\"", "result", "=", "recursively_find_and_replace_command_substitutions", "(", "substitution_result", ".", "str", ")", "position", "=", "substitution_result", ".", "position", "ast", "=", "Parser", ".", "parse", "(", "result", ")", "with_standard_streams", "do", "|", "stdin", ",", "stdout", ",", "stderr", "|", "r", ",", "w", "=", "IO", ".", "pipe", "@stdout", "=", "w", "ast", ".", "accept", "(", "self", ")", "output", "=", "r", ".", "read", ".", "chomp", "# Treat consecutive newlines in output as a single space", "output", "=", "output", ".", "gsub", "(", "/", "\\n", "/", ",", "' '", ")", "# Double quote the output and escape any double quotes already", "# existing", "output", "=", "%|\"#{output.gsub(/\"/, '\\\\\"')}\"|", "# Put thd output back into the original input", "debug_log", "\"replacing command substitution at position=#{(position.min...position.max)} with #{output.inspect}\"", "input", "[", "position", ".", "min", "...", "position", ".", "max", "]", "=", "output", "end", "end", "input", "end" ]

[ "+", "recursively_find_and_replace_command_substitutions", "+", "is", "responsible", "for", "recursively", "finding", "and", "expanding", "command", "substitutions", "in", "a", "depth", "first", "manner", "." ]

[ "def", "visit_CommandNode", "(", "node", ")", "debug_visit", "(", "node", ")", "@aliases_expanded", "||=", "[", "]", "@command_node_args_stack", "||=", "[", "]", "with_standard_streams", "do", "|", "stdin", ",", "stdout", ",", "stderr", "|", "args", "=", "process_ArgumentNodes", "(", "node", ".", "args", ")", "if", "!", "node", ".", "literal?", "&&", "!", "@aliases_expanded", ".", "include?", "(", "node", ".", "command", ")", "&&", "Aliases", ".", "instance", ".", "has_key?", "(", "node", ".", "command", ")", "_alias", "=", "Aliases", ".", "instance", ".", "fetch_alias", "(", "node", ".", "command", ")", "@suppress_events", "=", "true", "@command_node_args_stack", "<<", "args", "ast", "=", "Parser", ".", "parse", "(", "_alias", ")", "@aliases_expanded", ".", "push", "(", "node", ".", "command", ")", "ast", ".", "accept", "(", "self", ")", "@aliases_expanded", ".", "pop", "@suppress_events", "=", "false", "else", "cmd2execute", "=", "variable_expand", "(", "node", ".", "command", ")", "final_args", "=", "(", "args", "+", "@command_node_args_stack", ")", ".", "flatten", ".", "map", "(", ":shellescape", ")", "expanded_args", "=", "final_args", "command", "=", "CommandFactory", ".", "build_command_for", "(", "world", ":", "world", ",", "command", ":", "cmd2execute", ",", "args", ":", "expanded_args", ",", "heredoc", ":", "(", "node", ".", "heredoc", "&&", "node", ".", "heredoc", ".", "value", ")", ",", "internally_evaluate", ":", "node", ".", "internally_evaluate?", ",", "line", ":", "@input", ")", "@stdin", ",", "@stdout", ",", "@stderr", "=", "stream_redirections_for", "(", "node", ")", "set_last_result", "@blk", ".", "call", "command", ",", "@stdin", ",", "@stdout", ",", "@stderr", ",", "pipeline_stack", ".", "empty?", "@command_node_args_stack", ".", "clear", "end", "end", "end" ]

[ "VISITOR", "METHODS", "FOR", "AST", "TREE", "WALKING" ]

[ "def", "undocumented", "(", "scope", "=", ":modified", ")", "return", "[", "]", "unless", "scope", "!=", ":ignore", "&&", "File", ".", "exist?", "(", "undocumented_path", ")", "@undocumented", "=", "{", "modified", ":", "[", "]", ",", "all", ":", "[", "]", "}", "if", "@undocumented", ".", "nil?", "load_undocumented", "(", "scope", ")", "if", "@undocumented", "[", "scope", "]", ".", "empty?", "@undocumented", "[", "scope", "]", "end" ]

[ "Returns", "a", "list", "of", "undocumented", "symbols", "in", "the", "current", "diff", "." ]

[ "def", "update", "@payment_method", "=", "PaymentMethod", ".", "find", "params", "[", ":payment_method_id", "]", "data", "=", "JSON", ".", "parse", "Base64", ".", "strict_decode64", "params", "[", ":data", "]", "render", "text", ":", "\"Bad signature\\n\"", ",", "status", ":", "401", "and", "return", "unless", "@payment_method", ".", "check_signature", "params", "[", ":data", "]", ",", "params", "[", ":signature", "]", "@order", "=", "Order", ".", "find", "data", "[", "'order_id'", "]", "raise", "ArgumentError", "unless", "@order", ".", "payments", ".", "completed", ".", "empty?", "&&", "data", "[", "'currency'", "]", "==", "@order", ".", "currency", "&&", "BigDecimal", "(", "data", "[", "'amount'", "]", ")", "==", "@order", ".", "total", "&&", "data", "[", "'type'", "]", "==", "'buy'", "&&", "(", "data", "[", "'status'", "]", "==", "'success'", "||", "(", "@payment_method", ".", "preferred_test_mode", "&&", "data", "[", "'status'", "]", "==", "'sandbox'", ")", ")", "payment", "=", "@order", ".", "payments", ".", "create", "amount", ":", "@order", ".", "total", ",", "payment_method", ":", "@payment_method", "payment", ".", "complete!", "render", "text", ":", "\"Thank you.\\n\"", "end" ]

[ "callbacks", "from", "Liqpay", "server" ]

[ "def", "brokers", "@brokers_mutex", ".", "synchronize", "do", "@brokers", "||=", "begin", "brokers", "=", "zk", ".", "get_children", "(", "path", ":", "\"/brokers/ids\"", ")", "if", "brokers", ".", "fetch", "(", ":rc", ")", "!=", "Zookeeper", "::", "Constants", "::", "ZOK", "raise", "NoClusterRegistered", ",", "\"No Kafka cluster registered on this Zookeeper location.\"", "end", "result", ",", "mutex", "=", "{", "}", ",", "Mutex", ".", "new", "threads", "=", "brokers", ".", "fetch", "(", ":children", ")", ".", "map", "do", "|", "id", "|", "Thread", ".", "new", "do", "Thread", ".", "abort_on_exception", "=", "true", "broker_info", "=", "zk", ".", "get", "(", "path", ":", "\"/brokers/ids/#{id}\"", ")", "raise", "Kazoo", "::", "Error", ",", "\"Failed to retrieve broker info. Error code: #{broker_info.fetch(:rc)}\"", "unless", "broker_info", ".", "fetch", "(", ":rc", ")", "==", "Zookeeper", "::", "Constants", "::", "ZOK", "broker", "=", "Kazoo", "::", "Broker", ".", "from_json", "(", "self", ",", "id", ",", "JSON", ".", "parse", "(", "broker_info", ".", "fetch", "(", ":data", ")", ")", ")", "mutex", ".", "synchronize", "{", "result", "[", "id", ".", "to_i", "]", "=", "broker", "}", "end", "end", "threads", ".", "each", "(", ":join", ")", "result", "end", "end", "end" ]

[ "Returns", "a", "hash", "of", "all", "the", "brokers", "in", "the" ]

[ "def", "consumergroups", "@consumergroups", "||=", "begin", "consumers", "=", "zk", ".", "get_children", "(", "path", ":", "\"/consumers\"", ")", "consumers", ".", "fetch", "(", ":children", ")", ".", "map", "{", "|", "name", "|", "Kazoo", "::", "Consumergroup", ".", "new", "(", "self", ",", "name", ")", "}", "end", "end" ]

[ "Returns", "a", "list", "of", "consumer", "groups", "that", "are", "registered", "against", "the", "Kafka", "cluster", "." ]

[ "def", "topics", "(", "preload", ":", "Kazoo", "::", "Topic", "::", "DEFAULT_PRELOAD_METHODS", ")", "@topics_mutex", ".", "synchronize", "do", "@topics", "||=", "begin", "topics", "=", "zk", ".", "get_children", "(", "path", ":", "\"/brokers/topics\"", ")", "raise", "Kazoo", "::", "Error", ",", "\"Failed to list topics. Error code: #{topics.fetch(:rc)}\"", "unless", "topics", ".", "fetch", "(", ":rc", ")", "==", "Zookeeper", "::", "Constants", "::", "ZOK", "preload_topics_from_names", "(", "topics", ".", "fetch", "(", ":children", ")", ",", "preload", ":", "preload", ")", "end", "end", "end" ]

[ "Returns", "a", "hash", "of", "all", "the", "topics", "in", "the", "Kafka", "cluster", "indexed", "by", "the", "topic", "name", "." ]

[ "def", "create_topic", "(", "name", ",", "partitions", ":", "nil", ",", "replication_factor", ":", "nil", ",", "config", ":", "nil", ")", "raise", "ArgumentError", ",", "\"partitions must be a positive integer\"", "if", "Integer", "(", "partitions", ")", "<=", "0", "raise", "ArgumentError", ",", "\"replication_factor must be a positive integer\"", "if", "Integer", "(", "replication_factor", ")", "<=", "0", "Kazoo", "::", "Topic", ".", "create", "(", "self", ",", "name", ",", "partitions", ":", "Integer", "(", "partitions", ")", ",", "replication_factor", ":", "Integer", "(", "replication_factor", ")", ",", "config", ":", "config", ")", "end" ]

[ "Creates", "a", "topic", "on", "the", "Kafka", "cluster", "with", "the", "provided", "number", "of", "partitions", "and", "replication", "factor", "." ]

[ "def", "preferred_leader_election", "(", "partitions", ":", "nil", ")", "partitions", "=", "self", ".", "partitions", "if", "partitions", ".", "nil?", "result", "=", "zk", ".", "create", "(", "path", ":", "\"/admin/preferred_replica_election\"", ",", "data", ":", "JSON", ".", "generate", "(", "version", ":", "1", ",", "partitions", ":", "partitions", ")", ")", "case", "result", ".", "fetch", "(", ":rc", ")", "when", "Zookeeper", "::", "Constants", "::", "ZOK", "return", "true", "when", "Zookeeper", "::", "Constants", "::", "ZNODEEXISTS", "raise", "Kazoo", "::", "Error", ",", "\"Another preferred leader election is still in progress\"", "else", "raise", "Kazoo", "::", "Error", ",", "\"Failed to start preferred leadership election. Result code: #{result.fetch(:rc)}\"", "end", "end" ]

[ "Triggers", "a", "preferred", "leader", "elections", "for", "the", "provided", "list", "of", "partitions", ".", "If", "no", "list", "of", "partitions", "is", "provided", "the", "preferred", "leader", "will", "be", "elected", "for", "all", "partitions", "in", "the", "cluster", "." ]

[ "def", "recursive_create", "(", "path", ":", "nil", ")", "raise", "ArgumentError", ",", "\"path is a required argument\"", "if", "path", ".", "nil?", "result", "=", "zk", ".", "stat", "(", "path", ":", "path", ")", "case", "result", ".", "fetch", "(", ":rc", ")", "when", "Zookeeper", "::", "Constants", "::", "ZOK", "return", "when", "Zookeeper", "::", "Constants", "::", "ZNONODE", "recursive_create", "(", "path", ":", "File", ".", "dirname", "(", "path", ")", ")", "result", "=", "zk", ".", "create", "(", "path", ":", "path", ")", "case", "result", ".", "fetch", "(", ":rc", ")", "when", "Zookeeper", "::", "Constants", "::", "ZOK", ",", "Zookeeper", "::", "Constants", "::", "ZNODEEXISTS", "return", "else", "raise", "Kazoo", "::", "Error", ",", "\"Failed to create node #{path}. Result code: #{result.fetch(:rc)}\"", "end", "else", "raise", "Kazoo", "::", "Error", ",", "\"Failed to create node #{path}. Result code: #{result.fetch(:rc)}\"", "end", "end" ]

[ "Recursively", "creates", "a", "node", "in", "Zookeeper", "by", "recusrively", "trying", "to", "create", "its", "parent", "if", "it", "doesn", "not", "yet", "exist", "." ]

[ "def", "recursive_delete", "(", "path", ":", "nil", ")", "raise", "ArgumentError", ",", "\"path is a required argument\"", "if", "path", ".", "nil?", "result", "=", "zk", ".", "get_children", "(", "path", ":", "path", ")", "raise", "Kazoo", "::", "Error", ",", "\"Failed to list children of #{path} to delete them. Result code: #{result.fetch(:rc)}\"", "if", "result", ".", "fetch", "(", ":rc", ")", "!=", "Zookeeper", "::", "Constants", "::", "ZOK", "threads", "=", "result", ".", "fetch", "(", ":children", ")", ".", "map", "do", "|", "name", "|", "Thread", ".", "new", "do", "Thread", ".", "abort_on_exception", "=", "true", "recursive_delete", "(", "path", ":", "File", ".", "join", "(", "path", ",", "name", ")", ")", "end", "end", "threads", ".", "each", "(", ":join", ")", "result", "=", "zk", ".", "delete", "(", "path", ":", "path", ")", "raise", "Kazoo", "::", "Error", ",", "\"Failed to delete node #{path}. Result code: #{result.fetch(:rc)}\"", "if", "result", ".", "fetch", "(", ":rc", ")", "!=", "Zookeeper", "::", "Constants", "::", "ZOK", "end" ]

[ "Deletes", "a", "node", "and", "all", "of", "its", "children", "from", "Zookeeper", "." ]

[ "def", "find", "(", "text", ")", "nodes", "=", "parser", ".", "parse", "(", "text", ")", "nodes", ".", "length", ".", "times", ".", "find", "do", "|", "index", "|", "if", "(", "song", "=", "Song", ".", "new", "(", "nodes", "[", "index", "..", "-", "1", "]", ",", "rule", ":", "@rule", ")", ")", ".", "valid?", "break", "song", "end", "end", "end" ]

[ "Find", "one", "valid", "song", "from", "given", "text", "." ]

[ "def", "judge", "(", "text", ")", "Song", ".", "new", "(", "parser", ".", "parse", "(", "text", ")", ",", "exactly", ":", "true", ",", "rule", ":", "@rule", ")", ".", "valid?", "end" ]

[ "Judge", "if", "given", "text", "is", "valid", "song", "or", "not", "." ]

[ "def", "search", "(", "text", ")", "nodes", "=", "parser", ".", "parse", "(", "text", ")", "nodes", ".", "length", ".", "times", ".", "map", "do", "|", "index", "|", "Song", ".", "new", "(", "nodes", "[", "index", "..", "-", "1", "]", ",", "rule", ":", "@rule", ")", "end", ".", "select", "(", ":valid?", ")", "end" ]

[ "Search", "all", "valid", "songs", "from", "given", "text", "." ]

[ "def", "led_partitions", "result", ",", "mutex", "=", "[", "]", ",", "Mutex", ".", "new", "threads", "=", "cluster", ".", "partitions", ".", "map", "do", "|", "partition", "|", "Thread", ".", "new", "do", "Thread", ".", "abort_on_exception", "=", "true", "select", "=", "partition", ".", "leader", "==", "self", "mutex", ".", "synchronize", "{", "result", "<<", "partition", "}", "if", "select", "end", "end", "threads", ".", "each", "(", ":join", ")", "result", "end" ]

[ "Returns", "a", "list", "of", "all", "partitions", "that", "are", "currently", "led", "by", "this", "broker", "." ]

[ "def", "replicated_partitions", "result", ",", "mutex", "=", "[", "]", ",", "Mutex", ".", "new", "threads", "=", "cluster", ".", "partitions", ".", "map", "do", "|", "partition", "|", "Thread", ".", "new", "do", "Thread", ".", "abort_on_exception", "=", "true", "select", "=", "partition", ".", "replicas", ".", "include?", "(", "self", ")", "mutex", ".", "synchronize", "{", "result", "<<", "partition", "}", "if", "select", "end", "end", "threads", ".", "each", "(", ":join", ")", "result", "end" ]

[ "Returns", "a", "list", "of", "all", "partitions", "that", "host", "a", "replica", "on", "this", "broker", "." ]

[ "def", "critical?", "(", "replicas", ":", "1", ")", "result", ",", "mutex", "=", "false", ",", "Mutex", ".", "new", "threads", "=", "replicated_partitions", ".", "map", "do", "|", "partition", "|", "Thread", ".", "new", "do", "Thread", ".", "abort_on_exception", "=", "true", "isr", "=", "partition", ".", "isr", ".", "reject", "{", "|", "r", "|", "r", "==", "self", "}", "mutex", ".", "synchronize", "{", "result", "=", "true", "if", "isr", ".", "length", "<", "Integer", "(", "replicas", ")", "}", "end", "end", "threads", ".", "each", "(", ":join", ")", "result", "end" ]

[ "Returns", "whether", "this", "broker", "is", "currently", "considered", "critical", "." ]