Datasets:

semeru

/

code-text-ruby

like 3

Follow

Semeru Lab 7

[ "def", "dir_name", "(", "name", ")", "name", "=", "name", ".", "dup", "name", ".", "gsub!", "(", "\":\"", ",", "VAGRANT_COLON", ")", "if", "Util", "::", "Platform", ".", "windows?", "name", ".", "gsub!", "(", "\"/\"", ",", "VAGRANT_SLASH", ")", "name", "end" ]

[ "Returns", "the", "directory", "name", "for", "the", "box", "of", "the", "given", "name", "." ]

[ "def", "undir_name", "(", "name", ")", "name", "=", "name", ".", "dup", "name", ".", "gsub!", "(", "VAGRANT_COLON", ",", "\":\"", ")", "name", ".", "gsub!", "(", "VAGRANT_SLASH", ",", "\"/\"", ")", "name", "end" ]

[ "Returns", "the", "directory", "name", "for", "the", "box", "cleaned", "up" ]

[ "def", "v1_upgrade", "(", "dir", ")", "@logger", ".", "debug", "(", "\"Upgrading box in directory: #{dir}\"", ")", "temp_dir", "=", "Pathname", ".", "new", "(", "Dir", ".", "mktmpdir", "(", "TEMP_PREFIX", ",", "@temp_root", ")", ")", "@logger", ".", "debug", "(", "\"Temporary directory for upgrading: #{temp_dir}\"", ")", "# Move all the things into the temporary directory", "dir", ".", "children", "(", "true", ")", ".", "each", "do", "|", "child", "|", "# Don't move the temp_dir", "next", "if", "child", "==", "temp_dir", "# Move every other directory into the temporary directory", "@logger", ".", "debug", "(", "\"Copying to upgrade directory: #{child}\"", ")", "FileUtils", ".", "mv", "(", "child", ",", "temp_dir", ".", "join", "(", "child", ".", "basename", ")", ")", "end", "# If there is no metadata.json file, make one, since this is how", "# we determine if the box is a V2 box.", "metadata_file", "=", "temp_dir", ".", "join", "(", "\"metadata.json\"", ")", "if", "!", "metadata_file", ".", "file?", "metadata_file", ".", "open", "(", "\"w\"", ")", "do", "|", "f", "|", "f", ".", "write", "(", "JSON", ".", "generate", "(", "{", "provider", ":", "\"virtualbox\"", "}", ")", ")", "end", "end", "# Return the temporary directory", "temp_dir", "end" ]

[ "This", "upgrades", "the", "V1", "box", "contained", "unpacked", "in", "the", "given", "directory", "and", "returns", "the", "directory", "of", "the", "upgraded", "version", ".", "This", "is", "_destructive_", "to", "the", "contents", "of", "the", "old", "directory", ".", "That", "is", "the", "contents", "of", "the", "old", "V1", "box", "will", "be", "destroyed", "or", "moved", "." ]

[ "def", "with_temp_dir", "(", "dir", "=", "nil", ")", "dir", "||=", "Dir", ".", "mktmpdir", "(", "TEMP_PREFIX", ",", "@temp_root", ")", "dir", "=", "Pathname", ".", "new", "(", "dir", ")", "yield", "dir", "ensure", "FileUtils", ".", "rm_rf", "(", "dir", ".", "to_s", ")", "end" ]

[ "This", "is", "a", "helper", "that", "makes", "sure", "that", "our", "temporary", "directories", "are", "cleaned", "up", "no", "matter", "what", "." ]

[ "def", "initialize_capabilities!", "(", "host", ",", "hosts", ",", "capabilities", ",", "*", "args", ")", "@cap_logger", "=", "Log4r", "::", "Logger", ".", "new", "(", "\"vagrant::capability_host::#{self.class.to_s.downcase}\"", ")", "if", "host", "&&", "!", "hosts", "[", "host", "]", "raise", "Errors", "::", "CapabilityHostExplicitNotDetected", ",", "value", ":", "host", ".", "to_s", "end", "if", "!", "host", "host", "=", "autodetect_capability_host", "(", "hosts", ",", "args", ")", "if", "!", "host", "raise", "Errors", "::", "CapabilityHostNotDetected", "if", "!", "host", "end", "if", "!", "hosts", "[", "host", "]", "# This should never happen because the autodetect above uses the", "# hosts hash to look up hosts. And if an explicit host is specified,", "# we do another check higher up.", "raise", "\"Internal error. Host not found: #{host}\"", "end", "name", "=", "host", "host_info", "=", "hosts", "[", "name", "]", "host", "=", "host_info", "[", "0", "]", ".", "new", "chain", "=", "[", "]", "chain", "<<", "[", "name", ",", "host", "]", "# Build the proper chain of parents if there are any.", "# This allows us to do \"inheritance\" of capabilities later", "if", "host_info", "[", "1", "]", "parent_name", "=", "host_info", "[", "1", "]", "parent_info", "=", "hosts", "[", "parent_name", "]", "while", "parent_info", "chain", "<<", "[", "parent_name", ",", "parent_info", "[", "0", "]", ".", "new", "]", "parent_name", "=", "parent_info", "[", "1", "]", "parent_info", "=", "hosts", "[", "parent_name", "]", "end", "end", "@cap_host_chain", "=", "chain", "@cap_args", "=", "args", "@cap_caps", "=", "capabilities", "true", "end" ]

[ "Initializes", "the", "capability", "system", "by", "detecting", "the", "proper", "capability", "host", "to", "execute", "on", "and", "building", "the", "chain", "of", "capabilities", "to", "execute", "." ]

[ "def", "capability", "(", "cap_name", ",", "*", "args", ")", "cap_mod", "=", "capability_module", "(", "cap_name", ".", "to_sym", ")", "if", "!", "cap_mod", "raise", "Errors", "::", "CapabilityNotFound", ",", "cap", ":", "cap_name", ".", "to_s", ",", "host", ":", "@cap_host_chain", "[", "0", "]", "[", "0", "]", ".", "to_s", "end", "cap_method", "=", "nil", "begin", "cap_method", "=", "cap_mod", ".", "method", "(", "cap_name", ")", "rescue", "NameError", "raise", "Errors", "::", "CapabilityInvalid", ",", "cap", ":", "cap_name", ".", "to_s", ",", "host", ":", "@cap_host_chain", "[", "0", "]", "[", "0", "]", ".", "to_s", "end", "args", "=", "@cap_args", "+", "args", "@cap_logger", ".", "info", "(", "\"Execute capability: #{cap_name} #{args.inspect} (#{@cap_host_chain[0][0]})\"", ")", "cap_method", ".", "call", "(", "args", ")", "end" ]

[ "Executes", "the", "capability", "with", "the", "given", "name", "optionally", "passing", "more", "arguments", "onwards", "to", "the", "capability", ".", "If", "the", "capability", "returns", "a", "value", "it", "will", "be", "returned", "." ]

[ "def", "capability_module", "(", "cap_name", ")", "@cap_logger", ".", "debug", "(", "\"Searching for cap: #{cap_name}\"", ")", "@cap_host_chain", ".", "each", "do", "|", "host_name", ",", "host", "|", "@cap_logger", ".", "debug", "(", "\"Checking in: #{host_name}\"", ")", "caps", "=", "@cap_caps", "[", "host_name", "]", "if", "caps", "&&", "caps", ".", "key?", "(", "cap_name", ")", "@cap_logger", ".", "debug", "(", "\"Found cap: #{cap_name} in #{host_name}\"", ")", "return", "caps", "[", "cap_name", "]", "end", "end", "nil", "end" ]

[ "Returns", "the", "registered", "module", "for", "a", "capability", "with", "the", "given", "name", "." ]

[ "def", "in_use?", "(", "index", ")", "results", "=", "[", "]", "index", ".", "each", "do", "|", "entry", "|", "box_data", "=", "entry", ".", "extra_data", "[", "\"box\"", "]", "next", "if", "!", "box_data", "# If all the data matches, record it", "if", "box_data", "[", "\"name\"", "]", "==", "self", ".", "name", "&&", "box_data", "[", "\"provider\"", "]", "==", "self", ".", "provider", ".", "to_s", "&&", "box_data", "[", "\"version\"", "]", "==", "self", ".", "version", ".", "to_s", "results", "<<", "entry", "end", "end", "return", "nil", "if", "results", ".", "empty?", "results", "end" ]

[ "Checks", "if", "this", "box", "is", "in", "use", "according", "to", "the", "given", "machine", "index", "and", "returns", "the", "entries", "that", "appear", "to", "be", "using", "the", "box", "." ]

[ "def", "load_metadata", "(", "**", "download_options", ")", "tf", "=", "Tempfile", ".", "new", "(", "\"vagrant-load-metadata\"", ")", "tf", ".", "close", "url", "=", "@metadata_url", "if", "File", ".", "file?", "(", "url", ")", "||", "url", "!~", "/", "/i", "url", "=", "File", ".", "expand_path", "(", "url", ")", "url", "=", "Util", "::", "Platform", ".", "cygwin_windows_path", "(", "url", ")", "url", "=", "\"file:#{url}\"", "end", "opts", "=", "{", "headers", ":", "[", "\"Accept: application/json\"", "]", "}", ".", "merge", "(", "download_options", ")", "Util", "::", "Downloader", ".", "new", "(", "url", ",", "tf", ".", "path", ",", "**", "opts", ")", ".", "download!", "BoxMetadata", ".", "new", "(", "File", ".", "open", "(", "tf", ".", "path", ",", "\"r\"", ")", ")", "rescue", "Errors", "::", "DownloaderError", "=>", "e", "raise", "Errors", "::", "BoxMetadataDownloadError", ",", "message", ":", "e", ".", "extra_data", "[", ":message", "]", "ensure", "tf", ".", "unlink", "if", "tf", "end" ]

[ "Loads", "the", "metadata", "URL", "and", "returns", "the", "latest", "metadata", "associated", "with", "this", "box", "." ]

[ "def", "has_update?", "(", "version", "=", "nil", ",", "download_options", ":", "{", "}", ")", "if", "!", "@metadata_url", "raise", "Errors", "::", "BoxUpdateNoMetadata", ",", "name", ":", "@name", "end", "if", "download_options", ".", "delete", "(", ":automatic_check", ")", "&&", "!", "automatic_update_check_allowed?", "@logger", ".", "info", "(", "\"Skipping box update check\"", ")", "return", "end", "version", "+=", "\", \"", "if", "version", "version", "||=", "\"\"", "version", "+=", "\"> #{@version}\"", "md", "=", "self", ".", "load_metadata", "(", "download_options", ")", "newer", "=", "md", ".", "version", "(", "version", ",", "provider", ":", "@provider", ")", "return", "nil", "if", "!", "newer", "[", "md", ",", "newer", ",", "newer", ".", "provider", "(", "@provider", ")", "]", "end" ]

[ "Checks", "if", "the", "box", "has", "an", "update", "and", "returns", "the", "metadata", "version", "and", "provider", ".", "If", "the", "box", "doesn", "t", "have", "an", "update", "that", "satisfies", "the", "constraints", "it", "will", "return", "nil", "." ]

[ "def", "automatic_update_check_allowed?", "check_path", "=", "directory", ".", "join", "(", "\"box_update_check\"", ")", "if", "check_path", ".", "exist?", "last_check_span", "=", "Time", ".", "now", ".", "to_i", "-", "check_path", ".", "mtime", ".", "to_i", "if", "last_check_span", "<", "BOX_UPDATE_CHECK_INTERVAL", "@logger", ".", "info", "(", "\"box update check is under the interval threshold\"", ")", "return", "false", "end", "end", "FileUtils", ".", "touch", "(", "check_path", ")", "true", "end" ]

[ "Check", "if", "a", "box", "update", "check", "is", "allowed", ".", "Uses", "a", "file", "in", "the", "box", "data", "directory", "to", "track", "when", "the", "last", "auto", "update", "check", "was", "performed", "and", "returns", "true", "if", "the", "BOX_UPDATE_CHECK_INTERVAL", "has", "passed", "." ]

[ "def", "repackage", "(", "path", ")", "@logger", ".", "debug", "(", "\"Repackaging box '#{@name}' to: #{path}\"", ")", "Util", "::", "SafeChdir", ".", "safe_chdir", "(", "@directory", ")", "do", "# Find all the files in our current directory and tar it up!", "files", "=", "Dir", ".", "glob", "(", "File", ".", "join", "(", "\".\"", ",", "\"**\"", ",", "\"*\"", ")", ")", ".", "select", "{", "|", "f", "|", "File", ".", "file?", "(", "f", ")", "}", "# Package!", "Util", "::", "Subprocess", ".", "execute", "(", "\"bsdtar\"", ",", "\"-czf\"", ",", "path", ".", "to_s", ",", "files", ")", "end", "@logger", ".", "info", "(", "\"Repackaged box '#{@name}' successfully: #{path}\"", ")", "true", "end" ]

[ "This", "repackages", "this", "box", "and", "outputs", "it", "to", "the", "given", "path", "." ]

[ "def", "interpret", "(", "line", ")", "# is it a comment?", "return", "nil", "if", "line", ".", "strip", ".", "start_with?", "(", "\"#\"", ")", "keyword", ",", "command", "=", "line", ".", "split", "(", "\"=\"", ",", "2", ")", ".", "collect", "(", ":strip", ")", "# validate the keyword", "if", "keyword", ".", "match", "(", "/", "\\s", "/i", ")", "raise", "Errors", "::", "AliasInvalidError", ",", "alias", ":", "line", ",", "message", ":", "\"Alias keywords must not contain any whitespace.\"", "end", "[", "keyword", ",", "command", "]", "end" ]

[ "This", "interprets", "a", "raw", "line", "from", "the", "aliases", "file", "." ]

[ "def", "register", "(", "keyword", ",", "command", ")", "@aliases", ".", "register", "(", "keyword", ".", "to_sym", ")", "do", "lambda", "do", "|", "args", "|", "# directly execute shell commands", "if", "command", ".", "start_with?", "(", "\"!\"", ")", "return", "Util", "::", "SafeExec", ".", "exec", "\"#{command[1..-1]} #{args.join(\" \")}\"", ".", "strip", "end", "return", "CLI", ".", "new", "(", "command", ".", "split", ".", "concat", "(", "args", ")", ",", "@env", ")", ".", "execute", "end", "end", "end" ]

[ "This", "registers", "an", "alias", "." ]

[ "def", "redirect", "(", "uri", ",", "*", "args", ")", "if", "env", "[", "'HTTP_VERSION'", "]", "==", "'HTTP/1.1'", "and", "env", "[", "\"REQUEST_METHOD\"", "]", "!=", "'GET'", "status", "303", "else", "status", "302", "end", "# According to RFC 2616 section 14.30, \"the field value consists of a", "# single absolute URI\"", "response", "[", "'Location'", "]", "=", "uri", "(", "uri", ",", "settings", ".", "absolute_redirects?", ",", "settings", ".", "prefixed_redirects?", ")", "halt", "(", "args", ")", "end" ]

[ "Halt", "processing", "and", "redirect", "to", "the", "URI", "provided", "." ]

[ "def", "uri", "(", "addr", "=", "nil", ",", "absolute", "=", "true", ",", "add_script_name", "=", "true", ")", "return", "addr", "if", "addr", "=~", "/", "\\A", "\\+", "\\.", "\\-", "/", "uri", "=", "[", "host", "=", "\"\"", "]", "if", "absolute", "host", "<<", "\"http#{'s' if request.secure?}://\"", "if", "request", ".", "forwarded?", "or", "request", ".", "port", "!=", "(", "request", ".", "secure?", "?", "443", ":", "80", ")", "host", "<<", "request", ".", "host_with_port", "else", "host", "<<", "request", ".", "host", "end", "end", "uri", "<<", "request", ".", "script_name", ".", "to_s", "if", "add_script_name", "uri", "<<", "(", "addr", "?", "addr", ":", "request", ".", "path_info", ")", ".", "to_s", "File", ".", "join", "uri", "end" ]

[ "Generates", "the", "absolute", "URI", "for", "a", "given", "path", "in", "the", "app", ".", "Takes", "Rack", "routers", "and", "reverse", "proxies", "into", "account", "." ]

[ "def", "content_type", "(", "type", "=", "nil", ",", "params", "=", "{", "}", ")", "return", "response", "[", "'Content-Type'", "]", "unless", "type", "default", "=", "params", ".", "delete", ":default", "mime_type", "=", "mime_type", "(", "type", ")", "||", "default", "fail", "\"Unknown media type: %p\"", "%", "type", "if", "mime_type", ".", "nil?", "mime_type", "=", "mime_type", ".", "dup", "unless", "params", ".", "include?", ":charset", "or", "settings", ".", "add_charset", ".", "all?", "{", "|", "p", "|", "not", "p", "===", "mime_type", "}", "params", "[", ":charset", "]", "=", "params", ".", "delete", "(", "'charset'", ")", "||", "settings", ".", "default_encoding", "end", "params", ".", "delete", ":charset", "if", "mime_type", ".", "include?", "'charset'", "unless", "params", ".", "empty?", "mime_type", "<<", "(", "mime_type", ".", "include?", "(", "';'", ")", "?", "', '", ":", "';'", ")", "mime_type", "<<", "params", ".", "map", "{", "|", "kv", "|", "kv", ".", "join", "(", "'='", ")", "}", ".", "join", "(", "', '", ")", "end", "response", "[", "'Content-Type'", "]", "=", "mime_type", "end" ]

[ "Set", "the", "Content", "-", "Type", "of", "the", "response", "body", "given", "a", "media", "type", "or", "file", "extension", "." ]

[ "def", "stream", "(", "keep_open", "=", "false", ")", "scheduler", "=", "env", "[", "'async.callback'", "]", "?", "EventMachine", ":", "Stream", "current", "=", "@params", ".", "dup", "body", "Stream", ".", "new", "(", "scheduler", ",", "keep_open", ")", "{", "|", "out", "|", "with_params", "(", "current", ")", "{", "yield", "(", "out", ")", "}", "}", "end" ]

[ "Allows", "to", "start", "sending", "data", "to", "the", "client", "even", "though", "later", "parts", "of", "the", "response", "body", "have", "not", "yet", "been", "generated", "." ]

[ "def", "etag_matches?", "(", "list", ",", "new_resource", "=", "request", ".", "post?", ")", "return", "!", "new_resource", "if", "list", "==", "'*'", "list", ".", "to_s", ".", "split", "(", "/", "\\s", "\\s", "/", ")", ".", "include?", "response", "[", "'ETag'", "]", "end" ]

[ "Helper", "method", "checking", "if", "a", "ETag", "value", "list", "includes", "the", "current", "ETag", "." ]

[ "def", "render_ruby", "(", "engine", ",", "template", ",", "options", "=", "{", "}", ",", "locals", "=", "{", "}", ",", "&", "block", ")", "options", ",", "template", "=", "template", ",", "nil", "if", "template", ".", "is_a?", "(", "Hash", ")", "template", "=", "Proc", ".", "new", "{", "block", "}", "if", "template", ".", "nil?", "render", "engine", ",", "template", ",", "options", ",", "locals", "end" ]

[ "logic", "shared", "between", "builder", "and", "nokogiri" ]

[ "def", "filter!", "(", "type", ",", "base", "=", "settings", ")", "filter!", "type", ",", "base", ".", "superclass", "if", "base", ".", "superclass", ".", "respond_to?", "(", ":filters", ")", "base", ".", "filters", "[", "type", "]", ".", "each", "{", "|", "args", "|", "process_route", "(", "args", ")", "}", "end" ]

[ "Run", "filters", "defined", "on", "the", "class", "and", "all", "superclasses", "." ]

[ "def", "route!", "(", "base", "=", "settings", ",", "pass_block", "=", "nil", ")", "if", "routes", "=", "base", ".", "routes", "[", "@request", ".", "request_method", "]", "routes", ".", "each", "do", "|", "pattern", ",", "keys", ",", "conditions", ",", "block", "|", "pass_block", "=", "process_route", "(", "pattern", ",", "keys", ",", "conditions", ")", "do", "|", "*", "args", "|", "route_eval", "{", "block", "[", "args", "]", "}", "end", "end", "end", "# Run routes defined in superclass.", "if", "base", ".", "superclass", ".", "respond_to?", "(", ":routes", ")", "return", "route!", "(", "base", ".", "superclass", ",", "pass_block", ")", "end", "route_eval", "(", "pass_block", ")", "if", "pass_block", "route_missing", "end" ]

[ "Run", "routes", "defined", "on", "the", "class", "and", "all", "superclasses", "." ]

[ "def", "indifferent_hash", "Hash", ".", "new", "{", "|", "hash", ",", "key", "|", "hash", "[", "key", ".", "to_s", "]", "if", "Symbol", "===", "key", "}", "end" ]

[ "Creates", "a", "Hash", "with", "indifferent", "access", "." ]

[ "def", "_reduce_22", "(", "val", ",", "_values", ",", "result", ")", "n", "=", "val", "[", "0", "]", ";", "result", "=", "n", ".", "count", "(", "'.'", ")", ">", "0", "?", "n", ".", "to_f", ":", "n", ".", "to_i", "result", "end" ]

[ "reduce", "21", "omitted" ]

[ "def", "dry_run", "begin", "Fluent", "::", "Engine", ".", "dry_run_mode", "=", "true", "change_privilege", "init_engine", "run_configure", "rescue", "Fluent", "::", "ConfigError", "=>", "e", "$log", ".", "error", "\"config error\"", ",", "file", ":", "@config_path", ",", "error", ":", "e", "$log", ".", "debug_backtrace", "exit!", "(", "1", ")", "ensure", "Fluent", "::", "Engine", ".", "dry_run_mode", "=", "false", "end", "end" ]

[ "Set", "Engine", "s", "dry_run_mode", "true", "to", "override", "all", "target_id", "of", "worker", "sections" ]

[ "def", "slice", "(", "index", ",", "num", ")", "ensure_unpacked!", "MultiEventStream", ".", "new", "(", "@unpacked_times", ".", "slice", "(", "index", ",", "num", ")", ",", "@unpacked_records", ".", "slice", "(", "index", ",", "num", ")", ")", "end" ]

[ "This", "method", "returns", "MultiEventStream", "because", "there", "are", "no", "reason", "to", "surve", "binary", "serialized", "by", "msgpack", "." ]

[ "def", "read_ack_from_sock", "(", "sock", ",", "unpacker", ")", "begin", "raw_data", "=", "sock", ".", "instance_of?", "(", "Fluent", "::", "PluginHelper", "::", "Socket", "::", "WrappedSocket", "::", "TLS", ")", "?", "sock", ".", "readpartial", "(", "@read_length", ")", ":", "sock", ".", "recv", "(", "@read_length", ")", "rescue", "Errno", "::", "ECONNRESET", ",", "EOFError", "# ECONNRESET for #recv, #EOFError for #readpartial", "raw_data", "=", "\"\"", "end", "info", "=", "@sock_ack_waiting_mutex", ".", "synchronize", "{", "@sock_ack_waiting", ".", "find", "{", "|", "i", "|", "i", ".", "sock", "==", "sock", "}", "}", "# When connection is closed by remote host, socket is ready to read and #recv returns an empty string that means EOF.", "# If this happens we assume the data wasn't delivered and retry it.", "if", "raw_data", ".", "empty?", "log", ".", "warn", "\"destination node closed the connection. regard it as unavailable.\"", ",", "host", ":", "info", ".", "node", ".", "host", ",", "port", ":", "info", ".", "node", ".", "port", "info", ".", "node", ".", "disable!", "rollback_write", "(", "info", ".", "chunk_id", ",", "update_retry", ":", "false", ")", "return", "nil", "else", "unpacker", ".", "feed", "(", "raw_data", ")", "res", "=", "unpacker", ".", "read", "log", ".", "trace", "\"getting response from destination\"", ",", "host", ":", "info", ".", "node", ".", "host", ",", "port", ":", "info", ".", "node", ".", "port", ",", "chunk_id", ":", "dump_unique_id_hex", "(", "info", ".", "chunk_id", ")", ",", "response", ":", "res", "if", "res", "[", "'ack'", "]", "!=", "info", ".", "chunk_id_base64", "# Some errors may have occurred when ack and chunk id is different, so send the chunk again.", "log", ".", "warn", "\"ack in response and chunk id in sent data are different\"", ",", "chunk_id", ":", "dump_unique_id_hex", "(", "info", ".", "chunk_id", ")", ",", "ack", ":", "res", "[", "'ack'", "]", "rollback_write", "(", "info", ".", "chunk_id", ",", "update_retry", ":", "false", ")", "return", "nil", "else", "log", ".", "trace", "\"got a correct ack response\"", ",", "chunk_id", ":", "dump_unique_id_hex", "(", "info", ".", "chunk_id", ")", "end", "return", "info", ".", "chunk_id", "end", "rescue", "=>", "e", "log", ".", "error", "\"unexpected error while receiving ack message\"", ",", "error", ":", "e", "log", ".", "error_backtrace", "ensure", "info", ".", "sock", ".", "close_write", "rescue", "nil", "info", ".", "sock", ".", "close", "rescue", "nil", "@sock_ack_waiting_mutex", ".", "synchronize", "do", "@sock_ack_waiting", ".", "delete", "(", "info", ")", "end", "end" ]

[ "return", "chunk", "id", "to", "be", "committed" ]

[ "def", "parse_unixtime", "(", "value", ")", "unless", "value", ".", "is_a?", "(", "String", ")", "||", "value", ".", "is_a?", "(", "Numeric", ")", "raise", "TimeParseError", ",", "\"value must be a string or a number: #{value}(value.class)\"", "end", "if", "@cache1_key", "==", "value", "return", "@cache1_time", "elsif", "@cache2_key", "==", "value", "return", "@cache2_time", "end", "begin", "time", "=", "Fluent", "::", "EventTime", ".", "new", "(", "value", ".", "to_i", ")", "rescue", "=>", "e", "raise", "TimeParseError", ",", "\"invalid time format: value = #{value}, error_class = #{e.class.name}, error = #{e.message}\"", "end", "@cache1_key", "=", "@cache2_key", "@cache1_time", "=", "@cache2_time", "@cache2_key", "=", "value", "@cache2_time", "=", "time", "time", "end" ]

[ "to", "include", "TimeParseError" ]

[ "def", "plugin_info_by_id", "(", "plugin_id", ",", "opts", "=", "{", "}", ")", "found", "=", "all_plugins", ".", "find", "{", "|", "pe", "|", "pe", ".", "respond_to?", "(", ":plugin_id", ")", "&&", "pe", ".", "plugin_id", ".", "to_s", "==", "plugin_id", "}", "if", "found", "get_monitor_info", "(", "found", ",", "opts", ")", "else", "nil", "end", "end" ]

[ "search", "a", "plugin", "by", "plugin_id" ]

[ "def", "plugins_info_by_type", "(", "type", ",", "opts", "=", "{", "}", ")", "array", "=", "all_plugins", ".", "select", "{", "|", "pe", "|", "(", "pe", ".", "config", "[", "'@type'", "]", "==", "type", ")", "rescue", "nil", "}", "array", ".", "map", "{", "|", "pe", "|", "get_monitor_info", "(", "pe", ",", "opts", ")", "}", "end" ]

[ "This", "method", "returns", "an", "array", "because", "multiple", "plugins", "could", "have", "the", "same", "type" ]

[ "def", "get_monitor_info", "(", "pe", ",", "opts", "=", "{", "}", ")", "obj", "=", "{", "}", "# Common plugin information", "obj", "[", "'plugin_id'", "]", "=", "pe", ".", "plugin_id", "obj", "[", "'plugin_category'", "]", "=", "plugin_category", "(", "pe", ")", "obj", "[", "'type'", "]", "=", "pe", ".", "config", "[", "'@type'", "]", "obj", "[", "'config'", "]", "=", "pe", ".", "config", "if", "opts", "[", ":with_config", "]", "# run MONITOR_INFO in plugins' instance context and store the info to obj", "MONITOR_INFO", ".", "each_pair", "{", "|", "key", ",", "code", "|", "begin", "catch", "(", ":skip", ")", "do", "obj", "[", "key", "]", "=", "pe", ".", "instance_exec", "(", "code", ")", "end", "rescue", "NoMethodError", "=>", "e", "unless", "@first_warn", "log", ".", "error", "\"NoMethodError in monitoring plugins\"", ",", "key", ":", "key", ",", "plugin", ":", "pe", ".", "class", ",", "error", ":", "e", "log", ".", "error_backtrace", "@first_warn", "=", "true", "end", "rescue", "=>", "e", "log", ".", "warn", "\"unexpected error in monitoring plugins\"", ",", "key", ":", "key", ",", "plugin", ":", "pe", ".", "class", ",", "error", ":", "e", "end", "}", "obj", "[", "'retry'", "]", "=", "get_retry_info", "(", "pe", ".", "retry", ")", "if", "opts", "[", ":with_retry", "]", "and", "pe", ".", "instance_variable_defined?", "(", ":@retry", ")", "# include all instance variables if :with_debug_info is set", "if", "opts", "[", ":with_debug_info", "]", "iv", "=", "{", "}", "pe", ".", "instance_eval", "do", "instance_variables", ".", "each", "{", "|", "sym", "|", "next", "if", "IGNORE_ATTRIBUTES", ".", "include?", "(", "sym", ")", "key", "=", "sym", ".", "to_s", "[", "1", "..", "-", "1", "]", "# removes first '@'", "iv", "[", "key", "]", "=", "instance_variable_get", "(", "sym", ")", "}", "end", "obj", "[", "'instance_variables'", "]", "=", "iv", "elsif", "ivars", "=", "opts", "[", ":ivars", "]", "iv", "=", "{", "}", "ivars", ".", "each", "{", "|", "name", "|", "iname", "=", "\"@#{name}\"", "iv", "[", "name", "]", "=", "pe", ".", "instance_variable_get", "(", "iname", ")", "if", "pe", ".", "instance_variable_defined?", "(", "iname", ")", "}", "obj", "[", "'instance_variables'", "]", "=", "iv", "end", "obj", "end" ]

[ "get", "monitor", "info", "from", "the", "plugin", "pe", "and", "return", "a", "hash", "object" ]

[ "def", "sanitize", "(", "action", ")", "permissions", "=", "@permitted", "[", "action", "]", "if", "permissions", ".", "respond_to?", "(", ":call", ")", "cast_to_hash", "permissions", ".", "call", "(", "default_params", ")", "elsif", "permissions", ".", "present?", "cast_to_hash", "permit_keys", "(", "default_params", ",", "permissions", ")", "else", "unknown_action!", "(", "action", ")", "end", "end" ]

[ "Sanitize", "the", "parameters", "for", "a", "specific", "+", "action", "+", "." ]

[ "def", "permit", "(", "action", ",", "keys", ":", "nil", ",", "except", ":", "nil", ",", "&", "block", ")", "if", "block_given?", "@permitted", "[", "action", "]", "=", "block", "end", "if", "keys", ".", "present?", "@permitted", "[", "action", "]", "||=", "@auth_keys", ".", "dup", "@permitted", "[", "action", "]", ".", "concat", "(", "keys", ")", "end", "if", "except", ".", "present?", "@permitted", "[", "action", "]", "||=", "@auth_keys", ".", "dup", "@permitted", "[", "action", "]", "=", "@permitted", "[", "action", "]", "-", "except", "end", "end" ]

[ "Add", "or", "remove", "new", "parameters", "to", "the", "permitted", "list", "of", "an", "+", "action", "+", "." ]

[ "def", "stringify_params", "(", "conditions", ")", "return", "conditions", "unless", "conditions", ".", "is_a?", "(", "Hash", ")", "conditions", ".", "each", "do", "|", "k", ",", "v", "|", "conditions", "[", "k", "]", "=", "v", ".", "to_s", "if", "param_requires_string_conversion?", "(", "v", ")", "end", "end" ]

[ "Force", "keys", "to", "be", "string", "to", "avoid", "injection", "on", "mongoid", "related", "database", "." ]

[ "def", "parse", "(", "source", ",", "options", "=", "{", "}", ")", "@options", "=", "options", "@profiling", "=", "options", "[", ":profile", "]", "@line_numbers", "=", "options", "[", ":line_numbers", "]", "||", "@profiling", "parse_context", "=", "options", ".", "is_a?", "(", "ParseContext", ")", "?", "options", ":", "ParseContext", ".", "new", "(", "options", ")", "@root", "=", "Document", ".", "parse", "(", "tokenize", "(", "source", ")", ",", "parse_context", ")", "@warnings", "=", "parse_context", ".", "warnings", "self", "end" ]

[ "Parse", "source", "code", ".", "Returns", "self", "for", "easy", "chaining" ]

[ "def", "render", "(", "*", "args", ")", "return", "''", ".", "freeze", "if", "@root", ".", "nil?", "context", "=", "case", "args", ".", "first", "when", "Liquid", "::", "Context", "c", "=", "args", ".", "shift", "if", "@rethrow_errors", "c", ".", "exception_renderer", "=", "->", "(", "e", ")", "{", "raise", "}", "end", "c", "when", "Liquid", "::", "Drop", "drop", "=", "args", ".", "shift", "drop", ".", "context", "=", "Context", ".", "new", "(", "[", "drop", ",", "assigns", "]", ",", "instance_assigns", ",", "registers", ",", "@rethrow_errors", ",", "@resource_limits", ")", "when", "Hash", "Context", ".", "new", "(", "[", "args", ".", "shift", ",", "assigns", "]", ",", "instance_assigns", ",", "registers", ",", "@rethrow_errors", ",", "@resource_limits", ")", "when", "nil", "Context", ".", "new", "(", "assigns", ",", "instance_assigns", ",", "registers", ",", "@rethrow_errors", ",", "@resource_limits", ")", "else", "raise", "ArgumentError", ",", "\"Expected Hash or Liquid::Context as parameter\"", "end", "case", "args", ".", "last", "when", "Hash", "options", "=", "args", ".", "pop", "registers", ".", "merge!", "(", "options", "[", ":registers", "]", ")", "if", "options", "[", ":registers", "]", ".", "is_a?", "(", "Hash", ")", "apply_options_to_context", "(", "context", ",", "options", ")", "when", "Module", ",", "Array", "context", ".", "add_filters", "(", "args", ".", "pop", ")", "end", "# Retrying a render resets resource usage", "context", ".", "resource_limits", ".", "reset", "begin", "# render the nodelist.", "# for performance reasons we get an array back here. join will make a string out of it.", "result", "=", "with_profiling", "(", "context", ")", "do", "@root", ".", "render", "(", "context", ")", "end", "result", ".", "respond_to?", "(", ":join", ")", "?", "result", ".", "join", ":", "result", "rescue", "Liquid", "::", "MemoryError", "=>", "e", "context", ".", "handle_error", "(", "e", ")", "ensure", "@errors", "=", "context", ".", "errors", "end", "end" ]

[ "Render", "takes", "a", "hash", "with", "local", "variables", "." ]

[ "def", "truncate", "(", "input", ",", "length", "=", "50", ",", "truncate_string", "=", "\"...\"", ".", "freeze", ")", "return", "if", "input", ".", "nil?", "input_str", "=", "input", ".", "to_s", "length", "=", "Utils", ".", "to_integer", "(", "length", ")", "truncate_string_str", "=", "truncate_string", ".", "to_s", "l", "=", "length", "-", "truncate_string_str", ".", "length", "l", "=", "0", "if", "l", "<", "0", "input_str", ".", "length", ">", "length", "?", "input_str", "[", "0", "...", "l", "]", "+", "truncate_string_str", ":", "input_str", "end" ]

[ "Truncate", "a", "string", "down", "to", "x", "characters" ]

[ "def", "sort", "(", "input", ",", "property", "=", "nil", ")", "ary", "=", "InputIterator", ".", "new", "(", "input", ")", "return", "[", "]", "if", "ary", ".", "empty?", "if", "property", ".", "nil?", "ary", ".", "sort", "do", "|", "a", ",", "b", "|", "nil_safe_compare", "(", "a", ",", "b", ")", "end", "elsif", "ary", ".", "all?", "{", "|", "el", "|", "el", ".", "respond_to?", "(", ":[]", ")", "}", "begin", "ary", ".", "sort", "{", "|", "a", ",", "b", "|", "nil_safe_compare", "(", "a", "[", "property", "]", ",", "b", "[", "property", "]", ")", "}", "rescue", "TypeError", "raise_property_error", "(", "property", ")", "end", "end", "end" ]

[ "Sort", "elements", "of", "the", "array", "provide", "optional", "property", "with", "which", "to", "sort", "an", "array", "of", "hashes", "or", "drops" ]

[ "def", "where", "(", "input", ",", "property", ",", "target_value", "=", "nil", ")", "ary", "=", "InputIterator", ".", "new", "(", "input", ")", "if", "ary", ".", "empty?", "[", "]", "elsif", "ary", ".", "first", ".", "respond_to?", "(", ":[]", ")", "&&", "target_value", ".", "nil?", "begin", "ary", ".", "select", "{", "|", "item", "|", "item", "[", "property", "]", "}", "rescue", "TypeError", "raise_property_error", "(", "property", ")", "end", "elsif", "ary", ".", "first", ".", "respond_to?", "(", ":[]", ")", "begin", "ary", ".", "select", "{", "|", "item", "|", "item", "[", "property", "]", "==", "target_value", "}", "rescue", "TypeError", "raise_property_error", "(", "property", ")", "end", "end", "end" ]

[ "Filter", "the", "elements", "of", "an", "array", "to", "those", "with", "a", "certain", "property", "value", ".", "By", "default", "the", "target", "is", "any", "truthy", "value", "." ]

[ "def", "uniq", "(", "input", ",", "property", "=", "nil", ")", "ary", "=", "InputIterator", ".", "new", "(", "input", ")", "if", "property", ".", "nil?", "ary", ".", "uniq", "elsif", "ary", ".", "empty?", "# The next two cases assume a non-empty array.", "[", "]", "elsif", "ary", ".", "first", ".", "respond_to?", "(", ":[]", ")", "begin", "ary", ".", "uniq", "{", "|", "a", "|", "a", "[", "property", "]", "}", "rescue", "TypeError", "raise_property_error", "(", "property", ")", "end", "end", "end" ]

[ "Remove", "duplicate", "elements", "from", "an", "array", "provide", "optional", "property", "with", "which", "to", "determine", "uniqueness" ]

[ "def", "replace", "(", "input", ",", "string", ",", "replacement", "=", "''", ".", "freeze", ")", "input", ".", "to_s", ".", "gsub", "(", "string", ".", "to_s", ",", "replacement", ".", "to_s", ")", "end" ]

[ "Replace", "occurrences", "of", "a", "string", "with", "another" ]

[ "def", "replace_first", "(", "input", ",", "string", ",", "replacement", "=", "''", ".", "freeze", ")", "input", ".", "to_s", ".", "sub", "(", "string", ".", "to_s", ",", "replacement", ".", "to_s", ")", "end" ]

[ "Replace", "the", "first", "occurrences", "of", "a", "string", "with", "another" ]

[ "def", "stack", "(", "new_scope", "=", "nil", ")", "old_stack_used", "=", "@this_stack_used", "if", "new_scope", "push", "(", "new_scope", ")", "@this_stack_used", "=", "true", "else", "@this_stack_used", "=", "false", "end", "yield", "ensure", "pop", "if", "@this_stack_used", "@this_stack_used", "=", "old_stack_used", "end" ]

[ "Pushes", "a", "new", "local", "scope", "on", "the", "stack", "pops", "it", "at", "the", "end", "of", "the", "block" ]

[ "def", "find_variable", "(", "key", ",", "raise_on_not_found", ":", "true", ")", "# This was changed from find() to find_index() because this is a very hot", "# path and find_index() is optimized in MRI to reduce object allocation", "index", "=", "@scopes", ".", "find_index", "{", "|", "s", "|", "s", ".", "key?", "(", "key", ")", "}", "scope", "=", "@scopes", "[", "index", "]", "if", "index", "variable", "=", "nil", "if", "scope", ".", "nil?", "@environments", ".", "each", "do", "|", "e", "|", "variable", "=", "lookup_and_evaluate", "(", "e", ",", "key", ",", "raise_on_not_found", ":", "raise_on_not_found", ")", "# When lookup returned a value OR there is no value but the lookup also did not raise", "# then it is the value we are looking for.", "if", "!", "variable", ".", "nil?", "||", "@strict_variables", "&&", "raise_on_not_found", "scope", "=", "e", "break", "end", "end", "end", "scope", "||=", "@environments", ".", "last", "||", "@scopes", ".", "last", "variable", "||=", "lookup_and_evaluate", "(", "scope", ",", "key", ",", "raise_on_not_found", ":", "raise_on_not_found", ")", "variable", "=", "variable", ".", "to_liquid", "variable", ".", "context", "=", "self", "if", "variable", ".", "respond_to?", "(", ":context=", ")", "variable", "end" ]

[ "Fetches", "an", "object", "starting", "at", "the", "local", "scope", "and", "then", "moving", "up", "the", "hierachy" ]

[ "def", "deserialize_offenses", "(", "offenses", ")", "source_buffer", "=", "Parser", "::", "Source", "::", "Buffer", ".", "new", "(", "@filename", ")", "source_buffer", ".", "source", "=", "File", ".", "read", "(", "@filename", ",", "encoding", ":", "Encoding", "::", "UTF_8", ")", "offenses", ".", "map!", "do", "|", "o", "|", "location", "=", "Parser", "::", "Source", "::", "Range", ".", "new", "(", "source_buffer", ",", "o", "[", "'location'", "]", "[", "'begin_pos'", "]", ",", "o", "[", "'location'", "]", "[", "'end_pos'", "]", ")", "Cop", "::", "Offense", ".", "new", "(", "o", "[", "'severity'", "]", ",", "location", ",", "o", "[", "'message'", "]", ",", "o", "[", "'cop_name'", "]", ",", "o", "[", "'status'", "]", ".", "to_sym", ")", "end", "end" ]

[ "Restore", "an", "offense", "object", "loaded", "from", "a", "JSON", "file", "." ]

[ "def", "space_before?", "position", "=", "begin_pos", ".", "zero?", "?", "begin_pos", ":", "begin_pos", "-", "1", "pos", ".", "source_buffer", ".", "source", ".", "match", "(", "/", "\\G", "\\s", "/", ",", "position", ")", "end" ]

[ "Checks", "if", "there", "is", "whitespace", "before", "token" ]

[ "def", "option", "(", "opts", ",", "*", "args", ")", "long_opt_symbol", "=", "long_opt_symbol", "(", "args", ")", "args", "+=", "Array", "(", "OptionsHelp", "::", "TEXT", "[", "long_opt_symbol", "]", ")", "opts", ".", "on", "(", "args", ")", "do", "|", "arg", "|", "@options", "[", "long_opt_symbol", "]", "=", "arg", "yield", "arg", "if", "block_given?", "end", "end" ]

[ "Sets", "a", "value", "in", "the" ]

[ "def", "possibly_include_hidden?", "return", "@possibly_include_hidden", "if", "defined?", "(", "@possibly_include_hidden", ")", "@possibly_include_hidden", "=", "patterns_to_include", ".", "any?", "do", "|", "s", "|", "s", ".", "is_a?", "(", "Regexp", ")", "||", "s", ".", "start_with?", "(", "'.'", ")", "||", "s", ".", "include?", "(", "'/.'", ")", "end", "end" ]

[ "Returns", "true", "if", "there", "s", "a", "chance", "that", "an", "Include", "pattern", "matches", "hidden", "files", "false", "if", "that", "s", "definitely", "not", "possible", "." ]

[ "def", "check_for_infinite_loop", "(", "processed_source", ",", "offenses", ")", "checksum", "=", "processed_source", ".", "checksum", "if", "@processed_sources", ".", "include?", "(", "checksum", ")", "raise", "InfiniteCorrectionLoop", ".", "new", "(", "processed_source", ".", "path", ",", "offenses", ")", "end", "@processed_sources", "<<", "checksum", "end" ]

[ "Check", "whether", "a", "run", "created", "source", "identical", "to", "a", "previous", "run", "which", "means", "that", "we", "definitely", "have", "an", "infinite", "loop", "." ]

[ "def", "target_files_in_dir", "(", "base_dir", "=", "Dir", ".", "pwd", ")", "# Support Windows: Backslashes from command-line -> forward slashes", "if", "File", "::", "ALT_SEPARATOR", "base_dir", "=", "base_dir", ".", "gsub", "(", "File", "::", "ALT_SEPARATOR", ",", "File", "::", "SEPARATOR", ")", "end", "all_files", "=", "find_files", "(", "base_dir", ",", "File", "::", "FNM_DOTMATCH", ")", "hidden_files", "=", "Set", ".", "new", "(", "all_files", "-", "find_files", "(", "base_dir", ",", "0", ")", ")", "base_dir_config", "=", "@config_store", ".", "for", "(", "base_dir", ")", "target_files", "=", "all_files", ".", "select", "do", "|", "file", "|", "to_inspect?", "(", "file", ",", "hidden_files", ",", "base_dir_config", ")", "end", "# Most recently modified file first.", "target_files", ".", "sort_by!", "{", "|", "path", "|", "-", "Integer", "(", "File", ".", "mtime", "(", "path", ")", ")", "}", "if", "fail_fast?", "target_files", "end" ]

[ "Finds", "all", "Ruby", "source", "files", "under", "the", "current", "or", "other", "supplied", "directory", ".", "A", "Ruby", "source", "file", "is", "defined", "as", "a", "file", "with", "the", ".", "rb", "extension", "or", "a", "file", "with", "no", "extension", "that", "has", "a", "ruby", "shebang", "line", "as", "its", "first", "line", ".", "It", "is", "possible", "to", "specify", "includes", "and", "excludes", "using", "the", "config", "file", "so", "you", "can", "include", "other", "Ruby", "files", "like", "Rakefiles", "and", "gemspecs", "." ]

[ "def", "rubocop_checksum", "ResultCache", ".", "source_checksum", "||=", "begin", "lib_root", "=", "File", ".", "join", "(", "File", ".", "dirname", "(", "__FILE__", ")", ",", "'..'", ")", "exe_root", "=", "File", ".", "join", "(", "lib_root", ",", "'..'", ",", "'exe'", ")", "# These are all the files we have `require`d plus everything in the", "# exe directory. A change to any of them could affect the cop output", "# so we include them in the cache hash.", "source_files", "=", "$LOADED_FEATURES", "+", "Find", ".", "find", "(", "exe_root", ")", ".", "to_a", "sources", "=", "source_files", ".", "select", "{", "|", "path", "|", "File", ".", "file?", "(", "path", ")", "}", ".", "sort", ".", "map", "{", "|", "path", "|", "IO", ".", "read", "(", "path", ",", "encoding", ":", "Encoding", "::", "UTF_8", ")", "}", "Digest", "::", "SHA1", ".", "hexdigest", "(", "sources", ".", "join", ")", "end", "end" ]

[ "The", "checksum", "of", "the", "rubocop", "program", "running", "the", "inspection", "." ]

[ "def", "relevant_options_digest", "(", "options", ")", "options", "=", "options", ".", "reject", "{", "|", "key", ",", "_", "|", "NON_CHANGING", ".", "include?", "(", "key", ")", "}", "options", "=", "options", ".", "to_s", ".", "gsub", "(", "/", "/i", ",", "'_'", ")", "# We must avoid making file names too long for some filesystems to handle", "# If they are short, we can leave them human-readable", "options", ".", "length", "<=", "32", "?", "options", ":", "Digest", "::", "SHA1", ".", "hexdigest", "(", "options", ")", "end" ]

[ "Return", "a", "hash", "of", "the", "options", "given", "at", "invocation", "minus", "the", "ones", "that", "have", "no", "effect", "on", "which", "offenses", "and", "disabled", "line", "ranges", "are", "found", "and", "thus", "don", "t", "affect", "caching", "." ]

[ "def", "merge", "(", "base_hash", ",", "derived_hash", ",", "**", "opts", ")", "result", "=", "base_hash", ".", "merge", "(", "derived_hash", ")", "keys_appearing_in_both", "=", "base_hash", ".", "keys", "&", "derived_hash", ".", "keys", "keys_appearing_in_both", ".", "each", "do", "|", "key", "|", "if", "opts", "[", ":unset_nil", "]", "&&", "derived_hash", "[", "key", "]", ".", "nil?", "result", ".", "delete", "(", "key", ")", "elsif", "base_hash", "[", "key", "]", ".", "is_a?", "(", "Hash", ")", "result", "[", "key", "]", "=", "merge", "(", "base_hash", "[", "key", "]", ",", "derived_hash", "[", "key", "]", ",", "**", "opts", ")", "elsif", "should_union?", "(", "base_hash", ",", "key", ",", "opts", "[", ":inherit_mode", "]", ")", "result", "[", "key", "]", "=", "base_hash", "[", "key", "]", "|", "derived_hash", "[", "key", "]", "elsif", "opts", "[", ":debug", "]", "warn_on_duplicate_setting", "(", "base_hash", ",", "derived_hash", ",", "key", ",", "opts", ")", "end", "end", "result", "end" ]

[ "Return", "a", "recursive", "merge", "of", "two", "hashes", ".", "That", "is", "a", "normal", "hash", "merge", "with", "the", "addition", "that", "any", "value", "that", "is", "a", "hash", "and", "occurs", "in", "both", "arguments", "will", "also", "be", "merged", ".", "And", "so", "on", "." ]

[ "def", "build_node", "Chef", "::", "Log", ".", "trace", "(", "\"Building node object for #{@node_name}\"", ")", "@node", "=", "Chef", "::", "Node", ".", "find_or_create", "(", "node_name", ")", "ohai_data", "=", "@ohai", ".", "data", ".", "merge", "(", "@node", ".", "automatic_attrs", ")", "@node", ".", "consume_external_attrs", "(", "ohai_data", ",", "nil", ")", "@run_list_expansion", "=", "@node", ".", "expand!", "(", "\"server\"", ")", "@expanded_run_list_with_versions", "=", "@run_list_expansion", ".", "recipes", ".", "with_version_constraints_strings", "Chef", "::", "Log", ".", "info", "(", "\"Run List is [#{@node.run_list}]\"", ")", "Chef", "::", "Log", ".", "info", "(", "\"Run List expands to [#{@expanded_run_list_with_versions.join(', ')}]\"", ")", "@node", "end" ]

[ "DoppelGanger", "implementation", "of", "build_node", ".", "preserves", "as", "many", "of", "the", "node", "s", "attributes", "and", "does", "not", "save", "updates", "to", "the", "server" ]

[ "def", "list_objects", "objects", "=", "@model_class", ".", "method", "(", ":list", ")", ".", "arity", "==", "0", "?", "@model_class", ".", "list", ":", "@model_class", ".", "list", "(", "true", ")", "objects", ".", "map", "{", "|", "obj", "|", "Array", "(", "obj", ")", ".", "find", "{", "|", "o", "|", "o", ".", "kind_of?", "(", "@model_class", ")", "}", "}", "end" ]

[ "paper", "over", "inconsistencies", "in", "the", "model", "classes", "APIs", "and", "return", "the", "objects", "the", "user", "wanted", "instead", "of", "the", "URI", "=", ">", "object", "stuff" ]

[ "def", "apply_defaults", "# If we don't have a better guess use the username.", "Config", "[", ":node_name", "]", "||=", "Etc", ".", "getlogin", "# If we don't have a key (path or inline) check user.pem and $node_name.pem.", "unless", "Config", ".", "key?", "(", ":client_key", ")", "||", "Config", ".", "key?", "(", ":client_key_contents", ")", "key_path", "=", "find_default_key", "(", "[", "\"#{Config[:node_name]}.pem\"", ",", "\"user.pem\"", "]", ")", "Config", "[", ":client_key", "]", "=", "key_path", "if", "key_path", "end", "# Similarly look for a validation key file, though this should be less", "# common these days.", "unless", "Config", ".", "key?", "(", ":validation_key", ")", "||", "Config", ".", "key?", "(", ":validation_key_contents", ")", "key_path", "=", "find_default_key", "(", "[", "\"#{Config[:validation_client_name]}.pem\"", ",", "\"validator.pem\"", ",", "\"validation.pem\"", "]", ")", "Config", "[", ":validation_key", "]", "=", "key_path", "if", "key_path", "end", "end" ]

[ "Apply", "default", "configuration", "values", "for", "workstation", "-", "style", "tools", "." ]

[ "def", "find_default_key", "(", "key_names", ")", "key_names", ".", "each", "do", "|", "filename", "|", "path", "=", "Pathname", ".", "new", "(", "filename", ")", "# If we have a config location (like ./.chef/), look there first.", "if", "config_location", "local_path", "=", "path", ".", "expand_path", "(", "File", ".", "dirname", "(", "config_location", ")", ")", "return", "local_path", ".", "to_s", "if", "local_path", ".", "exist?", "end", "# Then check ~/.chef.", "home_path", "=", "path", ".", "expand_path", "(", "home_chef_dir", ")", "return", "home_path", ".", "to_s", "if", "home_path", ".", "exist?", "end", "nil", "end" ]

[ "Look", "for", "a", "default", "key", "file", "." ]

[ "def", "status", "(", "value", "=", "nil", ")", "response", ".", "status", "=", "Rack", "::", "Utils", ".", "status_code", "(", "value", ")", "if", "value", "response", ".", "status", "end" ]

[ "Set", "or", "retrieve", "the", "response", "status", "code", "." ]

[ "def", "config_file", "(", "*", "paths", ")", "Dir", ".", "chdir", "(", "root", "||", "'.'", ")", "do", "paths", ".", "each", "do", "|", "pattern", "|", "Dir", ".", "glob", "(", "pattern", ")", "do", "|", "file", "|", "raise", "UnsupportedConfigType", "unless", "[", "'.yml'", ",", "'.erb'", "]", ".", "include?", "(", "File", ".", "extname", "(", "file", ")", ")", "logger", ".", "info", "\"loading config file '#{file}'\"", "if", "logging?", "&&", "respond_to?", "(", ":logger", ")", "document", "=", "ERB", ".", "new", "(", "IO", ".", "read", "(", "file", ")", ")", ".", "result", "yaml", "=", "YAML", ".", "load", "(", "document", ")", "config", "=", "config_for_env", "(", "yaml", ")", "config", ".", "each_pair", "{", "|", "key", ",", "value", "|", "set", "(", "key", ",", "value", ")", "}", "end", "end", "end", "end" ]

[ "Loads", "the", "configuration", "from", "the", "YAML", "files", "whose", "+", "paths", "+", "are", "passed", "as", "arguments", "filtering", "the", "settings", "for", "the", "current", "environment", ".", "Note", "that", "these", "+", "paths", "+", "can", "actually", "be", "globs", "." ]

[ "def", "environment_keys?", "(", "hash", ")", "hash", ".", "is_a?", "(", "Hash", ")", "&&", "hash", ".", "any?", "{", "|", "k", ",", "_", "|", "environments", ".", "include?", "(", "k", ".", "to_s", ")", "}", "end" ]

[ "Returns", "true", "if", "supplied", "with", "a", "hash", "that", "has", "any", "recognized", "+", "environments", "+", "in", "its", "root", "keys", "." ]

[ "def", "stylesheet", "(", "*", "urls", ")", "urls", "<<", "{", "}", "unless", "urls", ".", "last", ".", "respond_to?", ":to_hash", "urls", ".", "last", "[", ":type", "]", "||=", "mime_type", "(", ":css", ")", "link", "(", ":stylesheet", ",", "urls", ")", "end" ]

[ "Sets", "Link", "HTTP", "header", "and", "returns", "HTML", "tags", "for", "using", "stylesheets", "." ]

[ "def", "link", "(", "*", "urls", ")", "opts", "=", "urls", ".", "last", ".", "respond_to?", "(", ":to_hash", ")", "?", "urls", ".", "pop", ":", "{", "}", "opts", "[", ":rel", "]", "=", "urls", ".", "shift", "unless", "urls", ".", "first", ".", "respond_to?", ":to_str", "options", "=", "opts", ".", "map", "{", "|", "k", ",", "v", "|", "\" #{k}=#{v.to_s.inspect}\"", "}", "html_pattern", "=", "\"<link href=\\\"%s\\\"#{options.join} />\"", "http_pattern", "=", "[", "\"<%s>\"", ",", "options", "]", ".", "join", "\";\"", "link", "=", "(", "response", "[", "\"Link\"", "]", "||=", "\"\"", ")", "urls", ".", "map", "do", "|", "url", "|", "link", "<<", "\",\\n\"", "unless", "link", ".", "empty?", "link", "<<", "(", "http_pattern", "%", "url", ")", "html_pattern", "%", "url", "end", ".", "join", "\"\\n\"", "end" ]

[ "Sets", "Link", "HTTP", "header", "and", "returns", "corresponding", "HTML", "tags", "." ]

[ "def", "each_run", "(", "file", ")", "if", "file", "file", "=", "File", ".", "new", "(", "file", ")", "matrix", "=", "YAML", ".", "load", "(", "ERB", ".", "new", "(", "file", ".", "read", ")", ".", "result", ")", "file", ".", "close", "matrix", ".", "each_with_index", "do", "|", "run", ",", "i", "|", "DEFAULT_RUN", ".", "merge", "(", "run", ")", "yield", "(", "run", ",", "i", ")", "end", "else", "yield", "(", "DEFAULT_RUN", ")", "end", "end" ]

[ "Parse", "a", "file", "of", "run", "definitions", "and", "yield", "each", "run", "." ]

[ "def", "add_attribute", "(", "name", ",", "&", "block", ")", "declaration", "=", "Declaration", "::", "Dynamic", ".", "new", "(", "name", ",", "@ignore", ",", "block", ")", "@definition", ".", "declare_attribute", "(", "declaration", ")", "end" ]

[ "Adds", "an", "attribute", "to", "the", "factory", ".", "The", "attribute", "value", "will", "be", "generated", "lazily", "by", "calling", "the", "block", "whenever", "an", "instance", "is", "generated", ".", "The", "block", "will", "not", "be", "called", "if", "the", "attribute", "is", "overridden", "for", "a", "specific", "instance", "." ]

[ "def", "sequence", "(", "name", ",", "*", "args", ",", "&", "block", ")", "sequence", "=", "Sequence", ".", "new", "(", "name", ",", "args", ",", "block", ")", "FactoryBot", "::", "Internal", ".", "register_inline_sequence", "(", "sequence", ")", "add_attribute", "(", "name", ")", "{", "increment_sequence", "(", "sequence", ")", "}", "end" ]

[ "Adds", "an", "attribute", "that", "will", "have", "unique", "values", "generated", "by", "a", "sequence", "with", "a", "specified", "format", "." ]

[ "def", "association", "(", "name", ",", "*", "options", ")", "if", "block_given?", "raise", "AssociationDefinitionError", ".", "new", "(", "\"Unexpected block passed to '#{name}' association \"", "\"in '#{@definition.name}' factory\"", ",", ")", "else", "declaration", "=", "Declaration", "::", "Association", ".", "new", "(", "name", ",", "options", ")", "@definition", ".", "declare_attribute", "(", "declaration", ")", "end", "end" ]

[ "Adds", "an", "attribute", "that", "builds", "an", "association", ".", "The", "associated", "instance", "will", "be", "built", "using", "the", "same", "build", "strategy", "as", "the", "parent", "instance", "." ]

[ "def", "lookahead", "@lookahead", "||=", "begin", "ast_node", "=", "selected_operation", "root_type", "=", "warden", ".", "root_type_for_operation", "(", "ast_node", ".", "operation_type", "||", "\"query\"", ")", "root_type", "=", "root_type", ".", "metadata", "[", ":type_class", "]", "||", "raise", "(", "\"Invariant: `lookahead` only works with class-based types\"", ")", "GraphQL", "::", "Execution", "::", "Lookahead", ".", "new", "(", "query", ":", "self", ",", "root_type", ":", "root_type", ",", "ast_nodes", ":", "[", "ast_node", "]", ")", "end", "end" ]

[ "A", "lookahead", "for", "the", "root", "selections", "of", "this", "query" ]

[ "def", "result", "if", "!", "@executed", "with_prepared_ast", "{", "Execution", "::", "Multiplex", ".", "run_queries", "(", "@schema", ",", "[", "self", "]", ",", "context", ":", "@context", ")", "}", "end", "@result", "||=", "Query", "::", "Result", ".", "new", "(", "query", ":", "self", ",", "values", ":", "@result_values", ")", "end" ]

[ "Get", "the", "result", "for", "this", "query", "executing", "it", "once" ]

[ "def", "implements", "(", "interfaces", ",", "inherit", ":", "false", ")", "if", "!", "interfaces", ".", "is_a?", "(", "Array", ")", "raise", "ArgumentError", ",", "\"`implements(interfaces)` must be an array, not #{interfaces.class} (#{interfaces})\"", "end", "@clean_interfaces", "=", "nil", "@clean_inherited_fields", "=", "nil", "dirty_ifaces", "=", "inherit", "?", "@dirty_inherited_interfaces", ":", "@dirty_interfaces", "dirty_ifaces", ".", "concat", "(", "interfaces", ")", "end" ]

[ "Declare", "that", "this", "object", "implements", "this", "interface", ".", "This", "declaration", "will", "be", "validated", "when", "the", "schema", "is", "defined", "." ]

[ "def", "wrap_arity", "(", "callable", ",", "from", ":", ",", "to", ":", ",", "name", ":", ",", "last", ":", "false", ")", "arity", "=", "get_arity", "(", "callable", ")", "if", "arity", "==", "to", "||", "arity", "<", "0", "# It already matches, return it as is", "callable", "elsif", "arity", "==", "from", "# It has the old arity, so wrap it with an arity converter", "message", "=", "\"#{name} with #{from} arguments is deprecated, it now accepts #{to} arguments, see:\"", "backtrace", "=", "caller", "(", "0", ",", "20", ")", "# Find the first line in the trace that isn't library internals:", "user_line", "=", "backtrace", ".", "find", "{", "|", "l", "|", "l", "!~", "/", "\\/", "/", "}", "warn", "(", "message", "+", "\"\\n\"", "+", "user_line", "+", "\"\\n\"", ")", "wrapper", "=", "last", "?", "LastArgumentsWrapper", ":", "FirstArgumentsWrapper", "wrapper", ".", "new", "(", "callable", ",", "from", ")", "else", "raise", "\"Can't wrap #{callable} (arity: #{arity}) to have arity #{to}\"", "end", "end" ]

[ "Given", "a", "callable", "whose", "API", "used", "to", "take", "from", "arguments", "check", "its", "arity", "and", "if", "needed", "apply", "a", "wrapper", "so", "that", "it", "can", "be", "called", "with", "to", "arguments", ".", "If", "a", "wrapper", "is", "applied", "warn", "the", "application", "with", "name", "." ]

[ "def", "execute", "(", "subscription_id", ",", "event", ",", "object", ")", "# Lookup the saved data for this subscription", "query_data", "=", "read_subscription", "(", "subscription_id", ")", "# Fetch the required keys from the saved data", "query_string", "=", "query_data", ".", "fetch", "(", ":query_string", ")", "variables", "=", "query_data", ".", "fetch", "(", ":variables", ")", "context", "=", "query_data", ".", "fetch", "(", ":context", ")", "operation_name", "=", "query_data", ".", "fetch", "(", ":operation_name", ")", "# Re-evaluate the saved query", "result", "=", "@schema", ".", "execute", "(", "{", "query", ":", "query_string", ",", "context", ":", "context", ",", "subscription_topic", ":", "event", ".", "topic", ",", "operation_name", ":", "operation_name", ",", "variables", ":", "variables", ",", "root_value", ":", "object", ",", "}", ")", "deliver", "(", "subscription_id", ",", "result", ")", "rescue", "GraphQL", "::", "Schema", "::", "Subscription", "::", "NoUpdateError", "# This update was skipped in user code; do nothing.", "rescue", "GraphQL", "::", "Schema", "::", "Subscription", "::", "UnsubscribedError", "# `unsubscribe` was called, clean up on our side", "# TODO also send `{more: false}` to client?", "delete_subscription", "(", "subscription_id", ")", "end" ]

[ "event", "was", "triggered", "on", "object", "and", "subscription_id", "was", "subscribed", "so", "it", "should", "be", "updated", "." ]

[ "def", "execute_all", "(", "event", ",", "object", ")", "each_subscription_id", "(", "event", ")", "do", "|", "subscription_id", "|", "execute", "(", "subscription_id", ",", "event", ",", "object", ")", "end", "end" ]

[ "Event", "event", "occurred", "on", "object", "Update", "all", "subscribers", "." ]

[ "def", "to_definition", "(", "schema", ",", "printer", ":", "nil", ",", "**", "args", ")", "printer", "||=", "GraphQL", "::", "Schema", "::", "Printer", ".", "new", "(", "schema", ",", "**", "args", ")", "printer", ".", "print_type", "(", "self", ")", "end" ]

[ "Return", "a", "GraphQL", "string", "for", "the", "type", "definition" ]

[ "def", "write_outfile", "(", "method_name", ",", "file", ")", "schema", "=", "@load_schema", ".", "call", "(", "self", ")", "context", "=", "@load_context", ".", "call", "(", "self", ")", "result", "=", "schema", ".", "public_send", "(", "method_name", ",", "only", ":", "@only", ",", "except", ":", "@except", ",", "context", ":", "context", ")", "dir", "=", "File", ".", "dirname", "(", "file", ")", "FileUtils", ".", "mkdir_p", "(", "dir", ")", "File", ".", "write", "(", "file", ",", "result", ")", "end" ]

[ "Use", "the", "provided", "method_name", "to", "generate", "a", "string", "from", "the", "specified", "schema", "then", "write", "it", "to", "file", "." ]

[ "def", "define_task", "namespace", "(", "@namespace", ")", "do", "namespace", "(", "\"schema\"", ")", "do", "desc", "(", "\"Dump the schema to IDL in #{idl_path}\"", ")", "task", ":idl", "=>", "@dependencies", "do", "write_outfile", "(", ":to_definition", ",", "idl_path", ")", "puts", "\"Schema IDL dumped into #{idl_path}\"", "end", "desc", "(", "\"Dump the schema to JSON in #{json_path}\"", ")", "task", ":json", "=>", "@dependencies", "do", "write_outfile", "(", ":to_json", ",", "json_path", ")", "puts", "\"Schema JSON dumped into #{json_path}\"", "end", "desc", "(", "\"Dump the schema to JSON and IDL\"", ")", "task", ":dump", "=>", "[", ":idl", ",", ":json", "]", "end", "end", "end" ]

[ "Use", "the", "Rake", "DSL", "to", "add", "tasks" ]

[ "def", "prepare_lazy", "(", "obj", ",", "args", ",", "ctx", ")", "GraphQL", "::", "Execution", "::", "Lazy", ".", "new", "{", "lazy_resolve", "(", "obj", ",", "args", ",", "ctx", ")", "}", "end" ]

[ "Prepare", "a", "lazy", "value", "for", "this", "field", ".", "It", "may", "be", "then", "-", "ed", "and", "resolved", "later", "." ]

[ "def", "call", "(", "member", ",", "ctx", ")", "(", "@only", "?", "@only", ".", "call", "(", "member", ",", "ctx", ")", ":", "true", ")", "&&", "(", "@except", "?", "!", "@except", ".", "call", "(", "member", ",", "ctx", ")", ":", "true", ")", "end" ]

[ "Returns", "true", "if", "member", "ctx", "passes", "this", "filter" ]

[ "def", "analyze_query", "(", "query", ",", "analyzers", ",", "multiplex_states", ":", "[", "]", ")", "query", ".", "trace", "(", "\"analyze_query\"", ",", "{", "query", ":", "query", "}", ")", "do", "analyzers_to_run", "=", "analyzers", ".", "select", "do", "|", "analyzer", "|", "if", "analyzer", ".", "respond_to?", "(", ":analyze?", ")", "analyzer", ".", "analyze?", "(", "query", ")", "else", "true", "end", "end", "reducer_states", "=", "analyzers_to_run", ".", "map", "{", "|", "r", "|", "ReducerState", ".", "new", "(", "r", ",", "query", ")", "}", "+", "multiplex_states", "irep", "=", "query", ".", "internal_representation", "irep", ".", "operation_definitions", ".", "each", "do", "|", "name", ",", "op_node", "|", "reduce_node", "(", "op_node", ",", "reducer_states", ")", "end", "reducer_states", ".", "map", "(", ":finalize_reducer", ")", "end", "end" ]

[ "Visit", "query", "s", "internal", "representation", "calling", "analyzers", "along", "the", "way", "." ]

[ "def", "reduce_node", "(", "irep_node", ",", "reducer_states", ")", "visit_analyzers", "(", ":enter", ",", "irep_node", ",", "reducer_states", ")", "irep_node", ".", "typed_children", ".", "each", "do", "|", "type_defn", ",", "children", "|", "children", ".", "each", "do", "|", "name", ",", "child_irep_node", "|", "reduce_node", "(", "child_irep_node", ",", "reducer_states", ")", "end", "end", "visit_analyzers", "(", ":leave", ",", "irep_node", ",", "reducer_states", ")", "end" ]

[ "Enter", "the", "node", "visit", "its", "children", "then", "leave", "the", "node", "." ]

[ "def", "validate", "(", "string_or_document", ",", "rules", ":", "nil", ",", "context", ":", "nil", ")", "doc", "=", "if", "string_or_document", ".", "is_a?", "(", "String", ")", "GraphQL", ".", "parse", "(", "string_or_document", ")", "else", "string_or_document", "end", "query", "=", "GraphQL", "::", "Query", ".", "new", "(", "self", ",", "document", ":", "doc", ",", "context", ":", "context", ")", "validator_opts", "=", "{", "schema", ":", "self", "}", "rules", "&&", "(", "validator_opts", "[", ":rules", "]", "=", "rules", ")", "validator", "=", "GraphQL", "::", "StaticValidation", "::", "Validator", ".", "new", "(", "validator_opts", ")", "res", "=", "validator", ".", "validate", "(", "query", ")", "res", "[", ":errors", "]", "end" ]

[ "Validate", "a", "query", "string", "according", "to", "this", "schema", "." ]

[ "def", "execute", "(", "query_str", "=", "nil", ",", "**", "kwargs", ")", "if", "query_str", "kwargs", "[", ":query", "]", "=", "query_str", "end", "# Some of the query context _should_ be passed to the multiplex, too", "multiplex_context", "=", "if", "(", "ctx", "=", "kwargs", "[", ":context", "]", ")", "{", "backtrace", ":", "ctx", "[", ":backtrace", "]", ",", "tracers", ":", "ctx", "[", ":tracers", "]", ",", "}", "else", "{", "}", "end", "# Since we're running one query, don't run a multiplex-level complexity analyzer", "all_results", "=", "multiplex", "(", "[", "kwargs", "]", ",", "max_complexity", ":", "nil", ",", "context", ":", "multiplex_context", ")", "all_results", "[", "0", "]", "end" ]

[ "Execute", "a", "query", "on", "itself", ".", "Raises", "an", "error", "if", "the", "schema", "definition", "is", "invalid", "." ]

[ "def", "check_resolved_type", "(", "type", ",", "object", ",", "ctx", "=", ":__undefined__", ")", "if", "ctx", "==", ":__undefined__", "# Old method signature", "ctx", "=", "object", "object", "=", "type", "type", "=", "nil", "end", "if", "object", ".", "is_a?", "(", "GraphQL", "::", "Schema", "::", "Object", ")", "object", "=", "object", ".", "object", "end", "if", "type", ".", "respond_to?", "(", ":graphql_definition", ")", "type", "=", "type", ".", "graphql_definition", "end", "# Prefer a type-local function; fall back to the schema-level function", "type_proc", "=", "type", "&&", "type", ".", "resolve_type_proc", "type_result", "=", "if", "type_proc", "type_proc", ".", "call", "(", "object", ",", "ctx", ")", "else", "yield", "(", "type", ",", "object", ",", "ctx", ")", "end", "if", "type_result", ".", "nil?", "nil", "else", "after_lazy", "(", "type_result", ")", "do", "|", "resolved_type_result", "|", "if", "resolved_type_result", ".", "respond_to?", "(", ":graphql_definition", ")", "resolved_type_result", "=", "resolved_type_result", ".", "graphql_definition", "end", "if", "!", "resolved_type_result", ".", "is_a?", "(", "GraphQL", "::", "BaseType", ")", "type_str", "=", "\"#{resolved_type_result} (#{resolved_type_result.class.name})\"", "raise", "\"resolve_type(#{object}) returned #{type_str}, but it should return a GraphQL type\"", "else", "resolved_type_result", "end", "end", "end", "end" ]

[ "This", "is", "a", "compatibility", "hack", "so", "that", "instance", "-", "level", "and", "class", "-", "level", "methods", "can", "get", "correctness", "checks", "without", "calling", "one", "another" ]

[ "def", "id_from_object", "(", "object", ",", "type", ",", "ctx", ")", "if", "@id_from_object_proc", ".", "nil?", "raise", "(", "NotImplementedError", ",", "\"Can't generate an ID for #{object.inspect} of type #{type}, schema's `id_from_object` must be defined\"", ")", "else", "@id_from_object_proc", ".", "call", "(", "object", ",", "type", ",", "ctx", ")", "end", "end" ]

[ "Get", "a", "unique", "identifier", "from", "this", "object" ]

[ "def", "to_definition", "(", "only", ":", "nil", ",", "except", ":", "nil", ",", "context", ":", "{", "}", ")", "GraphQL", "::", "Schema", "::", "Printer", ".", "print_schema", "(", "self", ",", "only", ":", "only", ",", "except", ":", "except", ",", "context", ":", "context", ")", "end" ]

[ "Return", "the", "GraphQL", "IDL", "for", "the", "schema" ]

[ "def", "coerce_non_null_input", "(", "value_name", ",", "ctx", ")", "if", "@values_by_name", ".", "key?", "(", "value_name", ")", "@values_by_name", ".", "fetch", "(", "value_name", ")", ".", "value", "elsif", "match_by_value", "=", "@values_by_name", ".", "find", "{", "|", "k", ",", "v", "|", "v", ".", "value", "==", "value_name", "}", "# this is for matching default values, which are \"inputs\", but they're", "# the Ruby value, not the GraphQL string.", "match_by_value", "[", "1", "]", ".", "value", "else", "nil", "end", "end" ]

[ "Get", "the", "underlying", "value", "for", "this", "enum", "value" ]

[ "def", "inspect_input", "(", "input", ":", ")", "[", "input", ".", "class", ".", "name", ",", "input", ".", "helper_method", ",", "# Access by method", "input", ".", "string_value", ",", "# Access by key:", "input", "[", ":string_value", "]", ",", "input", ".", "key?", "(", ":string_value", ")", ".", "to_s", ",", "# ~~Access by legacy key~~ # not anymore", "input", "[", ":string_value", "]", ",", "input", ".", "ensemble", ",", "input", ".", "key?", "(", ":ensemble", ")", ".", "to_s", ",", "]", "end" ]

[ "This", "is", "for", "testing", "input", "object", "behavior" ]

[ "def", "as_indexed_json", "(", "options", "=", "{", "}", ")", "self", ".", "as_json", "(", "include", ":", "{", "categories", ":", "{", "only", ":", ":title", "}", ",", "authors", ":", "{", "methods", ":", "[", ":full_name", ",", ":department", "]", ",", "only", ":", "[", ":full_name", ",", ":department", "]", "}", ",", "comments", ":", "{", "only", ":", ":text", "}", "}", ")", "end" ]

[ "Customize", "the", "JSON", "serialization", "for", "Elasticsearch" ]

[ "def", "inspect", "inspected", "=", "super", "# mask password", "inspected", ".", "gsub!", "@password", ",", "'*******'", "if", "@password", "inspected", ".", "gsub!", "@management_console_password", ",", "'*******'", "if", "@management_console_password", "inspected", ".", "gsub!", "@bearer_token", ",", "'********'", "if", "@bearer_token", "# Only show last 4 of token, secret", "inspected", ".", "gsub!", "@access_token", ",", "\"#{'*'*36}#{@access_token[36..-1]}\"", "if", "@access_token", "inspected", ".", "gsub!", "@client_secret", ",", "\"#{'*'*36}#{@client_secret[36..-1]}\"", "if", "@client_secret", "inspected", "end" ]

[ "Text", "representation", "of", "the", "client", "masking", "tokens", "and", "passwords" ]

[ "def", "agent", "@agent", "||=", "Sawyer", "::", "Agent", ".", "new", "(", "endpoint", ",", "sawyer_options", ")", "do", "|", "http", "|", "http", ".", "headers", "[", ":accept", "]", "=", "default_media_type", "http", ".", "headers", "[", ":content_type", "]", "=", "\"application/json\"", "http", ".", "headers", "[", ":user_agent", "]", "=", "user_agent", "if", "basic_authenticated?", "http", ".", "basic_auth", "(", "@login", ",", "@password", ")", "elsif", "token_authenticated?", "http", ".", "authorization", "'token'", ",", "@access_token", "elsif", "bearer_authenticated?", "http", ".", "authorization", "'Bearer'", ",", "@bearer_token", "elsif", "application_authenticated?", "http", ".", "params", "=", "http", ".", "params", ".", "merge", "application_authentication", "end", "end", "end" ]

[ "Hypermedia", "agent", "for", "the", "GitHub", "API" ]

[ "def", "boolean_from_response", "(", "method", ",", "path", ",", "options", "=", "{", "}", ")", "request", "(", "method", ",", "path", ",", "options", ")", "@last_response", ".", "status", "==", "204", "rescue", "Octokit", "::", "NotFound", "false", "end" ]

[ "Executes", "the", "request", "checking", "if", "it", "was", "successful" ]

[ "def", "aria_selected_link_to", "(", "text", ",", "link", ",", "options", "=", "{", "}", ")", "link_to", "(", "text", ",", "link", ",", "options", ".", "merge", "(", "\"aria-selected\"", ":", "is_active_link?", "(", "link", ",", "options", "[", ":aria_link_type", "]", "||", ":inclusive", ")", ")", ")", "end" ]

[ "Adds", "the", "aria", "-", "selected", "attribute", "to", "a", "link", "when", "it", "s", "pointing", "to", "the", "current", "path", ".", "The", "API", "is", "the", "same", "than", "the", "link_to", "one", "and", "uses", "this", "helper", "internally", "." ]

[ "def", "all_fields", "fields", "=", "public_attributes", ".", "map", "do", "|", "name", ",", "type", "|", "@template", ".", "content_tag", "(", ":div", ",", "input_field", "(", "name", ",", "type", ")", ",", "class", ":", "\"field\"", ")", "end", "safe_join", "(", "fields", ")", "end" ]

[ "Renders", "all", "form", "attributes", "defined", "by", "the", "handler", "." ]

[ "def", "input", "(", "name", ",", "options", "=", "{", "}", ")", "if", "options", "[", ":as", "]", "send", "(", "options", "[", ":as", "]", ".", "to_s", ",", "name", ",", "options", "[", ":input", "]", "||", "{", "}", ")", "else", "type", "=", "find_input_type", "(", "name", ".", "to_s", ")", "input_field", "(", "name", ",", "type", ")", "end", "end" ]

[ "Renders", "a", "single", "attribute", "from", "the", "form", "handlers", "." ]

[ "def", "resource_types", "@resource_types", "||=", "%w(", "Decidim::Accountability::Result", "Decidim::Blogs::Post", "Decidim::Comments::Comment", "Decidim::Consultations::Question", "Decidim::Debates::Debate", "Decidim::Meetings::Meeting", "Decidim::Proposals::Proposal", "Decidim::Surveys::Survey", "Decidim::Assembly", "Decidim::Consultation", "Decidim::Initiative", "Decidim::ParticipatoryProcess", ")", ".", "select", "do", "|", "klass", "|", "klass", ".", "safe_constantize", ".", "present?", "end", "end" ]

[ "All", "the", "resource", "types", "that", "are", "eligible", "to", "be", "included", "as", "an", "activity", "." ]

[ "def", "authorization_form_for", "(", "record", ",", "options", "=", "{", "}", ",", "&", "block", ")", "default_options", "=", "{", "builder", ":", "AuthorizationFormBuilder", ",", "as", ":", "\"authorization_handler\"", ",", "url", ":", "decidim_verifications", ".", "authorizations_path", "}", "options", "=", "default_options", ".", "merge", "(", "options", ")", "decidim_form_for", "(", "record", ",", "options", ",", "block", ")", "end" ]

[ "Creates", "a", "ew", "authorization", "form", "in", "a", "view", "accepts", "the", "same", "arguments", "as", "form_for", "." ]

[ "def", "store_current_location", "return", "if", "(", "devise_controller?", "&&", "params", "[", ":redirect_url", "]", ".", "blank?", ")", "||", "!", "request", ".", "format", ".", "html?", "value", "=", "params", "[", ":redirect_url", "]", "||", "request", ".", "url", "store_location_for", "(", ":user", ",", "value", ")", "end" ]

[ "Stores", "the", "url", "where", "the", "user", "will", "be", "redirected", "after", "login", "." ]

[ "def", "has_visible_scopes?", "(", "resource", ")", "resource", ".", "participatory_space", ".", "scopes_enabled?", "&&", "resource", ".", "scope", ".", "present?", "&&", "resource", ".", "participatory_space", ".", "scope", "!=", "resource", ".", "scope", "end" ]

[ "Checks", "if", "the", "resource", "should", "show", "its", "scope", "or", "not", ".", "resource", "-", "the", "resource", "to", "analize" ]

[ "def", "scopes_picker_tag", "(", "name", ",", "value", ",", "options", "=", "{", "}", ")", "root", "=", "try", "(", ":current_participatory_space", ")", "&.", "scope", "field", "=", "options", "[", ":field", "]", "||", "name", "scopes_picker_field_tag", "name", ",", "value", ",", "id", ":", "options", "[", ":id", "]", "do", "|", "scope", "|", "{", "url", ":", "decidim", ".", "scopes_picker_path", "(", "root", ":", "root", ",", "current", ":", "scope", "&.", "id", ",", "field", ":", "field", ")", ",", "text", ":", "scope_name_for_picker", "(", "scope", ",", "I18n", ".", "t", "(", "\"decidim.scopes.global\"", ")", ")", "}", "end", "end" ]

[ "Renders", "a", "scopes", "picker", "field", "in", "a", "form", "not", "linked", "to", "a", "specific", "model", ".", "name", "-", "name", "for", "the", "input", "value", "-", "value", "for", "the", "input" ]

[ "def", "amendments_for", "(", "amendable", ")", "return", "unless", "amendable", ".", "amendable?", "&&", "amendable", ".", "emendations", ".", "count", ".", "positive?", "content", "=", "content_tag", "(", ":h2", ",", "class", ":", "\"section-heading\"", ",", "id", ":", "\"amendments\"", ")", "do", "t", "(", "\"section_heading\"", ",", "scope", ":", "\"decidim.amendments.amendable\"", ",", "count", ":", "amendable", ".", "emendations", ".", "count", ")", "end", "content", "<<", "cell", "(", "\"decidim/collapsible_list\"", ",", "amendable", ".", "emendations", ",", "cell_options", ":", "{", "context", ":", "{", "current_user", ":", "current_user", "}", "}", ",", "list_class", ":", "\"row small-up-1 medium-up-2 card-grid\"", ",", "size", ":", "4", ")", ".", "to_s", "content_tag", ":div", ",", "content", ".", "html_safe", ",", "class", ":", "\"section\"", "end" ]

[ "Renders", "the", "emendations", "of", "an", "amendable", "resource" ]

[ "def", "allowed_to_accept_and_reject?", "(", "emendation", ")", "return", "unless", "emendation", ".", "amendment", ".", "evaluating?", "emendation", ".", "amendable", ".", "created_by?", "(", "current_user", ")", "||", "current_user", ".", "admin?", "end" ]

[ "Checks", "if", "the", "user", "can", "accept", "and", "reject", "the", "emendation" ]