Datasets:

---

CM

/

codexglue_code2text_ruby

like 1

[ "def", "get_bits", "need", "val", "=", "@bit_bucket", "while", "@bit_count", "<", "need", "val", "|=", "(", "@input_buffer", "[", "@in_pos", "+=", "1", "]", "<<", "@bit_count", ")", "@bit_count", "+=", "8", "end", "@bit_bucket", "=", "val", ">>", "need", "@bit_count", "-=", "need", "val", "&", "(", "(", "1", "<<", "need", ")", "-", "1", ")", "end" ]

[ "returns", "need", "bits", "from", "the", "input", "buffer", "==", "Format", "Notes", "bits", "are", "stored", "LSB", "to", "MSB" ]

[ "def", "inflate", "zstring", "=", "nil", "@zstring", "=", "zstring", "unless", "zstring", ".", "nil?", "#We can't use unpack, IronRuby doesn't have it yet.", "@zstring", ".", "each_byte", "{", "|", "b", "|", "@input_buffer", "<<", "b", "}", "unless", "@rawdeflate", "then", "compression_method_and_flags", "=", "@input_buffer", "[", "@in_pos", "+=", "1", "]", "flags", "=", "@input_buffer", "[", "@in_pos", "+=", "1", "]", "#CMF and FLG, when viewed as a 16-bit unsigned integer stored inMSB order (CMF*256 + FLG), is a multiple of 31", "if", "(", "(", "compression_method_and_flags", "<<", "0x08", ")", "+", "flags", ")", "%", "31", "!=", "0", "then", "raise", "Zlib", "::", "DataError", ".", "new", "(", "\"incorrect header check\"", ")", "end", "#CM = 8 denotes the ìdeflateî compression method with a window size up to 32K. (RFC's only specify CM 8)", "compression_method", "=", "compression_method_and_flags", "&", "0x0F", "if", "compression_method", "!=", "Z_DEFLATED", "then", "raise", "Zlib", "::", "DataError", ".", "new", "(", "\"unknown compression method\"", ")", "end", "#For CM = 8, CINFO is the base-2 logarithm of the LZ77 window size,minus eight (CINFO=7 indicates a 32K window size)", "compression_info", "=", "compression_method_and_flags", ">>", "0x04", "if", "(", "compression_info", "+", "8", ")", ">", "@w_bits", "then", "raise", "Zlib", "::", "DataError", ".", "new", "(", "\"invalid window size\"", ")", "end", "preset_dictionary_flag", "=", "(", "(", "flags", "&", "0x20", ")", ">>", "0x05", ")", "==", "1", "compression_level", "=", "(", "flags", "&", "0xC0", ")", ">>", "0x06", "if", "preset_dictionary_flag", "and", "@dict", ".", "nil?", "then", "raise", "Zlib", "::", "NeedDict", ".", "new", "\"Preset dictionary needed!\"", "end", "#TODO: Add Preset dictionary support", "if", "preset_dictionary_flag", "then", "@dict_crc", "=", "@input_buffer", "[", "@in_pos", "+=", "1", "]", "<<", "24", "|", "@input_buffer", "[", "@in_pos", "+=", "1", "]", "<<", "16", "|", "@input_buffer", "[", "@in_pos", "+=", "1", "]", "<<", "8", "|", "@input_buffer", "[", "@in_pos", "+=", "1", "]", "end", "end", "last_block", "=", "false", "#Begin processing DEFLATE stream", "until", "last_block", "last_block", "=", "(", "get_bits", "(", "1", ")", "==", "1", ")", "block_type", "=", "get_bits", "(", "2", ")", "case", "block_type", "when", "0", "then", "no_compression", "when", "1", "then", "fixed_codes", "when", "2", "then", "dynamic_codes", "when", "3", "then", "raise", "Zlib", "::", "DataError", ".", "new", "(", "\"invalid block type\"", ")", "end", "end", "finish", "end" ]

[ "==", "Example", "f", "=", "File", ".", "open", "example", ".", "z", "i", "=", "Inflate", ".", "new", "i", ".", "inflate", "f", ".", "read" ]

[ "def", "do_layout", "(", "payload", ",", "layouts", ")", "pre_render", "if", "respond_to?", "(", ":pre_render", ")", "&&", "hooks", "if", "respond_to?", "(", ":merge_payload", ")", "&&", "hooks", "old_do_layout", "(", "merge_payload", "(", "payload", ".", "dup", ")", ",", "layouts", ")", "else", "old_do_layout", "(", "payload", ",", "layouts", ")", "end", "post_render", "if", "respond_to?", "(", ":post_render", ")", "&&", "hooks", "end" ]

[ "Calls", "the", "pre_render", "method", "if", "it", "exists", "and", "then", "adds", "any", "necessary", "layouts", "to", "this", "convertible", "document", "." ]

[ "def", "site_payload", "@cached_payload", "=", "begin", "payload", "=", "old_site_payload", "site_hooks", ".", "each", "do", "|", "hook", "|", "p", "=", "hook", ".", "merge_payload", "(", "payload", ",", "self", ")", "next", "unless", "p", "&&", "p", ".", "is_a?", "(", "Hash", ")", "payload", "=", "Jekyll", "::", "Utils", ".", "deep_merge_hashes", "(", "payload", ",", "p", ")", "end", "payload", "end", "end" ]

[ "Allows", "site", "hooks", "to", "merge", "data", "into", "the", "site", "payload" ]

[ "def", "distance", "(", "coordinates", ")", "coordinates", "=", "coordinates", ".", "center", "if", "coordinates", ".", "respond_to?", "(", ":center", ")", "Math", ".", "sqrt", "(", "[", "center", ",", "coordinates", "]", ".", "transpose", ".", "map", "{", "|", "a", ",", "b", "|", "(", "b", "-", "a", ")", "**", "2", "}", ".", "reduce", "{", "|", "d1", ",", "d2", "|", "d1", "+", "d2", "}", ")", "end" ]

[ "Compute", "euclidien", "distance", "." ]

[ "def", "decorate", "(", "block", "=", "nil", ",", "name", ":", "\"generated\"", ",", "&", "callback", ")", "@decorations", "<<", "callback", "if", "block", "alias_name", "=", "\"__\"", "<<", "name", ".", "to_s", ".", "downcase", ".", "gsub", "(", "/", "/", ",", "?_", ")", "<<", "?1", "alias_name", "=", "alias_name", ".", "succ", "while", "private_method_defined?", "alias_name", "or", "method_defined?", "alias_name", "without_decorations", "{", "define_method", "(", "name", ",", "block", ")", "}", "alias_method", "(", "alias_name", ",", "name", ")", "remove_method", "(", "name", ")", "private", "(", "alias_name", ")", "end", "end" ]

[ "Set", "up", "a", "decoration", "." ]

[ "def", "find", "reset", ";", "return", "@images", "unless", "@url", "@page_no", "=", "@options", "[", "\"start\"", "]", "until", "@images", ".", "count", ">", "@options", "[", "\"total\"", "]", "||", "thread_has_ended?", "page", "=", "@agent", ".", "get", "\"#{@url}&page=#{@page_no}\"", "puts", "\"[VERBOSE] Searching: #{@url}&page=#{@page_no}\"", "if", "@options", "[", "\"verbose\"", "]", "&&", "options", "[", "\"cli\"", "]", "sources", "=", "page", ".", "image_urls", ".", "map", "{", "|", "x", "|", "x", ".", "to_s", "}", "sources", "=", "filter_images", "sources", "# hook for sub-classes", "@page_no", "+=", "1", "continue", "if", "sources", ".", "empty?", "sources", ".", "each", "do", "|", "source", "|", "hash", "=", "Digest", "::", "MD5", ".", "hexdigest", "(", "source", ")", "unless", "@images", ".", "has_key?", "(", "hash", ")", "@images", "[", "hash", "]", "=", "{", "url", ":", "source", "}", "puts", "source", "if", "options", "[", "\"cli\"", "]", "end", "end", "end", "@images", "=", "@images", ".", "map", "{", "|", "x", ",", "y", "|", "y", "}", "end" ]

[ "find", "images", "for", "this", "thread", "specified", "by", "starting", "page_no" ]

[ "def", "detekt", "(", "inline_mode", ":", "false", ")", "unless", "skip_gradle_task", "||", "gradlew_exists?", "fail", "(", "\"Could not find `gradlew` inside current directory\"", ")", "return", "end", "unless", "SEVERITY_LEVELS", ".", "include?", "(", "severity", ")", "fail", "(", "\"'#{severity}' is not a valid value for `severity` parameter.\"", ")", "return", "end", "system", "\"./gradlew #{gradle_task || 'detektCheck'}\"", "unless", "skip_gradle_task", "unless", "File", ".", "exist?", "(", "report_file", ")", "fail", "(", "\"Detekt report not found at `#{report_file}`. \"", "\"Have you forgot to add `xmlReport true` to your `build.gradle` file?\"", ")", "end", "issues", "=", "read_issues_from_report", "filtered_issues", "=", "filter_issues_by_severity", "(", "issues", ")", "if", "inline_mode", "# Report with inline comment", "send_inline_comment", "(", "filtered_issues", ")", "else", "message", "=", "message_for_issues", "(", "filtered_issues", ")", "markdown", "(", "\"### Detekt found issues\\n\\n\"", "+", "message", ")", "unless", "message", ".", "to_s", ".", "empty?", "end", "end" ]

[ "Calls", "Detekt", "task", "of", "your", "gradle", "project", ".", "It", "fails", "if", "gradlew", "cannot", "be", "found", "inside", "current", "directory", ".", "It", "fails", "if", "severity", "level", "is", "not", "a", "valid", "option", ".", "It", "fails", "if", "xmlReport", "configuration", "is", "not", "set", "to", "true", "in", "your", "build", ".", "gradle", "file", "." ]

[ "def", "get_builder_obj", "(", "shell_id", ",", "command_id", ",", "&", "block", ")", "body", "=", "{", "\"#{NS_WIN_SHELL}:DesiredStream\"", "=>", "'stdout stderr'", ",", ":attributes!", "=>", "{", "\"#{NS_WIN_SHELL}:DesiredStream\"", "=>", "{", "'CommandId'", "=>", "command_id", "}", "}", "}", "builder", "=", "Builder", "::", "XmlMarkup", ".", "new", "builder", ".", "instruct!", "(", ":xml", ",", ":encoding", "=>", "'UTF-8'", ")", "builder", ".", "tag!", ":env", ",", ":Envelope", ",", "namespaces", "do", "|", "env", "|", "env", ".", "tag!", "(", ":env", ",", ":Header", ")", "{", "|", "h", "|", "h", "<<", "Gyoku", ".", "xml", "(", "merge_headers", "(", "header", ",", "resource_uri_cmd", ",", "action_receive", ",", "selector_shell_id", "(", "shell_id", ")", ")", ")", "}", "env", ".", "tag!", "(", ":env", ",", ":Body", ")", "do", "|", "env_body", "|", "env_body", ".", "tag!", "(", "\"#{NS_WIN_SHELL}:Receive\"", ")", "{", "|", "cl", "|", "cl", "<<", "Gyoku", ".", "xml", "(", "body", ")", "}", "end", "end", "builder", "end" ]

[ "Override", "winrm", "to", "support", "sspinegotiate", "option", "." ]

[ "def", "get_command_output", "(", "shell_id", ",", "command_id", ",", "&", "block", ")", "done_elems", "=", "[", "]", "output", "=", "Output", ".", "new", "while", "done_elems", ".", "empty?", "resp_doc", "=", "nil", "builder", "=", "get_builder_obj", "(", "shell_id", ",", "command_id", ",", "block", ")", "request_msg", "=", "builder", ".", "target!", "resp_doc", "=", "send_get_output_message", "(", "request_msg", ")", "REXML", "::", "XPath", ".", "match", "(", "resp_doc", ",", "\"//#{NS_WIN_SHELL}:Stream\"", ")", ".", "each", "do", "|", "n", "|", "next", "if", "n", ".", "text", ".", "nil?", "||", "n", ".", "text", ".", "empty?", "stream", "=", "{", "n", ".", "attributes", "[", "'Name'", "]", ".", "to_sym", "=>", "Base64", ".", "decode64", "(", "n", ".", "text", ")", ".", "force_encoding", "(", "'utf-8'", ")", ".", "sub", "(", "\"\\xEF\\xBB\\xBF\"", ",", "\"\"", ")", "}", "output", "[", ":data", "]", "<<", "stream", "yield", "stream", "[", ":stdout", "]", ",", "stream", "[", ":stderr", "]", "if", "block_given?", "end", "# We may need to get additional output if the stream has not finished.\r", "# The CommandState will change from Running to Done like so:\r", "# @example\r", "# from...\r", "# <rsp:CommandState CommandId=\"...\" State=\"http://schemas.microsoft.com/wbem/wsman/1/windows/shell/CommandState/Running\"/>\r", "# to...\r", "# <rsp:CommandState CommandId=\"...\" State=\"http://schemas.microsoft.com/wbem/wsman/1/windows/shell/CommandState/Done\">\r", "# <rsp:ExitCode>0</rsp:ExitCode>\r", "# </rsp:CommandState>\r", "done_elems", "=", "REXML", "::", "XPath", ".", "match", "(", "resp_doc", ",", "\"//*[@State='http://schemas.microsoft.com/wbem/wsman/1/windows/shell/CommandState/Done']\"", ")", "end", "output", "[", ":exitcode", "]", "=", "REXML", "::", "XPath", ".", "first", "(", "resp_doc", ",", "\"//#{NS_WIN_SHELL}:ExitCode\"", ")", ".", "text", ".", "to_i", "output", "end" ]

[ "Get", "the", "Output", "of", "the", "given", "shell", "and", "command" ]

[ "def", "setting_attribute_is_allowed?", "(", "name", ",", "user", ")", "return", "false", "unless", "user", ".", "can_write?", "(", "self", ",", "name", ")", "(", "self", ".", "whitelisted_attributes", "&&", "self", ".", "whitelisted_attributes", ".", "has_key?", "(", "name", ".", "to_sym", ")", ")", "||", "(", "self", ".", "attribute_names", ".", "include?", "(", "name", ".", "to_s", ")", "&&", "(", "self", ".", "blacklisted_attributes", ".", "nil?", "||", "!", "self", ".", "blacklisted_attributes", ".", "has_key?", "(", "name", ".", "to_sym", ")", ")", ")", "end" ]

[ "An", "attribute", "is", "allowed", "if", "it", "s", "white", "listed", "or", "it", "s", "a", "valid", "attribute", "and", "not", "black", "listed" ]

[ "def", "turbot_api_parameters", "uri", "=", "URI", ".", "parse", "(", "host", ")", "{", ":host", "=>", "uri", ".", "host", ",", ":port", "=>", "uri", ".", "port", ",", ":scheme", "=>", "uri", ".", "scheme", ",", "}", "end" ]

[ "Returns", "the", "parameters", "for", "the", "Turbot", "API", "based", "on", "the", "base", "URL", "of", "the", "Turbot", "server", "." ]

[ "def", "handles?", "(", "device", ")", "device", "=", "Pling", ".", "_convert", "(", "device", ",", ":device", ")", "self", ".", "class", ".", "handled_types", ".", "include?", "(", "device", ".", "type", ")", "end" ]

[ "Checks", "if", "this", "gateway", "is", "able", "to", "handle", "the", "given", "device" ]

[ "def", "to_h", "ret", "=", "Hash", ".", "new", "@list", ".", "each", "do", "|", "i", "|", "ret", "[", "i", ".", "car", ".", "to_ruby", "]", "=", "i", ".", "cdr", ".", "to_ruby", "end", "ret", "end" ]

[ "alist", "-", ">", "hash" ]

[ "def", "parse", "(", "str", ")", "if", "str", ".", "nil?", "||", "str", "==", "\"\"", "raise", "ParserError", ".", "new", "(", "\"Empty input\"", ",", "0", ",", "\"\"", ")", "end", "s", "=", "StringScanner", ".", "new", "str", "@tokens", "=", "[", "]", "until", "s", ".", "eos?", "s", ".", "skip", "(", "/", "\\s", "/", ")", "?", "nil", ":", "s", ".", "scan", "(", "/", "\\A", "\\.", "/i", ")", "?", "(", "@tokens", "<<", "[", ":FLOAT", ",", "s", ".", "matched", "]", ")", ":", "s", ".", "scan", "(", "/", "\\A", "\\d", "/", ")", "?", "(", "@tokens", "<<", "[", ":INTEGER", ",", "s", ".", "matched", "]", ")", ":", "s", ".", "scan", "(", "/", "\\A", "\\.", "\\s", "/", ")", "?", "(", "@tokens", "<<", "[", "'.'", ",", "'.'", "]", ")", ":", "s", ".", "scan", "(", "/", "\\A", "\\-", "\\/", "\\-", "\\/", "/i", ")", "?", "(", "@tokens", "<<", "[", ":SYMBOL", ",", "s", ".", "matched", "]", ")", ":", "s", ".", "scan", "(", "/", "\\A", "\\\\", "\\\\", "/", ")", "?", "(", "@tokens", "<<", "[", ":STRING", ",", "_unescape_string", "(", "s", ".", "matched", ".", "slice", "(", "1", "...", "-", "1", ")", ")", "]", ")", ":", "s", ".", "scan", "(", "/", "\\A", "/", ")", "?", "(", "a", "=", "s", ".", "matched", ";", "@tokens", "<<", "[", "a", ",", "a", "]", ")", ":", "(", "raise", "ParserError", ".", "new", "(", "\"Scanner error\"", ",", "s", ".", "pos", ",", "s", ".", "peek", "(", "5", ")", ")", ")", "end", "@tokens", ".", "push", "[", "false", ",", "'END'", "]", "return", "do_parse", ".", "map", "do", "|", "i", "|", "normalize", "(", "i", ")", "end", "end" ]

[ "parse", "s", "-", "expression", "string", "and", "return", "sexp", "objects", "." ]

[ "def", "normalize", "(", "ast", ")", "if", "ast", ".", "class", "==", "SExpSymbol", "case", "ast", ".", "name", "when", "\"nil\"", "return", "SExpNil", ".", "new", "else", "return", "ast", "end", "elsif", "ast", ".", "cons?", "then", "ast", ".", "visit", "do", "|", "i", "|", "normalize", "(", "i", ")", "end", "end", "return", "ast", "end" ]

[ "replace", "special", "symbols" ]

[ "def", "write", "(", "objects", ",", "from", ":", "nil", ",", "as", ":", "nil", ")", "stream", ".", "pos", "=", "from", "if", "from", "as", "||=", "objects", ".", "class", "if", "objects", ".", "class", ".", "ancestors", ".", "include?", "(", "MemoryIO", "::", "Types", "::", "Type", ")", "return", "stream", ".", "write", "(", "objects", ")", "if", "as", ".", "nil?", "conv", "=", "to_proc", "(", "as", ",", ":write", ")", "Array", "(", "objects", ")", ".", "map", "{", "|", "o", "|", "conv", ".", "call", "(", "stream", ",", "o", ")", "}", "end" ]

[ "Write", "to", "stream", "." ]

[ "def", "underscore", "(", "str", ")", "return", "''", "if", "str", ".", "empty?", "str", "=", "str", ".", "gsub", "(", "'::'", ",", "'/'", ")", "str", ".", "gsub!", "(", "/", "/", ",", "'\\1_\\2'", ")", "str", ".", "gsub!", "(", "/", "\\d", "/", ",", "'\\1_\\2'", ")", "str", ".", "downcase!", "str", "end" ]

[ "Convert", "input", "into", "snake", "-", "case", "." ]

[ "def", "safe_eval", "(", "str", ",", "**", "vars", ")", "return", "str", "if", "str", ".", "is_a?", "(", "Integer", ")", "# dentaku 2 doesn't support hex", "str", "=", "str", ".", "gsub", "(", "/", "/", ")", "{", "|", "c", "|", "c", ".", "to_i", "(", "16", ")", "}", "Dentaku", "::", "Calculator", ".", "new", ".", "store", "(", "vars", ")", ".", "evaluate", "(", "str", ")", "end" ]

[ "Evaluate", "string", "safely", "." ]

[ "def", "unpack", "(", "str", ")", "str", ".", "bytes", ".", "reverse", ".", "reduce", "(", "0", ")", "{", "|", "s", ",", "c", "|", "s", "*", "256", "+", "c", "}", "end" ]

[ "Unpack", "a", "string", "into", "an", "integer", ".", "Little", "endian", "is", "used", "." ]

[ "def", "pack", "(", "val", ",", "b", ")", "Array", ".", "new", "(", "b", ")", "{", "|", "i", "|", "(", "val", ">>", "(", "i", "*", "8", ")", ")", "&", "0xff", "}", ".", "pack", "(", "'C*'", ")", "end" ]

[ "Pack", "an", "integer", "into", "+", "b", "+", "bytes", ".", "Little", "endian", "is", "used", "." ]

[ "def", "nearest", "(", "coord", ",", "options", "=", "{", "}", ")", "return", "nil", "if", "root", ".", "nil?", "return", "nil", "if", "coord", ".", "nil?", "results", "=", "(", "options", "[", ":results", "]", "?", "options", "[", ":results", "]", ":", "ResultSet", ".", "new", "(", "{", "limit", ":", "options", "[", ":limit", "]", "||", "1", "}", ")", ")", "root_ball", "=", "options", "[", ":root", "]", "||", "root", "# keep the stack while finding the leaf best match.", "parents", "=", "[", "]", "best_balls", "=", "[", "]", "in_target", "=", "[", "]", "# Move down to best match", "current_best", "=", "nil", "current", "=", "root_ball", "while", "current_best", ".", "nil?", "dim", "=", "current", ".", "dimension", "-", "1", "if", "(", "current", ".", "complete?", ")", "next_ball", "=", "(", "coord", "[", "dim", "]", "<=", "current", ".", "center", "[", "dim", "]", "?", "current", ".", "left", ":", "current", ".", "right", ")", "elsif", "(", "current", ".", "leaf?", ")", "next_ball", "=", "nil", "else", "next_ball", "=", "(", "current", ".", "left", ".", "nil?", "?", "current", ".", "right", ":", "current", ".", "left", ")", "end", "if", "(", "next_ball", ".", "nil?", ")", "current_best", "=", "current", "else", "parents", ".", "push", "current", "current", "=", "next_ball", "end", "end", "# Move up to check split", "parents", ".", "reverse!", "results", ".", "add", "(", "current_best", ".", "quick_distance", "(", "coord", ")", ",", "current_best", ".", "value", ")", "parents", ".", "each", "do", "|", "current_node", "|", "dist", "=", "current_node", ".", "quick_distance", "(", "coord", ")", "if", "results", ".", "eligible?", "(", "dist", ")", "results", ".", "add", "(", "dist", ",", "current_node", ".", "value", ")", "end", "dim", "=", "current_node", ".", "dimension", "-", "1", "if", "current_node", ".", "complete?", "# retrieve the splitting node.", "split_node", "=", "(", "coord", "[", "dim", "]", "<=", "current_node", ".", "center", "[", "dim", "]", "?", "current_node", ".", "right", ":", "current_node", ".", "left", ")", "best_dist", "=", "results", ".", "barrier_value", "if", "(", "(", "coord", "[", "dim", "]", "-", "current_node", ".", "center", "[", "dim", "]", ")", ".", "abs", "<=", "best_dist", ")", "# potential match, need to investigate subtree", "nearest", "(", "coord", ",", "root", ":", "split_node", ",", "results", ":", "results", ")", "end", "end", "end", "return", "results", ".", "limit", "==", "1", "?", "results", ".", "items", ".", "first", ":", "results", ".", "items", "end" ]

[ "Retrieve", "the", "nearest", "point", "from", "the", "given", "coord", "array", "." ]

[ "def", "parent_ball", "(", "coord", ")", "current", "=", "root", "d_idx", "=", "current", ".", "dimension", "-", "1", "result", "=", "nil", "while", "(", "result", ".", "nil?", ")", "if", "(", "coord", "[", "d_idx", "]", "<=", "current", ".", "center", "[", "d_idx", "]", ")", "if", "current", ".", "left", ".", "nil?", "result", "=", "current", "else", "current", "=", "current", ".", "left", "end", "else", "if", "current", ".", "right", ".", "nil?", "result", "=", "current", "else", "current", "=", "current", ".", "right", "end", "end", "d_idx", "=", "current", ".", "dimension", "-", "1", "end", "return", "result", "end" ]

[ "Retrieve", "the", "parent", "to", "which", "this", "coord", "should", "belongs", "to" ]

[ "def", "command", "(", "cmd", ",", "params", "=", "{", "}", ",", "options", "=", "''", ")", "flood_control", "out", "=", "''", "response", "=", "''", "out", "+=", "cmd", "params", ".", "each_pair", "do", "|", "key", ",", "value", "|", "out", "+=", "\" #{key}=#{encode_param(value.to_s)}\"", "end", "out", "+=", "' '", "+", "options", "@sock", ".", "puts", "out", "if", "cmd", "==", "'servernotifyregister'", "2", ".", "times", "{", "response", "+=", "@sock", ".", "gets", "}", "return", "parse_response", "(", "response", ")", "end", "loop", "do", "response", "+=", "@sock", ".", "gets", "break", "if", "response", ".", "index", "(", "' msg='", ")", "end", "# Array of commands that are expected to return as an array.", "# Not sure - clientgetids", "should_be_array", "=", "%w(", "bindinglist", "serverlist", "servergrouplist", "servergroupclientlist", "servergroupsbyclientid", "servergroupclientlist", "logview", "channellist", "channelfind", "channelgrouplist", "channelgroupclientlist", "channelgrouppermlist", "channelpermlist", "clientlist", "clientfind", "clientdblist", "clientdbfind", "channelclientpermlist", "permissionlist", "permoverview", "privilegekeylist", "messagelist", "complainlist", "banlist", "ftlist", "custominfo", "permfind", ")", "parsed_response", "=", "parse_response", "(", "response", ")", "should_be_array", ".", "include?", "(", "cmd", ")", "?", "parsed_response", ":", "parsed_response", ".", "first", "end" ]

[ "Sends", "command", "to", "the", "TeamSpeak", "3", "server", "and", "returns", "the", "response" ]

[ "def", "trh", "(", "tokens", "=", "{", "}", ",", "options", "=", "{", "}", ",", "&", "block", ")", "return", "''", "unless", "block_given?", "label", "=", "capture", "(", "block", ")", "tokenizer", "=", "Tml", "::", "Tokenizers", "::", "Dom", ".", "new", "(", "tokens", ",", "options", ")", "tokenizer", ".", "translate", "(", "label", ")", ".", "html_safe", "end" ]

[ "Translates", "HTML", "block", "noinspection", "RubyArgCount" ]

[ "def", "tml_language_flag_tag", "(", "lang", "=", "tml_current_language", ",", "opts", "=", "{", "}", ")", "return", "''", "unless", "tml_application", ".", "feature_enabled?", "(", ":language_flags", ")", "html", "=", "image_tag", "(", "lang", ".", "flag_url", ",", ":style", "=>", "(", "opts", "[", ":style", "]", "||", "'vertical-align:middle;'", ")", ",", ":title", "=>", "lang", ".", "native_name", ")", "html", "<<", "'&nbsp;&nbsp;'", ".", "html_safe", "html", ".", "html_safe", "end" ]

[ "Returns", "language", "flag" ]

[ "def", "tml_language_name_tag", "(", "lang", "=", "tml_current_language", ",", "opts", "=", "{", "}", ")", "show_flag", "=", "opts", "[", ":flag", "]", ".", "nil?", "?", "true", ":", "opts", "[", ":flag", "]", "name_type", "=", "opts", "[", ":language", "]", ".", "nil?", "?", ":english", ":", "opts", "[", ":language", "]", ".", "to_sym", "# :full, :native, :english, :locale, :both", "html", "=", "[", "]", "html", "<<", "\"<span style='white-space: nowrap'>\"", "html", "<<", "tml_language_flag_tag", "(", "lang", ",", "opts", ")", "if", "show_flag", "html", "<<", "\"<span dir='ltr'>\"", "if", "name_type", "==", ":both", "html", "<<", "lang", ".", "english_name", ".", "to_s", "html", "<<", "'<span class=\"trex-native-name\">'", "html", "<<", "lang", ".", "native_name", "html", "<<", "'</span>'", "else", "name", "=", "case", "name_type", "when", ":native", "then", "lang", ".", "native_name", "when", ":full", "then", "lang", ".", "full_name", "when", ":locale", "then", "lang", ".", "locale", "else", "lang", ".", "english_name", "end", "html", "<<", "name", ".", "to_s", "end", "html", "<<", "'</span></span>'", "html", ".", "join", ".", "html_safe", "end" ]

[ "Returns", "language", "name" ]

[ "def", "tml_language_selector_tag", "(", "type", "=", "nil", ",", "opts", "=", "{", "}", ")", "return", "unless", "Tml", ".", "config", ".", "enabled?", "type", "||=", ":default", "type", "=", ":dropdown", "if", "type", "==", ":select", "opts", "=", "opts", ".", "collect", "{", "|", "key", ",", "value", "|", "\"data-tml-#{key}='#{value}'\"", "}", ".", "join", "(", "' '", ")", "\"<div data-tml-language-selector='#{type}' #{opts}></div>\"", ".", "html_safe", "end" ]

[ "Returns", "language", "selector", "UI" ]

[ "def", "tml_style_attribute_tag", "(", "attr_name", "=", "'float'", ",", "default", "=", "'right'", ",", "lang", "=", "tml_current_language", ")", "return", "\"#{attr_name}:#{default}\"", ".", "html_safe", "if", "Tml", ".", "config", ".", "disabled?", "\"#{attr_name}:#{lang.align(default)}\"", ".", "html_safe", "end" ]

[ "Language", "Direction", "Support" ]

[ "def", "clone_and_transform_each", "(", "collection", ",", "&", "block", ")", "collection", ".", "inject", "(", "element_to_clone", ")", "do", "|", "sibling", ",", "item", "|", "item_element", "=", "clone_with_item", "(", "item", ",", "block", ")", "sibling", ".", "add_next_sibling", "(", "item_element", ")", "end", "end" ]

[ "Creates", "a", "clone", "for", "each", "item", "in", "the", "collection", "and", "yields", "it", "for", "transformation", "along", "with", "the", "corresponding", "item", ".", "The", "transformed", "clones", "are", "inserted", "after", "the", "element", "to", "clone", "." ]

[ "def", "clone_with_item", "(", "item", ",", "&", "block", ")", "item_element", "=", "element_to_clone", ".", "dup", "view", ".", "find", "(", "item_element", ")", "{", "yield", "(", "item", ")", "}", "item_element", "end" ]

[ "Creates", "a", "clone", "and", "yields", "it", "to", "the", "given", "block", "along", "with", "the", "given", "item", "." ]

[ "def", "text", "(", "selector", ",", "content", ")", "select", "(", "selector", ")", ".", "each", "do", "|", "node", "|", "node", ".", "content", "=", "content", "end", "end" ]

[ "Replaces", "the", "text", "content", "of", "the", "selected", "elements", "." ]

[ "def", "attr", "(", "selector", ",", "attributes_or_attribute_name", ",", "value", "=", "nil", ")", "attributes", "=", "attributes_or_attribute_name", ".", "to_effigy_attributes", "(", "value", ")", "select", "(", "selector", ")", ".", "each", "do", "|", "element", "|", "element", ".", "merge!", "(", "attributes", ")", "end", "end" ]

[ "Adds", "or", "updates", "the", "given", "attribute", "or", "attributes", "of", "the", "selected", "elements", "." ]

[ "def", "replace_each", "(", "selector", ",", "collection", ",", "&", "block", ")", "selected_elements", "=", "select", "(", "selector", ")", "ExampleElementTransformer", ".", "new", "(", "self", ",", "selected_elements", ")", ".", "replace_each", "(", "collection", ",", "block", ")", "end" ]

[ "Replaces", "the", "selected", "elements", "with", "a", "clone", "for", "each", "item", "in", "the", "collection", ".", "If", "multiple", "elements", "are", "selected", "only", "the", "first", "element", "will", "be", "used", "for", "cloning", ".", "All", "selected", "elements", "will", "be", "removed", "." ]

[ "def", "add_class", "(", "selector", ",", "*", "class_names", ")", "select", "(", "selector", ")", ".", "each", "do", "|", "element", "|", "class_list", "=", "ClassList", ".", "new", "(", "element", ")", "class_list", ".", "add", "class_names", "end", "end" ]

[ "Adds", "the", "given", "class", "names", "to", "the", "selected", "elements", "." ]

[ "def", "remove_class", "(", "selector", ",", "*", "class_names", ")", "select", "(", "selector", ")", ".", "each", "do", "|", "element", "|", "class_list", "=", "ClassList", ".", "new", "(", "element", ")", "class_list", ".", "remove", "(", "class_names", ")", "end", "end" ]

[ "Removes", "the", "given", "class", "names", "from", "the", "selected", "elements", "." ]

[ "def", "html", "(", "selector", ",", "inner_html", ")", "select", "(", "selector", ")", ".", "each", "do", "|", "node", "|", "node", ".", "inner_html", "=", "inner_html", "end", "end" ]

[ "Replaces", "the", "contents", "of", "the", "selected", "elements", "with", "live", "markup", "." ]

[ "def", "append", "(", "selector", ",", "html_to_append", ")", "select", "(", "selector", ")", ".", "each", "{", "|", "node", "|", "node", ".", "append_fragment", "html_to_append", "}", "end" ]

[ "Adds", "the", "given", "markup", "to", "the", "end", "of", "the", "selected", "elements", "." ]

[ "def", "find", "(", "selector", ")", "if", "block_given?", "old_context", "=", "@current_context", "@current_context", "=", "select", "(", "selector", ")", "yield", "@current_context", "=", "old_context", "else", "Selection", ".", "new", "(", "self", ",", "selector", ")", "end", "end" ]

[ "Selects", "an", "element", "or", "elements", "for", "chained", "transformation", "." ]

[ "def", "clone_element_with_item", "(", "original_element", ",", "item", ",", "&", "block", ")", "item_element", "=", "original_element", ".", "dup", "find", "(", "item_element", ")", "{", "yield", "(", "item", ")", "}", "item_element", "end" ]

[ "Clones", "an", "element", "sets", "it", "as", "the", "current", "context", "and", "yields", "to", "the", "given", "block", "with", "the", "given", "item", "." ]

[ "def", "handle_input", "(", "*", "input", ")", "while", "ch", "=", "next_ch", "(", "input", ")", "quit", "=", "QUIT_CONTROLS", ".", "include?", "(", "ch", ")", "enter", "=", "ENTER_CONTROLS", ".", "include?", "(", "ch", ")", "inc", "=", "INC_CONTROLS", ".", "include?", "(", "ch", ")", "dec", "=", "DEC_CONTROLS", ".", "include?", "(", "ch", ")", "break", "if", "shutdown?", "||", "(", "quit", "&&", "(", "!", "enter", "||", "quit_on_enter?", ")", ")", "if", "enter", "on_enter", "elsif", "inc", "on_inc", "elsif", "dec", "on_dec", "end", "if", "key_bound?", "(", "ch", ")", "invoke_key_bindings", "(", "ch", ")", "end", "on_key", "(", "ch", ")", "end", "ch", "end" ]

[ "Helper", "to", "be", "internally", "invoked", "by", "component", "on", "activation" ]

[ "def", "match", "(", "pattern_element", ")", "@num_match_attempts", "+=", "1", "return", ":no_pattern_element", "unless", "pattern_element", "return", ":skipped", "if", "pattern_element", ".", "delimiter", "&&", "(", "if", "last_match", "last_match", ".", "delimiter", "# don't match two delimiters in a row", "else", "@num_match_attempts", ">", "1", "# don't match a delimiter as the first element unless this is the first match attempt", "end", ")", "if", "result", "=", "pattern_element", ".", "parse", "(", "self", ")", "add_match", "result", ",", "pattern_element", ".", "name", "# success, but don't keep EmptyNodes", "end", "end" ]

[ "Attempts", "to", "match", "the", "pattern_element", "starting", "at", "the", "end", "of", "what", "has", "already", "been", "matched", "If", "successful", "adds", "the", "resulting", "Node", "to", "matches", ".", "returns", "nil", "on", "if", "pattern_element", "wasn", "t", "matched", ";", "non", "-", "nil", "if", "it", "was", "skipped", "or", "matched" ]

[ "def", "attempt_match", "matches_before", "=", "matches", ".", "length", "match_length_before", "=", "match_length", "(", "yield", "&&", "match_length", ">", "match_length_before", ")", ".", "tap", "do", "|", "success", "|", "# match_length test returns failure if no progress is made (our source position isn't advanced)", "unless", "success", "@matches", "=", "matches", "[", "0", "..", "matches_before", "-", "1", "]", "update_match_length", "end", "end", "end" ]

[ "a", "simple", "transaction", "-", "logs", "the", "curent", "number", "of", "matches", "if", "the", "block", "s", "result", "is", "false", "it", "discards", "all", "new", "matches" ]

[ "def", "to_canonical_s", "parts", "=", "[", "]", "parts", "<<", "self", ".", "number", ".", "upcase", "if", "self", ".", "number", "parts", "<<", "StreetAddress", ".", "string_for", "(", "self", ".", "pre_direction", ",", ":short", ")", ".", "upcase", "if", "self", ".", "pre_direction", "parts", "<<", "StreetAddress", ".", "string_for", "(", "StreetAddress", ".", "find_token", "(", "self", ".", "ordinal", ",", "ORDINALS", ")", ",", ":short", ")", ".", "upcase", "if", "self", ".", "ordinal", "canonical_name", "=", "self", ".", "name", ".", "gsub", "(", "/", "\\'", "/", ",", "''", ")", ".", "gsub", "(", "PO_BOX_PATTERN", ",", "'PO BOX'", ")", ".", "upcase", "if", "self", ".", "name", "canonical_name", ".", "gsub!", "(", "/", "/i", ",", "'RR'", ")", "if", "canonical_name", "=~", "RR_PATTERN", "# remove the original ordinal and box from the name, they are output in canonical form separately", "canonical_name", ".", "gsub!", "(", "self", ".", "ordinal", ".", "upcase", ",", "''", ")", "if", "self", ".", "ordinal", "canonical_name", ".", "gsub!", "(", "self", ".", "box_number", ",", "''", ")", "if", "self", ".", "box_number", "parts", "<<", "canonical_name", ".", "chomp", "(", "' '", ")", "if", "canonical_name", "parts", "<<", "self", ".", "box_number", "if", "self", ".", "box_number", "parts", "<<", "StreetAddress", ".", "string_for", "(", "self", ".", "suffix", ",", ":short", ")", ".", "upcase", "if", "self", ".", "suffix", "parts", "<<", "StreetAddress", ".", "string_for", "(", "self", ".", "post_direction", ",", ":short", ")", ".", "upcase", "if", "self", ".", "post_direction", "# make all unit type as the canoncial number \"#\"", "parts", "<<", "StreetAddress", ".", "string_for", "(", ":number", ",", ":short", ")", ".", "upcase", "if", "self", ".", "unit_type", "parts", "<<", "self", ".", "unit", ".", "upcase", "if", "self", ".", "unit", "parts", ".", "delete", "(", "''", ")", "parts", ".", "join", "(", "' '", ")", "end" ]

[ "to_canonical_s", "format", "the", "address", "in", "a", "postal", "service", "canonical", "format" ]

[ "def", "to_horizontal_table", "mortadella", "=", "Mortadella", "::", "Horizontal", ".", "new", "headers", ":", "@cucumber_table", ".", "headers", "@database_content", "=", "@database_content", ".", "all", "if", "@database_content", ".", "respond_to?", ":all", "@database_content", ".", "each", "do", "|", "record", "|", "cucumberator", "=", "cucumberator_for", "record", "mortadella", "<<", "@cucumber_table", ".", "headers", ".", "map", "do", "|", "header", "|", "cucumberator", ".", "value_for", "header", "end", "end", "mortadella", ".", "table", "end" ]

[ "Returns", "all", "entries", "in", "the", "database", "as", "a", "horizontal", "Mortadella", "table" ]

[ "def", "to_vertical_table", "object", "mortadella", "=", "Mortadella", "::", "Vertical", ".", "new", "cucumberator", "=", "cucumberator_for", "object", "@cucumber_table", ".", "rows_hash", ".", "each", "do", "|", "key", ",", "_", "|", "mortadella", "[", "key", "]", "=", "cucumberator", ".", "value_for", "key", "end", "mortadella", ".", "table", "end" ]

[ "Returns", "the", "given", "object", "as", "a", "vertical", "Mortadella", "table" ]

[ "def", "handle_json", "(", "json_str", ")", "begin", "req", "=", "JSON", "::", "parse", "(", "json_str", ")", "resp", "=", "handle", "(", "req", ")", "rescue", "JSON", "::", "ParserError", "=>", "e", "resp", "=", "err_resp", "(", "{", "}", ",", "-", "32700", ",", "\"Unable to parse JSON: #{e.message}\"", ")", "end", "# Note the `:ascii_only` usage here. Important.", "return", "JSON", "::", "generate", "(", "resp", ",", "{", ":ascii_only", "=>", "true", "}", ")", "end" ]

[ "Handles", "a", "request", "encoded", "as", "JSON", ".", "Returns", "the", "result", "as", "a", "JSON", "encoded", "string", "." ]

[ "def", "handle", "(", "req", ")", "if", "req", ".", "kind_of?", "(", "Array", ")", "resp_list", "=", "[", "]", "req", ".", "each", "do", "|", "r", "|", "resp_list", "<<", "handle_single", "(", "r", ")", "end", "return", "resp_list", "else", "return", "handle_single", "(", "req", ")", "end", "end" ]

[ "Handles", "a", "deserialized", "request", "and", "returns", "the", "result" ]

[ "def", "handle_single", "(", "req", ")", "method", "=", "req", "[", "\"method\"", "]", "if", "!", "method", "return", "err_resp", "(", "req", ",", "-", "32600", ",", "\"No method provided on request\"", ")", "end", "# Special case - client is requesting the IDL bound to this server, so", "# we return it verbatim. No further validation is needed in this case.", "if", "method", "==", "\"barrister-idl\"", "return", "ok_resp", "(", "req", ",", "@contract", ".", "idl", ")", "end", "# Make sure we can find an interface and function on the IDL for this", "# request method string", "err_resp", ",", "iface", ",", "func", "=", "@contract", ".", "resolve_method", "(", "req", ")", "if", "err_resp", "!=", "nil", "return", "err_resp", "end", "# Make sure that the params on the request match the IDL types", "err_resp", "=", "@contract", ".", "validate_params", "(", "req", ",", "func", ")", "if", "err_resp", "!=", "nil", "return", "err_resp", "end", "params", "=", "[", "]", "if", "req", "[", "\"params\"", "]", "params", "=", "req", "[", "\"params\"", "]", "end", "# Make sure we have a handler bound to this Server for the interface.", "# If not, that means `server.add_handler` was not called for this interface", "# name. That's likely a misconfiguration.", "handler", "=", "@handlers", "[", "iface", ".", "name", "]", "if", "!", "handler", "return", "err_resp", "(", "req", ",", "-", "32000", ",", "\"Server error. No handler is bound to interface #{iface.name}\"", ")", "end", "# Make sure that the handler has a method for the given function.", "if", "!", "handler", ".", "respond_to?", "(", "func", ".", "name", ")", "return", "err_resp", "(", "req", ",", "-", "32000", ",", "\"Server error. Handler for #{iface.name} does not implement #{func.name}\"", ")", "end", "begin", "# Call the handler function. This is where your code gets invoked.", "result", "=", "handler", ".", "send", "(", "func", ".", "name", ",", "params", ")", "# Verify that the handler function's return value matches the", "# correct type as specified in the IDL", "err_resp", "=", "@contract", ".", "validate_result", "(", "req", ",", "result", ",", "func", ")", "if", "err_resp", "!=", "nil", "return", "err_resp", "else", "return", "ok_resp", "(", "req", ",", "result", ")", "end", "rescue", "RpcException", "=>", "e", "# If the handler raised a RpcException, that's ok - return it unmodified.", "return", "err_resp", "(", "req", ",", "e", ".", "code", ",", "e", ".", "message", ",", "e", ".", "data", ")", "rescue", "=>", "e", "# If any other error was raised, print it and return a generic error to the client", "puts", "e", ".", "inspect", "puts", "e", ".", "backtrace", "return", "err_resp", "(", "req", ",", "-", "32000", ",", "\"Unknown error: #{e}\"", ")", "end", "end" ]

[ "Internal", "method", "that", "validates", "and", "executes", "a", "single", "request", "." ]

[ "def", "init_proxies", "singleton", "=", "class", "<<", "self", ";", "self", "end", "@contract", ".", "interfaces", ".", "each", "do", "|", "iface", "|", "proxy", "=", "InterfaceProxy", ".", "new", "(", "self", ",", "iface", ")", "singleton", ".", "send", ":define_method", ",", "iface", ".", "name", "do", "return", "proxy", "end", "end", "end" ]

[ "Internal", "method", "invoked", "by", "initialize", ".", "Iterates", "through", "the", "Contract", "and", "creates", "proxy", "classes", "for", "each", "interface", "." ]

[ "def", "request", "(", "method", ",", "params", ")", "req", "=", "{", "\"jsonrpc\"", "=>", "\"2.0\"", ",", "\"id\"", "=>", "Barrister", "::", "rand_str", "(", "22", ")", ",", "\"method\"", "=>", "method", "}", "if", "params", "req", "[", "\"params\"", "]", "=", "params", "end", "# We always validate that the method is valid", "err_resp", ",", "iface", ",", "func", "=", "@contract", ".", "resolve_method", "(", "req", ")", "if", "err_resp", "!=", "nil", "return", "err_resp", "end", "if", "@validate_req", "err_resp", "=", "@contract", ".", "validate_params", "(", "req", ",", "func", ")", "if", "err_resp", "!=", "nil", "return", "err_resp", "end", "end", "# This makes the request to the server", "resp", "=", "@trans", ".", "request", "(", "req", ")", "if", "@validate_result", "&&", "resp", "!=", "nil", "&&", "resp", ".", "key?", "(", "\"result\"", ")", "err_resp", "=", "@contract", ".", "validate_result", "(", "req", ",", "resp", "[", "\"result\"", "]", ",", "func", ")", "if", "err_resp", "!=", "nil", "resp", "=", "err_resp", "end", "end", "return", "resp", "end" ]

[ "Sends", "a", "JSON", "-", "RPC", "request", ".", "This", "method", "is", "automatically", "called", "by", "the", "proxy", "classes", "so", "in", "practice", "you", "don", "t", "usually", "call", "it", "directly", ".", "However", "it", "is", "available", "if", "you", "wish", "to", "avoid", "the", "use", "of", "proxy", "classes", "." ]

[ "def", "request", "(", "req", ")", "json_str", "=", "JSON", "::", "generate", "(", "req", ",", "{", ":ascii_only", "=>", "true", "}", ")", "http", "=", "Net", "::", "HTTP", ".", "new", "(", "@uri", ".", "host", ",", "@uri", ".", "port", ")", "request", "=", "Net", "::", "HTTP", "::", "Post", ".", "new", "(", "@uri", ".", "request_uri", ")", "request", ".", "body", "=", "json_str", "request", "[", "\"Content-Type\"", "]", "=", "\"application/json\"", "response", "=", "http", ".", "request", "(", "request", ")", "if", "response", ".", "code", "!=", "\"200\"", "raise", "RpcException", ".", "new", "(", "-", "32000", ",", "\"Non-200 response #{response.code} from #{@url}\"", ")", "else", "return", "JSON", "::", "parse", "(", "response", ".", "body", ")", "end", "end" ]

[ "Takes", "the", "URL", "to", "the", "server", "endpoint", "and", "parses", "it", "request", "is", "the", "only", "required", "method", "on", "a", "transport", "class", "." ]

[ "def", "send", "if", "@trans", ".", "sent", "raise", "\"Batch has already been sent!\"", "end", "@trans", ".", "sent", "=", "true", "requests", "=", "@trans", ".", "requests", "if", "requests", ".", "length", "<", "1", "raise", "RpcException", ".", "new", "(", "-", "32600", ",", "\"Batch cannot be empty\"", ")", "end", "# Send request batch to server", "resp_list", "=", "@parent", ".", "trans", ".", "request", "(", "requests", ")", "# Build a hash for the responses so we can re-order them", "# in request order.", "sorted", "=", "[", "]", "by_req_id", "=", "{", "}", "resp_list", ".", "each", "do", "|", "resp", "|", "by_req_id", "[", "resp", "[", "\"id\"", "]", "]", "=", "resp", "end", "# Iterate through the requests in the batch and assemble", "# the sorted result array", "requests", ".", "each", "do", "|", "req", "|", "id", "=", "req", "[", "\"id\"", "]", "resp", "=", "by_req_id", "[", "id", "]", "if", "!", "resp", "msg", "=", "\"No result for request id: #{id}\"", "resp", "=", "{", "\"id\"", "=>", "id", ",", "\"error\"", "=>", "{", "\"code\"", "=>", "-", "32603", ",", "\"message\"", "=>", "msg", "}", "}", "end", "sorted", "<<", "RpcResponse", ".", "new", "(", "req", ",", "resp", ")", "end", "return", "sorted", "end" ]

[ "Sends", "the", "batch", "of", "requests", "to", "the", "server", "." ]

[ "def", "resolve_method", "(", "req", ")", "method", "=", "req", "[", "\"method\"", "]", "iface_name", ",", "func_name", "=", "Barrister", "::", "parse_method", "(", "method", ")", "if", "iface_name", "==", "nil", "return", "err_resp", "(", "req", ",", "-", "32601", ",", "\"Method not found: #{method}\"", ")", "end", "iface", "=", "interface", "(", "iface_name", ")", "if", "!", "iface", "return", "err_resp", "(", "req", ",", "-", "32601", ",", "\"Interface not found on IDL: #{iface_name}\"", ")", "end", "func", "=", "iface", ".", "function", "(", "func_name", ")", "if", "!", "func", "return", "err_resp", "(", "req", ",", "-", "32601", ",", "\"Function #{func_name} does not exist on interface #{iface_name}\"", ")", "end", "return", "nil", ",", "iface", ",", "func", "end" ]

[ "Takes", "a", "JSON", "-", "RPC", "request", "hash", "and", "returns", "a", "3", "element", "tuple", ".", "This", "is", "called", "as", "part", "of", "the", "request", "validation", "sequence", "." ]

[ "def", "validate_params", "(", "req", ",", "func", ")", "params", "=", "req", "[", "\"params\"", "]", "if", "!", "params", "params", "=", "[", "]", "end", "e_params", "=", "func", ".", "params", ".", "length", "r_params", "=", "params", ".", "length", "if", "e_params", "!=", "r_params", "msg", "=", "\"Function #{func.name}: Param length #{r_params} != expected length: #{e_params}\"", "return", "err_resp", "(", "req", ",", "-", "32602", ",", "msg", ")", "end", "for", "i", "in", "(", "0", "..", "(", "e_params", "-", "1", ")", ")", "expected", "=", "func", ".", "params", "[", "i", "]", "invalid", "=", "validate", "(", "\"Param[#{i}]\"", ",", "expected", ",", "expected", "[", "\"is_array\"", "]", ",", "params", "[", "i", "]", ")", "if", "invalid", "!=", "nil", "return", "err_resp", "(", "req", ",", "-", "32602", ",", "invalid", ")", "end", "end", "# valid", "return", "nil", "end" ]

[ "Validates", "that", "the", "parameters", "on", "the", "JSON", "-", "RPC", "request", "match", "the", "types", "specified", "for", "this", "function" ]

[ "def", "validate_result", "(", "req", ",", "result", ",", "func", ")", "invalid", "=", "validate", "(", "\"\"", ",", "func", ".", "returns", ",", "func", ".", "returns", "[", "\"is_array\"", "]", ",", "result", ")", "if", "invalid", "==", "nil", "return", "nil", "else", "return", "err_resp", "(", "req", ",", "-", "32001", ",", "invalid", ")", "end", "end" ]

[ "Validates", "that", "the", "result", "from", "a", "handler", "method", "invocation", "match", "the", "return", "type", "for", "this", "function" ]

[ "def", "validate", "(", "name", ",", "expected", ",", "expect_array", ",", "val", ")", "# If val is nil, then check if the IDL allows this type to be optional", "if", "val", "==", "nil", "if", "expected", "[", "\"optional\"", "]", "return", "nil", "else", "return", "\"#{name} cannot be null\"", "end", "else", "exp_type", "=", "expected", "[", "\"type\"", "]", "# If we expect an array, make sure that val is an Array, and then", "# recursively validate the elements in the array", "if", "expect_array", "if", "val", ".", "kind_of?", "(", "Array", ")", "stop", "=", "val", ".", "length", "-", "1", "for", "i", "in", "(", "0", "..", "stop", ")", "invalid", "=", "validate", "(", "\"#{name}[#{i}]\"", ",", "expected", ",", "false", ",", "val", "[", "i", "]", ")", "if", "invalid", "!=", "nil", "return", "invalid", "end", "end", "return", "nil", "else", "return", "type_err", "(", "name", ",", "\"[]\"", "+", "expected", "[", "\"type\"", "]", ",", "val", ")", "end", "# Check the built in Barrister primitive types", "elsif", "exp_type", "==", "\"string\"", "if", "val", ".", "class", "==", "String", "return", "nil", "else", "return", "type_err", "(", "name", ",", "exp_type", ",", "val", ")", "end", "elsif", "exp_type", "==", "\"bool\"", "if", "val", ".", "class", "==", "TrueClass", "||", "val", ".", "class", "==", "FalseClass", "return", "nil", "else", "return", "type_err", "(", "name", ",", "exp_type", ",", "val", ")", "end", "elsif", "exp_type", "==", "\"int\"", "||", "exp_type", "==", "\"float\"", "if", "val", ".", "class", "==", "Integer", "||", "val", ".", "class", "==", "Fixnum", "||", "val", ".", "class", "==", "Bignum", "return", "nil", "elsif", "val", ".", "class", "==", "Float", "&&", "exp_type", "==", "\"float\"", "return", "nil", "else", "return", "type_err", "(", "name", ",", "exp_type", ",", "val", ")", "end", "# Expected type is not an array or a Barrister primitive.", "# It must be a struct or an enum.", "else", "# Try to find a struct", "struct", "=", "@structs", "[", "exp_type", "]", "if", "struct", "if", "!", "val", ".", "kind_of?", "(", "Hash", ")", "return", "\"#{name} #{exp_type} value must be a map/hash. not: \"", "+", "val", ".", "class", ".", "name", "end", "s_field_keys", "=", "{", "}", "# Resolve all fields on the struct and its ancestors", "s_fields", "=", "all_struct_fields", "(", "[", "]", ",", "struct", ")", "# Validate that each field on the struct has a valid value", "s_fields", ".", "each", "do", "|", "f", "|", "fname", "=", "f", "[", "\"name\"", "]", "invalid", "=", "validate", "(", "\"#{name}.#{fname}\"", ",", "f", ",", "f", "[", "\"is_array\"", "]", ",", "val", "[", "fname", "]", ")", "if", "invalid", "!=", "nil", "return", "invalid", "end", "s_field_keys", "[", "fname", "]", "=", "1", "end", "# Validate that there are no extraneous elements on the value", "val", ".", "keys", ".", "each", "do", "|", "k", "|", "if", "!", "s_field_keys", ".", "key?", "(", "k", ")", "return", "\"#{name}.#{k} is not a field in struct '#{exp_type}'\"", "end", "end", "# Struct is valid", "return", "nil", "end", "# Try to find an enum", "enum", "=", "@enums", "[", "exp_type", "]", "if", "enum", "if", "val", ".", "class", "!=", "String", "return", "\"#{name} enum value must be a string. got: \"", "+", "val", ".", "class", ".", "name", "end", "# Try to find an enum value that matches this val", "enum", "[", "\"values\"", "]", ".", "each", "do", "|", "en", "|", "if", "en", "[", "\"value\"", "]", "==", "val", "return", "nil", "end", "end", "# Invalid", "return", "\"#{name} #{val} is not a value in enum '#{exp_type}'\"", "end", "# Unlikely branch - suggests the IDL is internally inconsistent", "return", "\"#{name} unknown type: #{exp_type}\"", "end", "# Panic if we have a branch unaccounted for. Indicates a Barrister bug.", "raise", "\"Barrister ERROR: validate did not return for: #{name} #{expected}\"", "end", "end" ]

[ "Validates", "the", "type", "for", "a", "single", "value", ".", "This", "method", "is", "recursive", "when", "validating", "arrays", "or", "structs", "." ]

[ "def", "all_struct_fields", "(", "arr", ",", "struct", ")", "struct", "[", "\"fields\"", "]", ".", "each", "do", "|", "f", "|", "arr", "<<", "f", "end", "if", "struct", "[", "\"extends\"", "]", "parent", "=", "@structs", "[", "struct", "[", "\"extends\"", "]", "]", "if", "parent", "return", "all_struct_fields", "(", "arr", ",", "parent", ")", "end", "end", "return", "arr", "end" ]

[ "Recursively", "resolves", "all", "fields", "for", "the", "struct", "and", "its", "ancestors" ]

[ "def", "notify", "(", "exception", ",", "request", "=", "{", "}", ",", "environment", "=", "{", "}", ",", "session", "=", "{", "}", ")", "begin", "notification", "=", "Notification", ".", "new", "(", "exception", ",", "request", ",", "environment", ",", "session", ")", "@notifiers", ".", "each", "do", "|", "notifier", "|", "notifier", ".", "notify", "(", "notification", ")", "end", "# We need to ignore all the exceptions thrown by the notifiers.", "rescue", "Exception", "warn", "(", "'Rusen: Some or all the notifiers failed to sent the notification.'", ")", "end", "end" ]

[ "Sends", "a", "notification", "to", "the", "configured", "outputs", "." ]

[ "def", "[]=", "(", "key", ",", "value", ")", "coerced_value", "=", "coercion", "(", "key", ")", ".", "present?", "?", "coercion", "(", "key", ")", ".", "call", "(", "value", ")", ":", "value", "old_setter", "(", "key", ",", "coerced_value", ")", "end" ]

[ "Override", "setter", "to", "coerce", "the", "given", "value", "if", "a", "coercion", "is", "defined" ]

[ "def", "show", "Ncurses", "::", "Panel", ".", "top_panel", "(", "@panel", ")", "update_reterm", "@@registry", ".", "values", ".", "each", "{", "|", "panel", "|", "if", "panel", "==", "self", "dispatch", ":panel_show", "else", "panel", ".", "dispatch", ":panel_hide", "end", "}", "end" ]

[ "Initialize", "panel", "from", "the", "given", "window", "." ]

[ "def", "generate_id", "Base64", ".", "encode64", "(", "Digest", "::", "MD5", ".", "digest", "(", "\"#{Time.now}-#{rand}\"", ")", ")", ".", "gsub", "(", "'/'", ",", "'x'", ")", ".", "gsub", "(", "'+'", ",", "'y'", ")", ".", "gsub", "(", "'='", ",", "''", ")", ".", "strip", "end" ]

[ "Generate", "a", "unique", "id" ]

[ "def", "_pv_opts_lookup", "(", "opts", ",", "key", ")", "if", "opts", ".", "has_key?", "(", "key", ".", "to_s", ")", "opts", "[", "key", ".", "to_s", "]", "elsif", "opts", ".", "has_key?", "(", "key", ".", "to_sym", ")", "opts", "[", "key", ".", "to_sym", "]", "else", "nil", "end", "end" ]

[ "Return", "the", "value", "of", "a", "parameter", "or", "nil", "if", "it", "doesn", "t", "exist", "." ]

[ "def", "_pv_required", "(", "opts", ",", "key", ",", "is_required", "=", "true", ")", "if", "is_required", "if", "(", "opts", ".", "has_key?", "(", "key", ".", "to_s", ")", "&&", "!", "opts", "[", "key", ".", "to_s", "]", ".", "nil?", ")", "||", "(", "opts", ".", "has_key?", "(", "key", ".", "to_sym", ")", "&&", "!", "opts", "[", "key", ".", "to_sym", "]", ".", "nil?", ")", "true", "else", "raise", "ValidationFailed", ",", "\"Required argument #{key} is missing!\"", "end", "end", "end" ]

[ "Raise", "an", "exception", "if", "the", "parameter", "is", "not", "found", "." ]

[ "def", "_pv_respond_to", "(", "opts", ",", "key", ",", "method_name_list", ")", "value", "=", "_pv_opts_lookup", "(", "opts", ",", "key", ")", "unless", "value", ".", "nil?", "Array", "(", "method_name_list", ")", ".", "each", "do", "|", "method_name", "|", "unless", "value", ".", "respond_to?", "(", "method_name", ")", "raise", "ValidationFailed", ",", "\"Option #{key} must have a #{method_name} method!\"", "end", "end", "end", "end" ]

[ "Raise", "an", "exception", "if", "the", "parameter", "does", "not", "respond", "to", "a", "given", "set", "of", "methods", "." ]

[ "def", "_pv_default", "(", "opts", ",", "key", ",", "default_value", ")", "value", "=", "_pv_opts_lookup", "(", "opts", ",", "key", ")", "if", "value", "==", "nil", "opts", "[", "key", "]", "=", "default_value", "end", "end" ]

[ "Assign", "a", "default", "value", "to", "a", "parameter", "." ]

[ "def", "_pv_regex", "(", "opts", ",", "key", ",", "regex", ")", "value", "=", "_pv_opts_lookup", "(", "opts", ",", "key", ")", "if", "value", "!=", "nil", "passes", "=", "false", "[", "regex", "]", ".", "flatten", ".", "each", "do", "|", "r", "|", "if", "value", "!=", "nil", "if", "r", ".", "match", "(", "value", ".", "to_s", ")", "passes", "=", "true", "end", "end", "end", "unless", "passes", "raise", "ValidationFailed", ",", "\"Option #{key}'s value #{value} does not match regular expression #{regex.inspect}\"", "end", "end", "end" ]

[ "Check", "a", "parameter", "against", "a", "regular", "expression", "." ]

[ "def", "_pv_callbacks", "(", "opts", ",", "key", ",", "callbacks", ")", "raise", "ArgumentError", ",", "\"Callback list must be a hash!\"", "unless", "callbacks", ".", "kind_of?", "(", "Hash", ")", "value", "=", "_pv_opts_lookup", "(", "opts", ",", "key", ")", "if", "value", "!=", "nil", "callbacks", ".", "each", "do", "|", "message", ",", "zeproc", "|", "if", "zeproc", ".", "call", "(", "value", ")", "!=", "true", "raise", "ValidationFailed", ",", "\"Option #{key}'s value #{value} #{message}!\"", "end", "end", "end", "end" ]

[ "Check", "a", "parameter", "against", "a", "hash", "of", "proc", "s", "." ]

[ "def", "_pv_name_attribute", "(", "opts", ",", "key", ",", "is_name_attribute", "=", "true", ")", "if", "is_name_attribute", "if", "opts", "[", "key", "]", "==", "nil", "opts", "[", "key", "]", "=", "self", ".", "instance_variable_get", "(", "\"@name\"", ")", "end", "end", "end" ]

[ "Allow", "a", "parameter", "to", "default", "to" ]

[ "def", "answer_hiera", "# Render pretty JSON, because it is a subset of HOCON", "json", "=", "JSON", ".", "pretty_generate", "(", "answers", ")", "hocon", "=", "Hocon", "::", "Parser", "::", "ConfigDocumentFactory", ".", "parse_string", "(", "json", ")", "hocon", ".", "render", "end" ]

[ "This", "converts", "a", "data", "hash", "provided", "by", "answers", "and", "returns", "a", "Puppet", "Enterprise", "compatible", "hiera", "config", "file", "ready", "for", "use", "." ]

[ "def", "convertDT", "(", "tpitDT", ")", "return", "nil", "if", "tpitDT", ".", "nil?", "date", "=", "tpitDT", "[", "\"date\"", "]", "time", "=", "tpitDT", "[", "\"time\"", "]", "offset", "=", "tpitDT", "[", "\"utc_offset\"", "]", "if", "time", ".", "nil?", "# Just return a date", "Date", ".", "parse", "(", "date", ")", "elsif", "date", ".", "nil?", "# Or just a time", "Time", ".", "parse", "(", "time", ")", "else", "# Ideally both", "DateTime", ".", "parse", "(", "\"#{date}T#{time}#{offset}\"", ")", "end", "end" ]

[ "Convert", "a", "TripIt", "DateTime", "Object", "to", "a", "Ruby", "DateTime", "Object" ]

[ "def", "standard_build", "(", "short_cmd_string", ",", "target", ",", "command", ",", "sources", ",", "env", ",", "cache", ")", "unless", "cache", ".", "up_to_date?", "(", "target", ",", "command", ",", "sources", ",", "env", ")", "unless", "Rscons", ".", "phony_target?", "(", "target", ")", "cache", ".", "mkdir_p", "(", "File", ".", "dirname", "(", "target", ")", ")", "FileUtils", ".", "rm_f", "(", "target", ")", "end", "return", "false", "unless", "env", ".", "execute", "(", "short_cmd_string", ",", "command", ")", "cache", ".", "register_build", "(", "target", ",", "command", ",", "sources", ",", "env", ")", "end", "target", "end" ]

[ "Check", "if", "the", "cache", "is", "up", "to", "date", "for", "the", "target", "and", "if", "not", "execute", "the", "build", "command", ".", "This", "method", "does", "not", "support", "parallelization", "." ]

[ "def", "finalize!", "erase", "@@registry", ".", "delete", "(", "self", ")", "children", ".", "each", "{", "|", "c", "|", "del_child", "c", "}", "cdk_scr", ".", "destroy", "if", "cdk?", "component", ".", "finalize!", "if", "component?", "end" ]

[ "Invoke", "window", "finalization", "routine", "by", "destroying", "it", "and", "all", "children" ]

[ "def", "child_containing", "(", "x", ",", "y", ",", "z", ")", "found", "=", "nil", "children", ".", "find", "{", "|", "c", "|", "next", "if", "found", "# recursively descend into layout children", "if", "c", ".", "component", ".", "kind_of?", "(", "Layout", ")", "found", "=", "c", ".", "child_containing", "(", "x", ",", "y", ",", "z", ")", "else", "found", "=", "c", ".", "total_x", "<=", "x", "&&", "c", ".", "total_y", "<=", "y", "&&", "# c.z >= z", "(", "c", ".", "total_x", "+", "c", ".", "cols", ")", ">=", "x", "&&", "(", "c", ".", "total_y", "+", "c", ".", "rows", ")", ">=", "y", "found", "=", "c", "if", "found", "end", "}", "found", "end" ]

[ "Return", "child", "containing", "specified", "screen", "coordiantes", "else", "nil" ]

[ "def", "erase", "children", ".", "each", "{", "|", "c", "|", "c", ".", "erase", "}", "@win", ".", "werase", "if", "@win", "component", ".", "component", ".", "erase", "if", "cdk?", "&&", "component?", "&&", "component", ".", "init?", "end" ]

[ "Erase", "window", "drawing", "area" ]

[ "def", "no_border!", "@win", ".", "border", "(", "' '", ".", "ord", ",", "' '", ".", "ord", ",", "' '", ".", "ord", ",", "' '", ".", "ord", ",", "' '", ".", "ord", ",", "' '", ".", "ord", ",", "' '", ".", "ord", ",", "' '", ".", "ord", ")", "end" ]

[ "Remove", "Border", "around", "window" ]

[ "def", "sync_getch", "return", "self", ".", "getch", "unless", "sync_enabled?", "c", "=", "-", "1", "while", "c", "==", "-", "1", "&&", "!", "shutdown?", "c", "=", "self", ".", "getch", "run_sync!", "end", "c", "end" ]

[ "Normal", "getch", "unless", "sync", "enabled", "in", "which", "case", "timeout", "will", "be", "checked", "&", "components", "synchronized" ]

[ "def", "colors", "=", "(", "c", ")", "@colors", "=", "c", ".", "is_a?", "(", "ColorPair", ")", "?", "c", ":", "ColorPair", ".", "for", "(", "c", ")", ".", "first", "@win", ".", "bkgd", "(", "Ncurses", ".", "COLOR_PAIR", "(", "@colors", ".", "id", ")", ")", "unless", "@win", ".", "nil?", "component", ".", "colors", "=", "@colors", "if", "component?", "children", ".", "each", "{", "|", "ch", "|", "ch", ".", "colors", "=", "c", "}", "end" ]

[ "Set", "window", "color" ]

[ "def", "dimensions", "rows", "=", "[", "]", "cols", "=", "[", "]", "@win", ".", "getmaxyx", "(", "rows", ",", "cols", ")", "rows", "=", "rows", ".", "first", "cols", "=", "cols", ".", "first", "[", "rows", ",", "cols", "]", "end" ]

[ "Return", "window", "dimensions", "as", "an", "array", "containing", "rows", "&", "cols" ]

[ "def", "next_ip", "(", "arg", ")", "octets", "=", "arg", ".", "split", "(", "/", "\\.", "/", ",", "4", ")", ".", "map", "(", ":to_i", ")", "octets", "[", "3", "]", "+=", "1", "raise", "\"out of ips!\"", "if", "octets", "[", "3", "]", ">", "255", "return", "octets", ".", "map", "(", ":to_s", ")", ".", "join", "(", "\".\"", ")", "end" ]

[ "Gets", "the", "next", "unallocated", "IP", "given", "an", "IP", "to", "start", "with", "." ]

[ "def", "sanitize!", "self", ".", "class", ".", "sanitizable_attributes", ".", "each", "do", "|", "attr_name", "|", "cleaned_text", "=", "process_text_via_sanitization_method", "(", "self", ".", "send", "(", "attr_name", ")", ",", "attr_name", ")", "self", ".", "send", "(", "(", "attr_name", ".", "to_s", "+", "'='", ")", ",", "cleaned_text", ")", "end", "end" ]

[ "sanitize!", "is", "the", "method", "that", "is", "called", "when", "a", "model", "is", "saved", ".", "It", "can", "be", "called", "to", "manually", "sanitize", "attributes", "." ]

[ "def", "factorygirl_attributes", "symbolize_attributes!", "@attributes", ".", "each", "do", "|", "key", ",", "value", "|", "next", "unless", "respond_to?", "(", "method", "=", "method_name", "(", "key", ")", ")", "if", "(", "result", "=", "send", "method", ",", "value", ")", "||", "value", ".", "nil?", "@attributes", "[", "key", "]", "=", "result", "if", "@attributes", ".", "key?", "key", "else", "@attributes", ".", "delete", "key", "end", "end", "end" ]

[ "Returns", "the", "FactoryGirl", "version", "of", "this", "Creator", "s", "attributes" ]

[ "def", "add_provider", "(", "provider", ",", "*", "args", ")", "unless", "provider", ".", "respond_to?", "(", ":instance_methods", ")", "&&", "provider", ".", "instance_methods", ".", "include?", "(", ":lookup", ")", "raise", "ArgumentError", ",", "\"the given provider does not respond to lookup\"", "end", "@provider", "<<", "provider", ".", "new", "(", "args", ")", "end" ]

[ "Adds", "a", "provider", "to", "the", "chain", ".", "Providers", "are", "tried", "in", "the", "order", "they", "are", "added", "so", "the", "order", "is", "important", "." ]

[ "def", "lookup", "(", "setting", ",", "*", "args", ")", "setting", "=", "SettingPath", ".", "new", "setting", "if", "setting", ".", "is_a?", "String", "@provider", ".", "each", "do", "|", "provider", "|", "begin", "return", "special_value_or_string", "(", "provider", ".", "lookup", "(", "setting", ".", "clone", ",", "args", ")", ")", "rescue", "SettingNotFoundError", ";", "end", "end", "nil", "end" ]

[ "Tries", "all", "providers", "in", "the", "order", "they", "were", "added", "to", "provide", "a", "response", "for", "setting", "." ]

[ "def", "build_dir", "(", "src_dir", ",", "obj_dir", ")", "if", "src_dir", ".", "is_a?", "(", "String", ")", "src_dir", "=", "src_dir", ".", "gsub", "(", "\"\\\\\"", ",", "\"/\"", ")", ".", "sub", "(", "%r{", "}", ",", "\"\"", ")", "end", "@build_dirs", ".", "unshift", "(", "[", "src_dir", ",", "obj_dir", "]", ")", "end" ]

[ "Specify", "a", "build", "directory", "for", "this", "Environment", "." ]

[ "def", "process", "cache", "=", "Cache", ".", "instance", "failure", "=", "nil", "begin", "while", "@job_set", ".", "size", ">", "0", "or", "@threaded_commands", ".", "size", ">", "0", "if", "failure", "@job_set", ".", "clear!", "job", "=", "nil", "else", "targets_still_building", "=", "@threaded_commands", ".", "map", "do", "|", "tc", "|", "tc", ".", "build_operation", "[", ":target", "]", "end", "job", "=", "@job_set", ".", "get_next_job_to_run", "(", "targets_still_building", ")", "end", "# TODO: have Cache determine when checksums may be invalid based on", "# file size and/or timestamp.", "cache", ".", "clear_checksum_cache!", "if", "job", "result", "=", "run_builder", "(", "job", "[", ":builder", "]", ",", "job", "[", ":target", "]", ",", "job", "[", ":sources", "]", ",", "cache", ",", "job", "[", ":vars", "]", ",", "allow_delayed_execution", ":", "true", ",", "setup_info", ":", "job", "[", ":setup_info", "]", ")", "unless", "result", "failure", "=", "\"Failed to build #{job[:target]}\"", "Ansi", ".", "write", "(", "$stderr", ",", ":red", ",", "failure", ",", ":reset", ",", "\"\\n\"", ")", "next", "end", "end", "completed_tcs", "=", "Set", ".", "new", "# First do a non-blocking wait to pick up any threads that have", "# completed since last time.", "while", "tc", "=", "wait_for_threaded_commands", "(", "nonblock", ":", "true", ")", "completed_tcs", "<<", "tc", "end", "# If needed, do a blocking wait.", "if", "(", "@threaded_commands", ".", "size", ">", "0", ")", "and", "(", "(", "completed_tcs", ".", "empty?", "and", "job", ".", "nil?", ")", "or", "(", "@threaded_commands", ".", "size", ">=", "n_threads", ")", ")", "completed_tcs", "<<", "wait_for_threaded_commands", "end", "# Process all completed {ThreadedCommand} objects.", "completed_tcs", ".", "each", "do", "|", "tc", "|", "result", "=", "finalize_builder", "(", "tc", ")", "if", "result", "@build_hooks", "[", ":post", "]", ".", "each", "do", "|", "build_hook_block", "|", "build_hook_block", ".", "call", "(", "tc", ".", "build_operation", ")", "end", "else", "unless", "@echo", "==", ":command", "print_failed_command", "(", "tc", ".", "command", ")", "end", "failure", "=", "\"Failed to build #{tc.build_operation[:target]}\"", "Ansi", ".", "write", "(", "$stderr", ",", ":red", ",", "failure", ",", ":reset", ",", "\"\\n\"", ")", "break", "end", "end", "end", "ensure", "cache", ".", "write", "end", "if", "failure", "raise", "BuildError", ".", "new", "(", "failure", ")", "end", "end" ]

[ "Build", "all", "build", "targets", "specified", "in", "the", "Environment", "." ]

[ "def", "expand_varref", "(", "varref", ",", "extra_vars", "=", "nil", ")", "vars", "=", "if", "extra_vars", ".", "nil?", "@varset", "else", "@varset", ".", "merge", "(", "extra_vars", ")", "end", "lambda_args", "=", "[", "env", ":", "self", ",", "vars", ":", "vars", "]", "vars", ".", "expand_varref", "(", "varref", ",", "lambda_args", ")", "end" ]

[ "Expand", "a", "construction", "variable", "reference", "." ]

[ "def", "execute", "(", "short_desc", ",", "command", ",", "options", "=", "{", "}", ")", "print_builder_run_message", "(", "short_desc", ",", "command", ")", "env_args", "=", "options", "[", ":env", "]", "?", "[", "options", "[", ":env", "]", "]", ":", "[", "]", "options_args", "=", "options", "[", ":options", "]", "?", "[", "options", "[", ":options", "]", "]", ":", "[", "]", "system", "(", "env_args", ",", "Rscons", ".", "command_executer", ",", "command", ",", "options_args", ")", ".", "tap", "do", "|", "result", "|", "unless", "result", "or", "@echo", "==", ":command", "print_failed_command", "(", "command", ")", "end", "end", "end" ]

[ "Execute", "a", "builder", "command", "." ]

[ "def", "method_missing", "(", "method", ",", "*", "args", ")", "if", "@builders", ".", "has_key?", "(", "method", ".", "to_s", ")", "target", ",", "sources", ",", "vars", ",", "*", "rest", "=", "args", "vars", "||=", "{", "}", "unless", "vars", ".", "is_a?", "(", "Hash", ")", "or", "vars", ".", "is_a?", "(", "VarSet", ")", "raise", "\"Unexpected construction variable set: #{vars.inspect}\"", "end", "builder", "=", "@builders", "[", "method", ".", "to_s", "]", "target", "=", "expand_path", "(", "expand_varref", "(", "target", ")", ")", "sources", "=", "Array", "(", "sources", ")", ".", "map", "do", "|", "source", "|", "expand_path", "(", "expand_varref", "(", "source", ")", ")", "end", ".", "flatten", "build_target", "=", "builder", ".", "create_build_target", "(", "env", ":", "self", ",", "target", ":", "target", ",", "sources", ":", "sources", ",", "vars", ":", "vars", ")", "add_target", "(", "build_target", ".", "to_s", ",", "builder", ",", "sources", ",", "vars", ",", "rest", ")", "build_target", "else", "super", "end", "end" ]

[ "Define", "a", "build", "target", "." ]

[ "def", "depends", "(", "target", ",", "*", "user_deps", ")", "target", "=", "expand_varref", "(", "target", ".", "to_s", ")", "user_deps", "=", "user_deps", ".", "map", "{", "|", "ud", "|", "expand_varref", "(", "ud", ")", "}", "@user_deps", "[", "target", "]", "||=", "[", "]", "@user_deps", "[", "target", "]", "=", "(", "@user_deps", "[", "target", "]", "+", "user_deps", ")", ".", "uniq", "build_after", "(", "target", ",", "user_deps", ")", "end" ]

[ "Manually", "record", "a", "given", "target", "as", "depending", "on", "the", "specified", "files", "." ]

[ "def", "build_sources", "(", "sources", ",", "suffixes", ",", "cache", ",", "vars", ")", "sources", ".", "map", "do", "|", "source", "|", "if", "source", ".", "end_with?", "(", "suffixes", ")", "source", "else", "converted", "=", "nil", "suffixes", ".", "each", "do", "|", "suffix", "|", "converted_fname", "=", "get_build_fname", "(", "source", ",", "suffix", ")", "if", "builder", "=", "find_builder_for", "(", "converted_fname", ",", "source", ",", "[", "]", ")", "converted", "=", "run_builder", "(", "builder", ",", "converted_fname", ",", "[", "source", "]", ",", "cache", ",", "vars", ")", "return", "nil", "unless", "converted", "break", "end", "end", "converted", "or", "raise", "\"Could not find a builder to handle #{source.inspect}.\"", "end", "end", "end" ]

[ "Build", "a", "list", "of", "source", "files", "into", "files", "containing", "one", "of", "the", "suffixes", "given", "by", "suffixes", "." ]

[ "def", "register_builds", "(", "target", ",", "sources", ",", "suffixes", ",", "vars", ",", "options", "=", "{", "}", ")", "options", "[", ":features", "]", "||=", "[", "]", "@registered_build_dependencies", "[", "target", "]", "||=", "Set", ".", "new", "sources", ".", "map", "do", "|", "source", "|", "if", "source", ".", "end_with?", "(", "suffixes", ")", "source", "else", "output_fname", "=", "nil", "suffixes", ".", "each", "do", "|", "suffix", "|", "attempt_output_fname", "=", "get_build_fname", "(", "source", ",", "suffix", ",", "features", ":", "options", "[", ":features", "]", ")", "if", "builder", "=", "find_builder_for", "(", "attempt_output_fname", ",", "source", ",", "options", "[", ":features", "]", ")", "output_fname", "=", "attempt_output_fname", "self", ".", "__send__", "(", "builder", ".", "name", ",", "output_fname", ",", "source", ",", "vars", ")", "@registered_build_dependencies", "[", "target", "]", "<<", "output_fname", "break", "end", "end", "output_fname", "or", "raise", "\"Could not find a builder for #{source.inspect}.\"", "end", "end", "end" ]

[ "Find", "and", "register", "builders", "to", "build", "source", "files", "into", "files", "containing", "one", "of", "the", "suffixes", "given", "by", "suffixes", "." ]

[ "def", "run_builder", "(", "builder", ",", "target", ",", "sources", ",", "cache", ",", "vars", ",", "options", "=", "{", "}", ")", "vars", "=", "@varset", ".", "merge", "(", "vars", ")", "build_operation", "=", "{", "builder", ":", "builder", ",", "target", ":", "target", ",", "sources", ":", "sources", ",", "cache", ":", "cache", ",", "env", ":", "self", ",", "vars", ":", "vars", ",", "setup_info", ":", "options", "[", ":setup_info", "]", "}", "call_build_hooks", "=", "lambda", "do", "|", "sec", "|", "@build_hooks", "[", "sec", "]", ".", "each", "do", "|", "build_hook_block", "|", "build_hook_block", ".", "call", "(", "build_operation", ")", "end", "end", "# Invoke pre-build hooks.", "call_build_hooks", "[", ":pre", "]", "# Call the builder's #run method.", "if", "builder", ".", "method", "(", ":run", ")", ".", "arity", "==", "5", "rv", "=", "builder", ".", "run", "(", "build_operation", ".", "values_at", "(", ":target", ",", ":sources", ",", ":cache", ",", ":env", ",", ":vars", ")", ")", "else", "rv", "=", "builder", ".", "run", "(", "build_operation", ")", "end", "if", "rv", ".", "is_a?", "(", "ThreadedCommand", ")", "# Store the build operation so the post-build hooks can be called", "# with it when the threaded command completes.", "rv", ".", "build_operation", "=", "build_operation", "start_threaded_command", "(", "rv", ")", "unless", "options", "[", ":allow_delayed_execution", "]", "# Delayed command execution is not allowed, so we need to execute", "# the command and finalize the builder now.", "tc", "=", "wait_for_threaded_commands", "(", "which", ":", "[", "rv", "]", ")", "rv", "=", "finalize_builder", "(", "tc", ")", "if", "rv", "call_build_hooks", "[", ":post", "]", "else", "unless", "@echo", "==", ":command", "print_failed_command", "(", "tc", ".", "command", ")", "end", "end", "end", "else", "call_build_hooks", "[", ":post", "]", "if", "rv", "end", "rv", "end" ]

[ "Invoke", "a", "builder", "to", "build", "the", "given", "target", "based", "on", "the", "given", "sources", "." ]

[ "def", "expand_path", "(", "path", ")", "if", "Rscons", ".", "phony_target?", "(", "path", ")", "path", "elsif", "path", ".", "is_a?", "(", "Array", ")", "path", ".", "map", "do", "|", "path", "|", "expand_path", "(", "path", ")", "end", "else", "path", ".", "sub", "(", "%r{", "\\^", "\\\\", "}", ",", "@build_root", ")", ".", "gsub", "(", "\"\\\\\"", ",", "\"/\"", ")", "end", "end" ]

[ "Expand", "a", "path", "to", "be", "relative", "to", "the", "Environment", "s", "build", "root", "." ]

[ "def", "shell", "(", "command", ")", "shell_cmd", "=", "if", "self", "[", "\"SHELL\"", "]", "flag", "=", "self", "[", "\"SHELLFLAG\"", "]", "||", "(", "self", "[", "\"SHELL\"", "]", "==", "\"cmd\"", "?", "\"/c\"", ":", "\"-c\"", ")", "[", "self", "[", "\"SHELL\"", "]", ",", "flag", "]", "else", "Rscons", ".", "get_system_shell", "end", "IO", ".", "popen", "(", "[", "shell_cmd", ",", "command", "]", ")", "do", "|", "io", "|", "io", ".", "read", "end", "end" ]

[ "Execute", "a", "command", "using", "the", "system", "shell", "." ]

[ "def", "merge_flags", "(", "flags", ")", "flags", ".", "each_pair", "do", "|", "key", ",", "val", "|", "if", "self", "[", "key", "]", ".", "is_a?", "(", "Array", ")", "and", "val", ".", "is_a?", "(", "Array", ")", "self", "[", "key", "]", "+=", "val", "else", "self", "[", "key", "]", "=", "val", "end", "end", "end" ]

[ "Merge", "construction", "variable", "flags", "into", "this", "Environment", "s", "construction", "variables", "." ]

[ "def", "dump", "varset_hash", "=", "@varset", ".", "to_h", "varset_hash", ".", "keys", ".", "sort_by", "(", ":to_s", ")", ".", "each", "do", "|", "var", "|", "var_str", "=", "var", ".", "is_a?", "(", "Symbol", ")", "?", "var", ".", "inspect", ":", "var", "Ansi", ".", "write", "(", "$stdout", ",", ":cyan", ",", "var_str", ",", ":reset", ",", "\" => #{varset_hash[var].inspect}\\n\"", ")", "end", "end" ]

[ "Print", "the", "Environment", "s", "construction", "variables", "for", "debugging", "." ]

[ "def", "print_builder_run_message", "(", "short_description", ",", "command", ")", "case", "@echo", "when", ":command", "if", "command", ".", "is_a?", "(", "Array", ")", "message", "=", "command_to_s", "(", "command", ")", "elsif", "command", ".", "is_a?", "(", "String", ")", "message", "=", "command", "elsif", "short_description", ".", "is_a?", "(", "String", ")", "message", "=", "short_description", "end", "when", ":short", "message", "=", "short_description", "if", "short_description", "end", "Ansi", ".", "write", "(", "$stdout", ",", ":cyan", ",", "message", ",", ":reset", ",", "\"\\n\"", ")", "if", "message", "end" ]

[ "Print", "the", "builder", "run", "message", "depending", "on", "the", "Environment", "s", "echo", "mode", "." ]

[ "def", "add_target", "(", "target", ",", "builder", ",", "sources", ",", "vars", ",", "args", ")", "setup_info", "=", "builder", ".", "setup", "(", "target", ":", "target", ",", "sources", ":", "sources", ",", "env", ":", "self", ",", "vars", ":", "vars", ")", "@job_set", ".", "add_job", "(", "builder", ":", "builder", ",", "target", ":", "target", ",", "sources", ":", "sources", ",", "vars", ":", "vars", ",", "setup_info", ":", "setup_info", ")", "end" ]

[ "Add", "a", "build", "target", "." ]

[ "def", "start_threaded_command", "(", "tc", ")", "print_builder_run_message", "(", "tc", ".", "short_description", ",", "tc", ".", "command", ")", "env_args", "=", "tc", ".", "system_env", "?", "[", "tc", ".", "system_env", "]", ":", "[", "]", "options_args", "=", "tc", ".", "system_options", "?", "[", "tc", ".", "system_options", "]", ":", "[", "]", "system_args", "=", "[", "env_args", ",", "Rscons", ".", "command_executer", ",", "tc", ".", "command", ",", "options_args", "]", "tc", ".", "thread", "=", "Thread", ".", "new", "do", "system", "(", "system_args", ")", "end", "@threaded_commands", "<<", "tc", "end" ]

[ "Start", "a", "threaded", "command", "in", "a", "new", "thread", "." ]