Datasets:

---

CM

/

codexglue_code2text_ruby

like 1

[ "def", "errors", "reference_factories", ".", "inject", "(", "factory", ".", "errors", ")", "do", "|", "memo", ",", "f", "|", "Validation", "::", "ErrorCollection", ".", "combine", "(", "memo", ",", "f", ".", "errors", ")", "end", "end" ]

[ "Any", "validation", "errors", "that", "are", "present", "on", "the", "OpenAPI", "document" ]

[ "def", "register_reference", "(", "given_reference", ",", "factory", ",", "context", ")", "reference", "=", "Reference", ".", "new", "(", "given_reference", ")", "ReferenceResolver", ".", "new", "(", "reference", ",", "factory", ",", "context", ")", ".", "tap", "do", "|", "resolver", "|", "next", "if", "resolver", ".", "in_root_source?", "reference_register", ".", "register", "(", "resolver", ".", "reference_factory", ")", "end", "end" ]

[ "Used", "to", "register", "a", "reference", "with", "the", "underlying", "document", "and", "return", "a", "reference", "resolver", "to", "access", "the", "object", "referenced" ]

[ "def", "data_at_pointer", "(", "json_pointer", ")", "return", "data", "if", "json_pointer", ".", "empty?", "data", ".", "dig", "(", "json_pointer", ")", "if", "data", ".", "respond_to?", "(", ":dig", ")", "end" ]

[ "Access", "the", "data", "in", "a", "source", "at", "a", "particular", "pointer" ]

[ "def", "pages", "@pages", "||=", "begin", "from", "=", "@page", "-", "(", "@size", "/", "2", ")", ".", "ceil", "from", "=", "1", "if", "from", "<", "1", "upto", "=", "from", "+", "@size", "-", "1", "# Correct +from+ and +to+ if +to+ is more than number of pages", "if", "upto", ">", "pages_count", "from", "-=", "(", "upto", "-", "pages_count", ")", "from", "=", "1", "if", "from", "<", "1", "upto", "=", "pages_count", "end", "(", "from", "..", "upto", ")", ".", "to_a", "end", "end" ]

[ "Number", "of", "pages", "to", "display", "." ]

[ "def", "run", "(", "max_reviewers", "=", "3", ",", "file_blacklist", "=", "[", "]", ",", "user_blacklist", "=", "[", "]", ")", "files", "=", "select_files", "(", "file_blacklist", ")", "return", "if", "files", ".", "empty?", "authors", "=", "{", "}", "compose_urls", "(", "files", ")", ".", "each", "do", "|", "url", "|", "result", "=", "parse_blame", "(", "url", ")", "authors", ".", "merge!", "(", "result", ")", "{", "|", "_", ",", "m", ",", "n", "|", "m", "+", "n", "}", "end", "reviewers", "=", "find_reviewers", "(", "authors", ",", "user_blacklist", ",", "max_reviewers", ")", "if", "reviewers", ".", "count", ">", "0", "reviewers", "=", "reviewers", ".", "map", "{", "|", "r", "|", "'@'", "+", "r", "}", "result", "=", "format", "(", "'By analyzing the blame information on this pull '", "'request, we identified %s to be potential reviewer%s.'", ",", "reviewers", ".", "join", "(", "', '", ")", ",", "reviewers", ".", "count", ">", "1", "?", "'s'", ":", "''", ")", "markdown", "result", "end", "end" ]

[ "Mention", "potential", "reviewers", "." ]

[ "def", "push", "(", "node", ")", "node", "=", "Node", "(", "node", ")", "@head", "||=", "node", "if", "@tail", "@tail", ".", "next", "=", "node", "node", ".", "prev", "=", "@tail", "end", "@tail", "=", "node", "@length", "+=", "1", "self", "end" ]

[ "Pushes", "new", "nodes", "to", "the", "end", "of", "the", "list", "." ]

[ "def", "unshift", "(", "node", ")", "node", "=", "Node", "(", "node", ")", "@tail", "||=", "node", "node", ".", "next", "=", "@head", "@head", ".", "prev", "=", "node", "if", "@head", "@head", "=", "node", "@length", "+=", "1", "self", "end" ]

[ "Pushes", "new", "nodes", "on", "top", "of", "the", "list", "." ]

[ "def", "insert", "(", "to_add", ",", "after", ":", "nil", ",", "before", ":", "nil", ")", "if", "after", "&&", "before", "||", "!", "after", "&&", "!", "before", "raise", "ArgumentError", ",", "'either :after or :before keys should be passed'", "end", "matcher", "=", "after", "||", "before", "matcher_proc", "=", "if", "matcher", ".", "is_a?", "(", "Proc", ")", "__to_matcher", "(", "matcher", ")", "else", "__to_matcher", "(", "matcher", ")", "end", "node", "=", "each_node", ".", "find", "(", "matcher_proc", ")", "return", "unless", "node", "new_node", "=", "after", "?", "insert_after_node", "(", "to_add", ",", "node", ")", ":", "insert_before_node", "(", "to_add", ",", "node", ")", "new_node", ".", "data", "end" ]

[ "Inserts", "after", "or", "before", "first", "matched", "node", ".", "data", "from", "the", "the", "list", "by", "passed", "block", "or", "value", "." ]

[ "def", "insert_after_node", "(", "data", ",", "node", ")", "Node", "(", "data", ")", ".", "tap", "do", "|", "new_node", "|", "new_node", ".", "prev", "=", "node", "new_node", ".", "next", "=", "node", ".", "next", "if", "node", ".", "next", "node", ".", "next", ".", "prev", "=", "new_node", "else", "@tail", "=", "new_node", "end", "node", ".", "next", "=", "new_node", "@length", "+=", "1", "end", "end" ]

[ "Inserts", "data", "after", "first", "matched", "node", ".", "data", "." ]

[ "def", "insert_before_node", "(", "data", ",", "node", ")", "Node", "(", "data", ")", ".", "tap", "do", "|", "new_node", "|", "new_node", ".", "next", "=", "node", "new_node", ".", "prev", "=", "node", ".", "prev", "if", "node", ".", "prev", "node", ".", "prev", ".", "next", "=", "new_node", "else", "@head", "=", "new_node", "end", "node", ".", "prev", "=", "new_node", "@length", "+=", "1", "end", "end" ]

[ "Inserts", "data", "before", "first", "matched", "node", ".", "data", "." ]

[ "def", "delete", "(", "val", "=", "nil", ",", "&", "block", ")", "if", "val", ".", "respond_to?", "(", ":to_node", ")", "node", "=", "val", ".", "to_node", "__unlink_node", "(", "node", ")", "return", "node", ".", "data", "end", "each_node", ".", "find", "(", "__to_matcher", "(", "val", ",", "block", ")", ")", ".", "tap", "do", "|", "node_to_delete", "|", "return", "unless", "node_to_delete", "__unlink_node", "(", "node_to_delete", ")", "end", ".", "data", "end" ]

[ "Removes", "first", "matched", "node", ".", "data", "from", "the", "the", "list", "by", "passed", "block", "or", "value", "." ]

[ "def", "delete_all", "(", "val", "=", "nil", ",", "&", "block", ")", "each_node", ".", "select", "(", "__to_matcher", "(", "val", ",", "block", ")", ")", ".", "each", "do", "|", "node_to_delete", "|", "next", "unless", "node_to_delete", "__unlink_node", "(", "node_to_delete", ")", "end", ".", "map", "(", ":data", ")", "end" ]

[ "Removes", "all", "matched", "data", ".", "data", "from", "the", "the", "list", "by", "passed", "block", "or", "value", "." ]

[ "def", "regenerate", "store", ".", "delete_session", "(", "self", ".", "session_id", ")", "self", ".", "session_id", "=", "Merb", "::", "SessionMixin", ".", "rand_uuid", "store", ".", "store_session", "(", "self", ".", "session_id", ",", "self", ")", "end" ]

[ "Regenerate", "the", "session", "ID", "." ]

[ "def", "collect_methods", "list", "=", "@context", ".", "method_list", "unless", "@options", ".", "show_all", "list", "=", "list", ".", "find_all", "{", "|", "m", "|", "m", ".", "visibility", "==", ":public", "||", "m", ".", "visibility", "==", ":protected", "||", "m", ".", "force_documentation", "}", "end", "@methods", "=", "list", ".", "collect", "{", "|", "m", "|", "HtmlMethod", ".", "new", "(", "m", ",", "self", ",", "@options", ")", "}", "end" ]

[ "Create", "a", "list", "of", "HtmlMethod", "objects", "for", "each", "method", "in", "the", "corresponding", "context", "object", ".", "If", "the" ]

[ "def", "markup_code", "(", "tokens", ")", "src", "=", "\"\"", "tokens", ".", "each", "do", "|", "t", "|", "next", "unless", "t", "# p t.class", "# style = STYLE_MAP[t.class]", "style", "=", "case", "t", "when", "RubyToken", "::", "TkCONSTANT", "then", "\"ruby-constant\"", "when", "RubyToken", "::", "TkKW", "then", "\"ruby-keyword kw\"", "when", "RubyToken", "::", "TkIVAR", "then", "\"ruby-ivar\"", "when", "RubyToken", "::", "TkOp", "then", "\"ruby-operator\"", "when", "RubyToken", "::", "TkId", "then", "\"ruby-identifier\"", "when", "RubyToken", "::", "TkNode", "then", "\"ruby-node\"", "when", "RubyToken", "::", "TkCOMMENT", "then", "\"ruby-comment cmt\"", "when", "RubyToken", "::", "TkREGEXP", "then", "\"ruby-regexp re\"", "when", "RubyToken", "::", "TkSTRING", "then", "\"ruby-value str\"", "when", "RubyToken", "::", "TkVal", "then", "\"ruby-value\"", "else", "nil", "end", "text", "=", "CGI", ".", "escapeHTML", "(", "t", ".", "text", ")", "if", "style", "src", "<<", "\"<span class=\\\"#{style}\\\">#{text}</span>\"", "else", "src", "<<", "text", "end", "end", "add_line_numbers", "(", "src", ")", "src", "end" ]

[ "Given", "a", "sequence", "of", "source", "tokens", "mark", "up", "the", "source", "code", "to", "make", "it", "look", "purty", "." ]

[ "def", "net_smtp", "smtp", "=", "Net", "::", "SMTP", ".", "new", "(", "config", "[", ":host", "]", ",", "config", "[", ":port", "]", ".", "to_i", ")", "if", "config", "[", ":tls", "]", "if", "smtp", ".", "respond_to?", "(", ":enable_starttls", ")", "# 1.9.x", "smtp", ".", "enable_starttls", "elsif", "smtp", ".", "respond_to?", "(", ":enable_tls", ")", "&&", "smtp", ".", "respond_to?", "(", ":use_tls?", ")", "smtp", ".", "enable_tls", "(", "OpenSSL", "::", "SSL", "::", "VERIFY_NONE", ")", "# 1.8.x with tlsmail", "else", "raise", "'Unable to enable TLS, for Ruby 1.8.x install tlsmail'", "end", "end", "smtp", ".", "start", "(", "config", "[", ":domain", "]", ",", "config", "[", ":user", "]", ",", "config", "[", ":pass", "]", ",", "config", "[", ":auth", "]", ")", "{", "|", "smtp", "|", "to", "=", "@mail", ".", "to", ".", "is_a?", "(", "String", ")", "?", "@mail", ".", "to", ".", "split", "(", "/", "/", ")", ":", "@mail", ".", "to", "smtp", ".", "send_message", "(", "@mail", ".", "to_s", ",", "@mail", ".", "from", ".", "first", ",", "to", ")", "}", "end" ]

[ "Sends", "the", "mail", "using", "SMTP", "." ]

[ "def", "process_queue", "begin", "while", "blk", "=", "Merb", "::", "Dispatcher", ".", "work_queue", ".", "pop", "# we've been blocking on the queue waiting for an item sleeping.", "# when someone pushes an item it wakes up this thread so we ", "# immediately pass execution to the scheduler so we don't ", "# accidentally run this block before the action finishes ", "# it's own processing", "Thread", ".", "pass", "blk", ".", "call", "break", "if", "Merb", "::", "Dispatcher", ".", "work_queue", ".", "empty?", "&&", "Merb", ".", "exiting", "end", "rescue", "Exception", "=>", "e", "Merb", ".", "logger", ".", "warn!", "%Q!Worker Thread Crashed with Exception:\\n#{Merb.exception(e)}\\nRestarting Worker Thread!", "retry", "end", "end" ]

[ "Creates", "a", "new", "worker", "thread", "that", "loops", "over", "the", "work", "queue", "." ]

[ "def", "handle", "@start", "=", "env", "[", "\"merb.request_start\"", "]", "=", "Time", ".", "now", "Merb", ".", "logger", ".", "info", "{", "\"Started request handling: #{start.to_s}\"", "}", "find_route!", "return", "rack_response", "if", "handled?", "klass", "=", "controller", "Merb", ".", "logger", ".", "debug", "{", "\"Routed to: #{klass::_filter_params(params).inspect}\"", "}", "unless", "klass", "<", "Controller", "raise", "NotFound", ",", "\"Controller '#{klass}' not found.\\n\"", "\"If Merb tries to find a controller for static files, \"", "\"you may need to check your Rackup file, see the Problems \"", "\"section at: http://wiki.merbivore.com/pages/rack-middleware\"", "end", "if", "klass", ".", "abstract?", "raise", "NotFound", ",", "\"The '#{klass}' controller has no public actions\"", "end", "dispatch_action", "(", "klass", ",", "params", "[", ":action", "]", ")", "rescue", "Object", "=>", "exception", "dispatch_exception", "(", "exception", ")", "end" ]

[ "Handles", "request", "routing", "and", "action", "dispatch", "." ]

[ "def", "dispatch_action", "(", "klass", ",", "action_name", ",", "status", "=", "200", ")", "@env", "[", "\"merb.status\"", "]", "=", "status", "@env", "[", "\"merb.action_name\"", "]", "=", "action_name", "if", "Dispatcher", ".", "use_mutex", "@@mutex", ".", "synchronize", "{", "klass", ".", "call", "(", "env", ")", "}", "else", "klass", ".", "call", "(", "env", ")", "end", "end" ]

[ "Setup", "the", "controller", "and", "call", "the", "chosen", "action" ]

[ "def", "dispatch_exception", "(", "exception", ")", "if", "(", "exception", ".", "is_a?", "(", "Merb", "::", "ControllerExceptions", "::", "Base", ")", "&&", "!", "exception", ".", "is_a?", "(", "Merb", "::", "ControllerExceptions", "::", "ServerError", ")", ")", "Merb", ".", "logger", ".", "info", "(", "Merb", ".", "exception", "(", "exception", ")", ")", "else", "Merb", ".", "logger", ".", "error", "(", "Merb", ".", "exception", "(", "exception", ")", ")", "end", "exceptions", "=", "env", "[", "\"merb.exceptions\"", "]", "=", "[", "exception", "]", "begin", "e", "=", "exceptions", ".", "first", "if", "action_name", "=", "e", ".", "action_name", "dispatch_action", "(", "Exceptions", ",", "action_name", ",", "e", ".", "class", ".", "status", ")", "else", "dispatch_action", "(", "Dispatcher", "::", "DefaultException", ",", ":index", ",", "e", ".", "class", ".", "status", ")", "end", "rescue", "Object", "=>", "dispatch_issue", "if", "e", ".", "same?", "(", "dispatch_issue", ")", "||", "exceptions", ".", "size", ">", "5", "dispatch_action", "(", "Dispatcher", "::", "DefaultException", ",", ":index", ",", "e", ".", "class", ".", "status", ")", "else", "Merb", ".", "logger", ".", "error", "(", "\"Dispatching #{e.class} raised another error.\"", ")", "Merb", ".", "logger", ".", "error", "(", "Merb", ".", "exception", "(", "dispatch_issue", ")", ")", "exceptions", ".", "unshift", "dispatch_issue", "retry", "end", "end", "end" ]

[ "Re", "-", "route", "the", "current", "request", "to", "the", "Exception", "controller", "if", "it", "is", "available", "and", "try", "to", "render", "the", "exception", "nicely", "." ]

[ "def", "render_chunked", "(", "&", "blk", ")", "must_support_streaming!", "headers", "[", "'Transfer-Encoding'", "]", "=", "'chunked'", "Proc", ".", "new", "{", "|", "response", "|", "@response", "=", "response", "response", ".", "send_status_no_connection_close", "(", "''", ")", "response", ".", "send_header", "blk", ".", "call", "response", ".", "write", "(", "\"0\\r\\n\\r\\n\"", ")", "}", "end" ]

[ "Renders", "the", "block", "given", "as", "a", "parameter", "using", "chunked", "encoding", "." ]

[ "def", "render_then_call", "(", "str", ",", "&", "blk", ")", "Proc", ".", "new", "do", "|", "response", "|", "response", ".", "write", "(", "str", ")", "blk", ".", "call", "end", "end" ]

[ "Renders", "the", "passed", "in", "string", "then", "calls", "the", "block", "outside", "the", "mutex", "and", "after", "the", "string", "has", "been", "returned", "to", "the", "client", "." ]

[ "def", "send_file", "(", "file", ",", "opts", "=", "{", "}", ")", "opts", ".", "update", "(", "Merb", "::", "Const", "::", "DEFAULT_SEND_FILE_OPTIONS", ".", "merge", "(", "opts", ")", ")", "disposition", "=", "opts", "[", ":disposition", "]", ".", "dup", "||", "'attachment'", "disposition", "<<", "%(; filename=\"#{opts[:filename] ? opts[:filename] : File.basename(file)}\")", "headers", ".", "update", "(", "'Content-Type'", "=>", "opts", "[", ":type", "]", ".", "strip", ",", "# fixes a problem with extra '\\r' with some browsers", "'Content-Disposition'", "=>", "disposition", ",", "'Content-Transfer-Encoding'", "=>", "'binary'", ")", "Proc", ".", "new", "do", "|", "response", "|", "file", "=", "File", ".", "open", "(", "file", ",", "'rb'", ")", "while", "chunk", "=", "file", ".", "read", "(", "16384", ")", "response", ".", "write", "chunk", "end", "file", ".", "close", "end", "end" ]

[ "Sends", "a", "file", "over", "HTTP", ".", "When", "given", "a", "path", "to", "a", "file", "it", "will", "set", "the", "right", "headers", "so", "that", "the", "static", "file", "is", "served", "directly", "." ]

[ "def", "send_data", "(", "data", ",", "opts", "=", "{", "}", ")", "opts", ".", "update", "(", "Merb", "::", "Const", "::", "DEFAULT_SEND_FILE_OPTIONS", ".", "merge", "(", "opts", ")", ")", "disposition", "=", "opts", "[", ":disposition", "]", ".", "dup", "||", "'attachment'", "disposition", "<<", "%(; filename=\"#{opts[:filename]}\")", "if", "opts", "[", ":filename", "]", "headers", ".", "update", "(", "'Content-Type'", "=>", "opts", "[", ":type", "]", ".", "strip", ",", "# fixes a problem with extra '\\r' with some browsers", "'Content-Disposition'", "=>", "disposition", ",", "'Content-Transfer-Encoding'", "=>", "'binary'", ")", "data", "end" ]

[ "Send", "binary", "data", "over", "HTTP", "to", "the", "user", "as", "a", "file", "download", ".", "May", "set", "content", "type", "apparent", "file", "name", "and", "specify", "whether", "to", "show", "data", "inline", "or", "download", "as", "an", "attachment", "." ]

[ "def", "stream_file", "(", "opts", "=", "{", "}", ",", "&", "stream", ")", "opts", ".", "update", "(", "Merb", "::", "Const", "::", "DEFAULT_SEND_FILE_OPTIONS", ".", "merge", "(", "opts", ")", ")", "disposition", "=", "opts", "[", ":disposition", "]", ".", "dup", "||", "'attachment'", "disposition", "<<", "%(; filename=\"#{opts[:filename]}\")", "headers", ".", "update", "(", "'Content-Type'", "=>", "opts", "[", ":type", "]", ".", "strip", ",", "# fixes a problem with extra '\\r' with some browsers", "'Content-Disposition'", "=>", "disposition", ",", "'Content-Transfer-Encoding'", "=>", "'binary'", ",", "# Rack specification requires header values to respond to :each", "'CONTENT-LENGTH'", "=>", "opts", "[", ":content_length", "]", ".", "to_s", ")", "Proc", ".", "new", "do", "|", "response", "|", "stream", ".", "call", "(", "response", ")", "end", "end" ]

[ "Streams", "a", "file", "over", "HTTP", "." ]

[ "def", "set_cookie", "(", "name", ",", "value", ",", "expires", ")", "options", "=", "expires", ".", "is_a?", "(", "Hash", ")", "?", "expires", ":", "{", ":expires", "=>", "expires", "}", "cookies", ".", "set_cookie", "(", "name", ",", "value", ",", "options", ")", "end" ]

[ "Sets", "a", "cookie", "to", "be", "included", "in", "the", "response", "." ]

[ "def", "handle_redirect_messages", "(", "url", ",", "opts", "=", "{", "}", ")", "opts", "=", "opts", ".", "dup", "# check opts for message shortcut keys (and assign them to message)", "[", ":notice", ",", ":error", ",", ":success", "]", ".", "each", "do", "|", "message_key", "|", "if", "opts", "[", "message_key", "]", "opts", "[", ":message", "]", "||=", "{", "}", "opts", "[", ":message", "]", "[", "message_key", "]", "=", "opts", "[", "message_key", "]", "end", "end", "# append message query param if message is passed", "if", "opts", "[", ":message", "]", "notice", "=", "Merb", "::", "Parse", ".", "escape", "(", "[", "Marshal", ".", "dump", "(", "opts", "[", ":message", "]", ")", "]", ".", "pack", "(", "\"m\"", ")", ")", "u", "=", "::", "URI", ".", "parse", "(", "url", ")", "u", ".", "query", "=", "u", ".", "query", "?", "\"#{u.query}&_message=#{notice}\"", ":", "\"_message=#{notice}\"", "url", "=", "u", ".", "to_s", "end", "url", "end" ]

[ "Process", "a", "redirect", "url", "with", "options", "appending", "messages", "onto", "the", "url", "as", "query", "params" ]

[ "def", "_call_filters", "(", "filter_set", ")", "(", "filter_set", "||", "[", "]", ")", ".", "each", "do", "|", "filter", ",", "rule", "|", "if", "_call_filter_for_action?", "(", "rule", ",", "action_name", ")", "&&", "_filter_condition_met?", "(", "rule", ")", "case", "filter", "when", "Symbol", ",", "String", "if", "rule", ".", "key?", "(", ":with", ")", "args", "=", "rule", "[", ":with", "]", "send", "(", "filter", ",", "args", ")", "else", "send", "(", "filter", ")", "end", "when", "Proc", "then", "self", ".", "instance_eval", "(", "filter", ")", "end", "end", "end", "return", ":filter_chain_completed", "end" ]

[ "Calls", "a", "filter", "chain", "." ]

[ "def", "absolute_url", "(", "*", "args", ")", "# FIXME: arrgh, why request.protocol returns http://?", "# :// is not part of protocol name", "options", "=", "extract_options_from_args!", "(", "args", ")", "||", "{", "}", "protocol", "=", "options", ".", "delete", "(", ":protocol", ")", "host", "=", "options", ".", "delete", "(", ":host", ")", "raise", "ArgumentError", ",", "\"The :protocol option must be specified\"", "unless", "protocol", "raise", "ArgumentError", ",", "\"The :host option must be specified\"", "unless", "host", "args", "<<", "options", "protocol", "+", "\"://\"", "+", "host", "+", "url", "(", "args", ")", "end" ]

[ "Returns", "the", "absolute", "url", "including", "the", "passed", "protocol", "and", "host", "." ]

[ "def", "capture", "(", "*", "args", ",", "&", "block", ")", "ret", "=", "nil", "captured", "=", "send", "(", "\"capture_#{@_engine}\"", ",", "args", ")", "do", "|", "*", "args", "|", "ret", "=", "yield", "args", "end", "# return captured value only if it is not empty", "captured", ".", "empty?", "?", "ret", ".", "to_s", ":", "captured", "end" ]

[ "Calls", "the", "capture", "method", "for", "the", "selected", "template", "engine", "." ]

[ "def", "notify_of_exceptions", "if", "Merb", "::", "Plugins", ".", "config", "[", ":exceptions", "]", "[", ":environments", "]", ".", "include?", "(", "Merb", ".", "env", ")", "begin", "request", "=", "self", ".", "request", "details", "=", "{", "}", "details", "[", "'exceptions'", "]", "=", "request", ".", "exceptions", "details", "[", "'params'", "]", "=", "params", "details", "[", "'params'", "]", "=", "self", ".", "class", ".", "_filter_params", "(", "params", ")", "details", "[", "'environment'", "]", "=", "request", ".", "env", ".", "merge", "(", "'process'", "=>", "$$", ")", "details", "[", "'url'", "]", "=", "\"#{request.protocol}#{request.env[\"HTTP_HOST\"]}#{request.uri}\"", "MerbExceptions", "::", "Notification", ".", "new", "(", "details", ")", ".", "deliver!", "rescue", "Exception", "=>", "e", "exceptions", "=", "request", ".", "exceptions", "<<", "e", "Merb", ".", "logger", ".", "fatal!", "(", "\"Exception Notification Failed:\\n\"", "+", "(", "exceptions", ")", ".", "inspect", ")", "File", ".", "open", "(", "Merb", ".", "root", "/", "'log'", "/", "'notification_errors.log'", ",", "'a'", ")", "do", "|", "log", "|", "log", ".", "puts", "(", "\"Exception Notification Failed:\"", ")", "exceptions", ".", "each", "do", "|", "e", "|", "log", ".", "puts", "(", "Merb", ".", "exception", "(", "e", ")", ")", "end", "end", "end", "end", "end" ]

[ "if", "you", "need", "to", "handle", "the", "render", "yourself", "for", "some", "reason", "you", "can", "call", "this", "method", "directly", ".", "It", "sends", "notifications", "without", "any", "rendering", "logic", ".", "Note", "though", "that", "if", "you", "are", "sending", "lots", "of", "notifications", "this", "could", "delay", "sending", "a", "response", "back", "to", "the", "user", "so", "try", "to", "avoid", "using", "it", "where", "possible", "." ]

[ "def", "writable?", "(", "key", ",", "parameters", "=", "{", "}", ",", "conditions", "=", "{", "}", ")", "case", "key", "when", "String", ",", "Numeric", ",", "Symbol", "!", "conditions", ".", "has_key?", "(", ":expire_in", ")", "else", "nil", "end", "end" ]

[ "Creates", "directory", "for", "cached", "files", "unless", "it", "exists", ".", "File", "caching", "does", "not", "support", "expiration", "time", "." ]

[ "def", "read", "(", "key", ",", "parameters", "=", "{", "}", ")", "if", "exists?", "(", "key", ",", "parameters", ")", "read_file", "(", "pathify", "(", "key", ",", "parameters", ")", ")", "end", "end" ]

[ "Reads", "cached", "template", "from", "disk", "if", "it", "exists", "." ]

[ "def", "write", "(", "key", ",", "data", "=", "nil", ",", "parameters", "=", "{", "}", ",", "conditions", "=", "{", "}", ")", "if", "writable?", "(", "key", ",", "parameters", ",", "conditions", ")", "if", "File", ".", "file?", "(", "path", "=", "pathify", "(", "key", ",", "parameters", ")", ")", "write_file", "(", "path", ",", "data", ")", "else", "create_path", "(", "path", ")", "&&", "write_file", "(", "path", ",", "data", ")", "end", "end", "end" ]

[ "Writes", "cached", "template", "to", "disk", "creating", "cache", "directory", "if", "it", "does", "not", "exist", "." ]

[ "def", "fetch", "(", "key", ",", "parameters", "=", "{", "}", ",", "conditions", "=", "{", "}", ",", "&", "blk", ")", "read", "(", "key", ",", "parameters", ")", "||", "(", "writable?", "(", "key", ",", "parameters", ",", "conditions", ")", "&&", "write", "(", "key", ",", "value", "=", "blk", ".", "call", ",", "parameters", ",", "conditions", ")", "&&", "value", ")", "end" ]

[ "Fetches", "cached", "data", "by", "key", "if", "it", "exists", ".", "If", "it", "does", "not", "uses", "passed", "block", "to", "get", "new", "cached", "value", "and", "writes", "it", "using", "given", "key", "." ]

[ "def", "read_file", "(", "path", ")", "data", "=", "nil", "File", ".", "open", "(", "path", ",", "\"r\"", ")", "do", "|", "file", "|", "file", ".", "flock", "(", "File", "::", "LOCK_EX", ")", "data", "=", "file", ".", "read", "file", ".", "flock", "(", "File", "::", "LOCK_UN", ")", "end", "data", "end" ]

[ "Reads", "file", "content", ".", "Access", "to", "the", "file", "uses", "file", "locking", "." ]

[ "def", "write_file", "(", "path", ",", "data", ")", "File", ".", "open", "(", "path", ",", "\"w+\"", ")", "do", "|", "file", "|", "file", ".", "flock", "(", "File", "::", "LOCK_EX", ")", "file", ".", "write", "(", "data", ")", "file", ".", "flock", "(", "File", "::", "LOCK_UN", ")", "end", "true", "end" ]

[ "Writes", "file", "content", ".", "Access", "to", "the", "file", "uses", "file", "locking", "." ]

[ "def", "write", "(", "key", ",", "data", "=", "nil", ",", "parameters", "=", "{", "}", ",", "conditions", "=", "{", "}", ")", "@stores", ".", "capture_first", "{", "|", "s", "|", "s", ".", "write", "(", "key", ",", "data", ",", "parameters", ",", "conditions", ")", "}", "end" ]

[ "persists", "the", "data", "so", "that", "it", "can", "be", "retrieved", "by", "the", "key", "&", "parameters", ".", "returns", "nil", "if", "it", "is", "unable", "to", "persist", "the", "data", ".", "returns", "true", "if", "successful", "." ]

[ "def", "write_all", "(", "key", ",", "data", "=", "nil", ",", "parameters", "=", "{", "}", ",", "conditions", "=", "{", "}", ")", "@stores", ".", "map", "{", "|", "s", "|", "s", ".", "write_all", "(", "key", ",", "data", ",", "parameters", ",", "conditions", ")", "}", ".", "all?", "end" ]

[ "persists", "the", "data", "to", "all", "context", "stores", ".", "returns", "nil", "if", "none", "of", "the", "stores", "were", "able", "to", "persist", "the", "data", ".", "returns", "true", "if", "at", "least", "one", "write", "was", "successful", "." ]

[ "def", "fetch", "(", "key", ",", "parameters", "=", "{", "}", ",", "conditions", "=", "{", "}", ",", "&", "blk", ")", "read", "(", "key", ",", "parameters", ")", "||", "@stores", ".", "capture_first", "{", "|", "s", "|", "s", ".", "fetch", "(", "key", ",", "parameters", ",", "conditions", ",", "blk", ")", "}", "||", "blk", ".", "call", "end" ]

[ "tries", "to", "read", "the", "data", "from", "the", "store", ".", "If", "that", "fails", "it", "calls", "the", "block", "parameter", "and", "persists", "the", "result", ".", "If", "it", "cannot", "be", "fetched", "the", "block", "call", "is", "returned", "." ]

[ "def", "delete", "(", "key", ",", "parameters", "=", "{", "}", ")", "@stores", ".", "map", "{", "|", "s", "|", "s", ".", "delete", "(", "key", ",", "parameters", ")", "}", ".", "any?", "end" ]

[ "deletes", "the", "entry", "for", "the", "key", "&", "parameter", "from", "the", "store", "." ]

[ "def", "user", "=", "(", "user", ")", "session", "[", ":user", "]", "=", "nil", "&&", "return", "if", "user", ".", "nil?", "session", "[", ":user", "]", "=", "store_user", "(", "user", ")", "@user", "=", "session", "[", ":user", "]", "?", "user", ":", "session", "[", ":user", "]", "end" ]

[ "This", "method", "will", "store", "the", "user", "provided", "into", "the", "session", "and", "set", "the", "user", "as", "the", "currently", "logged", "in", "user" ]

[ "def", "authenticate!", "(", "request", ",", "params", ",", "*", "rest", ")", "opts", "=", "rest", ".", "last", ".", "kind_of?", "(", "Hash", ")", "?", "rest", ".", "pop", ":", "{", "}", "rest", "=", "rest", ".", "flatten", "strategies", "=", "if", "rest", ".", "empty?", "if", "request", ".", "session", "[", ":authentication_strategies", "]", "request", ".", "session", "[", ":authentication_strategies", "]", "else", "Merb", "::", "Authentication", ".", "default_strategy_order", "end", "else", "request", ".", "session", "[", ":authentication_strategies", "]", "||=", "[", "]", "request", ".", "session", "[", ":authentication_strategies", "]", "<<", "rest", "request", ".", "session", "[", ":authentication_strategies", "]", ".", "flatten!", ".", "uniq!", "request", ".", "session", "[", ":authentication_strategies", "]", "end", "msg", "=", "opts", "[", ":message", "]", "||", "error_message", "user", "=", "nil", "# This one should find the first one that matches. It should not run antother", "strategies", ".", "detect", "do", "|", "s", "|", "s", "=", "Merb", "::", "Authentication", ".", "lookup_strategy", "[", "s", "]", "# Get the strategy from string or class", "unless", "s", ".", "abstract?", "strategy", "=", "s", ".", "new", "(", "request", ",", "params", ")", "user", "=", "strategy", ".", "run!", "if", "strategy", ".", "halted?", "self", ".", "headers", ",", "self", ".", "status", ",", "self", ".", "body", "=", "[", "strategy", ".", "headers", ",", "strategy", ".", "status", ",", "strategy", ".", "body", "]", "halt!", "return", "end", "user", "end", "end", "# Check after callbacks to make sure the user is still cool", "user", "=", "run_after_authentication_callbacks", "(", "user", ",", "request", ",", "params", ")", "if", "user", "# Finally, Raise an error if there is no user found, or set it in the session if there is.", "raise", "Merb", "::", "Controller", "::", "Unauthenticated", ",", "msg", "unless", "user", "session", "[", ":authentication_strategies", "]", "=", "nil", "# clear the session of Failed Strategies if login is successful ", "self", ".", "user", "=", "user", "end" ]

[ "The", "workhorse", "of", "the", "framework", ".", "The", "authentiate!", "method", "is", "where", "the", "work", "is", "done", ".", "authenticate!", "will", "try", "each", "strategy", "in", "order", "either", "passed", "in", "or", "in", "the", "default_strategy_order", "." ]

[ "def", "extract_headers", "(", "controller_defaults", "=", "{", "}", ")", "defaults", "=", "@_cookie_defaults", ".", "merge", "(", "controller_defaults", ")", "cookies", "=", "[", "]", "self", ".", "each", "do", "|", "name", ",", "value", "|", "# Only set cookies that marked for inclusion in the response header. ", "next", "unless", "@_options_lookup", "[", "name", "]", "options", "=", "defaults", ".", "merge", "(", "@_options_lookup", "[", "name", "]", ")", "if", "(", "expiry", "=", "options", "[", "\"expires\"", "]", ")", ".", "respond_to?", "(", ":gmtime", ")", "options", "[", "\"expires\"", "]", "=", "expiry", ".", "gmtime", ".", "strftime", "(", "Merb", "::", "Const", "::", "COOKIE_EXPIRATION_FORMAT", ")", "end", "secure", "=", "options", ".", "delete", "(", "\"secure\"", ")", "http_only", "=", "options", ".", "delete", "(", "\"http_only\"", ")", "kookie", "=", "\"#{name}=#{Merb::Parse.escape(value)}; \"", "# WebKit in particular doens't like empty cookie options - skip them.", "options", ".", "each", "{", "|", "k", ",", "v", "|", "kookie", "<<", "\"#{k}=#{v}; \"", "unless", "v", ".", "blank?", "}", "kookie", "<<", "'secure; '", "if", "secure", "kookie", "<<", "'HttpOnly; '", "if", "http_only", "cookies", "<<", "kookie", ".", "rstrip", "end", "cookies", ".", "empty?", "?", "{", "}", ":", "{", "'Set-Cookie'", "=>", "cookies", "}", "end" ]

[ "Generate", "any", "necessary", "headers", "." ]

[ "def", "read", "(", "key", ",", "parameters", "=", "{", "}", ")", "begin", "@memcached", ".", "get", "(", "normalize", "(", "key", ",", "parameters", ")", ")", "rescue", "Memcached", "::", "NotFound", ",", "Memcached", "::", "Stored", "nil", "end", "end" ]

[ "Reads", "key", "from", "the", "cache", "." ]

[ "def", "write", "(", "key", ",", "data", "=", "nil", ",", "parameters", "=", "{", "}", ",", "conditions", "=", "{", "}", ")", "if", "writable?", "(", "key", ",", "parameters", ",", "conditions", ")", "begin", "@memcached", ".", "set", "(", "normalize", "(", "key", ",", "parameters", ")", ",", "data", ",", "expire_time", "(", "conditions", ")", ")", "true", "rescue", "nil", "end", "end", "end" ]

[ "Writes", "data", "to", "the", "cache", "using", "key", "parameters", "and", "conditions", "." ]

[ "def", "extract_required_files", "(", "files", ",", "options", "=", "{", "}", ")", "return", "[", "]", "if", "files", ".", "nil?", "||", "files", ".", "empty?", "seen", "=", "[", "]", "files", ".", "inject", "(", "[", "]", ")", "do", "|", "extracted", ",", "req_js", "|", "include_files", ",", "include_options", "=", "if", "req_js", ".", "last", ".", "is_a?", "(", "Hash", ")", "[", "req_js", "[", "0", "..", "-", "2", "]", ",", "options", ".", "merge", "(", "req_js", ".", "last", ")", "]", "else", "[", "req_js", ",", "options", "]", "end", "seen", "+=", "(", "includes", "=", "include_files", "-", "seen", ")", "extracted", "<<", "(", "includes", "+", "[", "include_options", "]", ")", "unless", "includes", ".", "empty?", "extracted", "end", "end" ]

[ "Helper", "method", "to", "filter", "out", "duplicate", "files", "." ]

[ "def", "reap_expired_sessions", "@timestamps", ".", "each", "do", "|", "session_id", ",", "stamp", "|", "delete_session", "(", "session_id", ")", "if", "(", "stamp", "+", "@session_ttl", ")", "<", "Time", ".", "now", "end", "GC", ".", "start", "end" ]

[ "Deletes", "any", "sessions", "that", "have", "reached", "their", "maximum", "validity", "." ]

[ "def", "to_cookie", "unless", "self", ".", "empty?", "data", "=", "self", ".", "serialize", "value", "=", "Merb", "::", "Parse", ".", "escape", "\"#{data}--#{generate_digest(data)}\"", "if", "value", ".", "size", ">", "MAX", "msg", "=", "\"Cookies have limit of 4K. Session contents: #{data.inspect}\"", "Merb", ".", "logger", ".", "error!", "(", "msg", ")", "raise", "CookieOverflow", ",", "msg", "end", "value", "end", "end" ]

[ "Create", "the", "raw", "cookie", "string", ";", "includes", "an", "HMAC", "keyed", "message", "digest", "." ]

[ "def", "secure_compare", "(", "a", ",", "b", ")", "if", "a", ".", "length", "==", "b", ".", "length", "# unpack to forty characters.", "# needed for 1.8 and 1.9 compat", "a_bytes", "=", "a", ".", "unpack", "(", "'C*'", ")", "b_bytes", "=", "b", ".", "unpack", "(", "'C*'", ")", "result", "=", "0", "for", "i", "in", "0", "..", "(", "a_bytes", ".", "length", "-", "1", ")", "result", "|=", "a_bytes", "[", "i", "]", "^", "b_bytes", "[", "i", "]", "end", "result", "==", "0", "else", "false", "end", "end" ]

[ "Securely", "compare", "two", "digests", "using", "a", "constant", "time", "algorithm", ".", "This", "avoids", "leaking", "information", "about", "the", "calculated", "HMAC" ]

[ "def", "unmarshal", "(", "cookie", ")", "if", "cookie", ".", "blank?", "{", "}", "else", "data", ",", "digest", "=", "Merb", "::", "Parse", ".", "unescape", "(", "cookie", ")", ".", "split", "(", "'--'", ")", "return", "{", "}", "if", "data", ".", "blank?", "||", "digest", ".", "blank?", "unless", "secure_compare", "(", "generate_digest", "(", "data", ")", ",", "digest", ")", "clear", "unless", "Merb", "::", "Config", "[", ":ignore_tampered_cookies", "]", "raise", "TamperedWithCookie", ",", "\"Maybe the site's session_secret_key has changed?\"", "end", "end", "unserialize", "(", "data", ")", "end", "end" ]

[ "Unmarshal", "cookie", "data", "to", "a", "hash", "and", "verify", "its", "integrity", "." ]

[ "def", "controller", "unless", "params", "[", ":controller", "]", "raise", "ControllerExceptions", "::", "NotFound", ",", "\"Route matched, but route did not specify a controller.\\n\"", "+", "\"Did you forgot to add :controller => \\\"people\\\" or :controller \"", "+", "\"segment to route definition?\\nHere is what's specified:\\n\"", "+", "route", ".", "inspect", "end", "path", "=", "[", "params", "[", ":namespace", "]", ",", "params", "[", ":controller", "]", "]", ".", "compact", ".", "join", "(", "Merb", "::", "Const", "::", "SLASH", ")", "controller", "=", "path", ".", "snake_case", ".", "to_const_string", "begin", "Object", ".", "full_const_get", "(", "controller", ")", "rescue", "NameError", "=>", "e", "msg", "=", "\"Controller class not found for controller `#{path}'\"", "Merb", ".", "logger", ".", "warn!", "(", "msg", ")", "raise", "ControllerExceptions", "::", "NotFound", ",", "msg", "end", "end" ]

[ "Returns", "the", "controller", "object", "for", "initialization", "and", "dispatching", "the", "request", "." ]

[ "def", "body_params", "@body_params", "||=", "begin", "if", "content_type", "&&", "content_type", ".", "match", "(", "Merb", "::", "Const", "::", "FORM_URL_ENCODED_REGEXP", ")", "# or content_type.nil?", "Merb", "::", "Parse", ".", "query", "(", "raw_post", ")", "end", "end", "end" ]

[ "Parameters", "passed", "in", "the", "body", "of", "the", "request", ".", "Ajax", "calls", "from", "prototype", ".", "js", "and", "other", "libraries", "pass", "content", "this", "way", "." ]

[ "def", "ensure_authenticated", "(", "*", "strategies", ")", "session", ".", "authenticate!", "(", "request", ",", "params", ",", "strategies", ")", "unless", "session", ".", "authenticated?", "auth", "=", "session", ".", "authentication", "if", "auth", ".", "halted?", "self", ".", "headers", ".", "merge!", "(", "auth", ".", "headers", ")", "self", ".", "status", "=", "auth", ".", "status", "throw", ":halt", ",", "auth", ".", "body", "end", "session", ".", "user", "end" ]

[ "This", "is", "the", "main", "method", "to", "use", "as", "a", "before", "filter", ".", "You", "can", "call", "it", "with", "options", "and", "strategies", "to", "use", ".", "It", "will", "check", "if", "a", "user", "is", "logged", "in", "and", "failing", "that", "will", "run", "through", "either", "specified", "." ]

[ "def", "callback", "(", "event", ",", "buffer", "=", "nil", ",", "start", "=", "nil", ",", "the_end", "=", "nil", ")", "return", "if", "!", "start", ".", "nil?", "&&", "start", "==", "the_end", "if", "@callbacks", ".", "has_key?", "event", "@callbacks", "[", "event", "]", ".", "call", "(", "buffer", ",", "start", ",", "the_end", ")", "end", "end" ]

[ "Issues", "a", "callback", "." ]

[ "def", "content_type", "=", "(", "type", ")", "unless", "Merb", ".", "available_mime_types", ".", "has_key?", "(", "type", ")", "raise", "Merb", "::", "ControllerExceptions", "::", "NotAcceptable", ".", "new", "(", "\"Unknown content_type for response: #{type}\"", ")", "end", "@_content_type", "=", "type", "mime", "=", "Merb", ".", "available_mime_types", "[", "type", "]", "headers", "[", "\"Content-Type\"", "]", "=", "mime", "[", ":content_type", "]", "# merge any format specific response headers", "mime", "[", ":response_headers", "]", ".", "each", "{", "|", "k", ",", "v", "|", "headers", "[", "k", "]", "||=", "v", "}", "# if given, use a block to finetune any runtime headers", "mime", "[", ":response_block", "]", ".", "call", "(", "self", ")", "if", "mime", "[", ":response_block", "]", "@_content_type", "end" ]

[ "Sets", "the", "content", "type", "of", "the", "current", "response", "to", "a", "value", "based", "on", "a", "passed", "in", "key", ".", "The", "Content", "-", "Type", "header", "will", "be", "set", "to", "the", "first", "registered", "header", "for", "the", "mime", "-", "type", "." ]

[ "def", "render_mail", "(", "options", "=", "@method", ")", "@_missing_templates", "=", "false", "# used to make sure that at least one template was found", "# If the options are not a hash, normalize to an action hash", "options", "=", "{", ":action", "=>", "{", ":html", "=>", "options", ",", ":text", "=>", "options", "}", "}", "if", "!", "options", ".", "is_a?", "(", "Hash", ")", "# Take care of the options", "opts_hash", "=", "{", "}", "opts", "=", "options", ".", "dup", "actions", "=", "opts", ".", "delete", "(", ":action", ")", "if", "opts", "[", ":action", "]", ".", "is_a?", "(", "Hash", ")", "templates", "=", "opts", ".", "delete", "(", ":template", ")", "if", "opts", "[", ":template", "]", ".", "is_a?", "(", "Hash", ")", "# Prepare the options hash for each format", "# We need to delete anything relating to the other format here", "# before we try to render the template.", "[", ":html", ",", ":text", "]", ".", "each", "do", "|", "fmt", "|", "opts_hash", "[", "fmt", "]", "=", "opts", ".", "delete", "(", "fmt", ")", "opts_hash", "[", "fmt", "]", "||=", "actions", "[", "fmt", "]", "if", "actions", "&&", "actions", "[", "fmt", "]", "opts_hash", "[", ":template", "]", "=", "templates", "[", "fmt", "]", "if", "templates", "&&", "templates", "[", "fmt", "]", "end", "# Send the result to the mailer", "{", ":html", "=>", "\"rawhtml=\"", ",", ":text", "=>", "\"text=\"", "}", ".", "each", "do", "|", "fmt", ",", "meth", "|", "begin", "local_opts", "=", "opts", ".", "merge", "(", ":format", "=>", "fmt", ")", "local_opts", ".", "merge!", "(", ":layout", "=>", "false", ")", "if", "opts_hash", "[", "fmt", "]", ".", "is_a?", "(", "String", ")", "clear_content", "value", "=", "render", "opts_hash", "[", "fmt", "]", ",", "local_opts", "@mail", ".", "send", "(", "meth", ",", "value", ")", "unless", "value", ".", "nil?", "||", "value", ".", "empty?", "rescue", "Merb", "::", "ControllerExceptions", "::", "TemplateNotFound", "=>", "e", "# An error should be logged if no template is found instead of an error raised", "if", "@_missing_templates", "Merb", ".", "logger", ".", "error", "(", "e", ".", "message", ")", "else", "@_missing_templates", "=", "true", "end", "end", "end", "@mail", "end" ]

[ "Allows", "you", "to", "render", "various", "types", "of", "things", "into", "the", "text", "and", "HTML", "parts", "of", "an", "email", "If", "you", "include", "just", "text", "the", "email", "will", "be", "sent", "as", "plain", "-", "text", ".", "If", "you", "include", "HTML", "the", "email", "will", "be", "sent", "as", "a", "multi", "-", "part", "email", "." ]

[ "def", "check_lgtm", "(", "image_url", ":", "nil", ",", "https_image_only", ":", "false", ")", "return", "unless", "status_report", "[", ":errors", "]", ".", "length", ".", "zero?", "&&", "status_report", "[", ":warnings", "]", ".", "length", ".", "zero?", "image_url", "||=", "fetch_image_url", "(", "https_image_only", ":", "https_image_only", ")", "markdown", "(", "markdown_template", "(", "image_url", ")", ")", "end" ]

[ "Check", "status", "report", "say", "lgtm", "if", "no", "violations", "Generates", "a", "markdown", "of", "a", "lgtm", "image", "." ]

[ "def", "each", "unless", "block_given?", "return", "self", ".", "enum_for", "(", ":each", ")", "else", "while", "@parser", ".", "has_next?", "event", "=", "@parser", ".", "pull", "# if it's the start of a record element ", "if", "event", ".", "start_element?", "and", "strip_ns", "(", "event", "[", "0", "]", ")", "==", "'record'", "yield", "build_record", "end", "end", "end", "end" ]

[ "Loop", "through", "the", "MARC", "records", "in", "the", "XML", "document" ]

[ "def", "build_record", "record", "=", "MARC", "::", "Record", ".", "new", "data_field", "=", "nil", "control_field", "=", "nil", "subfield", "=", "nil", "text", "=", "''", "attrs", "=", "nil", "if", "Module", ".", "constants", ".", "index", "(", "'Nokogiri'", ")", "and", "@parser", ".", "is_a?", "(", "Nokogiri", "::", "XML", "::", "Reader", ")", "datafield", "=", "nil", "cursor", "=", "nil", "open_elements", "=", "[", "]", "@parser", ".", "each", "do", "|", "node", "|", "if", "node", ".", "value?", "&&", "cursor", "if", "cursor", ".", "is_a?", "(", "Symbol", ")", "and", "cursor", "==", ":leader", "record", ".", "leader", "=", "node", ".", "value", "else", "cursor", ".", "value", "=", "node", ".", "value", "end", "cursor", "=", "nil", "end", "next", "unless", "node", ".", "namespace_uri", "==", "@ns", "if", "open_elements", ".", "index", "(", "node", ".", "local_name", ".", "downcase", ")", "open_elements", ".", "delete", "(", "node", ".", "local_name", ".", "downcase", ")", "next", "else", "open_elements", "<<", "node", ".", "local_name", ".", "downcase", "end", "case", "node", ".", "local_name", ".", "downcase", "when", "\"leader\"", "cursor", "=", ":leader", "when", "\"controlfield\"", "record", "<<", "datafield", "if", "datafield", "datafield", "=", "nil", "control_field", "=", "MARC", "::", "ControlField", ".", "new", "(", "node", ".", "attribute", "(", "'tag'", ")", ")", "record", "<<", "control_field", "cursor", "=", "control_field", "when", "\"datafield\"", "record", "<<", "datafield", "if", "datafield", "datafield", "=", "nil", "data_field", "=", "MARC", "::", "DataField", ".", "new", "(", "node", ".", "attribute", "(", "'tag'", ")", ",", "node", ".", "attribute", "(", "'ind1'", ")", ",", "node", ".", "attribute", "(", "'ind2'", ")", ")", "datafield", "=", "data_field", "when", "\"subfield\"", "raise", "\"No datafield to add to\"", "unless", "datafield", "subfield", "=", "MARC", "::", "Subfield", ".", "new", "(", "node", ".", "attribute", "(", "'code'", ")", ")", "datafield", ".", "append", "(", "subfield", ")", "cursor", "=", "subfield", "when", "\"record\"", "record", "<<", "datafield", "if", "datafield", "return", "record", "end", "#puts node.name", "end", "else", "while", "@parser", ".", "has_next?", "event", "=", "@parser", ".", "pull", "if", "event", ".", "text?", "text", "+=", "REXML", "::", "Text", "::", "unnormalize", "(", "event", "[", "0", "]", ")", "next", "end", "if", "event", ".", "start_element?", "text", "=", "''", "attrs", "=", "event", "[", "1", "]", "case", "strip_ns", "(", "event", "[", "0", "]", ")", "when", "'controlfield'", "text", "=", "''", "control_field", "=", "MARC", "::", "ControlField", ".", "new", "(", "attrs", "[", "'tag'", "]", ")", "when", "'datafield'", "text", "=", "''", "data_field", "=", "MARC", "::", "DataField", ".", "new", "(", "attrs", "[", "'tag'", "]", ",", "attrs", "[", "'ind1'", "]", ",", "attrs", "[", "'ind2'", "]", ")", "when", "'subfield'", "text", "=", "''", "subfield", "=", "MARC", "::", "Subfield", ".", "new", "(", "attrs", "[", "'code'", "]", ")", "end", "end", "if", "event", ".", "end_element?", "case", "strip_ns", "(", "event", "[", "0", "]", ")", "when", "'leader'", "record", ".", "leader", "=", "text", "when", "'record'", "return", "record", "when", "'controlfield'", "control_field", ".", "value", "=", "text", "record", ".", "append", "(", "control_field", ")", "when", "'datafield'", "record", ".", "append", "(", "data_field", ")", "when", "'subfield'", "subfield", ".", "value", "=", "text", "data_field", ".", "append", "(", "subfield", ")", "end", "end", "end", "end", "end" ]

[ "will", "accept", "parse", "events", "until", "a", "record", "has", "been", "built", "up" ]

[ "def", "validate_response", "(", "response", ")", "case", "response", "when", "SERVER_ERRORS", "raise", "::", "Lgtm", "::", "Errors", "::", "UnexpectedError", "when", "CLIENT_ERRORS", "raise", "::", "Lgtm", "::", "Errors", "::", "UnexpectedError", "end", "end" ]

[ "validate_response", "is", "response", "validating" ]

[ "def", "reindex", "@tags", "=", "{", "}", "self", ".", "each_with_index", "do", "|", "field", ",", "i", "|", "@tags", "[", "field", ".", "tag", "]", "||=", "[", "]", "@tags", "[", "field", ".", "tag", "]", "<<", "i", "end", "@clean", "=", "true", "end" ]

[ "Rebuild", "the", "HashWithChecksumAttribute", "with", "the", "current", "values", "of", "the", "fields", "Array" ]

[ "def", "fields", "(", "filter", "=", "nil", ")", "unless", "filter", "# Since we're returning the FieldMap object, which the caller", "# may mutate, we precautionarily mark dirty -- unless it's frozen", "# immutable.", "@fields", ".", "clean", "=", "false", "unless", "@fields", ".", "frozen?", "return", "@fields", "end", "@fields", ".", "reindex", "unless", "@fields", ".", "clean", "flds", "=", "[", "]", "if", "filter", ".", "is_a?", "(", "String", ")", "&&", "@fields", ".", "tags", "[", "filter", "]", "@fields", ".", "tags", "[", "filter", "]", ".", "each", "do", "|", "idx", "|", "flds", "<<", "@fields", "[", "idx", "]", "end", "elsif", "filter", ".", "is_a?", "(", "Array", ")", "||", "filter", ".", "is_a?", "(", "Range", ")", "@fields", ".", "each_by_tag", "(", "filter", ")", "do", "|", "tag", "|", "flds", "<<", "tag", "end", "end", "flds", "end" ]

[ "Provides", "a", "backwards", "compatible", "means", "to", "access", "the", "FieldMap", ".", "No", "argument", "returns", "the", "FieldMap", "array", "in", "entirety", ".", "Providing", "a", "string", "array", "or", "range", "of", "tags", "will", "return", "an", "array", "of", "fields", "in", "the", "order", "they", "appear", "in", "the", "record", "." ]

[ "def", "create", "upload_meta", "=", "prepare_to_upload", "response", "=", "upload_to_aws_s3", "(", "upload_meta", ")", "notify_ribose_file_upload_endpoint", "(", "response", ",", "upload_meta", ".", "fields", ".", "key", ")", "end" ]

[ "Initialize", "the", "file", "uploader" ]

[ "def", "request", "(", "options", "=", "{", "}", ")", "parsable", "=", "extract_config_option", "(", ":parse", ")", "!=", "false", "options", "[", ":query", "]", "=", "extract_config_option", "(", ":query", ")", "||", "{", "}", "response", "=", "agent", ".", "call", "(", "http_method", ",", "api_endpoint", ",", "data", ",", "options", ")", "parsable", "==", "true", "?", "response", ".", "data", ":", "response", "end" ]

[ "Initialize", "a", "Request" ]

[ "def", "to_hash", "field_hash", "=", "{", "@tag", "=>", "{", "'ind1'", "=>", "@indicator1", ",", "'ind2'", "=>", "@indicator2", ",", "'subfields'", "=>", "[", "]", "}", "}", "self", ".", "each", "do", "|", "subfield", "|", "field_hash", "[", "@tag", "]", "[", "'subfields'", "]", "<<", "{", "subfield", ".", "code", "=>", "subfield", ".", "value", "}", "end", "field_hash", "end" ]

[ "Turn", "the", "variable", "field", "and", "subfields", "into", "a", "hash", "for", "MARC", "-", "in", "-", "JSON" ]

[ "def", "call", "(", "obj", ",", "args", ",", "ctx", ")", "cache_key", "=", "[", "CacheQL", "::", "Railtie", ".", "config", ".", "global_key", ",", "obj", ".", "cache_key", ",", "ctx", ".", "field", ".", "name", "]", "CacheQL", "::", "Railtie", ".", "config", ".", "cache", ".", "fetch", "(", "cache_key", ",", "expires_in", ":", "CacheQL", "::", "Railtie", ".", "config", ".", "expires_range", ".", "sample", ".", "minutes", ")", "do", "@resolver_func", ".", "call", "(", "obj", ",", "args", ",", "ctx", ")", "end", "end" ]

[ "Resolve", "function", "level", "caching!" ]

[ "def", "call", "(", "input", ",", "options", "=", "{", "}", ")", "handler", "=", "handler_steps", "(", "options", ")", ".", "map", "(", "method", "(", ":step", ")", ")", ".", "reduce", "(", ":>>", ")", "handler", ".", "call", "(", "input", ")", "rescue", "StepError", "=>", "err", "raise", "TransactionFailedError", ".", "new", "(", "self", ",", "err", ")", "end" ]

[ "Call", "the", "transaction" ]

[ "def", "create_table", "(", "name", ")", "if", "!", "db", ".", "tables", ".", "include?", "(", "name", ".", "to_sym", ")", "db", ".", "create_table", "name", "do", "String", ":name", ",", ":size", "=>", "15", "Float", ":freq", "index", ":freq", "end", "end", "end" ]

[ "create", "a", "name", "table" ]

[ "def", "cleanup_surname", "(", "name", ")", "if", "name", ".", "length", ">", "4", "name", ".", "gsub!", "(", "/", "\\w", "/", ")", "{", "|", "s", "|", "\"Mc#{$1.capitalize}\"", "}", "name", ".", "gsub!", "(", "/", "\\w", "/", ")", "{", "|", "s", "|", "\"Mac#{$1.capitalize}\"", "}", "name", ".", "gsub!", "(", "/", "\\w", "/", ")", "{", "|", "s", "|", "\"Mac#{$1.capitalize}\"", "}", "name", ".", "gsub!", "(", "/", "\\w", "/", ")", "{", "|", "s", "|", "\"O'sh#{$1}\"", "}", "name", ".", "gsub!", "(", "/", "\\w", "/", ")", "{", "|", "s", "|", "\"Van#{$1.capitalize}\"", "}", "name", ".", "gsub!", "(", "/", "\\w", "/", ")", "{", "|", "s", "|", "\"Von#{$1.capitalize}\"", "}", "# name.gsub!(/^Dev(\\w+)/) { |s| \"DeV#{$1}\" } ", "end", "name", "end" ]

[ "apply", "some", "simple", "regexps", "to", "clean", "up", "surnames" ]

[ "def", "each_word", "(", "data", ",", "&", "block", ")", "return", "enum_for", "(", ":each_word", ",", "data", ")", "unless", "block", "unless", "data", ".", "respond_to?", "(", ":each_byte", ")", "raise", "(", "ArgumentError", ",", "\"the data to hexdump must define #each_byte\"", ")", "end", "if", "@word_size", ">", "1", "word", "=", "0", "count", "=", "0", "init_shift", "=", "if", "@endian", "==", ":big", "(", "(", "@word_size", "-", "1", ")", "*", "8", ")", "else", "0", "end", "shift", "=", "init_shift", "data", ".", "each_byte", "do", "|", "b", "|", "word", "|=", "(", "b", "<<", "shift", ")", "if", "@endian", "==", ":big", "shift", "-=", "8", "else", "shift", "+=", "8", "end", "count", "+=", "1", "if", "count", ">=", "@word_size", "yield", "word", "word", "=", "0", "count", "=", "0", "shift", "=", "init_shift", "end", "end", "# yield the remaining word", "yield", "word", "if", "count", ">", "0", "else", "data", ".", "each_byte", "(", "block", ")", "end", "end" ]

[ "Creates", "a", "new", "Hexdump", "dumper", "." ]

[ "def", "each", "(", "data", ")", "return", "enum_for", "(", ":each", ",", "data", ")", "unless", "block_given?", "index", "=", "0", "count", "=", "0", "numeric", "=", "[", "]", "printable", "=", "[", "]", "each_word", "(", "data", ")", "do", "|", "word", "|", "numeric", "<<", "format_numeric", "(", "word", ")", "printable", "<<", "format_printable", "(", "word", ")", "count", "+=", "1", "if", "count", ">=", "@width", "yield", "index", ",", "numeric", ",", "printable", "numeric", ".", "clear", "printable", ".", "clear", "index", "+=", "(", "@width", "*", "@word_size", ")", "count", "=", "0", "end", "end", "if", "count", ">", "0", "# yield the remaining data", "yield", "index", ",", "numeric", ",", "printable", "end", "end" ]

[ "Iterates", "over", "the", "hexdump", "." ]

[ "def", "dump", "(", "data", ",", "output", "=", "$stdout", ")", "unless", "output", ".", "respond_to?", "(", ":<<", ")", "raise", "(", "ArgumentError", ",", "\"output must support the #<< method\"", ")", "end", "bytes_segment_width", "=", "(", "(", "@width", "*", "@format_width", ")", "+", "@width", ")", "line_format", "=", "\"%.8x %-#{bytes_segment_width}s |%s|\\n\"", "index", "=", "0", "count", "=", "0", "numeric", "=", "''", "printable", "=", "''", "each_word", "(", "data", ")", "do", "|", "word", "|", "numeric", "<<", "format_numeric", "(", "word", ")", "<<", "' '", "printable", "<<", "format_printable", "(", "word", ")", "count", "+=", "1", "if", "count", ">=", "@width", "output", "<<", "sprintf", "(", "line_format", ",", "index", ",", "numeric", ",", "printable", ")", "numeric", "=", "''", "printable", "=", "''", "index", "+=", "(", "@width", "*", "@word_size", ")", "count", "=", "0", "end", "end", "if", "count", ">", "0", "# output the remaining line", "output", "<<", "sprintf", "(", "line_format", ",", "index", ",", "numeric", ",", "printable", ")", "end", "end" ]

[ "Dumps", "the", "hexdump", "." ]

[ "def", "format_printable", "(", "word", ")", "if", "@word_size", "==", "1", "PRINTABLE", "[", "word", "]", "elsif", "(", "RUBY_VERSION", ">", "'1.9.'", "&&", "(", "word", ">=", "-", "2", "&&", "word", "<=", "0x7fffffff", ")", ")", "begin", "word", ".", "chr", "(", "Encoding", "::", "UTF_8", ")", "rescue", "RangeError", "UNPRINTABLE", "end", "else", "UNPRINTABLE", "end", "end" ]

[ "Converts", "a", "word", "into", "a", "printable", "String", "." ]

[ "def", "set_model", "(", "vr_combo", ")", "# :nodoc:", "self", ".", "model", "=", "Gtk", "::", "ListStore", ".", "new", "(", "String", ")", "vr_combo", ".", "selections", ".", "each", "{", "|", "s", "|", "r", "=", "self", ".", "model", ".", "append", ";", "r", "[", "0", "]", "=", "s", "}", "self", ".", "text_column", "=", "0", "end" ]

[ "This", "sets", "the", "renderer", "s", "editable", "property", "to", "true", "and", "makes", "it", "save", "the", "edited", "value", "to", "the", "model", ".", "When", "a", "user", "edits", "a", "row", "in", "the", "ListView", "the", "value", "isn", "t", "automatically", "saved", "by", "Gtk", ".", "This", "method", "groups", "both", "actions", "together", "so", "setting", "edit_save", "=", "true", "allows", "both", "editing", "and", "saving", "of", "the", "field", "." ]

[ "def", "refresh", "(", "flags", "=", "{", "}", ")", "@root", "=", "flags", "[", ":root", "]", "if", "flags", "[", ":root", "]", "open_folders", "=", "flags", "[", ":open_folders", "]", "?", "flags", "[", ":open_folders", "]", ":", "get_open_folders", "(", ")", "model", ".", "clear", "@root_iter", "=", "add_file", "(", "@root", ",", "nil", ")", "open_folders", "(", "[", "@root_iter", "[", ":path", "]", "]", ")", "open_folders", "(", "open_folders", ")", "end" ]

[ "FileTreeView", "creates", "a", "TreeView", "of", "files", "with", "folders", "and", "icons", ".", "Often", "you", "should", "subclass", "this", "class", "for", "a", "particular", "use", "." ]

[ "def", "open_folders", "(", "folder_paths", ")", "model", ".", "each", "do", "|", "model", ",", "path", ",", "iter", "|", "if", "folder_paths", ".", "include?", "(", "iter", "[", "id", "(", ":path", ")", "]", ")", "fill_folder", "(", "iter", ")", "# expand_row(path, false)", "# self__row_expanded(self, iter, path) \r", "end", "end", "end" ]

[ "Opens", "a", "list", "of", "folders", "." ]

[ "def", "add_file", "(", "filename", ",", "parent", "=", "@root_iter", ")", "my_path", "=", "File", ".", "dirname", "(", "filename", ")", "model", ".", "each", "do", "|", "model", ",", "path", ",", "iter", "|", "return", "if", "iter", "[", "id", "(", ":path", ")", "]", "==", "filename", "# duplicate", "parent", "=", "iter", "if", "iter", "[", "id", "(", ":path", ")", "]", "==", "my_path", "end", "fn", "=", "filename", ".", "gsub", "(", "\"\\\\\"", ",", "\"/\"", ")", "parent", "[", "id", "(", ":empty", ")", "]", "=", "false", "unless", "parent", ".", "nil?", "child", "=", "add_row", "(", "parent", ")", "child", "[", ":pix", "]", "=", "@icons", ".", "get_icon", "(", "File", ".", "directory?", "(", "fn", ")", "?", "\"x.folder\"", ":", "fn", ")", "if", "@icons", "child", "[", ":file_name", "]", "=", "File", ".", "basename", "(", "fn", ")", "child", "[", ":path", "]", "=", "fn", "if", "File", ".", "directory?", "(", "fn", ")", "child", "[", ":sort_on", "]", "=", "\"0\"", "+", "child", "[", ":file_name", "]", "child", "[", ":empty", "]", "=", "true", "add_row", "(", "child", ")", "# dummy record so expander appears \r", "else", "child", "[", "id", "(", ":sort_on", ")", "]", "=", "\"1\"", "+", "child", "[", "id", "(", ":file_name", ")", "]", "end", "return", "child", "end" ]

[ "Adds", "a", "file", "to", "the", "tree", "under", "a", "given", "parent", "iter", "." ]

[ "def", "generate", "(", "params", "=", "{", "}", ")", "params", "=", "{", ":type", "=>", "random_gender", ",", ":frequency", "=>", ":common", ",", ":with_surname", "=>", "true", "}", ".", "merge", "(", "params", ")", "if", "!", "(", "params", "[", ":min_freq", "]", "||", "params", "[", ":max_freq", "]", ")", "params", "[", ":min_freq", "]", ",", "params", "[", ":max_freq", "]", "=", "frequency_values", "(", "params", "[", ":frequency", "]", ")", "else", "#", "# do some basic data validation in case someone is being a knucklehead", "#", "params", "[", ":min_freq", "]", "=", "params", "[", ":min_freq", "]", ".", "to_i", "params", "[", ":max_freq", "]", "=", "params", "[", ":max_freq", "]", ".", "to_i", "params", "[", ":max_freq", "]", "=", "params", "[", ":min_freq", "]", "+", "1", "if", "params", "[", ":max_freq", "]", "<=", "params", "[", ":min_freq", "]", "# max_freq needs to be at least 4 to get any results back,", "# because the most common male name only rates 3.3", "# JAMES 3.318 3.318 1", "params", "[", ":max_freq", "]", "=", "4", "if", "params", "[", ":max_freq", "]", "<", "4", "end", "name", "=", "get_name", "(", "params", "[", ":type", "]", ",", "params", "[", ":min_freq", "]", ",", "params", "[", ":max_freq", "]", ")", "# add surname if needed", "if", "params", "[", ":type", "]", "!=", ":surname", "&&", "params", "[", ":with_surname", "]", "==", "true", "name", "=", "\"#{name} #{get_name(:surname, params[:min_freq], params[:max_freq])}\"", "end", "name", "end" ]

[ "generate", "a", "name", "using", "the", "supplied", "parameter", "hash" ]

[ "def", "random_sort", "(", "set", ")", "set", ".", "order", "do", "# this is a bit of a hack obviously, but it checks the sort of", "# data engine being used to figure out how to randomly sort", "if", "set", ".", "class", ".", "name", "!~", "/", "/i", "random", ".", "function", "else", "rand", ".", "function", "end", "end", "end" ]

[ "randomly", "sort", "a", "result", "set", "according", "to", "the", "data", "adapter", "class" ]

[ "def", "get_name", "(", "src", ",", "min_freq", "=", "0", ",", "max_freq", "=", "100", ")", "tmp", "=", "random_sort", "(", "@db", "[", "src", ".", "to_sym", "]", ".", "filter", "{", "(", "freq", ">=", "min_freq", ")", "&", "(", "freq", "<=", "max_freq", ")", "}", ")", "tmp", ".", "count", ">", "0", "?", "tmp", ".", "first", "[", ":name", "]", ":", "nil", "end" ]

[ "query", "the", "db", "for", "a", "name" ]

[ "def", "top", "(", "options", "=", "{", "}", ",", "&", "block", ")", "params", "=", "{", "}", "if", "options", "[", ":game", "]", "params", "[", ":game", "]", "=", "options", "[", ":game", "]", "end", "period", "=", "options", "[", ":period", "]", "||", ":week", "if", "!", "[", ":week", ",", ":month", ",", ":all", "]", ".", "include?", "(", "period", ")", "raise", "ArgumentError", ",", "'period'", "end", "params", "[", ":period", "]", "=", "period", ".", "to_s", "return", "@query", ".", "connection", ".", "accumulate", "(", ":path", "=>", "'videos/top'", ",", ":params", "=>", "params", ",", ":json", "=>", "'videos'", ",", ":create", "=>", "->", "hash", "{", "Video", ".", "new", "(", "hash", ",", "@query", ")", "}", ",", ":limit", "=>", "options", "[", ":limit", "]", ",", ":offset", "=>", "options", "[", ":offset", "]", ",", "block", ")", "end" ]

[ "Get", "the", "list", "of", "most", "popular", "videos", "based", "on", "view", "count", "." ]

[ "def", "for_channel", "(", "channel", ",", "options", "=", "{", "}", ")", "if", "channel", ".", "respond_to?", "(", ":name", ")", "channel_name", "=", "channel", ".", "name", "else", "channel_name", "=", "channel", ".", "to_s", "end", "params", "=", "{", "}", "type", "=", "options", "[", ":type", "]", "||", ":highlights", "if", "!", "type", ".", "nil?", "if", "!", "[", ":broadcasts", ",", ":highlights", "]", ".", "include?", "(", "type", ")", "raise", "ArgumentError", ",", "'type'", "end", "params", "[", ":broadcasts", "]", "=", "(", "type", "==", ":broadcasts", ")", "end", "name", "=", "CGI", ".", "escape", "(", "channel_name", ")", "return", "@query", ".", "connection", ".", "accumulate", "(", ":path", "=>", "\"channels/#{name}/videos\"", ",", ":params", "=>", "params", ",", ":json", "=>", "'videos'", ",", ":create", "=>", "->", "hash", "{", "Video", ".", "new", "(", "hash", ",", "@query", ")", "}", ",", ":limit", "=>", "options", "[", ":limit", "]", ",", ":offset", "=>", "options", "[", ":offset", "]", ")", "end" ]

[ "Get", "the", "videos", "for", "a", "channel", "most", "recently", "created", "first", "." ]

[ "def", "following", "(", "options", "=", "{", "}", ",", "&", "block", ")", "name", "=", "CGI", ".", "escape", "(", "@name", ")", "return", "@query", ".", "connection", ".", "accumulate", "(", ":path", "=>", "\"users/#{name}/follows/channels\"", ",", ":json", "=>", "'follows'", ",", ":sub_json", "=>", "'channel'", ",", ":create", "=>", "->", "hash", "{", "Channel", ".", "new", "(", "hash", ",", "@query", ")", "}", ",", ":limit", "=>", "options", "[", ":limit", "]", ",", ":offset", "=>", "options", "[", ":offset", "]", ",", "block", ")", "end" ]

[ "Get", "the", "channels", "the", "user", "is", "currently", "following", "." ]

[ "def", "load_fixtures", "(", "resource", ",", "file", ")", "if", "block_given?", "Dir", ".", "mktmpdir", "(", "\"rspec-puppet-augeas\"", ")", "do", "|", "dir", "|", "prepare_fixtures", "(", "dir", ",", "resource", ",", "file", ")", "yield", "dir", "end", "else", "dir", "=", "Dir", ".", "mktmpdir", "(", "\"rspec-puppet-augeas\"", ")", "prepare_fixtures", "(", "dir", ",", "resource", ",", "file", ")", "dir", "end", "end" ]

[ "Copies", "test", "fixtures", "to", "a", "temporary", "directory", "If", "file", "is", "nil", "copies", "the", "entire", "augeas_fixtures", "directory", "If", "file", "is", "a", "hash", "it", "copies", "the", "value", "from", "augeas_fixtures", "to", "each", "key", "path" ]

[ "def", "apply", "(", "resource", ",", "logs", ")", "logs", ".", "clear", "Puppet", "::", "Util", "::", "Log", ".", "newdestination", "(", "Puppet", "::", "Test", "::", "LogCollector", ".", "new", "(", "logs", ")", ")", "Puppet", "::", "Util", "::", "Log", ".", "level", "=", "'debug'", "confdir", "=", "Dir", ".", "mktmpdir", "oldconfdir", "=", "Puppet", "[", ":confdir", "]", "Puppet", "[", ":confdir", "]", "=", "confdir", "[", ":require", ",", ":before", ",", ":notify", ",", ":subscribe", "]", ".", "each", "{", "|", "p", "|", "resource", ".", "delete", "p", "}", "catalog", "=", "Puppet", "::", "Resource", "::", "Catalog", ".", "new", "catalog", ".", "add_resource", "resource", "catalog", "=", "catalog", ".", "to_ral", "if", "resource", ".", "is_a?", "Puppet", "::", "Resource", "txn", "=", "catalog", ".", "apply", "Puppet", "::", "Util", "::", "Log", ".", "close_all", "txn", "ensure", "if", "confdir", "Puppet", "[", ":confdir", "]", "=", "oldconfdir", "FileUtils", ".", "rm_rf", "(", "confdir", ")", "end", "end" ]

[ "Runs", "a", "particular", "resource", "via", "a", "catalog", "and", "stores", "logs", "in", "the", "caller", "s", "supplied", "array" ]

[ "def", "followers", "(", "options", "=", "{", "}", ",", "&", "block", ")", "name", "=", "CGI", ".", "escape", "(", "@name", ")", "return", "@query", ".", "connection", ".", "accumulate", "(", ":path", "=>", "\"channels/#{name}/follows\"", ",", ":json", "=>", "'follows'", ",", ":sub_json", "=>", "'user'", ",", ":create", "=>", "->", "hash", "{", "User", ".", "new", "(", "hash", ",", "@query", ")", "}", ",", ":limit", "=>", "options", "[", ":limit", "]", ",", ":offset", "=>", "options", "[", ":offset", "]", ",", "block", ")", "end" ]

[ "Get", "the", "users", "following", "this", "channel", "." ]

[ "def", "find", "(", "options", ")", "raise", "ArgumentError", ",", "'options'", "if", "options", ".", "nil?", "raise", "ArgumentError", ",", "'name'", "if", "options", "[", ":name", "]", ".", "nil?", "params", "=", "{", ":query", "=>", "options", "[", ":name", "]", ",", ":type", "=>", "'suggest'", "}", "if", "options", "[", ":live", "]", "params", ".", "merge!", "(", ":live", "=>", "true", ")", "end", "return", "@query", ".", "connection", ".", "accumulate", "(", ":path", "=>", "'search/games'", ",", ":params", "=>", "params", ",", ":json", "=>", "'games'", ",", ":create", "=>", "GameSuggestion", ",", ":limit", "=>", "options", "[", ":limit", "]", ")", "end" ]

[ "Get", "a", "list", "of", "games", "with", "names", "similar", "to", "the", "specified", "name", "." ]

[ "def", "idempotent", "@logs_idempotent", "=", "[", "]", "root", "=", "load_fixtures", "(", "resource", ",", "{", "\".\"", "=>", "\"#{@root}/.\"", "}", ")", "oldroot", "=", "resource", "[", ":root", "]", "resource", "[", ":root", "]", "=", "root", "@txn_idempotent", "=", "apply", "(", "resource", ",", "@logs_idempotent", ")", "FileUtils", ".", "rm_r", "root", "resource", "[", ":root", "]", "=", "oldroot", "@txn_idempotent", "end" ]

[ "Run", "the", "resource", "a", "second", "time", "against", "the", "output", "dir", "from", "the", "first" ]

[ "def", "all", "(", "options", "=", "{", "}", ",", "&", "block", ")", "return", "@query", ".", "connection", ".", "accumulate", "(", ":path", "=>", "'streams'", ",", ":json", "=>", "'streams'", ",", ":create", "=>", "->", "hash", "{", "Stream", ".", "new", "(", "hash", ",", "@query", ")", "}", ",", ":limit", "=>", "options", "[", ":limit", "]", ",", ":offset", "=>", "options", "[", ":offset", "]", ",", "block", ")", "end" ]

[ "Get", "all", "currently", "live", "streams", "sorted", "by", "descending", "viewer", "count", "." ]

[ "def", "find", "(", "options", ",", "&", "block", ")", "check", "=", "options", ".", "dup", "check", ".", "delete", "(", ":limit", ")", "check", ".", "delete", "(", ":offset", ")", "raise", "ArgumentError", ",", "'options'", "if", "check", ".", "empty?", "params", "=", "{", "}", "channels", "=", "options", "[", ":channel", "]", "if", "channels", "if", "!", "channels", ".", "respond_to?", "(", ":map", ")", "raise", "ArgumentError", ",", "':channel'", "end", "params", "[", ":channel", "]", "=", "channels", ".", "map", "{", "|", "channel", "|", "if", "channel", ".", "respond_to?", "(", ":name", ")", "channel", ".", "name", "else", "channel", ".", "to_s", "end", "}", ".", "join", "(", "','", ")", "end", "game", "=", "options", "[", ":game", "]", "if", "game", "if", "game", ".", "respond_to?", "(", ":name", ")", "params", "[", ":game", "]", "=", "game", ".", "name", "else", "params", "[", ":game", "]", "=", "game", ".", "to_s", "end", "end", "if", "options", "[", ":hls", "]", "params", "[", ":hls", "]", "=", "true", "end", "if", "options", "[", ":embeddable", "]", "params", "[", ":embeddable", "]", "=", "true", "end", "return", "@query", ".", "connection", ".", "accumulate", "(", ":path", "=>", "'streams'", ",", ":params", "=>", "params", ",", ":json", "=>", "'streams'", ",", ":create", "=>", "->", "hash", "{", "Stream", ".", "new", "(", "hash", ",", "@query", ")", "}", ",", ":limit", "=>", "options", "[", ":limit", "]", ",", ":offset", "=>", "options", "[", ":offset", "]", ",", "block", ")", "end" ]

[ "Get", "streams", "for", "a", "specific", "game", "for", "a", "set", "of", "channels", "or", "by", "other", "criteria", "sorted", "by", "descending", "viewer", "count", "." ]

[ "def", "apk_file", "build_path", "=", "Souyuz", ".", "project", ".", "options", "[", ":output_path", "]", "assembly_name", "=", "Souyuz", ".", "project", ".", "options", "[", ":assembly_name", "]", "Souyuz", ".", "cache", "[", ":build_apk_path", "]", "=", "\"#{build_path}/#{assembly_name}.apk\"", "\"#{build_path}/#{assembly_name}.apk\"", "end" ]

[ "android", "build", "stuff", "to", "follow", ".." ]

[ "def", "package_path", "build_path", "=", "Souyuz", ".", "project", ".", "options", "[", ":output_path", "]", "assembly_name", "=", "Souyuz", ".", "project", ".", "options", "[", ":assembly_name", "]", "# in the upcomming switch we determin the output path of iOS ipa files", "# those change in the Xamarin.iOS Cycle 9 release", "# see https://developer.xamarin.com/releases/ios/xamarin.ios_10/xamarin.ios_10.4/", "if", "File", ".", "exist?", "\"#{build_path}/#{assembly_name}.ipa\"", "# after Xamarin.iOS Cycle 9", "package_path", "=", "build_path", "else", "# before Xamarin.iOS Cycle 9", "package_path", "=", "Dir", ".", "glob", "(", "\"#{build_path}/#{assembly_name} *\"", ")", ".", "sort", ".", "last", "end", "package_path", "end" ]

[ "ios", "build", "stuff", "to", "follow", ".." ]

[ "def", "attr_configurable_single", "*", "args", ",", "&", "block", "trans", "=", "attr_configurable_wrap", "lambda", "{", "|", "v", "|", "v", ".", "is_a?", "(", "Array", ")", "?", "v", ".", "first", ":", "v", "}", ",", "block", "attr_configurable", "(", "args", ",", "trans", ")", "end" ]

[ "Creates", "a", "group", "readable", "and", "writeable", "attributes", "that", "can", "be", "set", "by", "a", "URI", "query", "parameter", "sharing", "the", "same", "name", "a", "property", "of", "a", "URI", "or", "a", "default", "value", ".", "The", "value", "of", "this", "attribute", "will", "be", "transformed", "by", "invoking", "the", "given", "block", "if", "one", "has", "been", "provided", ".", "If", "the", "attributes", "created", "by", "this", "method", "are", "assigned", "an", "Array", "only", "the", "first", "element", "will", "be", "used", "as", "their", "value", "." ]

[ "def", "attr_configurable_arr", "*", "args", ",", "&", "block", "trans", "=", "attr_configurable_wrap", "lambda", "{", "|", "v", "|", "Array", "(", "v", ")", "}", ",", "block", "attr_configurable", "(", "args", ",", "trans", ")", "end" ]

[ "Creates", "a", "group", "readable", "and", "writeable", "attributes", "that", "can", "be", "set", "by", "a", "URI", "query", "parameter", "sharing", "the", "same", "name", "a", "property", "of", "a", "URI", "or", "a", "default", "value", ".", "The", "value", "of", "this", "attribute", "will", "be", "transformed", "by", "invoking", "the", "given", "block", "if", "one", "has", "been", "provided", ".", "If", "the", "attributes", "created", "by", "this", "method", "are", "assigned", "a", "value", "that", "is", "not", "an", "Array", "the", "value", "will", "be", "wrapped", "in", "an", "array", "." ]

[ "def", "attr_configurable_int", "*", "args", ",", "&", "block", "trans", "=", "attr_configurable_wrap", "lambda", "{", "|", "v", "|", "v", ".", "to_i", "}", ",", "block", "attr_configurable_single", "(", "args", ",", "trans", ")", "end" ]

[ "Creates", "readable", "and", "writeable", "attributes", "that", "are", "automatically", "converted", "into", "integers", "." ]

[ "def", "method_missing", "(", "method", ",", "*", "args", ",", "&", "block", ")", "# Check string keys first, original and downcase", "string_method", "=", "method", ".", "to_s", "if", "raw_hash", ".", "key?", "(", "string_method", ")", "return", "self", "[", "string_method", "]", "elsif", "raw_hash", ".", "key?", "(", "string_method", ".", "downcase", ")", "return", "self", "[", "string_method", ".", "downcase", "]", "end", "if", "string_method", "=~", "/", "/", "string_method", "=", "string_method", ".", "snakecase", "end", "index", "=", "string_method", ".", "downcase", ".", "to_sym", "# Check symbol key and return local hash entry.", "return", "self", "[", "index", "]", "if", "raw_hash", ".", "has_key?", "(", "index", ")", "# Then delegate to hash object.", "if", "raw_hash", ".", "respond_to?", "(", "method", ")", "return", "raw_hash", ".", "send", "(", "method", ",", "args", ")", "end", "# Finally return nil.", "nil", "end" ]

[ "Allows", "method", "-", "like", "access", "to", "the", "hash", "using", "camelcase", "field", "names", "." ]

[ "def", "blocks", "RelationProxy", ".", "new", "(", "self", ",", "Block", ",", "[", "Operations", "::", "Create", ",", "Operations", "::", "List", ",", "Operations", "::", "Delete", "]", ")", "do", "def", "from_response", "(", "response", ",", "client", ")", "response", "[", "'url'", "]", "||=", "\"#{base.url}#{resource_type.url}/#{response['user_id']}\"", "super", "end", "def", "create", "(", "attributes", ",", "client", "=", "self", ".", "client", ")", "response", "=", "client", ".", "post", "(", "url", ",", "attributes", ")", "from_response", "(", "{", "'user_id'", "=>", "attributes", "[", "'user_id'", "]", "}", ",", "client", ")", "end", "end", "end" ]

[ "Returns", "the", "users", "blocked", "by", "this", "user" ]

[ "def", "identity", "SingletonRelationProxy", ".", "new", "(", "self", ",", "Layer", "::", "Identity", ")", "do", "def", "from_response", "(", "response", ",", "client", ")", "response", "[", "'url'", "]", "||=", "\"#{base.url}#{resource_type.url}\"", "super", "end", "def", "create", "(", "attributes", ",", "client", "=", "self", ".", "client", ")", "client", ".", "post", "(", "url", ",", "attributes", ")", "fetch", "end", "def", "delete", "(", "client", "=", "self", ".", "client", ")", "client", ".", "delete", "(", "url", ")", "end", "end", "end" ]

[ "Returns", "the", "identity", "object", "for", "this", "user" ]

[ "def", "messages", "RelationProxy", ".", "new", "(", "self", ",", "Message", ",", "[", "Operations", "::", "Create", ",", "Operations", "::", "Paginate", ",", "Operations", "::", "Find", ",", "Operations", "::", "Delete", ",", "Operations", "::", "Destroy", "]", ")", "end" ]

[ "Returns", "the", "conversations", "messages" ]