Datasets:

---

semeru

/

code-text-ruby

like 4

Follow

Semeru Lab 8

[ "def", "valid?", "(", "context", "=", "nil", ")", "current_context", ",", "self", ".", "validation_context", "=", "validation_context", ",", "context", "errors", ".", "clear", "run_validations!", "ensure", "self", ".", "validation_context", "=", "current_context", "end" ]

[ "Runs", "all", "the", "specified", "validations", "and", "returns", "+", "true", "+", "if", "no", "errors", "were", "added", "otherwise", "+", "false", "+", "." ]

[ "def", "message_verifier", "(", "verifier_name", ")", "@message_verifiers", "[", "verifier_name", "]", "||=", "begin", "secret", "=", "key_generator", ".", "generate_key", "(", "verifier_name", ".", "to_s", ")", "ActiveSupport", "::", "MessageVerifier", ".", "new", "(", "secret", ")", "end", "end" ]

[ "Returns", "a", "message", "verifier", "object", "." ]

[ "def", "env_config", "@app_env_config", "||=", "begin", "super", ".", "merge", "(", "\"action_dispatch.parameter_filter\"", "=>", "config", ".", "filter_parameters", ",", "\"action_dispatch.redirect_filter\"", "=>", "config", ".", "filter_redirect", ",", "\"action_dispatch.secret_key_base\"", "=>", "secret_key_base", ",", "\"action_dispatch.show_exceptions\"", "=>", "config", ".", "action_dispatch", ".", "show_exceptions", ",", "\"action_dispatch.show_detailed_exceptions\"", "=>", "config", ".", "consider_all_requests_local", ",", "\"action_dispatch.logger\"", "=>", "Rails", ".", "logger", ",", "\"action_dispatch.backtrace_cleaner\"", "=>", "Rails", ".", "backtrace_cleaner", ",", "\"action_dispatch.key_generator\"", "=>", "key_generator", ",", "\"action_dispatch.http_auth_salt\"", "=>", "config", ".", "action_dispatch", ".", "http_auth_salt", ",", "\"action_dispatch.signed_cookie_salt\"", "=>", "config", ".", "action_dispatch", ".", "signed_cookie_salt", ",", "\"action_dispatch.encrypted_cookie_salt\"", "=>", "config", ".", "action_dispatch", ".", "encrypted_cookie_salt", ",", "\"action_dispatch.encrypted_signed_cookie_salt\"", "=>", "config", ".", "action_dispatch", ".", "encrypted_signed_cookie_salt", ",", "\"action_dispatch.authenticated_encrypted_cookie_salt\"", "=>", "config", ".", "action_dispatch", ".", "authenticated_encrypted_cookie_salt", ",", "\"action_dispatch.use_authenticated_cookie_encryption\"", "=>", "config", ".", "action_dispatch", ".", "use_authenticated_cookie_encryption", ",", "\"action_dispatch.encrypted_cookie_cipher\"", "=>", "config", ".", "action_dispatch", ".", "encrypted_cookie_cipher", ",", "\"action_dispatch.signed_cookie_digest\"", "=>", "config", ".", "action_dispatch", ".", "signed_cookie_digest", ",", "\"action_dispatch.cookies_serializer\"", "=>", "config", ".", "action_dispatch", ".", "cookies_serializer", ",", "\"action_dispatch.cookies_digest\"", "=>", "config", ".", "action_dispatch", ".", "cookies_digest", ",", "\"action_dispatch.cookies_rotations\"", "=>", "config", ".", "action_dispatch", ".", "cookies_rotations", ",", "\"action_dispatch.use_cookies_with_metadata\"", "=>", "config", ".", "action_dispatch", ".", "use_cookies_with_metadata", ",", "\"action_dispatch.content_security_policy\"", "=>", "config", ".", "content_security_policy", ",", "\"action_dispatch.content_security_policy_report_only\"", "=>", "config", ".", "content_security_policy_report_only", ",", "\"action_dispatch.content_security_policy_nonce_generator\"", "=>", "config", ".", "content_security_policy_nonce_generator", ")", "end", "end" ]

[ "Stores", "some", "of", "the", "Rails", "initial", "environment", "parameters", "which", "will", "be", "used", "by", "middlewares", "and", "engines", "to", "configure", "themselves", "." ]

[ "def", "encrypted", "(", "path", ",", "key_path", ":", "\"config/master.key\"", ",", "env_key", ":", "\"RAILS_MASTER_KEY\"", ")", "ActiveSupport", "::", "EncryptedConfiguration", ".", "new", "(", "config_path", ":", "Rails", ".", "root", ".", "join", "(", "path", ")", ",", "key_path", ":", "Rails", ".", "root", ".", "join", "(", "key_path", ")", ",", "env_key", ":", "env_key", ",", "raise_if_missing_key", ":", "config", ".", "require_master_key", ")", "end" ]

[ "Shorthand", "to", "decrypt", "any", "encrypted", "configurations", "or", "files", "." ]

[ "def", "ordered_railties", "#:nodoc:", "@ordered_railties", "||=", "begin", "order", "=", "config", ".", "railties_order", ".", "map", "do", "|", "railtie", "|", "if", "railtie", "==", ":main_app", "self", "elsif", "railtie", ".", "respond_to?", "(", ":instance", ")", "railtie", ".", "instance", "else", "railtie", "end", "end", "all", "=", "(", "railties", "-", "order", ")", "all", ".", "push", "(", "self", ")", "unless", "(", "all", "+", "order", ")", ".", "include?", "(", "self", ")", "order", ".", "push", "(", ":all", ")", "unless", "order", ".", "include?", "(", ":all", ")", "index", "=", "order", ".", "index", "(", ":all", ")", "order", "[", "index", "]", "=", "all", "order", "end", "end" ]

[ "Returns", "the", "ordered", "railties", "for", "this", "application", "considering", "railties_order", "." ]

[ "def", "raw_post", "unless", "has_header?", "\"RAW_POST_DATA\"", "raw_post_body", "=", "body", "set_header", "(", "\"RAW_POST_DATA\"", ",", "raw_post_body", ".", "read", "(", "content_length", ")", ")", "raw_post_body", ".", "rewind", "if", "raw_post_body", ".", "respond_to?", "(", ":rewind", ")", "end", "get_header", "\"RAW_POST_DATA\"", "end" ]

[ "Read", "the", "request", "\\", "body", ".", "This", "is", "useful", "for", "web", "services", "that", "need", "to", "work", "with", "raw", "requests", "directly", "." ]

[ "def", "body", "if", "raw_post", "=", "get_header", "(", "\"RAW_POST_DATA\"", ")", "raw_post", "=", "raw_post", ".", "dup", ".", "force_encoding", "(", "Encoding", "::", "BINARY", ")", "StringIO", ".", "new", "(", "raw_post", ")", "else", "body_stream", "end", "end" ]

[ "The", "request", "body", "is", "an", "IO", "input", "stream", ".", "If", "the", "RAW_POST_DATA", "environment", "variable", "is", "already", "set", "wrap", "it", "in", "a", "StringIO", "." ]

[ "def", "GET", "fetch_header", "(", "\"action_dispatch.request.query_parameters\"", ")", "do", "|", "k", "|", "rack_query_params", "=", "super", "||", "{", "}", "# Check for non UTF-8 parameter values, which would cause errors later", "Request", "::", "Utils", ".", "check_param_encoding", "(", "rack_query_params", ")", "set_header", "k", ",", "Request", "::", "Utils", ".", "normalize_encode_params", "(", "rack_query_params", ")", "end", "rescue", "Rack", "::", "Utils", "::", "ParameterTypeError", ",", "Rack", "::", "Utils", "::", "InvalidParameterError", "=>", "e", "raise", "ActionController", "::", "BadRequest", ".", "new", "(", "\"Invalid query parameters: #{e.message}\"", ")", "end" ]

[ "Override", "Rack", "s", "GET", "method", "to", "support", "indifferent", "access", "." ]

[ "def", "POST", "fetch_header", "(", "\"action_dispatch.request.request_parameters\"", ")", "do", "pr", "=", "parse_formatted_parameters", "(", "params_parsers", ")", "do", "|", "params", "|", "super", "||", "{", "}", "end", "self", ".", "request_parameters", "=", "Request", "::", "Utils", ".", "normalize_encode_params", "(", "pr", ")", "end", "rescue", "Rack", "::", "Utils", "::", "ParameterTypeError", ",", "Rack", "::", "Utils", "::", "InvalidParameterError", "=>", "e", "raise", "ActionController", "::", "BadRequest", ".", "new", "(", "\"Invalid request parameters: #{e.message}\"", ")", "end" ]

[ "Override", "Rack", "s", "POST", "method", "to", "support", "indifferent", "access", "." ]

[ "def", "setup", "(", "context", ",", "options", ",", "as", ",", "block", ")", "@options", "=", "options", "@block", "=", "block", "@locals", "=", "options", "[", ":locals", "]", "||", "{", "}", "@details", "=", "extract_details", "(", "options", ")", "partial", "=", "options", "[", ":partial", "]", "if", "String", "===", "partial", "@has_object", "=", "options", ".", "key?", "(", ":object", ")", "@object", "=", "options", "[", ":object", "]", "@collection", "=", "collection_from_options", "@path", "=", "partial", "else", "@has_object", "=", "true", "@object", "=", "partial", "@collection", "=", "collection_from_object", "||", "collection_from_options", "if", "@collection", "paths", "=", "@collection_data", "=", "@collection", ".", "map", "{", "|", "o", "|", "partial_path", "(", "o", ",", "context", ")", "}", "if", "paths", ".", "uniq", ".", "length", "==", "1", "@path", "=", "paths", ".", "first", "else", "paths", ".", "map!", "{", "|", "path", "|", "retrieve_variable", "(", "path", ",", "as", ")", ".", "unshift", "(", "path", ")", "}", "@path", "=", "nil", "end", "else", "@path", "=", "partial_path", "(", "@object", ",", "context", ")", "end", "end", "self", "end" ]

[ "Sets", "up", "instance", "variables", "needed", "for", "rendering", "a", "partial", ".", "This", "method", "finds", "the", "options", "and", "details", "and", "extracts", "them", ".", "The", "method", "also", "contains", "logic", "that", "handles", "the", "type", "of", "object", "passed", "in", "as", "the", "partial", "." ]

[ "def", "partial_path", "(", "object", ",", "view", ")", "object", "=", "object", ".", "to_model", "if", "object", ".", "respond_to?", "(", ":to_model", ")", "path", "=", "if", "object", ".", "respond_to?", "(", ":to_partial_path", ")", "object", ".", "to_partial_path", "else", "raise", "ArgumentError", ".", "new", "(", "\"'#{object.inspect}' is not an ActiveModel-compatible object. It must implement :to_partial_path.\"", ")", "end", "if", "view", ".", "prefix_partial_path_with_controller_namespace", "prefixed_partial_names", "[", "path", "]", "||=", "merge_prefix_into_object_path", "(", "@context_prefix", ",", "path", ".", "dup", ")", "else", "path", "end", "end" ]

[ "Obtains", "the", "path", "to", "where", "the", "object", "s", "partial", "is", "located", ".", "If", "the", "object", "responds", "to", "+", "to_partial_path", "+", "then", "+", "to_partial_path", "+", "will", "be", "called", "and", "will", "provide", "the", "path", ".", "If", "the", "object", "does", "not", "respond", "to", "+", "to_partial_path", "+", "then", "an", "+", "ArgumentError", "+", "is", "raised", "." ]

[ "def", "serializable_hash", "(", "options", "=", "nil", ")", "options", "||=", "{", "}", "attribute_names", "=", "attributes", ".", "keys", "if", "only", "=", "options", "[", ":only", "]", "attribute_names", "&=", "Array", "(", "only", ")", ".", "map", "(", ":to_s", ")", "elsif", "except", "=", "options", "[", ":except", "]", "attribute_names", "-=", "Array", "(", "except", ")", ".", "map", "(", ":to_s", ")", "end", "hash", "=", "{", "}", "attribute_names", ".", "each", "{", "|", "n", "|", "hash", "[", "n", "]", "=", "read_attribute_for_serialization", "(", "n", ")", "}", "Array", "(", "options", "[", ":methods", "]", ")", ".", "each", "{", "|", "m", "|", "hash", "[", "m", ".", "to_s", "]", "=", "send", "(", "m", ")", "}", "serializable_add_includes", "(", "options", ")", "do", "|", "association", ",", "records", ",", "opts", "|", "hash", "[", "association", ".", "to_s", "]", "=", "if", "records", ".", "respond_to?", "(", ":to_ary", ")", "records", ".", "to_ary", ".", "map", "{", "|", "a", "|", "a", ".", "serializable_hash", "(", "opts", ")", "}", "else", "records", ".", "serializable_hash", "(", "opts", ")", "end", "end", "hash", "end" ]

[ "Returns", "a", "serialized", "hash", "of", "your", "object", "." ]

[ "def", "helpers", "@helpers", "||=", "begin", "helpers", "=", "Module", ".", "new", "all", "=", "ActionController", "::", "Base", ".", "all_helpers_from_path", "(", "helpers_paths", ")", "ActionController", "::", "Base", ".", "modules_for_helpers", "(", "all", ")", ".", "each", "do", "|", "mod", "|", "helpers", ".", "include", "(", "mod", ")", "end", "helpers", "end", "end" ]

[ "Returns", "a", "module", "with", "all", "the", "helpers", "defined", "for", "the", "engine", "." ]

[ "def", "app", "@app", "||", "@app_build_lock", ".", "synchronize", "{", "@app", "||=", "begin", "stack", "=", "default_middleware_stack", "config", ".", "middleware", "=", "build_middleware", ".", "merge_into", "(", "stack", ")", "config", ".", "middleware", ".", "build", "(", "endpoint", ")", "end", "}", "end" ]

[ "Returns", "the", "underlying", "Rack", "application", "for", "this", "engine", "." ]

[ "def", "routes", "(", "&", "block", ")", "@routes", "||=", "ActionDispatch", "::", "Routing", "::", "RouteSet", ".", "new_with_config", "(", "config", ")", "@routes", ".", "append", "(", "block", ")", "if", "block_given?", "@routes", "end" ]

[ "Defines", "the", "routes", "for", "this", "engine", ".", "If", "a", "block", "is", "given", "to", "routes", "it", "is", "appended", "to", "the", "engine", "." ]

[ "def", "attach", "(", "attachable", ")", "if", "record", ".", "persisted?", "&&", "!", "record", ".", "changed?", "record", ".", "update", "(", "name", "=>", "attachable", ")", "else", "record", ".", "public_send", "(", "\"#{name}=\"", ",", "attachable", ")", "end", "end" ]

[ "Attaches", "an", "+", "attachable", "+", "to", "the", "record", "." ]

[ "def", "stream", "(", "key", ")", "file", "=", "file_for", "(", "key", ",", "skip_lookup", ":", "false", ")", "chunk_size", "=", "5", ".", "megabytes", "offset", "=", "0", "raise", "ActiveStorage", "::", "FileNotFoundError", "unless", "file", ".", "present?", "while", "offset", "<", "file", ".", "size", "yield", "file", ".", "download", "(", "range", ":", "offset", "..", "(", "offset", "+", "chunk_size", "-", "1", ")", ")", ".", "string", "offset", "+=", "chunk_size", "end", "end" ]

[ "Reads", "the", "file", "for", "the", "given", "key", "in", "chunks", "yielding", "each", "to", "the", "block", "." ]

[ "def", "updated?", "current_watched", "=", "watched", "if", "@last_watched", ".", "size", "!=", "current_watched", ".", "size", "@watched", "=", "current_watched", "true", "else", "current_updated_at", "=", "updated_at", "(", "current_watched", ")", "if", "@last_update_at", "<", "current_updated_at", "@watched", "=", "current_watched", "@updated_at", "=", "current_updated_at", "true", "else", "false", "end", "end", "end" ]

[ "It", "accepts", "two", "parameters", "on", "initialization", ".", "The", "first", "is", "an", "array", "of", "files", "and", "the", "second", "is", "an", "optional", "hash", "of", "directories", ".", "The", "hash", "must", "have", "directories", "as", "keys", "and", "the", "value", "is", "an", "array", "of", "extensions", "to", "be", "watched", "under", "that", "directory", "." ]

[ "def", "max_mtime", "(", "paths", ")", "time_now", "=", "Time", ".", "now", "max_mtime", "=", "nil", "# Time comparisons are performed with #compare_without_coercion because", "# AS redefines these operators in a way that is much slower and does not", "# bring any benefit in this particular code.", "#", "# Read t1.compare_without_coercion(t2) < 0 as t1 < t2.", "paths", ".", "each", "do", "|", "path", "|", "mtime", "=", "File", ".", "mtime", "(", "path", ")", "next", "if", "time_now", ".", "compare_without_coercion", "(", "mtime", ")", "<", "0", "if", "max_mtime", ".", "nil?", "||", "max_mtime", ".", "compare_without_coercion", "(", "mtime", ")", "<", "0", "max_mtime", "=", "mtime", "end", "end", "max_mtime", "end" ]

[ "This", "method", "returns", "the", "maximum", "mtime", "of", "the", "files", "in", "+", "paths", "+", "or", "+", "nil", "+", "if", "the", "array", "is", "empty", "." ]

[ "def", "benchmark", "(", "message", "=", "\"Benchmarking\"", ",", "options", "=", "{", "}", ")", "if", "logger", "options", ".", "assert_valid_keys", "(", ":level", ",", ":silence", ")", "options", "[", ":level", "]", "||=", ":info", "result", "=", "nil", "ms", "=", "Benchmark", ".", "ms", "{", "result", "=", "options", "[", ":silence", "]", "?", "logger", ".", "silence", "{", "yield", "}", ":", "yield", "}", "logger", ".", "send", "(", "options", "[", ":level", "]", ",", "\"%s (%.1fms)\"", "%", "[", "message", ",", "ms", "]", ")", "result", "else", "yield", "end", "end" ]

[ "Allows", "you", "to", "measure", "the", "execution", "time", "of", "a", "block", "in", "a", "template", "and", "records", "the", "result", "to", "the", "log", ".", "Wrap", "this", "block", "around", "expensive", "operations", "or", "possible", "bottlenecks", "to", "get", "a", "time", "reading", "for", "the", "operation", ".", "For", "example", "let", "s", "say", "you", "thought", "your", "file", "processing", "method", "was", "taking", "too", "long", ";", "you", "could", "wrap", "it", "in", "a", "benchmark", "block", "." ]

[ "def", "new", "(", "attributes", "=", "nil", ",", "&", "block", ")", "block", "=", "_deprecated_scope_block", "(", "\"new\"", ",", "block", ")", "scoping", "{", "klass", ".", "new", "(", "attributes", ",", "block", ")", "}", "end" ]

[ "Initializes", "new", "record", "from", "relation", "while", "maintaining", "the", "current", "scope", "." ]

[ "def", "create", "(", "attributes", "=", "nil", ",", "&", "block", ")", "if", "attributes", ".", "is_a?", "(", "Array", ")", "attributes", ".", "collect", "{", "|", "attr", "|", "create", "(", "attr", ",", "block", ")", "}", "else", "block", "=", "_deprecated_scope_block", "(", "\"create\"", ",", "block", ")", "scoping", "{", "klass", ".", "create", "(", "attributes", ",", "block", ")", "}", "end", "end" ]

[ "Tries", "to", "create", "a", "new", "record", "with", "the", "same", "scoped", "attributes", "defined", "in", "the", "relation", ".", "Returns", "the", "initialized", "object", "if", "validation", "fails", "." ]

[ "def", "to_sql", "@to_sql", "||=", "begin", "if", "eager_loading?", "apply_join_dependency", "do", "|", "relation", ",", "join_dependency", "|", "relation", "=", "join_dependency", ".", "apply_column_aliases", "(", "relation", ")", "relation", ".", "to_sql", "end", "else", "conn", "=", "klass", ".", "connection", "conn", ".", "unprepared_statement", "{", "conn", ".", "to_sql", "(", "arel", ")", "}", "end", "end", "end" ]

[ "Returns", "sql", "statement", "for", "the", "relation", "." ]

[ "def", "init_with_attributes", "(", "attributes", ",", "new_record", "=", "false", ")", "# :nodoc:", "@new_record", "=", "new_record", "@attributes", "=", "attributes", "init_internals", "yield", "self", "if", "block_given?", "_run_find_callbacks", "_run_initialize_callbacks", "self", "end" ]

[ "Initialize", "an", "empty", "model", "object", "from", "+", "attributes", "+", ".", "+", "attributes", "+", "should", "be", "an", "attributes", "object", "and", "unlike", "the", "initialize", "method", "no", "assignment", "calls", "are", "made", "per", "attribute", "." ]

[ "def", "inspect", "# We check defined?(@attributes) not to issue warnings if the object is", "# allocated but not initialized.", "inspection", "=", "if", "defined?", "(", "@attributes", ")", "&&", "@attributes", "self", ".", "class", ".", "attribute_names", ".", "collect", "do", "|", "name", "|", "if", "has_attribute?", "(", "name", ")", "attr", "=", "_read_attribute", "(", "name", ")", "value", "=", "if", "attr", ".", "nil?", "attr", ".", "inspect", "else", "attr", "=", "format_for_inspect", "(", "attr", ")", "inspection_filter", ".", "filter_param", "(", "name", ",", "attr", ")", "end", "\"#{name}: #{value}\"", "end", "end", ".", "compact", ".", "join", "(", "\", \"", ")", "else", "\"not initialized\"", "end", "\"#<#{self.class} #{inspection}>\"", "end" ]

[ "Returns", "the", "contents", "of", "the", "record", "as", "a", "nicely", "formatted", "string", "." ]

[ "def", "mail", "(", "headers", "=", "{", "}", ",", "&", "block", ")", "return", "message", "if", "@_mail_was_called", "&&", "headers", ".", "blank?", "&&", "!", "block", "# At the beginning, do not consider class default for content_type", "content_type", "=", "headers", "[", ":content_type", "]", "headers", "=", "apply_defaults", "(", "headers", ")", "# Apply charset at the beginning so all fields are properly quoted", "message", ".", "charset", "=", "charset", "=", "headers", "[", ":charset", "]", "# Set configure delivery behavior", "wrap_delivery_behavior!", "(", "headers", "[", ":delivery_method", "]", ",", "headers", "[", ":delivery_method_options", "]", ")", "assign_headers_to_message", "(", "message", ",", "headers", ")", "# Render the templates and blocks", "responses", "=", "collect_responses", "(", "headers", ",", "block", ")", "@_mail_was_called", "=", "true", "create_parts_from_responses", "(", "message", ",", "responses", ")", "# Setup content type, reapply charset and handle parts order", "message", ".", "content_type", "=", "set_content_type", "(", "message", ",", "content_type", ",", "headers", "[", ":content_type", "]", ")", "message", ".", "charset", "=", "charset", "if", "message", ".", "multipart?", "message", ".", "body", ".", "set_sort_order", "(", "headers", "[", ":parts_order", "]", ")", "message", ".", "body", ".", "sort_parts!", "end", "message", "end" ]

[ "The", "main", "method", "that", "creates", "the", "message", "and", "renders", "the", "email", "templates", ".", "There", "are", "two", "ways", "to", "call", "this", "method", "with", "a", "block", "or", "without", "a", "block", "." ]

[ "def", "attach", "(", "*", "attachables", ")", "if", "record", ".", "persisted?", "&&", "!", "record", ".", "changed?", "record", ".", "update", "(", "name", "=>", "blobs", "+", "attachables", ".", "flatten", ")", "else", "record", ".", "public_send", "(", "\"#{name}=\"", ",", "blobs", "+", "attachables", ".", "flatten", ")", "end", "end" ]

[ "Attaches", "one", "or", "more", "+", "attachables", "+", "to", "the", "record", "." ]

[ "def", "charset", "=", "(", "charset", ")", "content_type", "=", "parsed_content_type_header", ".", "mime_type", "if", "false", "==", "charset", "set_content_type", "content_type", ",", "nil", "else", "set_content_type", "content_type", ",", "charset", "||", "self", ".", "class", ".", "default_charset", "end", "end" ]

[ "Sets", "the", "HTTP", "character", "set", ".", "In", "case", "of", "+", "nil", "+", "parameter", "it", "sets", "the", "charset", "to", "+", "default_charset", "+", "." ]

[ "def", "days_to_week_start", "(", "start_day", "=", "Date", ".", "beginning_of_week", ")", "start_day_number", "=", "DAYS_INTO_WEEK", ".", "fetch", "(", "start_day", ")", "(", "wday", "-", "start_day_number", ")", "%", "7", "end" ]

[ "Returns", "the", "number", "of", "days", "to", "the", "start", "of", "the", "week", "on", "the", "given", "day", ".", "Week", "is", "assumed", "to", "start", "on", "+", "start_day", "+", "default", "is", "+", "Date", ".", "beginning_of_week", "+", "or", "+", "config", ".", "beginning_of_week", "+", "when", "set", "." ]

[ "def", "remote_send", "(", "req", ",", "marshalled", "=", "false", ")", "send_initial_metadata", "GRPC", ".", "logger", ".", "debug", "(", "\"sending #{req}, marshalled? #{marshalled}\"", ")", "payload", "=", "marshalled", "?", "req", ":", "@marshal", ".", "call", "(", "req", ")", "@call", ".", "run_batch", "(", "SEND_MESSAGE", "=>", "payload", ")", "end" ]

[ "remote_send", "sends", "a", "request", "to", "the", "remote", "endpoint", "." ]

[ "def", "send_status", "(", "code", "=", "OK", ",", "details", "=", "''", ",", "assert_finished", "=", "false", ",", "metadata", ":", "{", "}", ")", "send_initial_metadata", "ops", "=", "{", "SEND_STATUS_FROM_SERVER", "=>", "Struct", "::", "Status", ".", "new", "(", "code", ",", "details", ",", "metadata", ")", "}", "ops", "[", "RECV_CLOSE_ON_SERVER", "]", "=", "nil", "if", "assert_finished", "@call", ".", "run_batch", "(", "ops", ")", "set_output_stream_done", "nil", "end" ]

[ "send_status", "sends", "a", "status", "to", "the", "remote", "endpoint", "." ]

[ "def", "remote_read", "ops", "=", "{", "RECV_MESSAGE", "=>", "nil", "}", "ops", "[", "RECV_INITIAL_METADATA", "]", "=", "nil", "unless", "@metadata_received", "batch_result", "=", "@call", ".", "run_batch", "(", "ops", ")", "unless", "@metadata_received", "@call", ".", "metadata", "=", "batch_result", ".", "metadata", "@metadata_received", "=", "true", "end", "get_message_from_batch_result", "(", "batch_result", ")", "end" ]

[ "remote_read", "reads", "a", "response", "from", "the", "remote", "endpoint", "." ]

[ "def", "each_remote_read", "return", "enum_for", "(", ":each_remote_read", ")", "unless", "block_given?", "begin", "loop", "do", "resp", "=", "remote_read", "break", "if", "resp", ".", "nil?", "# the last response was received", "yield", "resp", "end", "ensure", "set_input_stream_done", "end", "end" ]

[ "each_remote_read", "passes", "each", "response", "to", "the", "given", "block", "or", "returns", "an", "enumerator", "the", "responses", "if", "no", "block", "is", "given", ".", "Used", "to", "generate", "the", "request", "enumerable", "for", "server", "-", "side", "client", "-", "streaming", "RPC", "s", "." ]

[ "def", "each_remote_read_then_finish", "return", "enum_for", "(", ":each_remote_read_then_finish", ")", "unless", "block_given?", "loop", "do", "resp", "=", "begin", "remote_read", "rescue", "GRPC", "::", "Core", "::", "CallError", "=>", "e", "GRPC", ".", "logger", ".", "warn", "(", "\"In each_remote_read_then_finish: #{e}\"", ")", "nil", "end", "break", "if", "resp", ".", "nil?", "# the last response was received", "yield", "resp", "end", "receive_and_check_status", "ensure", "set_input_stream_done", "end" ]

[ "each_remote_read_then_finish", "passes", "each", "response", "to", "the", "given", "block", "or", "returns", "an", "enumerator", "of", "the", "responses", "if", "no", "block", "is", "given", "." ]

[ "def", "request_response", "(", "req", ",", "metadata", ":", "{", "}", ")", "raise_error_if_already_executed", "ops", "=", "{", "SEND_MESSAGE", "=>", "@marshal", ".", "call", "(", "req", ")", ",", "SEND_CLOSE_FROM_CLIENT", "=>", "nil", ",", "RECV_INITIAL_METADATA", "=>", "nil", ",", "RECV_MESSAGE", "=>", "nil", ",", "RECV_STATUS_ON_CLIENT", "=>", "nil", "}", "@send_initial_md_mutex", ".", "synchronize", "do", "# Metadata might have already been sent if this is an operation view", "unless", "@metadata_sent", "ops", "[", "SEND_INITIAL_METADATA", "]", "=", "@metadata_to_send", ".", "merge!", "(", "metadata", ")", "end", "@metadata_sent", "=", "true", "end", "begin", "batch_result", "=", "@call", ".", "run_batch", "(", "ops", ")", "# no need to check for cancellation after a CallError because this", "# batch contains a RECV_STATUS op", "ensure", "set_input_stream_done", "set_output_stream_done", "end", "@call", ".", "metadata", "=", "batch_result", ".", "metadata", "attach_status_results_and_complete_call", "(", "batch_result", ")", "get_message_from_batch_result", "(", "batch_result", ")", "end" ]

[ "request_response", "sends", "a", "request", "to", "a", "GRPC", "server", "and", "returns", "the", "response", "." ]

[ "def", "client_streamer", "(", "requests", ",", "metadata", ":", "{", "}", ")", "raise_error_if_already_executed", "begin", "send_initial_metadata", "(", "metadata", ")", "requests", ".", "each", "{", "|", "r", "|", "@call", ".", "run_batch", "(", "SEND_MESSAGE", "=>", "@marshal", ".", "call", "(", "r", ")", ")", "}", "rescue", "GRPC", "::", "Core", "::", "CallError", "=>", "e", "receive_and_check_status", "# check for Cancelled", "raise", "e", "rescue", "=>", "e", "set_input_stream_done", "raise", "e", "ensure", "set_output_stream_done", "end", "batch_result", "=", "@call", ".", "run_batch", "(", "SEND_CLOSE_FROM_CLIENT", "=>", "nil", ",", "RECV_INITIAL_METADATA", "=>", "nil", ",", "RECV_MESSAGE", "=>", "nil", ",", "RECV_STATUS_ON_CLIENT", "=>", "nil", ")", "set_input_stream_done", "@call", ".", "metadata", "=", "batch_result", ".", "metadata", "attach_status_results_and_complete_call", "(", "batch_result", ")", "get_message_from_batch_result", "(", "batch_result", ")", "end" ]

[ "client_streamer", "sends", "a", "stream", "of", "requests", "to", "a", "GRPC", "server", "and", "returns", "a", "single", "response", "." ]

[ "def", "server_streamer", "(", "req", ",", "metadata", ":", "{", "}", ")", "raise_error_if_already_executed", "ops", "=", "{", "SEND_MESSAGE", "=>", "@marshal", ".", "call", "(", "req", ")", ",", "SEND_CLOSE_FROM_CLIENT", "=>", "nil", "}", "@send_initial_md_mutex", ".", "synchronize", "do", "# Metadata might have already been sent if this is an operation view", "unless", "@metadata_sent", "ops", "[", "SEND_INITIAL_METADATA", "]", "=", "@metadata_to_send", ".", "merge!", "(", "metadata", ")", "end", "@metadata_sent", "=", "true", "end", "begin", "@call", ".", "run_batch", "(", "ops", ")", "rescue", "GRPC", "::", "Core", "::", "CallError", "=>", "e", "receive_and_check_status", "# checks for Cancelled", "raise", "e", "rescue", "=>", "e", "set_input_stream_done", "raise", "e", "ensure", "set_output_stream_done", "end", "replies", "=", "enum_for", "(", ":each_remote_read_then_finish", ")", "return", "replies", "unless", "block_given?", "replies", ".", "each", "{", "|", "r", "|", "yield", "r", "}", "end" ]

[ "server_streamer", "sends", "one", "request", "to", "the", "GRPC", "server", "which", "yields", "a", "stream", "of", "responses", "." ]

[ "def", "bidi_streamer", "(", "requests", ",", "metadata", ":", "{", "}", ",", "&", "blk", ")", "raise_error_if_already_executed", "# Metadata might have already been sent if this is an operation view", "begin", "send_initial_metadata", "(", "metadata", ")", "rescue", "GRPC", "::", "Core", "::", "CallError", "=>", "e", "batch_result", "=", "@call", ".", "run_batch", "(", "RECV_STATUS_ON_CLIENT", "=>", "nil", ")", "set_input_stream_done", "set_output_stream_done", "attach_status_results_and_complete_call", "(", "batch_result", ")", "raise", "e", "rescue", "=>", "e", "set_input_stream_done", "set_output_stream_done", "raise", "e", "end", "bd", "=", "BidiCall", ".", "new", "(", "@call", ",", "@marshal", ",", "@unmarshal", ",", "metadata_received", ":", "@metadata_received", ")", "bd", ".", "run_on_client", "(", "requests", ",", "proc", "{", "set_input_stream_done", "}", ",", "proc", "{", "set_output_stream_done", "}", ",", "blk", ")", "end" ]

[ "bidi_streamer", "sends", "a", "stream", "of", "requests", "to", "the", "GRPC", "server", "and", "yields", "a", "stream", "of", "responses", "." ]

[ "def", "run_server_bidi", "(", "mth", ",", "interception_ctx", ")", "view", "=", "multi_req_view", "bidi_call", "=", "BidiCall", ".", "new", "(", "@call", ",", "@marshal", ",", "@unmarshal", ",", "metadata_received", ":", "@metadata_received", ",", "req_view", ":", "view", ")", "requests", "=", "bidi_call", ".", "read_next_loop", "(", "proc", "{", "set_input_stream_done", "}", ",", "false", ")", "interception_ctx", ".", "intercept!", "(", ":bidi_streamer", ",", "call", ":", "view", ",", "method", ":", "mth", ",", "requests", ":", "requests", ")", "do", "bidi_call", ".", "run_on_server", "(", "mth", ",", "requests", ")", "end", "end" ]

[ "run_server_bidi", "orchestrates", "a", "BiDi", "stream", "processing", "on", "a", "server", "." ]

[ "def", "run_on_client", "(", "requests", ",", "set_input_stream_done", ",", "set_output_stream_done", ",", "&", "blk", ")", "@enq_th", "=", "Thread", ".", "new", "do", "write_loop", "(", "requests", ",", "set_output_stream_done", ":", "set_output_stream_done", ")", "end", "read_loop", "(", "set_input_stream_done", ",", "blk", ")", "end" ]

[ "Creates", "a", "BidiCall", "." ]

[ "def", "run_on_server", "(", "gen_each_reply", ",", "requests", ")", "replies", "=", "nil", "# Pass in the optional call object parameter if possible", "if", "gen_each_reply", ".", "arity", "==", "1", "replies", "=", "gen_each_reply", ".", "call", "(", "requests", ")", "elsif", "gen_each_reply", ".", "arity", "==", "2", "replies", "=", "gen_each_reply", ".", "call", "(", "requests", ",", "@req_view", ")", "else", "fail", "'Illegal arity of reply generator'", "end", "write_loop", "(", "replies", ",", "is_client", ":", "false", ")", "end" ]

[ "Begins", "orchestration", "of", "the", "Bidi", "stream", "for", "a", "server", "generating", "replies", "." ]

[ "def", "read_using_run_batch", "ops", "=", "{", "RECV_MESSAGE", "=>", "nil", "}", "ops", "[", "RECV_INITIAL_METADATA", "]", "=", "nil", "unless", "@metadata_received", "begin", "batch_result", "=", "@call", ".", "run_batch", "(", "ops", ")", "unless", "@metadata_received", "@call", ".", "metadata", "=", "batch_result", ".", "metadata", "@metadata_received", "=", "true", "end", "batch_result", "rescue", "GRPC", "::", "Core", "::", "CallError", "=>", "e", "GRPC", ".", "logger", ".", "warn", "(", "'bidi call: read_using_run_batch failed'", ")", "GRPC", ".", "logger", ".", "warn", "(", "e", ")", "nil", "end", "end" ]

[ "performs", "a", "read", "using" ]

[ "def", "write_loop", "(", "requests", ",", "is_client", ":", "true", ",", "set_output_stream_done", ":", "nil", ")", "GRPC", ".", "logger", ".", "debug", "(", "'bidi-write-loop: starting'", ")", "count", "=", "0", "requests", ".", "each", "do", "|", "req", "|", "GRPC", ".", "logger", ".", "debug", "(", "\"bidi-write-loop: #{count}\"", ")", "count", "+=", "1", "payload", "=", "@marshal", ".", "call", "(", "req", ")", "# Fails if status already received", "begin", "@req_view", ".", "send_initial_metadata", "unless", "@req_view", ".", "nil?", "@call", ".", "run_batch", "(", "SEND_MESSAGE", "=>", "payload", ")", "rescue", "GRPC", "::", "Core", "::", "CallError", "=>", "e", "# This is almost definitely caused by a status arriving while still", "# writing. Don't re-throw the error", "GRPC", ".", "logger", ".", "warn", "(", "'bidi-write-loop: ended with error'", ")", "GRPC", ".", "logger", ".", "warn", "(", "e", ")", "break", "end", "end", "GRPC", ".", "logger", ".", "debug", "(", "\"bidi-write-loop: #{count} writes done\"", ")", "if", "is_client", "GRPC", ".", "logger", ".", "debug", "(", "\"bidi-write-loop: client sent #{count}, waiting\"", ")", "begin", "@call", ".", "run_batch", "(", "SEND_CLOSE_FROM_CLIENT", "=>", "nil", ")", "rescue", "GRPC", "::", "Core", "::", "CallError", "=>", "e", "GRPC", ".", "logger", ".", "warn", "(", "'bidi-write-loop: send close failed'", ")", "GRPC", ".", "logger", ".", "warn", "(", "e", ")", "end", "GRPC", ".", "logger", ".", "debug", "(", "'bidi-write-loop: done'", ")", "end", "GRPC", ".", "logger", ".", "debug", "(", "'bidi-write-loop: finished'", ")", "rescue", "StandardError", "=>", "e", "GRPC", ".", "logger", ".", "warn", "(", "'bidi-write-loop: failed'", ")", "GRPC", ".", "logger", ".", "warn", "(", "e", ")", "if", "is_client", "@call", ".", "cancel_with_status", "(", "GRPC", "::", "Core", "::", "StatusCodes", "::", "UNKNOWN", ",", "\"GRPC bidi call error: #{e.inspect}\"", ")", "else", "raise", "e", "end", "ensure", "set_output_stream_done", ".", "call", "if", "is_client", "end" ]

[ "set_output_stream_done", "is", "relevant", "on", "client", "-", "side" ]

[ "def", "read_loop", "(", "set_input_stream_done", ",", "is_client", ":", "true", ")", "return", "enum_for", "(", ":read_loop", ",", "set_input_stream_done", ",", "is_client", ":", "is_client", ")", "unless", "block_given?", "GRPC", ".", "logger", ".", "debug", "(", "'bidi-read-loop: starting'", ")", "begin", "count", "=", "0", "# queue the initial read before beginning the loop", "loop", "do", "GRPC", ".", "logger", ".", "debug", "(", "\"bidi-read-loop: #{count}\"", ")", "count", "+=", "1", "batch_result", "=", "read_using_run_batch", "# handle the next message", "if", "batch_result", ".", "nil?", "||", "batch_result", ".", "message", ".", "nil?", "GRPC", ".", "logger", ".", "debug", "(", "\"bidi-read-loop: null batch #{batch_result}\"", ")", "if", "is_client", "batch_result", "=", "@call", ".", "run_batch", "(", "RECV_STATUS_ON_CLIENT", "=>", "nil", ")", "@call", ".", "status", "=", "batch_result", ".", "status", "@call", ".", "trailing_metadata", "=", "@call", ".", "status", ".", "metadata", "if", "@call", ".", "status", "GRPC", ".", "logger", ".", "debug", "(", "\"bidi-read-loop: done status #{@call.status}\"", ")", "batch_result", ".", "check_status", "end", "GRPC", ".", "logger", ".", "debug", "(", "'bidi-read-loop: done reading!'", ")", "break", "end", "res", "=", "@unmarshal", ".", "call", "(", "batch_result", ".", "message", ")", "yield", "res", "end", "rescue", "StandardError", "=>", "e", "GRPC", ".", "logger", ".", "warn", "(", "'bidi: read-loop failed'", ")", "GRPC", ".", "logger", ".", "warn", "(", "e", ")", "raise", "e", "ensure", "set_input_stream_done", ".", "call", "end", "GRPC", ".", "logger", ".", "debug", "(", "'bidi-read-loop: finished'", ")", "# Make sure that the write loop is done before finishing the call.", "# Note that blocking is ok at this point because we've already received", "# a status", "@enq_th", ".", "join", "if", "is_client", "end" ]

[ "Provides", "an", "enumerator", "that", "yields", "results", "of", "remote", "reads" ]

[ "def", "schedule", "(", "*", "args", ",", "&", "blk", ")", "return", "if", "blk", ".", "nil?", "@stop_mutex", ".", "synchronize", "do", "if", "@stopped", "GRPC", ".", "logger", ".", "warn", "(", "'did not schedule job, already stopped'", ")", "return", "end", "GRPC", ".", "logger", ".", "info", "(", "'schedule another job'", ")", "fail", "'No worker threads available'", "if", "@ready_workers", ".", "empty?", "worker_queue", "=", "@ready_workers", ".", "pop", "fail", "'worker already has a task waiting'", "unless", "worker_queue", ".", "empty?", "worker_queue", "<<", "[", "blk", ",", "args", "]", "end", "end" ]

[ "Runs", "the", "given", "block", "on", "the", "queue", "with", "the", "provided", "args", "." ]

[ "def", "start", "@stop_mutex", ".", "synchronize", "do", "fail", "'already stopped'", "if", "@stopped", "end", "until", "@workers", ".", "size", "==", "@size", ".", "to_i", "new_worker_queue", "=", "Queue", ".", "new", "@ready_workers", "<<", "new_worker_queue", "next_thread", "=", "Thread", ".", "new", "(", "new_worker_queue", ")", "do", "|", "jobs", "|", "catch", "(", ":exit", ")", "do", "# allows { throw :exit } to kill a thread", "loop_execute_jobs", "(", "jobs", ")", "end", "remove_current_thread", "end", "@workers", "<<", "next_thread", "end", "end" ]

[ "Starts", "running", "the", "jobs", "in", "the", "thread", "pool", "." ]

[ "def", "stop", "GRPC", ".", "logger", ".", "info", "(", "'stopping, will wait for all the workers to exit'", ")", "@stop_mutex", ".", "synchronize", "do", "# wait @keep_alive seconds for workers to stop", "@stopped", "=", "true", "loop", "do", "break", "unless", "ready_for_work?", "worker_queue", "=", "@ready_workers", ".", "pop", "worker_queue", "<<", "[", "proc", "{", "throw", ":exit", "}", ",", "[", "]", "]", "end", "@stop_cond", ".", "wait", "(", "@stop_mutex", ",", "@keep_alive", ")", "if", "@workers", ".", "size", ">", "0", "end", "forcibly_stop_workers", "GRPC", ".", "logger", ".", "info", "(", "'stopped, all workers are shutdown'", ")", "end" ]

[ "Stops", "the", "jobs", "in", "the", "pool" ]

[ "def", "forcibly_stop_workers", "return", "unless", "@workers", ".", "size", ">", "0", "GRPC", ".", "logger", ".", "info", "(", "\"forcibly terminating #{@workers.size} worker(s)\"", ")", "@workers", ".", "each", "do", "|", "t", "|", "next", "unless", "t", ".", "alive?", "begin", "t", ".", "exit", "rescue", "StandardError", "=>", "e", "GRPC", ".", "logger", ".", "warn", "(", "'error while terminating a worker'", ")", "GRPC", ".", "logger", ".", "warn", "(", "e", ")", "end", "end", "end" ]

[ "Forcibly", "shutdown", "any", "threads", "that", "are", "still", "alive", "." ]

[ "def", "stop", "# if called via run_till_terminated_or_interrupted,", "# signal stop_server_thread and dont do anything", "if", "@stop_server", ".", "nil?", "==", "false", "&&", "@stop_server", "==", "false", "@stop_server", "=", "true", "@stop_server_cv", ".", "broadcast", "return", "end", "@run_mutex", ".", "synchronize", "do", "fail", "'Cannot stop before starting'", "if", "@running_state", "==", ":not_started", "return", "if", "@running_state", "!=", ":running", "transition_running_state", "(", ":stopping", ")", "deadline", "=", "from_relative_time", "(", "@poll_period", ")", "@server", ".", "shutdown_and_notify", "(", "deadline", ")", "end", "@pool", ".", "stop", "end" ]

[ "Creates", "a", "new", "RpcServer", "." ]

[ "def", "transition_running_state", "(", "target_state", ")", "state_transitions", "=", "{", "not_started", ":", ":running", ",", "running", ":", ":stopping", ",", "stopping", ":", ":stopped", "}", "if", "state_transitions", "[", "@running_state", "]", "==", "target_state", "@running_state", "=", "target_state", "else", "fail", "\"Bad server state transition: #{@running_state}->#{target_state}\"", "end", "end" ]

[ "Can", "only", "be", "called", "while", "holding" ]

[ "def", "handle", "(", "service", ")", "@run_mutex", ".", "synchronize", "do", "unless", "@running_state", "==", ":not_started", "fail", "'cannot add services if the server has been started'", "end", "cls", "=", "service", ".", "is_a?", "(", "Class", ")", "?", "service", ":", "service", ".", "class", "assert_valid_service_class", "(", "cls", ")", "add_rpc_descs_for", "(", "service", ")", "end", "end" ]

[ "handle", "registration", "of", "classes" ]

[ "def", "run", "@run_mutex", ".", "synchronize", "do", "fail", "'cannot run without registering services'", "if", "rpc_descs", ".", "size", ".", "zero?", "@pool", ".", "start", "@server", ".", "start", "transition_running_state", "(", ":running", ")", "@run_cond", ".", "broadcast", "end", "loop_handle_server_calls", "end" ]

[ "runs", "the", "server" ]

[ "def", "run_till_terminated_or_interrupted", "(", "signals", ",", "wait_interval", "=", "60", ")", "@stop_server", "=", "false", "@stop_server_mu", "=", "Mutex", ".", "new", "@stop_server_cv", "=", "ConditionVariable", ".", "new", "@stop_server_thread", "=", "Thread", ".", "new", "do", "loop", "do", "break", "if", "@stop_server", "@stop_server_mu", ".", "synchronize", "do", "@stop_server_cv", ".", "wait", "(", "@stop_server_mu", ",", "wait_interval", ")", "end", "end", "# stop is surrounded by mutex, should handle multiple calls to stop", "# correctly", "stop", "end", "valid_signals", "=", "Signal", ".", "list", "# register signal handlers", "signals", ".", "each", "do", "|", "sig", "|", "# input validation", "if", "sig", ".", "class", "==", "String", "sig", ".", "upcase!", "if", "sig", ".", "start_with?", "(", "'SIG'", ")", "# cut out the SIG prefix to see if valid signal", "sig", "=", "sig", "[", "3", "..", "-", "1", "]", "end", "end", "# register signal traps for all valid signals", "if", "valid_signals", ".", "value?", "(", "sig", ")", "||", "valid_signals", ".", "key?", "(", "sig", ")", "Signal", ".", "trap", "(", "sig", ")", "do", "@stop_server", "=", "true", "@stop_server_cv", ".", "broadcast", "end", "else", "fail", "\"#{sig} not a valid signal\"", "end", "end", "run", "@stop_server_thread", ".", "join", "end" ]

[ "runs", "the", "server", "with", "signal", "handlers" ]

[ "def", "available?", "(", "an_rpc", ")", "return", "an_rpc", "if", "@pool", ".", "ready_for_work?", "GRPC", ".", "logger", ".", "warn", "(", "'no free worker threads currently'", ")", "noop", "=", "proc", "{", "|", "x", "|", "x", "}", "# Create a new active call that knows that metadata hasn't been", "# sent yet", "c", "=", "ActiveCall", ".", "new", "(", "an_rpc", ".", "call", ",", "noop", ",", "noop", ",", "an_rpc", ".", "deadline", ",", "metadata_received", ":", "true", ",", "started", ":", "false", ")", "c", ".", "send_status", "(", "GRPC", "::", "Core", "::", "StatusCodes", "::", "RESOURCE_EXHAUSTED", ",", "'No free threads in thread pool'", ")", "nil", "end" ]

[ "Sends", "RESOURCE_EXHAUSTED", "if", "there", "are", "too", "many", "unprocessed", "jobs" ]

[ "def", "implemented?", "(", "an_rpc", ")", "mth", "=", "an_rpc", ".", "method", ".", "to_sym", "return", "an_rpc", "if", "rpc_descs", ".", "key?", "(", "mth", ")", "GRPC", ".", "logger", ".", "warn", "(", "\"UNIMPLEMENTED: #{an_rpc}\"", ")", "noop", "=", "proc", "{", "|", "x", "|", "x", "}", "# Create a new active call that knows that", "# metadata hasn't been sent yet", "c", "=", "ActiveCall", ".", "new", "(", "an_rpc", ".", "call", ",", "noop", ",", "noop", ",", "an_rpc", ".", "deadline", ",", "metadata_received", ":", "true", ",", "started", ":", "false", ")", "c", ".", "send_status", "(", "GRPC", "::", "Core", "::", "StatusCodes", "::", "UNIMPLEMENTED", ",", "''", ")", "nil", "end" ]

[ "Sends", "UNIMPLEMENTED", "if", "the", "method", "is", "not", "implemented", "by", "this", "server" ]

[ "def", "loop_handle_server_calls", "fail", "'not started'", "if", "running_state", "==", ":not_started", "while", "running_state", "==", ":running", "begin", "an_rpc", "=", "@server", ".", "request_call", "break", "if", "(", "!", "an_rpc", ".", "nil?", ")", "&&", "an_rpc", ".", "call", ".", "nil?", "active_call", "=", "new_active_server_call", "(", "an_rpc", ")", "unless", "active_call", ".", "nil?", "@pool", ".", "schedule", "(", "active_call", ")", "do", "|", "ac", "|", "c", ",", "mth", "=", "ac", "begin", "rpc_descs", "[", "mth", "]", ".", "run_server_method", "(", "c", ",", "rpc_handlers", "[", "mth", "]", ",", "@interceptors", ".", "build_context", ")", "rescue", "StandardError", "c", ".", "send_status", "(", "GRPC", "::", "Core", "::", "StatusCodes", "::", "INTERNAL", ",", "'Server handler failed'", ")", "end", "end", "end", "rescue", "Core", "::", "CallError", ",", "RuntimeError", "=>", "e", "# these might happen for various reasons. The correct behavior of", "# the server is to log them and continue, if it's not shutting down.", "if", "running_state", "==", ":running", "GRPC", ".", "logger", ".", "warn", "(", "\"server call failed: #{e}\"", ")", "end", "next", "end", "end", "# @running_state should be :stopping here", "@run_mutex", ".", "synchronize", "do", "transition_running_state", "(", ":stopped", ")", "GRPC", ".", "logger", ".", "info", "(", "\"stopped: #{self}\"", ")", "@server", ".", "close", "end", "end" ]

[ "handles", "calls", "to", "the", "server" ]

[ "def", "request_response", "(", "method", ",", "req", ",", "marshal", ",", "unmarshal", ",", "deadline", ":", "nil", ",", "return_op", ":", "false", ",", "parent", ":", "nil", ",", "credentials", ":", "nil", ",", "metadata", ":", "{", "}", ")", "c", "=", "new_active_call", "(", "method", ",", "marshal", ",", "unmarshal", ",", "deadline", ":", "deadline", ",", "parent", ":", "parent", ",", "credentials", ":", "credentials", ")", "interception_context", "=", "@interceptors", ".", "build_context", "intercept_args", "=", "{", "method", ":", "method", ",", "request", ":", "req", ",", "call", ":", "c", ".", "interceptable", ",", "metadata", ":", "metadata", "}", "if", "return_op", "# return the operation view of the active_call; define #execute as a", "# new method for this instance that invokes #request_response.", "c", ".", "merge_metadata_to_send", "(", "metadata", ")", "op", "=", "c", ".", "operation", "op", ".", "define_singleton_method", "(", ":execute", ")", "do", "interception_context", ".", "intercept!", "(", ":request_response", ",", "intercept_args", ")", "do", "c", ".", "request_response", "(", "req", ",", "metadata", ":", "metadata", ")", "end", "end", "op", "else", "interception_context", ".", "intercept!", "(", ":request_response", ",", "intercept_args", ")", "do", "c", ".", "request_response", "(", "req", ",", "metadata", ":", "metadata", ")", "end", "end", "end" ]

[ "Creates", "a", "new", "ClientStub", "." ]

[ "def", "new_active_call", "(", "method", ",", "marshal", ",", "unmarshal", ",", "deadline", ":", "nil", ",", "parent", ":", "nil", ",", "credentials", ":", "nil", ")", "deadline", "=", "from_relative_time", "(", "@timeout", ")", "if", "deadline", ".", "nil?", "# Provide each new client call with its own completion queue", "call", "=", "@ch", ".", "create_call", "(", "parent", ",", "# parent call", "@propagate_mask", ",", "# propagation options", "method", ",", "nil", ",", "# host use nil,", "deadline", ")", "call", ".", "set_credentials!", "credentials", "unless", "credentials", ".", "nil?", "ActiveCall", ".", "new", "(", "call", ",", "marshal", ",", "unmarshal", ",", "deadline", ",", "started", ":", "false", ")", "end" ]

[ "Creates", "a", "new", "active", "stub" ]

[ "def", "lookup_variable", "(", "context", ",", "variable", ")", "lookup", "=", "context", "variable", ".", "split", "(", "\".\"", ")", ".", "each", "do", "|", "value", "|", "lookup", "=", "lookup", "[", "value", "]", "end", "lookup", "||", "variable", "end" ]

[ "Lookup", "a", "Liquid", "variable", "in", "the", "given", "context", "." ]

[ "def", "converters", "@converters", "||=", "site", ".", "converters", ".", "select", "{", "|", "c", "|", "c", ".", "matches", "(", "document", ".", "extname", ")", "}", ".", "sort", "end" ]

[ "Determine", "which", "converters", "to", "use", "based", "on", "this", "document", "s", "extension", "." ]

[ "def", "run", "Jekyll", ".", "logger", ".", "debug", "\"Rendering:\"", ",", "document", ".", "relative_path", "assign_pages!", "assign_current_document!", "assign_highlighter_options!", "assign_layout_data!", "Jekyll", ".", "logger", ".", "debug", "\"Pre-Render Hooks:\"", ",", "document", ".", "relative_path", "document", ".", "trigger_hooks", "(", ":pre_render", ",", "payload", ")", "render_document", "end" ]

[ "Prepare", "payload", "and", "render", "the", "document" ]

[ "def", "render_document", "info", "=", "{", ":registers", "=>", "{", ":site", "=>", "site", ",", ":page", "=>", "payload", "[", "\"page\"", "]", "}", ",", ":strict_filters", "=>", "liquid_options", "[", "\"strict_filters\"", "]", ",", ":strict_variables", "=>", "liquid_options", "[", "\"strict_variables\"", "]", ",", "}", "output", "=", "document", ".", "content", "if", "document", ".", "render_with_liquid?", "Jekyll", ".", "logger", ".", "debug", "\"Rendering Liquid:\"", ",", "document", ".", "relative_path", "output", "=", "render_liquid", "(", "output", ",", "payload", ",", "info", ",", "document", ".", "path", ")", "end", "Jekyll", ".", "logger", ".", "debug", "\"Rendering Markup:\"", ",", "document", ".", "relative_path", "output", "=", "convert", "(", "output", ".", "to_s", ")", "document", ".", "content", "=", "output", "if", "document", ".", "place_in_layout?", "Jekyll", ".", "logger", ".", "debug", "\"Rendering Layout:\"", ",", "document", ".", "relative_path", "output", "=", "place_in_layouts", "(", "output", ",", "payload", ",", "info", ")", "end", "output", "end" ]

[ "Render", "the", "document", "." ]

[ "def", "place_in_layouts", "(", "content", ",", "payload", ",", "info", ")", "output", "=", "content", ".", "dup", "layout", "=", "layouts", "[", "document", ".", "data", "[", "\"layout\"", "]", ".", "to_s", "]", "validate_layout", "(", "layout", ")", "used", "=", "Set", ".", "new", "(", "[", "layout", "]", ")", "# Reset the payload layout data to ensure it starts fresh for each page.", "payload", "[", "\"layout\"", "]", "=", "nil", "while", "layout", "output", "=", "render_layout", "(", "output", ",", "layout", ",", "info", ")", "add_regenerator_dependencies", "(", "layout", ")", "next", "unless", "(", "layout", "=", "site", ".", "layouts", "[", "layout", ".", "data", "[", "\"layout\"", "]", "]", ")", "break", "if", "used", ".", "include?", "(", "layout", ")", "used", "<<", "layout", "end", "output", "end" ]

[ "Render", "layouts", "and", "place", "document", "content", "inside", "." ]

[ "def", "validate_layout", "(", "layout", ")", "if", "invalid_layout?", "(", "layout", ")", "Jekyll", ".", "logger", ".", "warn", "(", "\"Build Warning:\"", ",", "\"Layout '#{document.data[\"layout\"]}' requested \"", "\"in #{document.relative_path} does not exist.\"", ")", "elsif", "!", "layout", ".", "nil?", "layout_source", "=", "layout", ".", "path", ".", "start_with?", "(", "site", ".", "source", ")", "?", ":site", ":", ":theme", "Jekyll", ".", "logger", ".", "debug", "\"Layout source:\"", ",", "layout_source", "end", "end" ]

[ "Checks", "if", "the", "layout", "specified", "in", "the", "document", "actually", "exists" ]

[ "def", "render_layout", "(", "output", ",", "layout", ",", "info", ")", "payload", "[", "\"content\"", "]", "=", "output", "payload", "[", "\"layout\"", "]", "=", "Utils", ".", "deep_merge_hashes", "(", "layout", ".", "data", ",", "payload", "[", "\"layout\"", "]", "||", "{", "}", ")", "render_liquid", "(", "layout", ".", "content", ",", "payload", ",", "info", ",", "layout", ".", "relative_path", ")", "end" ]

[ "Render", "layout", "content", "into", "document", ".", "output" ]

[ "def", "assign_pages!", "payload", "[", "\"page\"", "]", "=", "document", ".", "to_liquid", "payload", "[", "\"paginator\"", "]", "=", "(", "document", ".", "pager", ".", "to_liquid", "if", "document", ".", "respond_to?", "(", ":pager", ")", ")", "end" ]

[ "Set", "page", "content", "to", "payload", "and", "assign", "pager", "if", "document", "has", "one", "." ]

[ "def", "read", "@site", ".", "layouts", "=", "LayoutReader", ".", "new", "(", "site", ")", ".", "read", "read_directories", "read_included_excludes", "sort_files!", "@site", ".", "data", "=", "DataReader", ".", "new", "(", "site", ")", ".", "read", "(", "site", ".", "config", "[", "\"data_dir\"", "]", ")", "CollectionReader", ".", "new", "(", "site", ")", ".", "read", "ThemeAssetsReader", ".", "new", "(", "site", ")", ".", "read", "end" ]

[ "Read", "Site", "data", "from", "disk", "and", "load", "it", "into", "internal", "data", "structures", "." ]

[ "def", "retrieve_dirs", "(", "_base", ",", "dir", ",", "dot_dirs", ")", "dot_dirs", ".", "each", "do", "|", "file", "|", "dir_path", "=", "site", ".", "in_source_dir", "(", "dir", ",", "file", ")", "rel_path", "=", "File", ".", "join", "(", "dir", ",", "file", ")", "@site", ".", "reader", ".", "read_directories", "(", "rel_path", ")", "unless", "@site", ".", "dest", ".", "chomp", "(", "\"/\"", ")", "==", "dir_path", "end", "end" ]

[ "Recursively", "traverse", "directories", "with", "the", "read_directories", "function", "." ]

[ "def", "get_entries", "(", "dir", ",", "subfolder", ")", "base", "=", "site", ".", "in_source_dir", "(", "dir", ",", "subfolder", ")", "return", "[", "]", "unless", "File", ".", "exist?", "(", "base", ")", "entries", "=", "Dir", ".", "chdir", "(", "base", ")", "{", "filter_entries", "(", "Dir", "[", "\"**/*\"", "]", ",", "base", ")", "}", "entries", ".", "delete_if", "{", "|", "e", "|", "File", ".", "directory?", "(", "site", ".", "in_source_dir", "(", "base", ",", "e", ")", ")", "}", "end" ]

[ "Read", "the", "entries", "from", "a", "particular", "directory", "for", "processing" ]

[ "def", "write", "each_site_file", "do", "|", "item", "|", "item", ".", "write", "(", "dest", ")", "if", "regenerator", ".", "regenerate?", "(", "item", ")", "end", "regenerator", ".", "write_metadata", "Jekyll", "::", "Hooks", ".", "trigger", ":site", ",", ":post_write", ",", "self", "end" ]

[ "Write", "static", "files", "pages", "and", "posts", "." ]

[ "def", "post_attr_hash", "(", "post_attr", ")", "# Build a hash map based on the specified post attribute ( post attr =>", "# array of posts ) then sort each array in reverse order.", "@post_attr_hash", "[", "post_attr", "]", "||=", "begin", "hash", "=", "Hash", ".", "new", "{", "|", "h", ",", "key", "|", "h", "[", "key", "]", "=", "[", "]", "}", "posts", ".", "docs", ".", "each", "do", "|", "p", "|", "p", ".", "data", "[", "post_attr", "]", "&.", "each", "{", "|", "t", "|", "hash", "[", "t", "]", "<<", "p", "}", "end", "hash", ".", "each_value", "{", "|", "posts", "|", "posts", ".", "sort!", ".", "reverse!", "}", "hash", "end", "end" ]

[ "Construct", "a", "Hash", "of", "Posts", "indexed", "by", "the", "specified", "Post", "attribute", "." ]

[ "def", "find_converter_instance", "(", "klass", ")", "@find_converter_instance", "||=", "{", "}", "@find_converter_instance", "[", "klass", "]", "||=", "begin", "converters", ".", "find", "{", "|", "converter", "|", "converter", ".", "instance_of?", "(", "klass", ")", "}", "||", "raise", "(", "\"No Converters found for #{klass}\"", ")", "end", "end" ]

[ "Get", "the", "implementation", "class", "for", "the", "given", "Converter", ".", "Returns", "the", "Converter", "instance", "implementing", "the", "given", "Converter", ".", "klass", "-", "The", "Class", "of", "the", "Converter", "to", "fetch", "." ]

[ "def", "instantiate_subclasses", "(", "klass", ")", "klass", ".", "descendants", ".", "select", "{", "|", "c", "|", "!", "safe", "||", "c", ".", "safe", "}", ".", "sort", ".", "map", "do", "|", "c", "|", "c", ".", "new", "(", "config", ")", "end", "end" ]

[ "klass", "-", "class", "or", "module", "containing", "the", "subclasses", ".", "Returns", "array", "of", "instances", "of", "subclasses", "of", "parameter", ".", "Create", "array", "of", "instances", "of", "the", "subclasses", "of", "the", "class", "or", "module", "passed", "in", "as", "argument", "." ]

[ "def", "documents", "@documents", "||=", "collections", ".", "reduce", "(", "Set", ".", "new", ")", "do", "|", "docs", ",", "(", "_", ",", "collection", ")", "|", "docs", "+", "collection", ".", "docs", "+", "collection", ".", "files", "end", ".", "to_a", "end" ]

[ "Get", "all", "the", "documents" ]

[ "def", "configure_cache", "Jekyll", "::", "Cache", ".", "cache_dir", "=", "in_source_dir", "(", "config", "[", "\"cache_dir\"", "]", ",", "\"Jekyll/Cache\"", ")", "Jekyll", "::", "Cache", ".", "disable_disk_cache!", "if", "safe", "end" ]

[ "Disable", "Marshaling", "cache", "to", "disk", "in", "Safe", "Mode" ]

[ "def", "find", "(", "path", ",", "type", ",", "setting", ")", "value", "=", "nil", "old_scope", "=", "nil", "matching_sets", "(", "path", ",", "type", ")", ".", "each", "do", "|", "set", "|", "if", "set", "[", "\"values\"", "]", ".", "key?", "(", "setting", ")", "&&", "has_precedence?", "(", "old_scope", ",", "set", "[", "\"scope\"", "]", ")", "value", "=", "set", "[", "\"values\"", "]", "[", "setting", "]", "old_scope", "=", "set", "[", "\"scope\"", "]", "end", "end", "value", "end" ]

[ "Finds", "a", "default", "value", "for", "a", "given", "setting", "filtered", "by", "path", "and", "type" ]

[ "def", "all", "(", "path", ",", "type", ")", "defaults", "=", "{", "}", "old_scope", "=", "nil", "matching_sets", "(", "path", ",", "type", ")", ".", "each", "do", "|", "set", "|", "if", "has_precedence?", "(", "old_scope", ",", "set", "[", "\"scope\"", "]", ")", "defaults", "=", "Utils", ".", "deep_merge_hashes", "(", "defaults", ",", "set", "[", "\"values\"", "]", ")", "old_scope", "=", "set", "[", "\"scope\"", "]", "else", "defaults", "=", "Utils", ".", "deep_merge_hashes", "(", "set", "[", "\"values\"", "]", ",", "defaults", ")", "end", "end", "defaults", "end" ]

[ "Collects", "a", "hash", "with", "all", "default", "values", "for", "a", "page", "or", "post" ]

[ "def", "valid_sets", "sets", "=", "@site", ".", "config", "[", "\"defaults\"", "]", "return", "[", "]", "unless", "sets", ".", "is_a?", "(", "Array", ")", "sets", ".", "map", "do", "|", "set", "|", "if", "valid?", "(", "set", ")", "ensure_time!", "(", "update_deprecated_types", "(", "set", ")", ")", "else", "Jekyll", ".", "logger", ".", "warn", "\"Defaults:\"", ",", "\"An invalid front-matter default set was found:\"", "Jekyll", ".", "logger", ".", "warn", "set", ".", "to_s", "nil", "end", "end", ".", "compact", "end" ]

[ "Returns", "a", "list", "of", "valid", "sets" ]

[ "def", "[]", "(", "key", ")", "return", "@cache", "[", "key", "]", "if", "@cache", ".", "key?", "(", "key", ")", "path", "=", "path_to", "(", "hash", "(", "key", ")", ")", "if", "disk_cache_enabled?", "&&", "File", ".", "file?", "(", "path", ")", "&&", "File", ".", "readable?", "(", "path", ")", "@cache", "[", "key", "]", "=", "load", "(", "path", ")", "else", "raise", "end", "end" ]

[ "Retrieve", "a", "cached", "item", "Raises", "if", "key", "does", "not", "exist", "in", "cache" ]

[ "def", "[]=", "(", "key", ",", "value", ")", "@cache", "[", "key", "]", "=", "value", "return", "unless", "disk_cache_enabled?", "path", "=", "path_to", "(", "hash", "(", "key", ")", ")", "value", "=", "new", "Hash", "(", "value", ")", "if", "value", ".", "is_a?", "(", "Hash", ")", "&&", "!", "value", ".", "default", ".", "nil?", "dump", "(", "path", ",", "value", ")", "rescue", "TypeError", "Jekyll", ".", "logger", ".", "debug", "\"Cache:\"", ",", "\"Cannot dump object #{key}\"", "end" ]

[ "Add", "an", "item", "to", "cache" ]

[ "def", "delete", "(", "key", ")", "@cache", ".", "delete", "(", "key", ")", "File", ".", "delete", "(", "path_to", "(", "hash", "(", "key", ")", ")", ")", "if", "disk_cache_enabled?", "end" ]

[ "Remove", "one", "particular", "item", "from", "the", "cache" ]

[ "def", "key?", "(", "key", ")", "# First, check if item is already cached in memory", "return", "true", "if", "@cache", ".", "key?", "(", "key", ")", "# Otherwise, it might be cached on disk", "# but we should not consider the disk cache if it is disabled", "return", "false", "unless", "disk_cache_enabled?", "path", "=", "path_to", "(", "hash", "(", "key", ")", ")", "File", ".", "file?", "(", "path", ")", "&&", "File", ".", "readable?", "(", "path", ")", "end" ]

[ "Check", "if", "key", "already", "exists", "in", "this", "cache" ]

[ "def", "path_to", "(", "hash", "=", "nil", ")", "@base_dir", "||=", "File", ".", "join", "(", "Jekyll", "::", "Cache", ".", "cache_dir", ",", "@name", ")", "return", "@base_dir", "if", "hash", ".", "nil?", "File", ".", "join", "(", "@base_dir", ",", "hash", "[", "0", "..", "1", "]", ",", "hash", "[", "2", "..", "-", "1", "]", ")", ".", "freeze", "end" ]

[ "Given", "a", "hashed", "key", "return", "the", "path", "to", "where", "this", "item", "would", "be", "saved", "on", "disk", "." ]

[ "def", "render_liquid", "(", "content", ",", "payload", ",", "info", ",", "path", ")", "_renderer", ".", "render_liquid", "(", "content", ",", "payload", ",", "info", ",", "path", ")", "end" ]

[ "Render", "Liquid", "in", "the", "content" ]

[ "def", "to_liquid", "(", "attrs", "=", "nil", ")", "further_data", "=", "Hash", "[", "(", "attrs", "||", "self", ".", "class", "::", "ATTRIBUTES_FOR_LIQUID", ")", ".", "map", "do", "|", "attribute", "|", "[", "attribute", ",", "send", "(", "attribute", ")", "]", "end", "]", "defaults", "=", "site", ".", "frontmatter_defaults", ".", "all", "(", "relative_path", ",", "type", ")", "Utils", ".", "deep_merge_hashes", "defaults", ",", "Utils", ".", "deep_merge_hashes", "(", "data", ",", "further_data", ")", "end" ]

[ "Convert", "this", "Convertible", "s", "data", "to", "a", "Hash", "suitable", "for", "use", "by", "Liquid", "." ]

[ "def", "render_all_layouts", "(", "layouts", ",", "payload", ",", "info", ")", "_renderer", ".", "layouts", "=", "layouts", "self", ".", "output", "=", "_renderer", ".", "place_in_layouts", "(", "output", ",", "payload", ",", "info", ")", "ensure", "@_renderer", "=", "nil", "# this will allow the modifications above to disappear", "end" ]

[ "Recursively", "render", "layouts" ]

[ "def", "do_layout", "(", "payload", ",", "layouts", ")", "self", ".", "output", "=", "_renderer", ".", "tap", "do", "|", "renderer", "|", "renderer", ".", "layouts", "=", "layouts", "renderer", ".", "payload", "=", "payload", "end", ".", "run", "Jekyll", ".", "logger", ".", "debug", "\"Post-Render Hooks:\"", ",", "relative_path", "Jekyll", "::", "Hooks", ".", "trigger", "hook_owner", ",", ":post_render", ",", "self", "ensure", "@_renderer", "=", "nil", "# this will allow the modifications above to disappear", "end" ]

[ "Add", "any", "necessary", "layouts", "to", "this", "convertible", "document", "." ]

[ "def", "require_theme_deps", "return", "false", "unless", "site", ".", "theme", ".", "runtime_dependencies", "site", ".", "theme", ".", "runtime_dependencies", ".", "each", "do", "|", "dep", "|", "next", "if", "dep", ".", "name", "==", "\"jekyll\"", "External", ".", "require_with_graceful_fail", "(", "dep", ".", "name", ")", "if", "plugin_allowed?", "(", "dep", ".", "name", ")", "end", "end" ]

[ "Require", "each", "of", "the", "runtime_dependencies", "specified", "by", "the", "theme", "s", "gemspec", "." ]

[ "def", "require_plugin_files", "unless", "site", ".", "safe", "plugins_path", ".", "each", "do", "|", "plugin_search_path", "|", "plugin_files", "=", "Utils", ".", "safe_glob", "(", "plugin_search_path", ",", "File", ".", "join", "(", "\"**\"", ",", "\"*.rb\"", ")", ")", "Jekyll", "::", "External", ".", "require_with_graceful_fail", "(", "plugin_files", ")", "end", "end", "end" ]

[ "Require", "all", ".", "rb", "files", "if", "safe", "mode", "is", "off" ]

[ "def", "path", "# Static file is from a collection inside custom collections directory", "if", "!", "@collection", ".", "nil?", "&&", "!", "@site", ".", "config", "[", "\"collections_dir\"", "]", ".", "empty?", "File", ".", "join", "(", "[", "@base", ",", "@site", ".", "config", "[", "\"collections_dir\"", "]", ",", "@dir", ",", "@name", "]", ".", "compact", ")", "else", "File", ".", "join", "(", "[", "@base", ",", "@dir", ",", "@name", "]", ".", "compact", ")", "end", "end" ]

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

[ "def", "merge_data!", "(", "other", ",", "source", ":", "\"YAML front matter\"", ")", "merge_categories!", "(", "other", ")", "Utils", ".", "deep_merge_hashes!", "(", "data", ",", "other", ")", "merge_date!", "(", "source", ")", "data", "end" ]

[ "Merge", "some", "data", "in", "with", "this", "document", "s", "data", "." ]

[ "def", "deep_merge_hashes!", "(", "target", ",", "overwrite", ")", "merge_values", "(", "target", ",", "overwrite", ")", "merge_default_proc", "(", "target", ",", "overwrite", ")", "duplicate_frozen_values", "(", "target", ")", "target", "end" ]

[ "Merges", "a", "master", "hash", "with", "another", "hash", "recursively", "." ]

[ "def", "pluralized_array_from_hash", "(", "hash", ",", "singular_key", ",", "plural_key", ")", "[", "]", ".", "tap", "do", "|", "array", "|", "value", "=", "value_from_singular_key", "(", "hash", ",", "singular_key", ")", "value", "||=", "value_from_plural_key", "(", "hash", ",", "plural_key", ")", "array", "<<", "value", "end", ".", "flatten", ".", "compact", "end" ]

[ "Read", "array", "from", "the", "supplied", "hash", "favouring", "the", "singular", "key", "and", "then", "the", "plural", "key", "and", "handling", "any", "nil", "entries", "." ]

[ "def", "has_liquid_construct?", "(", "content", ")", "return", "false", "if", "content", ".", "nil?", "||", "content", ".", "empty?", "content", ".", "include?", "(", "\"{%\"", ")", "||", "content", ".", "include?", "(", "\"{{\"", ")", "end" ]

[ "Determine", "whether", "the", "given", "content", "string", "contains", "Liquid", "Tags", "or", "Vaiables" ]

[ "def", "add_permalink_suffix", "(", "template", ",", "permalink_style", ")", "template", "=", "template", ".", "dup", "case", "permalink_style", "when", ":pretty", "template", "<<", "\"/\"", "when", ":date", ",", ":ordinal", ",", ":none", "template", "<<", "\":output_ext\"", "else", "template", "<<", "\"/\"", "if", "permalink_style", ".", "to_s", ".", "end_with?", "(", "\"/\"", ")", "template", "<<", "\":output_ext\"", "if", "permalink_style", ".", "to_s", ".", "end_with?", "(", "\":output_ext\"", ")", "end", "template", "end" ]

[ "Add", "an", "appropriate", "suffix", "to", "template", "so", "that", "it", "matches", "the", "specified", "permalink", "style", "." ]

[ "def", "replace_character_sequence_with_hyphen", "(", "string", ",", "mode", ":", "\"default\"", ")", "replaceable_char", "=", "case", "mode", "when", "\"raw\"", "SLUGIFY_RAW_REGEXP", "when", "\"pretty\"", "# \"._~!$&'()+,;=@\" is human readable (not URI-escaped) in URL", "# and is allowed in both extN and NTFS.", "SLUGIFY_PRETTY_REGEXP", "when", "\"ascii\"", "# For web servers not being able to handle Unicode, the safe", "# method is to ditch anything else but latin letters and numeric", "# digits.", "SLUGIFY_ASCII_REGEXP", "else", "SLUGIFY_DEFAULT_REGEXP", "end", "# Strip according to the mode", "string", ".", "gsub", "(", "replaceable_char", ",", "\"-\"", ")", "end" ]

[ "Replace", "each", "character", "sequence", "with", "a", "hyphen", "." ]

[ "def", "process", "(", "name", ")", "self", ".", "ext", "=", "File", ".", "extname", "(", "name", ")", "self", ".", "basename", "=", "name", "[", "0", "..", "-", "ext", ".", "length", "-", "1", "]", ".", "gsub", "(", "%r!", "\\.", "\\z", "!", ",", "\"\"", ")", "end" ]

[ "Extract", "information", "from", "the", "page", "filename", "." ]

[ "def", "render", "(", "layouts", ",", "site_payload", ")", "site_payload", "[", "\"page\"", "]", "=", "to_liquid", "site_payload", "[", "\"paginator\"", "]", "=", "pager", ".", "to_liquid", "do_layout", "(", "site_payload", ",", "layouts", ")", "end" ]

[ "Add", "any", "necessary", "layouts", "to", "this", "post" ]

[ "def", "where_exp", "(", "input", ",", "variable", ",", "expression", ")", "return", "input", "unless", "input", ".", "respond_to?", "(", ":select", ")", "input", "=", "input", ".", "values", "if", "input", ".", "is_a?", "(", "Hash", ")", "# FIXME", "condition", "=", "parse_condition", "(", "expression", ")", "@context", ".", "stack", "do", "input", ".", "select", "do", "|", "object", "|", "@context", "[", "variable", "]", "=", "object", "condition", ".", "evaluate", "(", "@context", ")", "end", "end", "||", "[", "]", "end" ]

[ "Filters", "an", "array", "of", "objects", "against", "an", "expression" ]

[ "def", "sort", "(", "input", ",", "property", "=", "nil", ",", "nils", "=", "\"first\"", ")", "raise", "ArgumentError", ",", "\"Cannot sort a null object.\"", "if", "input", ".", "nil?", "if", "property", ".", "nil?", "input", ".", "sort", "else", "if", "nils", "==", "\"first\"", "order", "=", "-", "1", "elsif", "nils", "==", "\"last\"", "order", "=", "+", "1", "else", "raise", "ArgumentError", ",", "\"Invalid nils order: \"", "\"'#{nils}' is not a valid nils order. It must be 'first' or 'last'.\"", "end", "sort_input", "(", "input", ",", "property", ",", "order", ")", "end", "end" ]

[ "Sort", "an", "array", "of", "objects" ]