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 | partition stringclasses 1
value |
|---|---|---|---|---|---|---|---|---|---|---|---|
guard/rb-inotify | lib/rb-inotify/notifier.rb | INotify.Notifier.process | def process
read_events.each do |event|
event.callback!
event.flags.include?(:ignored) && event.notifier.watchers.delete(event.watcher_id)
end
end | ruby | def process
read_events.each do |event|
event.callback!
event.flags.include?(:ignored) && event.notifier.watchers.delete(event.watcher_id)
end
end | [
"def",
"process",
"read_events",
".",
"each",
"do",
"|",
"event",
"|",
"event",
".",
"callback!",
"event",
".",
"flags",
".",
"include?",
"(",
":ignored",
")",
"&&",
"event",
".",
"notifier",
".",
"watchers",
".",
"delete",
"(",
"event",
".",
"watcher_id... | Blocks until there are one or more filesystem events
that this notifier has watchers registered for.
Once there are events, the appropriate callbacks are called
and this function returns.
@see #run | [
"Blocks",
"until",
"there",
"are",
"one",
"or",
"more",
"filesystem",
"events",
"that",
"this",
"notifier",
"has",
"watchers",
"registered",
"for",
".",
"Once",
"there",
"are",
"events",
"the",
"appropriate",
"callbacks",
"are",
"called",
"and",
"this",
"funct... | 3fae270905c7bd259e69fe420dbdcd59bb47fa3d | https://github.com/guard/rb-inotify/blob/3fae270905c7bd259e69fe420dbdcd59bb47fa3d/lib/rb-inotify/notifier.rb#L251-L256 | train |
chefspec/fauxhai | lib/fauxhai/mocker.rb | Fauxhai.Mocker.data | def data
@fauxhai_data ||= lambda do
# If a path option was specified, use it
if @options[:path]
filepath = File.expand_path(@options[:path])
unless File.exist?(filepath)
raise Fauxhai::Exception::InvalidPlatform.new("You specified a path to a JSON file on the loca... | ruby | def data
@fauxhai_data ||= lambda do
# If a path option was specified, use it
if @options[:path]
filepath = File.expand_path(@options[:path])
unless File.exist?(filepath)
raise Fauxhai::Exception::InvalidPlatform.new("You specified a path to a JSON file on the loca... | [
"def",
"data",
"@fauxhai_data",
"||=",
"lambda",
"do",
"if",
"@options",
"[",
":path",
"]",
"filepath",
"=",
"File",
".",
"expand_path",
"(",
"@options",
"[",
":path",
"]",
")",
"unless",
"File",
".",
"exist?",
"(",
"filepath",
")",
"raise",
"Fauxhai",
"... | Create a new Ohai Mock with fauxhai.
@param [Hash] options
the options for the mocker
@option options [String] :platform
the platform to mock
@option options [String] :version
the version of the platform to mock
@option options [String] :path
the path to a local JSON file
@option options [Bool] :githu... | [
"Create",
"a",
"new",
"Ohai",
"Mock",
"with",
"fauxhai",
"."
] | c73522490738f254920a4c344822524fef1ee7d0 | https://github.com/chefspec/fauxhai/blob/c73522490738f254920a4c344822524fef1ee7d0/lib/fauxhai/mocker.rb#L31-L73 | train |
chefspec/fauxhai | lib/fauxhai/mocker.rb | Fauxhai.Mocker.parse_and_validate | def parse_and_validate(unparsed_data)
parsed_data = JSON.parse(unparsed_data)
if parsed_data['deprecated']
STDERR.puts "WARNING: Fauxhai platform data for #{parsed_data['platform']} #{parsed_data['platform_version']} is deprecated and will be removed in the 7.0 release 3/2019. #{PLATFORM_LIST_MESSAG... | ruby | def parse_and_validate(unparsed_data)
parsed_data = JSON.parse(unparsed_data)
if parsed_data['deprecated']
STDERR.puts "WARNING: Fauxhai platform data for #{parsed_data['platform']} #{parsed_data['platform_version']} is deprecated and will be removed in the 7.0 release 3/2019. #{PLATFORM_LIST_MESSAG... | [
"def",
"parse_and_validate",
"(",
"unparsed_data",
")",
"parsed_data",
"=",
"JSON",
".",
"parse",
"(",
"unparsed_data",
")",
"if",
"parsed_data",
"[",
"'deprecated'",
"]",
"STDERR",
".",
"puts",
"\"WARNING: Fauxhai platform data for #{parsed_data['platform']} #{parsed_data[... | As major releases of Ohai ship it's difficult and sometimes impossible
to regenerate all fauxhai data. This allows us to deprecate old releases
and eventually remove them while giving end users ample warning. | [
"As",
"major",
"releases",
"of",
"Ohai",
"ship",
"it",
"s",
"difficult",
"and",
"sometimes",
"impossible",
"to",
"regenerate",
"all",
"fauxhai",
"data",
".",
"This",
"allows",
"us",
"to",
"deprecate",
"old",
"releases",
"and",
"eventually",
"remove",
"them",
... | c73522490738f254920a4c344822524fef1ee7d0 | https://github.com/chefspec/fauxhai/blob/c73522490738f254920a4c344822524fef1ee7d0/lib/fauxhai/mocker.rb#L80-L86 | train |
jwilger/the_help | lib/the_help/service_caller.rb | TheHelp.ServiceCaller.call_service | def call_service(service, **args, &block)
service_args = {
context: service_context,
logger: service_logger
}.merge(args)
service_logger.debug("#{self.class.name}/#{__id__} called service " \
"#{service.name}")
service.call(**service_args, &block)
e... | ruby | def call_service(service, **args, &block)
service_args = {
context: service_context,
logger: service_logger
}.merge(args)
service_logger.debug("#{self.class.name}/#{__id__} called service " \
"#{service.name}")
service.call(**service_args, &block)
e... | [
"def",
"call_service",
"(",
"service",
",",
"**",
"args",
",",
"&",
"block",
")",
"service_args",
"=",
"{",
"context",
":",
"service_context",
",",
"logger",
":",
"service_logger",
"}",
".",
"merge",
"(",
"args",
")",
"service_logger",
".",
"debug",
"(",
... | Calls the specified service
@param service [Class<TheHelp::Service>]
@param args [Hash<Symbol, Object>] Any additional keyword arguments are
passed directly to the service.
@return [self] | [
"Calls",
"the",
"specified",
"service"
] | 4ca6dff0f1960a096657ac421a8b4e384c92deb8 | https://github.com/jwilger/the_help/blob/4ca6dff0f1960a096657ac421a8b4e384c92deb8/lib/the_help/service_caller.rb#L35-L43 | train |
ManageIQ/awesome_spawn | lib/awesome_spawn/command_line_builder.rb | AwesomeSpawn.CommandLineBuilder.build | def build(command, params = nil)
params = assemble_params(sanitize(params))
params.empty? ? command.to_s : "#{command} #{params}"
end | ruby | def build(command, params = nil)
params = assemble_params(sanitize(params))
params.empty? ? command.to_s : "#{command} #{params}"
end | [
"def",
"build",
"(",
"command",
",",
"params",
"=",
"nil",
")",
"params",
"=",
"assemble_params",
"(",
"sanitize",
"(",
"params",
")",
")",
"params",
".",
"empty?",
"?",
"command",
".",
"to_s",
":",
"\"#{command} #{params}\"",
"end"
] | Build the full command line.
@param [String] command The command to run
@param [Hash,Array] params Optional command line parameters. They can
be passed as a Hash or associative Array. The values are sanitized to
prevent command line injection. Keys as Symbols are prefixed with `--`,
and `_` is replaced wit... | [
"Build",
"the",
"full",
"command",
"line",
"."
] | 7cbf922be564271ce958a75a4e8660d9eef93823 | https://github.com/ManageIQ/awesome_spawn/blob/7cbf922be564271ce958a75a4e8660d9eef93823/lib/awesome_spawn/command_line_builder.rb#L46-L49 | train |
lancejpollard/authlogic-connect | lib/authlogic_connect/common/user.rb | AuthlogicConnect::Common::User.InstanceMethods.save | def save(options = {}, &block)
self.errors.clear
# log_state
options = {} if options == false
options[:validate] = true unless options.has_key?(:validate)
save_options = ActiveRecord::VERSION::MAJOR < 3 ? options[:validate] : options
# kill the block if we're starting authenti... | ruby | def save(options = {}, &block)
self.errors.clear
# log_state
options = {} if options == false
options[:validate] = true unless options.has_key?(:validate)
save_options = ActiveRecord::VERSION::MAJOR < 3 ? options[:validate] : options
# kill the block if we're starting authenti... | [
"def",
"save",
"(",
"options",
"=",
"{",
"}",
",",
"&",
"block",
")",
"self",
".",
"errors",
".",
"clear",
"options",
"=",
"{",
"}",
"if",
"options",
"==",
"false",
"options",
"[",
":validate",
"]",
"=",
"true",
"unless",
"options",
".",
"has_key?",
... | core save method coordinating how to save the user.
we dont' want to ru validations based on the
authentication mission we are trying to accomplish.
instead, we just return save as false.
the next time around, when we recieve the callback,
we will run the validations.
when you call 'current_user_session' in Appli... | [
"core",
"save",
"method",
"coordinating",
"how",
"to",
"save",
"the",
"user",
".",
"we",
"dont",
"want",
"to",
"ru",
"validations",
"based",
"on",
"the",
"authentication",
"mission",
"we",
"are",
"trying",
"to",
"accomplish",
".",
"instead",
"we",
"just",
... | 3b1959ec07f1a9c4164753fea5a5cb1079b88257 | https://github.com/lancejpollard/authlogic-connect/blob/3b1959ec07f1a9c4164753fea5a5cb1079b88257/lib/authlogic_connect/common/user.rb#L55-L73 | train |
lancejpollard/authlogic-connect | lib/authlogic_connect/oauth/user.rb | AuthlogicConnect::Oauth::User.InstanceMethods.save_oauth_session | def save_oauth_session
super
auth_session[:auth_attributes] = attributes.reject!{|k, v| v.blank? || !self.respond_to?(k)} unless is_auth_session?
end | ruby | def save_oauth_session
super
auth_session[:auth_attributes] = attributes.reject!{|k, v| v.blank? || !self.respond_to?(k)} unless is_auth_session?
end | [
"def",
"save_oauth_session",
"super",
"auth_session",
"[",
":auth_attributes",
"]",
"=",
"attributes",
".",
"reject!",
"{",
"|",
"k",
",",
"v",
"|",
"v",
".",
"blank?",
"||",
"!",
"self",
".",
"respond_to?",
"(",
"k",
")",
"}",
"unless",
"is_auth_session?"... | user adds a few extra things to this method from Process
modules work like inheritance | [
"user",
"adds",
"a",
"few",
"extra",
"things",
"to",
"this",
"method",
"from",
"Process",
"modules",
"work",
"like",
"inheritance"
] | 3b1959ec07f1a9c4164753fea5a5cb1079b88257 | https://github.com/lancejpollard/authlogic-connect/blob/3b1959ec07f1a9c4164753fea5a5cb1079b88257/lib/authlogic_connect/oauth/user.rb#L33-L36 | train |
lancejpollard/authlogic-connect | lib/authlogic_connect/oauth/user.rb | AuthlogicConnect::Oauth::User.InstanceMethods.complete_oauth_transaction | def complete_oauth_transaction
token = token_class.new(oauth_token_and_secret)
old_token = token_class.find_by_key_or_token(token.key, token.token)
token = old_token if old_token
if has_token?(oauth_provider)
self.errors.add(:tokens, "you have already created an account using your... | ruby | def complete_oauth_transaction
token = token_class.new(oauth_token_and_secret)
old_token = token_class.find_by_key_or_token(token.key, token.token)
token = old_token if old_token
if has_token?(oauth_provider)
self.errors.add(:tokens, "you have already created an account using your... | [
"def",
"complete_oauth_transaction",
"token",
"=",
"token_class",
".",
"new",
"(",
"oauth_token_and_secret",
")",
"old_token",
"=",
"token_class",
".",
"find_by_key_or_token",
"(",
"token",
".",
"key",
",",
"token",
".",
"token",
")",
"token",
"=",
"old_token",
... | single implementation method for oauth.
this is called after we get the callback url and we are saving the user
to the database.
it is called by the validation chain. | [
"single",
"implementation",
"method",
"for",
"oauth",
".",
"this",
"is",
"called",
"after",
"we",
"get",
"the",
"callback",
"url",
"and",
"we",
"are",
"saving",
"the",
"user",
"to",
"the",
"database",
".",
"it",
"is",
"called",
"by",
"the",
"validation",
... | 3b1959ec07f1a9c4164753fea5a5cb1079b88257 | https://github.com/lancejpollard/authlogic-connect/blob/3b1959ec07f1a9c4164753fea5a5cb1079b88257/lib/authlogic_connect/oauth/user.rb#L51-L61 | train |
ondra-m/ruby-spark | lib/spark/command_builder.rb | Spark.CommandBuilder.serialize_function | def serialize_function(func)
case func
when String
serialize_function_from_string(func)
when Symbol
serialize_function_from_symbol(func)
when Proc
serialize_function_from_proc(func)
when Method
serialize_function_from_meth... | ruby | def serialize_function(func)
case func
when String
serialize_function_from_string(func)
when Symbol
serialize_function_from_symbol(func)
when Proc
serialize_function_from_proc(func)
when Method
serialize_function_from_meth... | [
"def",
"serialize_function",
"(",
"func",
")",
"case",
"func",
"when",
"String",
"serialize_function_from_string",
"(",
"func",
")",
"when",
"Symbol",
"serialize_function_from_symbol",
"(",
"func",
")",
"when",
"Proc",
"serialize_function_from_proc",
"(",
"func",
")",... | Serialized can be Proc and Method
=== Func
* *string:* already serialized proc
* *proc:* proc
* *symbol:* name of method
* *method:* Method class | [
"Serialized",
"can",
"be",
"Proc",
"and",
"Method"
] | d1b9787642fe582dee906de3c6bb9407ded27145 | https://github.com/ondra-m/ruby-spark/blob/d1b9787642fe582dee906de3c6bb9407ded27145/lib/spark/command_builder.rb#L87-L100 | train |
ondra-m/ruby-spark | lib/spark/command_builder.rb | Spark.CommandBuilder.serialize_function_from_method | def serialize_function_from_method(meth)
if pry?
meth = Pry::Method.new(meth)
end
{type: 'method', name: meth.name, content: meth.source}
rescue
raise Spark::SerializeError, 'Method can not be serialized. Use full path or Proc.'
end | ruby | def serialize_function_from_method(meth)
if pry?
meth = Pry::Method.new(meth)
end
{type: 'method', name: meth.name, content: meth.source}
rescue
raise Spark::SerializeError, 'Method can not be serialized. Use full path or Proc.'
end | [
"def",
"serialize_function_from_method",
"(",
"meth",
")",
"if",
"pry?",
"meth",
"=",
"Pry",
"::",
"Method",
".",
"new",
"(",
"meth",
")",
"end",
"{",
"type",
":",
"'method'",
",",
"name",
":",
"meth",
".",
"name",
",",
"content",
":",
"meth",
".",
"... | Serialize method as string
def test(x)
x*x
end
serialize_function_from_method(method(:test))
# => "def test(x)\n x*x\nend\n" | [
"Serialize",
"method",
"as",
"string"
] | d1b9787642fe582dee906de3c6bb9407ded27145 | https://github.com/ondra-m/ruby-spark/blob/d1b9787642fe582dee906de3c6bb9407ded27145/lib/spark/command_builder.rb#L130-L138 | train |
ondra-m/ruby-spark | lib/spark/config.rb | Spark.Config.from_file | def from_file(file)
check_read_only
if file && File.exist?(file)
file = File.expand_path(file)
RubyUtils.loadPropertiesFile(spark_conf, file)
end
end | ruby | def from_file(file)
check_read_only
if file && File.exist?(file)
file = File.expand_path(file)
RubyUtils.loadPropertiesFile(spark_conf, file)
end
end | [
"def",
"from_file",
"(",
"file",
")",
"check_read_only",
"if",
"file",
"&&",
"File",
".",
"exist?",
"(",
"file",
")",
"file",
"=",
"File",
".",
"expand_path",
"(",
"file",
")",
"RubyUtils",
".",
"loadPropertiesFile",
"(",
"spark_conf",
",",
"file",
")",
... | Initialize java SparkConf and load default configuration. | [
"Initialize",
"java",
"SparkConf",
"and",
"load",
"default",
"configuration",
"."
] | d1b9787642fe582dee906de3c6bb9407ded27145 | https://github.com/ondra-m/ruby-spark/blob/d1b9787642fe582dee906de3c6bb9407ded27145/lib/spark/config.rb#L22-L29 | train |
ondra-m/ruby-spark | lib/spark/config.rb | Spark.Config.get | def get(key)
value = spark_conf.get(key.to_s)
case TYPES[key]
when :boolean
parse_boolean(value)
when :integer
parse_integer(value)
else
value
end
rescue
nil
end | ruby | def get(key)
value = spark_conf.get(key.to_s)
case TYPES[key]
when :boolean
parse_boolean(value)
when :integer
parse_integer(value)
else
value
end
rescue
nil
end | [
"def",
"get",
"(",
"key",
")",
"value",
"=",
"spark_conf",
".",
"get",
"(",
"key",
".",
"to_s",
")",
"case",
"TYPES",
"[",
"key",
"]",
"when",
":boolean",
"parse_boolean",
"(",
"value",
")",
"when",
":integer",
"parse_integer",
"(",
"value",
")",
"else... | Rescue from NoSuchElementException | [
"Rescue",
"from",
"NoSuchElementException"
] | d1b9787642fe582dee906de3c6bb9407ded27145 | https://github.com/ondra-m/ruby-spark/blob/d1b9787642fe582dee906de3c6bb9407ded27145/lib/spark/config.rb#L85-L98 | train |
ondra-m/ruby-spark | lib/spark/config.rb | Spark.Config.load_executor_envs | def load_executor_envs
prefix = 'SPARK_RUBY_EXECUTOR_ENV_'
envs = ENV.select{|key, _| key.start_with?(prefix)}
envs.each do |key, value|
key = key.dup # ENV keys are frozen
key.slice!(0, prefix.size)
set("spark.ruby.executor.env.#{key}", value)
end
end | ruby | def load_executor_envs
prefix = 'SPARK_RUBY_EXECUTOR_ENV_'
envs = ENV.select{|key, _| key.start_with?(prefix)}
envs.each do |key, value|
key = key.dup # ENV keys are frozen
key.slice!(0, prefix.size)
set("spark.ruby.executor.env.#{key}", value)
end
end | [
"def",
"load_executor_envs",
"prefix",
"=",
"'SPARK_RUBY_EXECUTOR_ENV_'",
"envs",
"=",
"ENV",
".",
"select",
"{",
"|",
"key",
",",
"_",
"|",
"key",
".",
"start_with?",
"(",
"prefix",
")",
"}",
"envs",
".",
"each",
"do",
"|",
"key",
",",
"value",
"|",
"... | Load environment variables for executor from ENV.
== Examples:
SPARK_RUBY_EXECUTOR_ENV_KEY1="1"
SPARK_RUBY_EXECUTOR_ENV_KEY2="2" | [
"Load",
"environment",
"variables",
"for",
"executor",
"from",
"ENV",
"."
] | d1b9787642fe582dee906de3c6bb9407ded27145 | https://github.com/ondra-m/ruby-spark/blob/d1b9787642fe582dee906de3c6bb9407ded27145/lib/spark/config.rb#L208-L218 | train |
ondra-m/ruby-spark | lib/spark/worker/worker.rb | Worker.Base.compute | def compute
before_start
# Load split index
@split_index = socket.read_int
# Load files
SparkFiles.root_directory = socket.read_string
# Load broadcast
count = socket.read_int
count.times do
Spark::Broadcast.register(socket.read_long, socket.r... | ruby | def compute
before_start
# Load split index
@split_index = socket.read_int
# Load files
SparkFiles.root_directory = socket.read_string
# Load broadcast
count = socket.read_int
count.times do
Spark::Broadcast.register(socket.read_long, socket.r... | [
"def",
"compute",
"before_start",
"@split_index",
"=",
"socket",
".",
"read_int",
"SparkFiles",
".",
"root_directory",
"=",
"socket",
".",
"read_string",
"count",
"=",
"socket",
".",
"read_int",
"count",
".",
"times",
"do",
"Spark",
"::",
"Broadcast",
".",
"re... | These methods must be on one method because iterator is Lazy
which mean that exception can be raised at `serializer` or `compute` | [
"These",
"methods",
"must",
"be",
"on",
"one",
"method",
"because",
"iterator",
"is",
"Lazy",
"which",
"mean",
"that",
"exception",
"can",
"be",
"raised",
"at",
"serializer",
"or",
"compute"
] | d1b9787642fe582dee906de3c6bb9407ded27145 | https://github.com/ondra-m/ruby-spark/blob/d1b9787642fe582dee906de3c6bb9407ded27145/lib/spark/worker/worker.rb#L57-L86 | train |
ondra-m/ruby-spark | lib/spark/rdd.rb | Spark.RDD.inspect | def inspect
comms = @command.commands.join(' -> ')
result = %{#<#{self.class.name}:0x#{object_id}}
result << %{ (#{comms})} unless comms.empty?
result << %{ (cached)} if cached?
result << %{\n}
result << %{ Serializer: "#{serializer}"\n}
result << %{Deserializer: "#{deserial... | ruby | def inspect
comms = @command.commands.join(' -> ')
result = %{#<#{self.class.name}:0x#{object_id}}
result << %{ (#{comms})} unless comms.empty?
result << %{ (cached)} if cached?
result << %{\n}
result << %{ Serializer: "#{serializer}"\n}
result << %{Deserializer: "#{deserial... | [
"def",
"inspect",
"comms",
"=",
"@command",
".",
"commands",
".",
"join",
"(",
"' -> '",
")",
"result",
"=",
"%{#<#{self.class.name}:0x#{object_id}}",
"result",
"<<",
"%{ (#{comms})}",
"unless",
"comms",
".",
"empty?",
"result",
"<<",
"%{ (cached)}",
"if",
"cached... | Initializing RDD, this method is root of all Pipelined RDD - its unique
If you call some operations on this class it will be computed in Java
== Parameters:
jrdd:: org.apache.spark.api.java.JavaRDD
context:: {Spark::Context}
serializer:: {Spark::Serializer} | [
"Initializing",
"RDD",
"this",
"method",
"is",
"root",
"of",
"all",
"Pipelined",
"RDD",
"-",
"its",
"unique",
"If",
"you",
"call",
"some",
"operations",
"on",
"this",
"class",
"it",
"will",
"be",
"computed",
"in",
"Java"
] | d1b9787642fe582dee906de3c6bb9407ded27145 | https://github.com/ondra-m/ruby-spark/blob/d1b9787642fe582dee906de3c6bb9407ded27145/lib/spark/rdd.rb#L37-L48 | train |
ondra-m/ruby-spark | lib/spark/rdd.rb | Spark.RDD.take | def take(count)
buffer = []
parts_count = self.partitions_size
# No parts was scanned, yet
last_scanned = -1
while buffer.empty?
last_scanned += 1
buffer += context.run_job_with_command(self, [last_scanned], true, Spark::Command::Take, 0, -1)
end
# Assumption... | ruby | def take(count)
buffer = []
parts_count = self.partitions_size
# No parts was scanned, yet
last_scanned = -1
while buffer.empty?
last_scanned += 1
buffer += context.run_job_with_command(self, [last_scanned], true, Spark::Command::Take, 0, -1)
end
# Assumption... | [
"def",
"take",
"(",
"count",
")",
"buffer",
"=",
"[",
"]",
"parts_count",
"=",
"self",
".",
"partitions_size",
"last_scanned",
"=",
"-",
"1",
"while",
"buffer",
".",
"empty?",
"last_scanned",
"+=",
"1",
"buffer",
"+=",
"context",
".",
"run_job_with_command",... | Take the first num elements of the RDD.
It works by first scanning one partition, and use the results from
that partition to estimate the number of additional partitions needed
to satisfy the limit.
== Example:
rdd = $sc.parallelize(0..100, 20)
rdd.take(5)
# => [0, 1, 2, 3, 4] | [
"Take",
"the",
"first",
"num",
"elements",
"of",
"the",
"RDD",
"."
] | d1b9787642fe582dee906de3c6bb9407ded27145 | https://github.com/ondra-m/ruby-spark/blob/d1b9787642fe582dee906de3c6bb9407ded27145/lib/spark/rdd.rb#L247-L281 | train |
ondra-m/ruby-spark | lib/spark/rdd.rb | Spark.RDD.aggregate | def aggregate(zero_value, seq_op, comb_op)
_reduce(Spark::Command::Aggregate, seq_op, comb_op, zero_value)
end | ruby | def aggregate(zero_value, seq_op, comb_op)
_reduce(Spark::Command::Aggregate, seq_op, comb_op, zero_value)
end | [
"def",
"aggregate",
"(",
"zero_value",
",",
"seq_op",
",",
"comb_op",
")",
"_reduce",
"(",
"Spark",
"::",
"Command",
"::",
"Aggregate",
",",
"seq_op",
",",
"comb_op",
",",
"zero_value",
")",
"end"
] | Aggregate the elements of each partition, and then the results for all the partitions, using
given combine functions and a neutral "zero value".
This function can return a different result type. We need one operation for merging.
Result must be an Array otherwise Serializer Array's zero value will be send
as mult... | [
"Aggregate",
"the",
"elements",
"of",
"each",
"partition",
"and",
"then",
"the",
"results",
"for",
"all",
"the",
"partitions",
"using",
"given",
"combine",
"functions",
"and",
"a",
"neutral",
"zero",
"value",
"."
] | d1b9787642fe582dee906de3c6bb9407ded27145 | https://github.com/ondra-m/ruby-spark/blob/d1b9787642fe582dee906de3c6bb9407ded27145/lib/spark/rdd.rb#L342-L344 | train |
ondra-m/ruby-spark | lib/spark/rdd.rb | Spark.RDD.coalesce | def coalesce(num_partitions)
if self.is_a?(PipelinedRDD)
deser = @command.serializer
else
deser = @command.deserializer
end
new_jrdd = jrdd.coalesce(num_partitions)
RDD.new(new_jrdd, context, @command.serializer, deser)
end | ruby | def coalesce(num_partitions)
if self.is_a?(PipelinedRDD)
deser = @command.serializer
else
deser = @command.deserializer
end
new_jrdd = jrdd.coalesce(num_partitions)
RDD.new(new_jrdd, context, @command.serializer, deser)
end | [
"def",
"coalesce",
"(",
"num_partitions",
")",
"if",
"self",
".",
"is_a?",
"(",
"PipelinedRDD",
")",
"deser",
"=",
"@command",
".",
"serializer",
"else",
"deser",
"=",
"@command",
".",
"deserializer",
"end",
"new_jrdd",
"=",
"jrdd",
".",
"coalesce",
"(",
"... | Return a new RDD that is reduced into num_partitions partitions.
== Example:
rdd = $sc.parallelize(0..10, 3)
rdd.coalesce(2).glom.collect
# => [[0, 1, 2], [3, 4, 5, 6, 7, 8, 9, 10]] | [
"Return",
"a",
"new",
"RDD",
"that",
"is",
"reduced",
"into",
"num_partitions",
"partitions",
"."
] | d1b9787642fe582dee906de3c6bb9407ded27145 | https://github.com/ondra-m/ruby-spark/blob/d1b9787642fe582dee906de3c6bb9407ded27145/lib/spark/rdd.rb#L683-L692 | train |
ondra-m/ruby-spark | lib/spark/rdd.rb | Spark.RDD.shuffle | def shuffle(seed=nil)
seed ||= Random.new_seed
new_rdd_from_command(Spark::Command::Shuffle, seed)
end | ruby | def shuffle(seed=nil)
seed ||= Random.new_seed
new_rdd_from_command(Spark::Command::Shuffle, seed)
end | [
"def",
"shuffle",
"(",
"seed",
"=",
"nil",
")",
"seed",
"||=",
"Random",
".",
"new_seed",
"new_rdd_from_command",
"(",
"Spark",
"::",
"Command",
"::",
"Shuffle",
",",
"seed",
")",
"end"
] | Return a shuffled RDD.
== Example:
rdd = $sc.parallelize(0..10)
rdd.shuffle.collect
# => [3, 10, 6, 7, 8, 0, 4, 2, 9, 1, 5] | [
"Return",
"a",
"shuffled",
"RDD",
"."
] | d1b9787642fe582dee906de3c6bb9407ded27145 | https://github.com/ondra-m/ruby-spark/blob/d1b9787642fe582dee906de3c6bb9407ded27145/lib/spark/rdd.rb#L733-L737 | train |
ondra-m/ruby-spark | lib/spark/rdd.rb | Spark.RDD.reserialize | def reserialize(new_serializer)
if serializer == new_serializer
return self
end
new_command = @command.deep_copy
new_command.serializer = new_serializer
PipelinedRDD.new(self, new_command)
end | ruby | def reserialize(new_serializer)
if serializer == new_serializer
return self
end
new_command = @command.deep_copy
new_command.serializer = new_serializer
PipelinedRDD.new(self, new_command)
end | [
"def",
"reserialize",
"(",
"new_serializer",
")",
"if",
"serializer",
"==",
"new_serializer",
"return",
"self",
"end",
"new_command",
"=",
"@command",
".",
"deep_copy",
"new_command",
".",
"serializer",
"=",
"new_serializer",
"PipelinedRDD",
".",
"new",
"(",
"self... | Return a new RDD with different serializer. This method is useful during union
and join operations.
== Example:
rdd = $sc.parallelize([1, 2, 3], nil, serializer: "marshal")
rdd = rdd.map(lambda{|x| x.to_s})
rdd.reserialize("oj").collect
# => ["1", "2", "3"] | [
"Return",
"a",
"new",
"RDD",
"with",
"different",
"serializer",
".",
"This",
"method",
"is",
"useful",
"during",
"union",
"and",
"join",
"operations",
"."
] | d1b9787642fe582dee906de3c6bb9407ded27145 | https://github.com/ondra-m/ruby-spark/blob/d1b9787642fe582dee906de3c6bb9407ded27145/lib/spark/rdd.rb#L765-L774 | train |
ondra-m/ruby-spark | lib/spark/rdd.rb | Spark.RDD.intersection | def intersection(other)
mapping_function = 'lambda{|item| [item, nil]}'
filter_function = 'lambda{|(key, values)| values.size > 1}'
self.map(mapping_function)
.cogroup(other.map(mapping_function))
.filter(filter_function)
.keys
end | ruby | def intersection(other)
mapping_function = 'lambda{|item| [item, nil]}'
filter_function = 'lambda{|(key, values)| values.size > 1}'
self.map(mapping_function)
.cogroup(other.map(mapping_function))
.filter(filter_function)
.keys
end | [
"def",
"intersection",
"(",
"other",
")",
"mapping_function",
"=",
"'lambda{|item| [item, nil]}'",
"filter_function",
"=",
"'lambda{|(key, values)| values.size > 1}'",
"self",
".",
"map",
"(",
"mapping_function",
")",
".",
"cogroup",
"(",
"other",
".",
"map",
"(",
"ma... | Return the intersection of this RDD and another one. The output will not contain
any duplicate elements, even if the input RDDs did.
== Example:
rdd1 = $sc.parallelize([1,2,3,4,5])
rdd2 = $sc.parallelize([1,4,5,6,7])
rdd1.intersection(rdd2).collect
# => [1, 4, 5] | [
"Return",
"the",
"intersection",
"of",
"this",
"RDD",
"and",
"another",
"one",
".",
"The",
"output",
"will",
"not",
"contain",
"any",
"duplicate",
"elements",
"even",
"if",
"the",
"input",
"RDDs",
"did",
"."
] | d1b9787642fe582dee906de3c6bb9407ded27145 | https://github.com/ondra-m/ruby-spark/blob/d1b9787642fe582dee906de3c6bb9407ded27145/lib/spark/rdd.rb#L785-L793 | train |
ondra-m/ruby-spark | lib/spark/rdd.rb | Spark.RDD.partition_by | def partition_by(num_partitions, partition_func=nil)
num_partitions ||= default_reduce_partitions
partition_func ||= 'lambda{|x| Spark::Digest.portable_hash(x.to_s)}'
_partition_by(num_partitions, Spark::Command::PartitionBy::Basic, partition_func)
end | ruby | def partition_by(num_partitions, partition_func=nil)
num_partitions ||= default_reduce_partitions
partition_func ||= 'lambda{|x| Spark::Digest.portable_hash(x.to_s)}'
_partition_by(num_partitions, Spark::Command::PartitionBy::Basic, partition_func)
end | [
"def",
"partition_by",
"(",
"num_partitions",
",",
"partition_func",
"=",
"nil",
")",
"num_partitions",
"||=",
"default_reduce_partitions",
"partition_func",
"||=",
"'lambda{|x| Spark::Digest.portable_hash(x.to_s)}'",
"_partition_by",
"(",
"num_partitions",
",",
"Spark",
"::"... | Return a copy of the RDD partitioned using the specified partitioner.
== Example:
rdd = $sc.parallelize(["1","2","3","4","5"]).map(lambda {|x| [x, 1]})
rdd.partitionBy(2).glom.collect
# => [[["3", 1], ["4", 1]], [["1", 1], ["2", 1], ["5", 1]]] | [
"Return",
"a",
"copy",
"of",
"the",
"RDD",
"partitioned",
"using",
"the",
"specified",
"partitioner",
"."
] | d1b9787642fe582dee906de3c6bb9407ded27145 | https://github.com/ondra-m/ruby-spark/blob/d1b9787642fe582dee906de3c6bb9407ded27145/lib/spark/rdd.rb#L802-L807 | train |
ondra-m/ruby-spark | lib/spark/rdd.rb | Spark.RDD.take_sample | def take_sample(with_replacement, num, seed=nil)
if num < 0
raise Spark::RDDError, 'Size have to be greater than 0'
elsif num == 0
return []
end
# Taken from scala
num_st_dev = 10.0
# Number of items
initial_count = self.count
return [] if initial_count... | ruby | def take_sample(with_replacement, num, seed=nil)
if num < 0
raise Spark::RDDError, 'Size have to be greater than 0'
elsif num == 0
return []
end
# Taken from scala
num_st_dev = 10.0
# Number of items
initial_count = self.count
return [] if initial_count... | [
"def",
"take_sample",
"(",
"with_replacement",
",",
"num",
",",
"seed",
"=",
"nil",
")",
"if",
"num",
"<",
"0",
"raise",
"Spark",
"::",
"RDDError",
",",
"'Size have to be greater than 0'",
"elsif",
"num",
"==",
"0",
"return",
"[",
"]",
"end",
"num_st_dev",
... | Return a fixed-size sampled subset of this RDD in an array
== Examples:
rdd = $sc.parallelize(0..100)
rdd.take_sample(true, 10)
# => [90, 84, 74, 44, 27, 22, 72, 96, 80, 54]
rdd.take_sample(false, 10)
# => [5, 35, 30, 48, 22, 33, 40, 75, 42, 32] | [
"Return",
"a",
"fixed",
"-",
"size",
"sampled",
"subset",
"of",
"this",
"RDD",
"in",
"an",
"array"
] | d1b9787642fe582dee906de3c6bb9407ded27145 | https://github.com/ondra-m/ruby-spark/blob/d1b9787642fe582dee906de3c6bb9407ded27145/lib/spark/rdd.rb#L837-L884 | train |
ondra-m/ruby-spark | lib/spark/rdd.rb | Spark.RDD.group_by_key | def group_by_key(num_partitions=nil)
create_combiner = 'lambda{|item| [item]}'
merge_value = 'lambda{|combiner, item| combiner << item; combiner}'
merge_combiners = 'lambda{|combiner_1, combiner_2| combiner_1 += combiner_2; combiner_1}'
combine_by_key(create_combiner, merge_value, merge_com... | ruby | def group_by_key(num_partitions=nil)
create_combiner = 'lambda{|item| [item]}'
merge_value = 'lambda{|combiner, item| combiner << item; combiner}'
merge_combiners = 'lambda{|combiner_1, combiner_2| combiner_1 += combiner_2; combiner_1}'
combine_by_key(create_combiner, merge_value, merge_com... | [
"def",
"group_by_key",
"(",
"num_partitions",
"=",
"nil",
")",
"create_combiner",
"=",
"'lambda{|item| [item]}'",
"merge_value",
"=",
"'lambda{|combiner, item| combiner << item; combiner}'",
"merge_combiners",
"=",
"'lambda{|combiner_1, combiner_2| combiner_1 += combiner_2; combiner_1}... | Group the values for each key in the RDD into a single sequence. Allows controlling the
partitioning of the resulting key-value pair RDD by passing a Partitioner.
Note: If you are grouping in order to perform an aggregation (such as a sum or average)
over each key, using reduce_by_key or combine_by_key will provide... | [
"Group",
"the",
"values",
"for",
"each",
"key",
"in",
"the",
"RDD",
"into",
"a",
"single",
"sequence",
".",
"Allows",
"controlling",
"the",
"partitioning",
"of",
"the",
"resulting",
"key",
"-",
"value",
"pair",
"RDD",
"by",
"passing",
"a",
"Partitioner",
"... | d1b9787642fe582dee906de3c6bb9407ded27145 | https://github.com/ondra-m/ruby-spark/blob/d1b9787642fe582dee906de3c6bb9407ded27145/lib/spark/rdd.rb#L989-L995 | train |
ondra-m/ruby-spark | lib/spark/rdd.rb | Spark.RDD.aggregate_by_key | def aggregate_by_key(zero_value, seq_func, comb_func, num_partitions=nil)
_combine_by_key(
[Spark::Command::CombineByKey::CombineWithZero, zero_value, seq_func],
[Spark::Command::CombineByKey::Merge, comb_func],
num_partitions
)
end | ruby | def aggregate_by_key(zero_value, seq_func, comb_func, num_partitions=nil)
_combine_by_key(
[Spark::Command::CombineByKey::CombineWithZero, zero_value, seq_func],
[Spark::Command::CombineByKey::Merge, comb_func],
num_partitions
)
end | [
"def",
"aggregate_by_key",
"(",
"zero_value",
",",
"seq_func",
",",
"comb_func",
",",
"num_partitions",
"=",
"nil",
")",
"_combine_by_key",
"(",
"[",
"Spark",
"::",
"Command",
"::",
"CombineByKey",
"::",
"CombineWithZero",
",",
"zero_value",
",",
"seq_func",
"]"... | Aggregate the values of each key, using given combine functions and a neutral zero value.
== Example:
def combine(x,y)
x+y
end
def merge(x,y)
x*y
end
rdd = $sc.parallelize([["a", 1], ["b", 2], ["a", 3], ["a", 4], ["c", 5]], 2)
rdd.aggregate_by_key(1, method(:combine), method(:merge))
... | [
"Aggregate",
"the",
"values",
"of",
"each",
"key",
"using",
"given",
"combine",
"functions",
"and",
"a",
"neutral",
"zero",
"value",
"."
] | d1b9787642fe582dee906de3c6bb9407ded27145 | https://github.com/ondra-m/ruby-spark/blob/d1b9787642fe582dee906de3c6bb9407ded27145/lib/spark/rdd.rb#L1026-L1032 | train |
ondra-m/ruby-spark | lib/spark/rdd.rb | Spark.RDD.cogroup | def cogroup(*others)
unioned = self
others.each do |other|
unioned = unioned.union(other)
end
unioned.group_by_key
end | ruby | def cogroup(*others)
unioned = self
others.each do |other|
unioned = unioned.union(other)
end
unioned.group_by_key
end | [
"def",
"cogroup",
"(",
"*",
"others",
")",
"unioned",
"=",
"self",
"others",
".",
"each",
"do",
"|",
"other",
"|",
"unioned",
"=",
"unioned",
".",
"union",
"(",
"other",
")",
"end",
"unioned",
".",
"group_by_key",
"end"
] | For each key k in `this` or `other`, return a resulting RDD that contains a tuple with the
list of values for that key in `this` as well as `other`.
== Example:
rdd1 = $sc.parallelize([["a", 1], ["a", 2], ["b", 3]])
rdd2 = $sc.parallelize([["a", 4], ["a", 5], ["b", 6]])
rdd3 = $sc.parallelize([["a", 7], ["a... | [
"For",
"each",
"key",
"k",
"in",
"this",
"or",
"other",
"return",
"a",
"resulting",
"RDD",
"that",
"contains",
"a",
"tuple",
"with",
"the",
"list",
"of",
"values",
"for",
"that",
"key",
"in",
"this",
"as",
"well",
"as",
"other",
"."
] | d1b9787642fe582dee906de3c6bb9407ded27145 | https://github.com/ondra-m/ruby-spark/blob/d1b9787642fe582dee906de3c6bb9407ded27145/lib/spark/rdd.rb#L1057-L1064 | train |
ondra-m/ruby-spark | lib/spark/rdd.rb | Spark.RDD.subtract | def subtract(other, num_partitions=nil)
mapping_function = 'lambda{|x| [x,nil]}'
self.map(mapping_function)
.subtract_by_key(other.map(mapping_function), num_partitions)
.keys
end | ruby | def subtract(other, num_partitions=nil)
mapping_function = 'lambda{|x| [x,nil]}'
self.map(mapping_function)
.subtract_by_key(other.map(mapping_function), num_partitions)
.keys
end | [
"def",
"subtract",
"(",
"other",
",",
"num_partitions",
"=",
"nil",
")",
"mapping_function",
"=",
"'lambda{|x| [x,nil]}'",
"self",
".",
"map",
"(",
"mapping_function",
")",
".",
"subtract_by_key",
"(",
"other",
".",
"map",
"(",
"mapping_function",
")",
",",
"n... | Return an RDD with the elements from self that are not in other.
== Example:
rdd1 = $sc.parallelize([["a", 1], ["a", 2], ["b", 3], ["c", 4]])
rdd2 = $sc.parallelize([["a", 2], ["c", 6]])
rdd1.subtract(rdd2).collect
# => [["a", 1], ["b", 3], ["c", 4]] | [
"Return",
"an",
"RDD",
"with",
"the",
"elements",
"from",
"self",
"that",
"are",
"not",
"in",
"other",
"."
] | d1b9787642fe582dee906de3c6bb9407ded27145 | https://github.com/ondra-m/ruby-spark/blob/d1b9787642fe582dee906de3c6bb9407ded27145/lib/spark/rdd.rb#L1094-L1100 | train |
ondra-m/ruby-spark | lib/spark/rdd.rb | Spark.RDD.sort_by | def sort_by(key_function=nil, ascending=true, num_partitions=nil)
key_function ||= 'lambda{|x| x}'
num_partitions ||= default_reduce_partitions
command_klass = Spark::Command::SortByKey
# Allow spill data to disk due to memory limit
# spilling = config['spark.shuffle.spill'] || false
... | ruby | def sort_by(key_function=nil, ascending=true, num_partitions=nil)
key_function ||= 'lambda{|x| x}'
num_partitions ||= default_reduce_partitions
command_klass = Spark::Command::SortByKey
# Allow spill data to disk due to memory limit
# spilling = config['spark.shuffle.spill'] || false
... | [
"def",
"sort_by",
"(",
"key_function",
"=",
"nil",
",",
"ascending",
"=",
"true",
",",
"num_partitions",
"=",
"nil",
")",
"key_function",
"||=",
"'lambda{|x| x}'",
"num_partitions",
"||=",
"default_reduce_partitions",
"command_klass",
"=",
"Spark",
"::",
"Command",
... | Sorts this RDD by the given key_function
This is a different implementation than spark. Sort by doesn't use
key_by method first. It can be slower but take less memory and
you can always use map.sort_by_key
== Example:
rdd = $sc.parallelize(["aaaaaaa", "cc", "b", "eeee", "ddd"])
rdd.sort_by.collect
# => ... | [
"Sorts",
"this",
"RDD",
"by",
"the",
"given",
"key_function"
] | d1b9787642fe582dee906de3c6bb9407ded27145 | https://github.com/ondra-m/ruby-spark/blob/d1b9787642fe582dee906de3c6bb9407ded27145/lib/spark/rdd.rb#L1139-L1181 | train |
ondra-m/ruby-spark | lib/spark/rdd.rb | Spark.RDD._reduce | def _reduce(klass, seq_op, comb_op, zero_value=nil)
if seq_op.nil?
# Partitions are already reduced
rdd = self
else
rdd = new_rdd_from_command(klass, seq_op, zero_value)
end
# Send all results to one worker and combine results
rdd = rdd.coalesce(1).... | ruby | def _reduce(klass, seq_op, comb_op, zero_value=nil)
if seq_op.nil?
# Partitions are already reduced
rdd = self
else
rdd = new_rdd_from_command(klass, seq_op, zero_value)
end
# Send all results to one worker and combine results
rdd = rdd.coalesce(1).... | [
"def",
"_reduce",
"(",
"klass",
",",
"seq_op",
",",
"comb_op",
",",
"zero_value",
"=",
"nil",
")",
"if",
"seq_op",
".",
"nil?",
"rdd",
"=",
"self",
"else",
"rdd",
"=",
"new_rdd_from_command",
"(",
"klass",
",",
"seq_op",
",",
"zero_value",
")",
"end",
... | This is base method for reduce operation. Is used by reduce, fold and aggregation.
Only difference is that fold has zero value. | [
"This",
"is",
"base",
"method",
"for",
"reduce",
"operation",
".",
"Is",
"used",
"by",
"reduce",
"fold",
"and",
"aggregation",
".",
"Only",
"difference",
"is",
"that",
"fold",
"has",
"zero",
"value",
"."
] | d1b9787642fe582dee906de3c6bb9407ded27145 | https://github.com/ondra-m/ruby-spark/blob/d1b9787642fe582dee906de3c6bb9407ded27145/lib/spark/rdd.rb#L1301-L1318 | train |
ondra-m/ruby-spark | lib/spark/rdd.rb | Spark.RDD._combine_by_key | def _combine_by_key(combine, merge, num_partitions)
num_partitions ||= default_reduce_partitions
# Combine key
combined = new_rdd_from_command(combine.shift, *combine)
# Merge items
shuffled = combined.partition_by(num_partitions)
merge_comm = shuffled.add_command(merge... | ruby | def _combine_by_key(combine, merge, num_partitions)
num_partitions ||= default_reduce_partitions
# Combine key
combined = new_rdd_from_command(combine.shift, *combine)
# Merge items
shuffled = combined.partition_by(num_partitions)
merge_comm = shuffled.add_command(merge... | [
"def",
"_combine_by_key",
"(",
"combine",
",",
"merge",
",",
"num_partitions",
")",
"num_partitions",
"||=",
"default_reduce_partitions",
"combined",
"=",
"new_rdd_from_command",
"(",
"combine",
".",
"shift",
",",
"*",
"combine",
")",
"shuffled",
"=",
"combined",
... | For using a different combine_by_key
== Used for:
* combine_by_key
* fold_by_key (with zero value) | [
"For",
"using",
"a",
"different",
"combine_by_key"
] | d1b9787642fe582dee906de3c6bb9407ded27145 | https://github.com/ondra-m/ruby-spark/blob/d1b9787642fe582dee906de3c6bb9407ded27145/lib/spark/rdd.rb#L1341-L1352 | train |
ondra-m/ruby-spark | lib/spark/logger.rb | Spark.Logger.disable | def disable
jlogger.setLevel(level_off)
JLogger.getLogger('org').setLevel(level_off)
JLogger.getLogger('akka').setLevel(level_off)
JLogger.getRootLogger.setLevel(level_off)
end | ruby | def disable
jlogger.setLevel(level_off)
JLogger.getLogger('org').setLevel(level_off)
JLogger.getLogger('akka').setLevel(level_off)
JLogger.getRootLogger.setLevel(level_off)
end | [
"def",
"disable",
"jlogger",
".",
"setLevel",
"(",
"level_off",
")",
"JLogger",
".",
"getLogger",
"(",
"'org'",
")",
".",
"setLevel",
"(",
"level_off",
")",
"JLogger",
".",
"getLogger",
"(",
"'akka'",
")",
".",
"setLevel",
"(",
"level_off",
")",
"JLogger",... | Disable all Spark log | [
"Disable",
"all",
"Spark",
"log"
] | d1b9787642fe582dee906de3c6bb9407ded27145 | https://github.com/ondra-m/ruby-spark/blob/d1b9787642fe582dee906de3c6bb9407ded27145/lib/spark/logger.rb#L18-L23 | train |
ondra-m/ruby-spark | lib/spark/context.rb | Spark.Context.accumulator | def accumulator(value, accum_param=:+, zero_value=0)
Spark::Accumulator.new(value, accum_param, zero_value)
end | ruby | def accumulator(value, accum_param=:+, zero_value=0)
Spark::Accumulator.new(value, accum_param, zero_value)
end | [
"def",
"accumulator",
"(",
"value",
",",
"accum_param",
"=",
":+",
",",
"zero_value",
"=",
"0",
")",
"Spark",
"::",
"Accumulator",
".",
"new",
"(",
"value",
",",
"accum_param",
",",
"zero_value",
")",
"end"
] | Create an Accumulator with the given initial value, using a given
accum_param helper object to define how to add values of the
data type if provided.
== Example:
accum = $sc.accumulator(7)
rdd = $sc.parallelize(0..5, 4)
rdd = rdd.bind(accum: accum)
rdd = rdd.map_partitions(lambda{|_| accum.add(1) })
... | [
"Create",
"an",
"Accumulator",
"with",
"the",
"given",
"initial",
"value",
"using",
"a",
"given",
"accum_param",
"helper",
"object",
"to",
"define",
"how",
"to",
"add",
"values",
"of",
"the",
"data",
"type",
"if",
"provided",
"."
] | d1b9787642fe582dee906de3c6bb9407ded27145 | https://github.com/ondra-m/ruby-spark/blob/d1b9787642fe582dee906de3c6bb9407ded27145/lib/spark/context.rb#L188-L190 | train |
ondra-m/ruby-spark | lib/spark/context.rb | Spark.Context.parallelize | def parallelize(data, num_slices=nil, serializer=nil)
num_slices ||= default_parallelism
serializer ||= default_serializer
serializer.check_each(data)
# Through file
file = Tempfile.new('to_parallelize', temp_dir)
serializer.dump_to_io(data, file)
file.close # not unlink
... | ruby | def parallelize(data, num_slices=nil, serializer=nil)
num_slices ||= default_parallelism
serializer ||= default_serializer
serializer.check_each(data)
# Through file
file = Tempfile.new('to_parallelize', temp_dir)
serializer.dump_to_io(data, file)
file.close # not unlink
... | [
"def",
"parallelize",
"(",
"data",
",",
"num_slices",
"=",
"nil",
",",
"serializer",
"=",
"nil",
")",
"num_slices",
"||=",
"default_parallelism",
"serializer",
"||=",
"default_serializer",
"serializer",
".",
"check_each",
"(",
"data",
")",
"file",
"=",
"Tempfile... | Distribute a local Ruby collection to form an RDD
Direct method can be slow so be careful, this method update data inplace
== Parameters:
data:: Range or Array
num_slices:: number of slice
serializer:: custom serializer (default: serializer based on configuration)
== Examples:
$sc.parallelize(["1", "2", "3"]... | [
"Distribute",
"a",
"local",
"Ruby",
"collection",
"to",
"form",
"an",
"RDD",
"Direct",
"method",
"can",
"be",
"slow",
"so",
"be",
"careful",
"this",
"method",
"update",
"data",
"inplace"
] | d1b9787642fe582dee906de3c6bb9407ded27145 | https://github.com/ondra-m/ruby-spark/blob/d1b9787642fe582dee906de3c6bb9407ded27145/lib/spark/context.rb#L207-L222 | train |
ondra-m/ruby-spark | lib/spark/context.rb | Spark.Context.run_job | def run_job(rdd, f, partitions=nil, allow_local=false)
run_job_with_command(rdd, partitions, allow_local, Spark::Command::MapPartitions, f)
end | ruby | def run_job(rdd, f, partitions=nil, allow_local=false)
run_job_with_command(rdd, partitions, allow_local, Spark::Command::MapPartitions, f)
end | [
"def",
"run_job",
"(",
"rdd",
",",
"f",
",",
"partitions",
"=",
"nil",
",",
"allow_local",
"=",
"false",
")",
"run_job_with_command",
"(",
"rdd",
",",
"partitions",
",",
"allow_local",
",",
"Spark",
"::",
"Command",
"::",
"MapPartitions",
",",
"f",
")",
... | Executes the given partition function f on the specified set of partitions,
returning the result as an array of elements.
If partitions is not specified, this will run over all partitions.
== Example:
rdd = $sc.parallelize(0..10, 5)
$sc.run_job(rdd, lambda{|x| x.to_s}, [0,2])
# => ["[0, 1]", "[4, 5]"] | [
"Executes",
"the",
"given",
"partition",
"function",
"f",
"on",
"the",
"specified",
"set",
"of",
"partitions",
"returning",
"the",
"result",
"as",
"an",
"array",
"of",
"elements",
"."
] | d1b9787642fe582dee906de3c6bb9407ded27145 | https://github.com/ondra-m/ruby-spark/blob/d1b9787642fe582dee906de3c6bb9407ded27145/lib/spark/context.rb#L278-L280 | train |
ondra-m/ruby-spark | lib/spark/context.rb | Spark.Context.run_job_with_command | def run_job_with_command(rdd, partitions, allow_local, command, *args)
if !partitions.nil? && !partitions.is_a?(Array)
raise Spark::ContextError, 'Partitions must be nil or Array'
end
partitions_size = rdd.partitions_size
# Execute all parts
if partitions.nil?
partitions ... | ruby | def run_job_with_command(rdd, partitions, allow_local, command, *args)
if !partitions.nil? && !partitions.is_a?(Array)
raise Spark::ContextError, 'Partitions must be nil or Array'
end
partitions_size = rdd.partitions_size
# Execute all parts
if partitions.nil?
partitions ... | [
"def",
"run_job_with_command",
"(",
"rdd",
",",
"partitions",
",",
"allow_local",
",",
"command",
",",
"*",
"args",
")",
"if",
"!",
"partitions",
".",
"nil?",
"&&",
"!",
"partitions",
".",
"is_a?",
"(",
"Array",
")",
"raise",
"Spark",
"::",
"ContextError",... | Execute the given command on specific set of partitions. | [
"Execute",
"the",
"given",
"command",
"on",
"specific",
"set",
"of",
"partitions",
"."
] | d1b9787642fe582dee906de3c6bb9407ded27145 | https://github.com/ondra-m/ruby-spark/blob/d1b9787642fe582dee906de3c6bb9407ded27145/lib/spark/context.rb#L284-L309 | train |
ondra-m/ruby-spark | lib/spark/stat_counter.rb | Spark.StatCounter.merge | def merge(other)
if other.is_a?(Spark::StatCounter)
merge_stat_counter(other)
elsif other.respond_to?(:each)
merge_array(other)
else
merge_value(other)
end
self
end | ruby | def merge(other)
if other.is_a?(Spark::StatCounter)
merge_stat_counter(other)
elsif other.respond_to?(:each)
merge_array(other)
else
merge_value(other)
end
self
end | [
"def",
"merge",
"(",
"other",
")",
"if",
"other",
".",
"is_a?",
"(",
"Spark",
"::",
"StatCounter",
")",
"merge_stat_counter",
"(",
"other",
")",
"elsif",
"other",
".",
"respond_to?",
"(",
":each",
")",
"merge_array",
"(",
"other",
")",
"else",
"merge_value... | min of our values | [
"min",
"of",
"our",
"values"
] | d1b9787642fe582dee906de3c6bb9407ded27145 | https://github.com/ondra-m/ruby-spark/blob/d1b9787642fe582dee906de3c6bb9407ded27145/lib/spark/stat_counter.rb#L20-L30 | train |
magnetis/caze | lib/caze.rb | Caze.ClassMethods.raise_use_case_error | def raise_use_case_error(use_case, error)
name = error.class.name.split('::').last
klass = define_use_case_error(use_case, name)
wrapped = klass.new(error.message)
wrapped.set_backtrace(error.backtrace)
raise wrapped
end | ruby | def raise_use_case_error(use_case, error)
name = error.class.name.split('::').last
klass = define_use_case_error(use_case, name)
wrapped = klass.new(error.message)
wrapped.set_backtrace(error.backtrace)
raise wrapped
end | [
"def",
"raise_use_case_error",
"(",
"use_case",
",",
"error",
")",
"name",
"=",
"error",
".",
"class",
".",
"name",
".",
"split",
"(",
"'::'",
")",
".",
"last",
"klass",
"=",
"define_use_case_error",
"(",
"use_case",
",",
"name",
")",
"wrapped",
"=",
"kl... | This method intends to inject the error inside the context of the use case,
so we can identify the use case from it was raised | [
"This",
"method",
"intends",
"to",
"inject",
"the",
"error",
"inside",
"the",
"context",
"of",
"the",
"use",
"case",
"so",
"we",
"can",
"identify",
"the",
"use",
"case",
"from",
"it",
"was",
"raised"
] | 04a827f1efa1ad7a5ab91ce7cd2644f92b5621e0 | https://github.com/magnetis/caze/blob/04a827f1efa1ad7a5ab91ce7cd2644f92b5621e0/lib/caze.rb#L66-L74 | train |
mbryzek/schema-evolution-manager | lib/schema-evolution-manager/db.rb | SchemaEvolutionManager.Db.bootstrap! | def bootstrap!
scripts = Scripts.new(self, Scripts::BOOTSTRAP_SCRIPTS)
dir = File.join(Library.base_dir, "scripts")
scripts.each_pending(dir) do |filename, path|
psql_file(filename, path)
scripts.record_as_run!(filename)
end
end | ruby | def bootstrap!
scripts = Scripts.new(self, Scripts::BOOTSTRAP_SCRIPTS)
dir = File.join(Library.base_dir, "scripts")
scripts.each_pending(dir) do |filename, path|
psql_file(filename, path)
scripts.record_as_run!(filename)
end
end | [
"def",
"bootstrap!",
"scripts",
"=",
"Scripts",
".",
"new",
"(",
"self",
",",
"Scripts",
"::",
"BOOTSTRAP_SCRIPTS",
")",
"dir",
"=",
"File",
".",
"join",
"(",
"Library",
".",
"base_dir",
",",
"\"scripts\"",
")",
"scripts",
".",
"each_pending",
"(",
"dir",
... | Installs schema_evolution_manager. Automatically upgrades schema_evolution_manager. | [
"Installs",
"schema_evolution_manager",
".",
"Automatically",
"upgrades",
"schema_evolution_manager",
"."
] | eda4f9bd653c2248492b43256daf5e2a41bfff7e | https://github.com/mbryzek/schema-evolution-manager/blob/eda4f9bd653c2248492b43256daf5e2a41bfff7e/lib/schema-evolution-manager/db.rb#L19-L26 | train |
mbryzek/schema-evolution-manager | lib/schema-evolution-manager/db.rb | SchemaEvolutionManager.Db.psql_command | def psql_command(sql_command)
Preconditions.assert_class(sql_command, String)
command = "psql --no-align --tuples-only --no-psqlrc --command \"%s\" %s" % [sql_command, @url]
Library.system_or_error(command)
end | ruby | def psql_command(sql_command)
Preconditions.assert_class(sql_command, String)
command = "psql --no-align --tuples-only --no-psqlrc --command \"%s\" %s" % [sql_command, @url]
Library.system_or_error(command)
end | [
"def",
"psql_command",
"(",
"sql_command",
")",
"Preconditions",
".",
"assert_class",
"(",
"sql_command",
",",
"String",
")",
"command",
"=",
"\"psql --no-align --tuples-only --no-psqlrc --command \\\"%s\\\" %s\"",
"%",
"[",
"sql_command",
",",
"@url",
"]",
"Library",
"... | executes a simple sql command. | [
"executes",
"a",
"simple",
"sql",
"command",
"."
] | eda4f9bd653c2248492b43256daf5e2a41bfff7e | https://github.com/mbryzek/schema-evolution-manager/blob/eda4f9bd653c2248492b43256daf5e2a41bfff7e/lib/schema-evolution-manager/db.rb#L29-L33 | train |
mbryzek/schema-evolution-manager | lib/schema-evolution-manager/migration_file.rb | SchemaEvolutionManager.MigrationFile.parse_attribute_values | def parse_attribute_values
values = []
each_property do |name, value|
values << AttributeValue.new(name, value)
end
DEFAULTS.each do |default|
if values.find { |v| v.attribute.name == default.attribute.name }.nil?
values << default
end
end
values
... | ruby | def parse_attribute_values
values = []
each_property do |name, value|
values << AttributeValue.new(name, value)
end
DEFAULTS.each do |default|
if values.find { |v| v.attribute.name == default.attribute.name }.nil?
values << default
end
end
values
... | [
"def",
"parse_attribute_values",
"values",
"=",
"[",
"]",
"each_property",
"do",
"|",
"name",
",",
"value",
"|",
"values",
"<<",
"AttributeValue",
".",
"new",
"(",
"name",
",",
"value",
")",
"end",
"DEFAULTS",
".",
"each",
"do",
"|",
"default",
"|",
"if"... | Returns a list of AttributeValues from the file itself,
including all defaults set by SEM. AttributeValues are defined
in comments in the file. | [
"Returns",
"a",
"list",
"of",
"AttributeValues",
"from",
"the",
"file",
"itself",
"including",
"all",
"defaults",
"set",
"by",
"SEM",
".",
"AttributeValues",
"are",
"defined",
"in",
"comments",
"in",
"the",
"file",
"."
] | eda4f9bd653c2248492b43256daf5e2a41bfff7e | https://github.com/mbryzek/schema-evolution-manager/blob/eda4f9bd653c2248492b43256daf5e2a41bfff7e/lib/schema-evolution-manager/migration_file.rb#L60-L73 | train |
mbryzek/schema-evolution-manager | lib/schema-evolution-manager/scripts.rb | SchemaEvolutionManager.Scripts.each_pending | def each_pending(dir)
files = {}
Scripts.all(dir).each do |path|
name = File.basename(path)
files[name] = path
end
scripts_previously_run(files.keys).each do |filename|
files.delete(filename)
end
files.keys.sort.each do |filename|
## We have to reche... | ruby | def each_pending(dir)
files = {}
Scripts.all(dir).each do |path|
name = File.basename(path)
files[name] = path
end
scripts_previously_run(files.keys).each do |filename|
files.delete(filename)
end
files.keys.sort.each do |filename|
## We have to reche... | [
"def",
"each_pending",
"(",
"dir",
")",
"files",
"=",
"{",
"}",
"Scripts",
".",
"all",
"(",
"dir",
")",
".",
"each",
"do",
"|",
"path",
"|",
"name",
"=",
"File",
".",
"basename",
"(",
"path",
")",
"files",
"[",
"name",
"]",
"=",
"path",
"end",
... | For each sql script that needs to be applied to this database,
yields a pair of |filename, fullpath| in proper order
db = Db.new(host, user, name)
scripts = Scripts.new(db)
scripts.each_pending do |filename, path|
puts filename
end | [
"For",
"each",
"sql",
"script",
"that",
"needs",
"to",
"be",
"applied",
"to",
"this",
"database",
"yields",
"a",
"pair",
"of",
"|filename",
"fullpath|",
"in",
"proper",
"order"
] | eda4f9bd653c2248492b43256daf5e2a41bfff7e | https://github.com/mbryzek/schema-evolution-manager/blob/eda4f9bd653c2248492b43256daf5e2a41bfff7e/lib/schema-evolution-manager/scripts.rb#L41-L61 | train |
mbryzek/schema-evolution-manager | lib/schema-evolution-manager/scripts.rb | SchemaEvolutionManager.Scripts.has_run? | def has_run?(filename)
if @db.schema_schema_evolution_manager_exists?
query = "select count(*) from %s.%s where filename = '%s'" % [Db.schema_name, @table_name, filename]
@db.psql_command(query).to_i > 0
else
false
end
end | ruby | def has_run?(filename)
if @db.schema_schema_evolution_manager_exists?
query = "select count(*) from %s.%s where filename = '%s'" % [Db.schema_name, @table_name, filename]
@db.psql_command(query).to_i > 0
else
false
end
end | [
"def",
"has_run?",
"(",
"filename",
")",
"if",
"@db",
".",
"schema_schema_evolution_manager_exists?",
"query",
"=",
"\"select count(*) from %s.%s where filename = '%s'\"",
"%",
"[",
"Db",
".",
"schema_name",
",",
"@table_name",
",",
"filename",
"]",
"@db",
".",
"psql_... | True if this script has already been applied to the db. False
otherwise. | [
"True",
"if",
"this",
"script",
"has",
"already",
"been",
"applied",
"to",
"the",
"db",
".",
"False",
"otherwise",
"."
] | eda4f9bd653c2248492b43256daf5e2a41bfff7e | https://github.com/mbryzek/schema-evolution-manager/blob/eda4f9bd653c2248492b43256daf5e2a41bfff7e/lib/schema-evolution-manager/scripts.rb#L65-L72 | train |
mbryzek/schema-evolution-manager | lib/schema-evolution-manager/scripts.rb | SchemaEvolutionManager.Scripts.record_as_run! | def record_as_run!(filename)
Preconditions.check_state(filename.match(/^\d\d\d\d\d\d+\-\d\d\d\d\d\d\.sql$/),
"Invalid filename[#{filename}]. Must be like: 20120503-173242.sql")
command = "insert into %s.%s (filename) select '%s' where not exists (select 1 from %s.%s where fil... | ruby | def record_as_run!(filename)
Preconditions.check_state(filename.match(/^\d\d\d\d\d\d+\-\d\d\d\d\d\d\.sql$/),
"Invalid filename[#{filename}]. Must be like: 20120503-173242.sql")
command = "insert into %s.%s (filename) select '%s' where not exists (select 1 from %s.%s where fil... | [
"def",
"record_as_run!",
"(",
"filename",
")",
"Preconditions",
".",
"check_state",
"(",
"filename",
".",
"match",
"(",
"/",
"\\d",
"\\d",
"\\d",
"\\d",
"\\d",
"\\d",
"\\-",
"\\d",
"\\d",
"\\d",
"\\d",
"\\d",
"\\d",
"\\.",
"/",
")",
",",
"\"Invalid filen... | Inserts a record to indiciate that we have loaded the specified file. | [
"Inserts",
"a",
"record",
"to",
"indiciate",
"that",
"we",
"have",
"loaded",
"the",
"specified",
"file",
"."
] | eda4f9bd653c2248492b43256daf5e2a41bfff7e | https://github.com/mbryzek/schema-evolution-manager/blob/eda4f9bd653c2248492b43256daf5e2a41bfff7e/lib/schema-evolution-manager/scripts.rb#L75-L80 | train |
mbryzek/schema-evolution-manager | lib/schema-evolution-manager/scripts.rb | SchemaEvolutionManager.Scripts.scripts_previously_run | def scripts_previously_run(scripts)
if scripts.empty? || !@db.schema_schema_evolution_manager_exists?
[]
else
sql = "select filename from %s.%s where filename in (%s)" % [Db.schema_name, @table_name, "'" + scripts.join("', '") + "'"]
@db.psql_command(sql).strip.split
end
en... | ruby | def scripts_previously_run(scripts)
if scripts.empty? || !@db.schema_schema_evolution_manager_exists?
[]
else
sql = "select filename from %s.%s where filename in (%s)" % [Db.schema_name, @table_name, "'" + scripts.join("', '") + "'"]
@db.psql_command(sql).strip.split
end
en... | [
"def",
"scripts_previously_run",
"(",
"scripts",
")",
"if",
"scripts",
".",
"empty?",
"||",
"!",
"@db",
".",
"schema_schema_evolution_manager_exists?",
"[",
"]",
"else",
"sql",
"=",
"\"select filename from %s.%s where filename in (%s)\"",
"%",
"[",
"Db",
".",
"schema_... | Fetch the list of scripts that have already been applied to this
database. | [
"Fetch",
"the",
"list",
"of",
"scripts",
"that",
"have",
"already",
"been",
"applied",
"to",
"this",
"database",
"."
] | eda4f9bd653c2248492b43256daf5e2a41bfff7e | https://github.com/mbryzek/schema-evolution-manager/blob/eda4f9bd653c2248492b43256daf5e2a41bfff7e/lib/schema-evolution-manager/scripts.rb#L85-L92 | train |
mbryzek/schema-evolution-manager | lib/schema-evolution-manager/install_template.rb | SchemaEvolutionManager.InstallTemplate.generate | def generate
template = Template.new
template.add('timestamp', Time.now.to_s)
template.add('lib_dir', @lib_dir)
template.add('bin_dir', @bin_dir)
template.parse(TEMPLATE)
end | ruby | def generate
template = Template.new
template.add('timestamp', Time.now.to_s)
template.add('lib_dir', @lib_dir)
template.add('bin_dir', @bin_dir)
template.parse(TEMPLATE)
end | [
"def",
"generate",
"template",
"=",
"Template",
".",
"new",
"template",
".",
"add",
"(",
"'timestamp'",
",",
"Time",
".",
"now",
".",
"to_s",
")",
"template",
".",
"add",
"(",
"'lib_dir'",
",",
"@lib_dir",
")",
"template",
".",
"add",
"(",
"'bin_dir'",
... | Generates the actual contents of the install file | [
"Generates",
"the",
"actual",
"contents",
"of",
"the",
"install",
"file"
] | eda4f9bd653c2248492b43256daf5e2a41bfff7e | https://github.com/mbryzek/schema-evolution-manager/blob/eda4f9bd653c2248492b43256daf5e2a41bfff7e/lib/schema-evolution-manager/install_template.rb#L12-L18 | train |
yohasebe/wp2txt | lib/wp2txt.rb | Wp2txt.Runner.fill_buffer | def fill_buffer
while true do
begin
new_lines = @file_pointer.read(10485760)
rescue => e
return nil
end
return nil unless new_lines
# temp_buf is filled with text split by "\n"
temp_buf = []
ss = StringScanner.new(new_lines)
... | ruby | def fill_buffer
while true do
begin
new_lines = @file_pointer.read(10485760)
rescue => e
return nil
end
return nil unless new_lines
# temp_buf is filled with text split by "\n"
temp_buf = []
ss = StringScanner.new(new_lines)
... | [
"def",
"fill_buffer",
"while",
"true",
"do",
"begin",
"new_lines",
"=",
"@file_pointer",
".",
"read",
"(",
"10485760",
")",
"rescue",
"=>",
"e",
"return",
"nil",
"end",
"return",
"nil",
"unless",
"new_lines",
"temp_buf",
"=",
"[",
"]",
"ss",
"=",
"StringSc... | read text data from bz2 compressed file by 1 megabyte | [
"read",
"text",
"data",
"from",
"bz2",
"compressed",
"file",
"by",
"1",
"megabyte"
] | 0938ddd3b076611ce37c8f9decc58cf97589c06c | https://github.com/yohasebe/wp2txt/blob/0938ddd3b076611ce37c8f9decc58cf97589c06c/lib/wp2txt.rb#L146-L177 | train |
chrisvfritz/language_filter | lib/language_filter.rb | LanguageFilter.Filter.replace | def replace(word)
case @replacement
when :vowels then word.gsub(/[aeiou]/i, '*')
when :stars then '*' * word.size
when :nonconsonants then word.gsub(/[^bcdfghjklmnpqrstvwxyz]/i, '*')
when :default, :garbled then '$@!#%'
else raise LanguageFilter::UnknownReplacement.new("#{@replaceme... | ruby | def replace(word)
case @replacement
when :vowels then word.gsub(/[aeiou]/i, '*')
when :stars then '*' * word.size
when :nonconsonants then word.gsub(/[^bcdfghjklmnpqrstvwxyz]/i, '*')
when :default, :garbled then '$@!#%'
else raise LanguageFilter::UnknownReplacement.new("#{@replaceme... | [
"def",
"replace",
"(",
"word",
")",
"case",
"@replacement",
"when",
":vowels",
"then",
"word",
".",
"gsub",
"(",
"/",
"/i",
",",
"'*'",
")",
"when",
":stars",
"then",
"'*'",
"*",
"word",
".",
"size",
"when",
":nonconsonants",
"then",
"word",
".",
"gsub... | This was moved to private because users should just use sanitize for any content | [
"This",
"was",
"moved",
"to",
"private",
"because",
"users",
"should",
"just",
"use",
"sanitize",
"for",
"any",
"content"
] | 084fe0654e4cb18e0a145fad1006dcf98bf4011c | https://github.com/chrisvfritz/language_filter/blob/084fe0654e4cb18e0a145fad1006dcf98bf4011c/lib/language_filter.rb#L258-L266 | train |
benbalter/jekyll-readme-index | lib/jekyll/static_file_ext.rb | Jekyll.StaticFile.to_page | def to_page
page = Jekyll::Page.new(@site, @base, @dir, @name)
page.data["permalink"] = File.dirname(url) + "/"
page
end | ruby | def to_page
page = Jekyll::Page.new(@site, @base, @dir, @name)
page.data["permalink"] = File.dirname(url) + "/"
page
end | [
"def",
"to_page",
"page",
"=",
"Jekyll",
"::",
"Page",
".",
"new",
"(",
"@site",
",",
"@base",
",",
"@dir",
",",
"@name",
")",
"page",
".",
"data",
"[",
"\"permalink\"",
"]",
"=",
"File",
".",
"dirname",
"(",
"url",
")",
"+",
"\"/\"",
"page",
"end"... | Convert this static file to a Page | [
"Convert",
"this",
"static",
"file",
"to",
"a",
"Page"
] | 19897e9250c3e410c5fc461b6f5737902bb7208f | https://github.com/benbalter/jekyll-readme-index/blob/19897e9250c3e410c5fc461b6f5737902bb7208f/lib/jekyll/static_file_ext.rb#L6-L10 | train |
sue445/apple_system_status | lib/apple_system_status/crawler.rb | AppleSystemStatus.Crawler.perform | def perform(country: nil, title: nil)
@session.visit(apple_url(country))
response = {
title: @session.find(".section-date .date-copy").text.strip,
services: [],
}
MAX_RETRY_COUNT.times do
services = fetch_services
if services.empty?
# wait until th... | ruby | def perform(country: nil, title: nil)
@session.visit(apple_url(country))
response = {
title: @session.find(".section-date .date-copy").text.strip,
services: [],
}
MAX_RETRY_COUNT.times do
services = fetch_services
if services.empty?
# wait until th... | [
"def",
"perform",
"(",
"country",
":",
"nil",
",",
"title",
":",
"nil",
")",
"@session",
".",
"visit",
"(",
"apple_url",
"(",
"country",
")",
")",
"response",
"=",
"{",
"title",
":",
"@session",
".",
"find",
"(",
"\".section-date .date-copy\"",
")",
".",... | crawl apple system status page
@param country [String] country code. (e.g. jp, ca, fr. default. us)
@param title [String] If specified, narrow the service title
@return [Hash]
@example response format
{
title: ,
services: [
{ title: , description: , status: }
]
} | [
"crawl",
"apple",
"system",
"status",
"page"
] | 9675c02e2157081f7e7a607e740430c67b0a603a | https://github.com/sue445/apple_system_status/blob/9675c02e2157081f7e7a607e740430c67b0a603a/lib/apple_system_status/crawler.rb#L55-L84 | train |
14113/fio_api | lib/base/list.rb | FioAPI.List.fetch_and_deserialize_response | def fetch_and_deserialize_response(path)
self.request = FioAPI::Request.get(path, parser: ListResponseDeserializer)
self.response = request.parsed_response
request
end | ruby | def fetch_and_deserialize_response(path)
self.request = FioAPI::Request.get(path, parser: ListResponseDeserializer)
self.response = request.parsed_response
request
end | [
"def",
"fetch_and_deserialize_response",
"(",
"path",
")",
"self",
".",
"request",
"=",
"FioAPI",
"::",
"Request",
".",
"get",
"(",
"path",
",",
"parser",
":",
"ListResponseDeserializer",
")",
"self",
".",
"response",
"=",
"request",
".",
"parsed_response",
"r... | Create request object ot provided uri and instantiate list deserializer.
Request uri and deserialize response to response object with account info and transactions list.
== Parameters:
args::
Parts of uri
== Returns:
List insatnce with account info and transactions list | [
"Create",
"request",
"object",
"ot",
"provided",
"uri",
"and",
"instantiate",
"list",
"deserializer",
".",
"Request",
"uri",
"and",
"deserialize",
"response",
"to",
"response",
"object",
"with",
"account",
"info",
"and",
"transactions",
"list",
"."
] | f982c27332ef629929aff03f93e8df9c7516414c | https://github.com/14113/fio_api/blob/f982c27332ef629929aff03f93e8df9c7516414c/lib/base/list.rb#L88-L92 | train |
archangel/archangel | app/helpers/archangel/flash_helper.rb | Archangel.FlashHelper.flash_class_for | def flash_class_for(flash_type)
flash_type = flash_type.to_s.downcase.parameterize
{
success: "success", error: "danger", alert: "warning", notice: "info"
}.fetch(flash_type.to_sym, flash_type)
end | ruby | def flash_class_for(flash_type)
flash_type = flash_type.to_s.downcase.parameterize
{
success: "success", error: "danger", alert: "warning", notice: "info"
}.fetch(flash_type.to_sym, flash_type)
end | [
"def",
"flash_class_for",
"(",
"flash_type",
")",
"flash_type",
"=",
"flash_type",
".",
"to_s",
".",
"downcase",
".",
"parameterize",
"{",
"success",
":",
"\"success\"",
",",
"error",
":",
"\"danger\"",
",",
"alert",
":",
"\"warning\"",
",",
"notice",
":",
"... | Converts Rails flash message type to Bootstrap flash message type
@param flash_type [String,Symbol] the flash message type
@return [String] flash message type | [
"Converts",
"Rails",
"flash",
"message",
"type",
"to",
"Bootstrap",
"flash",
"message",
"type"
] | f84a9e3a0003f64a6057f8f4db1e05163a7d43b6 | https://github.com/archangel/archangel/blob/f84a9e3a0003f64a6057f8f4db1e05163a7d43b6/app/helpers/archangel/flash_helper.rb#L14-L20 | train |
artsy/momentum | lib/momentum/opsworks.rb | Momentum::OpsWorks.Deployer.execute_recipe! | def execute_recipe!(stack_name, layer, recipe, app_name = Momentum.config[:app_base_name])
raise "No recipe provided" unless recipe
stack = Momentum::OpsWorks.get_stack(@ow, stack_name)
app = Momentum::OpsWorks.get_app(@ow, stack, app_name)
layer_names = layer ? [layer] : Momentum.config[:app_la... | ruby | def execute_recipe!(stack_name, layer, recipe, app_name = Momentum.config[:app_base_name])
raise "No recipe provided" unless recipe
stack = Momentum::OpsWorks.get_stack(@ow, stack_name)
app = Momentum::OpsWorks.get_app(@ow, stack, app_name)
layer_names = layer ? [layer] : Momentum.config[:app_la... | [
"def",
"execute_recipe!",
"(",
"stack_name",
",",
"layer",
",",
"recipe",
",",
"app_name",
"=",
"Momentum",
".",
"config",
"[",
":app_base_name",
"]",
")",
"raise",
"\"No recipe provided\"",
"unless",
"recipe",
"stack",
"=",
"Momentum",
"::",
"OpsWorks",
".",
... | wait up to 15 minutes | [
"wait",
"up",
"to",
"15",
"minutes"
] | 61b9926a783c3a3fc4f105334d1e291273132392 | https://github.com/artsy/momentum/blob/61b9926a783c3a3fc4f105334d1e291273132392/lib/momentum/opsworks.rb#L68-L87 | train |
fixrb/fix | lib/fix/on.rb | Fix.On.it | def it(*, &spec)
i = It.new(described, challenges, helpers)
result = i.verify(&spec)
if configuration.fetch(:verbose, true)
print result.to_char(configuration.fetch(:color, false))
end
results << result
end | ruby | def it(*, &spec)
i = It.new(described, challenges, helpers)
result = i.verify(&spec)
if configuration.fetch(:verbose, true)
print result.to_char(configuration.fetch(:color, false))
end
results << result
end | [
"def",
"it",
"(",
"*",
",",
"&",
"spec",
")",
"i",
"=",
"It",
".",
"new",
"(",
"described",
",",
"challenges",
",",
"helpers",
")",
"result",
"=",
"i",
".",
"verify",
"(",
"&",
"spec",
")",
"if",
"configuration",
".",
"fetch",
"(",
":verbose",
",... | Add it method to the DSL.
@api public
@example It must eql "FOO"
it { MUST equal 'FOO' }
@param spec [Proc] A spec to compare against the computed actual value.
@return [Array] List of results. | [
"Add",
"it",
"method",
"to",
"the",
"DSL",
"."
] | 7023dce0c28eb92db7a2dbafe56e81246f215e31 | https://github.com/fixrb/fix/blob/7023dce0c28eb92db7a2dbafe56e81246f215e31/lib/fix/on.rb#L62-L72 | train |
fixrb/fix | lib/fix/on.rb | Fix.On.on | def on(method_name, *args, &block)
o = On.new(described,
results,
(challenges + [Defi.send(method_name, *args)]),
helpers.dup,
configuration)
o.instance_eval(&block)
end | ruby | def on(method_name, *args, &block)
o = On.new(described,
results,
(challenges + [Defi.send(method_name, *args)]),
helpers.dup,
configuration)
o.instance_eval(&block)
end | [
"def",
"on",
"(",
"method_name",
",",
"*",
"args",
",",
"&",
"block",
")",
"o",
"=",
"On",
".",
"new",
"(",
"described",
",",
"results",
",",
"(",
"challenges",
"+",
"[",
"Defi",
".",
"send",
"(",
"method_name",
",",
"*",
"args",
")",
"]",
")",
... | Add on method to the DSL.
@api public
@example On +2, it must equal 44.
on(:+, 2) do
it { MUST equal 44 }
end
@param method_name [Symbol] The identifier of a method.
@param args [Array] A list of arguments.
@param block [Proc] A spec to compare against the computed value.
@return [A... | [
"Add",
"on",
"method",
"to",
"the",
"DSL",
"."
] | 7023dce0c28eb92db7a2dbafe56e81246f215e31 | https://github.com/fixrb/fix/blob/7023dce0c28eb92db7a2dbafe56e81246f215e31/lib/fix/on.rb#L88-L96 | train |
fixrb/fix | lib/fix/on.rb | Fix.On.context | def context(*, &block)
o = On.new(described,
[],
challenges,
helpers.dup,
configuration)
results.concat(Aw.fork! { o.instance_eval(&block) })
end | ruby | def context(*, &block)
o = On.new(described,
[],
challenges,
helpers.dup,
configuration)
results.concat(Aw.fork! { o.instance_eval(&block) })
end | [
"def",
"context",
"(",
"*",
",",
"&",
"block",
")",
"o",
"=",
"On",
".",
"new",
"(",
"described",
",",
"[",
"]",
",",
"challenges",
",",
"helpers",
".",
"dup",
",",
"configuration",
")",
"results",
".",
"concat",
"(",
"Aw",
".",
"fork!",
"{",
"o"... | Add context method to the DSL, to build an isolated scope.
@api public
@example Context when logged in.
context 'when logged in' do
it { MUST equal 200 }
end
@param block [Proc] A block of specs to test in isolation.
@return [Array] List of results. | [
"Add",
"context",
"method",
"to",
"the",
"DSL",
"to",
"build",
"an",
"isolated",
"scope",
"."
] | 7023dce0c28eb92db7a2dbafe56e81246f215e31 | https://github.com/fixrb/fix/blob/7023dce0c28eb92db7a2dbafe56e81246f215e31/lib/fix/on.rb#L127-L135 | train |
aastronautss/emittance | lib/emittance/watcher.rb | Emittance.Watcher.watch | def watch(identifier, callback_method = nil, **params, &callback)
if callback
_dispatcher(params).register identifier, params, &callback
else
_dispatcher(params).register_method_call identifier, self, callback_method, params
end
end | ruby | def watch(identifier, callback_method = nil, **params, &callback)
if callback
_dispatcher(params).register identifier, params, &callback
else
_dispatcher(params).register_method_call identifier, self, callback_method, params
end
end | [
"def",
"watch",
"(",
"identifier",
",",
"callback_method",
"=",
"nil",
",",
"**",
"params",
",",
"&",
"callback",
")",
"if",
"callback",
"_dispatcher",
"(",
"params",
")",
".",
"register",
"identifier",
",",
"params",
",",
"&",
"callback",
"else",
"_dispat... | Watch for an event, identified by its class' identifier. If a callback method is provided, then it will call that
method on the caller of +watch+ when the event happens. Otherwise, it will run the callback block.
@param identifier [Symbol] the event's identifier
@param callback_method [Symbol] one option for adding... | [
"Watch",
"for",
"an",
"event",
"identified",
"by",
"its",
"class",
"identifier",
".",
"If",
"a",
"callback",
"method",
"is",
"provided",
"then",
"it",
"will",
"call",
"that",
"method",
"on",
"the",
"caller",
"of",
"+",
"watch",
"+",
"when",
"the",
"event... | 3ff045c4b3f35c1ca7743bc09bcb1fff7934204c | https://github.com/aastronautss/emittance/blob/3ff045c4b3f35c1ca7743bc09bcb1fff7934204c/lib/emittance/watcher.rb#L18-L24 | train |
archangel/archangel | app/services/archangel/render_service.rb | Archangel.RenderService.call | def call
liquid = ::Liquid::Template.parse(template)
liquid.send(:render, stringify_assigns, liquid_options).html_safe
end | ruby | def call
liquid = ::Liquid::Template.parse(template)
liquid.send(:render, stringify_assigns, liquid_options).html_safe
end | [
"def",
"call",
"liquid",
"=",
"::",
"Liquid",
"::",
"Template",
".",
"parse",
"(",
"template",
")",
"liquid",
".",
"send",
"(",
":render",
",",
"stringify_assigns",
",",
"liquid_options",
")",
".",
"html_safe",
"end"
] | Render the Liquid content
@return [String] the rendered content | [
"Render",
"the",
"Liquid",
"content"
] | f84a9e3a0003f64a6057f8f4db1e05163a7d43b6 | https://github.com/archangel/archangel/blob/f84a9e3a0003f64a6057f8f4db1e05163a7d43b6/app/services/archangel/render_service.rb#L59-L62 | train |
archangel/archangel | app/helpers/archangel/application_helper.rb | Archangel.ApplicationHelper.frontend_resource_path | def frontend_resource_path(resource)
permalink_path = proc do |permalink|
archangel.frontend_page_path(permalink).gsub("%2F", "/")
end
return permalink_path.call(resource) unless resource.class == Page
return archangel.frontend_root_path if resource.homepage?
permalink_path.call(... | ruby | def frontend_resource_path(resource)
permalink_path = proc do |permalink|
archangel.frontend_page_path(permalink).gsub("%2F", "/")
end
return permalink_path.call(resource) unless resource.class == Page
return archangel.frontend_root_path if resource.homepage?
permalink_path.call(... | [
"def",
"frontend_resource_path",
"(",
"resource",
")",
"permalink_path",
"=",
"proc",
"do",
"|",
"permalink",
"|",
"archangel",
".",
"frontend_page_path",
"(",
"permalink",
")",
".",
"gsub",
"(",
"\"%2F\"",
",",
"\"/\"",
")",
"end",
"return",
"permalink_path",
... | Frontend resource permalink.
Same as `frontend_page_path` except it prints out nested resources in a
nice way.
Example
<%= frontend_resource_path('foo/bar') %> #=> /foo/bar
<%= frontend_resource_path(@page) %> #=> /foo/bar
@return [String] frontend resource permalink | [
"Frontend",
"resource",
"permalink",
"."
] | f84a9e3a0003f64a6057f8f4db1e05163a7d43b6 | https://github.com/archangel/archangel/blob/f84a9e3a0003f64a6057f8f4db1e05163a7d43b6/app/helpers/archangel/application_helper.rb#L20-L29 | train |
YotpoLtd/seoshop-api | lib/seoshop-api/client.rb | Seoshop.Client.get | def get(url, params = {})
params = params.inject({}){|memo,(k,v)| memo[k.to_s] = v; memo}
preform(url, :get, params: params) do
return connection.get(url, params)
end
end | ruby | def get(url, params = {})
params = params.inject({}){|memo,(k,v)| memo[k.to_s] = v; memo}
preform(url, :get, params: params) do
return connection.get(url, params)
end
end | [
"def",
"get",
"(",
"url",
",",
"params",
"=",
"{",
"}",
")",
"params",
"=",
"params",
".",
"inject",
"(",
"{",
"}",
")",
"{",
"|",
"memo",
",",
"(",
"k",
",",
"v",
")",
"|",
"memo",
"[",
"k",
".",
"to_s",
"]",
"=",
"v",
";",
"memo",
"}",
... | Does a GET request to the url with the params
@param url [String] the relative path in the Seoshop API
@param params [Hash] the url params that should be passed in the request | [
"Does",
"a",
"GET",
"request",
"to",
"the",
"url",
"with",
"the",
"params"
] | 7b1ea990824222be8c4543384c97b5640b97e433 | https://github.com/YotpoLtd/seoshop-api/blob/7b1ea990824222be8c4543384c97b5640b97e433/lib/seoshop-api/client.rb#L73-L78 | train |
YotpoLtd/seoshop-api | lib/seoshop-api/client.rb | Seoshop.Client.post | def post(url, params)
params = convert_hash_keys(params)
preform(url, :post, params: params) do
return connection.post(url, params)
end
end | ruby | def post(url, params)
params = convert_hash_keys(params)
preform(url, :post, params: params) do
return connection.post(url, params)
end
end | [
"def",
"post",
"(",
"url",
",",
"params",
")",
"params",
"=",
"convert_hash_keys",
"(",
"params",
")",
"preform",
"(",
"url",
",",
":post",
",",
"params",
":",
"params",
")",
"do",
"return",
"connection",
".",
"post",
"(",
"url",
",",
"params",
")",
... | Does a POST request to the url with the params
@param url [String] the relative path in the Seoshop API
@param params [Hash] the body of the request | [
"Does",
"a",
"POST",
"request",
"to",
"the",
"url",
"with",
"the",
"params"
] | 7b1ea990824222be8c4543384c97b5640b97e433 | https://github.com/YotpoLtd/seoshop-api/blob/7b1ea990824222be8c4543384c97b5640b97e433/lib/seoshop-api/client.rb#L85-L90 | train |
YotpoLtd/seoshop-api | lib/seoshop-api/client.rb | Seoshop.Client.put | def put(url, params)
params = convert_hash_keys(params)
preform(url, :put, params: params) do
return connection.put(url, params)
end
end | ruby | def put(url, params)
params = convert_hash_keys(params)
preform(url, :put, params: params) do
return connection.put(url, params)
end
end | [
"def",
"put",
"(",
"url",
",",
"params",
")",
"params",
"=",
"convert_hash_keys",
"(",
"params",
")",
"preform",
"(",
"url",
",",
":put",
",",
"params",
":",
"params",
")",
"do",
"return",
"connection",
".",
"put",
"(",
"url",
",",
"params",
")",
"en... | Does a PUT request to the url with the params
@param url [String] the relative path in the Seoshop API
@param params [Hash] the body of the request | [
"Does",
"a",
"PUT",
"request",
"to",
"the",
"url",
"with",
"the",
"params"
] | 7b1ea990824222be8c4543384c97b5640b97e433 | https://github.com/YotpoLtd/seoshop-api/blob/7b1ea990824222be8c4543384c97b5640b97e433/lib/seoshop-api/client.rb#L97-L102 | train |
archangel/archangel | lib/archangel/liquid_view.rb | Archangel.LiquidView.render | def render(template, local_assigns = {})
default_controller.headers["Content-Type"] ||= "text/html; charset=utf-8"
assigns = default_assigns(local_assigns)
options = { registers: default_registers }
Archangel::RenderService.call(template, assigns, options)
end | ruby | def render(template, local_assigns = {})
default_controller.headers["Content-Type"] ||= "text/html; charset=utf-8"
assigns = default_assigns(local_assigns)
options = { registers: default_registers }
Archangel::RenderService.call(template, assigns, options)
end | [
"def",
"render",
"(",
"template",
",",
"local_assigns",
"=",
"{",
"}",
")",
"default_controller",
".",
"headers",
"[",
"\"Content-Type\"",
"]",
"||=",
"\"text/html; charset=utf-8\"",
"assigns",
"=",
"default_assigns",
"(",
"local_assigns",
")",
"options",
"=",
"{"... | Render Liquid content
@param template [String] the content
@param local_assigns [Hash] the local assigned variables
@return [String] the rendered content | [
"Render",
"Liquid",
"content"
] | f84a9e3a0003f64a6057f8f4db1e05163a7d43b6 | https://github.com/archangel/archangel/blob/f84a9e3a0003f64a6057f8f4db1e05163a7d43b6/lib/archangel/liquid_view.rb#L35-L42 | train |
inukshuk/bibtex-ruby | lib/bibtex/lexer.rb | BibTeX.Lexer.push | def push(value)
case value[0]
when :CONTENT, :STRING_LITERAL
value[1].gsub!(/\n\s*/, ' ') if strip_line_breaks?
if !@stack.empty? && value[0] == @stack[-1][0]
@stack[-1][1] << value[1]
else
@stack.push(value)
end
when :ERROR
@stack.push(valu... | ruby | def push(value)
case value[0]
when :CONTENT, :STRING_LITERAL
value[1].gsub!(/\n\s*/, ' ') if strip_line_breaks?
if !@stack.empty? && value[0] == @stack[-1][0]
@stack[-1][1] << value[1]
else
@stack.push(value)
end
when :ERROR
@stack.push(valu... | [
"def",
"push",
"(",
"value",
")",
"case",
"value",
"[",
"0",
"]",
"when",
":CONTENT",
",",
":STRING_LITERAL",
"value",
"[",
"1",
"]",
".",
"gsub!",
"(",
"/",
"\\n",
"\\s",
"/",
",",
"' '",
")",
"if",
"strip_line_breaks?",
"if",
"!",
"@stack",
".",
... | Pushes a value onto the parse stack. Returns the Lexer. | [
"Pushes",
"a",
"value",
"onto",
"the",
"parse",
"stack",
".",
"Returns",
"the",
"Lexer",
"."
] | 69bd06d35499929f1eb1df6b98fa7b5a2d768b1d | https://github.com/inukshuk/bibtex-ruby/blob/69bd06d35499929f1eb1df6b98fa7b5a2d768b1d/lib/bibtex/lexer.rb#L145-L165 | train |
inukshuk/bibtex-ruby | lib/bibtex/lexer.rb | BibTeX.Lexer.analyse | def analyse(string = nil)
raise(ArgumentError, 'Lexer: failed to start analysis: no source given!') unless
string || @scanner
self.data = string || @scanner.string
until @scanner.eos?
send("parse_#{MODE[@mode]}")
end
push([false, '$end'])
end | ruby | def analyse(string = nil)
raise(ArgumentError, 'Lexer: failed to start analysis: no source given!') unless
string || @scanner
self.data = string || @scanner.string
until @scanner.eos?
send("parse_#{MODE[@mode]}")
end
push([false, '$end'])
end | [
"def",
"analyse",
"(",
"string",
"=",
"nil",
")",
"raise",
"(",
"ArgumentError",
",",
"'Lexer: failed to start analysis: no source given!'",
")",
"unless",
"string",
"||",
"@scanner",
"self",
".",
"data",
"=",
"string",
"||",
"@scanner",
".",
"string",
"until",
... | Start the lexical analysis. | [
"Start",
"the",
"lexical",
"analysis",
"."
] | 69bd06d35499929f1eb1df6b98fa7b5a2d768b1d | https://github.com/inukshuk/bibtex-ruby/blob/69bd06d35499929f1eb1df6b98fa7b5a2d768b1d/lib/bibtex/lexer.rb#L168-L179 | train |
inukshuk/bibtex-ruby | lib/bibtex/lexer.rb | BibTeX.Lexer.enter_object | def enter_object
@brace_level = 0
push [:AT,'@']
case
when @scanner.scan(Lexer.patterns[:string])
@mode = @active_object = :string
push [:STRING, @scanner.matched]
when @scanner.scan(Lexer.patterns[:preamble])
@mode = @active_object = :preamble
push [:PREAM... | ruby | def enter_object
@brace_level = 0
push [:AT,'@']
case
when @scanner.scan(Lexer.patterns[:string])
@mode = @active_object = :string
push [:STRING, @scanner.matched]
when @scanner.scan(Lexer.patterns[:preamble])
@mode = @active_object = :preamble
push [:PREAM... | [
"def",
"enter_object",
"@brace_level",
"=",
"0",
"push",
"[",
":AT",
",",
"'@'",
"]",
"case",
"when",
"@scanner",
".",
"scan",
"(",
"Lexer",
".",
"patterns",
"[",
":string",
"]",
")",
"@mode",
"=",
"@active_object",
"=",
":string",
"push",
"[",
":STRING"... | Called when the lexer encounters a new BibTeX object. | [
"Called",
"when",
"the",
"lexer",
"encounters",
"a",
"new",
"BibTeX",
"object",
"."
] | 69bd06d35499929f1eb1df6b98fa7b5a2d768b1d | https://github.com/inukshuk/bibtex-ruby/blob/69bd06d35499929f1eb1df6b98fa7b5a2d768b1d/lib/bibtex/lexer.rb#L285-L317 | train |
inukshuk/bibtex-ruby | lib/bibtex/entry.rb | BibTeX.Entry.initialize_copy | def initialize_copy(other)
@fields = {}
self.type = other.type
self.key = other.key
add(other.fields)
end | ruby | def initialize_copy(other)
@fields = {}
self.type = other.type
self.key = other.key
add(other.fields)
end | [
"def",
"initialize_copy",
"(",
"other",
")",
"@fields",
"=",
"{",
"}",
"self",
".",
"type",
"=",
"other",
".",
"type",
"self",
".",
"key",
"=",
"other",
".",
"key",
"add",
"(",
"other",
".",
"fields",
")",
"end"
] | Creates a new instance. If a hash is given, the entry is populated accordingly. | [
"Creates",
"a",
"new",
"instance",
".",
"If",
"a",
"hash",
"is",
"given",
"the",
"entry",
"is",
"populated",
"accordingly",
"."
] | 69bd06d35499929f1eb1df6b98fa7b5a2d768b1d | https://github.com/inukshuk/bibtex-ruby/blob/69bd06d35499929f1eb1df6b98fa7b5a2d768b1d/lib/bibtex/entry.rb#L85-L92 | train |
inukshuk/bibtex-ruby | lib/bibtex/entry.rb | BibTeX.Entry.key= | def key=(key)
key = key.to_s
if registered?
bibliography.entries.delete(@key)
key = register(key)
end
@key = key
rescue => e
raise BibTeXError, "failed to set key to #{key.inspect}: #{e.message}"
end | ruby | def key=(key)
key = key.to_s
if registered?
bibliography.entries.delete(@key)
key = register(key)
end
@key = key
rescue => e
raise BibTeXError, "failed to set key to #{key.inspect}: #{e.message}"
end | [
"def",
"key",
"=",
"(",
"key",
")",
"key",
"=",
"key",
".",
"to_s",
"if",
"registered?",
"bibliography",
".",
"entries",
".",
"delete",
"(",
"@key",
")",
"key",
"=",
"register",
"(",
"key",
")",
"end",
"@key",
"=",
"key",
"rescue",
"=>",
"e",
"rais... | Sets the Entry's key. If the Entry is currently registered with a
Bibliography, re-registers the Entry with the new key; note that this
may change the key value if another Entry is already regsitered with
the same key.
Returns the new key. | [
"Sets",
"the",
"Entry",
"s",
"key",
".",
"If",
"the",
"Entry",
"is",
"currently",
"registered",
"with",
"a",
"Bibliography",
"re",
"-",
"registers",
"the",
"Entry",
"with",
"the",
"new",
"key",
";",
"note",
"that",
"this",
"may",
"change",
"the",
"key",
... | 69bd06d35499929f1eb1df6b98fa7b5a2d768b1d | https://github.com/inukshuk/bibtex-ruby/blob/69bd06d35499929f1eb1df6b98fa7b5a2d768b1d/lib/bibtex/entry.rb#L183-L194 | train |
inukshuk/bibtex-ruby | lib/bibtex/entry.rb | BibTeX.Entry.provide | def provide(name)
return nil unless name.respond_to?(:to_sym)
name = name.to_sym
fields[name] || fields[aliases[name]]
end | ruby | def provide(name)
return nil unless name.respond_to?(:to_sym)
name = name.to_sym
fields[name] || fields[aliases[name]]
end | [
"def",
"provide",
"(",
"name",
")",
"return",
"nil",
"unless",
"name",
".",
"respond_to?",
"(",
":to_sym",
")",
"name",
"=",
"name",
".",
"to_sym",
"fields",
"[",
"name",
"]",
"||",
"fields",
"[",
"aliases",
"[",
"name",
"]",
"]",
"end"
] | Returns the field value referenced by the passed-in name.
For example, this will return the 'title' value for 'booktitle' if a
corresponding alias is defined. | [
"Returns",
"the",
"field",
"value",
"referenced",
"by",
"the",
"passed",
"-",
"in",
"name",
".",
"For",
"example",
"this",
"will",
"return",
"the",
"title",
"value",
"for",
"booktitle",
"if",
"a",
"corresponding",
"alias",
"is",
"defined",
"."
] | 69bd06d35499929f1eb1df6b98fa7b5a2d768b1d | https://github.com/inukshuk/bibtex-ruby/blob/69bd06d35499929f1eb1df6b98fa7b5a2d768b1d/lib/bibtex/entry.rb#L251-L255 | train |
inukshuk/bibtex-ruby | lib/bibtex/entry.rb | BibTeX.Entry.field_names | def field_names(filter = [], include_inherited = true)
names = fields.keys
if include_inherited && has_parent?
names.concat(inherited_fields)
end
unless filter.empty?
names = names & filter.map(&:to_sym)
end
names.sort!
names
end | ruby | def field_names(filter = [], include_inherited = true)
names = fields.keys
if include_inherited && has_parent?
names.concat(inherited_fields)
end
unless filter.empty?
names = names & filter.map(&:to_sym)
end
names.sort!
names
end | [
"def",
"field_names",
"(",
"filter",
"=",
"[",
"]",
",",
"include_inherited",
"=",
"true",
")",
"names",
"=",
"fields",
".",
"keys",
"if",
"include_inherited",
"&&",
"has_parent?",
"names",
".",
"concat",
"(",
"inherited_fields",
")",
"end",
"unless",
"filte... | Returns a sorted list of the Entry's field names. If a +filter+ is passed
as argument, returns all field names that are also defined by the filter.
If the +filter+ is empty, returns all field names.
If the second optional argument is true (default) and the Entry contains
a cross-reference, the list will include al... | [
"Returns",
"a",
"sorted",
"list",
"of",
"the",
"Entry",
"s",
"field",
"names",
".",
"If",
"a",
"+",
"filter",
"+",
"is",
"passed",
"as",
"argument",
"returns",
"all",
"field",
"names",
"that",
"are",
"also",
"defined",
"by",
"the",
"filter",
".",
"If",... | 69bd06d35499929f1eb1df6b98fa7b5a2d768b1d | https://github.com/inukshuk/bibtex-ruby/blob/69bd06d35499929f1eb1df6b98fa7b5a2d768b1d/lib/bibtex/entry.rb#L275-L288 | train |
inukshuk/bibtex-ruby | lib/bibtex/entry.rb | BibTeX.Entry.inherited_fields | def inherited_fields
return [] unless has_parent?
names = parent.fields.keys - fields.keys
names.concat(parent.aliases.reject { |k,v| !parent.has_field?(v) }.keys)
names.sort!
names
end | ruby | def inherited_fields
return [] unless has_parent?
names = parent.fields.keys - fields.keys
names.concat(parent.aliases.reject { |k,v| !parent.has_field?(v) }.keys)
names.sort!
names
end | [
"def",
"inherited_fields",
"return",
"[",
"]",
"unless",
"has_parent?",
"names",
"=",
"parent",
".",
"fields",
".",
"keys",
"-",
"fields",
".",
"keys",
"names",
".",
"concat",
"(",
"parent",
".",
"aliases",
".",
"reject",
"{",
"|",
"k",
",",
"v",
"|",
... | Returns a sorted list of all field names referenced by this Entry's cross-reference. | [
"Returns",
"a",
"sorted",
"list",
"of",
"all",
"field",
"names",
"referenced",
"by",
"this",
"Entry",
"s",
"cross",
"-",
"reference",
"."
] | 69bd06d35499929f1eb1df6b98fa7b5a2d768b1d | https://github.com/inukshuk/bibtex-ruby/blob/69bd06d35499929f1eb1df6b98fa7b5a2d768b1d/lib/bibtex/entry.rb#L291-L299 | train |
inukshuk/bibtex-ruby | lib/bibtex/entry.rb | BibTeX.Entry.rename! | def rename!(*arguments)
Hash[*arguments.flatten].each_pair do |from,to|
if fields.has_key?(from) && !fields.has_key?(to)
fields[to] = fields[from]
fields.delete(from)
end
end
self
end | ruby | def rename!(*arguments)
Hash[*arguments.flatten].each_pair do |from,to|
if fields.has_key?(from) && !fields.has_key?(to)
fields[to] = fields[from]
fields.delete(from)
end
end
self
end | [
"def",
"rename!",
"(",
"*",
"arguments",
")",
"Hash",
"[",
"*",
"arguments",
".",
"flatten",
"]",
".",
"each_pair",
"do",
"|",
"from",
",",
"to",
"|",
"if",
"fields",
".",
"has_key?",
"(",
"from",
")",
"&&",
"!",
"fields",
".",
"has_key?",
"(",
"to... | Renames the given field names unless a field with the new name already
exists. | [
"Renames",
"the",
"given",
"field",
"names",
"unless",
"a",
"field",
"with",
"the",
"new",
"name",
"already",
"exists",
"."
] | 69bd06d35499929f1eb1df6b98fa7b5a2d768b1d | https://github.com/inukshuk/bibtex-ruby/blob/69bd06d35499929f1eb1df6b98fa7b5a2d768b1d/lib/bibtex/entry.rb#L330-L338 | train |
inukshuk/bibtex-ruby | lib/bibtex/entry.rb | BibTeX.Entry.valid? | def valid?
REQUIRED_FIELDS[type].all? do |f|
f.is_a?(Array) ? !(f & fields.keys).empty? : !fields[f].nil?
end
end | ruby | def valid?
REQUIRED_FIELDS[type].all? do |f|
f.is_a?(Array) ? !(f & fields.keys).empty? : !fields[f].nil?
end
end | [
"def",
"valid?",
"REQUIRED_FIELDS",
"[",
"type",
"]",
".",
"all?",
"do",
"|",
"f",
"|",
"f",
".",
"is_a?",
"(",
"Array",
")",
"?",
"!",
"(",
"f",
"&",
"fields",
".",
"keys",
")",
".",
"empty?",
":",
"!",
"fields",
"[",
"f",
"]",
".",
"nil?",
... | Returns false if the entry is one of the standard entry types and does not have
definitions of all the required fields for that type. | [
"Returns",
"false",
"if",
"the",
"entry",
"is",
"one",
"of",
"the",
"standard",
"entry",
"types",
"and",
"does",
"not",
"have",
"definitions",
"of",
"all",
"the",
"required",
"fields",
"for",
"that",
"type",
"."
] | 69bd06d35499929f1eb1df6b98fa7b5a2d768b1d | https://github.com/inukshuk/bibtex-ruby/blob/69bd06d35499929f1eb1df6b98fa7b5a2d768b1d/lib/bibtex/entry.rb#L389-L393 | train |
inukshuk/bibtex-ruby | lib/bibtex/entry.rb | BibTeX.Entry.digest | def digest(filter = [])
names = field_names(filter)
digest = type.to_s
names.zip(values_at(*names)).each do |key, value|
digest << "|#{key}:#{value}"
end
digest = yield(digest, self) if block_given?
digest
end | ruby | def digest(filter = [])
names = field_names(filter)
digest = type.to_s
names.zip(values_at(*names)).each do |key, value|
digest << "|#{key}:#{value}"
end
digest = yield(digest, self) if block_given?
digest
end | [
"def",
"digest",
"(",
"filter",
"=",
"[",
"]",
")",
"names",
"=",
"field_names",
"(",
"filter",
")",
"digest",
"=",
"type",
".",
"to_s",
"names",
".",
"zip",
"(",
"values_at",
"(",
"*",
"names",
")",
")",
".",
"each",
"do",
"|",
"key",
",",
"valu... | Creates the entry's digest based on the passed-in filters.
The digest contains the type and all key-value pairs based
on the passed in filter.
If a block is given, the computed digest will be passed to
the block for post-processing (the entry itself will be passed
as the second parameter).
@see #field_names
... | [
"Creates",
"the",
"entry",
"s",
"digest",
"based",
"on",
"the",
"passed",
"-",
"in",
"filters",
"."
] | 69bd06d35499929f1eb1df6b98fa7b5a2d768b1d | https://github.com/inukshuk/bibtex-ruby/blob/69bd06d35499929f1eb1df6b98fa7b5a2d768b1d/lib/bibtex/entry.rb#L408-L418 | train |
inukshuk/bibtex-ruby | lib/bibtex/entry.rb | BibTeX.Entry.added_to_bibliography | def added_to_bibliography(bibliography)
super
@key = register(key)
[:parse_names, :parse_months].each do |parser|
send(parser) if bibliography.options[parser]
end
if bibliography.options.has_key?(:filter)
[*bibliography.options[:filter]].each do |filter|
conver... | ruby | def added_to_bibliography(bibliography)
super
@key = register(key)
[:parse_names, :parse_months].each do |parser|
send(parser) if bibliography.options[parser]
end
if bibliography.options.has_key?(:filter)
[*bibliography.options[:filter]].each do |filter|
conver... | [
"def",
"added_to_bibliography",
"(",
"bibliography",
")",
"super",
"@key",
"=",
"register",
"(",
"key",
")",
"[",
":parse_names",
",",
":parse_months",
"]",
".",
"each",
"do",
"|",
"parser",
"|",
"send",
"(",
"parser",
")",
"if",
"bibliography",
".",
"opti... | Called when the element was added to a bibliography. | [
"Called",
"when",
"the",
"element",
"was",
"added",
"to",
"a",
"bibliography",
"."
] | 69bd06d35499929f1eb1df6b98fa7b5a2d768b1d | https://github.com/inukshuk/bibtex-ruby/blob/69bd06d35499929f1eb1df6b98fa7b5a2d768b1d/lib/bibtex/entry.rb#L434-L450 | train |
inukshuk/bibtex-ruby | lib/bibtex/entry.rb | BibTeX.Entry.register | def register(key)
return nil if bibliography.nil?
k = key.dup
k.succ! while bibliography.has_key?(k)
bibliography.entries[k] = self
k
end | ruby | def register(key)
return nil if bibliography.nil?
k = key.dup
k.succ! while bibliography.has_key?(k)
bibliography.entries[k] = self
k
end | [
"def",
"register",
"(",
"key",
")",
"return",
"nil",
"if",
"bibliography",
".",
"nil?",
"k",
"=",
"key",
".",
"dup",
"k",
".",
"succ!",
"while",
"bibliography",
".",
"has_key?",
"(",
"k",
")",
"bibliography",
".",
"entries",
"[",
"k",
"]",
"=",
"self... | Registers this Entry in the associated Bibliographies entries hash.
This method may change the Entry's key, if another entry is already
registered with the current key.
Returns the key or nil if the Entry is not associated with a Bibliography. | [
"Registers",
"this",
"Entry",
"in",
"the",
"associated",
"Bibliographies",
"entries",
"hash",
".",
"This",
"method",
"may",
"change",
"the",
"Entry",
"s",
"key",
"if",
"another",
"entry",
"is",
"already",
"registered",
"with",
"the",
"current",
"key",
"."
] | 69bd06d35499929f1eb1df6b98fa7b5a2d768b1d | https://github.com/inukshuk/bibtex-ruby/blob/69bd06d35499929f1eb1df6b98fa7b5a2d768b1d/lib/bibtex/entry.rb#L469-L476 | train |
inukshuk/bibtex-ruby | lib/bibtex/entry.rb | BibTeX.Entry.parse_names | def parse_names
strings = bibliography ? bibliography.strings.values : []
NAME_FIELDS.each do |key|
if name = fields[key]
name = name.dup.replace(strings).join.to_name
fields[key] = name unless name.nil?
end
end
self
end | ruby | def parse_names
strings = bibliography ? bibliography.strings.values : []
NAME_FIELDS.each do |key|
if name = fields[key]
name = name.dup.replace(strings).join.to_name
fields[key] = name unless name.nil?
end
end
self
end | [
"def",
"parse_names",
"strings",
"=",
"bibliography",
"?",
"bibliography",
".",
"strings",
".",
"values",
":",
"[",
"]",
"NAME_FIELDS",
".",
"each",
"do",
"|",
"key",
"|",
"if",
"name",
"=",
"fields",
"[",
"key",
"]",
"name",
"=",
"name",
".",
"dup",
... | Parses all name values of the entry. Tries to replace and join the
value prior to parsing. | [
"Parses",
"all",
"name",
"values",
"of",
"the",
"entry",
".",
"Tries",
"to",
"replace",
"and",
"join",
"the",
"value",
"prior",
"to",
"parsing",
"."
] | 69bd06d35499929f1eb1df6b98fa7b5a2d768b1d | https://github.com/inukshuk/bibtex-ruby/blob/69bd06d35499929f1eb1df6b98fa7b5a2d768b1d/lib/bibtex/entry.rb#L522-L533 | train |
inukshuk/bibtex-ruby | lib/bibtex/entry.rb | BibTeX.Entry.convert! | def convert!(*filters)
filters = filters.flatten.map { |f| Filters.resolve!(f) }
fields.each_pair do |k, v|
(!block_given? || yield(k, v)) ? v.convert!(*filters) : v
end
self
end | ruby | def convert!(*filters)
filters = filters.flatten.map { |f| Filters.resolve!(f) }
fields.each_pair do |k, v|
(!block_given? || yield(k, v)) ? v.convert!(*filters) : v
end
self
end | [
"def",
"convert!",
"(",
"*",
"filters",
")",
"filters",
"=",
"filters",
".",
"flatten",
".",
"map",
"{",
"|",
"f",
"|",
"Filters",
".",
"resolve!",
"(",
"f",
")",
"}",
"fields",
".",
"each_pair",
"do",
"|",
"k",
",",
"v",
"|",
"(",
"!",
"block_gi... | In-place variant of @see #convert | [
"In",
"-",
"place",
"variant",
"of"
] | 69bd06d35499929f1eb1df6b98fa7b5a2d768b1d | https://github.com/inukshuk/bibtex-ruby/blob/69bd06d35499929f1eb1df6b98fa7b5a2d768b1d/lib/bibtex/entry.rb#L617-L625 | train |
inukshuk/bibtex-ruby | lib/bibtex/entry.rb | BibTeX.Entry.default_key | def default_key
k = names[0]
k = k.respond_to?(:family) ? k.family : k.to_s
k = BibTeX.transliterate(k).gsub(/["']/, '')
k = k[/[A-Za-z-]+/] || 'unknown'
k << (year.to_s[/\d+/] || '-')
k << 'a'
k.downcase!
k
end | ruby | def default_key
k = names[0]
k = k.respond_to?(:family) ? k.family : k.to_s
k = BibTeX.transliterate(k).gsub(/["']/, '')
k = k[/[A-Za-z-]+/] || 'unknown'
k << (year.to_s[/\d+/] || '-')
k << 'a'
k.downcase!
k
end | [
"def",
"default_key",
"k",
"=",
"names",
"[",
"0",
"]",
"k",
"=",
"k",
".",
"respond_to?",
"(",
":family",
")",
"?",
"k",
".",
"family",
":",
"k",
".",
"to_s",
"k",
"=",
"BibTeX",
".",
"transliterate",
"(",
"k",
")",
".",
"gsub",
"(",
"/",
"/",... | Returns a default key for this entry. | [
"Returns",
"a",
"default",
"key",
"for",
"this",
"entry",
"."
] | 69bd06d35499929f1eb1df6b98fa7b5a2d768b1d | https://github.com/inukshuk/bibtex-ruby/blob/69bd06d35499929f1eb1df6b98fa7b5a2d768b1d/lib/bibtex/entry.rb#L679-L688 | train |
inukshuk/bibtex-ruby | lib/bibtex/bibliography.rb | BibTeX.Bibliography.initialize_copy | def initialize_copy(other)
@options = other.options.dup
@errors = other.errors.dup
@data, @strings = [], {}
@entries = Hash.new { |h,k| h.fetch(k.to_s, nil) }
other.each do |element|
add element.dup
end
self
end | ruby | def initialize_copy(other)
@options = other.options.dup
@errors = other.errors.dup
@data, @strings = [], {}
@entries = Hash.new { |h,k| h.fetch(k.to_s, nil) }
other.each do |element|
add element.dup
end
self
end | [
"def",
"initialize_copy",
"(",
"other",
")",
"@options",
"=",
"other",
".",
"options",
".",
"dup",
"@errors",
"=",
"other",
".",
"errors",
".",
"dup",
"@data",
",",
"@strings",
"=",
"[",
"]",
",",
"{",
"}",
"@entries",
"=",
"Hash",
".",
"new",
"{",
... | Creates a new bibliography. | [
"Creates",
"a",
"new",
"bibliography",
"."
] | 69bd06d35499929f1eb1df6b98fa7b5a2d768b1d | https://github.com/inukshuk/bibtex-ruby/blob/69bd06d35499929f1eb1df6b98fa7b5a2d768b1d/lib/bibtex/bibliography.rb#L105-L116 | train |
inukshuk/bibtex-ruby | lib/bibtex/bibliography.rb | BibTeX.Bibliography.add | def add(*arguments)
Element.parse(arguments.flatten, @options).each do |element|
data << element.added_to_bibliography(self)
end
self
end | ruby | def add(*arguments)
Element.parse(arguments.flatten, @options).each do |element|
data << element.added_to_bibliography(self)
end
self
end | [
"def",
"add",
"(",
"*",
"arguments",
")",
"Element",
".",
"parse",
"(",
"arguments",
".",
"flatten",
",",
"@options",
")",
".",
"each",
"do",
"|",
"element",
"|",
"data",
"<<",
"element",
".",
"added_to_bibliography",
"(",
"self",
")",
"end",
"self",
"... | Adds a new element, or a list of new elements to the bibliography.
Returns the Bibliography for chainability. | [
"Adds",
"a",
"new",
"element",
"or",
"a",
"list",
"of",
"new",
"elements",
"to",
"the",
"bibliography",
".",
"Returns",
"the",
"Bibliography",
"for",
"chainability",
"."
] | 69bd06d35499929f1eb1df6b98fa7b5a2d768b1d | https://github.com/inukshuk/bibtex-ruby/blob/69bd06d35499929f1eb1df6b98fa7b5a2d768b1d/lib/bibtex/bibliography.rb#L120-L125 | train |
inukshuk/bibtex-ruby | lib/bibtex/bibliography.rb | BibTeX.Bibliography.save_to | def save_to(path, options = {})
options[:quotes] ||= %w({ })
File.open(path, 'w:UTF-8') do |f|
f.write(to_s(options))
end
self
end | ruby | def save_to(path, options = {})
options[:quotes] ||= %w({ })
File.open(path, 'w:UTF-8') do |f|
f.write(to_s(options))
end
self
end | [
"def",
"save_to",
"(",
"path",
",",
"options",
"=",
"{",
"}",
")",
"options",
"[",
":quotes",
"]",
"||=",
"%w(",
"{",
"}",
")",
"File",
".",
"open",
"(",
"path",
",",
"'w:UTF-8'",
")",
"do",
"|",
"f",
"|",
"f",
".",
"write",
"(",
"to_s",
"(",
... | Saves the bibliography to a file at the given path. Returns the bibliography. | [
"Saves",
"the",
"bibliography",
"to",
"a",
"file",
"at",
"the",
"given",
"path",
".",
"Returns",
"the",
"bibliography",
"."
] | 69bd06d35499929f1eb1df6b98fa7b5a2d768b1d | https://github.com/inukshuk/bibtex-ruby/blob/69bd06d35499929f1eb1df6b98fa7b5a2d768b1d/lib/bibtex/bibliography.rb#L137-L145 | train |
inukshuk/bibtex-ruby | lib/bibtex/bibliography.rb | BibTeX.Bibliography.delete | def delete(*arguments, &block)
objects = q(*arguments, &block).map { |o| o.removed_from_bibliography(self) }
@data = @data - objects
objects.length == 1 ? objects[0] : objects
end | ruby | def delete(*arguments, &block)
objects = q(*arguments, &block).map { |o| o.removed_from_bibliography(self) }
@data = @data - objects
objects.length == 1 ? objects[0] : objects
end | [
"def",
"delete",
"(",
"*",
"arguments",
",",
"&",
"block",
")",
"objects",
"=",
"q",
"(",
"*",
"arguments",
",",
"&",
"block",
")",
".",
"map",
"{",
"|",
"o",
"|",
"o",
".",
"removed_from_bibliography",
"(",
"self",
")",
"}",
"@data",
"=",
"@data",... | Deletes an object, or a list of objects from the bibliography.
If a list of objects is to be deleted, you can either supply the list
of objects or use a query or block to define the list.
Returns the object (or the list of objects) that were deleted; nil
if the object was not part of the bibliography. | [
"Deletes",
"an",
"object",
"or",
"a",
"list",
"of",
"objects",
"from",
"the",
"bibliography",
".",
"If",
"a",
"list",
"of",
"objects",
"is",
"to",
"be",
"deleted",
"you",
"can",
"either",
"supply",
"the",
"list",
"of",
"objects",
"or",
"use",
"a",
"que... | 69bd06d35499929f1eb1df6b98fa7b5a2d768b1d | https://github.com/inukshuk/bibtex-ruby/blob/69bd06d35499929f1eb1df6b98fa7b5a2d768b1d/lib/bibtex/bibliography.rb#L189-L193 | train |
inukshuk/bibtex-ruby | lib/bibtex/bibliography.rb | BibTeX.Bibliography.extend_initials! | def extend_initials!
groups = Hash.new do |h,k|
h[k] = { :prototype => nil, :names => [] }
end
# group names together
names.each do |name|
group = groups[name.sort_order(:initials => true).downcase]
group[:names] << name
if group[:prototype].nil? || group[:proto... | ruby | def extend_initials!
groups = Hash.new do |h,k|
h[k] = { :prototype => nil, :names => [] }
end
# group names together
names.each do |name|
group = groups[name.sort_order(:initials => true).downcase]
group[:names] << name
if group[:prototype].nil? || group[:proto... | [
"def",
"extend_initials!",
"groups",
"=",
"Hash",
".",
"new",
"do",
"|",
"h",
",",
"k",
"|",
"h",
"[",
"k",
"]",
"=",
"{",
":prototype",
"=>",
"nil",
",",
":names",
"=>",
"[",
"]",
"}",
"end",
"names",
".",
"each",
"do",
"|",
"name",
"|",
"grou... | This method combines all names in the bibliography that look identical
when using initials as first names and then tries to extend the first
names for all names in each group to the longest available form.
Returns the bibliography.
If your bibliography contains the names 'Poe, Edgar A.', 'Poe, E.A.',
and 'Poe, E.... | [
"This",
"method",
"combines",
"all",
"names",
"in",
"the",
"bibliography",
"that",
"look",
"identical",
"when",
"using",
"initials",
"as",
"first",
"names",
"and",
"then",
"tries",
"to",
"extend",
"the",
"first",
"names",
"for",
"all",
"names",
"in",
"each",... | 69bd06d35499929f1eb1df6b98fa7b5a2d768b1d | https://github.com/inukshuk/bibtex-ruby/blob/69bd06d35499929f1eb1df6b98fa7b5a2d768b1d/lib/bibtex/bibliography.rb#L320-L343 | train |
inukshuk/bibtex-ruby | lib/bibtex/elements.rb | BibTeX.Element.matches? | def matches?(query)
return true if query.nil? || query.respond_to?(:empty?) && query.empty?
case query
when Symbol
query.to_s == id.to_s
when Element
query == self
when Regexp
to_s.match(query)
when /^\/(.+)\/$/
to_s.match(Regexp.new($1))
when /... | ruby | def matches?(query)
return true if query.nil? || query.respond_to?(:empty?) && query.empty?
case query
when Symbol
query.to_s == id.to_s
when Element
query == self
when Regexp
to_s.match(query)
when /^\/(.+)\/$/
to_s.match(Regexp.new($1))
when /... | [
"def",
"matches?",
"(",
"query",
")",
"return",
"true",
"if",
"query",
".",
"nil?",
"||",
"query",
".",
"respond_to?",
"(",
":empty?",
")",
"&&",
"query",
".",
"empty?",
"case",
"query",
"when",
"Symbol",
"query",
".",
"to_s",
"==",
"id",
".",
"to_s",
... | Returns true if the element matches the given query. | [
"Returns",
"true",
"if",
"the",
"element",
"matches",
"the",
"given",
"query",
"."
] | 69bd06d35499929f1eb1df6b98fa7b5a2d768b1d | https://github.com/inukshuk/bibtex-ruby/blob/69bd06d35499929f1eb1df6b98fa7b5a2d768b1d/lib/bibtex/elements.rb#L92-L119 | train |
inukshuk/bibtex-ruby | lib/bibtex/names.rb | BibTeX.Name.set | def set(attributes = {})
attributes.each_pair do |key, value|
send("#{key}=", value) if respond_to?(key)
end
self
end | ruby | def set(attributes = {})
attributes.each_pair do |key, value|
send("#{key}=", value) if respond_to?(key)
end
self
end | [
"def",
"set",
"(",
"attributes",
"=",
"{",
"}",
")",
"attributes",
".",
"each_pair",
"do",
"|",
"key",
",",
"value",
"|",
"send",
"(",
"\"#{key}=\"",
",",
"value",
")",
"if",
"respond_to?",
"(",
"key",
")",
"end",
"self",
"end"
] | Set the name tokens to the values defined in the passed-in hash. | [
"Set",
"the",
"name",
"tokens",
"to",
"the",
"values",
"defined",
"in",
"the",
"passed",
"-",
"in",
"hash",
"."
] | 69bd06d35499929f1eb1df6b98fa7b5a2d768b1d | https://github.com/inukshuk/bibtex-ruby/blob/69bd06d35499929f1eb1df6b98fa7b5a2d768b1d/lib/bibtex/names.rb#L155-L161 | train |
inukshuk/bibtex-ruby | lib/bibtex/names.rb | BibTeX.Name.extend_initials | def extend_initials(with_first, for_last)
rename_if :first => with_first do |name|
if name.last == for_last
mine = name.initials.split(/\.[^[:alpha:]]*/)
other = initials(with_first).split(/\.[^[:alpha:]]*/)
mine == other || mine.length < other.length && mine == other[0, min... | ruby | def extend_initials(with_first, for_last)
rename_if :first => with_first do |name|
if name.last == for_last
mine = name.initials.split(/\.[^[:alpha:]]*/)
other = initials(with_first).split(/\.[^[:alpha:]]*/)
mine == other || mine.length < other.length && mine == other[0, min... | [
"def",
"extend_initials",
"(",
"with_first",
",",
"for_last",
")",
"rename_if",
":first",
"=>",
"with_first",
"do",
"|",
"name",
"|",
"if",
"name",
".",
"last",
"==",
"for_last",
"mine",
"=",
"name",
".",
"initials",
".",
"split",
"(",
"/",
"\\.",
"/",
... | Sets the name's first name to the passed-in name if the last name equals
for_last and the current first name has the same initials as with_first. | [
"Sets",
"the",
"name",
"s",
"first",
"name",
"to",
"the",
"passed",
"-",
"in",
"name",
"if",
"the",
"last",
"name",
"equals",
"for_last",
"and",
"the",
"current",
"first",
"name",
"has",
"the",
"same",
"initials",
"as",
"with_first",
"."
] | 69bd06d35499929f1eb1df6b98fa7b5a2d768b1d | https://github.com/inukshuk/bibtex-ruby/blob/69bd06d35499929f1eb1df6b98fa7b5a2d768b1d/lib/bibtex/names.rb#L187-L196 | train |
inukshuk/bibtex-ruby | lib/bibtex/names.rb | BibTeX.Name.rename_if | def rename_if(attributes, conditions = {})
if block_given?
set(attributes) if yield self
else
set(attributes) if conditions.all? do |key, value|
respond_to?(key) && send(key) == value
end
end
self
end | ruby | def rename_if(attributes, conditions = {})
if block_given?
set(attributes) if yield self
else
set(attributes) if conditions.all? do |key, value|
respond_to?(key) && send(key) == value
end
end
self
end | [
"def",
"rename_if",
"(",
"attributes",
",",
"conditions",
"=",
"{",
"}",
")",
"if",
"block_given?",
"set",
"(",
"attributes",
")",
"if",
"yield",
"self",
"else",
"set",
"(",
"attributes",
")",
"if",
"conditions",
".",
"all?",
"do",
"|",
"key",
",",
"va... | Renames the tokens according to the passed-in attributes if all of the
conditions match or if the given block returns true. | [
"Renames",
"the",
"tokens",
"according",
"to",
"the",
"passed",
"-",
"in",
"attributes",
"if",
"all",
"of",
"the",
"conditions",
"match",
"or",
"if",
"the",
"given",
"block",
"returns",
"true",
"."
] | 69bd06d35499929f1eb1df6b98fa7b5a2d768b1d | https://github.com/inukshuk/bibtex-ruby/blob/69bd06d35499929f1eb1df6b98fa7b5a2d768b1d/lib/bibtex/names.rb#L200-L210 | train |
redding/assert | lib/assert/context.rb | Assert.Context.assert | def assert(assertion, desc = nil)
if assertion
pass
else
what = if block_given?
yield
else
"Failed assert: assertion was "\
"`#{Assert::U.show(assertion, __assert_config__)}`."
end
fail(fail_message(desc, what))
end
end | ruby | def assert(assertion, desc = nil)
if assertion
pass
else
what = if block_given?
yield
else
"Failed assert: assertion was "\
"`#{Assert::U.show(assertion, __assert_config__)}`."
end
fail(fail_message(desc, what))
end
end | [
"def",
"assert",
"(",
"assertion",
",",
"desc",
"=",
"nil",
")",
"if",
"assertion",
"pass",
"else",
"what",
"=",
"if",
"block_given?",
"yield",
"else",
"\"Failed assert: assertion was \"",
"\"`#{Assert::U.show(assertion, __assert_config__)}`.\"",
"end",
"fail",
"(",
"... | check if the assertion is a truthy value, if so create a new pass result,
otherwise create a new fail result with the desc and what failed msg.
all other assertion helpers use this one in the end | [
"check",
"if",
"the",
"assertion",
"is",
"a",
"truthy",
"value",
"if",
"so",
"create",
"a",
"new",
"pass",
"result",
"otherwise",
"create",
"a",
"new",
"fail",
"result",
"with",
"the",
"desc",
"and",
"what",
"failed",
"msg",
".",
"all",
"other",
"asserti... | 52c0adf2db40bdd3490021539b3a26a0b530d5a4 | https://github.com/redding/assert/blob/52c0adf2db40bdd3490021539b3a26a0b530d5a4/lib/assert/context.rb#L68-L80 | train |
redding/assert | lib/assert/context.rb | Assert.Context.pass | def pass(pass_msg = nil)
if @__assert_pending__ == 0
capture_result(Assert::Result::Pass, pass_msg)
else
capture_result(Assert::Result::Fail, "Pending pass (make it "\
"not pending)")
end
end | ruby | def pass(pass_msg = nil)
if @__assert_pending__ == 0
capture_result(Assert::Result::Pass, pass_msg)
else
capture_result(Assert::Result::Fail, "Pending pass (make it "\
"not pending)")
end
end | [
"def",
"pass",
"(",
"pass_msg",
"=",
"nil",
")",
"if",
"@__assert_pending__",
"==",
"0",
"capture_result",
"(",
"Assert",
"::",
"Result",
"::",
"Pass",
",",
"pass_msg",
")",
"else",
"capture_result",
"(",
"Assert",
"::",
"Result",
"::",
"Fail",
",",
"\"Pen... | adds a Pass result to the end of the test's results
does not break test execution | [
"adds",
"a",
"Pass",
"result",
"to",
"the",
"end",
"of",
"the",
"test",
"s",
"results",
"does",
"not",
"break",
"test",
"execution"
] | 52c0adf2db40bdd3490021539b3a26a0b530d5a4 | https://github.com/redding/assert/blob/52c0adf2db40bdd3490021539b3a26a0b530d5a4/lib/assert/context.rb#L94-L101 | train |
redding/assert | lib/assert/context.rb | Assert.Context.fail | def fail(message = nil)
if @__assert_pending__ == 0
if halt_on_fail?
raise Result::TestFailure, message || ""
else
capture_result(Assert::Result::Fail, message || "")
end
else
if halt_on_fail?
raise Result::TestSkipped, "Pending fail: #{message |... | ruby | def fail(message = nil)
if @__assert_pending__ == 0
if halt_on_fail?
raise Result::TestFailure, message || ""
else
capture_result(Assert::Result::Fail, message || "")
end
else
if halt_on_fail?
raise Result::TestSkipped, "Pending fail: #{message |... | [
"def",
"fail",
"(",
"message",
"=",
"nil",
")",
"if",
"@__assert_pending__",
"==",
"0",
"if",
"halt_on_fail?",
"raise",
"Result",
"::",
"TestFailure",
",",
"message",
"||",
"\"\"",
"else",
"capture_result",
"(",
"Assert",
"::",
"Result",
"::",
"Fail",
",",
... | adds a Fail result to the end of the test's results
break test execution if assert is configured to halt on failures | [
"adds",
"a",
"Fail",
"result",
"to",
"the",
"end",
"of",
"the",
"test",
"s",
"results",
"break",
"test",
"execution",
"if",
"assert",
"is",
"configured",
"to",
"halt",
"on",
"failures"
] | 52c0adf2db40bdd3490021539b3a26a0b530d5a4 | https://github.com/redding/assert/blob/52c0adf2db40bdd3490021539b3a26a0b530d5a4/lib/assert/context.rb#L111-L125 | train |
justinweiss/resque_unit | lib/resque_unit/scheduler.rb | ResqueUnit.Scheduler.enqueue_in | def enqueue_in(number_of_seconds_from_now, klass, *args)
enqueue_at(Time.now + number_of_seconds_from_now, klass, *args)
end | ruby | def enqueue_in(number_of_seconds_from_now, klass, *args)
enqueue_at(Time.now + number_of_seconds_from_now, klass, *args)
end | [
"def",
"enqueue_in",
"(",
"number_of_seconds_from_now",
",",
"klass",
",",
"*",
"args",
")",
"enqueue_at",
"(",
"Time",
".",
"now",
"+",
"number_of_seconds_from_now",
",",
"klass",
",",
"*",
"args",
")",
"end"
] | Identical to enqueue_at but takes number_of_seconds_from_now
instead of a timestamp. | [
"Identical",
"to",
"enqueue_at",
"but",
"takes",
"number_of_seconds_from_now",
"instead",
"of",
"a",
"timestamp",
"."
] | 064f54b6405980dfdd37afabe03b959884b3b166 | https://github.com/justinweiss/resque_unit/blob/064f54b6405980dfdd37afabe03b959884b3b166/lib/resque_unit/scheduler.rb#L21-L23 | train |
justinweiss/resque_unit | lib/resque_unit/helpers.rb | ResqueUnit.Helpers.decode | def decode(object)
return unless object
if defined? Yajl
begin
Yajl::Parser.parse(object, :check_utf8 => false)
rescue Yajl::ParseError
end
else
begin
JSON.parse(object)
rescue JSON::ParserError
end
end
end | ruby | def decode(object)
return unless object
if defined? Yajl
begin
Yajl::Parser.parse(object, :check_utf8 => false)
rescue Yajl::ParseError
end
else
begin
JSON.parse(object)
rescue JSON::ParserError
end
end
end | [
"def",
"decode",
"(",
"object",
")",
"return",
"unless",
"object",
"if",
"defined?",
"Yajl",
"begin",
"Yajl",
"::",
"Parser",
".",
"parse",
"(",
"object",
",",
":check_utf8",
"=>",
"false",
")",
"rescue",
"Yajl",
"::",
"ParseError",
"end",
"else",
"begin",... | Given a string, returns a Ruby object. | [
"Given",
"a",
"string",
"returns",
"a",
"Ruby",
"object",
"."
] | 064f54b6405980dfdd37afabe03b959884b3b166 | https://github.com/justinweiss/resque_unit/blob/064f54b6405980dfdd37afabe03b959884b3b166/lib/resque_unit/helpers.rb#L14-L28 | train |
justinweiss/resque_unit | lib/resque_unit/helpers.rb | ResqueUnit.Helpers.constantize | def constantize(camel_cased_word)
camel_cased_word = camel_cased_word.to_s
if camel_cased_word.include?('-')
camel_cased_word = classify(camel_cased_word)
end
names = camel_cased_word.split('::')
names.shift if names.empty? || names.first.empty?
constant = Object
nam... | ruby | def constantize(camel_cased_word)
camel_cased_word = camel_cased_word.to_s
if camel_cased_word.include?('-')
camel_cased_word = classify(camel_cased_word)
end
names = camel_cased_word.split('::')
names.shift if names.empty? || names.first.empty?
constant = Object
nam... | [
"def",
"constantize",
"(",
"camel_cased_word",
")",
"camel_cased_word",
"=",
"camel_cased_word",
".",
"to_s",
"if",
"camel_cased_word",
".",
"include?",
"(",
"'-'",
")",
"camel_cased_word",
"=",
"classify",
"(",
"camel_cased_word",
")",
"end",
"names",
"=",
"camel... | Given a camel cased word, returns the constant it represents
constantize('JobName') # => JobName | [
"Given",
"a",
"camel",
"cased",
"word",
"returns",
"the",
"constant",
"it",
"represents"
] | 064f54b6405980dfdd37afabe03b959884b3b166 | https://github.com/justinweiss/resque_unit/blob/064f54b6405980dfdd37afabe03b959884b3b166/lib/resque_unit/helpers.rb#L40-L55 | train |
joshwlewis/unitwise | lib/unitwise/term.rb | Unitwise.Term.atom= | def atom=(value)
value.is_a?(Atom) ? super(value) : super(Atom.find(value.to_s))
end | ruby | def atom=(value)
value.is_a?(Atom) ? super(value) : super(Atom.find(value.to_s))
end | [
"def",
"atom",
"=",
"(",
"value",
")",
"value",
".",
"is_a?",
"(",
"Atom",
")",
"?",
"super",
"(",
"value",
")",
":",
"super",
"(",
"Atom",
".",
"find",
"(",
"value",
".",
"to_s",
")",
")",
"end"
] | Set the atom.
@param value [String, Atom] Either a string representing an Atom, or an
Atom
@api public | [
"Set",
"the",
"atom",
"."
] | f786d2e660721a0238949e7abce20852879de8ef | https://github.com/joshwlewis/unitwise/blob/f786d2e660721a0238949e7abce20852879de8ef/lib/unitwise/term.rb#L12-L14 | train |
joshwlewis/unitwise | lib/unitwise/term.rb | Unitwise.Term.prefix= | def prefix=(value)
value.is_a?(Prefix) ? super(value) : super(Prefix.find(value.to_s))
end | ruby | def prefix=(value)
value.is_a?(Prefix) ? super(value) : super(Prefix.find(value.to_s))
end | [
"def",
"prefix",
"=",
"(",
"value",
")",
"value",
".",
"is_a?",
"(",
"Prefix",
")",
"?",
"super",
"(",
"value",
")",
":",
"super",
"(",
"Prefix",
".",
"find",
"(",
"value",
".",
"to_s",
")",
")",
"end"
] | Set the prefix.
@param value [String, Prefix] Either a string representing a Prefix, or
a Prefix | [
"Set",
"the",
"prefix",
"."
] | f786d2e660721a0238949e7abce20852879de8ef | https://github.com/joshwlewis/unitwise/blob/f786d2e660721a0238949e7abce20852879de8ef/lib/unitwise/term.rb#L19-L21 | train |
joshwlewis/unitwise | lib/unitwise/term.rb | Unitwise.Term.root_terms | def root_terms
if terminal?
[self]
else
atom.scale.root_terms.map do |t|
self.class.new(:atom => t.atom, :exponent => t.exponent * exponent)
end
end
end | ruby | def root_terms
if terminal?
[self]
else
atom.scale.root_terms.map do |t|
self.class.new(:atom => t.atom, :exponent => t.exponent * exponent)
end
end
end | [
"def",
"root_terms",
"if",
"terminal?",
"[",
"self",
"]",
"else",
"atom",
".",
"scale",
".",
"root_terms",
".",
"map",
"do",
"|",
"t",
"|",
"self",
".",
"class",
".",
"new",
"(",
":atom",
"=>",
"t",
".",
"atom",
",",
":exponent",
"=>",
"t",
".",
... | The base units this term is derived from
@return [Array] An array of Unitwise::Term
@api public | [
"The",
"base",
"units",
"this",
"term",
"is",
"derived",
"from"
] | f786d2e660721a0238949e7abce20852879de8ef | https://github.com/joshwlewis/unitwise/blob/f786d2e660721a0238949e7abce20852879de8ef/lib/unitwise/term.rb#L77-L85 | train |
joshwlewis/unitwise | lib/unitwise/term.rb | Unitwise.Term.operate | def operate(operator, other)
exp = operator == '/' ? -1 : 1
if other.respond_to?(:terms)
Unit.new(other.terms.map { |t| t ** exp } << self)
elsif other.respond_to?(:atom)
Unit.new([self, other ** exp])
elsif other.is_a?(Numeric)
self.class.new(to_hash.merge(:factor => fac... | ruby | def operate(operator, other)
exp = operator == '/' ? -1 : 1
if other.respond_to?(:terms)
Unit.new(other.terms.map { |t| t ** exp } << self)
elsif other.respond_to?(:atom)
Unit.new([self, other ** exp])
elsif other.is_a?(Numeric)
self.class.new(to_hash.merge(:factor => fac... | [
"def",
"operate",
"(",
"operator",
",",
"other",
")",
"exp",
"=",
"operator",
"==",
"'/'",
"?",
"-",
"1",
":",
"1",
"if",
"other",
".",
"respond_to?",
"(",
":terms",
")",
"Unit",
".",
"new",
"(",
"other",
".",
"terms",
".",
"map",
"{",
"|",
"t",
... | Multiply or divide a term
@api private | [
"Multiply",
"or",
"divide",
"a",
"term"
] | f786d2e660721a0238949e7abce20852879de8ef | https://github.com/joshwlewis/unitwise/blob/f786d2e660721a0238949e7abce20852879de8ef/lib/unitwise/term.rb#L134-L143 | train |
joshwlewis/unitwise | lib/unitwise/base.rb | Unitwise.Base.to_s | def to_s(mode = :primary_code)
res = send(mode) || primary_code
res.respond_to?(:each) ? res.first.to_s : res.to_s
end | ruby | def to_s(mode = :primary_code)
res = send(mode) || primary_code
res.respond_to?(:each) ? res.first.to_s : res.to_s
end | [
"def",
"to_s",
"(",
"mode",
"=",
":primary_code",
")",
"res",
"=",
"send",
"(",
"mode",
")",
"||",
"primary_code",
"res",
".",
"respond_to?",
"(",
":each",
")",
"?",
"res",
".",
"first",
".",
"to_s",
":",
"res",
".",
"to_s",
"end"
] | String representation for the instance.
@param mode [symbol] The attribute to for stringification
@return [String]
@api public | [
"String",
"representation",
"for",
"the",
"instance",
"."
] | f786d2e660721a0238949e7abce20852879de8ef | https://github.com/joshwlewis/unitwise/blob/f786d2e660721a0238949e7abce20852879de8ef/lib/unitwise/base.rb#L53-L56 | train |
joshwlewis/unitwise | lib/unitwise/atom.rb | Unitwise.Atom.scale= | def scale=(attrs)
@scale = if attrs[:function_code]
Functional.new(attrs[:value], attrs[:unit_code], attrs[:function_code])
else
Scale.new(attrs[:value], attrs[:unit_code])
end
end | ruby | def scale=(attrs)
@scale = if attrs[:function_code]
Functional.new(attrs[:value], attrs[:unit_code], attrs[:function_code])
else
Scale.new(attrs[:value], attrs[:unit_code])
end
end | [
"def",
"scale",
"=",
"(",
"attrs",
")",
"@scale",
"=",
"if",
"attrs",
"[",
":function_code",
"]",
"Functional",
".",
"new",
"(",
"attrs",
"[",
":value",
"]",
",",
"attrs",
"[",
":unit_code",
"]",
",",
"attrs",
"[",
":function_code",
"]",
")",
"else",
... | Set the atom's scale. It can be set as a Scale or a Functional
@return [Unitwise::Functional, Unitwise::Scale]
@api public | [
"Set",
"the",
"atom",
"s",
"scale",
".",
"It",
"can",
"be",
"set",
"as",
"a",
"Scale",
"or",
"a",
"Functional"
] | f786d2e660721a0238949e7abce20852879de8ef | https://github.com/joshwlewis/unitwise/blob/f786d2e660721a0238949e7abce20852879de8ef/lib/unitwise/atom.rb#L93-L99 | train |
joshwlewis/unitwise | lib/unitwise/atom.rb | Unitwise.Atom.validate! | def validate!
missing_properties = %i{primary_code names scale}.select do |prop|
val = liner_get(prop)
val.nil? || (val.respond_to?(:empty) && val.empty?)
end
if !missing_properties.empty?
missing_list = missing_properties.join(',')
raise Unitwise::DefinitionError,
... | ruby | def validate!
missing_properties = %i{primary_code names scale}.select do |prop|
val = liner_get(prop)
val.nil? || (val.respond_to?(:empty) && val.empty?)
end
if !missing_properties.empty?
missing_list = missing_properties.join(',')
raise Unitwise::DefinitionError,
... | [
"def",
"validate!",
"missing_properties",
"=",
"%i{",
"primary_code",
"names",
"scale",
"}",
".",
"select",
"do",
"|",
"prop",
"|",
"val",
"=",
"liner_get",
"(",
"prop",
")",
"val",
".",
"nil?",
"||",
"(",
"val",
".",
"respond_to?",
"(",
":empty",
")",
... | A basic validator for atoms. It checks for the bare minimum properties
and that it's scalar and magnitude can be resolved. Note that this method
requires the units it depends on to already exist, so it is not used
when loading the initial data from UCUM.
@return [true] returns true if the atom is valid
@raise [Uni... | [
"A",
"basic",
"validator",
"for",
"atoms",
".",
"It",
"checks",
"for",
"the",
"bare",
"minimum",
"properties",
"and",
"that",
"it",
"s",
"scalar",
"and",
"magnitude",
"can",
"be",
"resolved",
".",
"Note",
"that",
"this",
"method",
"requires",
"the",
"units... | f786d2e660721a0238949e7abce20852879de8ef | https://github.com/joshwlewis/unitwise/blob/f786d2e660721a0238949e7abce20852879de8ef/lib/unitwise/atom.rb#L128-L148 | train |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.