id int32 0 24.9k | repo stringlengths 5 58 | path stringlengths 9 168 | func_name stringlengths 9 130 | original_string stringlengths 66 10.5k | language stringclasses 1
value | code stringlengths 66 10.5k | code_tokens list | docstring stringlengths 8 16k | docstring_tokens list | sha stringlengths 40 40 | url stringlengths 94 266 |
|---|---|---|---|---|---|---|---|---|---|---|---|
12,200 | attr-encrypted/attr_encrypted | lib/attr_encrypted.rb | AttrEncrypted.InstanceMethods.encrypt | def encrypt(attribute, value)
encrypted_attributes[attribute.to_sym][:operation] = :encrypting
encrypted_attributes[attribute.to_sym][:value_present] = self.class.not_empty?(value)
self.class.encrypt(attribute, value, evaluated_attr_encrypted_options_for(attribute))
end | ruby | def encrypt(attribute, value)
encrypted_attributes[attribute.to_sym][:operation] = :encrypting
encrypted_attributes[attribute.to_sym][:value_present] = self.class.not_empty?(value)
self.class.encrypt(attribute, value, evaluated_attr_encrypted_options_for(attribute))
end | [
"def",
"encrypt",
"(",
"attribute",
",",
"value",
")",
"encrypted_attributes",
"[",
"attribute",
".",
"to_sym",
"]",
"[",
":operation",
"]",
"=",
":encrypting",
"encrypted_attributes",
"[",
"attribute",
".",
"to_sym",
"]",
"[",
":value_present",
"]",
"=",
"sel... | Encrypts a value for the attribute specified using options evaluated in the current object's scope
Example
class User
attr_accessor :secret_key
attr_encrypted :email, key: :secret_key
def initialize(secret_key)
self.secret_key = secret_key
end
end
@user = User.new('some-secret-key')
@... | [
"Encrypts",
"a",
"value",
"for",
"the",
"attribute",
"specified",
"using",
"options",
"evaluated",
"in",
"the",
"current",
"object",
"s",
"scope"
] | 11df93aef14c661dd0c03169d382a0412f93124e | https://github.com/attr-encrypted/attr_encrypted/blob/11df93aef14c661dd0c03169d382a0412f93124e/lib/attr_encrypted.rb#L349-L353 |
12,201 | attr-encrypted/attr_encrypted | lib/attr_encrypted.rb | AttrEncrypted.InstanceMethods.encrypted_attributes | def encrypted_attributes
@encrypted_attributes ||= begin
duplicated= {}
self.class.encrypted_attributes.map { |key, value| duplicated[key] = value.dup }
duplicated
end
end | ruby | def encrypted_attributes
@encrypted_attributes ||= begin
duplicated= {}
self.class.encrypted_attributes.map { |key, value| duplicated[key] = value.dup }
duplicated
end
end | [
"def",
"encrypted_attributes",
"@encrypted_attributes",
"||=",
"begin",
"duplicated",
"=",
"{",
"}",
"self",
".",
"class",
".",
"encrypted_attributes",
".",
"map",
"{",
"|",
"key",
",",
"value",
"|",
"duplicated",
"[",
"key",
"]",
"=",
"value",
".",
"dup",
... | Copies the class level hash of encrypted attributes with virtual attribute names as keys
and their corresponding options as values to the instance | [
"Copies",
"the",
"class",
"level",
"hash",
"of",
"encrypted",
"attributes",
"with",
"virtual",
"attribute",
"names",
"as",
"keys",
"and",
"their",
"corresponding",
"options",
"as",
"values",
"to",
"the",
"instance"
] | 11df93aef14c661dd0c03169d382a0412f93124e | https://github.com/attr-encrypted/attr_encrypted/blob/11df93aef14c661dd0c03169d382a0412f93124e/lib/attr_encrypted.rb#L358-L364 |
12,202 | fazibear/colorize | lib/colorize/instance_methods.rb | Colorize.InstanceMethods.colorize | def colorize(params)
return self if self.class.disable_colorization
require_windows_libs
scan_for_colors.inject(self.class.new) do |str, match|
colors_from_params(match, params)
defaults_colors(match)
str << "\033[#{match[0]};#{match[1]};#{match[2]}m#{match[3]}\033[0m"
en... | ruby | def colorize(params)
return self if self.class.disable_colorization
require_windows_libs
scan_for_colors.inject(self.class.new) do |str, match|
colors_from_params(match, params)
defaults_colors(match)
str << "\033[#{match[0]};#{match[1]};#{match[2]}m#{match[3]}\033[0m"
en... | [
"def",
"colorize",
"(",
"params",
")",
"return",
"self",
"if",
"self",
".",
"class",
".",
"disable_colorization",
"require_windows_libs",
"scan_for_colors",
".",
"inject",
"(",
"self",
".",
"class",
".",
"new",
")",
"do",
"|",
"str",
",",
"match",
"|",
"co... | Change color of string
Examples:
puts "This is blue".colorize(:blue)
puts "This is light blue".colorize(:light_blue)
puts "This is also blue".colorize(:color => :blue)
puts "This is light blue with red background".colorize(:color => :light_blue, :background => :red)
puts "This is light blue with red b... | [
"Change",
"color",
"of",
"string"
] | 526654c6d7dfc5483b70184d06b994eba8359514 | https://github.com/fazibear/colorize/blob/526654c6d7dfc5483b70184d06b994eba8359514/lib/colorize/instance_methods.rb#L19-L27 |
12,203 | fazibear/colorize | lib/colorize/instance_methods.rb | Colorize.InstanceMethods.colorized? | def colorized?
scan_for_colors.inject([]) do |colors, match|
colors << match.tap(&:pop)
end.flatten.compact.any?
end | ruby | def colorized?
scan_for_colors.inject([]) do |colors, match|
colors << match.tap(&:pop)
end.flatten.compact.any?
end | [
"def",
"colorized?",
"scan_for_colors",
".",
"inject",
"(",
"[",
"]",
")",
"do",
"|",
"colors",
",",
"match",
"|",
"colors",
"<<",
"match",
".",
"tap",
"(",
":pop",
")",
"end",
".",
"flatten",
".",
"compact",
".",
"any?",
"end"
] | Return true if string is colorized | [
"Return",
"true",
"if",
"string",
"is",
"colorized"
] | 526654c6d7dfc5483b70184d06b994eba8359514 | https://github.com/fazibear/colorize/blob/526654c6d7dfc5483b70184d06b994eba8359514/lib/colorize/instance_methods.rb#L41-L45 |
12,204 | fazibear/colorize | lib/colorize/instance_methods.rb | Colorize.InstanceMethods.colors_from_params | def colors_from_params(match, params)
case params
when Hash then colors_from_hash(match, params)
when Symbol then color_from_symbol(match, params)
end
end | ruby | def colors_from_params(match, params)
case params
when Hash then colors_from_hash(match, params)
when Symbol then color_from_symbol(match, params)
end
end | [
"def",
"colors_from_params",
"(",
"match",
",",
"params",
")",
"case",
"params",
"when",
"Hash",
"then",
"colors_from_hash",
"(",
"match",
",",
"params",
")",
"when",
"Symbol",
"then",
"color_from_symbol",
"(",
"match",
",",
"params",
")",
"end",
"end"
] | Set color from params | [
"Set",
"color",
"from",
"params"
] | 526654c6d7dfc5483b70184d06b994eba8359514 | https://github.com/fazibear/colorize/blob/526654c6d7dfc5483b70184d06b994eba8359514/lib/colorize/instance_methods.rb#L61-L66 |
12,205 | fazibear/colorize | lib/colorize/instance_methods.rb | Colorize.InstanceMethods.colors_from_hash | def colors_from_hash(match, hash)
match[0] = mode(hash[:mode]) if mode(hash[:mode])
match[1] = color(hash[:color]) if color(hash[:color])
match[2] = background_color(hash[:background]) if background_color(hash[:background])
end | ruby | def colors_from_hash(match, hash)
match[0] = mode(hash[:mode]) if mode(hash[:mode])
match[1] = color(hash[:color]) if color(hash[:color])
match[2] = background_color(hash[:background]) if background_color(hash[:background])
end | [
"def",
"colors_from_hash",
"(",
"match",
",",
"hash",
")",
"match",
"[",
"0",
"]",
"=",
"mode",
"(",
"hash",
"[",
":mode",
"]",
")",
"if",
"mode",
"(",
"hash",
"[",
":mode",
"]",
")",
"match",
"[",
"1",
"]",
"=",
"color",
"(",
"hash",
"[",
":co... | Set colors from params hash | [
"Set",
"colors",
"from",
"params",
"hash"
] | 526654c6d7dfc5483b70184d06b994eba8359514 | https://github.com/fazibear/colorize/blob/526654c6d7dfc5483b70184d06b994eba8359514/lib/colorize/instance_methods.rb#L71-L75 |
12,206 | fazibear/colorize | lib/colorize/class_methods.rb | Colorize.ClassMethods.color_methods | def color_methods
colors.each do |key|
next if key == :default
define_method key do
colorize(:color => key)
end
define_method "on_#{key}" do
colorize(:background => key)
end
end
end | ruby | def color_methods
colors.each do |key|
next if key == :default
define_method key do
colorize(:color => key)
end
define_method "on_#{key}" do
colorize(:background => key)
end
end
end | [
"def",
"color_methods",
"colors",
".",
"each",
"do",
"|",
"key",
"|",
"next",
"if",
"key",
"==",
":default",
"define_method",
"key",
"do",
"colorize",
"(",
":color",
"=>",
"key",
")",
"end",
"define_method",
"\"on_#{key}\"",
"do",
"colorize",
"(",
":backgrou... | Generate color and on_color methods | [
"Generate",
"color",
"and",
"on_color",
"methods"
] | 526654c6d7dfc5483b70184d06b994eba8359514 | https://github.com/fazibear/colorize/blob/526654c6d7dfc5483b70184d06b994eba8359514/lib/colorize/class_methods.rb#L93-L105 |
12,207 | ruby/racc | lib/racc/grammar_file_parser.rb | Racc.GrammarFileParser.parse_user_code | def parse_user_code
epilogue = @scanner.epilogue
return unless epilogue.text
epilogue.text.scan(/^----([^\n\r]*)(?:\n|\r\n|\r)(.*?)(?=^----|\Z)/m) do
label = canonical_label($~[1])
range = epilogue.slice($~.begin(2), $~.end(2))
add_user_code(label, range)
end
end | ruby | def parse_user_code
epilogue = @scanner.epilogue
return unless epilogue.text
epilogue.text.scan(/^----([^\n\r]*)(?:\n|\r\n|\r)(.*?)(?=^----|\Z)/m) do
label = canonical_label($~[1])
range = epilogue.slice($~.begin(2), $~.end(2))
add_user_code(label, range)
end
end | [
"def",
"parse_user_code",
"epilogue",
"=",
"@scanner",
".",
"epilogue",
"return",
"unless",
"epilogue",
".",
"text",
"epilogue",
".",
"text",
".",
"scan",
"(",
"/",
"\\n",
"\\r",
"\\n",
"\\r",
"\\n",
"\\r",
"\\Z",
"/m",
")",
"do",
"label",
"=",
"canonica... | User Code Block | [
"User",
"Code",
"Block"
] | d3244edfa11dd6e86e43f570c6444d41c7e3552a | https://github.com/ruby/racc/blob/d3244edfa11dd6e86e43f570c6444d41c7e3552a/lib/racc/grammar_file_parser.rb#L255-L263 |
12,208 | ruby/racc | lib/racc/simulated_automaton.rb | Racc.SimulatedAutomaton.consume! | def consume!(token)
return self if @error
action = @state.action[token] || @state.defact
case action
when Shift
@sstack.push(@state)
@state = action.goto_state
shifted(token)
when Reduce
reduce_by!(action.rule)
consume!(token)
when Accept
... | ruby | def consume!(token)
return self if @error
action = @state.action[token] || @state.defact
case action
when Shift
@sstack.push(@state)
@state = action.goto_state
shifted(token)
when Reduce
reduce_by!(action.rule)
consume!(token)
when Accept
... | [
"def",
"consume!",
"(",
"token",
")",
"return",
"self",
"if",
"@error",
"action",
"=",
"@state",
".",
"action",
"[",
"token",
"]",
"||",
"@state",
".",
"defact",
"case",
"action",
"when",
"Shift",
"@sstack",
".",
"push",
"(",
"@state",
")",
"@state",
"... | consuming a terminal may set off a series of reduces before the terminal
is shifted | [
"consuming",
"a",
"terminal",
"may",
"set",
"off",
"a",
"series",
"of",
"reduces",
"before",
"the",
"terminal",
"is",
"shifted"
] | d3244edfa11dd6e86e43f570c6444d41c7e3552a | https://github.com/ruby/racc/blob/d3244edfa11dd6e86e43f570c6444d41c7e3552a/lib/racc/simulated_automaton.rb#L36-L58 |
12,209 | ruby/racc | lib/racc/state.rb | Racc.States.path | def path(state, rule)
rule.symbols.each_with_object([]) do |tok, path|
goto = state.gotos[tok]
path << goto
state = goto.to_state
end
end | ruby | def path(state, rule)
rule.symbols.each_with_object([]) do |tok, path|
goto = state.gotos[tok]
path << goto
state = goto.to_state
end
end | [
"def",
"path",
"(",
"state",
",",
"rule",
")",
"rule",
".",
"symbols",
".",
"each_with_object",
"(",
"[",
"]",
")",
"do",
"|",
"tok",
",",
"path",
"|",
"goto",
"=",
"state",
".",
"gotos",
"[",
"tok",
"]",
"path",
"<<",
"goto",
"state",
"=",
"goto... | Sequence of state transitions which would be taken when starting
from 'state', then following the RHS of 'rule' right to the end | [
"Sequence",
"of",
"state",
"transitions",
"which",
"would",
"be",
"taken",
"when",
"starting",
"from",
"state",
"then",
"following",
"the",
"RHS",
"of",
"rule",
"right",
"to",
"the",
"end"
] | d3244edfa11dd6e86e43f570c6444d41c7e3552a | https://github.com/ruby/racc/blob/d3244edfa11dd6e86e43f570c6444d41c7e3552a/lib/racc/state.rb#L208-L214 |
12,210 | ruby/racc | lib/racc/state.rb | Racc.States.walk_graph | def walk_graph(bitmap, graph)
index = Array.new(graph.size, nil)
traversed = Set.new
graph.nodes do |node|
next if traversed.include?(node)
traverse(node, traversed, index, [], bitmap, graph)
end
end | ruby | def walk_graph(bitmap, graph)
index = Array.new(graph.size, nil)
traversed = Set.new
graph.nodes do |node|
next if traversed.include?(node)
traverse(node, traversed, index, [], bitmap, graph)
end
end | [
"def",
"walk_graph",
"(",
"bitmap",
",",
"graph",
")",
"index",
"=",
"Array",
".",
"new",
"(",
"graph",
".",
"size",
",",
"nil",
")",
"traversed",
"=",
"Set",
".",
"new",
"graph",
".",
"nodes",
"do",
"|",
"node",
"|",
"next",
"if",
"traversed",
"."... | traverse a directed graph
each entry in 'bitmap' corresponds to a graph node
after the traversal, the bitmap for each node will be the union of its
original value, and ALL the values for all the nodes which are reachable
from it | [
"traverse",
"a",
"directed",
"graph",
"each",
"entry",
"in",
"bitmap",
"corresponds",
"to",
"a",
"graph",
"node",
"after",
"the",
"traversal",
"the",
"bitmap",
"for",
"each",
"node",
"will",
"be",
"the",
"union",
"of",
"its",
"original",
"value",
"and",
"A... | d3244edfa11dd6e86e43f570c6444d41c7e3552a | https://github.com/ruby/racc/blob/d3244edfa11dd6e86e43f570c6444d41c7e3552a/lib/racc/state.rb#L221-L229 |
12,211 | ruby/racc | lib/racc/state.rb | Racc.States.detailed_transition_graph | def detailed_transition_graph
@dtgraph ||= each_with_object(Graph::Labeled.new(size)) do |s, graph|
s.gotos.each do |tok, goto|
path = if tok.terminal?
[tok]
else
actions_to_reach_reduce(s.ident, tok)
end
graph.add_vector(s.ident, goto.to_sta... | ruby | def detailed_transition_graph
@dtgraph ||= each_with_object(Graph::Labeled.new(size)) do |s, graph|
s.gotos.each do |tok, goto|
path = if tok.terminal?
[tok]
else
actions_to_reach_reduce(s.ident, tok)
end
graph.add_vector(s.ident, goto.to_sta... | [
"def",
"detailed_transition_graph",
"@dtgraph",
"||=",
"each_with_object",
"(",
"Graph",
"::",
"Labeled",
".",
"new",
"(",
"size",
")",
")",
"do",
"|",
"s",
",",
"graph",
"|",
"s",
".",
"gotos",
".",
"each",
"do",
"|",
"tok",
",",
"goto",
"|",
"path",
... | Like `transition_graph`, but rather than vectors labeled with NTs, we
have vectors labeled with the shortest series of terminals and reduce
operations which could take us through the same transition | [
"Like",
"transition_graph",
"but",
"rather",
"than",
"vectors",
"labeled",
"with",
"NTs",
"we",
"have",
"vectors",
"labeled",
"with",
"the",
"shortest",
"series",
"of",
"terminals",
"and",
"reduce",
"operations",
"which",
"could",
"take",
"us",
"through",
"the",... | d3244edfa11dd6e86e43f570c6444d41c7e3552a | https://github.com/ruby/racc/blob/d3244edfa11dd6e86e43f570c6444d41c7e3552a/lib/racc/state.rb#L430-L441 |
12,212 | ruby/racc | lib/racc/grammar.rb | Racc.Rule.replace | def replace(placeholder, actual)
raise 'wrong placeholder' if placeholder != @target
@target.heads.delete(ptrs[0]) if @target
@target = actual
@target.heads << @ptrs[0]
@symbols.map! { |s| s == placeholder ? actual : s }
end | ruby | def replace(placeholder, actual)
raise 'wrong placeholder' if placeholder != @target
@target.heads.delete(ptrs[0]) if @target
@target = actual
@target.heads << @ptrs[0]
@symbols.map! { |s| s == placeholder ? actual : s }
end | [
"def",
"replace",
"(",
"placeholder",
",",
"actual",
")",
"raise",
"'wrong placeholder'",
"if",
"placeholder",
"!=",
"@target",
"@target",
".",
"heads",
".",
"delete",
"(",
"ptrs",
"[",
"0",
"]",
")",
"if",
"@target",
"@target",
"=",
"actual",
"@target",
"... | sometimes a Rule is instantiated before the target is actually known
it may be given a "placeholder" target first, which is later replaced
with the real one | [
"sometimes",
"a",
"Rule",
"is",
"instantiated",
"before",
"the",
"target",
"is",
"actually",
"known",
"it",
"may",
"be",
"given",
"a",
"placeholder",
"target",
"first",
"which",
"is",
"later",
"replaced",
"with",
"the",
"real",
"one"
] | d3244edfa11dd6e86e43f570c6444d41c7e3552a | https://github.com/ruby/racc/blob/d3244edfa11dd6e86e43f570c6444d41c7e3552a/lib/racc/grammar.rb#L470-L476 |
12,213 | ruby/racc | lib/racc/grammar.rb | Racc.Sym.expand | def expand
@expand ||= Racc.set_closure(@heads.dup) do |ptr|
if (sym = ptr.symbol) && sym.nonterminal?
sym.heads
end
end.freeze
end | ruby | def expand
@expand ||= Racc.set_closure(@heads.dup) do |ptr|
if (sym = ptr.symbol) && sym.nonterminal?
sym.heads
end
end.freeze
end | [
"def",
"expand",
"@expand",
"||=",
"Racc",
".",
"set_closure",
"(",
"@heads",
".",
"dup",
")",
"do",
"|",
"ptr",
"|",
"if",
"(",
"sym",
"=",
"ptr",
".",
"symbol",
")",
"&&",
"sym",
".",
"nonterminal?",
"sym",
".",
"heads",
"end",
"end",
".",
"freez... | If an instance of this NT comes next, then what rules could we be
starting? | [
"If",
"an",
"instance",
"of",
"this",
"NT",
"comes",
"next",
"then",
"what",
"rules",
"could",
"we",
"be",
"starting?"
] | d3244edfa11dd6e86e43f570c6444d41c7e3552a | https://github.com/ruby/racc/blob/d3244edfa11dd6e86e43f570c6444d41c7e3552a/lib/racc/grammar.rb#L738-L744 |
12,214 | refile/refile | lib/refile/rails/attachment_helper.rb | Refile.AttachmentHelper.attachment_image_tag | def attachment_image_tag(record, name, *args, fallback: nil, host: nil, prefix: nil, format: nil, **options)
file = record && record.public_send(name)
classes = ["attachment", (record.class.model_name.singular if record), name, *options[:class]]
if file
image_tag(attachment_url(record, name, ... | ruby | def attachment_image_tag(record, name, *args, fallback: nil, host: nil, prefix: nil, format: nil, **options)
file = record && record.public_send(name)
classes = ["attachment", (record.class.model_name.singular if record), name, *options[:class]]
if file
image_tag(attachment_url(record, name, ... | [
"def",
"attachment_image_tag",
"(",
"record",
",",
"name",
",",
"*",
"args",
",",
"fallback",
":",
"nil",
",",
"host",
":",
"nil",
",",
"prefix",
":",
"nil",
",",
"format",
":",
"nil",
",",
"**",
"options",
")",
"file",
"=",
"record",
"&&",
"record",... | Generates an image tag for the given attachment, adding appropriate
classes and optionally falling back to the given fallback image if there
is no file attached.
Returns `nil` if there is no file attached and no fallback specified.
@param [String] fallback The path to an image asset to be used a... | [
"Generates",
"an",
"image",
"tag",
"for",
"the",
"given",
"attachment",
"adding",
"appropriate",
"classes",
"and",
"optionally",
"falling",
"back",
"to",
"the",
"given",
"fallback",
"image",
"if",
"there",
"is",
"no",
"file",
"attached",
"."
] | e910f5ca5a9060c307bd0a5e813f1fec73219ed5 | https://github.com/refile/refile/blob/e910f5ca5a9060c307bd0a5e813f1fec73219ed5/lib/refile/rails/attachment_helper.rb#L51-L61 |
12,215 | refile/refile | lib/refile/rails/attachment_helper.rb | Refile.AttachmentHelper.attachment_cache_field | def attachment_cache_field(object_name, method, object:, **options)
options[:data] ||= {}
options[:data][:reference] ||= SecureRandom.hex
attacher_value = object.send("#{method}_data")
hidden_options = {
multiple: options[:multiple],
value: attacher_value.try(:to_json),
... | ruby | def attachment_cache_field(object_name, method, object:, **options)
options[:data] ||= {}
options[:data][:reference] ||= SecureRandom.hex
attacher_value = object.send("#{method}_data")
hidden_options = {
multiple: options[:multiple],
value: attacher_value.try(:to_json),
... | [
"def",
"attachment_cache_field",
"(",
"object_name",
",",
"method",
",",
"object",
":",
",",
"**",
"options",
")",
"options",
"[",
":data",
"]",
"||=",
"{",
"}",
"options",
"[",
":data",
"]",
"[",
":reference",
"]",
"||=",
"SecureRandom",
".",
"hex",
"at... | Generates a hidden form field which tracks the id of the file in the cache
before it is permanently stored.
@param object_name The name of the object to generate a field for
@param method The name of the field
@param [Hash] options
@option options [Object] object S... | [
"Generates",
"a",
"hidden",
"form",
"field",
"which",
"tracks",
"the",
"id",
"of",
"the",
"file",
"in",
"the",
"cache",
"before",
"it",
"is",
"permanently",
"stored",
"."
] | e910f5ca5a9060c307bd0a5e813f1fec73219ed5 | https://github.com/refile/refile/blob/e910f5ca5a9060c307bd0a5e813f1fec73219ed5/lib/refile/rails/attachment_helper.rb#L105-L122 |
12,216 | refile/refile | lib/refile/attachment.rb | Refile.Attachment.accepts_attachments_for | def accepts_attachments_for(collection_name, collection_class:, accessor_prefix:, attachment: :file, append: false)
include MultipleAttachments.new(
collection_name,
collection_class: collection_class,
name: accessor_prefix,
attachment: attachment,
append: append
)
... | ruby | def accepts_attachments_for(collection_name, collection_class:, accessor_prefix:, attachment: :file, append: false)
include MultipleAttachments.new(
collection_name,
collection_class: collection_class,
name: accessor_prefix,
attachment: attachment,
append: append
)
... | [
"def",
"accepts_attachments_for",
"(",
"collection_name",
",",
"collection_class",
":",
",",
"accessor_prefix",
":",
",",
"attachment",
":",
":file",
",",
"append",
":",
"false",
")",
"include",
"MultipleAttachments",
".",
"new",
"(",
"collection_name",
",",
"coll... | Macro which generates accessors in pure Ruby classes for assigning
multiple attachments at once. This is primarily useful together with
multiple file uploads. There is also an Active Record version of
this macro.
The name of the generated accessors will be the name of the association
(represented by an attribute ... | [
"Macro",
"which",
"generates",
"accessors",
"in",
"pure",
"Ruby",
"classes",
"for",
"assigning",
"multiple",
"attachments",
"at",
"once",
".",
"This",
"is",
"primarily",
"useful",
"together",
"with",
"multiple",
"file",
"uploads",
".",
"There",
"is",
"also",
"... | e910f5ca5a9060c307bd0a5e813f1fec73219ed5 | https://github.com/refile/refile/blob/e910f5ca5a9060c307bd0a5e813f1fec73219ed5/lib/refile/attachment.rb#L156-L164 |
12,217 | refile/refile | lib/refile/file.rb | Refile.File.download | def download
return io if io.is_a?(Tempfile)
Tempfile.new(id, binmode: true).tap do |tempfile|
IO.copy_stream(io, tempfile)
tempfile.rewind
tempfile.fsync
end
end | ruby | def download
return io if io.is_a?(Tempfile)
Tempfile.new(id, binmode: true).tap do |tempfile|
IO.copy_stream(io, tempfile)
tempfile.rewind
tempfile.fsync
end
end | [
"def",
"download",
"return",
"io",
"if",
"io",
".",
"is_a?",
"(",
"Tempfile",
")",
"Tempfile",
".",
"new",
"(",
"id",
",",
"binmode",
":",
"true",
")",
".",
"tap",
"do",
"|",
"tempfile",
"|",
"IO",
".",
"copy_stream",
"(",
"io",
",",
"tempfile",
")... | Downloads the file to a Tempfile on disk and returns this tempfile.
@example
file = backend.upload(StringIO.new("hello"))
tempfile = file.download
File.read(tempfile.path) # => "hello"
@return [Tempfile] a tempfile with the file's content | [
"Downloads",
"the",
"file",
"to",
"a",
"Tempfile",
"on",
"disk",
"and",
"returns",
"this",
"tempfile",
"."
] | e910f5ca5a9060c307bd0a5e813f1fec73219ed5 | https://github.com/refile/refile/blob/e910f5ca5a9060c307bd0a5e813f1fec73219ed5/lib/refile/file.rb#L69-L77 |
12,218 | vcr/vcr | lib/vcr/structs.rb | VCR.Response.to_hash | def to_hash
{
'status' => status.to_hash,
'headers' => headers,
'body' => serializable_body,
'http_version' => http_version
}.tap do |hash|
hash['adapter_metadata'] = adapter_metadata unless adapter_metadata.empty?
end
end | ruby | def to_hash
{
'status' => status.to_hash,
'headers' => headers,
'body' => serializable_body,
'http_version' => http_version
}.tap do |hash|
hash['adapter_metadata'] = adapter_metadata unless adapter_metadata.empty?
end
end | [
"def",
"to_hash",
"{",
"'status'",
"=>",
"status",
".",
"to_hash",
",",
"'headers'",
"=>",
"headers",
",",
"'body'",
"=>",
"serializable_body",
",",
"'http_version'",
"=>",
"http_version",
"}",
".",
"tap",
"do",
"|",
"hash",
"|",
"hash",
"[",
"'adapter_metad... | Builds a serializable hash from the response data.
@return [Hash] hash that represents this response
and can be easily serialized.
@see Response.from_hash | [
"Builds",
"a",
"serializable",
"hash",
"from",
"the",
"response",
"data",
"."
] | 945ca793a4b25c7ffc406b9fd7da1e94cbbb8141 | https://github.com/vcr/vcr/blob/945ca793a4b25c7ffc406b9fd7da1e94cbbb8141/lib/vcr/structs.rb#L345-L354 |
12,219 | vcr/vcr | lib/vcr/configuration.rb | VCR.Configuration.around_http_request | def around_http_request(*filters, &block)
unless VCR.fibers_available?
raise Errors::NotSupportedError.new \
"VCR::Configuration#around_http_request requires fibers, " +
"which are not available on your ruby intepreter."
end
fibers = {}
fiber_errors = {}
hook_a... | ruby | def around_http_request(*filters, &block)
unless VCR.fibers_available?
raise Errors::NotSupportedError.new \
"VCR::Configuration#around_http_request requires fibers, " +
"which are not available on your ruby intepreter."
end
fibers = {}
fiber_errors = {}
hook_a... | [
"def",
"around_http_request",
"(",
"*",
"filters",
",",
"&",
"block",
")",
"unless",
"VCR",
".",
"fibers_available?",
"raise",
"Errors",
"::",
"NotSupportedError",
".",
"new",
"\"VCR::Configuration#around_http_request requires fibers, \"",
"+",
"\"which are not available on... | Adds a callback that will be executed around each HTTP request.
@example
VCR.configure do |c|
c.around_http_request(lambda {|r| r.uri =~ /api.geocoder.com/}) do |request|
# extract an address like "1700 E Pine St, Seattle, WA"
# from a query like "address=1700+E+Pine+St%2C+Seattle%2C+WA"
addre... | [
"Adds",
"a",
"callback",
"that",
"will",
"be",
"executed",
"around",
"each",
"HTTP",
"request",
"."
] | 945ca793a4b25c7ffc406b9fd7da1e94cbbb8141 | https://github.com/vcr/vcr/blob/945ca793a4b25c7ffc406b9fd7da1e94cbbb8141/lib/vcr/configuration.rb#L395-L414 |
12,220 | floere/phony | lib/phony/dsl.rb | Phony.DSL.country | def country country_code, definition, options = {}
return unless Phony.config.load?(country_code)
definition.with country_code, options
Phony::CountryCodes.instance.add country_code, definition
end | ruby | def country country_code, definition, options = {}
return unless Phony.config.load?(country_code)
definition.with country_code, options
Phony::CountryCodes.instance.add country_code, definition
end | [
"def",
"country",
"country_code",
",",
"definition",
",",
"options",
"=",
"{",
"}",
"return",
"unless",
"Phony",
".",
"config",
".",
"load?",
"(",
"country_code",
")",
"definition",
".",
"with",
"country_code",
",",
"options",
"Phony",
"::",
"CountryCodes",
... | Define a country's rules.
Use the other DSL methods to define the country's rules.
@param [String] country_code The country code of the country.
@param [Phony::CountryCodes] definition Rules for this country.
@return Undefined.
@example Add a country with country code 27.
country '27', # CC, followed by rul... | [
"Define",
"a",
"country",
"s",
"rules",
"."
] | 9ca50743499cf478a25fdb927bcdacd29d2c90c7 | https://github.com/floere/phony/blob/9ca50743499cf478a25fdb927bcdacd29d2c90c7/lib/phony/dsl.rb#L43-L48 |
12,221 | floere/phony | lib/phony/dsl.rb | Phony.DSL.fixed | def fixed length, options = {}
options[:zero] = true if options[:zero].nil?
NationalSplitters::Fixed.instance_for length, options
end | ruby | def fixed length, options = {}
options[:zero] = true if options[:zero].nil?
NationalSplitters::Fixed.instance_for length, options
end | [
"def",
"fixed",
"length",
",",
"options",
"=",
"{",
"}",
"options",
"[",
":zero",
"]",
"=",
"true",
"if",
"options",
"[",
":zero",
"]",
".",
"nil?",
"NationalSplitters",
"::",
"Fixed",
".",
"instance_for",
"length",
",",
"options",
"end"
] | National matcher & splitters.
By default, a fixed length NDC
uses a zero prefix when formatted
with format :national.
@param [Fixnum] length The length of the fixed length NDC.
@param [Hash] options An options hash (set zero: false to not add a zero on format :national).
@return NationalSplitters::Fixed A fixe... | [
"National",
"matcher",
"&",
"splitters",
"."
] | 9ca50743499cf478a25fdb927bcdacd29d2c90c7 | https://github.com/floere/phony/blob/9ca50743499cf478a25fdb927bcdacd29d2c90c7/lib/phony/dsl.rb#L110-L113 |
12,222 | floere/phony | lib/phony/country_codes.rb | Phony.CountryCodes.add | def add country_code, country
country_code = country_code.to_s
optimized_country_code_access = country_code.size
@countries ||= {}
@countries[optimized_country_code_access] ||= {}
@countries[optimized_country_code_access][country_code] = country
end | ruby | def add country_code, country
country_code = country_code.to_s
optimized_country_code_access = country_code.size
@countries ||= {}
@countries[optimized_country_code_access] ||= {}
@countries[optimized_country_code_access][country_code] = country
end | [
"def",
"add",
"country_code",
",",
"country",
"country_code",
"=",
"country_code",
".",
"to_s",
"optimized_country_code_access",
"=",
"country_code",
".",
"size",
"@countries",
"||=",
"{",
"}",
"@countries",
"[",
"optimized_country_code_access",
"]",
"||=",
"{",
"}"... | Add the given country to the mapping under the
given country code. | [
"Add",
"the",
"given",
"country",
"to",
"the",
"mapping",
"under",
"the",
"given",
"country",
"code",
"."
] | 9ca50743499cf478a25fdb927bcdacd29d2c90c7 | https://github.com/floere/phony/blob/9ca50743499cf478a25fdb927bcdacd29d2c90c7/lib/phony/country_codes.rb#L21-L28 |
12,223 | floere/phony | lib/phony/country_codes.rb | Phony.CountryCodes.split | def split number
# Split the number into country, cc, and national part.
country, cc, national_number = partial_split number
# Split the national number into ndc and local part.
_, ndc, *local = country.split national_number
[cc, ndc, *local]
end | ruby | def split number
# Split the number into country, cc, and national part.
country, cc, national_number = partial_split number
# Split the national number into ndc and local part.
_, ndc, *local = country.split national_number
[cc, ndc, *local]
end | [
"def",
"split",
"number",
"# Split the number into country, cc, and national part.",
"country",
",",
"cc",
",",
"national_number",
"=",
"partial_split",
"number",
"# Split the national number into ndc and local part.",
"_",
",",
"ndc",
",",
"*",
"local",
"=",
"country",
"."... | Splits this number into cc, ndc and locally split number parts. | [
"Splits",
"this",
"number",
"into",
"cc",
"ndc",
"and",
"locally",
"split",
"number",
"parts",
"."
] | 9ca50743499cf478a25fdb927bcdacd29d2c90c7 | https://github.com/floere/phony/blob/9ca50743499cf478a25fdb927bcdacd29d2c90c7/lib/phony/country_codes.rb#L75-L83 |
12,224 | floere/phony | lib/phony/country_codes.rb | Phony.CountryCodes.format | def format number, options = {}
country, _, national_number = partial_split number
country.format national_number, options
end | ruby | def format number, options = {}
country, _, national_number = partial_split number
country.format national_number, options
end | [
"def",
"format",
"number",
",",
"options",
"=",
"{",
"}",
"country",
",",
"_",
",",
"national_number",
"=",
"partial_split",
"number",
"country",
".",
"format",
"national_number",
",",
"options",
"end"
] | Format the number. | [
"Format",
"the",
"number",
"."
] | 9ca50743499cf478a25fdb927bcdacd29d2c90c7 | https://github.com/floere/phony/blob/9ca50743499cf478a25fdb927bcdacd29d2c90c7/lib/phony/country_codes.rb#L87-L90 |
12,225 | floere/phony | lib/phony/country_codes.rb | Phony.CountryCodes.plausible? | def plausible? number, hints = {}
normalized = clean number
# False if it fails the basic check.
#
return false unless (4..16) === normalized.size
country, cc, rest = partial_split normalized
# Country code plausible?
#
cc_needed = hints[:cc]
return false if cc_n... | ruby | def plausible? number, hints = {}
normalized = clean number
# False if it fails the basic check.
#
return false unless (4..16) === normalized.size
country, cc, rest = partial_split normalized
# Country code plausible?
#
cc_needed = hints[:cc]
return false if cc_n... | [
"def",
"plausible?",
"number",
",",
"hints",
"=",
"{",
"}",
"normalized",
"=",
"clean",
"number",
"# False if it fails the basic check.",
"#",
"return",
"false",
"unless",
"(",
"4",
"..",
"16",
")",
"===",
"normalized",
".",
"size",
"country",
",",
"cc",
","... | Is this number plausible? | [
"Is",
"this",
"number",
"plausible?"
] | 9ca50743499cf478a25fdb927bcdacd29d2c90c7 | https://github.com/floere/phony/blob/9ca50743499cf478a25fdb927bcdacd29d2c90c7/lib/phony/country_codes.rb#L95-L114 |
12,226 | floere/phony | lib/phony/country_codes.rb | Phony.CountryCodes.vanity? | def vanity? number
country, _, national = partial_split number
country.vanity? national
end | ruby | def vanity? number
country, _, national = partial_split number
country.vanity? national
end | [
"def",
"vanity?",
"number",
"country",
",",
"_",
",",
"national",
"=",
"partial_split",
"number",
"country",
".",
"vanity?",
"national",
"end"
] | Is the given number a vanity number? | [
"Is",
"the",
"given",
"number",
"a",
"vanity",
"number?"
] | 9ca50743499cf478a25fdb927bcdacd29d2c90c7 | https://github.com/floere/phony/blob/9ca50743499cf478a25fdb927bcdacd29d2c90c7/lib/phony/country_codes.rb#L118-L121 |
12,227 | floere/phony | lib/phony/country_codes.rb | Phony.CountryCodes.partial_split | def partial_split number
cc = ''
1.upto(3) do |i|
cc << number.slice!(0..0)
country = countries[i][cc]
return [country, cc, number] if country
end
# This line is never reached as CCs are in prefix code.
end | ruby | def partial_split number
cc = ''
1.upto(3) do |i|
cc << number.slice!(0..0)
country = countries[i][cc]
return [country, cc, number] if country
end
# This line is never reached as CCs are in prefix code.
end | [
"def",
"partial_split",
"number",
"cc",
"=",
"''",
"1",
".",
"upto",
"(",
"3",
")",
"do",
"|",
"i",
"|",
"cc",
"<<",
"number",
".",
"slice!",
"(",
"0",
"..",
"0",
")",
"country",
"=",
"countries",
"[",
"i",
"]",
"[",
"cc",
"]",
"return",
"[",
... | Split off the country and the cc, and also return the national number part. | [
"Split",
"off",
"the",
"country",
"and",
"the",
"cc",
"and",
"also",
"return",
"the",
"national",
"number",
"part",
"."
] | 9ca50743499cf478a25fdb927bcdacd29d2c90c7 | https://github.com/floere/phony/blob/9ca50743499cf478a25fdb927bcdacd29d2c90c7/lib/phony/country_codes.rb#L140-L148 |
12,228 | floere/phony | lib/phony/country.rb | Phony.Country.split | def split national_number
_, trunk, ndc, *rest = internal_split national_number
[trunk, ndc, *rest]
end | ruby | def split national_number
_, trunk, ndc, *rest = internal_split national_number
[trunk, ndc, *rest]
end | [
"def",
"split",
"national_number",
"_",
",",
"trunk",
",",
"ndc",
",",
"*",
"rest",
"=",
"internal_split",
"national_number",
"[",
"trunk",
",",
"ndc",
",",
"rest",
"]",
"end"
] | A number is split with the code handlers as given in the initializer.
Note: If the ndc is nil, it will not return it.
@return [Trunk, String (ndc), Array<String> (national pieces)] | [
"A",
"number",
"is",
"split",
"with",
"the",
"code",
"handlers",
"as",
"given",
"in",
"the",
"initializer",
"."
] | 9ca50743499cf478a25fdb927bcdacd29d2c90c7 | https://github.com/floere/phony/blob/9ca50743499cf478a25fdb927bcdacd29d2c90c7/lib/phony/country.rb#L55-L58 |
12,229 | floere/phony | lib/phony/country.rb | Phony.Country.format | def format national_number, options = {}
type = options[:format] || @format
space = options[:spaces] || @space || @@default_space
local_space = options[:local_spaces] || @local_space || space || @@default_local_space
parentheses = options[:parentheses... | ruby | def format national_number, options = {}
type = options[:format] || @format
space = options[:spaces] || @space || @@default_space
local_space = options[:local_spaces] || @local_space || space || @@default_local_space
parentheses = options[:parentheses... | [
"def",
"format",
"national_number",
",",
"options",
"=",
"{",
"}",
"type",
"=",
"options",
"[",
":format",
"]",
"||",
"@format",
"space",
"=",
"options",
"[",
":spaces",
"]",
"||",
"@space",
"||",
"@@default_space",
"local_space",
"=",
"options",
"[",
":lo... | Format the number, given the national part of it. | [
"Format",
"the",
"number",
"given",
"the",
"national",
"part",
"of",
"it",
"."
] | 9ca50743499cf478a25fdb927bcdacd29d2c90c7 | https://github.com/floere/phony/blob/9ca50743499cf478a25fdb927bcdacd29d2c90c7/lib/phony/country.rb#L77-L90 |
12,230 | floere/phony | lib/phony/country.rb | Phony.Country.normalize | def normalize national_number
clean! national_number
normalized = @codes.reduce national_number do |number, code|
result = code.normalize number
break result if result
number
end
normalized
end | ruby | def normalize national_number
clean! national_number
normalized = @codes.reduce national_number do |number, code|
result = code.normalize number
break result if result
number
end
normalized
end | [
"def",
"normalize",
"national_number",
"clean!",
"national_number",
"normalized",
"=",
"@codes",
".",
"reduce",
"national_number",
"do",
"|",
"number",
",",
"code",
"|",
"result",
"=",
"code",
".",
"normalize",
"number",
"break",
"result",
"if",
"result",
"numbe... | Removes 0s from partially normalized numbers
such as 410443643533.
Example:
410443643533 -> 41443643533
In some cases it doesn't, like Italy. | [
"Removes",
"0s",
"from",
"partially",
"normalized",
"numbers",
"such",
"as",
"410443643533",
"."
] | 9ca50743499cf478a25fdb927bcdacd29d2c90c7 | https://github.com/floere/phony/blob/9ca50743499cf478a25fdb927bcdacd29d2c90c7/lib/phony/country.rb#L159-L167 |
12,231 | floere/phony | lib/phony/country.rb | Phony.Country.plausible? | def plausible? rest, hints = {}
local, _, ndc, *rest = internal_split rest
# Element based checking.
#
# Note: ndc == false means the country has none.
#
return false if ndc.nil?
return false if ndc && ndc.empty?
return false if @invalid_ndcs && @invalid_ndcs === ndc
... | ruby | def plausible? rest, hints = {}
local, _, ndc, *rest = internal_split rest
# Element based checking.
#
# Note: ndc == false means the country has none.
#
return false if ndc.nil?
return false if ndc && ndc.empty?
return false if @invalid_ndcs && @invalid_ndcs === ndc
... | [
"def",
"plausible?",
"rest",
",",
"hints",
"=",
"{",
"}",
"local",
",",
"_",
",",
"ndc",
",",
"*",
"rest",
"=",
"internal_split",
"rest",
"# Element based checking.",
"#",
"# Note: ndc == false means the country has none.",
"#",
"return",
"false",
"if",
"ndc",
"... | Tests for plausibility of this national number. | [
"Tests",
"for",
"plausibility",
"of",
"this",
"national",
"number",
"."
] | 9ca50743499cf478a25fdb927bcdacd29d2c90c7 | https://github.com/floere/phony/blob/9ca50743499cf478a25fdb927bcdacd29d2c90c7/lib/phony/country.rb#L171-L198 |
12,232 | mongodb/mongoid | lib/mongoid/criteria.rb | Mongoid.Criteria.merge! | def merge!(other)
criteria = other.to_criteria
selector.merge!(criteria.selector)
options.merge!(criteria.options)
self.documents = criteria.documents.dup unless criteria.documents.empty?
self.scoping_options = criteria.scoping_options
self.inclusions = (inclusions + criteria.inclusi... | ruby | def merge!(other)
criteria = other.to_criteria
selector.merge!(criteria.selector)
options.merge!(criteria.options)
self.documents = criteria.documents.dup unless criteria.documents.empty?
self.scoping_options = criteria.scoping_options
self.inclusions = (inclusions + criteria.inclusi... | [
"def",
"merge!",
"(",
"other",
")",
"criteria",
"=",
"other",
".",
"to_criteria",
"selector",
".",
"merge!",
"(",
"criteria",
".",
"selector",
")",
"options",
".",
"merge!",
"(",
"criteria",
".",
"options",
")",
"self",
".",
"documents",
"=",
"criteria",
... | Merge the other criteria into this one.
@example Merge another criteria into this criteria.
criteria.merge(Person.where(name: "bob"))
@param [ Criteria ] other The criteria to merge in.
@return [ Criteria ] The merged criteria.
@since 3.0.0 | [
"Merge",
"the",
"other",
"criteria",
"into",
"this",
"one",
"."
] | 56976e32610f4c2450882b0bfe14da099f0703f4 | https://github.com/mongodb/mongoid/blob/56976e32610f4c2450882b0bfe14da099f0703f4/lib/mongoid/criteria.rb#L242-L250 |
12,233 | mongodb/mongoid | lib/mongoid/criteria.rb | Mongoid.Criteria.only | def only(*args)
return clone if args.flatten.empty?
args = args.flatten
if (args & Fields::IDS).empty?
args.unshift(:_id)
end
if klass.hereditary?
super(*args.push(:_type))
else
super(*args)
end
end | ruby | def only(*args)
return clone if args.flatten.empty?
args = args.flatten
if (args & Fields::IDS).empty?
args.unshift(:_id)
end
if klass.hereditary?
super(*args.push(:_type))
else
super(*args)
end
end | [
"def",
"only",
"(",
"*",
"args",
")",
"return",
"clone",
"if",
"args",
".",
"flatten",
".",
"empty?",
"args",
"=",
"args",
".",
"flatten",
"if",
"(",
"args",
"&",
"Fields",
"::",
"IDS",
")",
".",
"empty?",
"args",
".",
"unshift",
"(",
":_id",
")",
... | Overriden to include _type in the fields.
@example Limit the fields returned from the database.
Band.only(:name)
@param [ Array<Symbol> ] args The names of the fields.
@return [ Criteria ] The cloned criteria.
@since 1.0.0 | [
"Overriden",
"to",
"include",
"_type",
"in",
"the",
"fields",
"."
] | 56976e32610f4c2450882b0bfe14da099f0703f4 | https://github.com/mongodb/mongoid/blob/56976e32610f4c2450882b0bfe14da099f0703f4/lib/mongoid/criteria.rb#L287-L298 |
12,234 | mongodb/mongoid | lib/mongoid/criteria.rb | Mongoid.Criteria.read | def read(value = nil)
clone.tap do |criteria|
criteria.options.merge!(read: value)
end
end | ruby | def read(value = nil)
clone.tap do |criteria|
criteria.options.merge!(read: value)
end
end | [
"def",
"read",
"(",
"value",
"=",
"nil",
")",
"clone",
".",
"tap",
"do",
"|",
"criteria",
"|",
"criteria",
".",
"options",
".",
"merge!",
"(",
"read",
":",
"value",
")",
"end",
"end"
] | Set the read preference for the criteria.
@example Set the read preference.
criteria.read(mode: :primary_preferred)
@param [ Hash ] value The mode preference.
@return [ Criteria ] The cloned criteria.
@since 5.0.0 | [
"Set",
"the",
"read",
"preference",
"for",
"the",
"criteria",
"."
] | 56976e32610f4c2450882b0bfe14da099f0703f4 | https://github.com/mongodb/mongoid/blob/56976e32610f4c2450882b0bfe14da099f0703f4/lib/mongoid/criteria.rb#L310-L314 |
12,235 | mongodb/mongoid | lib/mongoid/criteria.rb | Mongoid.Criteria.respond_to? | def respond_to?(name, include_private = false)
super || klass.respond_to?(name) || CHECK.respond_to?(name, include_private)
end | ruby | def respond_to?(name, include_private = false)
super || klass.respond_to?(name) || CHECK.respond_to?(name, include_private)
end | [
"def",
"respond_to?",
"(",
"name",
",",
"include_private",
"=",
"false",
")",
"super",
"||",
"klass",
".",
"respond_to?",
"(",
"name",
")",
"||",
"CHECK",
".",
"respond_to?",
"(",
"name",
",",
"include_private",
")",
"end"
] | Returns true if criteria responds to the given method.
@example Does the criteria respond to the method?
crtiteria.respond_to?(:each)
@param [ Symbol ] name The name of the class method on the +Document+.
@param [ true, false ] include_private Whether to include privates.
@return [ true, false ] If the criter... | [
"Returns",
"true",
"if",
"criteria",
"responds",
"to",
"the",
"given",
"method",
"."
] | 56976e32610f4c2450882b0bfe14da099f0703f4 | https://github.com/mongodb/mongoid/blob/56976e32610f4c2450882b0bfe14da099f0703f4/lib/mongoid/criteria.rb#L340-L342 |
12,236 | mongodb/mongoid | lib/mongoid/criteria.rb | Mongoid.Criteria.check_for_missing_documents! | def check_for_missing_documents!(result, ids)
if (result.size < ids.size) && Mongoid.raise_not_found_error
raise Errors::DocumentNotFound.new(klass, ids, ids - result.map(&:_id))
end
end | ruby | def check_for_missing_documents!(result, ids)
if (result.size < ids.size) && Mongoid.raise_not_found_error
raise Errors::DocumentNotFound.new(klass, ids, ids - result.map(&:_id))
end
end | [
"def",
"check_for_missing_documents!",
"(",
"result",
",",
"ids",
")",
"if",
"(",
"result",
".",
"size",
"<",
"ids",
".",
"size",
")",
"&&",
"Mongoid",
".",
"raise_not_found_error",
"raise",
"Errors",
"::",
"DocumentNotFound",
".",
"new",
"(",
"klass",
",",
... | Are documents in the query missing, and are we configured to raise an
error?
@api private
@example Check for missing documents.
criteria.check_for_missing_documents!([], [ 1 ])
@param [ Array<Document> ] result The result.
@param [ Array<Object> ] ids The ids.
@raise [ Errors::DocumentNotFound ] If none ar... | [
"Are",
"documents",
"in",
"the",
"query",
"missing",
"and",
"are",
"we",
"configured",
"to",
"raise",
"an",
"error?"
] | 56976e32610f4c2450882b0bfe14da099f0703f4 | https://github.com/mongodb/mongoid/blob/56976e32610f4c2450882b0bfe14da099f0703f4/lib/mongoid/criteria.rb#L459-L463 |
12,237 | mongodb/mongoid | lib/mongoid/criteria.rb | Mongoid.Criteria.initialize_copy | def initialize_copy(other)
@inclusions = other.inclusions.dup
@scoping_options = other.scoping_options
@documents = other.documents.dup
@context = nil
super
end | ruby | def initialize_copy(other)
@inclusions = other.inclusions.dup
@scoping_options = other.scoping_options
@documents = other.documents.dup
@context = nil
super
end | [
"def",
"initialize_copy",
"(",
"other",
")",
"@inclusions",
"=",
"other",
".",
"inclusions",
".",
"dup",
"@scoping_options",
"=",
"other",
".",
"scoping_options",
"@documents",
"=",
"other",
".",
"documents",
".",
"dup",
"@context",
"=",
"nil",
"super",
"end"
... | Clone or dup the current +Criteria+. This will return a new criteria with
the selector, options, klass, embedded options, etc intact.
@api private
@example Clone a criteria.
criteria.clone
@example Dup a criteria.
criteria.dup
@param [ Criteria ] other The criteria getting cloned.
@return [ nil ] nil.
... | [
"Clone",
"or",
"dup",
"the",
"current",
"+",
"Criteria",
"+",
".",
"This",
"will",
"return",
"a",
"new",
"criteria",
"with",
"the",
"selector",
"options",
"klass",
"embedded",
"options",
"etc",
"intact",
"."
] | 56976e32610f4c2450882b0bfe14da099f0703f4 | https://github.com/mongodb/mongoid/blob/56976e32610f4c2450882b0bfe14da099f0703f4/lib/mongoid/criteria.rb#L481-L487 |
12,238 | mongodb/mongoid | lib/mongoid/criteria.rb | Mongoid.Criteria.type_selection | def type_selection
klasses = klass._types
if klasses.size > 1
{ _type: { "$in" => klass._types }}
else
{ _type: klass._types[0] }
end
end | ruby | def type_selection
klasses = klass._types
if klasses.size > 1
{ _type: { "$in" => klass._types }}
else
{ _type: klass._types[0] }
end
end | [
"def",
"type_selection",
"klasses",
"=",
"klass",
".",
"_types",
"if",
"klasses",
".",
"size",
">",
"1",
"{",
"_type",
":",
"{",
"\"$in\"",
"=>",
"klass",
".",
"_types",
"}",
"}",
"else",
"{",
"_type",
":",
"klass",
".",
"_types",
"[",
"0",
"]",
"}... | Get the selector for type selection.
@api private
@example Get a type selection hash.
criteria.type_selection
@return [ Hash ] The type selection.
@since 3.0.3 | [
"Get",
"the",
"selector",
"for",
"type",
"selection",
"."
] | 56976e32610f4c2450882b0bfe14da099f0703f4 | https://github.com/mongodb/mongoid/blob/56976e32610f4c2450882b0bfe14da099f0703f4/lib/mongoid/criteria.rb#L552-L559 |
12,239 | mongodb/mongoid | lib/mongoid/positional.rb | Mongoid.Positional.positionally | def positionally(selector, operations, processed = {})
if selector.size == 1 || selector.values.any? { |val| val.nil? }
return operations
end
keys = selector.keys.map{ |m| m.sub('._id','') } - ['_id']
keys = keys.sort_by { |s| s.length*-1 }
process_operations(keys, operations, proc... | ruby | def positionally(selector, operations, processed = {})
if selector.size == 1 || selector.values.any? { |val| val.nil? }
return operations
end
keys = selector.keys.map{ |m| m.sub('._id','') } - ['_id']
keys = keys.sort_by { |s| s.length*-1 }
process_operations(keys, operations, proc... | [
"def",
"positionally",
"(",
"selector",
",",
"operations",
",",
"processed",
"=",
"{",
"}",
")",
"if",
"selector",
".",
"size",
"==",
"1",
"||",
"selector",
".",
"values",
".",
"any?",
"{",
"|",
"val",
"|",
"val",
".",
"nil?",
"}",
"return",
"operati... | Takes the provided selector and atomic operations and replaces the
indexes of the embedded documents with the positional operator when
needed.
@note The only time we can accurately know when to use the positional
operator is at the exact time we are going to persist something. So
we can tell by the selector t... | [
"Takes",
"the",
"provided",
"selector",
"and",
"atomic",
"operations",
"and",
"replaces",
"the",
"indexes",
"of",
"the",
"embedded",
"documents",
"with",
"the",
"positional",
"operator",
"when",
"needed",
"."
] | 56976e32610f4c2450882b0bfe14da099f0703f4 | https://github.com/mongodb/mongoid/blob/56976e32610f4c2450882b0bfe14da099f0703f4/lib/mongoid/positional.rb#L37-L44 |
12,240 | mongodb/mongoid | lib/mongoid/touchable.rb | Mongoid.Touchable.define_touchable! | def define_touchable!(association)
name = association.name
method_name = define_relation_touch_method(name, association)
association.inverse_class.tap do |klass|
klass.after_save method_name
klass.after_destroy method_name
klass.after_touch method_name
end
end | ruby | def define_touchable!(association)
name = association.name
method_name = define_relation_touch_method(name, association)
association.inverse_class.tap do |klass|
klass.after_save method_name
klass.after_destroy method_name
klass.after_touch method_name
end
end | [
"def",
"define_touchable!",
"(",
"association",
")",
"name",
"=",
"association",
".",
"name",
"method_name",
"=",
"define_relation_touch_method",
"(",
"name",
",",
"association",
")",
"association",
".",
"inverse_class",
".",
"tap",
"do",
"|",
"klass",
"|",
"kla... | Add the association to the touchable associations if the touch option was
provided.
@example Add the touchable.
Model.define_touchable!(assoc)
@param [ Association ] association The association metadata.
@return [ Class ] The model class.
@since 3.0.0 | [
"Add",
"the",
"association",
"to",
"the",
"touchable",
"associations",
"if",
"the",
"touch",
"option",
"was",
"provided",
"."
] | 56976e32610f4c2450882b0bfe14da099f0703f4 | https://github.com/mongodb/mongoid/blob/56976e32610f4c2450882b0bfe14da099f0703f4/lib/mongoid/touchable.rb#L55-L63 |
12,241 | mongodb/mongoid | lib/mongoid/loggable.rb | Mongoid.Loggable.default_logger | def default_logger
logger = Logger.new($stdout)
logger.level = Mongoid::Config.log_level
logger
end | ruby | def default_logger
logger = Logger.new($stdout)
logger.level = Mongoid::Config.log_level
logger
end | [
"def",
"default_logger",
"logger",
"=",
"Logger",
".",
"new",
"(",
"$stdout",
")",
"logger",
".",
"level",
"=",
"Mongoid",
"::",
"Config",
".",
"log_level",
"logger",
"end"
] | Gets the default Mongoid logger - stdout.
@api private
@example Get the default logger.
Loggable.default_logger
@return [ Logger ] The default logger.
@since 3.0.0 | [
"Gets",
"the",
"default",
"Mongoid",
"logger",
"-",
"stdout",
"."
] | 56976e32610f4c2450882b0bfe14da099f0703f4 | https://github.com/mongodb/mongoid/blob/56976e32610f4c2450882b0bfe14da099f0703f4/lib/mongoid/loggable.rb#L50-L54 |
12,242 | mongodb/mongoid | lib/mongoid/copyable.rb | Mongoid.Copyable.process_localized_attributes | def process_localized_attributes(klass, attrs)
klass.localized_fields.keys.each do |name|
if value = attrs.delete(name)
attrs["#{name}_translations"] = value
end
end
klass.embedded_relations.each do |_, association|
next unless attrs.present? && attrs[association.key]... | ruby | def process_localized_attributes(klass, attrs)
klass.localized_fields.keys.each do |name|
if value = attrs.delete(name)
attrs["#{name}_translations"] = value
end
end
klass.embedded_relations.each do |_, association|
next unless attrs.present? && attrs[association.key]... | [
"def",
"process_localized_attributes",
"(",
"klass",
",",
"attrs",
")",
"klass",
".",
"localized_fields",
".",
"keys",
".",
"each",
"do",
"|",
"name",
"|",
"if",
"value",
"=",
"attrs",
".",
"delete",
"(",
"name",
")",
"attrs",
"[",
"\"#{name}_translations\""... | When cloning, if the document has localized fields we need to ensure they
are properly processed in the clone.
@api private
@example Process localized attributes.
model.process_localized_attributes(attributes)
@param [ Hash ] attrs The attributes.
@since 3.0.20 | [
"When",
"cloning",
"if",
"the",
"document",
"has",
"localized",
"fields",
"we",
"need",
"to",
"ensure",
"they",
"are",
"properly",
"processed",
"in",
"the",
"clone",
"."
] | 56976e32610f4c2450882b0bfe14da099f0703f4 | https://github.com/mongodb/mongoid/blob/56976e32610f4c2450882b0bfe14da099f0703f4/lib/mongoid/copyable.rb#L67-L85 |
12,243 | mongodb/mongoid | lib/mongoid/shardable.rb | Mongoid.Shardable.shard_key_selector | def shard_key_selector
selector = {}
shard_key_fields.each do |field|
selector[field.to_s] = new_record? ? send(field) : attribute_was(field)
end
selector
end | ruby | def shard_key_selector
selector = {}
shard_key_fields.each do |field|
selector[field.to_s] = new_record? ? send(field) : attribute_was(field)
end
selector
end | [
"def",
"shard_key_selector",
"selector",
"=",
"{",
"}",
"shard_key_fields",
".",
"each",
"do",
"|",
"field",
"|",
"selector",
"[",
"field",
".",
"to_s",
"]",
"=",
"new_record?",
"?",
"send",
"(",
"field",
")",
":",
"attribute_was",
"(",
"field",
")",
"en... | Get the document selector with the defined shard keys.
@example Get the selector for the shard keys.
person.shard_key_selector
@return [ Hash ] The shard key selector.
@since 2.0.0 | [
"Get",
"the",
"document",
"selector",
"with",
"the",
"defined",
"shard",
"keys",
"."
] | 56976e32610f4c2450882b0bfe14da099f0703f4 | https://github.com/mongodb/mongoid/blob/56976e32610f4c2450882b0bfe14da099f0703f4/lib/mongoid/shardable.rb#L38-L44 |
12,244 | mongodb/mongoid | lib/mongoid/reloadable.rb | Mongoid.Reloadable.reload | def reload
reloaded = _reload
if Mongoid.raise_not_found_error && reloaded.empty?
raise Errors::DocumentNotFound.new(self.class, _id, _id)
end
@attributes = reloaded
@attributes_before_type_cast = {}
changed_attributes.clear
reset_readonly
apply_defaults
rel... | ruby | def reload
reloaded = _reload
if Mongoid.raise_not_found_error && reloaded.empty?
raise Errors::DocumentNotFound.new(self.class, _id, _id)
end
@attributes = reloaded
@attributes_before_type_cast = {}
changed_attributes.clear
reset_readonly
apply_defaults
rel... | [
"def",
"reload",
"reloaded",
"=",
"_reload",
"if",
"Mongoid",
".",
"raise_not_found_error",
"&&",
"reloaded",
".",
"empty?",
"raise",
"Errors",
"::",
"DocumentNotFound",
".",
"new",
"(",
"self",
".",
"class",
",",
"_id",
",",
"_id",
")",
"end",
"@attributes"... | Reloads the +Document+ attributes from the database. If the document has
not been saved then an error will get raised if the configuration option
was set. This can reload root documents or embedded documents.
@example Reload the document.
person.reload
@raise [ Errors::DocumentNotFound ] If the document was de... | [
"Reloads",
"the",
"+",
"Document",
"+",
"attributes",
"from",
"the",
"database",
".",
"If",
"the",
"document",
"has",
"not",
"been",
"saved",
"then",
"an",
"error",
"will",
"get",
"raised",
"if",
"the",
"configuration",
"option",
"was",
"set",
".",
"This",... | 56976e32610f4c2450882b0bfe14da099f0703f4 | https://github.com/mongodb/mongoid/blob/56976e32610f4c2450882b0bfe14da099f0703f4/lib/mongoid/reloadable.rb#L22-L36 |
12,245 | mongodb/mongoid | lib/mongoid/reloadable.rb | Mongoid.Reloadable.reload_root_document | def reload_root_document
{}.merge(collection.find({ _id: _id }, session: _session).read(mode: :primary).first || {})
end | ruby | def reload_root_document
{}.merge(collection.find({ _id: _id }, session: _session).read(mode: :primary).first || {})
end | [
"def",
"reload_root_document",
"{",
"}",
".",
"merge",
"(",
"collection",
".",
"find",
"(",
"{",
"_id",
":",
"_id",
"}",
",",
"session",
":",
"_session",
")",
".",
"read",
"(",
"mode",
":",
":primary",
")",
".",
"first",
"||",
"{",
"}",
")",
"end"
... | Reload the root document.
@example Reload the document.
document.reload_root_document
@return [ Hash ] The reloaded attributes.
@since 2.3.2 | [
"Reload",
"the",
"root",
"document",
"."
] | 56976e32610f4c2450882b0bfe14da099f0703f4 | https://github.com/mongodb/mongoid/blob/56976e32610f4c2450882b0bfe14da099f0703f4/lib/mongoid/reloadable.rb#L61-L63 |
12,246 | mongodb/mongoid | lib/mongoid/reloadable.rb | Mongoid.Reloadable.reload_embedded_document | def reload_embedded_document
extract_embedded_attributes({}.merge(
collection(_root).find(_id: _root._id).read(mode: :primary).first
))
end | ruby | def reload_embedded_document
extract_embedded_attributes({}.merge(
collection(_root).find(_id: _root._id).read(mode: :primary).first
))
end | [
"def",
"reload_embedded_document",
"extract_embedded_attributes",
"(",
"{",
"}",
".",
"merge",
"(",
"collection",
"(",
"_root",
")",
".",
"find",
"(",
"_id",
":",
"_root",
".",
"_id",
")",
".",
"read",
"(",
"mode",
":",
":primary",
")",
".",
"first",
")"... | Reload the embedded document.
@example Reload the document.
document.reload_embedded_document
@return [ Hash ] The reloaded attributes.
@since 2.3.2 | [
"Reload",
"the",
"embedded",
"document",
"."
] | 56976e32610f4c2450882b0bfe14da099f0703f4 | https://github.com/mongodb/mongoid/blob/56976e32610f4c2450882b0bfe14da099f0703f4/lib/mongoid/reloadable.rb#L73-L77 |
12,247 | mongodb/mongoid | lib/mongoid/reloadable.rb | Mongoid.Reloadable.extract_embedded_attributes | def extract_embedded_attributes(attributes)
atomic_position.split(".").inject(attributes) do |attrs, part|
attrs = attrs[part =~ /\d/ ? part.to_i : part]
attrs
end
end | ruby | def extract_embedded_attributes(attributes)
atomic_position.split(".").inject(attributes) do |attrs, part|
attrs = attrs[part =~ /\d/ ? part.to_i : part]
attrs
end
end | [
"def",
"extract_embedded_attributes",
"(",
"attributes",
")",
"atomic_position",
".",
"split",
"(",
"\".\"",
")",
".",
"inject",
"(",
"attributes",
")",
"do",
"|",
"attrs",
",",
"part",
"|",
"attrs",
"=",
"attrs",
"[",
"part",
"=~",
"/",
"\\d",
"/",
"?",... | Extract only the desired embedded document from the attributes.
@example Extract the embedded document.
document.extract_embedded_attributes(attributes)
@param [ Hash ] attributes The document in the db.
@return [ Hash ] The document's extracted attributes.
@since 2.3.2 | [
"Extract",
"only",
"the",
"desired",
"embedded",
"document",
"from",
"the",
"attributes",
"."
] | 56976e32610f4c2450882b0bfe14da099f0703f4 | https://github.com/mongodb/mongoid/blob/56976e32610f4c2450882b0bfe14da099f0703f4/lib/mongoid/reloadable.rb#L89-L94 |
12,248 | mongodb/mongoid | lib/mongoid/attributes.rb | Mongoid.Attributes.attribute_present? | def attribute_present?(name)
attribute = read_raw_attribute(name)
!attribute.blank? || attribute == false
rescue ActiveModel::MissingAttributeError
false
end | ruby | def attribute_present?(name)
attribute = read_raw_attribute(name)
!attribute.blank? || attribute == false
rescue ActiveModel::MissingAttributeError
false
end | [
"def",
"attribute_present?",
"(",
"name",
")",
"attribute",
"=",
"read_raw_attribute",
"(",
"name",
")",
"!",
"attribute",
".",
"blank?",
"||",
"attribute",
"==",
"false",
"rescue",
"ActiveModel",
"::",
"MissingAttributeError",
"false",
"end"
] | Determine if an attribute is present.
@example Is the attribute present?
person.attribute_present?("title")
@param [ String, Symbol ] name The name of the attribute.
@return [ true, false ] True if present, false if not.
@since 1.0.0 | [
"Determine",
"if",
"an",
"attribute",
"is",
"present",
"."
] | 56976e32610f4c2450882b0bfe14da099f0703f4 | https://github.com/mongodb/mongoid/blob/56976e32610f4c2450882b0bfe14da099f0703f4/lib/mongoid/attributes.rb#L32-L37 |
12,249 | mongodb/mongoid | lib/mongoid/attributes.rb | Mongoid.Attributes.read_attribute | def read_attribute(name)
field = fields[name.to_s]
raw = read_raw_attribute(name)
field ? field.demongoize(raw) : raw
end | ruby | def read_attribute(name)
field = fields[name.to_s]
raw = read_raw_attribute(name)
field ? field.demongoize(raw) : raw
end | [
"def",
"read_attribute",
"(",
"name",
")",
"field",
"=",
"fields",
"[",
"name",
".",
"to_s",
"]",
"raw",
"=",
"read_raw_attribute",
"(",
"name",
")",
"field",
"?",
"field",
".",
"demongoize",
"(",
"raw",
")",
":",
"raw",
"end"
] | Read a value from the document attributes. If the value does not exist
it will return nil.
@example Read an attribute.
person.read_attribute(:title)
@example Read an attribute (alternate syntax.)
person[:title]
@param [ String, Symbol ] name The name of the attribute to get.
@return [ Object ] The value ... | [
"Read",
"a",
"value",
"from",
"the",
"document",
"attributes",
".",
"If",
"the",
"value",
"does",
"not",
"exist",
"it",
"will",
"return",
"nil",
"."
] | 56976e32610f4c2450882b0bfe14da099f0703f4 | https://github.com/mongodb/mongoid/blob/56976e32610f4c2450882b0bfe14da099f0703f4/lib/mongoid/attributes.rb#L95-L99 |
12,250 | mongodb/mongoid | lib/mongoid/attributes.rb | Mongoid.Attributes.read_attribute_before_type_cast | def read_attribute_before_type_cast(name)
attr = name.to_s
if attributes_before_type_cast.key?(attr)
attributes_before_type_cast[attr]
else
read_raw_attribute(attr)
end
end | ruby | def read_attribute_before_type_cast(name)
attr = name.to_s
if attributes_before_type_cast.key?(attr)
attributes_before_type_cast[attr]
else
read_raw_attribute(attr)
end
end | [
"def",
"read_attribute_before_type_cast",
"(",
"name",
")",
"attr",
"=",
"name",
".",
"to_s",
"if",
"attributes_before_type_cast",
".",
"key?",
"(",
"attr",
")",
"attributes_before_type_cast",
"[",
"attr",
"]",
"else",
"read_raw_attribute",
"(",
"attr",
")",
"end"... | Read a value from the attributes before type cast. If the value has not
yet been assigned then this will return the attribute's existing value
using read_raw_attribute.
@example Read an attribute before type cast.
person.read_attribute_before_type_cast(:price)
@param [ String, Symbol ] name The name of the att... | [
"Read",
"a",
"value",
"from",
"the",
"attributes",
"before",
"type",
"cast",
".",
"If",
"the",
"value",
"has",
"not",
"yet",
"been",
"assigned",
"then",
"this",
"will",
"return",
"the",
"attribute",
"s",
"existing",
"value",
"using",
"read_raw_attribute",
".... | 56976e32610f4c2450882b0bfe14da099f0703f4 | https://github.com/mongodb/mongoid/blob/56976e32610f4c2450882b0bfe14da099f0703f4/lib/mongoid/attributes.rb#L115-L122 |
12,251 | mongodb/mongoid | lib/mongoid/attributes.rb | Mongoid.Attributes.remove_attribute | def remove_attribute(name)
as_writable_attribute!(name) do |access|
_assigning do
attribute_will_change!(access)
delayed_atomic_unsets[atomic_attribute_name(access)] = [] unless new_record?
attributes.delete(access)
end
end
end | ruby | def remove_attribute(name)
as_writable_attribute!(name) do |access|
_assigning do
attribute_will_change!(access)
delayed_atomic_unsets[atomic_attribute_name(access)] = [] unless new_record?
attributes.delete(access)
end
end
end | [
"def",
"remove_attribute",
"(",
"name",
")",
"as_writable_attribute!",
"(",
"name",
")",
"do",
"|",
"access",
"|",
"_assigning",
"do",
"attribute_will_change!",
"(",
"access",
")",
"delayed_atomic_unsets",
"[",
"atomic_attribute_name",
"(",
"access",
")",
"]",
"="... | Remove a value from the +Document+ attributes. If the value does not exist
it will fail gracefully.
@example Remove the attribute.
person.remove_attribute(:title)
@param [ String, Symbol ] name The name of the attribute to remove.
@raise [ Errors::ReadonlyAttribute ] If the field cannot be removed due
to b... | [
"Remove",
"a",
"value",
"from",
"the",
"+",
"Document",
"+",
"attributes",
".",
"If",
"the",
"value",
"does",
"not",
"exist",
"it",
"will",
"fail",
"gracefully",
"."
] | 56976e32610f4c2450882b0bfe14da099f0703f4 | https://github.com/mongodb/mongoid/blob/56976e32610f4c2450882b0bfe14da099f0703f4/lib/mongoid/attributes.rb#L136-L144 |
12,252 | mongodb/mongoid | lib/mongoid/attributes.rb | Mongoid.Attributes.write_attribute | def write_attribute(name, value)
access = database_field_name(name)
if attribute_writable?(access)
_assigning do
validate_attribute_value(access, value)
localized = fields[access].try(:localized?)
attributes_before_type_cast[name.to_s] = value
typed_value = ty... | ruby | def write_attribute(name, value)
access = database_field_name(name)
if attribute_writable?(access)
_assigning do
validate_attribute_value(access, value)
localized = fields[access].try(:localized?)
attributes_before_type_cast[name.to_s] = value
typed_value = ty... | [
"def",
"write_attribute",
"(",
"name",
",",
"value",
")",
"access",
"=",
"database_field_name",
"(",
"name",
")",
"if",
"attribute_writable?",
"(",
"access",
")",
"_assigning",
"do",
"validate_attribute_value",
"(",
"access",
",",
"value",
")",
"localized",
"=",... | Write a single attribute to the document attribute hash. This will
also fire the before and after update callbacks, and perform any
necessary typecasting.
@example Write the attribute.
person.write_attribute(:title, "Mr.")
@example Write the attribute (alternate syntax.)
person[:title] = "Mr."
@param [ St... | [
"Write",
"a",
"single",
"attribute",
"to",
"the",
"document",
"attribute",
"hash",
".",
"This",
"will",
"also",
"fire",
"the",
"before",
"and",
"after",
"update",
"callbacks",
"and",
"perform",
"any",
"necessary",
"typecasting",
"."
] | 56976e32610f4c2450882b0bfe14da099f0703f4 | https://github.com/mongodb/mongoid/blob/56976e32610f4c2450882b0bfe14da099f0703f4/lib/mongoid/attributes.rb#L160-L180 |
12,253 | mongodb/mongoid | lib/mongoid/attributes.rb | Mongoid.Attributes.attribute_missing? | def attribute_missing?(name)
selection = __selected_fields
return false unless selection
field = fields[name]
(selection.values.first == 0 && selection_excluded?(name, selection, field)) ||
(selection.values.first == 1 && !selection_included?(name, selection, field))
end | ruby | def attribute_missing?(name)
selection = __selected_fields
return false unless selection
field = fields[name]
(selection.values.first == 0 && selection_excluded?(name, selection, field)) ||
(selection.values.first == 1 && !selection_included?(name, selection, field))
end | [
"def",
"attribute_missing?",
"(",
"name",
")",
"selection",
"=",
"__selected_fields",
"return",
"false",
"unless",
"selection",
"field",
"=",
"fields",
"[",
"name",
"]",
"(",
"selection",
".",
"values",
".",
"first",
"==",
"0",
"&&",
"selection_excluded?",
"("... | Determine if the attribute is missing from the document, due to loading
it from the database with missing fields.
@example Is the attribute missing?
document.attribute_missing?("test")
@param [ String ] name The name of the attribute.
@return [ true, false ] If the attribute is missing.
@since 4.0.0 | [
"Determine",
"if",
"the",
"attribute",
"is",
"missing",
"from",
"the",
"document",
"due",
"to",
"loading",
"it",
"from",
"the",
"database",
"with",
"missing",
"fields",
"."
] | 56976e32610f4c2450882b0bfe14da099f0703f4 | https://github.com/mongodb/mongoid/blob/56976e32610f4c2450882b0bfe14da099f0703f4/lib/mongoid/attributes.rb#L232-L238 |
12,254 | mongodb/mongoid | lib/mongoid/attributes.rb | Mongoid.Attributes.typed_value_for | def typed_value_for(key, value)
fields.key?(key) ? fields[key].mongoize(value) : value.mongoize
end | ruby | def typed_value_for(key, value)
fields.key?(key) ? fields[key].mongoize(value) : value.mongoize
end | [
"def",
"typed_value_for",
"(",
"key",
",",
"value",
")",
"fields",
".",
"key?",
"(",
"key",
")",
"?",
"fields",
"[",
"key",
"]",
".",
"mongoize",
"(",
"value",
")",
":",
"value",
".",
"mongoize",
"end"
] | Return the typecasted value for a field.
@example Get the value typecasted.
person.typed_value_for(:title, :sir)
@param [ String, Symbol ] key The field name.
@param [ Object ] value The uncast value.
@return [ Object ] The cast value.
@since 1.0.0 | [
"Return",
"the",
"typecasted",
"value",
"for",
"a",
"field",
"."
] | 56976e32610f4c2450882b0bfe14da099f0703f4 | https://github.com/mongodb/mongoid/blob/56976e32610f4c2450882b0bfe14da099f0703f4/lib/mongoid/attributes.rb#L287-L289 |
12,255 | mongodb/mongoid | lib/mongoid/attributes.rb | Mongoid.Attributes.validate_attribute_value | def validate_attribute_value(access, value)
return unless fields[access] && value
validatable_types = [ Hash, Array ]
if validatable_types.include? fields[access].type
unless value.is_a? fields[access].type
raise Mongoid::Errors::InvalidValue.new(fields[access].type, value.class)
... | ruby | def validate_attribute_value(access, value)
return unless fields[access] && value
validatable_types = [ Hash, Array ]
if validatable_types.include? fields[access].type
unless value.is_a? fields[access].type
raise Mongoid::Errors::InvalidValue.new(fields[access].type, value.class)
... | [
"def",
"validate_attribute_value",
"(",
"access",
",",
"value",
")",
"return",
"unless",
"fields",
"[",
"access",
"]",
"&&",
"value",
"validatable_types",
"=",
"[",
"Hash",
",",
"Array",
"]",
"if",
"validatable_types",
".",
"include?",
"fields",
"[",
"access",... | Validates an attribute value. This provides validation checking if
the value is valid for given a field.
For now, only Hash and Array fields are validated.
@param [ String, Symbol ] access The name of the attribute to validate.
@param [ Object ] value The to be validated.
@since 3.0.10 | [
"Validates",
"an",
"attribute",
"value",
".",
"This",
"provides",
"validation",
"checking",
"if",
"the",
"value",
"is",
"valid",
"for",
"given",
"a",
"field",
".",
"For",
"now",
"only",
"Hash",
"and",
"Array",
"fields",
"are",
"validated",
"."
] | 56976e32610f4c2450882b0bfe14da099f0703f4 | https://github.com/mongodb/mongoid/blob/56976e32610f4c2450882b0bfe14da099f0703f4/lib/mongoid/attributes.rb#L349-L357 |
12,256 | mongodb/mongoid | lib/mongoid/factory.rb | Mongoid.Factory.build | def build(klass, attributes = nil)
attributes ||= {}
type = attributes[TYPE] || attributes[TYPE.to_sym]
if type && klass._types.include?(type)
type.constantize.new(attributes)
else
klass.new(attributes)
end
end | ruby | def build(klass, attributes = nil)
attributes ||= {}
type = attributes[TYPE] || attributes[TYPE.to_sym]
if type && klass._types.include?(type)
type.constantize.new(attributes)
else
klass.new(attributes)
end
end | [
"def",
"build",
"(",
"klass",
",",
"attributes",
"=",
"nil",
")",
"attributes",
"||=",
"{",
"}",
"type",
"=",
"attributes",
"[",
"TYPE",
"]",
"||",
"attributes",
"[",
"TYPE",
".",
"to_sym",
"]",
"if",
"type",
"&&",
"klass",
".",
"_types",
".",
"inclu... | Builds a new +Document+ from the supplied attributes.
@example Build the document.
Mongoid::Factory.build(Person, { "name" => "Durran" })
@param [ Class ] klass The class to instantiate from if _type is not present.
@param [ Hash ] attributes The document attributes.
@return [ Document ] The instantiated docu... | [
"Builds",
"a",
"new",
"+",
"Document",
"+",
"from",
"the",
"supplied",
"attributes",
"."
] | 56976e32610f4c2450882b0bfe14da099f0703f4 | https://github.com/mongodb/mongoid/blob/56976e32610f4c2450882b0bfe14da099f0703f4/lib/mongoid/factory.rb#L20-L28 |
12,257 | mongodb/mongoid | lib/mongoid/factory.rb | Mongoid.Factory.from_db | def from_db(klass, attributes = nil, criteria = nil, selected_fields = nil)
if criteria
selected_fields ||= criteria.options[:fields]
end
type = (attributes || {})[TYPE]
if type.blank?
obj = klass.instantiate(attributes, selected_fields)
if criteria && criteria.associatio... | ruby | def from_db(klass, attributes = nil, criteria = nil, selected_fields = nil)
if criteria
selected_fields ||= criteria.options[:fields]
end
type = (attributes || {})[TYPE]
if type.blank?
obj = klass.instantiate(attributes, selected_fields)
if criteria && criteria.associatio... | [
"def",
"from_db",
"(",
"klass",
",",
"attributes",
"=",
"nil",
",",
"criteria",
"=",
"nil",
",",
"selected_fields",
"=",
"nil",
")",
"if",
"criteria",
"selected_fields",
"||=",
"criteria",
".",
"options",
"[",
":fields",
"]",
"end",
"type",
"=",
"(",
"at... | Builds a new +Document+ from the supplied attributes loaded from the
database.
If a criteria object is given, it is used in two ways:
1. If the criteria has a list of fields specified via #only,
only those fields are populated in the returned document.
2. If the criteria has a referencing association (i.e., th... | [
"Builds",
"a",
"new",
"+",
"Document",
"+",
"from",
"the",
"supplied",
"attributes",
"loaded",
"from",
"the",
"database",
"."
] | 56976e32610f4c2450882b0bfe14da099f0703f4 | https://github.com/mongodb/mongoid/blob/56976e32610f4c2450882b0bfe14da099f0703f4/lib/mongoid/factory.rb#L52-L80 |
12,258 | mongodb/mongoid | lib/mongoid/atomic.rb | Mongoid.Atomic.add_atomic_pull | def add_atomic_pull(document)
document.flagged_for_destroy = true
(delayed_atomic_pulls[document.association_name.to_s] ||= []).push(document)
end | ruby | def add_atomic_pull(document)
document.flagged_for_destroy = true
(delayed_atomic_pulls[document.association_name.to_s] ||= []).push(document)
end | [
"def",
"add_atomic_pull",
"(",
"document",
")",
"document",
".",
"flagged_for_destroy",
"=",
"true",
"(",
"delayed_atomic_pulls",
"[",
"document",
".",
"association_name",
".",
"to_s",
"]",
"||=",
"[",
"]",
")",
".",
"push",
"(",
"document",
")",
"end"
] | Add the document as an atomic pull.
@example Add the atomic pull.
person.add_atomic_pull(address)
@param [ Document ] document The embedded document to pull.
@since 2.2.0 | [
"Add",
"the",
"document",
"as",
"an",
"atomic",
"pull",
"."
] | 56976e32610f4c2450882b0bfe14da099f0703f4 | https://github.com/mongodb/mongoid/blob/56976e32610f4c2450882b0bfe14da099f0703f4/lib/mongoid/atomic.rb#L38-L41 |
12,259 | mongodb/mongoid | lib/mongoid/atomic.rb | Mongoid.Atomic.add_atomic_unset | def add_atomic_unset(document)
document.flagged_for_destroy = true
(delayed_atomic_unsets[document.association_name.to_s] ||= []).push(document)
end | ruby | def add_atomic_unset(document)
document.flagged_for_destroy = true
(delayed_atomic_unsets[document.association_name.to_s] ||= []).push(document)
end | [
"def",
"add_atomic_unset",
"(",
"document",
")",
"document",
".",
"flagged_for_destroy",
"=",
"true",
"(",
"delayed_atomic_unsets",
"[",
"document",
".",
"association_name",
".",
"to_s",
"]",
"||=",
"[",
"]",
")",
".",
"push",
"(",
"document",
")",
"end"
] | Add an atomic unset for the document.
@example Add an atomic unset.
document.add_atomic_unset(doc)
@param [ Document ] document The child document.
@return [ Array<Document> ] The children.
@since 3.0.0 | [
"Add",
"an",
"atomic",
"unset",
"for",
"the",
"document",
"."
] | 56976e32610f4c2450882b0bfe14da099f0703f4 | https://github.com/mongodb/mongoid/blob/56976e32610f4c2450882b0bfe14da099f0703f4/lib/mongoid/atomic.rb#L53-L56 |
12,260 | mongodb/mongoid | lib/mongoid/atomic.rb | Mongoid.Atomic.atomic_updates | def atomic_updates(_use_indexes = false)
process_flagged_destroys
mods = Modifiers.new
generate_atomic_updates(mods, self)
_children.each do |child|
child.process_flagged_destroys
generate_atomic_updates(mods, child)
end
mods
end | ruby | def atomic_updates(_use_indexes = false)
process_flagged_destroys
mods = Modifiers.new
generate_atomic_updates(mods, self)
_children.each do |child|
child.process_flagged_destroys
generate_atomic_updates(mods, child)
end
mods
end | [
"def",
"atomic_updates",
"(",
"_use_indexes",
"=",
"false",
")",
"process_flagged_destroys",
"mods",
"=",
"Modifiers",
".",
"new",
"generate_atomic_updates",
"(",
"mods",
",",
"self",
")",
"_children",
".",
"each",
"do",
"|",
"child",
"|",
"child",
".",
"proce... | Get all the atomic updates that need to happen for the current
+Document+. This includes all changes that need to happen in the
entire hierarchy that exists below where the save call was made.
@note MongoDB does not allow "conflicting modifications" to be
performed in a single operation. Conflicting modification... | [
"Get",
"all",
"the",
"atomic",
"updates",
"that",
"need",
"to",
"happen",
"for",
"the",
"current",
"+",
"Document",
"+",
".",
"This",
"includes",
"all",
"changes",
"that",
"need",
"to",
"happen",
"in",
"the",
"entire",
"hierarchy",
"that",
"exists",
"below... | 56976e32610f4c2450882b0bfe14da099f0703f4 | https://github.com/mongodb/mongoid/blob/56976e32610f4c2450882b0bfe14da099f0703f4/lib/mongoid/atomic.rb#L129-L138 |
12,261 | mongodb/mongoid | lib/mongoid/atomic.rb | Mongoid.Atomic.atomic_pulls | def atomic_pulls
pulls = {}
delayed_atomic_pulls.each_pair do |_, docs|
path = nil
ids = docs.map do |doc|
path ||= doc.flag_as_destroyed
doc._id
end
pulls[path] = { "_id" => { "$in" => ids }} and path = nil
end
pulls
end | ruby | def atomic_pulls
pulls = {}
delayed_atomic_pulls.each_pair do |_, docs|
path = nil
ids = docs.map do |doc|
path ||= doc.flag_as_destroyed
doc._id
end
pulls[path] = { "_id" => { "$in" => ids }} and path = nil
end
pulls
end | [
"def",
"atomic_pulls",
"pulls",
"=",
"{",
"}",
"delayed_atomic_pulls",
".",
"each_pair",
"do",
"|",
"_",
",",
"docs",
"|",
"path",
"=",
"nil",
"ids",
"=",
"docs",
".",
"map",
"do",
"|",
"doc",
"|",
"path",
"||=",
"doc",
".",
"flag_as_destroyed",
"doc",... | Get all the attributes that need to be pulled.
@example Get the pulls.
person.atomic_pulls
@return [ Array<Hash> ] The $pullAll operations.
@since 2.2.0 | [
"Get",
"all",
"the",
"attributes",
"that",
"need",
"to",
"be",
"pulled",
"."
] | 56976e32610f4c2450882b0bfe14da099f0703f4 | https://github.com/mongodb/mongoid/blob/56976e32610f4c2450882b0bfe14da099f0703f4/lib/mongoid/atomic.rb#L204-L215 |
12,262 | mongodb/mongoid | lib/mongoid/atomic.rb | Mongoid.Atomic.atomic_unsets | def atomic_unsets
unsets = []
delayed_atomic_unsets.each_pair do |name, docs|
path = nil
docs.each do |doc|
path ||= doc.flag_as_destroyed
end
unsets.push(path || name)
end
unsets
end | ruby | def atomic_unsets
unsets = []
delayed_atomic_unsets.each_pair do |name, docs|
path = nil
docs.each do |doc|
path ||= doc.flag_as_destroyed
end
unsets.push(path || name)
end
unsets
end | [
"def",
"atomic_unsets",
"unsets",
"=",
"[",
"]",
"delayed_atomic_unsets",
".",
"each_pair",
"do",
"|",
"name",
",",
"docs",
"|",
"path",
"=",
"nil",
"docs",
".",
"each",
"do",
"|",
"doc",
"|",
"path",
"||=",
"doc",
".",
"flag_as_destroyed",
"end",
"unset... | Get all the attributes that need to be unset.
@example Get the unsets.
person.atomic_unsets
@return [ Array<Hash> ] The $unset operations.
@since 2.2.0 | [
"Get",
"all",
"the",
"attributes",
"that",
"need",
"to",
"be",
"unset",
"."
] | 56976e32610f4c2450882b0bfe14da099f0703f4 | https://github.com/mongodb/mongoid/blob/56976e32610f4c2450882b0bfe14da099f0703f4/lib/mongoid/atomic.rb#L249-L259 |
12,263 | mongodb/mongoid | lib/mongoid/atomic.rb | Mongoid.Atomic.generate_atomic_updates | def generate_atomic_updates(mods, doc)
mods.unset(doc.atomic_unsets)
mods.pull(doc.atomic_pulls)
mods.set(doc.atomic_sets)
mods.set(doc.delayed_atomic_sets)
mods.push(doc.atomic_pushes)
mods.push(doc.atomic_array_pushes)
mods.add_to_set(doc.atomic_array_add_to_sets)
mods.... | ruby | def generate_atomic_updates(mods, doc)
mods.unset(doc.atomic_unsets)
mods.pull(doc.atomic_pulls)
mods.set(doc.atomic_sets)
mods.set(doc.delayed_atomic_sets)
mods.push(doc.atomic_pushes)
mods.push(doc.atomic_array_pushes)
mods.add_to_set(doc.atomic_array_add_to_sets)
mods.... | [
"def",
"generate_atomic_updates",
"(",
"mods",
",",
"doc",
")",
"mods",
".",
"unset",
"(",
"doc",
".",
"atomic_unsets",
")",
"mods",
".",
"pull",
"(",
"doc",
".",
"atomic_pulls",
")",
"mods",
".",
"set",
"(",
"doc",
".",
"atomic_sets",
")",
"mods",
"."... | Generates the atomic updates in the correct order.
@example Generate the updates.
model.generate_atomic_updates(mods, doc)
@param [ Modifiers ] mods The atomic modifications.
@param [ Document ] doc The document to update for.
@since 2.2.0 | [
"Generates",
"the",
"atomic",
"updates",
"in",
"the",
"correct",
"order",
"."
] | 56976e32610f4c2450882b0bfe14da099f0703f4 | https://github.com/mongodb/mongoid/blob/56976e32610f4c2450882b0bfe14da099f0703f4/lib/mongoid/atomic.rb#L349-L358 |
12,264 | mongodb/mongoid | lib/mongoid/persistence_context.rb | Mongoid.PersistenceContext.collection | def collection(parent = nil)
parent ? parent.collection.with(client_options) : client[collection_name.to_sym]
end | ruby | def collection(parent = nil)
parent ? parent.collection.with(client_options) : client[collection_name.to_sym]
end | [
"def",
"collection",
"(",
"parent",
"=",
"nil",
")",
"parent",
"?",
"parent",
".",
"collection",
".",
"with",
"(",
"client_options",
")",
":",
"client",
"[",
"collection_name",
".",
"to_sym",
"]",
"end"
] | Initialize the persistence context object.
@example Create a new persistence context.
PersistenceContext.new(model, collection: 'other')
@param [ Object ] object The class or model instance for which a persistence context
should be created.
@param [ Hash ] opts The persistence context options.
@since 6.0.0... | [
"Initialize",
"the",
"persistence",
"context",
"object",
"."
] | 56976e32610f4c2450882b0bfe14da099f0703f4 | https://github.com/mongodb/mongoid/blob/56976e32610f4c2450882b0bfe14da099f0703f4/lib/mongoid/persistence_context.rb#L71-L73 |
12,265 | mongodb/mongoid | lib/mongoid/persistence_context.rb | Mongoid.PersistenceContext.client | def client
@client ||= (client = Clients.with_name(client_name)
client = client.use(database_name) if database_name_option
client.with(client_options))
end | ruby | def client
@client ||= (client = Clients.with_name(client_name)
client = client.use(database_name) if database_name_option
client.with(client_options))
end | [
"def",
"client",
"@client",
"||=",
"(",
"client",
"=",
"Clients",
".",
"with_name",
"(",
"client_name",
")",
"client",
"=",
"client",
".",
"use",
"(",
"database_name",
")",
"if",
"database_name_option",
"client",
".",
"with",
"(",
"client_options",
")",
")",... | Get the client for this persistence context.
@example Get the client for this persistence context.
context.client
@return [ Mongo::Client ] The client for this persistence
context.
@since 6.0.0 | [
"Get",
"the",
"client",
"for",
"this",
"persistence",
"context",
"."
] | 56976e32610f4c2450882b0bfe14da099f0703f4 | https://github.com/mongodb/mongoid/blob/56976e32610f4c2450882b0bfe14da099f0703f4/lib/mongoid/persistence_context.rb#L111-L115 |
12,266 | mongodb/mongoid | lib/mongoid/changeable.rb | Mongoid.Changeable.changes | def changes
_changes = {}
changed.each do |attr|
change = attribute_change(attr)
_changes[attr] = change if change
end
_changes.with_indifferent_access
end | ruby | def changes
_changes = {}
changed.each do |attr|
change = attribute_change(attr)
_changes[attr] = change if change
end
_changes.with_indifferent_access
end | [
"def",
"changes",
"_changes",
"=",
"{",
"}",
"changed",
".",
"each",
"do",
"|",
"attr",
"|",
"change",
"=",
"attribute_change",
"(",
"attr",
")",
"_changes",
"[",
"attr",
"]",
"=",
"change",
"if",
"change",
"end",
"_changes",
".",
"with_indifferent_access"... | Get all the changes for the document.
@example Get all the changes.
model.changes
@return [ Hash<String, Array<Object, Object> ] The changes.
@since 2.4.0 | [
"Get",
"all",
"the",
"changes",
"for",
"the",
"document",
"."
] | 56976e32610f4c2450882b0bfe14da099f0703f4 | https://github.com/mongodb/mongoid/blob/56976e32610f4c2450882b0bfe14da099f0703f4/lib/mongoid/changeable.rb#L67-L74 |
12,267 | mongodb/mongoid | lib/mongoid/changeable.rb | Mongoid.Changeable.move_changes | def move_changes
@previous_changes = changes
Atomic::UPDATES.each do |update|
send(update).clear
end
changed_attributes.clear
end | ruby | def move_changes
@previous_changes = changes
Atomic::UPDATES.each do |update|
send(update).clear
end
changed_attributes.clear
end | [
"def",
"move_changes",
"@previous_changes",
"=",
"changes",
"Atomic",
"::",
"UPDATES",
".",
"each",
"do",
"|",
"update",
"|",
"send",
"(",
"update",
")",
".",
"clear",
"end",
"changed_attributes",
".",
"clear",
"end"
] | Call this method after save, so the changes can be properly switched.
This will unset the memoized children array, set new record to
false, set the document as validated, and move the dirty changes.
@example Move the changes to previous.
person.move_changes
@since 2.1.0 | [
"Call",
"this",
"method",
"after",
"save",
"so",
"the",
"changes",
"can",
"be",
"properly",
"switched",
"."
] | 56976e32610f4c2450882b0bfe14da099f0703f4 | https://github.com/mongodb/mongoid/blob/56976e32610f4c2450882b0bfe14da099f0703f4/lib/mongoid/changeable.rb#L85-L91 |
12,268 | mongodb/mongoid | lib/mongoid/changeable.rb | Mongoid.Changeable.attribute_change | def attribute_change(attr)
attr = database_field_name(attr)
[changed_attributes[attr], attributes[attr]] if attribute_changed?(attr)
end | ruby | def attribute_change(attr)
attr = database_field_name(attr)
[changed_attributes[attr], attributes[attr]] if attribute_changed?(attr)
end | [
"def",
"attribute_change",
"(",
"attr",
")",
"attr",
"=",
"database_field_name",
"(",
"attr",
")",
"[",
"changed_attributes",
"[",
"attr",
"]",
",",
"attributes",
"[",
"attr",
"]",
"]",
"if",
"attribute_changed?",
"(",
"attr",
")",
"end"
] | Get the old and new value for the provided attribute.
@example Get the attribute change.
model.attribute_change("name")
@param [ String ] attr The name of the attribute.
@return [ Array<Object> ] The old and new values.
@since 2.1.0 | [
"Get",
"the",
"old",
"and",
"new",
"value",
"for",
"the",
"provided",
"attribute",
"."
] | 56976e32610f4c2450882b0bfe14da099f0703f4 | https://github.com/mongodb/mongoid/blob/56976e32610f4c2450882b0bfe14da099f0703f4/lib/mongoid/changeable.rb#L169-L172 |
12,269 | mongodb/mongoid | lib/mongoid/changeable.rb | Mongoid.Changeable.attribute_changed? | def attribute_changed?(attr)
attr = database_field_name(attr)
return false unless changed_attributes.key?(attr)
changed_attributes[attr] != attributes[attr]
end | ruby | def attribute_changed?(attr)
attr = database_field_name(attr)
return false unless changed_attributes.key?(attr)
changed_attributes[attr] != attributes[attr]
end | [
"def",
"attribute_changed?",
"(",
"attr",
")",
"attr",
"=",
"database_field_name",
"(",
"attr",
")",
"return",
"false",
"unless",
"changed_attributes",
".",
"key?",
"(",
"attr",
")",
"changed_attributes",
"[",
"attr",
"]",
"!=",
"attributes",
"[",
"attr",
"]",... | Determine if a specific attribute has changed.
@example Has the attribute changed?
model.attribute_changed?("name")
@param [ String ] attr The name of the attribute.
@return [ true, false ] Whether the attribute has changed.
@since 2.1.6 | [
"Determine",
"if",
"a",
"specific",
"attribute",
"has",
"changed",
"."
] | 56976e32610f4c2450882b0bfe14da099f0703f4 | https://github.com/mongodb/mongoid/blob/56976e32610f4c2450882b0bfe14da099f0703f4/lib/mongoid/changeable.rb#L184-L188 |
12,270 | mongodb/mongoid | lib/mongoid/changeable.rb | Mongoid.Changeable.attribute_changed_from_default? | def attribute_changed_from_default?(attr)
field = fields[attr]
return false unless field
attributes[attr] != field.eval_default(self)
end | ruby | def attribute_changed_from_default?(attr)
field = fields[attr]
return false unless field
attributes[attr] != field.eval_default(self)
end | [
"def",
"attribute_changed_from_default?",
"(",
"attr",
")",
"field",
"=",
"fields",
"[",
"attr",
"]",
"return",
"false",
"unless",
"field",
"attributes",
"[",
"attr",
"]",
"!=",
"field",
".",
"eval_default",
"(",
"self",
")",
"end"
] | Get whether or not the field has a different value from the default.
@example Is the field different from the default?
model.attribute_changed_from_default?
@param [ String ] attr The name of the attribute.
@return [ true, false ] If the attribute differs.
@since 3.0.0 | [
"Get",
"whether",
"or",
"not",
"the",
"field",
"has",
"a",
"different",
"value",
"from",
"the",
"default",
"."
] | 56976e32610f4c2450882b0bfe14da099f0703f4 | https://github.com/mongodb/mongoid/blob/56976e32610f4c2450882b0bfe14da099f0703f4/lib/mongoid/changeable.rb#L200-L204 |
12,271 | mongodb/mongoid | lib/mongoid/changeable.rb | Mongoid.Changeable.attribute_was | def attribute_was(attr)
attr = database_field_name(attr)
attribute_changed?(attr) ? changed_attributes[attr] : attributes[attr]
end | ruby | def attribute_was(attr)
attr = database_field_name(attr)
attribute_changed?(attr) ? changed_attributes[attr] : attributes[attr]
end | [
"def",
"attribute_was",
"(",
"attr",
")",
"attr",
"=",
"database_field_name",
"(",
"attr",
")",
"attribute_changed?",
"(",
"attr",
")",
"?",
"changed_attributes",
"[",
"attr",
"]",
":",
"attributes",
"[",
"attr",
"]",
"end"
] | Get the previous value for the attribute.
@example Get the previous value.
model.attribute_was("name")
@param [ String ] attr The attribute name.
@since 2.4.0 | [
"Get",
"the",
"previous",
"value",
"for",
"the",
"attribute",
"."
] | 56976e32610f4c2450882b0bfe14da099f0703f4 | https://github.com/mongodb/mongoid/blob/56976e32610f4c2450882b0bfe14da099f0703f4/lib/mongoid/changeable.rb#L214-L217 |
12,272 | mongodb/mongoid | lib/mongoid/changeable.rb | Mongoid.Changeable.attribute_will_change! | def attribute_will_change!(attr)
unless changed_attributes.key?(attr)
changed_attributes[attr] = read_raw_attribute(attr).__deep_copy__
end
end | ruby | def attribute_will_change!(attr)
unless changed_attributes.key?(attr)
changed_attributes[attr] = read_raw_attribute(attr).__deep_copy__
end
end | [
"def",
"attribute_will_change!",
"(",
"attr",
")",
"unless",
"changed_attributes",
".",
"key?",
"(",
"attr",
")",
"changed_attributes",
"[",
"attr",
"]",
"=",
"read_raw_attribute",
"(",
"attr",
")",
".",
"__deep_copy__",
"end",
"end"
] | Flag an attribute as going to change.
@example Flag the attribute.
model.attribute_will_change!("name")
@param [ String ] attr The name of the attribute.
@return [ Object ] The old value.
@since 2.3.0 | [
"Flag",
"an",
"attribute",
"as",
"going",
"to",
"change",
"."
] | 56976e32610f4c2450882b0bfe14da099f0703f4 | https://github.com/mongodb/mongoid/blob/56976e32610f4c2450882b0bfe14da099f0703f4/lib/mongoid/changeable.rb#L229-L233 |
12,273 | mongodb/mongoid | lib/mongoid/changeable.rb | Mongoid.Changeable.reset_attribute! | def reset_attribute!(attr)
attr = database_field_name(attr)
attributes[attr] = changed_attributes.delete(attr) if attribute_changed?(attr)
end | ruby | def reset_attribute!(attr)
attr = database_field_name(attr)
attributes[attr] = changed_attributes.delete(attr) if attribute_changed?(attr)
end | [
"def",
"reset_attribute!",
"(",
"attr",
")",
"attr",
"=",
"database_field_name",
"(",
"attr",
")",
"attributes",
"[",
"attr",
"]",
"=",
"changed_attributes",
".",
"delete",
"(",
"attr",
")",
"if",
"attribute_changed?",
"(",
"attr",
")",
"end"
] | Set the attribute back to its old value.
@example Reset the attribute.
model.reset_attribute!("name")
@param [ String ] attr The name of the attribute.
@return [ Object ] The old value.
@since 2.4.0 | [
"Set",
"the",
"attribute",
"back",
"to",
"its",
"old",
"value",
"."
] | 56976e32610f4c2450882b0bfe14da099f0703f4 | https://github.com/mongodb/mongoid/blob/56976e32610f4c2450882b0bfe14da099f0703f4/lib/mongoid/changeable.rb#L245-L248 |
12,274 | mongodb/mongoid | lib/rails/mongoid.rb | Rails.Mongoid.load_models | def load_models(app)
app.config.paths["app/models"].expanded.each do |path|
preload = ::Mongoid.preload_models
if preload.resizable?
files = preload.map { |model| "#{path}/#{model.underscore}.rb" }
else
files = Dir.glob("#{path}/**/*.rb")
end
files.sort... | ruby | def load_models(app)
app.config.paths["app/models"].expanded.each do |path|
preload = ::Mongoid.preload_models
if preload.resizable?
files = preload.map { |model| "#{path}/#{model.underscore}.rb" }
else
files = Dir.glob("#{path}/**/*.rb")
end
files.sort... | [
"def",
"load_models",
"(",
"app",
")",
"app",
".",
"config",
".",
"paths",
"[",
"\"app/models\"",
"]",
".",
"expanded",
".",
"each",
"do",
"|",
"path",
"|",
"preload",
"=",
"::",
"Mongoid",
".",
"preload_models",
"if",
"preload",
".",
"resizable?",
"file... | Use the application configuration to get every model and require it, so
that indexing and inheritance work in both development and production
with the same results.
@example Load all the application models.
Rails::Mongoid.load_models(app)
@param [ Application ] app The rails application. | [
"Use",
"the",
"application",
"configuration",
"to",
"get",
"every",
"model",
"and",
"require",
"it",
"so",
"that",
"indexing",
"and",
"inheritance",
"work",
"in",
"both",
"development",
"and",
"production",
"with",
"the",
"same",
"results",
"."
] | 56976e32610f4c2450882b0bfe14da099f0703f4 | https://github.com/mongodb/mongoid/blob/56976e32610f4c2450882b0bfe14da099f0703f4/lib/rails/mongoid.rb#L15-L28 |
12,275 | mongodb/mongoid | lib/rails/mongoid.rb | Rails.Mongoid.load_model | def load_model(file)
begin
require_dependency(file)
rescue Exception => e
Logger.new($stdout).warn(e.message)
end
end | ruby | def load_model(file)
begin
require_dependency(file)
rescue Exception => e
Logger.new($stdout).warn(e.message)
end
end | [
"def",
"load_model",
"(",
"file",
")",
"begin",
"require_dependency",
"(",
"file",
")",
"rescue",
"Exception",
"=>",
"e",
"Logger",
".",
"new",
"(",
"$stdout",
")",
".",
"warn",
"(",
"e",
".",
"message",
")",
"end",
"end"
] | I don't want to mock out kernel for unit testing purposes, so added this
method as a convenience.
@example Load the model.
Mongoid.load_model("/mongoid/behavior")
@param [ String ] file The base filename.
@since 2.0.0.rc.3 | [
"I",
"don",
"t",
"want",
"to",
"mock",
"out",
"kernel",
"for",
"unit",
"testing",
"purposes",
"so",
"added",
"this",
"method",
"as",
"a",
"convenience",
"."
] | 56976e32610f4c2450882b0bfe14da099f0703f4 | https://github.com/mongodb/mongoid/blob/56976e32610f4c2450882b0bfe14da099f0703f4/lib/rails/mongoid.rb#L49-L55 |
12,276 | mongodb/mongoid | lib/mongoid/fields.rb | Mongoid.Fields.apply_default | def apply_default(name)
unless attributes.key?(name)
if field = fields[name]
default = field.eval_default(self)
unless default.nil? || field.lazy?
attribute_will_change!(name)
attributes[name] = default
end
end
end
end | ruby | def apply_default(name)
unless attributes.key?(name)
if field = fields[name]
default = field.eval_default(self)
unless default.nil? || field.lazy?
attribute_will_change!(name)
attributes[name] = default
end
end
end
end | [
"def",
"apply_default",
"(",
"name",
")",
"unless",
"attributes",
".",
"key?",
"(",
"name",
")",
"if",
"field",
"=",
"fields",
"[",
"name",
"]",
"default",
"=",
"field",
".",
"eval_default",
"(",
"self",
")",
"unless",
"default",
".",
"nil?",
"||",
"fi... | Applies a single default value for the given name.
@example Apply a single default.
model.apply_default("name")
@param [ String ] name The name of the field.
@since 2.4.0 | [
"Applies",
"a",
"single",
"default",
"value",
"for",
"the",
"given",
"name",
"."
] | 56976e32610f4c2450882b0bfe14da099f0703f4 | https://github.com/mongodb/mongoid/blob/56976e32610f4c2450882b0bfe14da099f0703f4/lib/mongoid/fields.rb#L101-L111 |
12,277 | mongodb/mongoid | lib/mongoid/persistable.rb | Mongoid.Persistable.post_process_persist | def post_process_persist(result, options = {})
post_persist unless result == false
errors.clear unless performing_validations?(options)
true
end | ruby | def post_process_persist(result, options = {})
post_persist unless result == false
errors.clear unless performing_validations?(options)
true
end | [
"def",
"post_process_persist",
"(",
"result",
",",
"options",
"=",
"{",
"}",
")",
"post_persist",
"unless",
"result",
"==",
"false",
"errors",
".",
"clear",
"unless",
"performing_validations?",
"(",
"options",
")",
"true",
"end"
] | Post process the persistence operation.
@api private
@example Post process the persistence operation.
document.post_process_persist(true)
@param [ Object ] result The result of the operation.
@param [ Hash ] options The options.
@return [ true ] true.
@since 4.0.0 | [
"Post",
"process",
"the",
"persistence",
"operation",
"."
] | 56976e32610f4c2450882b0bfe14da099f0703f4 | https://github.com/mongodb/mongoid/blob/56976e32610f4c2450882b0bfe14da099f0703f4/lib/mongoid/persistable.rb#L179-L183 |
12,278 | mongodb/mongoid | lib/mongoid/persistable.rb | Mongoid.Persistable.process_atomic_operations | def process_atomic_operations(operations)
operations.each do |field, value|
access = database_field_name(field)
yield(access, value)
remove_change(access) unless executing_atomically?
end
end | ruby | def process_atomic_operations(operations)
operations.each do |field, value|
access = database_field_name(field)
yield(access, value)
remove_change(access) unless executing_atomically?
end
end | [
"def",
"process_atomic_operations",
"(",
"operations",
")",
"operations",
".",
"each",
"do",
"|",
"field",
",",
"value",
"|",
"access",
"=",
"database_field_name",
"(",
"field",
")",
"yield",
"(",
"access",
",",
"value",
")",
"remove_change",
"(",
"access",
... | Process the atomic operations - this handles the common behavior of
iterating through each op, getting the aliased field name, and removing
appropriate dirty changes.
@api private
@example Process the atomic operations.
document.process_atomic_operations(pulls) do |field, value|
...
end
@param [ Hash... | [
"Process",
"the",
"atomic",
"operations",
"-",
"this",
"handles",
"the",
"common",
"behavior",
"of",
"iterating",
"through",
"each",
"op",
"getting",
"the",
"aliased",
"field",
"name",
"and",
"removing",
"appropriate",
"dirty",
"changes",
"."
] | 56976e32610f4c2450882b0bfe14da099f0703f4 | https://github.com/mongodb/mongoid/blob/56976e32610f4c2450882b0bfe14da099f0703f4/lib/mongoid/persistable.rb#L220-L226 |
12,279 | mongodb/mongoid | lib/mongoid/persistable.rb | Mongoid.Persistable.persist_or_delay_atomic_operation | def persist_or_delay_atomic_operation(operation)
if executing_atomically?
operation.each do |(name, hash)|
@atomic_context[name] ||= {}
@atomic_context[name].merge!(hash)
end
else
persist_atomic_operations(operation)
end
end | ruby | def persist_or_delay_atomic_operation(operation)
if executing_atomically?
operation.each do |(name, hash)|
@atomic_context[name] ||= {}
@atomic_context[name].merge!(hash)
end
else
persist_atomic_operations(operation)
end
end | [
"def",
"persist_or_delay_atomic_operation",
"(",
"operation",
")",
"if",
"executing_atomically?",
"operation",
".",
"each",
"do",
"|",
"(",
"name",
",",
"hash",
")",
"|",
"@atomic_context",
"[",
"name",
"]",
"||=",
"{",
"}",
"@atomic_context",
"[",
"name",
"]"... | If we are in an atomically block, add the operations to the delayed group,
otherwise persist immediately.
@api private
@example Persist immediately or delay the operations.
document.persist_or_delay_atomic_operation(ops)
@param [ Hash ] operation The operation.
@since 4.0.0 | [
"If",
"we",
"are",
"in",
"an",
"atomically",
"block",
"add",
"the",
"operations",
"to",
"the",
"delayed",
"group",
"otherwise",
"persist",
"immediately",
"."
] | 56976e32610f4c2450882b0bfe14da099f0703f4 | https://github.com/mongodb/mongoid/blob/56976e32610f4c2450882b0bfe14da099f0703f4/lib/mongoid/persistable.rb#L299-L308 |
12,280 | mongodb/mongoid | lib/mongoid/persistable.rb | Mongoid.Persistable.persist_atomic_operations | def persist_atomic_operations(operations)
if persisted? && operations && !operations.empty?
selector = atomic_selector
_root.collection.find(selector).update_one(positionally(selector, operations), session: _session)
end
end | ruby | def persist_atomic_operations(operations)
if persisted? && operations && !operations.empty?
selector = atomic_selector
_root.collection.find(selector).update_one(positionally(selector, operations), session: _session)
end
end | [
"def",
"persist_atomic_operations",
"(",
"operations",
")",
"if",
"persisted?",
"&&",
"operations",
"&&",
"!",
"operations",
".",
"empty?",
"selector",
"=",
"atomic_selector",
"_root",
".",
"collection",
".",
"find",
"(",
"selector",
")",
".",
"update_one",
"(",... | Persist the atomic operations.
@api private
@example Persist the atomic operations.
persist_atomic_operations(ops)
@param [ Hash ] operations The atomic operations.
@since 4.0.0 | [
"Persist",
"the",
"atomic",
"operations",
"."
] | 56976e32610f4c2450882b0bfe14da099f0703f4 | https://github.com/mongodb/mongoid/blob/56976e32610f4c2450882b0bfe14da099f0703f4/lib/mongoid/persistable.rb#L320-L325 |
12,281 | mongodb/mongoid | lib/mongoid/serializable.rb | Mongoid.Serializable.serializable_hash | def serializable_hash(options = nil)
options ||= {}
attrs = {}
names = field_names(options)
method_names = Array.wrap(options[:methods]).map do |name|
name.to_s if respond_to?(name)
end.compact
(names + method_names).each do |name|
without_autobuild do
se... | ruby | def serializable_hash(options = nil)
options ||= {}
attrs = {}
names = field_names(options)
method_names = Array.wrap(options[:methods]).map do |name|
name.to_s if respond_to?(name)
end.compact
(names + method_names).each do |name|
without_autobuild do
se... | [
"def",
"serializable_hash",
"(",
"options",
"=",
"nil",
")",
"options",
"||=",
"{",
"}",
"attrs",
"=",
"{",
"}",
"names",
"=",
"field_names",
"(",
"options",
")",
"method_names",
"=",
"Array",
".",
"wrap",
"(",
"options",
"[",
":methods",
"]",
")",
"."... | Gets the document as a serializable hash, used by ActiveModel's JSON
serializer.
@example Get the serializable hash.
document.serializable_hash
@example Get the serializable hash with options.
document.serializable_hash(:include => :addresses)
@param [ Hash ] options The options to pass.
@option options ... | [
"Gets",
"the",
"document",
"as",
"a",
"serializable",
"hash",
"used",
"by",
"ActiveModel",
"s",
"JSON",
"serializer",
"."
] | 56976e32610f4c2450882b0bfe14da099f0703f4 | https://github.com/mongodb/mongoid/blob/56976e32610f4c2450882b0bfe14da099f0703f4/lib/mongoid/serializable.rb#L38-L55 |
12,282 | mongodb/mongoid | lib/mongoid/serializable.rb | Mongoid.Serializable.field_names | def field_names(options)
names = (as_attributes.keys + attribute_names).uniq.sort
only = Array.wrap(options[:only]).map(&:to_s)
except = Array.wrap(options[:except]).map(&:to_s)
except |= ['_type'] unless Mongoid.include_type_for_serialization
if !only.empty?
names &= only
... | ruby | def field_names(options)
names = (as_attributes.keys + attribute_names).uniq.sort
only = Array.wrap(options[:only]).map(&:to_s)
except = Array.wrap(options[:except]).map(&:to_s)
except |= ['_type'] unless Mongoid.include_type_for_serialization
if !only.empty?
names &= only
... | [
"def",
"field_names",
"(",
"options",
")",
"names",
"=",
"(",
"as_attributes",
".",
"keys",
"+",
"attribute_names",
")",
".",
"uniq",
".",
"sort",
"only",
"=",
"Array",
".",
"wrap",
"(",
"options",
"[",
":only",
"]",
")",
".",
"map",
"(",
":to_s",
")... | Get the names of all fields that will be serialized.
@api private
@example Get all the field names.
document.send(:field_names)
@return [ Array<String> ] The names of the fields.
@since 3.0.0 | [
"Get",
"the",
"names",
"of",
"all",
"fields",
"that",
"will",
"be",
"serialized",
"."
] | 56976e32610f4c2450882b0bfe14da099f0703f4 | https://github.com/mongodb/mongoid/blob/56976e32610f4c2450882b0bfe14da099f0703f4/lib/mongoid/serializable.rb#L69-L82 |
12,283 | mongodb/mongoid | lib/mongoid/serializable.rb | Mongoid.Serializable.serialize_attribute | def serialize_attribute(attrs, name, names, options)
if relations.key?(name)
value = send(name)
attrs[name] = value ? value.serializable_hash(options) : nil
elsif names.include?(name) && !fields.key?(name)
attrs[name] = read_raw_attribute(name)
elsif !attribute_missing?(name)
... | ruby | def serialize_attribute(attrs, name, names, options)
if relations.key?(name)
value = send(name)
attrs[name] = value ? value.serializable_hash(options) : nil
elsif names.include?(name) && !fields.key?(name)
attrs[name] = read_raw_attribute(name)
elsif !attribute_missing?(name)
... | [
"def",
"serialize_attribute",
"(",
"attrs",
",",
"name",
",",
"names",
",",
"options",
")",
"if",
"relations",
".",
"key?",
"(",
"name",
")",
"value",
"=",
"send",
"(",
"name",
")",
"attrs",
"[",
"name",
"]",
"=",
"value",
"?",
"value",
".",
"seriali... | Serialize a single attribute. Handles associations, fields, and dynamic
attributes.
@api private
@example Serialize the attribute.
document.serialize_attribute({}, "id" , [ "id" ])
@param [ Hash ] attrs The attributes.
@param [ String ] name The attribute name.
@param [ Array<String> ] names The names of al... | [
"Serialize",
"a",
"single",
"attribute",
".",
"Handles",
"associations",
"fields",
"and",
"dynamic",
"attributes",
"."
] | 56976e32610f4c2450882b0bfe14da099f0703f4 | https://github.com/mongodb/mongoid/blob/56976e32610f4c2450882b0bfe14da099f0703f4/lib/mongoid/serializable.rb#L100-L109 |
12,284 | mongodb/mongoid | lib/mongoid/serializable.rb | Mongoid.Serializable.serialize_relations | def serialize_relations(attributes = {}, options = {})
inclusions = options[:include]
relation_names(inclusions).each do |name|
association = relations[name.to_s]
if association && relation = send(association.name)
attributes[association.name.to_s] =
relation.serializab... | ruby | def serialize_relations(attributes = {}, options = {})
inclusions = options[:include]
relation_names(inclusions).each do |name|
association = relations[name.to_s]
if association && relation = send(association.name)
attributes[association.name.to_s] =
relation.serializab... | [
"def",
"serialize_relations",
"(",
"attributes",
"=",
"{",
"}",
",",
"options",
"=",
"{",
"}",
")",
"inclusions",
"=",
"options",
"[",
":include",
"]",
"relation_names",
"(",
"inclusions",
")",
".",
"each",
"do",
"|",
"name",
"|",
"association",
"=",
"re... | For each of the provided include options, get the association needed and
provide it in the hash.
@example Serialize the included associations.
document.serialize_relations({}, :include => :addresses)
@param [ Hash ] attributes The attributes to serialize.
@param [ Hash ] options The serialization options.
@o... | [
"For",
"each",
"of",
"the",
"provided",
"include",
"options",
"get",
"the",
"association",
"needed",
"and",
"provide",
"it",
"in",
"the",
"hash",
"."
] | 56976e32610f4c2450882b0bfe14da099f0703f4 | https://github.com/mongodb/mongoid/blob/56976e32610f4c2450882b0bfe14da099f0703f4/lib/mongoid/serializable.rb#L125-L134 |
12,285 | mongodb/mongoid | lib/mongoid/serializable.rb | Mongoid.Serializable.relation_names | def relation_names(inclusions)
inclusions.is_a?(Hash) ? inclusions.keys : Array.wrap(inclusions)
end | ruby | def relation_names(inclusions)
inclusions.is_a?(Hash) ? inclusions.keys : Array.wrap(inclusions)
end | [
"def",
"relation_names",
"(",
"inclusions",
")",
"inclusions",
".",
"is_a?",
"(",
"Hash",
")",
"?",
"inclusions",
".",
"keys",
":",
"Array",
".",
"wrap",
"(",
"inclusions",
")",
"end"
] | Since the inclusions can be a hash, symbol, or array of symbols, this is
provided as a convenience to parse out the names.
@example Get the association names.
document.relation_names(:include => [ :addresses ])
@param [ Hash, Symbol, Array<Symbol> ] inclusions The inclusions.
@return [ Array<Symbol> ] The nam... | [
"Since",
"the",
"inclusions",
"can",
"be",
"a",
"hash",
"symbol",
"or",
"array",
"of",
"symbols",
"this",
"is",
"provided",
"as",
"a",
"convenience",
"to",
"parse",
"out",
"the",
"names",
"."
] | 56976e32610f4c2450882b0bfe14da099f0703f4 | https://github.com/mongodb/mongoid/blob/56976e32610f4c2450882b0bfe14da099f0703f4/lib/mongoid/serializable.rb#L147-L149 |
12,286 | mongodb/mongoid | lib/mongoid/serializable.rb | Mongoid.Serializable.relation_options | def relation_options(inclusions, options, name)
if inclusions.is_a?(Hash)
inclusions[name]
else
{ except: options[:except], only: options[:only] }
end
end | ruby | def relation_options(inclusions, options, name)
if inclusions.is_a?(Hash)
inclusions[name]
else
{ except: options[:except], only: options[:only] }
end
end | [
"def",
"relation_options",
"(",
"inclusions",
",",
"options",
",",
"name",
")",
"if",
"inclusions",
".",
"is_a?",
"(",
"Hash",
")",
"inclusions",
"[",
"name",
"]",
"else",
"{",
"except",
":",
"options",
"[",
":except",
"]",
",",
"only",
":",
"options",
... | Since the inclusions can be a hash, symbol, or array of symbols, this is
provided as a convenience to parse out the options.
@example Get the association options.
document.relation_names(:include => [ :addresses ])
@param [ Hash, Symbol, Array<Symbol> ] inclusions The inclusions.
@param [ Hash ] options The op... | [
"Since",
"the",
"inclusions",
"can",
"be",
"a",
"hash",
"symbol",
"or",
"array",
"of",
"symbols",
"this",
"is",
"provided",
"as",
"a",
"convenience",
"to",
"parse",
"out",
"the",
"options",
"."
] | 56976e32610f4c2450882b0bfe14da099f0703f4 | https://github.com/mongodb/mongoid/blob/56976e32610f4c2450882b0bfe14da099f0703f4/lib/mongoid/serializable.rb#L164-L170 |
12,287 | mongodb/mongoid | lib/mongoid/threaded.rb | Mongoid.Threaded.current_scope | def current_scope(klass = nil)
if klass && Thread.current[CURRENT_SCOPE_KEY].respond_to?(:keys)
Thread.current[CURRENT_SCOPE_KEY][
Thread.current[CURRENT_SCOPE_KEY].keys.find { |k| k <= klass }
]
else
Thread.current[CURRENT_SCOPE_KEY]
end
end | ruby | def current_scope(klass = nil)
if klass && Thread.current[CURRENT_SCOPE_KEY].respond_to?(:keys)
Thread.current[CURRENT_SCOPE_KEY][
Thread.current[CURRENT_SCOPE_KEY].keys.find { |k| k <= klass }
]
else
Thread.current[CURRENT_SCOPE_KEY]
end
end | [
"def",
"current_scope",
"(",
"klass",
"=",
"nil",
")",
"if",
"klass",
"&&",
"Thread",
".",
"current",
"[",
"CURRENT_SCOPE_KEY",
"]",
".",
"respond_to?",
"(",
":keys",
")",
"Thread",
".",
"current",
"[",
"CURRENT_SCOPE_KEY",
"]",
"[",
"Thread",
".",
"curren... | Get the current Mongoid scope.
@example Get the scope.
Threaded.current_scope(klass)
Threaded.current_scope
@param [ Klass ] klass The class type of the scope.
@return [ Criteria ] The scope.
@since 5.0.0 | [
"Get",
"the",
"current",
"Mongoid",
"scope",
"."
] | 56976e32610f4c2450882b0bfe14da099f0703f4 | https://github.com/mongodb/mongoid/blob/56976e32610f4c2450882b0bfe14da099f0703f4/lib/mongoid/threaded.rb#L228-L236 |
12,288 | mongodb/mongoid | lib/mongoid/threaded.rb | Mongoid.Threaded.set_current_scope | def set_current_scope(scope, klass)
if scope.nil?
if Thread.current[CURRENT_SCOPE_KEY]
Thread.current[CURRENT_SCOPE_KEY].delete(klass)
Thread.current[CURRENT_SCOPE_KEY] = nil if Thread.current[CURRENT_SCOPE_KEY].empty?
end
else
Thread.current[CURRENT_SCOPE_KEY] ||... | ruby | def set_current_scope(scope, klass)
if scope.nil?
if Thread.current[CURRENT_SCOPE_KEY]
Thread.current[CURRENT_SCOPE_KEY].delete(klass)
Thread.current[CURRENT_SCOPE_KEY] = nil if Thread.current[CURRENT_SCOPE_KEY].empty?
end
else
Thread.current[CURRENT_SCOPE_KEY] ||... | [
"def",
"set_current_scope",
"(",
"scope",
",",
"klass",
")",
"if",
"scope",
".",
"nil?",
"if",
"Thread",
".",
"current",
"[",
"CURRENT_SCOPE_KEY",
"]",
"Thread",
".",
"current",
"[",
"CURRENT_SCOPE_KEY",
"]",
".",
"delete",
"(",
"klass",
")",
"Thread",
"."... | Set the current Mongoid scope. Safe for multi-model scope chaining.
@example Set the scope.
Threaded.current_scope(scope, klass)
@param [ Criteria ] scope The current scope.
@param [ Class ] klass The current model class.
@return [ Criteria ] The scope.
@since 5.0.1 | [
"Set",
"the",
"current",
"Mongoid",
"scope",
".",
"Safe",
"for",
"multi",
"-",
"model",
"scope",
"chaining",
"."
] | 56976e32610f4c2450882b0bfe14da099f0703f4 | https://github.com/mongodb/mongoid/blob/56976e32610f4c2450882b0bfe14da099f0703f4/lib/mongoid/threaded.rb#L263-L273 |
12,289 | mongodb/mongoid | lib/mongoid/scopable.rb | Mongoid.Scopable.apply_default_scoping | def apply_default_scoping
if default_scoping
default_scoping.call.selector.each do |field, value|
attributes[field] = value unless value.respond_to?(:each)
end
end
end | ruby | def apply_default_scoping
if default_scoping
default_scoping.call.selector.each do |field, value|
attributes[field] = value unless value.respond_to?(:each)
end
end
end | [
"def",
"apply_default_scoping",
"if",
"default_scoping",
"default_scoping",
".",
"call",
".",
"selector",
".",
"each",
"do",
"|",
"field",
",",
"value",
"|",
"attributes",
"[",
"field",
"]",
"=",
"value",
"unless",
"value",
".",
"respond_to?",
"(",
":each",
... | Apply the default scoping to the attributes of the document, as long as
they are not complex queries.
@api private
@example Apply the default scoping.
document.apply_default_scoping
@return [ true, false ] If default scoping was applied.
@since 4.0.0 | [
"Apply",
"the",
"default",
"scoping",
"to",
"the",
"attributes",
"of",
"the",
"document",
"as",
"long",
"as",
"they",
"are",
"not",
"complex",
"queries",
"."
] | 56976e32610f4c2450882b0bfe14da099f0703f4 | https://github.com/mongodb/mongoid/blob/56976e32610f4c2450882b0bfe14da099f0703f4/lib/mongoid/scopable.rb#L32-L38 |
12,290 | mongodb/mongoid | lib/mongoid/validatable.rb | Mongoid.Validatable.read_attribute_for_validation | def read_attribute_for_validation(attr)
attribute = database_field_name(attr)
if relations.key?(attribute)
begin_validate
relation = without_autobuild { send(attr) }
exit_validate
relation.do_or_do_not(:in_memory) || relation
elsif fields[attribute].try(:localized?)
... | ruby | def read_attribute_for_validation(attr)
attribute = database_field_name(attr)
if relations.key?(attribute)
begin_validate
relation = without_autobuild { send(attr) }
exit_validate
relation.do_or_do_not(:in_memory) || relation
elsif fields[attribute].try(:localized?)
... | [
"def",
"read_attribute_for_validation",
"(",
"attr",
")",
"attribute",
"=",
"database_field_name",
"(",
"attr",
")",
"if",
"relations",
".",
"key?",
"(",
"attribute",
")",
"begin_validate",
"relation",
"=",
"without_autobuild",
"{",
"send",
"(",
"attr",
")",
"}"... | Overrides the default ActiveModel behavior since we need to handle
validations of associations slightly different than just calling the
getter.
@example Read the value.
person.read_attribute_for_validation(:addresses)
@param [ Symbol ] attr The name of the field or association.
@return [ Object ] The value o... | [
"Overrides",
"the",
"default",
"ActiveModel",
"behavior",
"since",
"we",
"need",
"to",
"handle",
"validations",
"of",
"associations",
"slightly",
"different",
"than",
"just",
"calling",
"the",
"getter",
"."
] | 56976e32610f4c2450882b0bfe14da099f0703f4 | https://github.com/mongodb/mongoid/blob/56976e32610f4c2450882b0bfe14da099f0703f4/lib/mongoid/validatable.rb#L70-L82 |
12,291 | mongodb/mongoid | lib/mongoid/traversable.rb | Mongoid.Traversable.collect_children | def collect_children
children = []
embedded_relations.each_pair do |name, association|
without_autobuild do
child = send(name)
Array.wrap(child).each do |doc|
children.push(doc)
children.concat(doc._children)
end if child
end
end
... | ruby | def collect_children
children = []
embedded_relations.each_pair do |name, association|
without_autobuild do
child = send(name)
Array.wrap(child).each do |doc|
children.push(doc)
children.concat(doc._children)
end if child
end
end
... | [
"def",
"collect_children",
"children",
"=",
"[",
"]",
"embedded_relations",
".",
"each_pair",
"do",
"|",
"name",
",",
"association",
"|",
"without_autobuild",
"do",
"child",
"=",
"send",
"(",
"name",
")",
"Array",
".",
"wrap",
"(",
"child",
")",
".",
"each... | Collect all the children of this document.
@example Collect all the children.
document.collect_children
@return [ Array<Document> ] The children.
@since 2.4.0 | [
"Collect",
"all",
"the",
"children",
"of",
"this",
"document",
"."
] | 56976e32610f4c2450882b0bfe14da099f0703f4 | https://github.com/mongodb/mongoid/blob/56976e32610f4c2450882b0bfe14da099f0703f4/lib/mongoid/traversable.rb#L42-L54 |
12,292 | mongodb/mongoid | lib/mongoid/traversable.rb | Mongoid.Traversable.remove_child | def remove_child(child)
name = child.association_name
if child.embedded_one?
remove_ivar(name)
else
relation = send(name)
relation.send(:delete_one, child)
end
end | ruby | def remove_child(child)
name = child.association_name
if child.embedded_one?
remove_ivar(name)
else
relation = send(name)
relation.send(:delete_one, child)
end
end | [
"def",
"remove_child",
"(",
"child",
")",
"name",
"=",
"child",
".",
"association_name",
"if",
"child",
".",
"embedded_one?",
"remove_ivar",
"(",
"name",
")",
"else",
"relation",
"=",
"send",
"(",
"name",
")",
"relation",
".",
"send",
"(",
":delete_one",
"... | Remove a child document from this parent. If an embeds one then set to
nil, otherwise remove from the embeds many.
This is called from the +RemoveEmbedded+ persistence command.
@example Remove the child.
document.remove_child(child)
@param [ Document ] child The child (embedded) document to remove.
@since 2... | [
"Remove",
"a",
"child",
"document",
"from",
"this",
"parent",
".",
"If",
"an",
"embeds",
"one",
"then",
"set",
"to",
"nil",
"otherwise",
"remove",
"from",
"the",
"embeds",
"many",
"."
] | 56976e32610f4c2450882b0bfe14da099f0703f4 | https://github.com/mongodb/mongoid/blob/56976e32610f4c2450882b0bfe14da099f0703f4/lib/mongoid/traversable.rb#L104-L112 |
12,293 | mongodb/mongoid | lib/mongoid/traversable.rb | Mongoid.Traversable.reset_persisted_children | def reset_persisted_children
_children.each do |child|
child.move_changes
child.new_record = false
end
_reset_memoized_children!
end | ruby | def reset_persisted_children
_children.each do |child|
child.move_changes
child.new_record = false
end
_reset_memoized_children!
end | [
"def",
"reset_persisted_children",
"_children",
".",
"each",
"do",
"|",
"child",
"|",
"child",
".",
"move_changes",
"child",
".",
"new_record",
"=",
"false",
"end",
"_reset_memoized_children!",
"end"
] | After children are persisted we can call this to move all their changes
and flag them as persisted in one call.
@example Reset the children.
document.reset_persisted_children
@return [ Array<Document> ] The children.
@since 2.1.0 | [
"After",
"children",
"are",
"persisted",
"we",
"can",
"call",
"this",
"to",
"move",
"all",
"their",
"changes",
"and",
"flag",
"them",
"as",
"persisted",
"in",
"one",
"call",
"."
] | 56976e32610f4c2450882b0bfe14da099f0703f4 | https://github.com/mongodb/mongoid/blob/56976e32610f4c2450882b0bfe14da099f0703f4/lib/mongoid/traversable.rb#L123-L129 |
12,294 | mongodb/mongoid | lib/mongoid/document.rb | Mongoid.Document.becomes | def becomes(klass)
unless klass.include?(Mongoid::Document)
raise ArgumentError, "A class which includes Mongoid::Document is expected"
end
became = klass.new(clone_document)
became._id = _id
became.instance_variable_set(:@changed_attributes, changed_attributes)
became.insta... | ruby | def becomes(klass)
unless klass.include?(Mongoid::Document)
raise ArgumentError, "A class which includes Mongoid::Document is expected"
end
became = klass.new(clone_document)
became._id = _id
became.instance_variable_set(:@changed_attributes, changed_attributes)
became.insta... | [
"def",
"becomes",
"(",
"klass",
")",
"unless",
"klass",
".",
"include?",
"(",
"Mongoid",
"::",
"Document",
")",
"raise",
"ArgumentError",
",",
"\"A class which includes Mongoid::Document is expected\"",
"end",
"became",
"=",
"klass",
".",
"new",
"(",
"clone_document... | Returns an instance of the specified class with the attributes,
errors, and embedded documents of the current document.
@example Return a subclass document as a superclass instance.
manager.becomes(Person)
@raise [ ArgumentError ] If the class doesn't include Mongoid::Document
@param [ Class ] klass The class... | [
"Returns",
"an",
"instance",
"of",
"the",
"specified",
"class",
"with",
"the",
"attributes",
"errors",
"and",
"embedded",
"documents",
"of",
"the",
"current",
"document",
"."
] | 56976e32610f4c2450882b0bfe14da099f0703f4 | https://github.com/mongodb/mongoid/blob/56976e32610f4c2450882b0bfe14da099f0703f4/lib/mongoid/document.rb#L223-L249 |
12,295 | mongodb/mongoid | lib/mongoid/association.rb | Mongoid.Association.reload_relations | def reload_relations
relations.each_pair do |name, meta|
if instance_variable_defined?("@_#{name}")
if _parent.nil? || instance_variable_get("@_#{name}") != _parent
remove_instance_variable("@_#{name}")
end
end
end
end | ruby | def reload_relations
relations.each_pair do |name, meta|
if instance_variable_defined?("@_#{name}")
if _parent.nil? || instance_variable_get("@_#{name}") != _parent
remove_instance_variable("@_#{name}")
end
end
end
end | [
"def",
"reload_relations",
"relations",
".",
"each_pair",
"do",
"|",
"name",
",",
"meta",
"|",
"if",
"instance_variable_defined?",
"(",
"\"@_#{name}\"",
")",
"if",
"_parent",
".",
"nil?",
"||",
"instance_variable_get",
"(",
"\"@_#{name}\"",
")",
"!=",
"_parent",
... | Convenience method for iterating through the loaded associations and
reloading them.
@example Reload the associations.
document.reload_relations
@return [ Hash ] The association metadata.
@since 2.1.6 | [
"Convenience",
"method",
"for",
"iterating",
"through",
"the",
"loaded",
"associations",
"and",
"reloading",
"them",
"."
] | 56976e32610f4c2450882b0bfe14da099f0703f4 | https://github.com/mongodb/mongoid/blob/56976e32610f4c2450882b0bfe14da099f0703f4/lib/mongoid/association.rb#L141-L149 |
12,296 | mongodb/mongoid | lib/mongoid/inspectable.rb | Mongoid.Inspectable.inspect_fields | def inspect_fields
fields.map do |name, field|
unless name == "_id"
as = field.options[:as]
"#{name}#{as ? "(#{as})" : nil}: #{@attributes[name].inspect}"
end
end.compact
end | ruby | def inspect_fields
fields.map do |name, field|
unless name == "_id"
as = field.options[:as]
"#{name}#{as ? "(#{as})" : nil}: #{@attributes[name].inspect}"
end
end.compact
end | [
"def",
"inspect_fields",
"fields",
".",
"map",
"do",
"|",
"name",
",",
"field",
"|",
"unless",
"name",
"==",
"\"_id\"",
"as",
"=",
"field",
".",
"options",
"[",
":as",
"]",
"\"#{name}#{as ? \"(#{as})\" : nil}: #{@attributes[name].inspect}\"",
"end",
"end",
".",
... | Get an array of inspected fields for the document.
@api private
@example Inspect the defined fields.
document.inspect_fields
@return [ String ] An array of pretty printed field values.
@since 1.0.0 | [
"Get",
"an",
"array",
"of",
"inspected",
"fields",
"for",
"the",
"document",
"."
] | 56976e32610f4c2450882b0bfe14da099f0703f4 | https://github.com/mongodb/mongoid/blob/56976e32610f4c2450882b0bfe14da099f0703f4/lib/mongoid/inspectable.rb#L37-L44 |
12,297 | mongodb/mongoid | lib/mongoid/interceptable.rb | Mongoid.Interceptable.run_callbacks | def run_callbacks(kind, *args, &block)
cascadable_children(kind).each do |child|
if child.run_callbacks(child_callback_type(kind, child), *args) == false
return false
end
end
callback_executable?(kind) ? super(kind, *args, &block) : true
end | ruby | def run_callbacks(kind, *args, &block)
cascadable_children(kind).each do |child|
if child.run_callbacks(child_callback_type(kind, child), *args) == false
return false
end
end
callback_executable?(kind) ? super(kind, *args, &block) : true
end | [
"def",
"run_callbacks",
"(",
"kind",
",",
"*",
"args",
",",
"&",
"block",
")",
"cascadable_children",
"(",
"kind",
")",
".",
"each",
"do",
"|",
"child",
"|",
"if",
"child",
".",
"run_callbacks",
"(",
"child_callback_type",
"(",
"kind",
",",
"child",
")",... | Run the callbacks for the document. This overrides active support's
functionality to cascade callbacks to embedded documents that have been
flagged as such.
@example Run the callbacks.
run_callbacks :save do
save!
end
@param [ Symbol ] kind The type of callback to execute.
@param [ Array ] args Any op... | [
"Run",
"the",
"callbacks",
"for",
"the",
"document",
".",
"This",
"overrides",
"active",
"support",
"s",
"functionality",
"to",
"cascade",
"callbacks",
"to",
"embedded",
"documents",
"that",
"have",
"been",
"flagged",
"as",
"such",
"."
] | 56976e32610f4c2450882b0bfe14da099f0703f4 | https://github.com/mongodb/mongoid/blob/56976e32610f4c2450882b0bfe14da099f0703f4/lib/mongoid/interceptable.rb#L127-L134 |
12,298 | mongodb/mongoid | lib/mongoid/interceptable.rb | Mongoid.Interceptable.cascadable_children | def cascadable_children(kind, children = Set.new)
embedded_relations.each_pair do |name, association|
next unless association.cascading_callbacks?
without_autobuild do
delayed_pulls = delayed_atomic_pulls[name]
delayed_unsets = delayed_atomic_unsets[name]
children.mer... | ruby | def cascadable_children(kind, children = Set.new)
embedded_relations.each_pair do |name, association|
next unless association.cascading_callbacks?
without_autobuild do
delayed_pulls = delayed_atomic_pulls[name]
delayed_unsets = delayed_atomic_unsets[name]
children.mer... | [
"def",
"cascadable_children",
"(",
"kind",
",",
"children",
"=",
"Set",
".",
"new",
")",
"embedded_relations",
".",
"each_pair",
"do",
"|",
"name",
",",
"association",
"|",
"next",
"unless",
"association",
".",
"cascading_callbacks?",
"without_autobuild",
"do",
... | Get all the child embedded documents that are flagged as cascadable.
@example Get all the cascading children.
document.cascadable_children(:update)
@param [ Symbol ] kind The type of callback.
@return [ Array<Document> ] The children.
@since 2.3.0 | [
"Get",
"all",
"the",
"child",
"embedded",
"documents",
"that",
"are",
"flagged",
"as",
"cascadable",
"."
] | 56976e32610f4c2450882b0bfe14da099f0703f4 | https://github.com/mongodb/mongoid/blob/56976e32610f4c2450882b0bfe14da099f0703f4/lib/mongoid/interceptable.rb#L163-L180 |
12,299 | mongodb/mongoid | lib/mongoid/interceptable.rb | Mongoid.Interceptable.cascadable_child? | def cascadable_child?(kind, child, association)
return false if kind == :initialize || kind == :find || kind == :touch
return false if kind == :validate && association.validate?
child.callback_executable?(kind) ? child.in_callback_state?(kind) : false
end | ruby | def cascadable_child?(kind, child, association)
return false if kind == :initialize || kind == :find || kind == :touch
return false if kind == :validate && association.validate?
child.callback_executable?(kind) ? child.in_callback_state?(kind) : false
end | [
"def",
"cascadable_child?",
"(",
"kind",
",",
"child",
",",
"association",
")",
"return",
"false",
"if",
"kind",
"==",
":initialize",
"||",
"kind",
"==",
":find",
"||",
"kind",
"==",
":touch",
"return",
"false",
"if",
"kind",
"==",
":validate",
"&&",
"asso... | Determine if the child should fire the callback.
@example Should the child fire the callback?
document.cascadable_child?(:update, doc)
@param [ Symbol ] kind The type of callback.
@param [ Document ] child The child document.
@return [ true, false ] If the child should fire the callback.
@since 2.3.0 | [
"Determine",
"if",
"the",
"child",
"should",
"fire",
"the",
"callback",
"."
] | 56976e32610f4c2450882b0bfe14da099f0703f4 | https://github.com/mongodb/mongoid/blob/56976e32610f4c2450882b0bfe14da099f0703f4/lib/mongoid/interceptable.rb#L193-L197 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.