Datasets:

---

CM

/

codexglue_code2text_ruby

like 1

[ "def", "traverse_children", "(", "aParentNode", ")", "children", "=", "aParentNode", ".", "children", "broadcast", "(", ":before_subnodes", ",", "aParentNode", ",", "children", ")", "# Let's proceed with the visit of children", "children", ".", "each_with_index", "do", "|", "a_node", ",", "i", "|", "edge_sign", "=", "aParentNode", ".", "signatures", "[", "i", "]", "if", "a_node", ".", "kind_of?", "(", "SPPF", "::", "CompositeNode", ")", "push_node", "(", "a_node", ",", "edge_sign", ")", "access_paths", "=", "node_accesses", "[", "a_node", "]", "last_path", "=", "legs", ".", "last", "[", "-", "1", "]", "path_reused", "=", "access_paths", ".", "include?", "(", "last_path", ")", "unless", "path_reused", "node_accesses", "[", "a_node", "]", ".", "push", "(", "last_path", ")", "a_node", ".", "accept", "(", "self", ")", "end", "pop_node", "else", "a_node", ".", "accept", "(", "self", ")", "end", "end", "broadcast", "(", ":after_subnodes", ",", "aParentNode", ",", "children", ")", "end" ]

[ "Visit", "event", ".", "The", "visitor", "is", "about", "to", "visit", "the", "children", "of", "a", "non", "terminal", "node", "." ]

[ "def", "[]", "(", "n", ")", "if", "@elements", "&&", "@elements", "[", "n", "-", "Celerity", ".", "index_offset", "]", "element_class", ".", "new", "(", "@container", ",", ":object", ",", "@elements", "[", "n", "-", "Celerity", ".", "index_offset", "]", ")", "else", "iterator_object", "(", "n", "-", "Celerity", ".", "index_offset", ")", "end", "end" ]

[ "Get", "the", "element", "at", "the", "given", "index", ".", "By", "default", "this", "is", "1", "-", "indexed", "to", "keep", "compatibility", "with", "Watir", "." ]

[ "def", "selected?", "(", "value", ")", "assert_exists", "raise", "UnknownObjectException", ",", "\"unknown option with value #{value.inspect} for select_list #{@conditions.inspect}\"", "unless", "include?", "(", "value", ")", "!", "!", "@object", ".", "getOptions", ".", "find", "{", "|", "e", "|", "matches_option?", "(", "e", ",", "value", ")", "&&", "e", ".", "isSelected", "}", "end" ]

[ "Returns", "true", "if", "any", "of", "the", "selected", "options", "match", "the", "given", "value", "." ]

[ "def", "contains_text", "(", "expected_text", ")", "assert_exists", "return", "nil", "unless", "respond_to?", ":text", "case", "expected_text", "when", "Regexp", "text", "(", ")", "=~", "expected_text", "when", "String", "text", "(", ")", ".", "index", "(", "expected_text", ")", "else", "raise", "TypeError", ",", "\"expected String or Regexp, got #{expected_text.inspect}:#{expected_text.class}\"", "end", "end" ]

[ "Check", "if", "the", "element", "contains", "the", "given", "text", "." ]

[ "def", "parse", "(", "aTokenizer", ")", "tokens", "=", "[", "]", "aTokenizer", ".", "each", "do", "|", "a_token", "|", "next", "unless", "a_token", "term_name", "=", "a_token", ".", "terminal", "term_symb", "=", "grammar", ".", "name2symbol", "[", "term_name", "]", "a_token", ".", "instance_variable_set", "(", ":@terminal", ",", "term_symb", ")", "tokens", "<<", "a_token", "end", "parser", "=", "build_parser", "(", "grammar", ")", "parser", ".", "gf_graph", ".", "diagnose", "if", "configuration", ".", "diagnose", "result", "=", "parser", ".", "parse", "(", "tokens", ")", "result", ".", "tidy_up!", "return", "result", "end" ]

[ "Parse", "the", "sequence", "of", "tokens", "produced", "by", "the", "given", "tokenizer", "object", "." ]

[ "def", "to_ptree", "(", "aRawParse", ")", "factory", "=", "ParseRep", "::", "ParseTreeFactory", ".", "new", "(", "aRawParse", ")", "if", "configuration", ".", "repr_builder", "==", ":default", "result", "=", "factory", ".", "create", "(", "nil", ")", "else", "result", "=", "factory", ".", "create", "(", "configuration", ".", "repr_builder", ")", "end", "return", "result", "end" ]

[ "Convert", "raw", "parse", "result", "into", "a", "parse", "tree", "representation" ]

[ "def", "to_pforest", "(", "aRawParse", ")", "factory", "=", "ParseRep", "::", "ParseForestFactory", ".", "new", "(", "aRawParse", ")", "if", "configuration", ".", "repr_builder", "==", ":default", "result", "=", "factory", ".", "create", "(", "nil", ")", "else", "result", "=", "factory", ".", "create", "(", "configuration", ".", "repr_builder", ")", "end", "return", "result", "end" ]

[ "Convert", "raw", "parse", "result", "into", "a", "parse", "forest", "representation" ]

[ "def", "with_nullpointer_retry", "(", "max_retries", "=", "3", ")", "tries", "=", "0", "yield", "rescue", "java", ".", "lang", ".", "NullPointerException", "=>", "e", "raise", "e", "if", "tries", ">=", "max_retries", "tries", "+=", "1", "warn", "\"warning: celerity caught #{e} - retry ##{tries}\"", "retry", "end" ]

[ "HtmlUnit", "throws", "NPEs", "sometimes", "when", "we", "re", "locating", "elements", "Retry", "seems", "to", "work", "fine", "." ]

[ "def", "click_and_attach", "assert_exists_and_enabled", "browser", "=", "Browser", ".", "new", "(", "@browser", ".", "options", ".", "dup", ")", "browser", ".", "webclient", ".", "set_cookie_manager", "(", "@browser", ".", "webclient", ".", "get_cookie_manager", ")", "# hirobumi: we do want cookies as well.", "@browser", ".", "disable_event_listener", "do", "rescue_status_code_exception", "{", "browser", ".", "page", "=", "@object", ".", "click", "}", "end", "browser", "end" ]

[ "Click", "the", "element", "and", "return", "a", "new", "Browser", "instance", "with", "the", "resulting", "page", ".", "This", "is", "useful", "for", "elements", "that", "trigger", "popups", "when", "clicked", "." ]

[ "def", "value?", "(", "value", ")", "value", "=", "Erlang", ".", "from", "(", "value", ")", "each", "{", "|", "k", ",", "v", "|", "return", "true", "if", "value", "==", "v", "}", "return", "false", "end" ]

[ "Return", "true", "if", "this", "Map", "has", "one", "or", "more", "keys", "which", "map", "to", "the", "provided", "value", "." ]

[ "def", "get", "(", "key", ")", "key", "=", "Erlang", ".", "from", "(", "key", ")", "entry", "=", "@trie", ".", "get", "(", "key", ")", "if", "entry", "return", "entry", "[", "1", "]", "elsif", "@default", "return", "@default", ".", "call", "(", "key", ")", "end", "end" ]

[ "Retrieve", "the", "value", "corresponding", "to", "the", "provided", "key", "object", ".", "If", "not", "found", "and", "this", "Map", "has", "a", "default", "block", "the", "default", "block", "is", "called", "to", "provide", "the", "value", ".", "Otherwise", "return", "nil", "." ]

[ "def", "fetch", "(", "key", ",", "default", "=", "Undefined", ")", "key", "=", "Erlang", ".", "from", "(", "key", ")", "entry", "=", "@trie", ".", "get", "(", "key", ")", "if", "entry", "return", "entry", "[", "1", "]", "elsif", "block_given?", "return", "yield", "(", "key", ")", "elsif", "not", "Undefined", ".", "equal?", "(", "default", ")", "return", "Erlang", ".", "from", "(", "default", ")", "else", "raise", "KeyError", ",", "\"key not found: #{key.inspect}\"", "end", "end" ]

[ "Retrieve", "the", "value", "corresponding", "to", "the", "given", "key", "object", "or", "use", "the", "provided", "default", "value", "or", "block", "or", "otherwise", "raise", "a", "KeyError", "." ]

[ "def", "slice", "(", "*", "wanted", ")", "trie", "=", "Trie", ".", "new", "(", "0", ")", "wanted", ".", "each", "{", "|", "key", "|", "key", "=", "Erlang", ".", "from", "(", "key", ")", "trie", ".", "put!", "(", "key", ",", "get", "(", "key", ")", ")", "if", "key?", "(", "key", ")", "}", "return", "self", ".", "class", ".", "alloc", "(", "trie", ",", "@default", ")", "end" ]

[ "Return", "a", "new", "Map", "with", "only", "the", "associations", "for", "the", "wanted", "keys", "retained", "." ]

[ "def", "poll_queue", "@job", "=", "reserve_job", "if", "@job", ".", "nil?", "@log", ".", "info", "(", "'No job found'", ")", "else", "@log", ".", "info", "(", "'Job starting'", ")", "begin", "@current_job_start_time", "=", "Time", ".", "now", "execute_job", "rescue", "=>", "e", "@log", ".", "info", "(", "\"Error running test: #{e.message}\\n : #{e.backtrace.join(\"\\n :\")}\"", ")", "end", "cleanup", "end", "end" ]

[ "The", "main", "worker", "process", "loop", "Check", "the", "queues", "for", "work" ]

[ "def", "reserve_job", "@log", ".", "info", "\"Trying to reserve job for queues: #{@queues.join(', ')}\"", "job", "=", "job_message_klass", ".", "reserve", "(", "@queues", ",", "reservation_details", ")", "@log", ".", "debug", "\"Job: #{job.inspect}\"", "raise", "InvalidJobReservationError", ".", "new", "(", "\"Invalid Job Reserved\"", ")", "if", "!", "(", "job", ".", "nil?", "||", "job", ".", "valid?", ")", "job", "end" ]

[ "Try", "to", "find", "and", "reserve", "a", "job" ]

[ "def", "diagnostics", "retn", "=", "true", "protect", "retn", "=", "@diagnostic_runner", ".", "run", "if", "!", "@diagnostic_runner", ".", "nil?", "unprotect", "@log", ".", "info", "(", "'Diagnostics failed'", ")", "if", "not", "retn", "status", "=", "device_status", "status", "=", "set_device_status", "(", "'happy'", ")", "if", "status", "==", "'busy'", "raise", "DeviceNotReady", ".", "new", "(", "\"Current device status: '#{status}'\"", ")", "if", "status", "!=", "'happy'", "retn", "end" ]

[ "Diagnostics", "function", "to", "be", "extended", "in", "child", "class", "as", "required" ]

[ "def", "upload_files", "(", "job", ",", "*", "paths", ")", "@log", ".", "info", "(", "\"Uploading assets\"", ")", "paths", ".", "each", "do", "|", "path", "|", "@log", ".", "info", "(", "\"Uploading files from #{path}\"", ")", "Dir", ".", "foreach", "(", "path", ")", "do", "|", "item", "|", "@log", ".", "info", "(", "\"File: #{item}\"", ")", "next", "if", "item", "==", "'.'", "or", "item", "==", "'..'", "begin", "artifact", "=", "job", ".", "report_artifact", "(", "\"#{path}/#{item}\"", ")", "@log", ".", "info", "(", "\"Artifact uploaded: #{artifact.attributes.to_s}\"", ")", "rescue", "=>", "e", "@log", ".", "error", "(", "\"Error uploading artifact #{item}: #{e.message}\"", ")", "@log", ".", "error", "(", "\" : #{e.backtrace.join(\"\\n : \")}\"", ")", "end", "end", "end", "end" ]

[ "Upload", "any", "files", "from", "the", "test" ]

[ "def", "checkout_code", "(", "repository", ",", "checkout_directory", ",", "branch", ")", "CodeCache", ".", "repo", "(", "repository", ")", ".", "checkout", "(", ":head", ",", "checkout_directory", ",", "branch", ")", "or", "raise", "\"Unable to checkout repository #{repository}\"", "end" ]

[ "Get", "a", "checkout", "of", "the", "repository" ]

[ "def", "gremlins", "{", "space", ":", "\"\\u2420\"", ",", "tab", ":", "\"\\u21B9\"", ",", "carriage_return", ":", "\"\\u23CE\"", ",", "line_feed", ":", "\"\\u240A\"", ",", "control_c", ":", "\"\\u2404\"", ",", "control_d", ":", "\"\\u2403\"", ",", "control_r", ":", "\"\\u2412\"", ",", "escape", ":", "\"\\u238B\"", ",", "backspace", ":", "\"\\u2408\"", ",", "delete", ":", "\"\\u232B\"", ",", "up", ":", "\"\\u2191\"", ",", "down", ":", "\"\\u2193\"", ",", "left", ":", "\"\\u2190\"", ",", "right", ":", "\"\\u2192\"", "}", "end" ]

[ "Glyphs", "and", "Alternate", "Names" ]

[ "def", "bitslice", "(", "arg", ",", "length", "=", "(", "missing_length", "=", "true", ")", ")", "if", "missing_length", "if", "arg", ".", "is_a?", "(", "Range", ")", "from", ",", "to", "=", "arg", ".", "begin", ",", "arg", ".", "end", "from", "+=", "bitsize", "if", "from", "<", "0", "return", "nil", "if", "from", "<", "0", "to", "+=", "bitsize", "if", "to", "<", "0", "to", "+=", "1", "if", "!", "arg", ".", "exclude_end?", "length", "=", "to", "-", "from", "length", "=", "0", "if", "length", "<", "0", "length", "=", "bitsize", "-", "from", "if", "(", "from", "+", "length", ")", ">", "bitsize", "return", "nil", "if", "length", "<", "0", "l8", "=", "length", ".", "div", "(", "8", ")", "l1", "=", "length", "%", "8", "pad", "=", "8", "-", "l1", "enum", "=", "each_bit", "skip", "=", "from", "enum", "=", "enum", ".", "drop_while", "{", "if", "skip", ">", "0", "skip", "-=", "1", "next", "true", "else", "next", "false", "end", "}", "head", "=", "enum", ".", "take", "(", "length", ")", "if", "l1", "==", "0", "return", "Erlang", "::", "Binary", "[", "[", "head", ".", "join", "]", ".", "pack", "(", "BIT_PACK", ")", "]", "else", "tail", "=", "head", "[", "-", "l1", "..", "-", "1", "]", "head", "=", "head", "[", "0", "...", "-", "l1", "]", "tail", "=", "(", "[", "0", "]", "*", "pad", ")", ".", "concat", "(", "tail", ")", "return", "Erlang", "::", "Bitstring", "[", "[", "[", "head", ".", "join", ",", "tail", ".", "join", "]", ".", "join", "]", ".", "pack", "(", "BIT_PACK", ")", ",", "bits", ":", "l1", "]", "end", "else", "arg", "+=", "bitsize", "if", "arg", "<", "0", "return", "nil", "if", "arg", "<", "0", "return", "nil", "if", "arg", ">=", "bitsize", "a8", "=", "arg", ".", "div", "(", "8", ")", "a1", "=", "arg", "%", "8", "byte", "=", "@data", ".", "getbyte", "(", "a8", ")", "return", "nil", "if", "byte", ".", "nil?", "return", "(", "byte", ">>", "(", "(", "@bits", "-", "a1", "-", "1", ")", "&", "7", ")", ")", "&", "1", "end", "else", "return", "nil", "if", "length", "<", "0", "arg", "+=", "bitsize", "if", "arg", "<", "0", "return", "nil", "if", "arg", "<", "0", "length", "=", "bitsize", "-", "arg", "if", "(", "arg", "+", "length", ")", ">", "bitsize", "return", "nil", "if", "length", "<", "0", "l8", "=", "length", ".", "div", "(", "8", ")", "l1", "=", "length", "%", "8", "pad", "=", "8", "-", "l1", "enum", "=", "each_bit", "skip", "=", "arg", "enum", "=", "enum", ".", "drop_while", "{", "if", "skip", ">", "0", "skip", "-=", "1", "next", "true", "else", "next", "false", "end", "}", "head", "=", "enum", ".", "take", "(", "length", ")", "if", "l1", "==", "0", "return", "Erlang", "::", "Binary", "[", "[", "head", ".", "join", "]", ".", "pack", "(", "BIT_PACK", ")", "]", "else", "tail", "=", "head", "[", "-", "l1", "..", "-", "1", "]", "head", "=", "head", "[", "0", "...", "-", "l1", "]", "tail", "=", "(", "[", "0", "]", "*", "pad", ")", ".", "concat", "(", "tail", ")", "return", "Erlang", "::", "Bitstring", "[", "[", "[", "head", ".", "join", ",", "tail", ".", "join", "]", ".", "join", "]", ".", "pack", "(", "BIT_PACK", ")", ",", "bits", ":", "l1", "]", "end", "end", "end" ]

[ "Return", "specific", "objects", "from", "the", "Bitstring", ".", "All", "overloads", "return", "nil", "if", "the", "starting", "index", "is", "out", "of", "range", "." ]

[ "def", "each_bit", "return", "enum_for", "(", ":each_bit", ")", "unless", "block_given?", "index", "=", "0", "headbits", "=", "(", "self", ".", "bytesize", "-", "1", ")", "*", "8", "skipbits", "=", "8", "-", "@bits", "@data", ".", "each_byte", "do", "|", "byte", "|", "loop", "do", "break", "if", "index", "==", "@bitsize", "if", "index", ">=", "headbits", "bit", "=", "(", "byte", ">>", "(", "7", "-", "(", "(", "index", "+", "skipbits", ")", "&", "7", ")", ")", ")", "&", "1", "else", "bit", "=", "(", "byte", ">>", "(", "7", "-", "(", "index", "&", "7", ")", ")", ")", "&", "1", "end", "yield", "bit", "index", "+=", "1", "break", "if", "(", "index", "&", "7", ")", "==", "0", "end", "end", "return", "self", "end" ]

[ "Call", "the", "given", "block", "once", "for", "each", "bit", "in", "the", "Bitstring", "passing", "each", "bit", "from", "first", "to", "last", "successively", "to", "the", "block", ".", "If", "no", "block", "is", "given", "returns", "an", "Enumerator", "." ]

[ "def", "start_crmux!", "(", "opts", ")", "self", ".", "chrome_debugging_port", "=", "find_free_port", "(", "Capybara", "::", "ChromeDevTools", ".", "preferred_port", ")", "self", ".", "crmux_listen_port", "=", "find_free_port", "(", "chrome_debugging_port", "+", "1", ")", "opts", "[", ":options", "]", ".", "args", "<<", "\"--remote-debugging-port=#{chrome_debugging_port}\"", "#opts[:options].add_preference 'debuggerAddress', \"127.0.0.1:#{crmux_listen_port}\"", "@debug_crmux", "=", "true", "command", "=", "\"npx crmux #{'-d' if @debug_crmux} \\\n --port=#{chrome_debugging_port} \\\n --listen=#{crmux_listen_port}\"", "puts", "%(command: #{command})", "if", "Capybara", "::", "ChromeDevTools", ".", "verbose", ">=", "3", "if", "@debug_crmux", "spawn_opts", "=", "{", "[", ":out", ",", ":err", "]", "=>", "'log/crmux.log'", "}", "else", "spawn_opts", "=", "{", "}", "end", "@crmux_pid", "=", "spawn", "(", "command", ",", "spawn_opts", ")", "puts", "%(Started crmux [pid #{@crmux_pid}], listening at http://localhost:#{crmux_listen_port}, connected to localhost:#{chrome_debugging_port})", "# You can also get the part later with: page.driver.browser.capabilities[\"goog:chromeOptions\"][\"debuggerAddress\"]", "sleep", "0.1", "at_exit", "do", "puts", "\"Killing crmux process #{@crmux_pid}...\"", "if", "Capybara", "::", "ChromeDevTools", ".", "verbose", ">=", "1", "Process", ".", "kill", "'TERM'", ",", "@crmux_pid", "end", "end" ]

[ "Starts", "crmux", "and", "adds", "debuggerAddress", "to", "opts", "that", "points", "to", "crmux", "listen", "address", "." ]

[ "def", "start", "parent_pid", "=", "Process", ".", "pid", "@worker_pid", "=", "Process", ".", "fork", "do", "object", "=", "Object", "@worker_class", ".", "split", "(", "'::'", ")", ".", "each", "{", "|", "sub", "|", "object", "=", "object", ".", "const_get", "(", "sub", ")", "}", "object", ".", "new", "(", "@options", ".", "merge", "(", "'parent_pid'", "=>", "parent_pid", ",", "'device_identity'", "=>", "self", ".", "identity", ",", "'port_allocator'", "=>", "self", ".", "port_allocator", ",", "'hive_id'", "=>", "Hive", ".", "hive_mind", ".", "device_details", "[", "'id'", "]", ")", ")", "end", "Process", ".", "detach", "@worker_pid", "Hive", ".", "logger", ".", "info", "(", "\"Worker started with pid #{@worker_pid}\"", ")", "end" ]

[ "Initialise", "the", "device", "Start", "the", "worker", "process" ]

[ "def", "stop", "protect_file", "=", "File", ".", "expand_path", "(", "\"#{@worker_pid}.protect\"", ",", "PIDS_DIRECTORY", ")", "Hive", ".", "logger", ".", "debug", "(", "\"Checking for protected file: #{protect_file}\"", ")", "if", "File", ".", "exists?", "File", ".", "expand_path", "(", "\"#{@worker_pid}.protect\"", ",", "PIDS_DIRECTORY", ")", "Hive", ".", "logger", ".", "debug", "(", "\"PID #{@worker_pid} is protected\"", ")", "false", "else", "@stop_count", "=", "@stop_count", ".", "nil?", "?", "0", ":", "@stop_count", "+", "1", "if", "self", ".", "running?", "if", "@stop_count", "<", "30", "Hive", ".", "logger", ".", "info", "(", "\"Attempting to terminate process #{@worker_pid} [#{@stop_count}]\"", ")", "Process", ".", "kill", "'TERM'", ",", "@worker_pid", "else", "Hive", ".", "logger", ".", "info", "(", "\"Killing process #{@worker_pid}\"", ")", "Process", ".", "kill", "'KILL'", ",", "@worker_pid", "if", "self", ".", "running?", "end", "end", "if", "self", ".", "running?", "false", "else", "@worker_pid", "=", "nil", "@stop_count", "=", "nil", "true", "end", "end", "end" ]

[ "Terminate", "the", "worker", "process" ]

[ "def", "padded_line", "(", "iteration", ",", "elapsed_time", ")", "meter_line", "=", "line", "(", "iteration", ",", "elapsed_time", ")", "pad_size", "=", "[", "@last_printed_length", "-", "meter_line", ".", "size", ",", "0", "]", ".", "max", "@last_printed_length", "=", "meter_line", ".", "size", "meter_line", "+", "' '", "*", "pad_size", "end" ]

[ "Initialize", "a", "new", "Printer", "." ]

[ "def", "put", "(", "index", ",", "element", "=", "yield", "(", "get", "(", "index", ")", ")", ")", "raise", "IndexError", ",", "\"index #{index} outside of tuple bounds\"", "if", "index", "<", "-", "@size", "element", "=", "Erlang", ".", "from", "(", "element", ")", "index", "+=", "@size", "if", "index", "<", "0", "if", "index", ">", "@size", "suffix", "=", "Array", ".", "new", "(", "index", "-", "@size", ",", "nil", ")", "suffix", "<<", "element", "return", "replace_suffix", "(", "@size", ",", "suffix", ")", "else", "return", "update_root", "(", "index", ",", "element", ")", "end", "end" ]

[ "Return", "a", "new", "Tuple", "with", "a", "new", "value", "at", "the", "given", "index", ".", "If", "index", "is", "greater", "than", "the", "length", "of", "the", "tuple", "the", "returned", "tuple", "will", "be", "padded", "with", "nil", "s", "to", "the", "correct", "size", "." ]

[ "def", "fetch", "(", "index", ",", "default", "=", "(", "missing_default", "=", "true", ")", ")", "if", "index", ">=", "-", "@size", "&&", "index", "<", "@size", "return", "get", "(", "index", ")", "elsif", "block_given?", "return", "Erlang", ".", "from", "(", "yield", "(", "index", ")", ")", "elsif", "!", "missing_default", "return", "Erlang", ".", "from", "(", "default", ")", "else", "raise", "IndexError", ",", "\"index #{index} outside of tuple bounds\"", "end", "end" ]

[ "Retrieve", "the", "value", "at", "index", "with", "optional", "default", "." ]

[ "def", "slice", "(", "arg", ",", "length", "=", "(", "missing_length", "=", "true", ")", ")", "if", "missing_length", "if", "arg", ".", "is_a?", "(", "Range", ")", "from", ",", "to", "=", "arg", ".", "begin", ",", "arg", ".", "end", "from", "+=", "@size", "if", "from", "<", "0", "to", "+=", "@size", "if", "to", "<", "0", "to", "+=", "1", "if", "!", "arg", ".", "exclude_end?", "length", "=", "to", "-", "from", "length", "=", "0", "if", "length", "<", "0", "return", "subsequence", "(", "from", ",", "length", ")", "else", "return", "get", "(", "arg", ")", "end", "else", "arg", "+=", "@size", "if", "arg", "<", "0", "return", "subsequence", "(", "arg", ",", "length", ")", "end", "end" ]

[ "Return", "specific", "objects", "from", "the", "Tuple", ".", "All", "overloads", "return", "nil", "if", "the", "starting", "index", "is", "out", "of", "range", "." ]

[ "def", "insert", "(", "index", ",", "*", "elements", ")", "raise", "IndexError", "if", "index", "<", "-", "@size", "index", "+=", "@size", "if", "index", "<", "0", "elements", "=", "elements", ".", "map", "{", "|", "element", "|", "Erlang", ".", "from", "(", "element", ")", "}", "if", "index", "<", "@size", "suffix", "=", "flatten_suffix", "(", "@root", ",", "@levels", "*", "BITS_PER_LEVEL", ",", "index", ",", "[", "]", ")", "suffix", ".", "unshift", "(", "elements", ")", "elsif", "index", "==", "@size", "suffix", "=", "elements", "else", "suffix", "=", "Array", ".", "new", "(", "index", "-", "@size", ",", "nil", ")", ".", "concat", "(", "elements", ")", "index", "=", "@size", "end", "return", "replace_suffix", "(", "index", ",", "suffix", ")", "end" ]

[ "Return", "a", "new", "Tuple", "with", "the", "given", "values", "inserted", "before", "the", "element", "at", "index", ".", "If", "index", "is", "greater", "than", "the", "current", "length", "nil", "values", "are", "added", "to", "pad", "the", "Tuple", "to", "the", "required", "size", "." ]

[ "def", "delete_at", "(", "index", ")", "return", "self", "if", "index", ">=", "@size", "||", "index", "<", "-", "@size", "index", "+=", "@size", "if", "index", "<", "0", "suffix", "=", "flatten_suffix", "(", "@root", ",", "@levels", "*", "BITS_PER_LEVEL", ",", "index", ",", "[", "]", ")", "return", "replace_suffix", "(", "index", ",", "suffix", ".", "tap", "{", "|", "a", "|", "a", ".", "shift", "}", ")", "end" ]

[ "Return", "a", "new", "Tuple", "with", "the", "element", "at", "index", "removed", ".", "If", "the", "given", "index", "does", "not", "exist", "return", "self", "." ]

[ "def", "select", "return", "enum_for", "(", ":select", ")", "unless", "block_given?", "return", "reduce", "(", "self", ".", "class", ".", "empty", ")", "{", "|", "tuple", ",", "element", "|", "yield", "(", "element", ")", "?", "tuple", ".", "add", "(", "element", ")", ":", "tuple", "}", "end" ]

[ "Return", "a", "new", "Tuple", "containing", "all", "elements", "for", "which", "the", "given", "block", "returns", "true", "." ]

[ "def", "shuffle", "return", "self", ".", "class", ".", "new", "(", "(", "(", "array", "=", "to_a", ")", ".", "frozen?", "?", "array", ".", "shuffle", ":", "array", ".", "shuffle!", ")", ".", "freeze", ")", "end" ]

[ "Return", "a", "new", "Tuple", "with", "the", "same", "elements", "as", "this", "one", "but", "randomly", "permuted", "." ]

[ "def", "reverse", "return", "self", ".", "class", ".", "new", "(", "(", "(", "array", "=", "to_a", ")", ".", "frozen?", "?", "array", ".", "reverse", ":", "array", ".", "reverse!", ")", ".", "freeze", ")", "end" ]

[ "Return", "a", "new", "Tuple", "with", "the", "same", "elements", "as", "this", "one", "but", "in", "reverse", "order", "." ]

[ "def", "rotate", "(", "count", "=", "1", ")", "return", "self", "if", "(", "count", "%", "@size", ")", "==", "0", "return", "self", ".", "class", ".", "new", "(", "(", "(", "array", "=", "to_a", ")", ".", "frozen?", "?", "array", ".", "rotate", "(", "count", ")", ":", "array", ".", "rotate!", "(", "count", ")", ")", ".", "freeze", ")", "end" ]

[ "Return", "a", "new", "Tuple", "with", "the", "same", "elements", "but", "rotated", "so", "that", "the", "one", "at", "index", "count", "is", "the", "first", "element", "of", "the", "new", "tuple", ".", "If", "count", "is", "positive", "the", "elements", "will", "be", "shifted", "left", "and", "those", "shifted", "past", "the", "lowest", "position", "will", "be", "moved", "to", "the", "end", ".", "If", "count", "is", "negative", "the", "elements", "will", "be", "shifted", "right", "and", "those", "shifted", "past", "the", "last", "position", "will", "be", "moved", "to", "the", "beginning", "." ]

[ "def", "sort", "(", "&", "comparator", ")", "comparator", "=", "Erlang", ".", "method", "(", ":compare", ")", "unless", "block_given?", "array", "=", "super", "(", "comparator", ")", "return", "self", ".", "class", ".", "new", "(", "array", ")", "end" ]

[ "Return", "a", "new", "Tuple", "with", "the", "same", "elements", "but", "sorted", "." ]

[ "def", "drop", "(", "n", ")", "return", "self", "if", "n", "==", "0", "return", "self", ".", "class", ".", "empty", "if", "n", ">=", "@size", "raise", "ArgumentError", ",", "\"attempt to drop negative size\"", "if", "n", "<", "0", "return", "self", ".", "class", ".", "new", "(", "flatten_suffix", "(", "@root", ",", "@levels", "*", "BITS_PER_LEVEL", ",", "n", ",", "[", "]", ")", ")", "end" ]

[ "Drop", "the", "first", "n", "elements", "and", "return", "the", "rest", "in", "a", "new", "Tuple", "." ]

[ "def", "*", "(", "times", ")", "return", "self", ".", "class", ".", "empty", "if", "times", "==", "0", "return", "self", "if", "times", "==", "1", "result", "=", "(", "to_a", "*", "times", ")", "return", "result", ".", "is_a?", "(", "Array", ")", "?", "self", ".", "class", ".", "new", "(", "result", ")", ":", "result", "end" ]

[ "Repetition", ".", "Return", "a", "new", "Tuple", "built", "by", "concatenating", "times", "copies", "of", "this", "one", "together", "." ]

[ "def", "combination", "(", "n", ")", "return", "enum_for", "(", ":combination", ",", "n", ")", "if", "not", "block_given?", "return", "self", "if", "n", "<", "0", "||", "@size", "<", "n", "if", "n", "==", "0", "yield", "[", "]", "elsif", "n", "==", "1", "each", "{", "|", "element", "|", "yield", "[", "element", "]", "}", "elsif", "n", "==", "@size", "yield", "self", ".", "to_a", "else", "combos", "=", "lambda", "do", "|", "result", ",", "index", ",", "remaining", "|", "while", "@size", "-", "index", ">", "remaining", "if", "remaining", "==", "1", "yield", "result", ".", "dup", "<<", "get", "(", "index", ")", "else", "combos", "[", "result", ".", "dup", "<<", "get", "(", "index", ")", ",", "index", "+", "1", ",", "remaining", "-", "1", "]", "end", "index", "+=", "1", "end", "index", ".", "upto", "(", "@size", "-", "1", ")", "{", "|", "i", "|", "result", "<<", "get", "(", "i", ")", "}", "yield", "result", "end", "combos", "[", "[", "]", ",", "0", ",", "n", "]", "end", "return", "self", "end" ]

[ "When", "invoked", "with", "a", "block", "yields", "all", "combinations", "of", "length", "n", "of", "elements", "from", "the", "Tuple", "and", "then", "returns", "self", ".", "There", "is", "no", "guarantee", "about", "which", "order", "the", "combinations", "will", "be", "yielded", "." ]

[ "def", "repeated_combination", "(", "n", ")", "return", "enum_for", "(", ":repeated_combination", ",", "n", ")", "if", "not", "block_given?", "if", "n", "<", "0", "# yield nothing", "elsif", "n", "==", "0", "yield", "[", "]", "elsif", "n", "==", "1", "each", "{", "|", "element", "|", "yield", "[", "element", "]", "}", "elsif", "@size", "==", "0", "# yield nothing", "else", "combos", "=", "lambda", "do", "|", "result", ",", "index", ",", "remaining", "|", "while", "index", "<", "@size", "-", "1", "if", "remaining", "==", "1", "yield", "result", ".", "dup", "<<", "get", "(", "index", ")", "else", "combos", "[", "result", ".", "dup", "<<", "get", "(", "index", ")", ",", "index", ",", "remaining", "-", "1", "]", "end", "index", "+=", "1", "end", "element", "=", "get", "(", "index", ")", "remaining", ".", "times", "{", "result", "<<", "element", "}", "yield", "result", "end", "combos", "[", "[", "]", ",", "0", ",", "n", "]", "end", "return", "self", "end" ]

[ "When", "invoked", "with", "a", "block", "yields", "all", "repeated", "combinations", "of", "length", "n", "of", "tuples", "from", "the", "Tuple", "and", "then", "returns", "self", ".", "A", "repeated", "combination", "is", "one", "in", "which", "any", "tuple", "from", "the", "Tuple", "can", "appear", "consecutively", "any", "number", "of", "times", "." ]

[ "def", "permutation", "(", "n", "=", "@size", ")", "return", "enum_for", "(", ":permutation", ",", "n", ")", "if", "not", "block_given?", "if", "n", "<", "0", "||", "@size", "<", "n", "# yield nothing", "elsif", "n", "==", "0", "yield", "[", "]", "elsif", "n", "==", "1", "each", "{", "|", "element", "|", "yield", "[", "element", "]", "}", "else", "used", ",", "result", "=", "[", "]", ",", "[", "]", "perms", "=", "lambda", "do", "|", "index", "|", "0", ".", "upto", "(", "@size", "-", "1", ")", "do", "|", "i", "|", "if", "!", "used", "[", "i", "]", "result", "[", "index", "]", "=", "get", "(", "i", ")", "if", "index", "<", "n", "-", "1", "used", "[", "i", "]", "=", "true", "perms", "[", "index", "+", "1", "]", "used", "[", "i", "]", "=", "false", "else", "yield", "result", ".", "dup", "end", "end", "end", "end", "perms", "[", "0", "]", "end", "return", "self", "end" ]

[ "Yields", "all", "permutations", "of", "length", "n", "of", "elements", "from", "the", "Tuple", "and", "then", "returns", "self", ".", "If", "no", "length", "n", "is", "specified", "permutations", "of", "all", "elements", "will", "be", "yielded", "." ]

[ "def", "product", "(", "*", "tuples", ")", "tuples", "=", "tuples", ".", "map", "{", "|", "tuple", "|", "Erlang", ".", "from", "(", "tuple", ")", "}", "# if no tuples passed, return \"product\" as in result of multiplying all elements", "return", "super", "if", "tuples", ".", "empty?", "tuples", ".", "unshift", "(", "self", ")", "if", "tuples", ".", "any?", "(", ":empty?", ")", "return", "block_given?", "?", "self", ":", "[", "]", "end", "counters", "=", "Array", ".", "new", "(", "tuples", ".", "size", ",", "0", ")", "bump_counters", "=", "lambda", "do", "i", "=", "tuples", ".", "size", "-", "1", "counters", "[", "i", "]", "+=", "1", "while", "counters", "[", "i", "]", "==", "tuples", "[", "i", "]", ".", "size", "counters", "[", "i", "]", "=", "0", "i", "-=", "1", "return", "true", "if", "i", "==", "-", "1", "# we are done", "counters", "[", "i", "]", "+=", "1", "end", "false", "# not done yet", "end", "build_array", "=", "lambda", "do", "array", "=", "[", "]", "counters", ".", "each_with_index", "{", "|", "index", ",", "i", "|", "array", "<<", "tuples", "[", "i", "]", "[", "index", "]", "}", "array", "end", "if", "block_given?", "while", "true", "yield", "build_array", "[", "]", "return", "self", "if", "bump_counters", "[", "]", "end", "else", "result", "=", "[", "]", "while", "true", "result", "<<", "build_array", "[", "]", "return", "result", "if", "bump_counters", "[", "]", "end", "end", "end" ]

[ "Cartesian", "product", "or", "multiplication", "." ]

[ "def", "rindex", "(", "obj", "=", "(", "missing_arg", "=", "true", ")", ")", "obj", "=", "Erlang", ".", "from", "(", "obj", ")", "i", "=", "@size", "-", "1", "if", "missing_arg", "if", "block_given?", "reverse_each", "{", "|", "element", "|", "return", "i", "if", "yield", "element", ";", "i", "-=", "1", "}", "return", "nil", "else", "return", "enum_for", "(", ":rindex", ")", "end", "else", "reverse_each", "{", "|", "element", "|", "return", "i", "if", "element", "==", "obj", ";", "i", "-=", "1", "}", "return", "nil", "end", "end" ]

[ "Find", "the", "index", "of", "an", "element", "starting", "from", "the", "end", "of", "the", "tuple", ".", "Returns", "nil", "if", "no", "element", "is", "found", "." ]

[ "def", "partition", "return", "enum_for", "(", ":partition", ")", "if", "not", "block_given?", "a", ",", "b", "=", "super", "return", "Erlang", "::", "Tuple", "[", "self", ".", "class", ".", "new", "(", "a", ")", ",", "self", ".", "class", ".", "new", "(", "b", ")", "]", "end" ]

[ "Return", "2", "collections", "the", "first", "containing", "all", "the", "elements", "for", "which", "the", "block", "evaluates", "to", "true", "the", "second", "containing", "the", "rest", "." ]

[ "def", "inspect", "result", "=", "\"#{self.class}[\"", "each_with_index", "{", "|", "obj", ",", "i", "|", "result", "<<", "', '", "if", "i", ">", "0", ";", "result", "<<", "obj", ".", "inspect", "}", "return", "result", "<<", "\"]\"", "end" ]

[ "Convert", "this", "collection", "to", "a", "programmer", "-", "readable", "String", "representation", "." ]

[ "def", "each", "raise", "Erlang", "::", "ImproperListError", "if", "improper?", "return", "to_enum", "unless", "block_given?", "list", "=", "self", "until", "list", ".", "empty?", "yield", "(", "list", ".", "head", ")", "list", "=", "list", ".", "tail", "end", "return", "self", "end" ]

[ "Call", "the", "given", "block", "once", "for", "each", "item", "in", "the", "list", "passing", "each", "item", "from", "first", "to", "last", "successively", "to", "the", "block", ".", "If", "no", "block", "is", "given", "returns", "an", "Enumerator", "." ]

[ "def", "flat_map", "(", "&", "block", ")", "raise", "Erlang", "::", "ImproperListError", "if", "improper?", "return", "enum_for", "(", ":flat_map", ")", "unless", "block_given?", "return", "self", "if", "empty?", "out", "=", "tail", "=", "Erlang", "::", "Cons", ".", "allocate", "list", "=", "self", "until", "list", ".", "empty?", "head_list", "=", "Erlang", "::", "List", ".", "from_enum", "(", "yield", "(", "list", ".", "head", ")", ")", "if", "head_list", ".", "empty?", "list", "=", "list", ".", "tail", "elsif", "list", ".", "tail", ".", "empty?", "tail", ".", "instance_variable_set", "(", ":@head", ",", "head_list", ".", "head", ")", "tail", ".", "instance_variable_set", "(", ":@tail", ",", "head_list", ".", "tail", ")", "tail", ".", "immutable!", "list", "=", "list", ".", "tail", "else", "new_node", "=", "Erlang", "::", "Cons", ".", "allocate", "new_node", ".", "instance_variable_set", "(", ":@improper", ",", "false", ")", "tail", ".", "instance_variable_set", "(", ":@head", ",", "head_list", ".", "head", ")", "tail", ".", "instance_variable_set", "(", ":@tail", ",", "head_list", ".", "tail", "+", "new_node", ")", "tail", ".", "immutable!", "list", "=", "list", ".", "tail", "tail", "=", "new_node", "end", "end", "if", "not", "tail", ".", "immutable?", "tail", ".", "instance_variable_set", "(", ":@tail", ",", "Erlang", "::", "Nil", ")", "tail", ".", "immutable!", "end", "if", "out", "===", "tail", "and", "not", "out", ".", "tail", ".", "kind_of?", "(", "Erlang", "::", "List", ")", "return", "out", ".", "tail", "else", "return", "out", "end", "end" ]

[ "Return", "a", "List", "which", "is", "realized", "by", "transforming", "each", "item", "into", "a", "List", "and", "flattening", "the", "resulting", "lists", "." ]

[ "def", "select", "(", "&", "block", ")", "raise", "Erlang", "::", "ImproperListError", "if", "improper?", "return", "enum_for", "(", ":select", ")", "unless", "block_given?", "out", "=", "tail", "=", "Erlang", "::", "Cons", ".", "allocate", "list", "=", "self", "while", "!", "list", ".", "empty?", "if", "yield", "(", "list", ".", "head", ")", "new_node", "=", "Erlang", "::", "Cons", ".", "allocate", "new_node", ".", "instance_variable_set", "(", ":@head", ",", "list", ".", "head", ")", "new_node", ".", "instance_variable_set", "(", ":@improper", ",", "false", ")", "tail", ".", "instance_variable_set", "(", ":@tail", ",", "new_node", ")", "tail", ".", "instance_variable_set", "(", ":@improper", ",", "false", ")", "tail", ".", "immutable!", "tail", "=", "new_node", "list", "=", "list", ".", "tail", "else", "list", "=", "list", ".", "tail", "end", "end", "if", "not", "tail", ".", "immutable?", "tail", ".", "instance_variable_set", "(", ":@tail", ",", "Erlang", "::", "Nil", ")", "tail", ".", "immutable!", "end", "return", "out", ".", "tail", "end" ]

[ "Return", "a", "List", "which", "contains", "all", "the", "items", "for", "which", "the", "given", "block", "returns", "true", "." ]

[ "def", "drop_while", "(", "&", "block", ")", "raise", "Erlang", "::", "ImproperListError", "if", "improper?", "return", "enum_for", "(", ":drop_while", ")", "unless", "block_given?", "list", "=", "self", "list", "=", "list", ".", "tail", "while", "!", "list", ".", "empty?", "&&", "yield", "(", "list", ".", "head", ")", "return", "list", "end" ]

[ "Return", "a", "List", "which", "contains", "all", "elements", "starting", "from", "the", "first", "element", "for", "which", "the", "block", "returns", "nil", "or", "false", "." ]

[ "def", "pop", "raise", "Erlang", "::", "ImproperListError", "if", "improper?", "return", "self", "if", "empty?", "new_size", "=", "size", "-", "1", "return", "Erlang", "::", "List", ".", "new", "(", "head", ",", "tail", ".", "take", "(", "new_size", "-", "1", ")", ")", "if", "new_size", ">=", "1", "return", "Erlang", "::", "Nil", "end" ]

[ "Return", "a", "List", "containing", "all", "but", "the", "last", "item", "from", "this", "List", "." ]

[ "def", "drop", "(", "number", ")", "raise", "Erlang", "::", "ImproperListError", "if", "improper?", "list", "=", "self", "while", "!", "list", ".", "empty?", "&&", "number", ">", "0", "number", "-=", "1", "list", "=", "list", ".", "tail", "end", "return", "list", "end" ]

[ "Return", "a", "List", "containing", "all", "items", "after", "the", "first", "number", "items", "from", "this", "List", "." ]

[ "def", "append", "(", "other", ")", "# raise Erlang::ImproperListError if improper?", "other", "=", "Erlang", ".", "from", "(", "other", ")", "return", "self", "if", "not", "improper?", "and", "Erlang", ".", "is_list", "(", "other", ")", "and", "other", ".", "empty?", "return", "other", "if", "Erlang", ".", "is_list", "(", "other", ")", "and", "empty?", "is_improper", "=", "Erlang", ".", "is_list", "(", "other", ")", "?", "other", ".", "improper?", ":", "true", "out", "=", "tail", "=", "Erlang", "::", "Cons", ".", "allocate", "list", "=", "self", "until", "list", ".", "empty?", "new_node", "=", "Erlang", "::", "Cons", ".", "allocate", "new_node", ".", "instance_variable_set", "(", ":@head", ",", "list", ".", "head", ")", "new_node", ".", "instance_variable_set", "(", ":@improper", ",", "is_improper", ")", "tail", ".", "instance_variable_set", "(", ":@tail", ",", "new_node", ")", "tail", ".", "instance_variable_set", "(", ":@improper", ",", "is_improper", ")", "tail", ".", "immutable!", "tail", "=", "new_node", "if", "not", "Erlang", ".", "is_list", "(", "list", ".", "tail", ")", "new_node", "=", "Erlang", "::", "Cons", ".", "allocate", "new_node", ".", "instance_variable_set", "(", ":@head", ",", "list", ".", "tail", ")", "new_node", ".", "instance_variable_set", "(", ":@improper", ",", "is_improper", ")", "tail", ".", "instance_variable_set", "(", ":@tail", ",", "new_node", ")", "tail", ".", "instance_variable_set", "(", ":@improper", ",", "is_improper", ")", "tail", ".", "immutable!", "tail", "=", "new_node", "list", "=", "Erlang", "::", "Nil", "else", "list", "=", "list", ".", "tail", "end", "end", "if", "not", "tail", ".", "immutable?", "tail", ".", "instance_variable_set", "(", ":@tail", ",", "other", ")", "tail", ".", "immutable!", "end", "return", "out", ".", "tail", "end" ]

[ "Return", "a", "List", "with", "all", "items", "from", "this", "List", "followed", "by", "all", "items", "from", "other", "." ]

[ "def", "transpose", "raise", "Erlang", "::", "ImproperListError", "if", "improper?", "return", "Erlang", "::", "Nil", "if", "empty?", "return", "Erlang", "::", "Nil", "if", "any?", "{", "|", "list", "|", "list", ".", "empty?", "}", "heads", ",", "tails", "=", "Erlang", "::", "Nil", ",", "Erlang", "::", "Nil", "reverse_each", "{", "|", "list", "|", "heads", ",", "tails", "=", "heads", ".", "cons", "(", "list", ".", "head", ")", ",", "tails", ".", "cons", "(", "list", ".", "tail", ")", "}", "return", "Erlang", "::", "Cons", ".", "new", "(", "heads", ",", "tails", ".", "transpose", ")", "end" ]

[ "Gather", "the", "first", "element", "of", "each", "nested", "list", "into", "a", "new", "List", "then", "the", "second", "element", "of", "each", "nested", "list", "then", "the", "third", "and", "so", "on", ".", "In", "other", "words", "if", "each", "nested", "list", "is", "a", "row", "return", "a", "List", "of", "columns", "instead", "." ]

[ "def", "rotate", "(", "count", "=", "1", ")", "raise", "Erlang", "::", "ImproperListError", "if", "improper?", "raise", "TypeError", ",", "\"expected Integer\"", "if", "not", "count", ".", "is_a?", "(", "Integer", ")", "return", "self", "if", "empty?", "||", "(", "count", "%", "size", ")", "==", "0", "count", "=", "(", "count", ">=", "0", ")", "?", "count", "%", "size", ":", "(", "size", "-", "(", "~", "count", "%", "size", ")", "-", "1", ")", "return", "drop", "(", "count", ")", ".", "append", "(", "take", "(", "count", ")", ")", "end" ]

[ "Return", "a", "new", "List", "with", "the", "same", "elements", "but", "rotated", "so", "that", "the", "one", "at", "index", "count", "is", "the", "first", "element", "of", "the", "new", "list", ".", "If", "count", "is", "positive", "the", "elements", "will", "be", "shifted", "left", "and", "those", "shifted", "past", "the", "lowest", "position", "will", "be", "moved", "to", "the", "end", ".", "If", "count", "is", "negative", "the", "elements", "will", "be", "shifted", "right", "and", "those", "shifted", "past", "the", "last", "position", "will", "be", "moved", "to", "the", "beginning", "." ]

[ "def", "sort", "(", "&", "comparator", ")", "comparator", "=", "Erlang", ".", "method", "(", ":compare", ")", "unless", "block_given?", "array", "=", "super", "(", "comparator", ")", "return", "List", ".", "from_enum", "(", "array", ")", "end" ]

[ "Return", "a", "new", "List", "with", "the", "same", "items", "but", "sorted", "." ]

[ "def", "intersperse", "(", "sep", ")", "raise", "Erlang", "::", "ImproperListError", "if", "improper?", "return", "self", "if", "tail", ".", "empty?", "sep", "=", "Erlang", ".", "from", "(", "sep", ")", "out", "=", "tail", "=", "Erlang", "::", "Cons", ".", "allocate", "list", "=", "self", "until", "list", ".", "empty?", "new_node", "=", "Erlang", "::", "Cons", ".", "allocate", "new_node", ".", "instance_variable_set", "(", ":@head", ",", "list", ".", "head", ")", "new_node", ".", "instance_variable_set", "(", ":@improper", ",", "false", ")", "if", "not", "list", ".", "tail", ".", "empty?", "sep_node", "=", "Erlang", "::", "Cons", ".", "allocate", "sep_node", ".", "instance_variable_set", "(", ":@head", ",", "sep", ")", "sep_node", ".", "instance_variable_set", "(", ":@improper", ",", "false", ")", "new_node", ".", "instance_variable_set", "(", ":@tail", ",", "sep_node", ")", "new_node", ".", "immutable!", "end", "tail", ".", "instance_variable_set", "(", ":@tail", ",", "new_node", ")", "tail", ".", "instance_variable_set", "(", ":@improper", ",", "false", ")", "tail", ".", "immutable!", "if", "list", ".", "tail", ".", "empty?", "tail", "=", "new_node", "else", "tail", "=", "new_node", ".", "tail", "end", "list", "=", "list", ".", "tail", "end", "if", "not", "tail", ".", "immutable?", "tail", ".", "instance_variable_set", "(", ":@tail", ",", "Erlang", "::", "Nil", ")", "tail", ".", "immutable!", "end", "return", "out", ".", "tail", "end" ]

[ "Return", "a", "new", "List", "with", "sep", "inserted", "between", "each", "of", "the", "existing", "elements", "." ]

[ "def", "union", "(", "other", ")", "raise", "Erlang", "::", "ImproperListError", "if", "improper?", "other", "=", "Erlang", ".", "from", "(", "other", ")", "raise", "ArgumentError", ",", "\"other must be of Erlang::List type\"", "if", "not", "Erlang", ".", "is_list", "(", "other", ")", "raise", "Erlang", "::", "ImproperListError", "if", "other", ".", "improper?", "items", "=", "::", "Set", ".", "new", "return", "_uniq", "(", "items", ")", ".", "append", "(", "other", ".", "_uniq", "(", "items", ")", ")", "end" ]

[ "Return", "a", "List", "with", "all", "the", "elements", "from", "both", "this", "list", "and", "other", "with", "all", "duplicates", "removed", "." ]

[ "def", "init", "raise", "Erlang", "::", "ImproperListError", "if", "improper?", "return", "Erlang", "::", "Nil", "if", "tail", ".", "empty?", "out", "=", "tail", "=", "Erlang", "::", "Cons", ".", "allocate", "list", "=", "self", "until", "list", ".", "tail", ".", "empty?", "new_node", "=", "Erlang", "::", "Cons", ".", "allocate", "new_node", ".", "instance_variable_set", "(", ":@head", ",", "list", ".", "head", ")", "new_node", ".", "instance_variable_set", "(", ":@improper", ",", "false", ")", "tail", ".", "instance_variable_set", "(", ":@tail", ",", "new_node", ")", "tail", ".", "instance_variable_set", "(", ":@improper", ",", "false", ")", "tail", ".", "immutable!", "tail", "=", "new_node", "list", "=", "list", ".", "tail", "end", "if", "not", "tail", ".", "immutable?", "tail", ".", "instance_variable_set", "(", ":@tail", ",", "Erlang", "::", "Nil", ")", "tail", ".", "immutable!", "end", "return", "out", ".", "tail", "end" ]

[ "Return", "a", "List", "with", "all", "elements", "except", "the", "last", "one", "." ]

[ "def", "last", "(", "allow_improper", "=", "false", ")", "if", "allow_improper", "and", "improper?", "list", "=", "self", "list", "=", "list", ".", "tail", "while", "list", ".", "tail", ".", "kind_of?", "(", "Erlang", "::", "List", ")", "return", "list", ".", "tail", "else", "raise", "Erlang", "::", "ImproperListError", "if", "improper?", "list", "=", "self", "list", "=", "list", ".", "tail", "until", "list", ".", "tail", ".", "empty?", "return", "list", ".", "head", "end", "end" ]

[ "Return", "the", "last", "item", "in", "this", "list", "." ]

[ "def", "tails", "raise", "Erlang", "::", "ImproperListError", "if", "improper?", "return", "self", "if", "empty?", "out", "=", "tail", "=", "Erlang", "::", "Cons", ".", "allocate", "list", "=", "self", "until", "list", ".", "empty?", "new_node", "=", "Erlang", "::", "Cons", ".", "allocate", "new_node", ".", "instance_variable_set", "(", ":@head", ",", "list", ")", "new_node", ".", "instance_variable_set", "(", ":@improper", ",", "false", ")", "tail", ".", "instance_variable_set", "(", ":@tail", ",", "new_node", ")", "list", "=", "list", ".", "tail", "tail", "=", "new_node", "end", "tail", ".", "instance_variable_set", "(", ":@tail", ",", "Erlang", "::", "Nil", ")", "return", "out", ".", "tail", "end" ]

[ "Return", "a", "List", "of", "all", "suffixes", "of", "this", "list", "." ]

[ "def", "inits", "raise", "Erlang", "::", "ImproperListError", "if", "improper?", "return", "self", "if", "empty?", "prev", "=", "nil", "return", "map", "do", "|", "head", "|", "if", "prev", ".", "nil?", "Erlang", "::", "List", ".", "from_enum", "(", "prev", "=", "[", "head", "]", ")", "else", "Erlang", "::", "List", ".", "from_enum", "(", "prev", ".", "push", "(", "head", ")", ")", "end", "end", "end" ]

[ "Return", "a", "List", "of", "all", "prefixes", "of", "this", "list", "." ]

[ "def", "combination", "(", "n", ")", "raise", "Erlang", "::", "ImproperListError", "if", "improper?", "return", "Erlang", "::", "Cons", ".", "new", "(", "Erlang", "::", "Nil", ")", "if", "n", "==", "0", "return", "self", "if", "empty?", "return", "tail", ".", "combination", "(", "n", "-", "1", ")", ".", "map", "{", "|", "list", "|", "list", ".", "cons", "(", "head", ")", "}", ".", "append", "(", "tail", ".", "combination", "(", "n", ")", ")", "end" ]

[ "Return", "a", "List", "of", "all", "combinations", "of", "length", "n", "of", "items", "from", "this", "List", "." ]

[ "def", "chunk", "(", "number", ")", "raise", "Erlang", "::", "ImproperListError", "if", "improper?", "return", "self", "if", "empty?", "out", "=", "tail", "=", "Erlang", "::", "Cons", ".", "allocate", "list", "=", "self", "until", "list", ".", "empty?", "first", ",", "list", "=", "list", ".", "split_at", "(", "number", ")", "new_node", "=", "Erlang", "::", "Cons", ".", "allocate", "new_node", ".", "instance_variable_set", "(", ":@head", ",", "first", ")", "new_node", ".", "instance_variable_set", "(", ":@improper", ",", "false", ")", "tail", ".", "instance_variable_set", "(", ":@tail", ",", "new_node", ")", "tail", ".", "instance_variable_set", "(", ":@improper", ",", "false", ")", "tail", ".", "immutable!", "tail", "=", "new_node", "end", "if", "not", "tail", ".", "immutable?", "tail", ".", "instance_variable_set", "(", ":@tail", ",", "Erlang", "::", "Nil", ")", "tail", ".", "immutable!", "end", "return", "out", ".", "tail", "end" ]

[ "Split", "the", "items", "in", "this", "list", "in", "groups", "of", "number", ".", "Return", "a", "list", "of", "lists", "." ]

[ "def", "flatten", "raise", "Erlang", "::", "ImproperListError", "if", "improper?", "return", "self", "if", "empty?", "out", "=", "tail", "=", "Erlang", "::", "Cons", ".", "allocate", "list", "=", "self", "until", "list", ".", "empty?", "if", "list", ".", "head", ".", "is_a?", "(", "Erlang", "::", "Cons", ")", "list", "=", "list", ".", "head", ".", "append", "(", "list", ".", "tail", ")", "elsif", "Erlang", "::", "Nil", ".", "equal?", "(", "list", ".", "head", ")", "list", "=", "list", ".", "tail", "else", "new_node", "=", "Erlang", "::", "Cons", ".", "allocate", "new_node", ".", "instance_variable_set", "(", ":@head", ",", "list", ".", "head", ")", "new_node", ".", "instance_variable_set", "(", ":@improper", ",", "false", ")", "tail", ".", "instance_variable_set", "(", ":@tail", ",", "new_node", ")", "tail", ".", "immutable!", "list", "=", "list", ".", "tail", "tail", "=", "new_node", "end", "end", "if", "not", "tail", ".", "immutable?", "tail", ".", "instance_variable_set", "(", ":@tail", ",", "Erlang", "::", "Nil", ")", "tail", ".", "immutable!", "end", "return", "out", ".", "tail", "end" ]

[ "Return", "a", "new", "List", "with", "all", "nested", "lists", "recursively", "flattened", "out", "that", "is", "their", "elements", "inserted", "into", "the", "new", "List", "in", "the", "place", "where", "the", "nested", "list", "originally", "was", "." ]

[ "def", "slice", "(", "arg", ",", "length", "=", "(", "missing_length", "=", "true", ")", ")", "raise", "Erlang", "::", "ImproperListError", "if", "improper?", "if", "missing_length", "if", "arg", ".", "is_a?", "(", "Range", ")", "from", ",", "to", "=", "arg", ".", "begin", ",", "arg", ".", "end", "from", "+=", "size", "if", "from", "<", "0", "return", "nil", "if", "from", "<", "0", "to", "+=", "size", "if", "to", "<", "0", "to", "+=", "1", "if", "!", "arg", ".", "exclude_end?", "length", "=", "to", "-", "from", "length", "=", "0", "if", "length", "<", "0", "list", "=", "self", "while", "from", ">", "0", "return", "nil", "if", "list", ".", "empty?", "list", "=", "list", ".", "tail", "from", "-=", "1", "end", "return", "list", ".", "take", "(", "length", ")", "else", "return", "at", "(", "arg", ")", "end", "else", "return", "nil", "if", "length", "<", "0", "arg", "+=", "size", "if", "arg", "<", "0", "return", "nil", "if", "arg", "<", "0", "list", "=", "self", "while", "arg", ">", "0", "return", "nil", "if", "list", ".", "empty?", "list", "=", "list", ".", "tail", "arg", "-=", "1", "end", "return", "list", ".", "take", "(", "length", ")", "end", "end" ]

[ "Return", "specific", "objects", "from", "the", "List", ".", "All", "overloads", "return", "nil", "if", "the", "starting", "index", "is", "out", "of", "range", "." ]

[ "def", "indices", "(", "object", "=", "Erlang", "::", "Undefined", ",", "i", "=", "0", ",", "&", "block", ")", "raise", "Erlang", "::", "ImproperListError", "if", "improper?", "object", "=", "Erlang", ".", "from", "(", "object", ")", "if", "object", "!=", "Erlang", "::", "Undefined", "return", "indices", "{", "|", "item", "|", "item", "==", "object", "}", "if", "not", "block_given?", "return", "Erlang", "::", "Nil", "if", "empty?", "out", "=", "tail", "=", "Erlang", "::", "Cons", ".", "allocate", "list", "=", "self", "until", "list", ".", "empty?", "if", "yield", "(", "list", ".", "head", ")", "new_node", "=", "Erlang", "::", "Cons", ".", "allocate", "new_node", ".", "instance_variable_set", "(", ":@head", ",", "i", ")", "new_node", ".", "instance_variable_set", "(", ":@improper", ",", "false", ")", "tail", ".", "instance_variable_set", "(", ":@tail", ",", "new_node", ")", "tail", ".", "instance_variable_set", "(", ":@improper", ",", "false", ")", "tail", ".", "immutable!", "tail", "=", "new_node", "list", "=", "list", ".", "tail", "else", "list", "=", "list", ".", "tail", "end", "i", "+=", "1", "end", "if", "not", "tail", ".", "immutable?", "tail", ".", "instance_variable_set", "(", ":@tail", ",", "Erlang", "::", "Nil", ")", "tail", ".", "immutable!", "end", "return", "out", ".", "tail", "end" ]

[ "Return", "a", "List", "of", "indices", "of", "matching", "objects", "." ]

[ "def", "merge", "(", "&", "comparator", ")", "raise", "Erlang", "::", "ImproperListError", "if", "improper?", "return", "merge_by", "unless", "block_given?", "sorted", "=", "reject", "(", ":empty?", ")", ".", "sort", "do", "|", "a", ",", "b", "|", "yield", "(", "a", ".", "head", ",", "b", ".", "head", ")", "end", "return", "Erlang", "::", "Nil", "if", "sorted", ".", "empty?", "return", "Erlang", "::", "Cons", ".", "new", "(", "sorted", ".", "head", ".", "head", ",", "sorted", ".", "tail", ".", "cons", "(", "sorted", ".", "head", ".", "tail", ")", ".", "merge", "(", "comparator", ")", ")", "end" ]

[ "Merge", "all", "the", "nested", "lists", "into", "a", "single", "list", "using", "the", "given", "comparator", "block", "to", "determine", "the", "order", "which", "items", "should", "be", "shifted", "out", "of", "the", "nested", "lists", "and", "into", "the", "output", "list", "." ]

[ "def", "insert", "(", "index", ",", "*", "items", ")", "raise", "Erlang", "::", "ImproperListError", "if", "improper?", "if", "index", "==", "0", "return", "Erlang", "::", "List", ".", "from_enum", "(", "items", ")", ".", "append", "(", "self", ")", "elsif", "index", ">", "0", "out", "=", "tail", "=", "Erlang", "::", "Cons", ".", "allocate", "list", "=", "self", "while", "index", ">", "0", "new_node", "=", "Erlang", "::", "Cons", ".", "allocate", "new_node", ".", "instance_variable_set", "(", ":@head", ",", "list", ".", "head", ")", "new_node", ".", "instance_variable_set", "(", ":@improper", ",", "false", ")", "tail", ".", "instance_variable_set", "(", ":@tail", ",", "new_node", ")", "tail", ".", "instance_variable_set", "(", ":@improper", ",", "false", ")", "tail", ".", "immutable!", "tail", "=", "new_node", "list", "=", "list", ".", "tail", "index", "-=", "1", "end", "if", "not", "tail", ".", "immutable?", "tail", ".", "instance_variable_set", "(", ":@tail", ",", "Erlang", "::", "List", ".", "from_enum", "(", "items", ")", ".", "append", "(", "list", ")", ")", "tail", ".", "immutable!", "end", "return", "out", ".", "tail", "else", "raise", "IndexError", "if", "index", "<", "-", "size", "return", "insert", "(", "index", "+", "size", ",", "items", ")", "end", "end" ]

[ "Return", "a", "new", "List", "with", "the", "given", "items", "inserted", "before", "the", "item", "at", "index", "." ]

[ "def", "delete_at", "(", "index", ")", "raise", "Erlang", "::", "ImproperListError", "if", "improper?", "if", "index", "==", "0", "tail", "elsif", "index", "<", "0", "index", "+=", "size", "if", "index", "<", "0", "return", "self", "if", "index", "<", "0", "delete_at", "(", "index", ")", "else", "out", "=", "tail", "=", "Erlang", "::", "Cons", ".", "allocate", "list", "=", "self", "while", "index", ">", "0", "new_node", "=", "Erlang", "::", "Cons", ".", "allocate", "new_node", ".", "instance_variable_set", "(", ":@head", ",", "list", ".", "head", ")", "new_node", ".", "instance_variable_set", "(", ":@improper", ",", "false", ")", "tail", ".", "instance_variable_set", "(", ":@tail", ",", "new_node", ")", "tail", ".", "instance_variable_set", "(", ":@improper", ",", "false", ")", "tail", ".", "immutable!", "tail", "=", "new_node", "list", "=", "list", ".", "tail", "index", "-=", "1", "end", "if", "not", "tail", ".", "immutable?", "tail", ".", "instance_variable_set", "(", ":@tail", ",", "list", ".", "tail", ")", "tail", ".", "immutable!", "end", "return", "out", ".", "tail", "end", "end" ]

[ "Return", "a", "List", "containing", "the", "same", "items", "minus", "the", "one", "at", "index", ".", "If", "index", "is", "negative", "it", "counts", "back", "from", "the", "end", "of", "the", "list", "." ]

[ "def", "permutation", "(", "length", "=", "size", ",", "&", "block", ")", "raise", "Erlang", "::", "ImproperListError", "if", "improper?", "return", "enum_for", "(", ":permutation", ",", "length", ")", "if", "not", "block_given?", "if", "length", "==", "0", "yield", "Erlang", "::", "Nil", "elsif", "length", "==", "1", "each", "{", "|", "obj", "|", "yield", "Erlang", "::", "Cons", ".", "new", "(", "obj", ",", "Erlang", "::", "Nil", ")", "}", "elsif", "not", "empty?", "if", "length", "<", "size", "tail", ".", "permutation", "(", "length", ",", "block", ")", "end", "tail", ".", "permutation", "(", "length", "-", "1", ")", "do", "|", "p", "|", "0", ".", "upto", "(", "length", "-", "1", ")", "do", "|", "i", "|", "left", ",", "right", "=", "p", ".", "split_at", "(", "i", ")", "yield", "left", ".", "append", "(", "right", ".", "cons", "(", "head", ")", ")", "end", "end", "end", "return", "self", "end" ]

[ "Yields", "all", "permutations", "of", "length", "n", "of", "the", "items", "in", "the", "list", "and", "then", "returns", "self", ".", "If", "no", "length", "n", "is", "specified", "permutations", "of", "the", "entire", "list", "will", "be", "yielded", "." ]

[ "def", "partition", "(", "&", "block", ")", "raise", "Erlang", "::", "ImproperListError", "if", "improper?", "return", "enum_for", "(", ":partition", ")", "if", "not", "block_given?", "left", "=", "left_tail", "=", "Erlang", "::", "Cons", ".", "allocate", "right", "=", "right_tail", "=", "Erlang", "::", "Cons", ".", "allocate", "list", "=", "self", "while", "!", "list", ".", "empty?", "if", "yield", "(", "list", ".", "head", ")", "new_node", "=", "Erlang", "::", "Cons", ".", "allocate", "new_node", ".", "instance_variable_set", "(", ":@head", ",", "list", ".", "head", ")", "new_node", ".", "instance_variable_set", "(", ":@improper", ",", "false", ")", "left_tail", ".", "instance_variable_set", "(", ":@tail", ",", "new_node", ")", "left_tail", ".", "instance_variable_set", "(", ":@improper", ",", "false", ")", "left_tail", ".", "immutable!", "left_tail", "=", "new_node", "list", "=", "list", ".", "tail", "else", "new_node", "=", "Erlang", "::", "Cons", ".", "allocate", "new_node", ".", "instance_variable_set", "(", ":@head", ",", "list", ".", "head", ")", "new_node", ".", "instance_variable_set", "(", ":@improper", ",", "false", ")", "right_tail", ".", "instance_variable_set", "(", ":@tail", ",", "new_node", ")", "right_tail", ".", "instance_variable_set", "(", ":@improper", ",", "false", ")", "right_tail", ".", "immutable!", "right_tail", "=", "new_node", "list", "=", "list", ".", "tail", "end", "end", "if", "not", "left_tail", ".", "immutable?", "left_tail", ".", "instance_variable_set", "(", ":@tail", ",", "Erlang", "::", "Nil", ")", "left_tail", ".", "immutable!", "end", "if", "not", "right_tail", ".", "immutable?", "right_tail", ".", "instance_variable_set", "(", ":@tail", ",", "Erlang", "::", "Nil", ")", "right_tail", ".", "immutable!", "end", "return", "Erlang", "::", "Tuple", "[", "left", ".", "tail", ",", "right", ".", "tail", "]", "end" ]

[ "Return", "two", "List", "s", "the", "first", "containing", "all", "the", "elements", "for", "which", "the", "block", "evaluates", "to", "true", "the", "second", "containing", "the", "rest", "." ]

[ "def", "inspect", "if", "improper?", "result", "=", "'Erlang::List['", "list", "=", "to_proper_list", "list", ".", "each_with_index", "{", "|", "obj", ",", "i", "|", "result", "<<", "', '", "if", "i", ">", "0", ";", "result", "<<", "obj", ".", "inspect", "}", "result", "<<", "']'", "result", "<<", "\" + #{last(true).inspect}\"", "return", "result", "else", "result", "=", "'['", "list", "=", "self", "list", ".", "each_with_index", "{", "|", "obj", ",", "i", "|", "result", "<<", "', '", "if", "i", ">", "0", ";", "result", "<<", "obj", ".", "inspect", "}", "result", "<<", "']'", "return", "result", "end", "end" ]

[ "Return", "the", "contents", "of", "this", "List", "as", "a", "programmer", "-", "readable", "String", ".", "If", "all", "the", "items", "in", "the", "list", "are", "serializable", "as", "Ruby", "literal", "strings", "the", "returned", "string", "can", "be", "passed", "to", "eval", "to", "reconstitute", "an", "equivalent", "List", "." ]

[ "def", "copy", "(", "n", "=", "1", ")", "raise", "ArgumentError", ",", "'n must be a non-negative Integer'", "if", "not", "n", ".", "is_a?", "(", "::", "Integer", ")", "or", "n", "<", "0", "return", "self", "if", "n", "==", "1", "return", "Erlang", "::", "Binary", "[", "(", "@data", "*", "n", ")", "]", "end" ]

[ "Returns", "a", "new", "Binary", "containing", "n", "copies", "of", "itself", ".", "n", "must", "be", "greater", "than", "or", "equal", "to", "0", "." ]

[ "def", "each_bit", "return", "enum_for", "(", ":each_bit", ")", "unless", "block_given?", "index", "=", "0", "bitsize", "=", "self", ".", "bitsize", "@data", ".", "each_byte", "do", "|", "byte", "|", "loop", "do", "break", "if", "index", "==", "bitsize", "bit", "=", "(", "byte", ">>", "(", "7", "-", "(", "index", "&", "7", ")", ")", ")", "&", "1", "yield", "bit", "index", "+=", "1", "break", "if", "(", "index", "&", "7", ")", "==", "0", "end", "end", "return", "self", "end" ]

[ "Call", "the", "given", "block", "once", "for", "each", "bit", "in", "the", "Binary", "passing", "each", "bit", "from", "first", "to", "last", "successively", "to", "the", "block", ".", "If", "no", "block", "is", "given", "returns", "an", "Enumerator", "." ]

[ "def", "part", "(", "position", ",", "length", ")", "raise", "ArgumentError", ",", "'position must be an Integer'", "if", "not", "position", ".", "is_a?", "(", "::", "Integer", ")", "raise", "ArgumentError", ",", "'length must be a non-negative Integer'", "if", "not", "length", ".", "is_a?", "(", "::", "Integer", ")", "or", "length", "<", "0", "return", "Erlang", "::", "Binary", "[", "@data", ".", "byteslice", "(", "position", ",", "length", ")", "]", "end" ]

[ "Returns", "the", "section", "of", "this", "Binary", "starting", "at", "position", "of", "length", "." ]

[ "def", "wait_until", "time_to_wait", "=", "30", ",", "&", "block", "time_limit", "=", "Time", ".", "now", "+", "time_to_wait", "until", "block", ".", "call", "if", "Time", ".", "now", ">", "time_limit", "raise", "\"wait_until timeout after #{time_to_wait} seconds\"", "end", "sleep", "0.1", "end", "true", "end" ]

[ "Calls", "the", "block", "until", "it", "returns", "true", "or", "+", "time_to_wait", "+", "is", "reached", ".", "+", "time_to_wait", "+", "is", "30", "seconds", "by", "default" ]

[ "def", "confirm", "(", "bool", ",", "&", "block", ")", "blk", "=", "\"lambda { #{bool} }\"", "self", ".", "send_remote", "(", ":add_listener", ",", ":confirm", ")", "{", "blk", "}", "block", ".", "call", "self", ".", "send_remote", "(", ":remove_listener", ",", ":confirm", ",", "lambda", "{", "blk", "}", ")", "end" ]

[ "Specify", "whether", "to", "accept", "or", "reject", "all", "confirm", "js", "dialogs", "for", "the", "code", "in", "the", "block", "that", "s", "run", "." ]

[ "def", "bind", "(", "client", ")", "if", "self", ".", "class", ".", "const_defined?", "(", ":WithClient", ")", "mod", "=", "self", ".", "class", ".", "const_get", "(", ":WithClient", ")", "else", "mod", "=", "Page", "::", "WithClient", "end", "unless", "singleton_class", ".", "include?", "(", "mod", ")", "extend", "(", "mod", ")", "end", "self", ".", "client", "=", "client", "self", "end" ]

[ "Bind", "+", "self", "+", "to", "+", "client", "+" ]

[ "def", "login", "(", "pixiv_id", ",", "password", ")", "doc", "=", "agent", ".", "get", "(", "\"https://accounts.pixiv.net/login?lang=ja&source=pc&view_type=page\"", ")", "return", "if", "doc", "&&", "doc", ".", "body", "=~", "/", "/", "form", "=", "doc", ".", "forms_with", "(", "action", ":", "'/login'", ")", ".", "first", "puts", "doc", ".", "body", "and", "raise", "Error", "::", "LoginFailed", ",", "'login form is not available'", "unless", "form", "form", ".", "pixiv_id", "=", "pixiv_id", "form", ".", "password", "=", "password", "doc", "=", "agent", ".", "submit", "(", "form", ")", "raise", "Error", "::", "LoginFailed", "unless", "doc", "&&", "doc", ".", "body", "=~", "/", "/", "@member_id", "=", "member_id_from_mypage", "(", "doc", ")", "end" ]

[ "A", "new", "instance", "of", "Client", "logged", "in", "with", "the", "given", "credentials" ]

[ "def", "download_illust", "(", "illust", ",", "io_or_filename", ",", "size", "=", ":original", ")", "size", "=", "{", ":s", "=>", ":small", ",", ":m", "=>", ":medium", ",", ":o", "=>", ":original", "}", "[", "size", "]", "||", "size", "url", "=", "illust", ".", "__send__", "(", "\"#{size}_image_url\"", ")", "referer", "=", "case", "size", "when", ":small", "then", "nil", "when", ":medium", "then", "illust", ".", "url", "when", ":original", "then", "illust", ".", "url", "else", "raise", "ArgumentError", ",", "\"unknown size `#{size}`\"", "end", "save_to", "=", "io_or_filename", "if", "save_to", ".", "is_a?", "(", "Array", ")", "save_to", "=", "filename_from_pattern", "(", "save_to", ",", "illust", ",", "url", ")", "end", "FileUtils", ".", "mkdir_p", "(", "File", ".", "dirname", "(", "save_to", ")", ")", "unless", "save_to", ".", "respond_to?", "(", ":write", ")", "@agent", ".", "download", "(", "url", ",", "save_to", ",", "[", "]", ",", "referer", ")", "end" ]

[ "Downloads", "the", "image", "to", "+", "io_or_filename", "+" ]

[ "def", "download_manga", "(", "illust", ",", "pattern", ",", "&", "block", ")", "action", "=", "DownloadActionRegistry", ".", "new", "(", "block", ")", "illust", ".", "original_image_urls", ".", "each_with_index", "do", "|", "url", ",", "n", "|", "begin", "action", ".", "before_each", ".", "call", "(", "url", ",", "n", ")", "if", "action", ".", "before_each", "filename", "=", "filename_from_pattern", "(", "pattern", ",", "illust", ",", "url", ")", "FileUtils", ".", "mkdir_p", "(", "File", ".", "dirname", "(", "filename", ")", ")", "@agent", ".", "download", "(", "url", ",", "filename", ",", "[", "]", ",", "illust", ".", "original_image_referer", ")", "action", ".", "after_each", ".", "call", "(", "url", ",", "n", ")", "if", "action", ".", "after_each", "rescue", "action", ".", "on_error", "?", "action", ".", "on_error", ".", "call", "(", "$!", ")", ":", "raise", "end", "end", "end" ]

[ "Downloads", "the", "images", "to", "+", "pattern", "+" ]

[ "def", "filename_from_pattern", "(", "pattern", ",", "illust", ",", "url", ")", "pattern", ".", "map", "{", "|", "i", "|", "if", "i", "==", ":image_name", "name", "=", "File", ".", "basename", "(", "url", ")", "if", "name", "=~", "/", "\\.", "\\w", "\\?", "\\d", "/", "name", "+=", "'.'", "+", "$1", "end", "name", "elsif", "i", ".", "is_a?", "(", "Symbol", ")", "then", "illust", ".", "send", "(", "i", ")", "elsif", "i", ".", "respond_to?", "(", ":call", ")", "then", "i", ".", "call", "(", "illust", ")", "else", "i", "end", "}", ".", "join", "(", "''", ")", "end" ]

[ "Generate", "filename", "from", "+", "pattern", "+", "in", "context", "of", "+", "illust", "+", "and", "+", "url", "+" ]

[ "def", "soa", "# return the first SOA we find in the records array.", "rr", "=", "@records", ".", "find", "{", "|", "rr", "|", "rr", ".", "type", "==", "\"SOA\"", "}", "return", "rr", "if", "rr", "# otherwise create a new SOA", "rr", "=", "DNS", "::", "Zone", "::", "RR", "::", "SOA", ".", "new", "rr", ".", "serial", "=", "Time", ".", "now", ".", "utc", ".", "strftime", "(", "\"%Y%m%d01\"", ")", "rr", ".", "refresh_ttl", "=", "'3h'", "rr", ".", "retry_ttl", "=", "'15m'", "rr", ".", "expiry_ttl", "=", "'4w'", "rr", ".", "minimum_ttl", "=", "'30m'", "# store and return new SOA", "@records", "<<", "rr", "return", "rr", "end" ]

[ "Create", "an", "empty", "instance", "of", "a", "DNS", "zone", "that", "you", "can", "drive", "programmatically", "." ]

[ "def", "dump_pretty", "content", "=", "[", "]", "last_type", "=", "\"SOA\"", "sorted_records", ".", "each", "do", "|", "rr", "|", "content", "<<", "''", "if", "last_type", "!=", "rr", ".", "type", "content", "<<", "rr", ".", "dump", "last_type", "=", "rr", ".", "type", "end", "content", ".", "join", "(", "\"\\n\"", ")", "<<", "\"\\n\"", "end" ]

[ "Generates", "pretty", "output", "of", "the", "zone", "and", "its", "records", "." ]

[ "def", "sorted_records", "# pull out RRs we want to stick near the top", "top_rrs", "=", "{", "}", "top", "=", "%w{", "SOA", "NS", "MX", "SPF", "TXT", "}", "top", ".", "each", "{", "|", "t", "|", "top_rrs", "[", "t", "]", "=", "@records", ".", "select", "{", "|", "rr", "|", "rr", ".", "type", "==", "t", "}", "}", "remaining", "=", "@records", ".", "reject", "{", "|", "rr", "|", "top", ".", "include?", "(", "rr", ".", "type", ")", "}", "# sort remaining RRs by type, alphabeticly", "remaining", ".", "sort!", "{", "|", "a", ",", "b", "|", "a", ".", "type", "<=>", "b", ".", "type", "}", "top_rrs", ".", "values", ".", "flatten", "+", "remaining", "end" ]

[ "Records", "sorted", "with", "more", "important", "types", "being", "at", "the", "top", "." ]

[ "def", "update_in", "(", "*", "key_path", ",", "&", "block", ")", "if", "key_path", ".", "empty?", "raise", "ArgumentError", ",", "\"must have at least one key in path\"", "end", "key", "=", "key_path", "[", "0", "]", "if", "key_path", ".", "size", "==", "1", "new_value", "=", "block", ".", "call", "(", "fetch", "(", "key", ",", "nil", ")", ")", "else", "value", "=", "fetch", "(", "key", ",", "EmptyMap", ")", "new_value", "=", "value", ".", "update_in", "(", "key_path", "[", "1", "..", "-", "1", "]", ",", "block", ")", "end", "return", "put", "(", "key", ",", "new_value", ")", "end" ]

[ "Return", "a", "new", "container", "with", "a", "deeply", "nested", "value", "modified", "to", "the", "result", "of", "the", "given", "code", "block", ".", "When", "traversing", "the", "nested", "containers", "non", "-", "existing", "keys", "are", "created", "with", "empty", "Hash", "values", "." ]

[ "def", "dig", "(", "key", ",", "*", "rest", ")", "value", "=", "get", "(", "key", ")", "if", "rest", ".", "empty?", "||", "value", ".", "nil?", "return", "value", "elsif", "value", ".", "respond_to?", "(", ":dig", ")", "return", "value", ".", "dig", "(", "rest", ")", "end", "end" ]

[ "Return", "the", "value", "of", "successively", "indexing", "into", "a", "collection", ".", "If", "any", "of", "the", "keys", "is", "not", "present", "in", "the", "collection", "return", "nil", ".", "keys", "that", "the", "Erlang", "type", "doesn", "t", "understand", "raises", "an", "argument", "error" ]

[ "def", "download_all_data", "(", "url", ")", "next_data_indices", "=", "{", "}", "while", "next_data_indices", "html", "=", "Downloader", ".", "read_page", "(", "url", ")", "# Sometimes Pandora returns the same next_data_indices as the previous page.", "# If we don't check for this, an infinite loop occurs.", "# This problem occurs with tconrad.", "prev_next_data_indices", "=", "next_data_indices", "next_data_indices", "=", "@parser", ".", "get_next_data_indices", "(", "html", ")", "next_data_indices", "=", "false", "if", "prev_next_data_indices", "==", "next_data_indices", "url", "=", "yield", "(", "html", ",", "next_data_indices", ")", "end", "end" ]

[ "Downloads", "all", "data", "given", "a", "starting", "URL", ".", "Some", "Pandora", "feeds", "only", "return", "5", "-", "10", "items", "per", "page", "but", "contain", "a", "link", "to", "the", "next", "set", "of", "data", ".", "Threads", "cannot", "be", "used", "because", "page", "A", "be", "must", "visited", "to", "know", "how", "to", "obtain", "page", "B", "." ]

[ "def", "get_url", "(", "data_name", ",", "next_data_indices", "=", "{", "}", ")", "if", "next_data_indices", ".", "empty?", "next_data_indices", "=", "{", "nextStartIndex", ":", "0", ",", "nextLikeStartIndex", ":", "0", ",", "nextThumbStartIndex", ":", "0", "}", "else", "next_data_indices", "=", "next_data_indices", ".", "dup", "end", "next_data_indices", "[", ":webname", "]", "=", "@webname", "next_data_indices", "[", ":pat", "]", "=", "Downloader", ".", "get_pat", "DATA_FEED_URLS", "[", "data_name", "]", "%", "next_data_indices", "end" ]

[ "Grabs", "a", "URL", "from", "DATA_FEED_URLS", "and", "formats", "it", "appropriately", "." ]

[ "def", "yubikey_authenticated?", "(", "otp", ")", "if", "yubico_identity?", "&&", "Account", ".", "verify_yubico_otp", "(", "otp", ")", "(", "Account", ".", "extract_yubico_identity_from_otp", "(", "otp", ")", "==", "yubico_identity", ")", "else", "false", "end", "end" ]

[ "Is", "the", "Yubico", "OTP", "valid", "and", "belongs", "to", "this", "account?" ]

[ "def", "[]", "(", "name", ")", "enum_by_name", "(", "name", ")", ".", "each", "{", "|", "f", "|", "return", "f", ".", "value", "if", "f", ".", "value", "!=", "\"\"", "}", "enum_by_name", "(", "name", ")", ".", "each", "{", "|", "f", "|", "return", "f", ".", "value", "}", "nil", "end" ]

[ "The", "value", "of", "the", "first", "field", "named", "+", "name", "+", "or", "nil", "if", "no", "match", "is", "found", "." ]

[ "def", "push_unique", "(", "field", ")", "push", "(", "field", ")", "unless", "@fields", ".", "detect", "{", "|", "f", "|", "f", ".", "name?", "field", ".", "name", "}", "self", "end" ]

[ "Push", "+", "field", "+", "onto", "the", "fields", "unless", "there", "is", "already", "a", "field", "with", "this", "name", "." ]

[ "def", "delete", "(", "field", ")", "case", "when", "field", ".", "name?", "(", "\"BEGIN\"", ")", ",", "field", ".", "name?", "(", "\"END\"", ")", "raise", "ArgumentError", ",", "\"Cannot delete BEGIN or END fields.\"", "else", "@fields", ".", "delete", "field", "end", "self", "end" ]

[ "Delete", "+", "field", "+", "." ]

[ "def", "number", "(", "n", ")", "n", ".", "is_a?", "(", "Range", ")", "?", "n", ".", "to_a", ".", "rand", ":", "rand", "(", "n", ")", "end" ]

[ "n", "can", "be", "an", "Integer", "or", "a", "Range", ".", "If", "it", "is", "an", "Integer", "it", "just", "returns", "a", "random", "number", "greater", "than", "or", "equal", "to", "0", "and", "less", "than", "n", ".", "If", "it", "is", "a", "Range", "it", "returns", "a", "random", "number", "within", "the", "range", "Examples" ]

[ "def", "rewrite_css", "(", "css_module_code", ")", "# Parse incoming CSS into an AST", "css_root", "=", "Sass", "::", "SCSS", "::", "CssParser", ".", "new", "(", "css_module_code", ",", "\"(CSSModules)\"", ",", "1", ")", ".", "parse", "Sass", "::", "Tree", "::", "Visitors", "::", "SetOptions", ".", "visit", "(", "css_root", ",", "{", "}", ")", "ModuleVisitor", ".", "visit", "(", "css_root", ")", "css_root", ".", "render", "end" ]

[ "Take", "css", "module", "code", "as", "input", "and", "rewrite", "it", "as", "browser", "-", "friendly", "CSS", "code", ".", "Apply", "opaque", "transformations", "so", "that", "selectors", "can", "only", "be", "accessed", "programatically", "not", "by", "class", "name", "literals", "." ]

[ "def", "grammatical_construct", "(", "grammar", ",", "what", "=", "nil", ")", "output", "=", "\"\"", "if", "what", ".", "nil?", "case", "grammar", "when", "Hash", "a_key", "=", "grammar", ".", "keys", ".", "sort_by", "{", "rand", "}", "[", "0", "]", "output", "+=", "grammatical_construct", "(", "grammar", ",", "a_key", ")", "when", "Array", "grammar", ".", "each", "do", "|", "item", "|", "output", "+=", "grammatical_construct", "(", "item", ")", "end", "when", "String", "output", "+=", "grammar", "end", "else", "rhs", "=", "grammar", "[", "what", "]", "case", "rhs", "when", "Array", "rhs", ".", "each", "do", "|", "item", "|", "case", "item", "when", "Symbol", "output", "+=", "grammatical_construct", "(", "grammar", ",", "item", ")", "when", "String", "output", "+=", "item", "when", "Hash", "output", "+=", "grammatical_construct", "(", "item", ")", "else", "raise", "\"#{item.inspect} must be a symbol or string or Hash\"", "end", "end", "when", "Hash", "output", "+=", "grammatical_construct", "(", "rhs", ")", "when", "Symbol", "output", "+=", "grammatical_construct", "(", "rhs", ")", "when", "String", "output", "+=", "rhs", "else", "raise", "\"#{rhs.inspect} must be a symbol, string, Array or Hash\"", "end", "end", "return", "output", "end" ]

[ "Returns", "simple", "sentences", "based", "on", "a", "supplied", "grammar", "which", "must", "be", "a", "hash", "the", "keys", "of", "which", "are", "symbols", ".", "The", "values", "are", "either", "an", "array", "of", "successive", "values", "or", "a", "grammar", "(", "i", ".", "e", "hash", "with", "symbols", "as", "keys", "and", "hashes", "or", "arrays", "as", "values", ".", "The", "arrays", "contain", "symbols", "referencing", "the", "keys", "in", "the", "present", "grammar", "or", "strings", "to", "be", "output", ".", "The", "keys", "are", "always", "symbols", "." ]

[ "def", "endpoints_for_circle_with_radius", "(", "radius", ",", "steps", "=", "30", ")", "raise", "ArgumentError", ",", "\"Number of points has to be in range of 1..360!\"", "unless", "(", "1", "..", "360", ")", ".", "include?", "steps", "points", "=", "[", "]", "steps", ".", "times", "do", "|", "i", "|", "points", "<<", "endpoint", "(", "radius", ",", "i", "*", "360", "/", "steps", ")", "end", "points", "<<", "points", ".", "first", "points", "end" ]

[ "Returns", "ends", "poionts", "which", "will", "make", "up", "a", "circle", "around", "current", "location", "and", "have", "given", "radius" ]

[ "def", "companyname", "num", "=", "rand", "(", "5", ")", "if", "num", "==", "0", "num", "=", "1", "end", "final", "=", "num", ".", "times", ".", "collect", "{", "@@lastnames", ".", "rand", ".", "capitalize", "}", "if", "final", ".", "count", "==", "1", "\"#{final.first} #{@@company_types.rand}, #{@@incorporation_types.rand}\"", "else", "incorporation_type", "=", "rand", "(", "17", ")", "%", "2", "==", "0", "?", "@@incorporation_types", ".", "rand", ":", "nil", "company_type", "=", "rand", "(", "17", ")", "%", "2", "==", "0", "?", "@@company_types", ".", "rand", ":", "nil", "trailer", "=", "company_type", ".", "nil?", "?", "\"\"", ":", "\" #{company_type}\"", "trailer", "<<", "\", #{incorporation_type}\"", "unless", "incorporation_type", ".", "nil?", "\"#{final[0..-1].join(', ')} & #{final.last}#{trailer}\"", "end", "end" ]

[ "Returns", "a", "random", "company", "name" ]

[ "def", "base", "base", "=", "Base", ".", "new", "type", "=", "@parser", ".", "graph", ".", "fetch", "(", "\"og:type\"", ",", "\"website\"", ")", ".", "downcase", "validate_type", "type", "@parser", ".", "graph", ".", "each", "do", "|", "property", "|", "build_property", "base", ",", "property", "end", "synthesize_required_properties", "base", "drop_empty_children", "base", "validate", "base", "base", "end" ]

[ "Create", "a", "new", "builder", "." ]

[ "def", "nav", "(", "name", ",", "url", ",", "pages", "=", "nil", ",", "active", "=", "false", ")", "content_tag", ":li", ",", "link_to", "(", "name", ",", "url", ")", ",", ":class", "=>", "(", "active", "||", "(", "pages", "&&", "active_page?", "(", "pages", ")", ")", "?", "'act'", ":", "nil", ")", "end" ]

[ "Renders", "a", "navigation", "element", "and", "marks", "it", "as", "active", "where", "appropriate", ".", "See", "active_page?", "for", "details" ]

[ "def", "active_page?", "(", "pages", "=", "{", "}", ")", "is_active", "=", "pages", ".", "include?", "(", "params", "[", ":controller", "]", ")", "is_active", "=", "pages", "[", "params", "[", ":controller", "]", "]", ".", "include?", "(", "params", "[", ":action", "]", ")", "if", "is_active", "&&", "!", "pages", "[", "params", "[", ":controller", "]", "]", ".", "empty?", "is_active", "end" ]

[ "Takes", "a", "hash", "with", "pages", "and", "tells", "whether", "the", "current", "page", "is", "among", "them", ".", "The", "keys", "must", "be", "controller", "names", "and", "their", "value", "must", "be", "an", "array", "of", "action", "names", ".", "If", "the", "array", "is", "empty", "every", "action", "is", "supposed", "to", "be", "valid", "." ]