id
int32 0
24.9k
| repo
stringlengths 5
58
| path
stringlengths 9
168
| func_name
stringlengths 9
130
| original_string
stringlengths 66
10.5k
| language
stringclasses 1
value | code
stringlengths 66
10.5k
| code_tokens
list | docstring
stringlengths 8
16k
| docstring_tokens
list | sha
stringlengths 40
40
| url
stringlengths 94
266
|
|---|---|---|---|---|---|---|---|---|---|---|---|
17,200
|
voltrb/volt
|
lib/volt/reactive/dependency.rb
|
Volt.Dependency.depend
|
def depend
# If there is no @dependencies, don't depend because it has been removed
return unless @dependencies
current = Computation.current
if current
added = @dependencies.add?(current)
if added
# The first time the dependency is depended on by this computation, we call on_dep
@on_dep.call if @on_dep && @dependencies.size == 1
current.on_invalidate do
# If @dependencies is nil, this Dependency has been removed
if @dependencies
# For set, .delete returns a boolean if it was deleted
deleted = @dependencies.delete?(current)
# Call on stop dep if no more deps
@on_stop_dep.call if @on_stop_dep && deleted && @dependencies.size == 0
end
end
end
end
end
|
ruby
|
def depend
# If there is no @dependencies, don't depend because it has been removed
return unless @dependencies
current = Computation.current
if current
added = @dependencies.add?(current)
if added
# The first time the dependency is depended on by this computation, we call on_dep
@on_dep.call if @on_dep && @dependencies.size == 1
current.on_invalidate do
# If @dependencies is nil, this Dependency has been removed
if @dependencies
# For set, .delete returns a boolean if it was deleted
deleted = @dependencies.delete?(current)
# Call on stop dep if no more deps
@on_stop_dep.call if @on_stop_dep && deleted && @dependencies.size == 0
end
end
end
end
end
|
[
"def",
"depend",
"# If there is no @dependencies, don't depend because it has been removed",
"return",
"unless",
"@dependencies",
"current",
"=",
"Computation",
".",
"current",
"if",
"current",
"added",
"=",
"@dependencies",
".",
"add?",
"(",
"current",
")",
"if",
"added",
"# The first time the dependency is depended on by this computation, we call on_dep",
"@on_dep",
".",
"call",
"if",
"@on_dep",
"&&",
"@dependencies",
".",
"size",
"==",
"1",
"current",
".",
"on_invalidate",
"do",
"# If @dependencies is nil, this Dependency has been removed",
"if",
"@dependencies",
"# For set, .delete returns a boolean if it was deleted",
"deleted",
"=",
"@dependencies",
".",
"delete?",
"(",
"current",
")",
"# Call on stop dep if no more deps",
"@on_stop_dep",
".",
"call",
"if",
"@on_stop_dep",
"&&",
"deleted",
"&&",
"@dependencies",
".",
"size",
"==",
"0",
"end",
"end",
"end",
"end",
"end"
] |
Setup a new dependency.
@param on_dep [Proc] a proc to be called the first time a computation depends
on this dependency.
@param on_stop_dep [Proc] a proc to be called when no computations are depending
on this dependency anymore.
|
[
"Setup",
"a",
"new",
"dependency",
"."
] |
f942b92385adbc894ee4a37903ee6a9c1a65e9a4
|
https://github.com/voltrb/volt/blob/f942b92385adbc894ee4a37903ee6a9c1a65e9a4/lib/volt/reactive/dependency.rb#L21-L45
|
17,201
|
voltrb/volt
|
lib/volt/models/model.rb
|
Volt.Model.assign_attributes
|
def assign_attributes(attrs, initial_setup = false, skip_changes = false)
attrs = wrap_values(attrs)
if attrs
# When doing a mass-assign, we don't validate or save until the end.
if initial_setup || skip_changes
Model.no_change_tracking do
assign_all_attributes(attrs, skip_changes)
end
else
assign_all_attributes(attrs)
end
else
# Assign to empty
@attributes = {}
end
# Trigger and change all
@deps.changed_all!
@deps = HashDependency.new
run_initial_setup(initial_setup)
end
|
ruby
|
def assign_attributes(attrs, initial_setup = false, skip_changes = false)
attrs = wrap_values(attrs)
if attrs
# When doing a mass-assign, we don't validate or save until the end.
if initial_setup || skip_changes
Model.no_change_tracking do
assign_all_attributes(attrs, skip_changes)
end
else
assign_all_attributes(attrs)
end
else
# Assign to empty
@attributes = {}
end
# Trigger and change all
@deps.changed_all!
@deps = HashDependency.new
run_initial_setup(initial_setup)
end
|
[
"def",
"assign_attributes",
"(",
"attrs",
",",
"initial_setup",
"=",
"false",
",",
"skip_changes",
"=",
"false",
")",
"attrs",
"=",
"wrap_values",
"(",
"attrs",
")",
"if",
"attrs",
"# When doing a mass-assign, we don't validate or save until the end.",
"if",
"initial_setup",
"||",
"skip_changes",
"Model",
".",
"no_change_tracking",
"do",
"assign_all_attributes",
"(",
"attrs",
",",
"skip_changes",
")",
"end",
"else",
"assign_all_attributes",
"(",
"attrs",
")",
"end",
"else",
"# Assign to empty",
"@attributes",
"=",
"{",
"}",
"end",
"# Trigger and change all",
"@deps",
".",
"changed_all!",
"@deps",
"=",
"HashDependency",
".",
"new",
"run_initial_setup",
"(",
"initial_setup",
")",
"end"
] |
Assign multiple attributes as a hash, directly.
|
[
"Assign",
"multiple",
"attributes",
"as",
"a",
"hash",
"directly",
"."
] |
f942b92385adbc894ee4a37903ee6a9c1a65e9a4
|
https://github.com/voltrb/volt/blob/f942b92385adbc894ee4a37903ee6a9c1a65e9a4/lib/volt/models/model.rb#L140-L162
|
17,202
|
voltrb/volt
|
lib/volt/models/model.rb
|
Volt.Model.set
|
def set(attribute_name, value, &block)
# Assign, without the =
attribute_name = attribute_name.to_sym
check_valid_field_name(attribute_name)
old_value = @attributes[attribute_name]
new_value = wrap_value(value, [attribute_name])
if old_value != new_value
# Track the old value, skip if we are in no_validate
attribute_will_change!(attribute_name, old_value) unless Volt.in_mode?(:no_change_tracking)
# Assign the new value
@attributes[attribute_name] = new_value
@deps.changed!(attribute_name)
@size_dep.changed! if old_value.nil? || new_value.nil?
# TODO: Can we make this so it doesn't need to be handled for non store collections
# (maybe move it to persistor, though thats weird since buffers don't have a persistor)
clear_server_errors(attribute_name) if @server_errors.present?
# Save the changes
run_changed(attribute_name) unless Volt.in_mode?(:no_change_tracking)
end
new_value
end
|
ruby
|
def set(attribute_name, value, &block)
# Assign, without the =
attribute_name = attribute_name.to_sym
check_valid_field_name(attribute_name)
old_value = @attributes[attribute_name]
new_value = wrap_value(value, [attribute_name])
if old_value != new_value
# Track the old value, skip if we are in no_validate
attribute_will_change!(attribute_name, old_value) unless Volt.in_mode?(:no_change_tracking)
# Assign the new value
@attributes[attribute_name] = new_value
@deps.changed!(attribute_name)
@size_dep.changed! if old_value.nil? || new_value.nil?
# TODO: Can we make this so it doesn't need to be handled for non store collections
# (maybe move it to persistor, though thats weird since buffers don't have a persistor)
clear_server_errors(attribute_name) if @server_errors.present?
# Save the changes
run_changed(attribute_name) unless Volt.in_mode?(:no_change_tracking)
end
new_value
end
|
[
"def",
"set",
"(",
"attribute_name",
",",
"value",
",",
"&",
"block",
")",
"# Assign, without the =",
"attribute_name",
"=",
"attribute_name",
".",
"to_sym",
"check_valid_field_name",
"(",
"attribute_name",
")",
"old_value",
"=",
"@attributes",
"[",
"attribute_name",
"]",
"new_value",
"=",
"wrap_value",
"(",
"value",
",",
"[",
"attribute_name",
"]",
")",
"if",
"old_value",
"!=",
"new_value",
"# Track the old value, skip if we are in no_validate",
"attribute_will_change!",
"(",
"attribute_name",
",",
"old_value",
")",
"unless",
"Volt",
".",
"in_mode?",
"(",
":no_change_tracking",
")",
"# Assign the new value",
"@attributes",
"[",
"attribute_name",
"]",
"=",
"new_value",
"@deps",
".",
"changed!",
"(",
"attribute_name",
")",
"@size_dep",
".",
"changed!",
"if",
"old_value",
".",
"nil?",
"||",
"new_value",
".",
"nil?",
"# TODO: Can we make this so it doesn't need to be handled for non store collections",
"# (maybe move it to persistor, though thats weird since buffers don't have a persistor)",
"clear_server_errors",
"(",
"attribute_name",
")",
"if",
"@server_errors",
".",
"present?",
"# Save the changes",
"run_changed",
"(",
"attribute_name",
")",
"unless",
"Volt",
".",
"in_mode?",
"(",
":no_change_tracking",
")",
"end",
"new_value",
"end"
] |
Do the assignment to a model and trigger a changed event
|
[
"Do",
"the",
"assignment",
"to",
"a",
"model",
"and",
"trigger",
"a",
"changed",
"event"
] |
f942b92385adbc894ee4a37903ee6a9c1a65e9a4
|
https://github.com/voltrb/volt/blob/f942b92385adbc894ee4a37903ee6a9c1a65e9a4/lib/volt/models/model.rb#L204-L233
|
17,203
|
voltrb/volt
|
lib/volt/models/model.rb
|
Volt.Model.read_new_model
|
def read_new_model(method_name)
if @persistor && @persistor.respond_to?(:read_new_model)
return @persistor.read_new_model(method_name)
else
opts = @options.merge(parent: self, path: path + [method_name])
if method_name.plural?
return new_array_model([], opts)
else
return new_model({}, opts)
end
end
end
|
ruby
|
def read_new_model(method_name)
if @persistor && @persistor.respond_to?(:read_new_model)
return @persistor.read_new_model(method_name)
else
opts = @options.merge(parent: self, path: path + [method_name])
if method_name.plural?
return new_array_model([], opts)
else
return new_model({}, opts)
end
end
end
|
[
"def",
"read_new_model",
"(",
"method_name",
")",
"if",
"@persistor",
"&&",
"@persistor",
".",
"respond_to?",
"(",
":read_new_model",
")",
"return",
"@persistor",
".",
"read_new_model",
"(",
"method_name",
")",
"else",
"opts",
"=",
"@options",
".",
"merge",
"(",
"parent",
":",
"self",
",",
"path",
":",
"path",
"+",
"[",
"method_name",
"]",
")",
"if",
"method_name",
".",
"plural?",
"return",
"new_array_model",
"(",
"[",
"]",
",",
"opts",
")",
"else",
"return",
"new_model",
"(",
"{",
"}",
",",
"opts",
")",
"end",
"end",
"end"
] |
Get a new model, make it easy to override
|
[
"Get",
"a",
"new",
"model",
"make",
"it",
"easy",
"to",
"override"
] |
f942b92385adbc894ee4a37903ee6a9c1a65e9a4
|
https://github.com/voltrb/volt/blob/f942b92385adbc894ee4a37903ee6a9c1a65e9a4/lib/volt/models/model.rb#L284-L296
|
17,204
|
voltrb/volt
|
lib/volt/models/model.rb
|
Volt.Model.update
|
def update(attrs)
old_attrs = @attributes.dup
Model.no_change_tracking do
assign_all_attributes(attrs, false)
validate!.then do |errs|
if errs && errs.present?
# Revert wholesale
@attributes = old_attrs
Promise.new.resolve(errs)
else
# Persist
persist_changes(nil)
end
end
end
end
|
ruby
|
def update(attrs)
old_attrs = @attributes.dup
Model.no_change_tracking do
assign_all_attributes(attrs, false)
validate!.then do |errs|
if errs && errs.present?
# Revert wholesale
@attributes = old_attrs
Promise.new.resolve(errs)
else
# Persist
persist_changes(nil)
end
end
end
end
|
[
"def",
"update",
"(",
"attrs",
")",
"old_attrs",
"=",
"@attributes",
".",
"dup",
"Model",
".",
"no_change_tracking",
"do",
"assign_all_attributes",
"(",
"attrs",
",",
"false",
")",
"validate!",
".",
"then",
"do",
"|",
"errs",
"|",
"if",
"errs",
"&&",
"errs",
".",
"present?",
"# Revert wholesale",
"@attributes",
"=",
"old_attrs",
"Promise",
".",
"new",
".",
"resolve",
"(",
"errs",
")",
"else",
"# Persist",
"persist_changes",
"(",
"nil",
")",
"end",
"end",
"end",
"end"
] |
Update tries to update the model and returns
|
[
"Update",
"tries",
"to",
"update",
"the",
"model",
"and",
"returns"
] |
f942b92385adbc894ee4a37903ee6a9c1a65e9a4
|
https://github.com/voltrb/volt/blob/f942b92385adbc894ee4a37903ee6a9c1a65e9a4/lib/volt/models/model.rb#L361-L377
|
17,205
|
voltrb/volt
|
lib/volt/server/html_parser/view_scope.rb
|
Volt.ViewScope.close_scope
|
def close_scope(pop = true)
if pop
scope = @handler.scope.pop
else
scope = @handler.last
end
fail "template path already exists: #{scope.path}" if @handler.templates[scope.path]
template = {
'html' => scope.html
}
if scope.bindings.size > 0
# Add the bindings if there are any
template['bindings'] = scope.bindings
end
@handler.templates[scope.path] = template
end
|
ruby
|
def close_scope(pop = true)
if pop
scope = @handler.scope.pop
else
scope = @handler.last
end
fail "template path already exists: #{scope.path}" if @handler.templates[scope.path]
template = {
'html' => scope.html
}
if scope.bindings.size > 0
# Add the bindings if there are any
template['bindings'] = scope.bindings
end
@handler.templates[scope.path] = template
end
|
[
"def",
"close_scope",
"(",
"pop",
"=",
"true",
")",
"if",
"pop",
"scope",
"=",
"@handler",
".",
"scope",
".",
"pop",
"else",
"scope",
"=",
"@handler",
".",
"last",
"end",
"fail",
"\"template path already exists: #{scope.path}\"",
"if",
"@handler",
".",
"templates",
"[",
"scope",
".",
"path",
"]",
"template",
"=",
"{",
"'html'",
"=>",
"scope",
".",
"html",
"}",
"if",
"scope",
".",
"bindings",
".",
"size",
">",
"0",
"# Add the bindings if there are any",
"template",
"[",
"'bindings'",
"]",
"=",
"scope",
".",
"bindings",
"end",
"@handler",
".",
"templates",
"[",
"scope",
".",
"path",
"]",
"=",
"template",
"end"
] |
Called when this scope should be closed out
|
[
"Called",
"when",
"this",
"scope",
"should",
"be",
"closed",
"out"
] |
f942b92385adbc894ee4a37903ee6a9c1a65e9a4
|
https://github.com/voltrb/volt/blob/f942b92385adbc894ee4a37903ee6a9c1a65e9a4/lib/volt/server/html_parser/view_scope.rb#L157-L176
|
17,206
|
voltrb/volt
|
lib/volt/helpers/time/duration.rb
|
Volt.Duration.+
|
def +(other)
if other.is_a?(Volt::Duration)
Volt::Duration.new(value + other.value, parts + other.parts)
else
Volt::Duration.new(value + other, parts + [[:seconds, other]])
end
end
|
ruby
|
def +(other)
if other.is_a?(Volt::Duration)
Volt::Duration.new(value + other.value, parts + other.parts)
else
Volt::Duration.new(value + other, parts + [[:seconds, other]])
end
end
|
[
"def",
"+",
"(",
"other",
")",
"if",
"other",
".",
"is_a?",
"(",
"Volt",
"::",
"Duration",
")",
"Volt",
"::",
"Duration",
".",
"new",
"(",
"value",
"+",
"other",
".",
"value",
",",
"parts",
"+",
"other",
".",
"parts",
")",
"else",
"Volt",
"::",
"Duration",
".",
"new",
"(",
"value",
"+",
"other",
",",
"parts",
"+",
"[",
"[",
":seconds",
",",
"other",
"]",
"]",
")",
"end",
"end"
] |
Compares with the value on another Duration if Duration is passed
or just compares value with the other object
Adds durations or duration to a VoltTime or seconds to the duration
|
[
"Compares",
"with",
"the",
"value",
"on",
"another",
"Duration",
"if",
"Duration",
"is",
"passed",
"or",
"just",
"compares",
"value",
"with",
"the",
"other",
"object",
"Adds",
"durations",
"or",
"duration",
"to",
"a",
"VoltTime",
"or",
"seconds",
"to",
"the",
"duration"
] |
f942b92385adbc894ee4a37903ee6a9c1a65e9a4
|
https://github.com/voltrb/volt/blob/f942b92385adbc894ee4a37903ee6a9c1a65e9a4/lib/volt/helpers/time/duration.rb#L23-L29
|
17,207
|
voltrb/volt
|
lib/volt/server/html_parser/sandlebars_parser.rb
|
Volt.SandlebarsParser.start_binding
|
def start_binding
binding = ''
open_count = 1
# scan until we reach a {{ or }}
loop do
binding << @html.scan_until(/(\{\{|\}\}|\n|\Z)/)
match = @html[1]
if match == '}}'
# close
open_count -= 1
break if open_count == 0
elsif match == '{{'
# open more
open_count += 1
elsif match == "\n" || @html.eos?
# Starting new tag, should be closed before this
# or end of doc before closed binding
raise_parse_error("unclosed binding: {#{binding.strip}")
else
#:nocov:
fail 'should not reach here'
#:nocov:
end
end
binding = binding[0..-3]
@handler.binding(binding) if @handler.respond_to?(:binding)
end
|
ruby
|
def start_binding
binding = ''
open_count = 1
# scan until we reach a {{ or }}
loop do
binding << @html.scan_until(/(\{\{|\}\}|\n|\Z)/)
match = @html[1]
if match == '}}'
# close
open_count -= 1
break if open_count == 0
elsif match == '{{'
# open more
open_count += 1
elsif match == "\n" || @html.eos?
# Starting new tag, should be closed before this
# or end of doc before closed binding
raise_parse_error("unclosed binding: {#{binding.strip}")
else
#:nocov:
fail 'should not reach here'
#:nocov:
end
end
binding = binding[0..-3]
@handler.binding(binding) if @handler.respond_to?(:binding)
end
|
[
"def",
"start_binding",
"binding",
"=",
"''",
"open_count",
"=",
"1",
"# scan until we reach a {{ or }}",
"loop",
"do",
"binding",
"<<",
"@html",
".",
"scan_until",
"(",
"/",
"\\{",
"\\{",
"\\}",
"\\}",
"\\n",
"\\Z",
"/",
")",
"match",
"=",
"@html",
"[",
"1",
"]",
"if",
"match",
"==",
"'}}'",
"# close",
"open_count",
"-=",
"1",
"break",
"if",
"open_count",
"==",
"0",
"elsif",
"match",
"==",
"'{{'",
"# open more",
"open_count",
"+=",
"1",
"elsif",
"match",
"==",
"\"\\n\"",
"||",
"@html",
".",
"eos?",
"# Starting new tag, should be closed before this",
"# or end of doc before closed binding",
"raise_parse_error",
"(",
"\"unclosed binding: {#{binding.strip}\"",
")",
"else",
"#:nocov:",
"fail",
"'should not reach here'",
"#:nocov:",
"end",
"end",
"binding",
"=",
"binding",
"[",
"0",
"..",
"-",
"3",
"]",
"@handler",
".",
"binding",
"(",
"binding",
")",
"if",
"@handler",
".",
"respond_to?",
"(",
":binding",
")",
"end"
] |
Findings the end of a binding
|
[
"Findings",
"the",
"end",
"of",
"a",
"binding"
] |
f942b92385adbc894ee4a37903ee6a9c1a65e9a4
|
https://github.com/voltrb/volt/blob/f942b92385adbc894ee4a37903ee6a9c1a65e9a4/lib/volt/server/html_parser/sandlebars_parser.rb#L104-L133
|
17,208
|
voltrb/volt
|
lib/volt/server/rack/http_resource.rb
|
Volt.HttpResource.dispatch_to_controller
|
def dispatch_to_controller(params, request)
namespace = params[:component] || 'main'
controller_name = params[:controller] + '_controller'
action = params[:action]
namespace_module = Object.const_get(namespace.camelize.to_sym)
klass = namespace_module.const_get(controller_name.camelize.to_sym)
controller = klass.new(@volt_app, params, request)
# Use the 'meta' thread local to set the user_id for Volt.current_user
meta_data = {}
user_id = request.cookies['user_id']
meta_data['user_id'] = user_id if user_id
Thread.current['meta'] = meta_data
controller.perform(action)
end
|
ruby
|
def dispatch_to_controller(params, request)
namespace = params[:component] || 'main'
controller_name = params[:controller] + '_controller'
action = params[:action]
namespace_module = Object.const_get(namespace.camelize.to_sym)
klass = namespace_module.const_get(controller_name.camelize.to_sym)
controller = klass.new(@volt_app, params, request)
# Use the 'meta' thread local to set the user_id for Volt.current_user
meta_data = {}
user_id = request.cookies['user_id']
meta_data['user_id'] = user_id if user_id
Thread.current['meta'] = meta_data
controller.perform(action)
end
|
[
"def",
"dispatch_to_controller",
"(",
"params",
",",
"request",
")",
"namespace",
"=",
"params",
"[",
":component",
"]",
"||",
"'main'",
"controller_name",
"=",
"params",
"[",
":controller",
"]",
"+",
"'_controller'",
"action",
"=",
"params",
"[",
":action",
"]",
"namespace_module",
"=",
"Object",
".",
"const_get",
"(",
"namespace",
".",
"camelize",
".",
"to_sym",
")",
"klass",
"=",
"namespace_module",
".",
"const_get",
"(",
"controller_name",
".",
"camelize",
".",
"to_sym",
")",
"controller",
"=",
"klass",
".",
"new",
"(",
"@volt_app",
",",
"params",
",",
"request",
")",
"# Use the 'meta' thread local to set the user_id for Volt.current_user",
"meta_data",
"=",
"{",
"}",
"user_id",
"=",
"request",
".",
"cookies",
"[",
"'user_id'",
"]",
"meta_data",
"[",
"'user_id'",
"]",
"=",
"user_id",
"if",
"user_id",
"Thread",
".",
"current",
"[",
"'meta'",
"]",
"=",
"meta_data",
"controller",
".",
"perform",
"(",
"action",
")",
"end"
] |
Find the correct controller and call the correct action on it.
The controller name and actions need to be set as params for the
matching route
|
[
"Find",
"the",
"correct",
"controller",
"and",
"call",
"the",
"correct",
"action",
"on",
"it",
".",
"The",
"controller",
"name",
"and",
"actions",
"need",
"to",
"be",
"set",
"as",
"params",
"for",
"the",
"matching",
"route"
] |
f942b92385adbc894ee4a37903ee6a9c1a65e9a4
|
https://github.com/voltrb/volt/blob/f942b92385adbc894ee4a37903ee6a9c1a65e9a4/lib/volt/server/rack/http_resource.rb#L34-L51
|
17,209
|
voltrb/volt
|
lib/volt/page/bindings/each_binding.rb
|
Volt.EachBinding.update
|
def update(value)
# Since we're checking things like size, we don't want this to be re-triggered on a
# size change, so we run without tracking.
Computation.run_without_tracking do
# Adjust to the new size
values = current_values(value)
@value = values
remove_listeners
if @value.respond_to?(:on)
@added_listener = @value.on('added') { |position| item_added(position) }
@removed_listener = @value.on('removed') { |position| item_removed(position) }
end
templates_size = nil
values_size = nil
Volt.run_in_mode(:no_model_promises) do
templates_size = @templates.size
unless values.respond_to?(:size)
fail InvalidObjectForEachBinding, "Each binding's require an object that responds to size and [] methods. The binding received: #{values.inspect}"
end
values_size = values.size
end
# Start over, re-create all nodes
(templates_size - 1).downto(0) do |index|
item_removed(index)
end
0.upto(values_size - 1) do |index|
item_added(index)
end
end
end
|
ruby
|
def update(value)
# Since we're checking things like size, we don't want this to be re-triggered on a
# size change, so we run without tracking.
Computation.run_without_tracking do
# Adjust to the new size
values = current_values(value)
@value = values
remove_listeners
if @value.respond_to?(:on)
@added_listener = @value.on('added') { |position| item_added(position) }
@removed_listener = @value.on('removed') { |position| item_removed(position) }
end
templates_size = nil
values_size = nil
Volt.run_in_mode(:no_model_promises) do
templates_size = @templates.size
unless values.respond_to?(:size)
fail InvalidObjectForEachBinding, "Each binding's require an object that responds to size and [] methods. The binding received: #{values.inspect}"
end
values_size = values.size
end
# Start over, re-create all nodes
(templates_size - 1).downto(0) do |index|
item_removed(index)
end
0.upto(values_size - 1) do |index|
item_added(index)
end
end
end
|
[
"def",
"update",
"(",
"value",
")",
"# Since we're checking things like size, we don't want this to be re-triggered on a",
"# size change, so we run without tracking.",
"Computation",
".",
"run_without_tracking",
"do",
"# Adjust to the new size",
"values",
"=",
"current_values",
"(",
"value",
")",
"@value",
"=",
"values",
"remove_listeners",
"if",
"@value",
".",
"respond_to?",
"(",
":on",
")",
"@added_listener",
"=",
"@value",
".",
"on",
"(",
"'added'",
")",
"{",
"|",
"position",
"|",
"item_added",
"(",
"position",
")",
"}",
"@removed_listener",
"=",
"@value",
".",
"on",
"(",
"'removed'",
")",
"{",
"|",
"position",
"|",
"item_removed",
"(",
"position",
")",
"}",
"end",
"templates_size",
"=",
"nil",
"values_size",
"=",
"nil",
"Volt",
".",
"run_in_mode",
"(",
":no_model_promises",
")",
"do",
"templates_size",
"=",
"@templates",
".",
"size",
"unless",
"values",
".",
"respond_to?",
"(",
":size",
")",
"fail",
"InvalidObjectForEachBinding",
",",
"\"Each binding's require an object that responds to size and [] methods. The binding received: #{values.inspect}\"",
"end",
"values_size",
"=",
"values",
".",
"size",
"end",
"# Start over, re-create all nodes",
"(",
"templates_size",
"-",
"1",
")",
".",
"downto",
"(",
"0",
")",
"do",
"|",
"index",
"|",
"item_removed",
"(",
"index",
")",
"end",
"0",
".",
"upto",
"(",
"values_size",
"-",
"1",
")",
"do",
"|",
"index",
"|",
"item_added",
"(",
"index",
")",
"end",
"end",
"end"
] |
When a changed event happens, we update to the new size.
|
[
"When",
"a",
"changed",
"event",
"happens",
"we",
"update",
"to",
"the",
"new",
"size",
"."
] |
f942b92385adbc894ee4a37903ee6a9c1a65e9a4
|
https://github.com/voltrb/volt/blob/f942b92385adbc894ee4a37903ee6a9c1a65e9a4/lib/volt/page/bindings/each_binding.rb#L41-L78
|
17,210
|
voltrb/volt
|
lib/volt/page/bindings/each_binding.rb
|
Volt.EachBinding.update_indexes_after
|
def update_indexes_after(start_index)
size = @templates.size
if size > 0
start_index.upto(size - 1) do |index|
@templates[index].context.locals[:_index=].call(index)
end
end
end
|
ruby
|
def update_indexes_after(start_index)
size = @templates.size
if size > 0
start_index.upto(size - 1) do |index|
@templates[index].context.locals[:_index=].call(index)
end
end
end
|
[
"def",
"update_indexes_after",
"(",
"start_index",
")",
"size",
"=",
"@templates",
".",
"size",
"if",
"size",
">",
"0",
"start_index",
".",
"upto",
"(",
"size",
"-",
"1",
")",
"do",
"|",
"index",
"|",
"@templates",
"[",
"index",
"]",
".",
"context",
".",
"locals",
"[",
":_index=",
"]",
".",
"call",
"(",
"index",
")",
"end",
"end",
"end"
] |
When items are added or removed in the middle of the list, we need
to update each templates index value.
|
[
"When",
"items",
"are",
"added",
"or",
"removed",
"in",
"the",
"middle",
"of",
"the",
"list",
"we",
"need",
"to",
"update",
"each",
"templates",
"index",
"value",
"."
] |
f942b92385adbc894ee4a37903ee6a9c1a65e9a4
|
https://github.com/voltrb/volt/blob/f942b92385adbc894ee4a37903ee6a9c1a65e9a4/lib/volt/page/bindings/each_binding.rb#L152-L159
|
17,211
|
voltrb/volt
|
lib/volt/page/bindings/each_binding.rb
|
Volt.EachBinding.remove
|
def remove
@computation.stop
@computation = nil
# Clear value
@value = []
@getter = nil
remove_listeners
if @templates
template_count = @templates.size
template_count.times do |index|
item_removed(template_count - index - 1)
end
# @templates.compact.each(&:remove)
@templates = nil
end
super
end
|
ruby
|
def remove
@computation.stop
@computation = nil
# Clear value
@value = []
@getter = nil
remove_listeners
if @templates
template_count = @templates.size
template_count.times do |index|
item_removed(template_count - index - 1)
end
# @templates.compact.each(&:remove)
@templates = nil
end
super
end
|
[
"def",
"remove",
"@computation",
".",
"stop",
"@computation",
"=",
"nil",
"# Clear value",
"@value",
"=",
"[",
"]",
"@getter",
"=",
"nil",
"remove_listeners",
"if",
"@templates",
"template_count",
"=",
"@templates",
".",
"size",
"template_count",
".",
"times",
"do",
"|",
"index",
"|",
"item_removed",
"(",
"template_count",
"-",
"index",
"-",
"1",
")",
"end",
"# @templates.compact.each(&:remove)",
"@templates",
"=",
"nil",
"end",
"super",
"end"
] |
When this each_binding is removed, cleanup.
|
[
"When",
"this",
"each_binding",
"is",
"removed",
"cleanup",
"."
] |
f942b92385adbc894ee4a37903ee6a9c1a65e9a4
|
https://github.com/voltrb/volt/blob/f942b92385adbc894ee4a37903ee6a9c1a65e9a4/lib/volt/page/bindings/each_binding.rb#L180-L201
|
17,212
|
voltrb/volt
|
lib/volt/router/routes.rb
|
Volt.Routes.rest
|
def rest(path, params)
endpoints = (params.delete(:only) || [:index, :show, :create, :update, :destroy]).to_a
endpoints = endpoints - params.delete(:except).to_a
endpoints.each do |endpoint|
self.send(('restful_' + endpoint.to_s).to_sym, path, params)
end
end
|
ruby
|
def rest(path, params)
endpoints = (params.delete(:only) || [:index, :show, :create, :update, :destroy]).to_a
endpoints = endpoints - params.delete(:except).to_a
endpoints.each do |endpoint|
self.send(('restful_' + endpoint.to_s).to_sym, path, params)
end
end
|
[
"def",
"rest",
"(",
"path",
",",
"params",
")",
"endpoints",
"=",
"(",
"params",
".",
"delete",
"(",
":only",
")",
"||",
"[",
":index",
",",
":show",
",",
":create",
",",
":update",
",",
":destroy",
"]",
")",
".",
"to_a",
"endpoints",
"=",
"endpoints",
"-",
"params",
".",
"delete",
"(",
":except",
")",
".",
"to_a",
"endpoints",
".",
"each",
"do",
"|",
"endpoint",
"|",
"self",
".",
"send",
"(",
"(",
"'restful_'",
"+",
"endpoint",
".",
"to_s",
")",
".",
"to_sym",
",",
"path",
",",
"params",
")",
"end",
"end"
] |
Create rest endpoints
|
[
"Create",
"rest",
"endpoints"
] |
f942b92385adbc894ee4a37903ee6a9c1a65e9a4
|
https://github.com/voltrb/volt/blob/f942b92385adbc894ee4a37903ee6a9c1a65e9a4/lib/volt/router/routes.rb#L93-L99
|
17,213
|
voltrb/volt
|
lib/volt/router/routes.rb
|
Volt.Routes.params_to_url
|
def params_to_url(test_params)
# Extract the desired method from the params
method = test_params.delete(:method) || :client
method = method.to_sym
# Add in underscores
test_params = test_params.each_with_object({}) do |(k, v), obj|
obj[k.to_sym] = v
end
@param_matches[method].each do |param_matcher|
# TODO: Maybe a deep dup?
result, new_params = check_params_match(test_params.dup, param_matcher[0])
return param_matcher[1].call(new_params) if result
end
[nil, nil]
end
|
ruby
|
def params_to_url(test_params)
# Extract the desired method from the params
method = test_params.delete(:method) || :client
method = method.to_sym
# Add in underscores
test_params = test_params.each_with_object({}) do |(k, v), obj|
obj[k.to_sym] = v
end
@param_matches[method].each do |param_matcher|
# TODO: Maybe a deep dup?
result, new_params = check_params_match(test_params.dup, param_matcher[0])
return param_matcher[1].call(new_params) if result
end
[nil, nil]
end
|
[
"def",
"params_to_url",
"(",
"test_params",
")",
"# Extract the desired method from the params",
"method",
"=",
"test_params",
".",
"delete",
"(",
":method",
")",
"||",
":client",
"method",
"=",
"method",
".",
"to_sym",
"# Add in underscores",
"test_params",
"=",
"test_params",
".",
"each_with_object",
"(",
"{",
"}",
")",
"do",
"|",
"(",
"k",
",",
"v",
")",
",",
"obj",
"|",
"obj",
"[",
"k",
".",
"to_sym",
"]",
"=",
"v",
"end",
"@param_matches",
"[",
"method",
"]",
".",
"each",
"do",
"|",
"param_matcher",
"|",
"# TODO: Maybe a deep dup?",
"result",
",",
"new_params",
"=",
"check_params_match",
"(",
"test_params",
".",
"dup",
",",
"param_matcher",
"[",
"0",
"]",
")",
"return",
"param_matcher",
"[",
"1",
"]",
".",
"call",
"(",
"new_params",
")",
"if",
"result",
"end",
"[",
"nil",
",",
"nil",
"]",
"end"
] |
Takes in params and generates a path and the remaining params
that should be shown in the url. The extra "unused" params
will be tacked onto the end of the url ?param1=value1, etc...
returns the url and new params, or nil, nil if no match is found.
|
[
"Takes",
"in",
"params",
"and",
"generates",
"a",
"path",
"and",
"the",
"remaining",
"params",
"that",
"should",
"be",
"shown",
"in",
"the",
"url",
".",
"The",
"extra",
"unused",
"params",
"will",
"be",
"tacked",
"onto",
"the",
"end",
"of",
"the",
"url",
"?param1",
"=",
"value1",
"etc",
"..."
] |
f942b92385adbc894ee4a37903ee6a9c1a65e9a4
|
https://github.com/voltrb/volt/blob/f942b92385adbc894ee4a37903ee6a9c1a65e9a4/lib/volt/router/routes.rb#L126-L144
|
17,214
|
voltrb/volt
|
lib/volt/router/routes.rb
|
Volt.Routes.url_to_params
|
def url_to_params(*args)
if args.size < 2
path = args[0]
method = :client
else
path = args[1]
method = args[0].to_sym
end
# First try a direct match
result = @direct_routes[method][path]
return result if result
# Next, split the url and walk the sections
parts = url_parts(path)
match_path(parts, parts, @indirect_routes[method])
end
|
ruby
|
def url_to_params(*args)
if args.size < 2
path = args[0]
method = :client
else
path = args[1]
method = args[0].to_sym
end
# First try a direct match
result = @direct_routes[method][path]
return result if result
# Next, split the url and walk the sections
parts = url_parts(path)
match_path(parts, parts, @indirect_routes[method])
end
|
[
"def",
"url_to_params",
"(",
"*",
"args",
")",
"if",
"args",
".",
"size",
"<",
"2",
"path",
"=",
"args",
"[",
"0",
"]",
"method",
"=",
":client",
"else",
"path",
"=",
"args",
"[",
"1",
"]",
"method",
"=",
"args",
"[",
"0",
"]",
".",
"to_sym",
"end",
"# First try a direct match",
"result",
"=",
"@direct_routes",
"[",
"method",
"]",
"[",
"path",
"]",
"return",
"result",
"if",
"result",
"# Next, split the url and walk the sections",
"parts",
"=",
"url_parts",
"(",
"path",
")",
"match_path",
"(",
"parts",
",",
"parts",
",",
"@indirect_routes",
"[",
"method",
"]",
")",
"end"
] |
Takes in a path and returns the matching params.
returns params as a hash
|
[
"Takes",
"in",
"a",
"path",
"and",
"returns",
"the",
"matching",
"params",
".",
"returns",
"params",
"as",
"a",
"hash"
] |
f942b92385adbc894ee4a37903ee6a9c1a65e9a4
|
https://github.com/voltrb/volt/blob/f942b92385adbc894ee4a37903ee6a9c1a65e9a4/lib/volt/router/routes.rb#L148-L165
|
17,215
|
voltrb/volt
|
lib/volt/router/routes.rb
|
Volt.Routes.match_path
|
def match_path(original_parts, remaining_parts, node)
# Take off the top part and get the rest into a new array
# part will be nil if we are out of parts (fancy how that works out, now
# stand in wonder about how much someone thought this through, though
# really I just got lucky)
part, *parts = remaining_parts
if part.nil?
if node[part]
# We found a match, replace the bindings and return
# TODO: Handle nested
setup_bindings_in_params(original_parts, node[part])
else
false
end
else
if (new_node = node[part])
# Direct match for section, continue
result = match_path(original_parts, parts, new_node)
return result if result
end
if (new_node = node['*'])
# Match on binding single section
result = match_path(original_parts, parts, new_node)
return result if result
end
if ((params = node['**']) && params && (params = params[nil]))
# Match on binding multiple sections
result = setup_bindings_in_params(original_parts, params)
return result if result
end
return false
end
end
|
ruby
|
def match_path(original_parts, remaining_parts, node)
# Take off the top part and get the rest into a new array
# part will be nil if we are out of parts (fancy how that works out, now
# stand in wonder about how much someone thought this through, though
# really I just got lucky)
part, *parts = remaining_parts
if part.nil?
if node[part]
# We found a match, replace the bindings and return
# TODO: Handle nested
setup_bindings_in_params(original_parts, node[part])
else
false
end
else
if (new_node = node[part])
# Direct match for section, continue
result = match_path(original_parts, parts, new_node)
return result if result
end
if (new_node = node['*'])
# Match on binding single section
result = match_path(original_parts, parts, new_node)
return result if result
end
if ((params = node['**']) && params && (params = params[nil]))
# Match on binding multiple sections
result = setup_bindings_in_params(original_parts, params)
return result if result
end
return false
end
end
|
[
"def",
"match_path",
"(",
"original_parts",
",",
"remaining_parts",
",",
"node",
")",
"# Take off the top part and get the rest into a new array",
"# part will be nil if we are out of parts (fancy how that works out, now",
"# stand in wonder about how much someone thought this through, though",
"# really I just got lucky)",
"part",
",",
"*",
"parts",
"=",
"remaining_parts",
"if",
"part",
".",
"nil?",
"if",
"node",
"[",
"part",
"]",
"# We found a match, replace the bindings and return",
"# TODO: Handle nested",
"setup_bindings_in_params",
"(",
"original_parts",
",",
"node",
"[",
"part",
"]",
")",
"else",
"false",
"end",
"else",
"if",
"(",
"new_node",
"=",
"node",
"[",
"part",
"]",
")",
"# Direct match for section, continue",
"result",
"=",
"match_path",
"(",
"original_parts",
",",
"parts",
",",
"new_node",
")",
"return",
"result",
"if",
"result",
"end",
"if",
"(",
"new_node",
"=",
"node",
"[",
"'*'",
"]",
")",
"# Match on binding single section",
"result",
"=",
"match_path",
"(",
"original_parts",
",",
"parts",
",",
"new_node",
")",
"return",
"result",
"if",
"result",
"end",
"if",
"(",
"(",
"params",
"=",
"node",
"[",
"'**'",
"]",
")",
"&&",
"params",
"&&",
"(",
"params",
"=",
"params",
"[",
"nil",
"]",
")",
")",
"# Match on binding multiple sections",
"result",
"=",
"setup_bindings_in_params",
"(",
"original_parts",
",",
"params",
")",
"return",
"result",
"if",
"result",
"end",
"return",
"false",
"end",
"end"
] |
Recursively walk the @indirect_routes hash, return the params for a route, return
false for non-matches.
|
[
"Recursively",
"walk",
"the"
] |
f942b92385adbc894ee4a37903ee6a9c1a65e9a4
|
https://github.com/voltrb/volt/blob/f942b92385adbc894ee4a37903ee6a9c1a65e9a4/lib/volt/router/routes.rb#L183-L217
|
17,216
|
voltrb/volt
|
lib/volt/router/routes.rb
|
Volt.Routes.setup_bindings_in_params
|
def setup_bindings_in_params(original_parts, params)
# Create a copy of the params we can modify and return
params = params.dup
params.each_pair do |key, value|
if value.is_a?(Fixnum)
# Lookup the param's value in the original url parts
params[key] = original_parts[value]
elsif value.is_a?(Range)
# When doing multiple section bindings, we lookup the parts as a range
# then join them with /
params[key] = original_parts[value].join('/')
end
end
params
end
|
ruby
|
def setup_bindings_in_params(original_parts, params)
# Create a copy of the params we can modify and return
params = params.dup
params.each_pair do |key, value|
if value.is_a?(Fixnum)
# Lookup the param's value in the original url parts
params[key] = original_parts[value]
elsif value.is_a?(Range)
# When doing multiple section bindings, we lookup the parts as a range
# then join them with /
params[key] = original_parts[value].join('/')
end
end
params
end
|
[
"def",
"setup_bindings_in_params",
"(",
"original_parts",
",",
"params",
")",
"# Create a copy of the params we can modify and return",
"params",
"=",
"params",
".",
"dup",
"params",
".",
"each_pair",
"do",
"|",
"key",
",",
"value",
"|",
"if",
"value",
".",
"is_a?",
"(",
"Fixnum",
")",
"# Lookup the param's value in the original url parts",
"params",
"[",
"key",
"]",
"=",
"original_parts",
"[",
"value",
"]",
"elsif",
"value",
".",
"is_a?",
"(",
"Range",
")",
"# When doing multiple section bindings, we lookup the parts as a range",
"# then join them with /",
"params",
"[",
"key",
"]",
"=",
"original_parts",
"[",
"value",
"]",
".",
"join",
"(",
"'/'",
")",
"end",
"end",
"params",
"end"
] |
The params out of match_path will have integers in the params that came from bindings
in the url. This replaces those with the values from the url.
|
[
"The",
"params",
"out",
"of",
"match_path",
"will",
"have",
"integers",
"in",
"the",
"params",
"that",
"came",
"from",
"bindings",
"in",
"the",
"url",
".",
"This",
"replaces",
"those",
"with",
"the",
"values",
"from",
"the",
"url",
"."
] |
f942b92385adbc894ee4a37903ee6a9c1a65e9a4
|
https://github.com/voltrb/volt/blob/f942b92385adbc894ee4a37903ee6a9c1a65e9a4/lib/volt/router/routes.rb#L221-L237
|
17,217
|
voltrb/volt
|
lib/volt/router/routes.rb
|
Volt.Routes.check_params_match
|
def check_params_match(test_params, param_matcher)
param_matcher.each_pair do |key, value|
if value.is_a?(Hash)
if test_params[key]
result = check_params_match(test_params[key], value)
if result == false
return false
else
test_params.delete(key)
end
else
# test_params did not have matching key
return false
end
elsif value.nil?
return false unless test_params.key?(key)
else
if test_params[key] == value
test_params.delete(key)
else
return false
end
end
end
[true, test_params]
end
|
ruby
|
def check_params_match(test_params, param_matcher)
param_matcher.each_pair do |key, value|
if value.is_a?(Hash)
if test_params[key]
result = check_params_match(test_params[key], value)
if result == false
return false
else
test_params.delete(key)
end
else
# test_params did not have matching key
return false
end
elsif value.nil?
return false unless test_params.key?(key)
else
if test_params[key] == value
test_params.delete(key)
else
return false
end
end
end
[true, test_params]
end
|
[
"def",
"check_params_match",
"(",
"test_params",
",",
"param_matcher",
")",
"param_matcher",
".",
"each_pair",
"do",
"|",
"key",
",",
"value",
"|",
"if",
"value",
".",
"is_a?",
"(",
"Hash",
")",
"if",
"test_params",
"[",
"key",
"]",
"result",
"=",
"check_params_match",
"(",
"test_params",
"[",
"key",
"]",
",",
"value",
")",
"if",
"result",
"==",
"false",
"return",
"false",
"else",
"test_params",
".",
"delete",
"(",
"key",
")",
"end",
"else",
"# test_params did not have matching key",
"return",
"false",
"end",
"elsif",
"value",
".",
"nil?",
"return",
"false",
"unless",
"test_params",
".",
"key?",
"(",
"key",
")",
"else",
"if",
"test_params",
"[",
"key",
"]",
"==",
"value",
"test_params",
".",
"delete",
"(",
"key",
")",
"else",
"return",
"false",
"end",
"end",
"end",
"[",
"true",
",",
"test_params",
"]",
"end"
] |
Takes in a hash of params and checks to make sure keys in param_matcher
are in test_params. Checks for equal value unless value in param_matcher
is nil.
returns false or true, new_params - where the new params are a the params not
used in the basic match. Later some of these may be inserted into the url.
|
[
"Takes",
"in",
"a",
"hash",
"of",
"params",
"and",
"checks",
"to",
"make",
"sure",
"keys",
"in",
"param_matcher",
"are",
"in",
"test_params",
".",
"Checks",
"for",
"equal",
"value",
"unless",
"value",
"in",
"param_matcher",
"is",
"nil",
"."
] |
f942b92385adbc894ee4a37903ee6a9c1a65e9a4
|
https://github.com/voltrb/volt/blob/f942b92385adbc894ee4a37903ee6a9c1a65e9a4/lib/volt/router/routes.rb#L323-L350
|
17,218
|
voltrb/volt
|
lib/volt/models/associations.rb
|
Volt.Associations.association_with_root_model
|
def association_with_root_model(method_name)
persistor = self.persistor || (respond_to?(:save_to) && save_to && save_to.persistor)
# Check if we are on the store collection
if persistor.is_a?(Volt::Persistors::ModelStore) ||
persistor.is_a?(Volt::Persistors::Page)
# Get the root node
root = persistor.try(:root_model)
# Yield to the block passing in the root node
yield(root)
else
# raise an error about the method not being supported on this collection
fail "#{method_name} currently only works on the store and page collection (support for other collections coming soon)"
end
end
|
ruby
|
def association_with_root_model(method_name)
persistor = self.persistor || (respond_to?(:save_to) && save_to && save_to.persistor)
# Check if we are on the store collection
if persistor.is_a?(Volt::Persistors::ModelStore) ||
persistor.is_a?(Volt::Persistors::Page)
# Get the root node
root = persistor.try(:root_model)
# Yield to the block passing in the root node
yield(root)
else
# raise an error about the method not being supported on this collection
fail "#{method_name} currently only works on the store and page collection (support for other collections coming soon)"
end
end
|
[
"def",
"association_with_root_model",
"(",
"method_name",
")",
"persistor",
"=",
"self",
".",
"persistor",
"||",
"(",
"respond_to?",
"(",
":save_to",
")",
"&&",
"save_to",
"&&",
"save_to",
".",
"persistor",
")",
"# Check if we are on the store collection",
"if",
"persistor",
".",
"is_a?",
"(",
"Volt",
"::",
"Persistors",
"::",
"ModelStore",
")",
"||",
"persistor",
".",
"is_a?",
"(",
"Volt",
"::",
"Persistors",
"::",
"Page",
")",
"# Get the root node",
"root",
"=",
"persistor",
".",
"try",
"(",
":root_model",
")",
"# Yield to the block passing in the root node",
"yield",
"(",
"root",
")",
"else",
"# raise an error about the method not being supported on this collection",
"fail",
"\"#{method_name} currently only works on the store and page collection (support for other collections coming soon)\"",
"end",
"end"
] |
Currently the has_many and belongs_to associations only work on the store collection,
this method checks to make sure we are on store and returns the root reference to it.
|
[
"Currently",
"the",
"has_many",
"and",
"belongs_to",
"associations",
"only",
"work",
"on",
"the",
"store",
"collection",
"this",
"method",
"checks",
"to",
"make",
"sure",
"we",
"are",
"on",
"store",
"and",
"returns",
"the",
"root",
"reference",
"to",
"it",
"."
] |
f942b92385adbc894ee4a37903ee6a9c1a65e9a4
|
https://github.com/voltrb/volt/blob/f942b92385adbc894ee4a37903ee6a9c1a65e9a4/lib/volt/models/associations.rb#L77-L92
|
17,219
|
voltrb/volt
|
lib/volt/server/forking_server.rb
|
Volt.ForkingServer.boot_error
|
def boot_error(error)
msg = error.inspect
if error.respond_to?(:backtrace)
msg << "\n" + error.backtrace.join("\n")
end
Volt.logger.error(msg)
# Only require when needed
require 'cgi'
@rack_app = Proc.new do
path = File.join(File.dirname(__FILE__), "forking_server/boot_error.html.erb")
html = File.read(path)
error_page = ERB.new(html, nil, '-').result(binding)
[500, {"Content-Type" => "text/html"}, error_page]
end
@dispatcher = ErrorDispatcher.new
end
|
ruby
|
def boot_error(error)
msg = error.inspect
if error.respond_to?(:backtrace)
msg << "\n" + error.backtrace.join("\n")
end
Volt.logger.error(msg)
# Only require when needed
require 'cgi'
@rack_app = Proc.new do
path = File.join(File.dirname(__FILE__), "forking_server/boot_error.html.erb")
html = File.read(path)
error_page = ERB.new(html, nil, '-').result(binding)
[500, {"Content-Type" => "text/html"}, error_page]
end
@dispatcher = ErrorDispatcher.new
end
|
[
"def",
"boot_error",
"(",
"error",
")",
"msg",
"=",
"error",
".",
"inspect",
"if",
"error",
".",
"respond_to?",
"(",
":backtrace",
")",
"msg",
"<<",
"\"\\n\"",
"+",
"error",
".",
"backtrace",
".",
"join",
"(",
"\"\\n\"",
")",
"end",
"Volt",
".",
"logger",
".",
"error",
"(",
"msg",
")",
"# Only require when needed",
"require",
"'cgi'",
"@rack_app",
"=",
"Proc",
".",
"new",
"do",
"path",
"=",
"File",
".",
"join",
"(",
"File",
".",
"dirname",
"(",
"__FILE__",
")",
",",
"\"forking_server/boot_error.html.erb\"",
")",
"html",
"=",
"File",
".",
"read",
"(",
"path",
")",
"error_page",
"=",
"ERB",
".",
"new",
"(",
"html",
",",
"nil",
",",
"'-'",
")",
".",
"result",
"(",
"binding",
")",
"[",
"500",
",",
"{",
"\"Content-Type\"",
"=>",
"\"text/html\"",
"}",
",",
"error_page",
"]",
"end",
"@dispatcher",
"=",
"ErrorDispatcher",
".",
"new",
"end"
] |
called from the child when the boot failes. Sets up an error page rack
app to show the user the error and handle reloading requests.
|
[
"called",
"from",
"the",
"child",
"when",
"the",
"boot",
"failes",
".",
"Sets",
"up",
"an",
"error",
"page",
"rack",
"app",
"to",
"show",
"the",
"user",
"the",
"error",
"and",
"handle",
"reloading",
"requests",
"."
] |
f942b92385adbc894ee4a37903ee6a9c1a65e9a4
|
https://github.com/voltrb/volt/blob/f942b92385adbc894ee4a37903ee6a9c1a65e9a4/lib/volt/server/forking_server.rb#L102-L120
|
17,220
|
voltrb/volt
|
lib/volt/server/html_parser/attribute_scope.rb
|
Volt.AttributeScope.process_attributes
|
def process_attributes(tag_name, attributes)
new_attributes = attributes.dup
attributes.each_pair do |name, value|
if name[0..1] == 'e-'
process_event_binding(tag_name, new_attributes, name, value)
else
process_attribute(tag_name, new_attributes, name, value)
end
end
new_attributes
end
|
ruby
|
def process_attributes(tag_name, attributes)
new_attributes = attributes.dup
attributes.each_pair do |name, value|
if name[0..1] == 'e-'
process_event_binding(tag_name, new_attributes, name, value)
else
process_attribute(tag_name, new_attributes, name, value)
end
end
new_attributes
end
|
[
"def",
"process_attributes",
"(",
"tag_name",
",",
"attributes",
")",
"new_attributes",
"=",
"attributes",
".",
"dup",
"attributes",
".",
"each_pair",
"do",
"|",
"name",
",",
"value",
"|",
"if",
"name",
"[",
"0",
"..",
"1",
"]",
"==",
"'e-'",
"process_event_binding",
"(",
"tag_name",
",",
"new_attributes",
",",
"name",
",",
"value",
")",
"else",
"process_attribute",
"(",
"tag_name",
",",
"new_attributes",
",",
"name",
",",
"value",
")",
"end",
"end",
"new_attributes",
"end"
] |
Take the attributes and create any bindings
|
[
"Take",
"the",
"attributes",
"and",
"create",
"any",
"bindings"
] |
f942b92385adbc894ee4a37903ee6a9c1a65e9a4
|
https://github.com/voltrb/volt/blob/f942b92385adbc894ee4a37903ee6a9c1a65e9a4/lib/volt/server/html_parser/attribute_scope.rb#L29-L41
|
17,221
|
voltrb/volt
|
lib/volt/server/html_parser/attribute_scope.rb
|
Volt.AttributeScope.binding_parts_and_count
|
def binding_parts_and_count(value)
if value.is_a?(String)
parts = value.split(/(\{\{[^\}]+\}\})/).reject(&:blank?)
else
parts = ['']
end
binding_count = parts.count { |p| p[0] == '{' && p[1] == '{' && p[-2] == '}' && p[-1] == '}' }
[parts, binding_count]
end
|
ruby
|
def binding_parts_and_count(value)
if value.is_a?(String)
parts = value.split(/(\{\{[^\}]+\}\})/).reject(&:blank?)
else
parts = ['']
end
binding_count = parts.count { |p| p[0] == '{' && p[1] == '{' && p[-2] == '}' && p[-1] == '}' }
[parts, binding_count]
end
|
[
"def",
"binding_parts_and_count",
"(",
"value",
")",
"if",
"value",
".",
"is_a?",
"(",
"String",
")",
"parts",
"=",
"value",
".",
"split",
"(",
"/",
"\\{",
"\\{",
"\\}",
"\\}",
"\\}",
"/",
")",
".",
"reject",
"(",
":blank?",
")",
"else",
"parts",
"=",
"[",
"''",
"]",
"end",
"binding_count",
"=",
"parts",
".",
"count",
"{",
"|",
"p",
"|",
"p",
"[",
"0",
"]",
"==",
"'{'",
"&&",
"p",
"[",
"1",
"]",
"==",
"'{'",
"&&",
"p",
"[",
"-",
"2",
"]",
"==",
"'}'",
"&&",
"p",
"[",
"-",
"1",
"]",
"==",
"'}'",
"}",
"[",
"parts",
",",
"binding_count",
"]",
"end"
] |
Takes a string and splits on bindings, returns the string split on bindings
and the number of bindings.
|
[
"Takes",
"a",
"string",
"and",
"splits",
"on",
"bindings",
"returns",
"the",
"string",
"split",
"on",
"bindings",
"and",
"the",
"number",
"of",
"bindings",
"."
] |
f942b92385adbc894ee4a37903ee6a9c1a65e9a4
|
https://github.com/voltrb/volt/blob/f942b92385adbc894ee4a37903ee6a9c1a65e9a4/lib/volt/server/html_parser/attribute_scope.rb#L63-L72
|
17,222
|
voltrb/volt
|
lib/volt/server/html_parser/component_view_scope.rb
|
Volt.ComponentViewScope.close_scope
|
def close_scope
binding_number = @handler.scope[-2].binding_number
@handler.scope[-2].binding_number += 1
@path += "/__template/#{binding_number}"
super
@handler.html << "<!-- $#{binding_number} --><!-- $/#{binding_number} -->"
@handler.scope.last.save_binding(binding_number, "lambda { |__p, __t, __c, __id| Volt::ComponentBinding.new(__p, __t, __c, __id, #{@binding_in_path.inspect}, Proc.new { [#{@arguments}] }, #{@path.inspect}) }")
end
|
ruby
|
def close_scope
binding_number = @handler.scope[-2].binding_number
@handler.scope[-2].binding_number += 1
@path += "/__template/#{binding_number}"
super
@handler.html << "<!-- $#{binding_number} --><!-- $/#{binding_number} -->"
@handler.scope.last.save_binding(binding_number, "lambda { |__p, __t, __c, __id| Volt::ComponentBinding.new(__p, __t, __c, __id, #{@binding_in_path.inspect}, Proc.new { [#{@arguments}] }, #{@path.inspect}) }")
end
|
[
"def",
"close_scope",
"binding_number",
"=",
"@handler",
".",
"scope",
"[",
"-",
"2",
"]",
".",
"binding_number",
"@handler",
".",
"scope",
"[",
"-",
"2",
"]",
".",
"binding_number",
"+=",
"1",
"@path",
"+=",
"\"/__template/#{binding_number}\"",
"super",
"@handler",
".",
"html",
"<<",
"\"<!-- $#{binding_number} --><!-- $/#{binding_number} -->\"",
"@handler",
".",
"scope",
".",
"last",
".",
"save_binding",
"(",
"binding_number",
",",
"\"lambda { |__p, __t, __c, __id| Volt::ComponentBinding.new(__p, __t, __c, __id, #{@binding_in_path.inspect}, Proc.new { [#{@arguments}] }, #{@path.inspect}) }\"",
")",
"end"
] |
The path passed in is the path used to lookup view's. The path from the tag is passed in
as tag_name
|
[
"The",
"path",
"passed",
"in",
"is",
"the",
"path",
"used",
"to",
"lookup",
"view",
"s",
".",
"The",
"path",
"from",
"the",
"tag",
"is",
"passed",
"in",
"as",
"tag_name"
] |
f942b92385adbc894ee4a37903ee6a9c1a65e9a4
|
https://github.com/voltrb/volt/blob/f942b92385adbc894ee4a37903ee6a9c1a65e9a4/lib/volt/server/html_parser/component_view_scope.rb#L56-L65
|
17,223
|
voltrb/volt
|
lib/volt/server/rack/asset_files.rb
|
Volt.AssetFiles.javascript_tags
|
def javascript_tags(volt_app)
@opal_tag_generator ||= Opal::Server::Index.new(nil, volt_app.opal_files.server)
javascript_files = []
@assets.each do |type, path|
case type
when :folder
# for a folder, we search for all .js files and return a tag for them
base_path = base(path)
javascript_files += Dir["#{path}/**/*.js"].sort.map do |folder|
# Grab the component folder/assets/js/file.js
local_path = folder[path.size..-1]
@app_url + '/' + base_path + local_path
end
when :javascript_file
# javascript_file is a cdn path to a JS file
javascript_files << path
end
end
javascript_files = javascript_files.uniq
scripts = javascript_files.map {|url| "<script src=\"#{url}\"></script>" }
# Include volt itself. Unless we are running with MAPS=all, just include
# the main file without sourcemaps.
volt_path = 'volt/volt/app'
if ENV['MAPS'] == 'all'
scripts << @opal_tag_generator.javascript_include_tag(volt_path)
else
scripts << "<script src=\"#{volt_app.app_url}/#{volt_path}.js\"></script>"
scripts << "<script>#{Opal::Processor.load_asset_code(volt_app.sprockets, volt_path)}</script>"
end
scripts << @opal_tag_generator.javascript_include_tag('components/main')
scripts.join("\n")
end
|
ruby
|
def javascript_tags(volt_app)
@opal_tag_generator ||= Opal::Server::Index.new(nil, volt_app.opal_files.server)
javascript_files = []
@assets.each do |type, path|
case type
when :folder
# for a folder, we search for all .js files and return a tag for them
base_path = base(path)
javascript_files += Dir["#{path}/**/*.js"].sort.map do |folder|
# Grab the component folder/assets/js/file.js
local_path = folder[path.size..-1]
@app_url + '/' + base_path + local_path
end
when :javascript_file
# javascript_file is a cdn path to a JS file
javascript_files << path
end
end
javascript_files = javascript_files.uniq
scripts = javascript_files.map {|url| "<script src=\"#{url}\"></script>" }
# Include volt itself. Unless we are running with MAPS=all, just include
# the main file without sourcemaps.
volt_path = 'volt/volt/app'
if ENV['MAPS'] == 'all'
scripts << @opal_tag_generator.javascript_include_tag(volt_path)
else
scripts << "<script src=\"#{volt_app.app_url}/#{volt_path}.js\"></script>"
scripts << "<script>#{Opal::Processor.load_asset_code(volt_app.sprockets, volt_path)}</script>"
end
scripts << @opal_tag_generator.javascript_include_tag('components/main')
scripts.join("\n")
end
|
[
"def",
"javascript_tags",
"(",
"volt_app",
")",
"@opal_tag_generator",
"||=",
"Opal",
"::",
"Server",
"::",
"Index",
".",
"new",
"(",
"nil",
",",
"volt_app",
".",
"opal_files",
".",
"server",
")",
"javascript_files",
"=",
"[",
"]",
"@assets",
".",
"each",
"do",
"|",
"type",
",",
"path",
"|",
"case",
"type",
"when",
":folder",
"# for a folder, we search for all .js files and return a tag for them",
"base_path",
"=",
"base",
"(",
"path",
")",
"javascript_files",
"+=",
"Dir",
"[",
"\"#{path}/**/*.js\"",
"]",
".",
"sort",
".",
"map",
"do",
"|",
"folder",
"|",
"# Grab the component folder/assets/js/file.js",
"local_path",
"=",
"folder",
"[",
"path",
".",
"size",
"..",
"-",
"1",
"]",
"@app_url",
"+",
"'/'",
"+",
"base_path",
"+",
"local_path",
"end",
"when",
":javascript_file",
"# javascript_file is a cdn path to a JS file",
"javascript_files",
"<<",
"path",
"end",
"end",
"javascript_files",
"=",
"javascript_files",
".",
"uniq",
"scripts",
"=",
"javascript_files",
".",
"map",
"{",
"|",
"url",
"|",
"\"<script src=\\\"#{url}\\\"></script>\"",
"}",
"# Include volt itself. Unless we are running with MAPS=all, just include",
"# the main file without sourcemaps.",
"volt_path",
"=",
"'volt/volt/app'",
"if",
"ENV",
"[",
"'MAPS'",
"]",
"==",
"'all'",
"scripts",
"<<",
"@opal_tag_generator",
".",
"javascript_include_tag",
"(",
"volt_path",
")",
"else",
"scripts",
"<<",
"\"<script src=\\\"#{volt_app.app_url}/#{volt_path}.js\\\"></script>\"",
"scripts",
"<<",
"\"<script>#{Opal::Processor.load_asset_code(volt_app.sprockets, volt_path)}</script>\"",
"end",
"scripts",
"<<",
"@opal_tag_generator",
".",
"javascript_include_tag",
"(",
"'components/main'",
")",
"scripts",
".",
"join",
"(",
"\"\\n\"",
")",
"end"
] |
Returns script tags that should be included
|
[
"Returns",
"script",
"tags",
"that",
"should",
"be",
"included"
] |
f942b92385adbc894ee4a37903ee6a9c1a65e9a4
|
https://github.com/voltrb/volt/blob/f942b92385adbc894ee4a37903ee6a9c1a65e9a4/lib/volt/server/rack/asset_files.rb#L125-L162
|
17,224
|
voltrb/volt
|
lib/volt/server/rack/asset_files.rb
|
Volt.AssetFiles.css
|
def css
css_files = []
@assets.each do |type, path|
case type
when :folder
# Don't import any css/scss files that start with an underscore, so scss partials
# aren't imported by default:
# http://sass-lang.com/guide
base_path = base(path)
css_files += Dir["#{path}/**/[^_]*.{css,scss,sass}"].sort.map do |folder|
local_path = folder[path.size..-1].gsub(/[.](scss|sass)$/, '')
css_path = @app_url + '/' + base_path + local_path
css_path += '.css' unless css_path =~ /[.]css$/
css_path
end
when :css_file
css_files << path
end
end
css_files.uniq
end
|
ruby
|
def css
css_files = []
@assets.each do |type, path|
case type
when :folder
# Don't import any css/scss files that start with an underscore, so scss partials
# aren't imported by default:
# http://sass-lang.com/guide
base_path = base(path)
css_files += Dir["#{path}/**/[^_]*.{css,scss,sass}"].sort.map do |folder|
local_path = folder[path.size..-1].gsub(/[.](scss|sass)$/, '')
css_path = @app_url + '/' + base_path + local_path
css_path += '.css' unless css_path =~ /[.]css$/
css_path
end
when :css_file
css_files << path
end
end
css_files.uniq
end
|
[
"def",
"css",
"css_files",
"=",
"[",
"]",
"@assets",
".",
"each",
"do",
"|",
"type",
",",
"path",
"|",
"case",
"type",
"when",
":folder",
"# Don't import any css/scss files that start with an underscore, so scss partials",
"# aren't imported by default:",
"# http://sass-lang.com/guide",
"base_path",
"=",
"base",
"(",
"path",
")",
"css_files",
"+=",
"Dir",
"[",
"\"#{path}/**/[^_]*.{css,scss,sass}\"",
"]",
".",
"sort",
".",
"map",
"do",
"|",
"folder",
"|",
"local_path",
"=",
"folder",
"[",
"path",
".",
"size",
"..",
"-",
"1",
"]",
".",
"gsub",
"(",
"/",
"/",
",",
"''",
")",
"css_path",
"=",
"@app_url",
"+",
"'/'",
"+",
"base_path",
"+",
"local_path",
"css_path",
"+=",
"'.css'",
"unless",
"css_path",
"=~",
"/",
"/",
"css_path",
"end",
"when",
":css_file",
"css_files",
"<<",
"path",
"end",
"end",
"css_files",
".",
"uniq",
"end"
] |
Returns an array of all css files that should be included.
|
[
"Returns",
"an",
"array",
"of",
"all",
"css",
"files",
"that",
"should",
"be",
"included",
"."
] |
f942b92385adbc894ee4a37903ee6a9c1a65e9a4
|
https://github.com/voltrb/volt/blob/f942b92385adbc894ee4a37903ee6a9c1a65e9a4/lib/volt/server/rack/asset_files.rb#L172-L193
|
17,225
|
voltrb/volt
|
lib/volt/utils/generic_pool.rb
|
Volt.GenericPool.lookup_without_generate
|
def lookup_without_generate(*args)
section = @pool
args.each_with_index do |arg, index|
section = section[arg]
return nil unless section
end
section
end
|
ruby
|
def lookup_without_generate(*args)
section = @pool
args.each_with_index do |arg, index|
section = section[arg]
return nil unless section
end
section
end
|
[
"def",
"lookup_without_generate",
"(",
"*",
"args",
")",
"section",
"=",
"@pool",
"args",
".",
"each_with_index",
"do",
"|",
"arg",
",",
"index",
"|",
"section",
"=",
"section",
"[",
"arg",
"]",
"return",
"nil",
"unless",
"section",
"end",
"section",
"end"
] |
Looks up the path without generating a new one
|
[
"Looks",
"up",
"the",
"path",
"without",
"generating",
"a",
"new",
"one"
] |
f942b92385adbc894ee4a37903ee6a9c1a65e9a4
|
https://github.com/voltrb/volt/blob/f942b92385adbc894ee4a37903ee6a9c1a65e9a4/lib/volt/utils/generic_pool.rb#L46-L55
|
17,226
|
voltrb/volt
|
lib/volt/models/errors.rb
|
Volt.Errors.merge!
|
def merge!(errors)
if errors
errors.each_pair do |field, messages|
messages.each do |message|
add(field, message)
end
end
end
end
|
ruby
|
def merge!(errors)
if errors
errors.each_pair do |field, messages|
messages.each do |message|
add(field, message)
end
end
end
end
|
[
"def",
"merge!",
"(",
"errors",
")",
"if",
"errors",
"errors",
".",
"each_pair",
"do",
"|",
"field",
",",
"messages",
"|",
"messages",
".",
"each",
"do",
"|",
"message",
"|",
"add",
"(",
"field",
",",
"message",
")",
"end",
"end",
"end",
"end"
] |
Merge another set of errors in
|
[
"Merge",
"another",
"set",
"of",
"errors",
"in"
] |
f942b92385adbc894ee4a37903ee6a9c1a65e9a4
|
https://github.com/voltrb/volt/blob/f942b92385adbc894ee4a37903ee6a9c1a65e9a4/lib/volt/models/errors.rb#L11-L19
|
17,227
|
voltrb/volt
|
lib/volt/server/html_parser/view_handler.rb
|
Volt.ViewHandler.link_asset
|
def link_asset(url, link=true)
if @sprockets_context
# Getting the asset_path also links to the context.
linked_url = @sprockets_context.asset_path(url)
else
# When compiling on the server, we don't use sprockets (atm), so the
# context won't exist. Typically compiling on the server is just used
# to test, so we simply return the url.
linked_url = url
end
last << url if link
linked_url
end
|
ruby
|
def link_asset(url, link=true)
if @sprockets_context
# Getting the asset_path also links to the context.
linked_url = @sprockets_context.asset_path(url)
else
# When compiling on the server, we don't use sprockets (atm), so the
# context won't exist. Typically compiling on the server is just used
# to test, so we simply return the url.
linked_url = url
end
last << url if link
linked_url
end
|
[
"def",
"link_asset",
"(",
"url",
",",
"link",
"=",
"true",
")",
"if",
"@sprockets_context",
"# Getting the asset_path also links to the context.",
"linked_url",
"=",
"@sprockets_context",
".",
"asset_path",
"(",
"url",
")",
"else",
"# When compiling on the server, we don't use sprockets (atm), so the",
"# context won't exist. Typically compiling on the server is just used",
"# to test, so we simply return the url.",
"linked_url",
"=",
"url",
"end",
"last",
"<<",
"url",
"if",
"link",
"linked_url",
"end"
] |
Called from the view scope when an asset_url binding is hit.
|
[
"Called",
"from",
"the",
"view",
"scope",
"when",
"an",
"asset_url",
"binding",
"is",
"hit",
"."
] |
f942b92385adbc894ee4a37903ee6a9c1a65e9a4
|
https://github.com/voltrb/volt/blob/f942b92385adbc894ee4a37903ee6a9c1a65e9a4/lib/volt/server/html_parser/view_handler.rb#L92-L106
|
17,228
|
voltrb/volt
|
lib/volt/server/rack/component_code.rb
|
Volt.ComponentCode.code
|
def code
# Start with config code
initializer_code = @client ? generate_config_code : ''
component_code = ''
asset_files = AssetFiles.from_cache(@volt_app.app_url, @component_name, @component_paths)
asset_files.component_paths.each do |component_path, component_name|
comp_template = ComponentTemplates.new(component_path, component_name, @client)
initializer_code << comp_template.initializer_code + "\n\n"
component_code << comp_template.component_code + "\n\n"
end
initializer_code + component_code
end
|
ruby
|
def code
# Start with config code
initializer_code = @client ? generate_config_code : ''
component_code = ''
asset_files = AssetFiles.from_cache(@volt_app.app_url, @component_name, @component_paths)
asset_files.component_paths.each do |component_path, component_name|
comp_template = ComponentTemplates.new(component_path, component_name, @client)
initializer_code << comp_template.initializer_code + "\n\n"
component_code << comp_template.component_code + "\n\n"
end
initializer_code + component_code
end
|
[
"def",
"code",
"# Start with config code",
"initializer_code",
"=",
"@client",
"?",
"generate_config_code",
":",
"''",
"component_code",
"=",
"''",
"asset_files",
"=",
"AssetFiles",
".",
"from_cache",
"(",
"@volt_app",
".",
"app_url",
",",
"@component_name",
",",
"@component_paths",
")",
"asset_files",
".",
"component_paths",
".",
"each",
"do",
"|",
"component_path",
",",
"component_name",
"|",
"comp_template",
"=",
"ComponentTemplates",
".",
"new",
"(",
"component_path",
",",
"component_name",
",",
"@client",
")",
"initializer_code",
"<<",
"comp_template",
".",
"initializer_code",
"+",
"\"\\n\\n\"",
"component_code",
"<<",
"comp_template",
".",
"component_code",
"+",
"\"\\n\\n\"",
"end",
"initializer_code",
"+",
"component_code",
"end"
] |
The client argument is for if this code is being generated for the client
|
[
"The",
"client",
"argument",
"is",
"for",
"if",
"this",
"code",
"is",
"being",
"generated",
"for",
"the",
"client"
] |
f942b92385adbc894ee4a37903ee6a9c1a65e9a4
|
https://github.com/voltrb/volt/blob/f942b92385adbc894ee4a37903ee6a9c1a65e9a4/lib/volt/server/rack/component_code.rb#L17-L30
|
17,229
|
voltrb/volt
|
lib/volt/models/model_wrapper.rb
|
Volt.ModelWrapper.wrap_value
|
def wrap_value(value, lookup)
if value.is_a?(Array)
new_array_model(value, @options.merge(parent: self, path: path + lookup))
elsif value.is_a?(Hash)
new_model(value, @options.merge(parent: self, path: path + lookup))
else
value
end
end
|
ruby
|
def wrap_value(value, lookup)
if value.is_a?(Array)
new_array_model(value, @options.merge(parent: self, path: path + lookup))
elsif value.is_a?(Hash)
new_model(value, @options.merge(parent: self, path: path + lookup))
else
value
end
end
|
[
"def",
"wrap_value",
"(",
"value",
",",
"lookup",
")",
"if",
"value",
".",
"is_a?",
"(",
"Array",
")",
"new_array_model",
"(",
"value",
",",
"@options",
".",
"merge",
"(",
"parent",
":",
"self",
",",
"path",
":",
"path",
"+",
"lookup",
")",
")",
"elsif",
"value",
".",
"is_a?",
"(",
"Hash",
")",
"new_model",
"(",
"value",
",",
"@options",
".",
"merge",
"(",
"parent",
":",
"self",
",",
"path",
":",
"path",
"+",
"lookup",
")",
")",
"else",
"value",
"end",
"end"
] |
For cretain values, we wrap them to make the behave as a
model.
|
[
"For",
"cretain",
"values",
"we",
"wrap",
"them",
"to",
"make",
"the",
"behave",
"as",
"a",
"model",
"."
] |
f942b92385adbc894ee4a37903ee6a9c1a65e9a4
|
https://github.com/voltrb/volt/blob/f942b92385adbc894ee4a37903ee6a9c1a65e9a4/lib/volt/models/model_wrapper.rb#L5-L13
|
17,230
|
jfairbank/chroma
|
lib/chroma/harmonies.rb
|
Chroma.Harmonies.analogous
|
def analogous(options = {})
size = options[:size] || 6
slices = options[:slice_by] || 30
hsl = @color.hsl
part = 360 / slices
hsl.h = ((hsl.h - (part * size >> 1)) + 720) % 360
palette = (size - 1).times.reduce([@color]) do |arr, n|
hsl.h = (hsl.h + part) % 360
arr << Color.new(hsl, @color.format)
end
with_reformat(palette, options[:as])
end
|
ruby
|
def analogous(options = {})
size = options[:size] || 6
slices = options[:slice_by] || 30
hsl = @color.hsl
part = 360 / slices
hsl.h = ((hsl.h - (part * size >> 1)) + 720) % 360
palette = (size - 1).times.reduce([@color]) do |arr, n|
hsl.h = (hsl.h + part) % 360
arr << Color.new(hsl, @color.format)
end
with_reformat(palette, options[:as])
end
|
[
"def",
"analogous",
"(",
"options",
"=",
"{",
"}",
")",
"size",
"=",
"options",
"[",
":size",
"]",
"||",
"6",
"slices",
"=",
"options",
"[",
":slice_by",
"]",
"||",
"30",
"hsl",
"=",
"@color",
".",
"hsl",
"part",
"=",
"360",
"/",
"slices",
"hsl",
".",
"h",
"=",
"(",
"(",
"hsl",
".",
"h",
"-",
"(",
"part",
"*",
"size",
">>",
"1",
")",
")",
"+",
"720",
")",
"%",
"360",
"palette",
"=",
"(",
"size",
"-",
"1",
")",
".",
"times",
".",
"reduce",
"(",
"[",
"@color",
"]",
")",
"do",
"|",
"arr",
",",
"n",
"|",
"hsl",
".",
"h",
"=",
"(",
"hsl",
".",
"h",
"+",
"part",
")",
"%",
"360",
"arr",
"<<",
"Color",
".",
"new",
"(",
"hsl",
",",
"@color",
".",
"format",
")",
"end",
"with_reformat",
"(",
"palette",
",",
"options",
"[",
":as",
"]",
")",
"end"
] |
Generate an analogous palette.
@example
'red'.paint.palette.analogous #=> [red, #ff0066, #ff0033, red, #ff3300, #ff6600]
'red'.paint.palette.analogous(as: :hex) #=> ['#f00', '#f06', '#f03', '#f00', '#f30', '#f60']
'red'.paint.palette.analogous(size: 3) #=> [red, #ff001a, #ff1a00]
'red'.paint.palette.analogous(size: 3, slice_by: 60) #=> [red, #ff000d, #ff0d00]
@param options [Hash]
@option options :size [Symbol] (6) number of results to return
@option options :slice_by [Symbol] (30)
the angle in degrees to slice the hue circle per color
@option options :as [Symbol] (nil) optional format to output colors as strings
@return [Array<Color>, Array<String>] depending on presence of `options[:as]`
|
[
"Generate",
"an",
"analogous",
"palette",
"."
] |
acbb19f98172c969ba887ab5cee3c1e12e125a9c
|
https://github.com/jfairbank/chroma/blob/acbb19f98172c969ba887ab5cee3c1e12e125a9c/lib/chroma/harmonies.rb#L79-L93
|
17,231
|
jfairbank/chroma
|
lib/chroma/harmonies.rb
|
Chroma.Harmonies.monochromatic
|
def monochromatic(options = {})
size = options[:size] || 6
h, s, v = @color.hsv
modification = 1.0 / size
palette = size.times.map do
Color.new(ColorModes::Hsv.new(h, s, v), @color.format).tap do
v = (v + modification) % 1
end
end
with_reformat(palette, options[:as])
end
|
ruby
|
def monochromatic(options = {})
size = options[:size] || 6
h, s, v = @color.hsv
modification = 1.0 / size
palette = size.times.map do
Color.new(ColorModes::Hsv.new(h, s, v), @color.format).tap do
v = (v + modification) % 1
end
end
with_reformat(palette, options[:as])
end
|
[
"def",
"monochromatic",
"(",
"options",
"=",
"{",
"}",
")",
"size",
"=",
"options",
"[",
":size",
"]",
"||",
"6",
"h",
",",
"s",
",",
"v",
"=",
"@color",
".",
"hsv",
"modification",
"=",
"1.0",
"/",
"size",
"palette",
"=",
"size",
".",
"times",
".",
"map",
"do",
"Color",
".",
"new",
"(",
"ColorModes",
"::",
"Hsv",
".",
"new",
"(",
"h",
",",
"s",
",",
"v",
")",
",",
"@color",
".",
"format",
")",
".",
"tap",
"do",
"v",
"=",
"(",
"v",
"+",
"modification",
")",
"%",
"1",
"end",
"end",
"with_reformat",
"(",
"palette",
",",
"options",
"[",
":as",
"]",
")",
"end"
] |
Generate a monochromatic palette.
@example
'red'.paint.palette.monochromatic #=> [red, #2a0000, #550000, maroon, #aa0000, #d40000]
'red'.paint.palette.monochromatic(as: :hex) #=> ['#ff0000', '#2a0000', '#550000', '#800000', '#aa0000', '#d40000']
'red'.paint.palette.monochromatic(size: 3) #=> [red, #550000, #aa0000]
@param options [Hash]
@option options :size [Symbol] (6) number of results to return
@option options :as [Symbol] (nil) optional format to output colors as strings
@return [Array<Color>, Array<String>] depending on presence of `options[:as]`
|
[
"Generate",
"a",
"monochromatic",
"palette",
"."
] |
acbb19f98172c969ba887ab5cee3c1e12e125a9c
|
https://github.com/jfairbank/chroma/blob/acbb19f98172c969ba887ab5cee3c1e12e125a9c/lib/chroma/harmonies.rb#L106-L119
|
17,232
|
cookpad/barbeque
|
lib/barbeque/message_queue.rb
|
Barbeque.MessageQueue.dequeue
|
def dequeue
loop do
return nil if @stop
message = receive_message
if message
if message.valid?
return message
else
delete_message(message)
end
end
end
end
|
ruby
|
def dequeue
loop do
return nil if @stop
message = receive_message
if message
if message.valid?
return message
else
delete_message(message)
end
end
end
end
|
[
"def",
"dequeue",
"loop",
"do",
"return",
"nil",
"if",
"@stop",
"message",
"=",
"receive_message",
"if",
"message",
"if",
"message",
".",
"valid?",
"return",
"message",
"else",
"delete_message",
"(",
"message",
")",
"end",
"end",
"end",
"end"
] |
Receive a message from SQS queue.
@return [Barbeque::Message::Base]
|
[
"Receive",
"a",
"message",
"from",
"SQS",
"queue",
"."
] |
2c719e278e3dc0b3f2f852e794ee71326a446696
|
https://github.com/cookpad/barbeque/blob/2c719e278e3dc0b3f2f852e794ee71326a446696/lib/barbeque/message_queue.rb#L17-L29
|
17,233
|
rhomobile/rhodes
|
lib/framework/rho/rho.rb
|
Rho.RHO.init_sources
|
def init_sources()
return unless defined? Rho::RhoConfig::sources
@all_models_loaded = true
uniq_sources = Rho::RhoConfig::sources.values
puts 'init_sources: ' #+ uniq_sources.inspect
uniq_sources.each do |source|
source['str_associations'] = ""
end
uniq_sources.each do |source|
partition = source['partition']
@db_partitions[partition] = nil unless @db_partitions[partition]
if source['belongs_to']
source['belongs_to'].each do |hash_pair|
attrib = hash_pair.keys[0]
src_name = hash_pair.values[0]
associationsSrc = find_src_byname(uniq_sources, src_name)
if !associationsSrc
puts "Error: belongs_to '#{source['name']}' : source name '#{src_name}' does not exist."
next
end
str_associations = associationsSrc['str_associations']
str_associations = "" unless str_associations
str_associations += ',' if str_associations.length() > 0
str_associations += source['name'] + ',' + attrib
associationsSrc['str_associations'] = str_associations
end
end
end
#user partition should alwayse exist
@db_partitions['user'] = nil unless @db_partitions['user']
hash_migrate = {}
puts "@db_partitions : #{@db_partitions}"
@db_partitions.each do |partition, db|
db = Rhom::RhomDbAdapter.new(Rho::RhoFSConnector::get_db_fullpathname(partition), partition) unless db
db.start_transaction
begin
init_db_sources(db, uniq_sources, partition,hash_migrate)
#SyncEngine.update_blob_attribs(partition, -1 )
db.commit
rescue Exception => e
trace_msg = e.backtrace.join("\n")
puts "exception when init_db_sources: #{e}; Trace:" + trace_msg
db.rollback
end
@db_partitions[partition] = db
end
puts "Migrate schema sources: #{hash_migrate}"
::Rho::RHO.init_schema_sources(hash_migrate)
::Rho::RHO.check_sources_migration(uniq_sources)
#@db_partitions.each do |partition, db|
# SyncEngine.update_blob_attribs(partition, -1 )
#end
::Rho::RHO.init_sync_source_properties(uniq_sources)
end
|
ruby
|
def init_sources()
return unless defined? Rho::RhoConfig::sources
@all_models_loaded = true
uniq_sources = Rho::RhoConfig::sources.values
puts 'init_sources: ' #+ uniq_sources.inspect
uniq_sources.each do |source|
source['str_associations'] = ""
end
uniq_sources.each do |source|
partition = source['partition']
@db_partitions[partition] = nil unless @db_partitions[partition]
if source['belongs_to']
source['belongs_to'].each do |hash_pair|
attrib = hash_pair.keys[0]
src_name = hash_pair.values[0]
associationsSrc = find_src_byname(uniq_sources, src_name)
if !associationsSrc
puts "Error: belongs_to '#{source['name']}' : source name '#{src_name}' does not exist."
next
end
str_associations = associationsSrc['str_associations']
str_associations = "" unless str_associations
str_associations += ',' if str_associations.length() > 0
str_associations += source['name'] + ',' + attrib
associationsSrc['str_associations'] = str_associations
end
end
end
#user partition should alwayse exist
@db_partitions['user'] = nil unless @db_partitions['user']
hash_migrate = {}
puts "@db_partitions : #{@db_partitions}"
@db_partitions.each do |partition, db|
db = Rhom::RhomDbAdapter.new(Rho::RhoFSConnector::get_db_fullpathname(partition), partition) unless db
db.start_transaction
begin
init_db_sources(db, uniq_sources, partition,hash_migrate)
#SyncEngine.update_blob_attribs(partition, -1 )
db.commit
rescue Exception => e
trace_msg = e.backtrace.join("\n")
puts "exception when init_db_sources: #{e}; Trace:" + trace_msg
db.rollback
end
@db_partitions[partition] = db
end
puts "Migrate schema sources: #{hash_migrate}"
::Rho::RHO.init_schema_sources(hash_migrate)
::Rho::RHO.check_sources_migration(uniq_sources)
#@db_partitions.each do |partition, db|
# SyncEngine.update_blob_attribs(partition, -1 )
#end
::Rho::RHO.init_sync_source_properties(uniq_sources)
end
|
[
"def",
"init_sources",
"(",
")",
"return",
"unless",
"defined?",
"Rho",
"::",
"RhoConfig",
"::",
"sources",
"@all_models_loaded",
"=",
"true",
"uniq_sources",
"=",
"Rho",
"::",
"RhoConfig",
"::",
"sources",
".",
"values",
"puts",
"'init_sources: '",
"#+ uniq_sources.inspect",
"uniq_sources",
".",
"each",
"do",
"|",
"source",
"|",
"source",
"[",
"'str_associations'",
"]",
"=",
"\"\"",
"end",
"uniq_sources",
".",
"each",
"do",
"|",
"source",
"|",
"partition",
"=",
"source",
"[",
"'partition'",
"]",
"@db_partitions",
"[",
"partition",
"]",
"=",
"nil",
"unless",
"@db_partitions",
"[",
"partition",
"]",
"if",
"source",
"[",
"'belongs_to'",
"]",
"source",
"[",
"'belongs_to'",
"]",
".",
"each",
"do",
"|",
"hash_pair",
"|",
"attrib",
"=",
"hash_pair",
".",
"keys",
"[",
"0",
"]",
"src_name",
"=",
"hash_pair",
".",
"values",
"[",
"0",
"]",
"associationsSrc",
"=",
"find_src_byname",
"(",
"uniq_sources",
",",
"src_name",
")",
"if",
"!",
"associationsSrc",
"puts",
"\"Error: belongs_to '#{source['name']}' : source name '#{src_name}' does not exist.\"",
"next",
"end",
"str_associations",
"=",
"associationsSrc",
"[",
"'str_associations'",
"]",
"str_associations",
"=",
"\"\"",
"unless",
"str_associations",
"str_associations",
"+=",
"','",
"if",
"str_associations",
".",
"length",
"(",
")",
">",
"0",
"str_associations",
"+=",
"source",
"[",
"'name'",
"]",
"+",
"','",
"+",
"attrib",
"associationsSrc",
"[",
"'str_associations'",
"]",
"=",
"str_associations",
"end",
"end",
"end",
"#user partition should alwayse exist",
"@db_partitions",
"[",
"'user'",
"]",
"=",
"nil",
"unless",
"@db_partitions",
"[",
"'user'",
"]",
"hash_migrate",
"=",
"{",
"}",
"puts",
"\"@db_partitions : #{@db_partitions}\"",
"@db_partitions",
".",
"each",
"do",
"|",
"partition",
",",
"db",
"|",
"db",
"=",
"Rhom",
"::",
"RhomDbAdapter",
".",
"new",
"(",
"Rho",
"::",
"RhoFSConnector",
"::",
"get_db_fullpathname",
"(",
"partition",
")",
",",
"partition",
")",
"unless",
"db",
"db",
".",
"start_transaction",
"begin",
"init_db_sources",
"(",
"db",
",",
"uniq_sources",
",",
"partition",
",",
"hash_migrate",
")",
"#SyncEngine.update_blob_attribs(partition, -1 )",
"db",
".",
"commit",
"rescue",
"Exception",
"=>",
"e",
"trace_msg",
"=",
"e",
".",
"backtrace",
".",
"join",
"(",
"\"\\n\"",
")",
"puts",
"\"exception when init_db_sources: #{e}; Trace:\"",
"+",
"trace_msg",
"db",
".",
"rollback",
"end",
"@db_partitions",
"[",
"partition",
"]",
"=",
"db",
"end",
"puts",
"\"Migrate schema sources: #{hash_migrate}\"",
"::",
"Rho",
"::",
"RHO",
".",
"init_schema_sources",
"(",
"hash_migrate",
")",
"::",
"Rho",
"::",
"RHO",
".",
"check_sources_migration",
"(",
"uniq_sources",
")",
"#@db_partitions.each do |partition, db|",
"# SyncEngine.update_blob_attribs(partition, -1 )",
"#end",
"::",
"Rho",
"::",
"RHO",
".",
"init_sync_source_properties",
"(",
"uniq_sources",
")",
"end"
] |
setup the sources table and model attributes for all applications
|
[
"setup",
"the",
"sources",
"table",
"and",
"model",
"attributes",
"for",
"all",
"applications"
] |
3c5f87b1a44f0ba2865ca0e1dd780dd202f64872
|
https://github.com/rhomobile/rhodes/blob/3c5f87b1a44f0ba2865ca0e1dd780dd202f64872/lib/framework/rho/rho.rb#L456-L524
|
17,234
|
rhomobile/rhodes
|
lib/extensions/uri/uri/generic.rb
|
URI.Generic.replace!
|
def replace!(oth)
if self.class != oth.class
raise ArgumentError, "expected #{self.class} object"
end
component.each do |c|
self.__send__("#{c}=", oth.__send__(c))
end
end
|
ruby
|
def replace!(oth)
if self.class != oth.class
raise ArgumentError, "expected #{self.class} object"
end
component.each do |c|
self.__send__("#{c}=", oth.__send__(c))
end
end
|
[
"def",
"replace!",
"(",
"oth",
")",
"if",
"self",
".",
"class",
"!=",
"oth",
".",
"class",
"raise",
"ArgumentError",
",",
"\"expected #{self.class} object\"",
"end",
"component",
".",
"each",
"do",
"|",
"c",
"|",
"self",
".",
"__send__",
"(",
"\"#{c}=\"",
",",
"oth",
".",
"__send__",
"(",
"c",
")",
")",
"end",
"end"
] |
replace self by other URI object
|
[
"replace",
"self",
"by",
"other",
"URI",
"object"
] |
3c5f87b1a44f0ba2865ca0e1dd780dd202f64872
|
https://github.com/rhomobile/rhodes/blob/3c5f87b1a44f0ba2865ca0e1dd780dd202f64872/lib/extensions/uri/uri/generic.rb#L225-L233
|
17,235
|
rhomobile/rhodes
|
res/build-tools/ruby-standalone/212/usr/local/lib/ruby/2.1.0/open-uri.rb
|
OpenURI.Meta.charset
|
def charset
type, *parameters = content_type_parse
if pair = parameters.assoc('charset')
pair.last.downcase
elsif block_given?
yield
elsif type && %r{\Atext/} =~ type &&
@base_uri && /\Ahttp\z/i =~ @base_uri.scheme
"iso-8859-1" # RFC2616 3.7.1
else
nil
end
end
|
ruby
|
def charset
type, *parameters = content_type_parse
if pair = parameters.assoc('charset')
pair.last.downcase
elsif block_given?
yield
elsif type && %r{\Atext/} =~ type &&
@base_uri && /\Ahttp\z/i =~ @base_uri.scheme
"iso-8859-1" # RFC2616 3.7.1
else
nil
end
end
|
[
"def",
"charset",
"type",
",",
"*",
"parameters",
"=",
"content_type_parse",
"if",
"pair",
"=",
"parameters",
".",
"assoc",
"(",
"'charset'",
")",
"pair",
".",
"last",
".",
"downcase",
"elsif",
"block_given?",
"yield",
"elsif",
"type",
"&&",
"%r{",
"\\A",
"}",
"=~",
"type",
"&&",
"@base_uri",
"&&",
"/",
"\\A",
"\\z",
"/i",
"=~",
"@base_uri",
".",
"scheme",
"\"iso-8859-1\"",
"# RFC2616 3.7.1",
"else",
"nil",
"end",
"end"
] |
returns a charset parameter in Content-Type field.
It is downcased for canonicalization.
If charset parameter is not given but a block is given,
the block is called and its result is returned.
It can be used to guess charset.
If charset parameter and block is not given,
nil is returned except text type in HTTP.
In that case, "iso-8859-1" is returned as defined by RFC2616 3.7.1.
|
[
"returns",
"a",
"charset",
"parameter",
"in",
"Content",
"-",
"Type",
"field",
".",
"It",
"is",
"downcased",
"for",
"canonicalization",
"."
] |
3c5f87b1a44f0ba2865ca0e1dd780dd202f64872
|
https://github.com/rhomobile/rhodes/blob/3c5f87b1a44f0ba2865ca0e1dd780dd202f64872/res/build-tools/ruby-standalone/212/usr/local/lib/ruby/2.1.0/open-uri.rb#L523-L535
|
17,236
|
rhomobile/rhodes
|
res/build-tools/ruby-standalone/212/usr/local/lib/ruby/2.1.0/net/pop.rb
|
Net.POP3.delete_all
|
def delete_all # :yield: message
mails().each do |m|
yield m if block_given?
m.delete unless m.deleted?
end
end
|
ruby
|
def delete_all # :yield: message
mails().each do |m|
yield m if block_given?
m.delete unless m.deleted?
end
end
|
[
"def",
"delete_all",
"# :yield: message",
"mails",
"(",
")",
".",
"each",
"do",
"|",
"m",
"|",
"yield",
"m",
"if",
"block_given?",
"m",
".",
"delete",
"unless",
"m",
".",
"deleted?",
"end",
"end"
] |
Deletes all messages on the server.
If called with a block, yields each message in turn before deleting it.
=== Example
n = 1
pop.delete_all do |m|
File.open("inbox/#{n}") do |f|
f.write m.pop
end
n += 1
end
This method raises a POPError if an error occurs.
|
[
"Deletes",
"all",
"messages",
"on",
"the",
"server",
"."
] |
3c5f87b1a44f0ba2865ca0e1dd780dd202f64872
|
https://github.com/rhomobile/rhodes/blob/3c5f87b1a44f0ba2865ca0e1dd780dd202f64872/res/build-tools/ruby-standalone/212/usr/local/lib/ruby/2.1.0/net/pop.rb#L686-L691
|
17,237
|
rhomobile/rhodes
|
res/build-tools/ruby-standalone/212/usr/local/lib/ruby/2.1.0/net/pop.rb
|
Net.POPMail.pop
|
def pop( dest = '', &block ) # :yield: message_chunk
if block_given?
@command.retr(@number, &block)
nil
else
@command.retr(@number) do |chunk|
dest << chunk
end
dest
end
end
|
ruby
|
def pop( dest = '', &block ) # :yield: message_chunk
if block_given?
@command.retr(@number, &block)
nil
else
@command.retr(@number) do |chunk|
dest << chunk
end
dest
end
end
|
[
"def",
"pop",
"(",
"dest",
"=",
"''",
",",
"&",
"block",
")",
"# :yield: message_chunk",
"if",
"block_given?",
"@command",
".",
"retr",
"(",
"@number",
",",
"block",
")",
"nil",
"else",
"@command",
".",
"retr",
"(",
"@number",
")",
"do",
"|",
"chunk",
"|",
"dest",
"<<",
"chunk",
"end",
"dest",
"end",
"end"
] |
This method fetches the message. If called with a block, the
message is yielded to the block one chunk at a time. If called
without a block, the message is returned as a String. The optional
+dest+ argument will be prepended to the returned String; this
argument is essentially obsolete.
=== Example without block
POP3.start('pop.example.com', 110,
'YourAccount, 'YourPassword') do |pop|
n = 1
pop.mails.each do |popmail|
File.open("inbox/#{n}", 'w') do |f|
f.write popmail.pop
end
popmail.delete
n += 1
end
end
=== Example with block
POP3.start('pop.example.com', 110,
'YourAccount, 'YourPassword') do |pop|
n = 1
pop.mails.each do |popmail|
File.open("inbox/#{n}", 'w') do |f|
popmail.pop do |chunk|
f.write chunk
end
end
n += 1
end
end
This method raises a POPError if an error occurs.
|
[
"This",
"method",
"fetches",
"the",
"message",
".",
"If",
"called",
"with",
"a",
"block",
"the",
"message",
"is",
"yielded",
"to",
"the",
"block",
"one",
"chunk",
"at",
"a",
"time",
".",
"If",
"called",
"without",
"a",
"block",
"the",
"message",
"is",
"returned",
"as",
"a",
"String",
".",
"The",
"optional",
"+",
"dest",
"+",
"argument",
"will",
"be",
"prepended",
"to",
"the",
"returned",
"String",
";",
"this",
"argument",
"is",
"essentially",
"obsolete",
"."
] |
3c5f87b1a44f0ba2865ca0e1dd780dd202f64872
|
https://github.com/rhomobile/rhodes/blob/3c5f87b1a44f0ba2865ca0e1dd780dd202f64872/res/build-tools/ruby-standalone/212/usr/local/lib/ruby/2.1.0/net/pop.rb#L801-L811
|
17,238
|
rhomobile/rhodes
|
res/build-tools/ruby-standalone/212/usr/local/lib/ruby/2.1.0/rake/dsl_definition.rb
|
Rake.DSL.directory
|
def directory(*args, &block)
result = file_create(*args, &block)
dir, _ = *Rake.application.resolve_args(args)
Rake.each_dir_parent(dir) do |d|
file_create d do |t|
mkdir_p t.name unless File.exist?(t.name)
end
end
result
end
|
ruby
|
def directory(*args, &block)
result = file_create(*args, &block)
dir, _ = *Rake.application.resolve_args(args)
Rake.each_dir_parent(dir) do |d|
file_create d do |t|
mkdir_p t.name unless File.exist?(t.name)
end
end
result
end
|
[
"def",
"directory",
"(",
"*",
"args",
",",
"&",
"block",
")",
"result",
"=",
"file_create",
"(",
"args",
",",
"block",
")",
"dir",
",",
"_",
"=",
"Rake",
".",
"application",
".",
"resolve_args",
"(",
"args",
")",
"Rake",
".",
"each_dir_parent",
"(",
"dir",
")",
"do",
"|",
"d",
"|",
"file_create",
"d",
"do",
"|",
"t",
"|",
"mkdir_p",
"t",
".",
"name",
"unless",
"File",
".",
"exist?",
"(",
"t",
".",
"name",
")",
"end",
"end",
"result",
"end"
] |
Declare a set of files tasks to create the given directories on
demand.
Example:
directory "testdata/doc"
|
[
"Declare",
"a",
"set",
"of",
"files",
"tasks",
"to",
"create",
"the",
"given",
"directories",
"on",
"demand",
"."
] |
3c5f87b1a44f0ba2865ca0e1dd780dd202f64872
|
https://github.com/rhomobile/rhodes/blob/3c5f87b1a44f0ba2865ca0e1dd780dd202f64872/res/build-tools/ruby-standalone/212/usr/local/lib/ruby/2.1.0/rake/dsl_definition.rb#L64-L73
|
17,239
|
rhomobile/rhodes
|
res/build-tools/ruby-standalone/212/usr/local/lib/ruby/2.1.0/rake/dsl_definition.rb
|
Rake.DSL.namespace
|
def namespace(name=nil, &block)
name = name.to_s if name.kind_of?(Symbol)
name = name.to_str if name.respond_to?(:to_str)
unless name.kind_of?(String) || name.nil?
raise ArgumentError, "Expected a String or Symbol for a namespace name"
end
Rake.application.in_namespace(name, &block)
end
|
ruby
|
def namespace(name=nil, &block)
name = name.to_s if name.kind_of?(Symbol)
name = name.to_str if name.respond_to?(:to_str)
unless name.kind_of?(String) || name.nil?
raise ArgumentError, "Expected a String or Symbol for a namespace name"
end
Rake.application.in_namespace(name, &block)
end
|
[
"def",
"namespace",
"(",
"name",
"=",
"nil",
",",
"&",
"block",
")",
"name",
"=",
"name",
".",
"to_s",
"if",
"name",
".",
"kind_of?",
"(",
"Symbol",
")",
"name",
"=",
"name",
".",
"to_str",
"if",
"name",
".",
"respond_to?",
"(",
":to_str",
")",
"unless",
"name",
".",
"kind_of?",
"(",
"String",
")",
"||",
"name",
".",
"nil?",
"raise",
"ArgumentError",
",",
"\"Expected a String or Symbol for a namespace name\"",
"end",
"Rake",
".",
"application",
".",
"in_namespace",
"(",
"name",
",",
"block",
")",
"end"
] |
Create a new rake namespace and use it for evaluating the given
block. Returns a NameSpace object that can be used to lookup
tasks defined in the namespace.
E.g.
ns = namespace "nested" do
task :run
end
task_run = ns[:run] # find :run in the given namespace.
|
[
"Create",
"a",
"new",
"rake",
"namespace",
"and",
"use",
"it",
"for",
"evaluating",
"the",
"given",
"block",
".",
"Returns",
"a",
"NameSpace",
"object",
"that",
"can",
"be",
"used",
"to",
"lookup",
"tasks",
"defined",
"in",
"the",
"namespace",
"."
] |
3c5f87b1a44f0ba2865ca0e1dd780dd202f64872
|
https://github.com/rhomobile/rhodes/blob/3c5f87b1a44f0ba2865ca0e1dd780dd202f64872/res/build-tools/ruby-standalone/212/usr/local/lib/ruby/2.1.0/rake/dsl_definition.rb#L98-L105
|
17,240
|
rhomobile/rhodes
|
lib/extensions/rexml/rexml/element.rb
|
REXML.Element.delete_namespace
|
def delete_namespace namespace="xmlns"
namespace = "xmlns:#{namespace}" unless namespace == 'xmlns'
attribute = attributes.get_attribute(namespace)
attribute.remove unless attribute.nil?
self
end
|
ruby
|
def delete_namespace namespace="xmlns"
namespace = "xmlns:#{namespace}" unless namespace == 'xmlns'
attribute = attributes.get_attribute(namespace)
attribute.remove unless attribute.nil?
self
end
|
[
"def",
"delete_namespace",
"namespace",
"=",
"\"xmlns\"",
"namespace",
"=",
"\"xmlns:#{namespace}\"",
"unless",
"namespace",
"==",
"'xmlns'",
"attribute",
"=",
"attributes",
".",
"get_attribute",
"(",
"namespace",
")",
"attribute",
".",
"remove",
"unless",
"attribute",
".",
"nil?",
"self",
"end"
] |
Removes a namespace from this node. This only works if the namespace is
actually declared in this node. If no argument is passed, deletes the
default namespace.
Evaluates to: this element
doc = Document.new "<a xmlns:foo='bar' xmlns='twiddle'/>"
doc.root.delete_namespace
puts doc # -> <a xmlns:foo='bar'/>
doc.root.delete_namespace 'foo'
puts doc # -> <a/>
|
[
"Removes",
"a",
"namespace",
"from",
"this",
"node",
".",
"This",
"only",
"works",
"if",
"the",
"namespace",
"is",
"actually",
"declared",
"in",
"this",
"node",
".",
"If",
"no",
"argument",
"is",
"passed",
"deletes",
"the",
"default",
"namespace",
"."
] |
3c5f87b1a44f0ba2865ca0e1dd780dd202f64872
|
https://github.com/rhomobile/rhodes/blob/3c5f87b1a44f0ba2865ca0e1dd780dd202f64872/lib/extensions/rexml/rexml/element.rb#L270-L275
|
17,241
|
rhomobile/rhodes
|
lib/extensions/rexml/rexml/element.rb
|
REXML.Attributes.each_attribute
|
def each_attribute # :yields: attribute
each_value do |val|
if val.kind_of? Attribute
yield val
else
val.each_value { |atr| yield atr }
end
end
end
|
ruby
|
def each_attribute # :yields: attribute
each_value do |val|
if val.kind_of? Attribute
yield val
else
val.each_value { |atr| yield atr }
end
end
end
|
[
"def",
"each_attribute",
"# :yields: attribute",
"each_value",
"do",
"|",
"val",
"|",
"if",
"val",
".",
"kind_of?",
"Attribute",
"yield",
"val",
"else",
"val",
".",
"each_value",
"{",
"|",
"atr",
"|",
"yield",
"atr",
"}",
"end",
"end",
"end"
] |
Iterates over the attributes of an Element. Yields actual Attribute
nodes, not String values.
doc = Document.new '<a x="1" y="2"/>'
doc.root.attributes.each_attribute {|attr|
p attr.expanded_name+" => "+attr.value
}
|
[
"Iterates",
"over",
"the",
"attributes",
"of",
"an",
"Element",
".",
"Yields",
"actual",
"Attribute",
"nodes",
"not",
"String",
"values",
"."
] |
3c5f87b1a44f0ba2865ca0e1dd780dd202f64872
|
https://github.com/rhomobile/rhodes/blob/3c5f87b1a44f0ba2865ca0e1dd780dd202f64872/lib/extensions/rexml/rexml/element.rb#L1014-L1022
|
17,242
|
rhomobile/rhodes
|
res/build-tools/ruby-standalone/212/usr/local/lib/ruby/gems/2.1.0/gems/extlib-0.9.16/lib/extlib/rubygems.rb
|
Gem.Specification.sort_obj
|
def sort_obj
[@name, installation_path == File.join(defined?(Merb) && Merb.respond_to?(:root) ? Merb.root : Dir.pwd,"gems") ? 1 : -1, @version.to_ints, @new_platform == Gem::Platform::RUBY ? -1 : 1]
end
|
ruby
|
def sort_obj
[@name, installation_path == File.join(defined?(Merb) && Merb.respond_to?(:root) ? Merb.root : Dir.pwd,"gems") ? 1 : -1, @version.to_ints, @new_platform == Gem::Platform::RUBY ? -1 : 1]
end
|
[
"def",
"sort_obj",
"[",
"@name",
",",
"installation_path",
"==",
"File",
".",
"join",
"(",
"defined?",
"(",
"Merb",
")",
"&&",
"Merb",
".",
"respond_to?",
"(",
":root",
")",
"?",
"Merb",
".",
"root",
":",
"Dir",
".",
"pwd",
",",
"\"gems\"",
")",
"?",
"1",
":",
"-",
"1",
",",
"@version",
".",
"to_ints",
",",
"@new_platform",
"==",
"Gem",
"::",
"Platform",
"::",
"RUBY",
"?",
"-",
"1",
":",
"1",
"]",
"end"
] |
Overwrite this so that gems in the gems directory get preferred over gems
from any other location. If there are two gems of different versions in
the gems directory, the later one will load as usual.
@return [Array<Array>] The object used for sorting gem specs.
|
[
"Overwrite",
"this",
"so",
"that",
"gems",
"in",
"the",
"gems",
"directory",
"get",
"preferred",
"over",
"gems",
"from",
"any",
"other",
"location",
".",
"If",
"there",
"are",
"two",
"gems",
"of",
"different",
"versions",
"in",
"the",
"gems",
"directory",
"the",
"later",
"one",
"will",
"load",
"as",
"usual",
"."
] |
3c5f87b1a44f0ba2865ca0e1dd780dd202f64872
|
https://github.com/rhomobile/rhodes/blob/3c5f87b1a44f0ba2865ca0e1dd780dd202f64872/res/build-tools/ruby-standalone/212/usr/local/lib/ruby/gems/2.1.0/gems/extlib-0.9.16/lib/extlib/rubygems.rb#L34-L36
|
17,243
|
rhomobile/rhodes
|
res/build-tools/ruby-standalone/212/usr/local/lib/ruby/2.1.0/webrick/server.rb
|
WEBrick.GenericServer.shutdown
|
def shutdown
stop
@listeners.each{|s|
if @logger.debug?
addr = s.addr
@logger.debug("close TCPSocket(#{addr[2]}, #{addr[1]})")
end
begin
s.shutdown
rescue Errno::ENOTCONN
# when `Errno::ENOTCONN: Socket is not connected' on some platforms,
# call #close instead of #shutdown.
# (ignore @config[:ShutdownSocketWithoutClose])
s.close
else
unless @config[:ShutdownSocketWithoutClose]
s.close
end
end
}
@listeners.clear
end
|
ruby
|
def shutdown
stop
@listeners.each{|s|
if @logger.debug?
addr = s.addr
@logger.debug("close TCPSocket(#{addr[2]}, #{addr[1]})")
end
begin
s.shutdown
rescue Errno::ENOTCONN
# when `Errno::ENOTCONN: Socket is not connected' on some platforms,
# call #close instead of #shutdown.
# (ignore @config[:ShutdownSocketWithoutClose])
s.close
else
unless @config[:ShutdownSocketWithoutClose]
s.close
end
end
}
@listeners.clear
end
|
[
"def",
"shutdown",
"stop",
"@listeners",
".",
"each",
"{",
"|",
"s",
"|",
"if",
"@logger",
".",
"debug?",
"addr",
"=",
"s",
".",
"addr",
"@logger",
".",
"debug",
"(",
"\"close TCPSocket(#{addr[2]}, #{addr[1]})\"",
")",
"end",
"begin",
"s",
".",
"shutdown",
"rescue",
"Errno",
"::",
"ENOTCONN",
"# when `Errno::ENOTCONN: Socket is not connected' on some platforms,",
"# call #close instead of #shutdown.",
"# (ignore @config[:ShutdownSocketWithoutClose])",
"s",
".",
"close",
"else",
"unless",
"@config",
"[",
":ShutdownSocketWithoutClose",
"]",
"s",
".",
"close",
"end",
"end",
"}",
"@listeners",
".",
"clear",
"end"
] |
Shuts down the server and all listening sockets. New listeners must be
provided to restart the server.
|
[
"Shuts",
"down",
"the",
"server",
"and",
"all",
"listening",
"sockets",
".",
"New",
"listeners",
"must",
"be",
"provided",
"to",
"restart",
"the",
"server",
"."
] |
3c5f87b1a44f0ba2865ca0e1dd780dd202f64872
|
https://github.com/rhomobile/rhodes/blob/3c5f87b1a44f0ba2865ca0e1dd780dd202f64872/res/build-tools/ruby-standalone/212/usr/local/lib/ruby/2.1.0/webrick/server.rb#L219-L240
|
17,244
|
rhomobile/rhodes
|
res/build-tools/ruby-standalone/212/usr/local/lib/ruby/2.1.0/webrick/log.rb
|
WEBrick.BasicLog.format
|
def format(arg)
if arg.is_a?(Exception)
"#{arg.class}: #{arg.message}\n\t" <<
arg.backtrace.join("\n\t") << "\n"
elsif arg.respond_to?(:to_str)
arg.to_str
else
arg.inspect
end
end
|
ruby
|
def format(arg)
if arg.is_a?(Exception)
"#{arg.class}: #{arg.message}\n\t" <<
arg.backtrace.join("\n\t") << "\n"
elsif arg.respond_to?(:to_str)
arg.to_str
else
arg.inspect
end
end
|
[
"def",
"format",
"(",
"arg",
")",
"if",
"arg",
".",
"is_a?",
"(",
"Exception",
")",
"\"#{arg.class}: #{arg.message}\\n\\t\"",
"<<",
"arg",
".",
"backtrace",
".",
"join",
"(",
"\"\\n\\t\"",
")",
"<<",
"\"\\n\"",
"elsif",
"arg",
".",
"respond_to?",
"(",
":to_str",
")",
"arg",
".",
"to_str",
"else",
"arg",
".",
"inspect",
"end",
"end"
] |
Formats +arg+ for the logger
* If +arg+ is an Exception, it will format the error message and
the back trace.
* If +arg+ responds to #to_str, it will return it.
* Otherwise it will return +arg+.inspect.
|
[
"Formats",
"+",
"arg",
"+",
"for",
"the",
"logger"
] |
3c5f87b1a44f0ba2865ca0e1dd780dd202f64872
|
https://github.com/rhomobile/rhodes/blob/3c5f87b1a44f0ba2865ca0e1dd780dd202f64872/res/build-tools/ruby-standalone/212/usr/local/lib/ruby/2.1.0/webrick/log.rb#L118-L127
|
17,245
|
rhomobile/rhodes
|
res/build-tools/ruby-standalone/212/usr/local/lib/ruby/gems/2.1.0/gems/rest-client-1.7.2/lib/restclient/request.rb
|
RestClient.Request.process_url_params
|
def process_url_params url, headers
url_params = {}
headers.delete_if do |key, value|
if 'params' == key.to_s.downcase && value.is_a?(Hash)
url_params.merge! value
true
else
false
end
end
unless url_params.empty?
query_string = url_params.collect { |k, v| "#{k.to_s}=#{CGI::escape(v.to_s)}" }.join('&')
url + "?#{query_string}"
else
url
end
end
|
ruby
|
def process_url_params url, headers
url_params = {}
headers.delete_if do |key, value|
if 'params' == key.to_s.downcase && value.is_a?(Hash)
url_params.merge! value
true
else
false
end
end
unless url_params.empty?
query_string = url_params.collect { |k, v| "#{k.to_s}=#{CGI::escape(v.to_s)}" }.join('&')
url + "?#{query_string}"
else
url
end
end
|
[
"def",
"process_url_params",
"url",
",",
"headers",
"url_params",
"=",
"{",
"}",
"headers",
".",
"delete_if",
"do",
"|",
"key",
",",
"value",
"|",
"if",
"'params'",
"==",
"key",
".",
"to_s",
".",
"downcase",
"&&",
"value",
".",
"is_a?",
"(",
"Hash",
")",
"url_params",
".",
"merge!",
"value",
"true",
"else",
"false",
"end",
"end",
"unless",
"url_params",
".",
"empty?",
"query_string",
"=",
"url_params",
".",
"collect",
"{",
"|",
"k",
",",
"v",
"|",
"\"#{k.to_s}=#{CGI::escape(v.to_s)}\"",
"}",
".",
"join",
"(",
"'&'",
")",
"url",
"+",
"\"?#{query_string}\"",
"else",
"url",
"end",
"end"
] |
Extract the query parameters and append them to the url
|
[
"Extract",
"the",
"query",
"parameters",
"and",
"append",
"them",
"to",
"the",
"url"
] |
3c5f87b1a44f0ba2865ca0e1dd780dd202f64872
|
https://github.com/rhomobile/rhodes/blob/3c5f87b1a44f0ba2865ca0e1dd780dd202f64872/res/build-tools/ruby-standalone/212/usr/local/lib/ruby/gems/2.1.0/gems/rest-client-1.7.2/lib/restclient/request.rb#L192-L208
|
17,246
|
rhomobile/rhodes
|
res/build-tools/ruby-standalone/212/usr/local/lib/ruby/gems/2.1.0/gems/rest-client-1.7.2/lib/restclient/request.rb
|
RestClient.Request.stringify_headers
|
def stringify_headers headers
headers.inject({}) do |result, (key, value)|
if key.is_a? Symbol
key = key.to_s.split(/_/).map { |w| w.capitalize }.join('-')
end
if 'CONTENT-TYPE' == key.upcase
target_value = value.to_s
result[key] = MIME::Types.type_for_extension target_value
elsif 'ACCEPT' == key.upcase
# Accept can be composed of several comma-separated values
if value.is_a? Array
target_values = value
else
target_values = value.to_s.split ','
end
result[key] = target_values.map { |ext| MIME::Types.type_for_extension(ext.to_s.strip) }.join(', ')
else
result[key] = value.to_s
end
result
end
end
|
ruby
|
def stringify_headers headers
headers.inject({}) do |result, (key, value)|
if key.is_a? Symbol
key = key.to_s.split(/_/).map { |w| w.capitalize }.join('-')
end
if 'CONTENT-TYPE' == key.upcase
target_value = value.to_s
result[key] = MIME::Types.type_for_extension target_value
elsif 'ACCEPT' == key.upcase
# Accept can be composed of several comma-separated values
if value.is_a? Array
target_values = value
else
target_values = value.to_s.split ','
end
result[key] = target_values.map { |ext| MIME::Types.type_for_extension(ext.to_s.strip) }.join(', ')
else
result[key] = value.to_s
end
result
end
end
|
[
"def",
"stringify_headers",
"headers",
"headers",
".",
"inject",
"(",
"{",
"}",
")",
"do",
"|",
"result",
",",
"(",
"key",
",",
"value",
")",
"|",
"if",
"key",
".",
"is_a?",
"Symbol",
"key",
"=",
"key",
".",
"to_s",
".",
"split",
"(",
"/",
"/",
")",
".",
"map",
"{",
"|",
"w",
"|",
"w",
".",
"capitalize",
"}",
".",
"join",
"(",
"'-'",
")",
"end",
"if",
"'CONTENT-TYPE'",
"==",
"key",
".",
"upcase",
"target_value",
"=",
"value",
".",
"to_s",
"result",
"[",
"key",
"]",
"=",
"MIME",
"::",
"Types",
".",
"type_for_extension",
"target_value",
"elsif",
"'ACCEPT'",
"==",
"key",
".",
"upcase",
"# Accept can be composed of several comma-separated values",
"if",
"value",
".",
"is_a?",
"Array",
"target_values",
"=",
"value",
"else",
"target_values",
"=",
"value",
".",
"to_s",
".",
"split",
"','",
"end",
"result",
"[",
"key",
"]",
"=",
"target_values",
".",
"map",
"{",
"|",
"ext",
"|",
"MIME",
"::",
"Types",
".",
"type_for_extension",
"(",
"ext",
".",
"to_s",
".",
"strip",
")",
"}",
".",
"join",
"(",
"', '",
")",
"else",
"result",
"[",
"key",
"]",
"=",
"value",
".",
"to_s",
"end",
"result",
"end",
"end"
] |
Return a hash of headers whose keys are capitalized strings
|
[
"Return",
"a",
"hash",
"of",
"headers",
"whose",
"keys",
"are",
"capitalized",
"strings"
] |
3c5f87b1a44f0ba2865ca0e1dd780dd202f64872
|
https://github.com/rhomobile/rhodes/blob/3c5f87b1a44f0ba2865ca0e1dd780dd202f64872/res/build-tools/ruby-standalone/212/usr/local/lib/ruby/gems/2.1.0/gems/rest-client-1.7.2/lib/restclient/request.rb#L541-L562
|
17,247
|
rhomobile/rhodes
|
res/build-tools/ruby-standalone/212/usr/local/lib/ruby/gems/2.1.0/gems/extlib-0.9.16/lib/extlib/simple_set.rb
|
Extlib.SimpleSet.merge
|
def merge(arr)
super(arr.inject({}) {|s,x| s[x] = true; s })
end
|
ruby
|
def merge(arr)
super(arr.inject({}) {|s,x| s[x] = true; s })
end
|
[
"def",
"merge",
"(",
"arr",
")",
"super",
"(",
"arr",
".",
"inject",
"(",
"{",
"}",
")",
"{",
"|",
"s",
",",
"x",
"|",
"s",
"[",
"x",
"]",
"=",
"true",
";",
"s",
"}",
")",
"end"
] |
Merge _arr_ with receiver, producing the union of receiver & _arr_
s = Extlib::SimpleSet.new([:a, :b, :c])
s.merge([:c, :d, :e, f]) #=> #<SimpleSet: {:e, :c, :f, :a, :d, :b}>
@param [Array] arr Values to merge with set.
@return [SimpleSet] The set after the Array was merged in.
@api public
|
[
"Merge",
"_arr_",
"with",
"receiver",
"producing",
"the",
"union",
"of",
"receiver",
"&",
"_arr_"
] |
3c5f87b1a44f0ba2865ca0e1dd780dd202f64872
|
https://github.com/rhomobile/rhodes/blob/3c5f87b1a44f0ba2865ca0e1dd780dd202f64872/res/build-tools/ruby-standalone/212/usr/local/lib/ruby/gems/2.1.0/gems/extlib-0.9.16/lib/extlib/simple_set.rb#L45-L47
|
17,248
|
rhomobile/rhodes
|
lib/build/development/live_update_task.rb
|
RhoDevelopment.LiveUpdateTask.execute
|
def execute
puts "Executing #{self.class.taskName} at #{Time::now}".primary
begin
self.action
rescue => e
puts "Executing #{self.class.taskName} failed".warning
puts e.inspect.to_s.info
puts e.backtrace.to_s.info
end
end
|
ruby
|
def execute
puts "Executing #{self.class.taskName} at #{Time::now}".primary
begin
self.action
rescue => e
puts "Executing #{self.class.taskName} failed".warning
puts e.inspect.to_s.info
puts e.backtrace.to_s.info
end
end
|
[
"def",
"execute",
"puts",
"\"Executing #{self.class.taskName} at #{Time::now}\"",
".",
"primary",
"begin",
"self",
".",
"action",
"rescue",
"=>",
"e",
"puts",
"\"Executing #{self.class.taskName} failed\"",
".",
"warning",
"puts",
"e",
".",
"inspect",
".",
"to_s",
".",
"info",
"puts",
"e",
".",
"backtrace",
".",
"to_s",
".",
"info",
"end",
"end"
] |
Execute specific task action
|
[
"Execute",
"specific",
"task",
"action"
] |
3c5f87b1a44f0ba2865ca0e1dd780dd202f64872
|
https://github.com/rhomobile/rhodes/blob/3c5f87b1a44f0ba2865ca0e1dd780dd202f64872/lib/build/development/live_update_task.rb#L26-L35
|
17,249
|
rhomobile/rhodes
|
lib/build/development/live_update_task.rb
|
RhoDevelopment.PlatformPartialUpdateBuildingTask.dispatchToUrl
|
def dispatchToUrl(anUri)
uri = URI.join(anUri, 'tasks/new')
Net::HTTP.post_form(uri, {'taskName' => self.class.taskName, 'platform' => @platform, 'filename' => @filename})
end
|
ruby
|
def dispatchToUrl(anUri)
uri = URI.join(anUri, 'tasks/new')
Net::HTTP.post_form(uri, {'taskName' => self.class.taskName, 'platform' => @platform, 'filename' => @filename})
end
|
[
"def",
"dispatchToUrl",
"(",
"anUri",
")",
"uri",
"=",
"URI",
".",
"join",
"(",
"anUri",
",",
"'tasks/new'",
")",
"Net",
"::",
"HTTP",
".",
"post_form",
"(",
"uri",
",",
"{",
"'taskName'",
"=>",
"self",
".",
"class",
".",
"taskName",
",",
"'platform'",
"=>",
"@platform",
",",
"'filename'",
"=>",
"@filename",
"}",
")",
"end"
] |
Method serializes itself to a hash and sends post request with the hash to specified URI
@param anUri [URI] URI for post request
|
[
"Method",
"serializes",
"itself",
"to",
"a",
"hash",
"and",
"sends",
"post",
"request",
"with",
"the",
"hash",
"to",
"specified",
"URI"
] |
3c5f87b1a44f0ba2865ca0e1dd780dd202f64872
|
https://github.com/rhomobile/rhodes/blob/3c5f87b1a44f0ba2865ca0e1dd780dd202f64872/lib/build/development/live_update_task.rb#L167-L170
|
17,250
|
rhomobile/rhodes
|
lib/build/development/live_update_task.rb
|
RhoDevelopment.PartialUpdateTask.action
|
def action
updated_list_filename = File.join(Configuration::application_root, 'upgrade_package_add_files.txt')
removed_list_filename = File.join(Configuration::application_root, 'upgrade_package_remove_files.txt')
mkdir_p Configuration::development_directory
Configuration::enabled_subscriber_platforms.each { |each|
RhoDevelopment.setup(Configuration::development_directory, each)
puts "Check changes for #{each}".warning
changed = RhoDevelopment.check_changes_from_last_build(updated_list_filename, removed_list_filename)
if changed
puts "Source code for platform #{each} was changed".primary
WebServer.dispatch_task(PlatformPartialUpdateBuildingTask.new(each, @filename));
Configuration::enabled_subscribers_by_platform(each).each { |subscriber|
WebServer.dispatch_task(SubscriberPartialUpdateNotifyingTask.new(subscriber, @filename));
}
else
puts "Source code for platform #{each} wasn't changed".primary
end
}
end
|
ruby
|
def action
updated_list_filename = File.join(Configuration::application_root, 'upgrade_package_add_files.txt')
removed_list_filename = File.join(Configuration::application_root, 'upgrade_package_remove_files.txt')
mkdir_p Configuration::development_directory
Configuration::enabled_subscriber_platforms.each { |each|
RhoDevelopment.setup(Configuration::development_directory, each)
puts "Check changes for #{each}".warning
changed = RhoDevelopment.check_changes_from_last_build(updated_list_filename, removed_list_filename)
if changed
puts "Source code for platform #{each} was changed".primary
WebServer.dispatch_task(PlatformPartialUpdateBuildingTask.new(each, @filename));
Configuration::enabled_subscribers_by_platform(each).each { |subscriber|
WebServer.dispatch_task(SubscriberPartialUpdateNotifyingTask.new(subscriber, @filename));
}
else
puts "Source code for platform #{each} wasn't changed".primary
end
}
end
|
[
"def",
"action",
"updated_list_filename",
"=",
"File",
".",
"join",
"(",
"Configuration",
"::",
"application_root",
",",
"'upgrade_package_add_files.txt'",
")",
"removed_list_filename",
"=",
"File",
".",
"join",
"(",
"Configuration",
"::",
"application_root",
",",
"'upgrade_package_remove_files.txt'",
")",
"mkdir_p",
"Configuration",
"::",
"development_directory",
"Configuration",
"::",
"enabled_subscriber_platforms",
".",
"each",
"{",
"|",
"each",
"|",
"RhoDevelopment",
".",
"setup",
"(",
"Configuration",
"::",
"development_directory",
",",
"each",
")",
"puts",
"\"Check changes for #{each}\"",
".",
"warning",
"changed",
"=",
"RhoDevelopment",
".",
"check_changes_from_last_build",
"(",
"updated_list_filename",
",",
"removed_list_filename",
")",
"if",
"changed",
"puts",
"\"Source code for platform #{each} was changed\"",
".",
"primary",
"WebServer",
".",
"dispatch_task",
"(",
"PlatformPartialUpdateBuildingTask",
".",
"new",
"(",
"each",
",",
"@filename",
")",
")",
";",
"Configuration",
"::",
"enabled_subscribers_by_platform",
"(",
"each",
")",
".",
"each",
"{",
"|",
"subscriber",
"|",
"WebServer",
".",
"dispatch_task",
"(",
"SubscriberPartialUpdateNotifyingTask",
".",
"new",
"(",
"subscriber",
",",
"@filename",
")",
")",
";",
"}",
"else",
"puts",
"\"Source code for platform #{each} wasn't changed\"",
".",
"primary",
"end",
"}",
"end"
] |
Checks has source code changes for each platform
|
[
"Checks",
"has",
"source",
"code",
"changes",
"for",
"each",
"platform"
] |
3c5f87b1a44f0ba2865ca0e1dd780dd202f64872
|
https://github.com/rhomobile/rhodes/blob/3c5f87b1a44f0ba2865ca0e1dd780dd202f64872/lib/build/development/live_update_task.rb#L328-L346
|
17,251
|
rhomobile/rhodes
|
lib/extensions/rhoxml/rexml/xpath_parser.rb
|
REXML.XPathParser.descendant_or_self
|
def descendant_or_self( path_stack, nodeset )
rs = []
#puts "#"*80
#puts "PATH_STACK = #{path_stack.inspect}"
#puts "NODESET = #{nodeset.collect{|n|n.inspect}.inspect}"
d_o_s( path_stack, nodeset, rs )
#puts "RS = #{rs.collect{|n|n.inspect}.inspect}"
document_order(rs.flatten.compact)
#rs.flatten.compact
end
|
ruby
|
def descendant_or_self( path_stack, nodeset )
rs = []
#puts "#"*80
#puts "PATH_STACK = #{path_stack.inspect}"
#puts "NODESET = #{nodeset.collect{|n|n.inspect}.inspect}"
d_o_s( path_stack, nodeset, rs )
#puts "RS = #{rs.collect{|n|n.inspect}.inspect}"
document_order(rs.flatten.compact)
#rs.flatten.compact
end
|
[
"def",
"descendant_or_self",
"(",
"path_stack",
",",
"nodeset",
")",
"rs",
"=",
"[",
"]",
"#puts \"#\"*80",
"#puts \"PATH_STACK = #{path_stack.inspect}\"",
"#puts \"NODESET = #{nodeset.collect{|n|n.inspect}.inspect}\"",
"d_o_s",
"(",
"path_stack",
",",
"nodeset",
",",
"rs",
")",
"#puts \"RS = #{rs.collect{|n|n.inspect}.inspect}\"",
"document_order",
"(",
"rs",
".",
"flatten",
".",
"compact",
")",
"#rs.flatten.compact",
"end"
] |
FIXME
The next two methods are BAD MOJO!
This is my achilles heel. If anybody thinks of a better
way of doing this, be my guest. This really sucks, but
it is a wonder it works at all.
|
[
"FIXME",
"The",
"next",
"two",
"methods",
"are",
"BAD",
"MOJO!",
"This",
"is",
"my",
"achilles",
"heel",
".",
"If",
"anybody",
"thinks",
"of",
"a",
"better",
"way",
"of",
"doing",
"this",
"be",
"my",
"guest",
".",
"This",
"really",
"sucks",
"but",
"it",
"is",
"a",
"wonder",
"it",
"works",
"at",
"all",
"."
] |
3c5f87b1a44f0ba2865ca0e1dd780dd202f64872
|
https://github.com/rhomobile/rhodes/blob/3c5f87b1a44f0ba2865ca0e1dd780dd202f64872/lib/extensions/rhoxml/rexml/xpath_parser.rb#L540-L549
|
17,252
|
rhomobile/rhodes
|
lib/extensions/rhoxml/rexml/xpath_parser.rb
|
REXML.XPathParser.document_order
|
def document_order( array_of_nodes )
new_arry = []
array_of_nodes.each { |node|
node_idx = []
np = node.node_type == :attribute ? node.element : node
while np.parent and np.parent.node_type == :element
node_idx << np.parent.index( np )
np = np.parent
end
new_arry << [ node_idx.reverse, node ]
}
#puts "new_arry = #{new_arry.inspect}"
new_arry.sort{ |s1, s2| s1[0] <=> s2[0] }.collect{ |s| s[1] }
end
|
ruby
|
def document_order( array_of_nodes )
new_arry = []
array_of_nodes.each { |node|
node_idx = []
np = node.node_type == :attribute ? node.element : node
while np.parent and np.parent.node_type == :element
node_idx << np.parent.index( np )
np = np.parent
end
new_arry << [ node_idx.reverse, node ]
}
#puts "new_arry = #{new_arry.inspect}"
new_arry.sort{ |s1, s2| s1[0] <=> s2[0] }.collect{ |s| s[1] }
end
|
[
"def",
"document_order",
"(",
"array_of_nodes",
")",
"new_arry",
"=",
"[",
"]",
"array_of_nodes",
".",
"each",
"{",
"|",
"node",
"|",
"node_idx",
"=",
"[",
"]",
"np",
"=",
"node",
".",
"node_type",
"==",
":attribute",
"?",
"node",
".",
"element",
":",
"node",
"while",
"np",
".",
"parent",
"and",
"np",
".",
"parent",
".",
"node_type",
"==",
":element",
"node_idx",
"<<",
"np",
".",
"parent",
".",
"index",
"(",
"np",
")",
"np",
"=",
"np",
".",
"parent",
"end",
"new_arry",
"<<",
"[",
"node_idx",
".",
"reverse",
",",
"node",
"]",
"}",
"#puts \"new_arry = #{new_arry.inspect}\"",
"new_arry",
".",
"sort",
"{",
"|",
"s1",
",",
"s2",
"|",
"s1",
"[",
"0",
"]",
"<=>",
"s2",
"[",
"0",
"]",
"}",
".",
"collect",
"{",
"|",
"s",
"|",
"s",
"[",
"1",
"]",
"}",
"end"
] |
Reorders an array of nodes so that they are in document order
It tries to do this efficiently.
FIXME: I need to get rid of this, but the issue is that most of the XPath
interpreter functions as a filter, which means that we lose context going
in and out of function calls. If I knew what the index of the nodes was,
I wouldn't have to do this. Maybe add a document IDX for each node?
Problems with mutable documents. Or, rewrite everything.
|
[
"Reorders",
"an",
"array",
"of",
"nodes",
"so",
"that",
"they",
"are",
"in",
"document",
"order",
"It",
"tries",
"to",
"do",
"this",
"efficiently",
"."
] |
3c5f87b1a44f0ba2865ca0e1dd780dd202f64872
|
https://github.com/rhomobile/rhodes/blob/3c5f87b1a44f0ba2865ca0e1dd780dd202f64872/lib/extensions/rhoxml/rexml/xpath_parser.rb#L573-L586
|
17,253
|
rhomobile/rhodes
|
spec/framework_spec/app/spec/language/fixtures/break.rb
|
BreakSpecs.Lambda.break_in_defining_scope
|
def break_in_defining_scope(value=true)
note :a
note lambda {
note :b
if value
break :break
else
break
end
note :c
}.call
note :d
end
|
ruby
|
def break_in_defining_scope(value=true)
note :a
note lambda {
note :b
if value
break :break
else
break
end
note :c
}.call
note :d
end
|
[
"def",
"break_in_defining_scope",
"(",
"value",
"=",
"true",
")",
"note",
":a",
"note",
"lambda",
"{",
"note",
":b",
"if",
"value",
"break",
":break",
"else",
"break",
"end",
"note",
":c",
"}",
".",
"call",
"note",
":d",
"end"
] |
Cases for the invocation of the scope defining the lambda still active
on the call stack when the lambda is invoked.
|
[
"Cases",
"for",
"the",
"invocation",
"of",
"the",
"scope",
"defining",
"the",
"lambda",
"still",
"active",
"on",
"the",
"call",
"stack",
"when",
"the",
"lambda",
"is",
"invoked",
"."
] |
3c5f87b1a44f0ba2865ca0e1dd780dd202f64872
|
https://github.com/rhomobile/rhodes/blob/3c5f87b1a44f0ba2865ca0e1dd780dd202f64872/spec/framework_spec/app/spec/language/fixtures/break.rb#L113-L125
|
17,254
|
rhomobile/rhodes
|
res/build-tools/ruby-standalone/212/usr/local/lib/ruby/2.1.0/net/smtp.rb
|
Net.SMTP.start
|
def start(helo = 'localhost',
user = nil, secret = nil, authtype = nil) # :yield: smtp
if block_given?
begin
do_start helo, user, secret, authtype
return yield(self)
ensure
do_finish
end
else
do_start helo, user, secret, authtype
return self
end
end
|
ruby
|
def start(helo = 'localhost',
user = nil, secret = nil, authtype = nil) # :yield: smtp
if block_given?
begin
do_start helo, user, secret, authtype
return yield(self)
ensure
do_finish
end
else
do_start helo, user, secret, authtype
return self
end
end
|
[
"def",
"start",
"(",
"helo",
"=",
"'localhost'",
",",
"user",
"=",
"nil",
",",
"secret",
"=",
"nil",
",",
"authtype",
"=",
"nil",
")",
"# :yield: smtp",
"if",
"block_given?",
"begin",
"do_start",
"helo",
",",
"user",
",",
"secret",
",",
"authtype",
"return",
"yield",
"(",
"self",
")",
"ensure",
"do_finish",
"end",
"else",
"do_start",
"helo",
",",
"user",
",",
"secret",
",",
"authtype",
"return",
"self",
"end",
"end"
] |
Opens a TCP connection and starts the SMTP session.
=== Parameters
+helo+ is the _HELO_ _domain_ that you'll dispatch mails from; see
the discussion in the overview notes.
If both of +user+ and +secret+ are given, SMTP authentication
will be attempted using the AUTH command. +authtype+ specifies
the type of authentication to attempt; it must be one of
:login, :plain, and :cram_md5. See the notes on SMTP Authentication
in the overview.
=== Block Usage
When this methods is called with a block, the newly-started SMTP
object is yielded to the block, and automatically closed after
the block call finishes. Otherwise, it is the caller's
responsibility to close the session when finished.
=== Example
This is very similar to the class method SMTP.start.
require 'net/smtp'
smtp = Net::SMTP.new('smtp.mail.server', 25)
smtp.start(helo_domain, account, password, authtype) do |smtp|
smtp.send_message msgstr, 'from@example.com', ['dest@example.com']
end
The primary use of this method (as opposed to SMTP.start)
is probably to set debugging (#set_debug_output) or ESMTP
(#esmtp=), which must be done before the session is
started.
=== Errors
If session has already been started, an IOError will be raised.
This method may raise:
* Net::SMTPAuthenticationError
* Net::SMTPServerBusy
* Net::SMTPSyntaxError
* Net::SMTPFatalError
* Net::SMTPUnknownError
* Net::OpenTimeout
* Net::ReadTimeout
* IOError
|
[
"Opens",
"a",
"TCP",
"connection",
"and",
"starts",
"the",
"SMTP",
"session",
"."
] |
3c5f87b1a44f0ba2865ca0e1dd780dd202f64872
|
https://github.com/rhomobile/rhodes/blob/3c5f87b1a44f0ba2865ca0e1dd780dd202f64872/res/build-tools/ruby-standalone/212/usr/local/lib/ruby/2.1.0/net/smtp.rb#L516-L529
|
17,255
|
rhomobile/rhodes
|
res/build-tools/ruby-standalone/212/usr/local/lib/ruby/2.1.0/net/smtp.rb
|
Net.SMTP.data
|
def data(msgstr = nil, &block) #:yield: stream
if msgstr and block
raise ArgumentError, "message and block are exclusive"
end
unless msgstr or block
raise ArgumentError, "message or block is required"
end
res = critical {
check_continue get_response('DATA')
if msgstr
@socket.write_message msgstr
else
@socket.write_message_by_block(&block)
end
recv_response()
}
check_response res
res
end
|
ruby
|
def data(msgstr = nil, &block) #:yield: stream
if msgstr and block
raise ArgumentError, "message and block are exclusive"
end
unless msgstr or block
raise ArgumentError, "message or block is required"
end
res = critical {
check_continue get_response('DATA')
if msgstr
@socket.write_message msgstr
else
@socket.write_message_by_block(&block)
end
recv_response()
}
check_response res
res
end
|
[
"def",
"data",
"(",
"msgstr",
"=",
"nil",
",",
"&",
"block",
")",
"#:yield: stream",
"if",
"msgstr",
"and",
"block",
"raise",
"ArgumentError",
",",
"\"message and block are exclusive\"",
"end",
"unless",
"msgstr",
"or",
"block",
"raise",
"ArgumentError",
",",
"\"message or block is required\"",
"end",
"res",
"=",
"critical",
"{",
"check_continue",
"get_response",
"(",
"'DATA'",
")",
"if",
"msgstr",
"@socket",
".",
"write_message",
"msgstr",
"else",
"@socket",
".",
"write_message_by_block",
"(",
"block",
")",
"end",
"recv_response",
"(",
")",
"}",
"check_response",
"res",
"res",
"end"
] |
This method sends a message.
If +msgstr+ is given, sends it as a message.
If block is given, yield a message writer stream.
You must write message before the block is closed.
# Example 1 (by string)
smtp.data(<<EndMessage)
From: john@example.com
To: betty@example.com
Subject: I found a bug
Check vm.c:58879.
EndMessage
# Example 2 (by block)
smtp.data {|f|
f.puts "From: john@example.com"
f.puts "To: betty@example.com"
f.puts "Subject: I found a bug"
f.puts ""
f.puts "Check vm.c:58879."
}
|
[
"This",
"method",
"sends",
"a",
"message",
".",
"If",
"+",
"msgstr",
"+",
"is",
"given",
"sends",
"it",
"as",
"a",
"message",
".",
"If",
"block",
"is",
"given",
"yield",
"a",
"message",
"writer",
"stream",
".",
"You",
"must",
"write",
"message",
"before",
"the",
"block",
"is",
"closed",
"."
] |
3c5f87b1a44f0ba2865ca0e1dd780dd202f64872
|
https://github.com/rhomobile/rhodes/blob/3c5f87b1a44f0ba2865ca0e1dd780dd202f64872/res/build-tools/ruby-standalone/212/usr/local/lib/ruby/2.1.0/net/smtp.rb#L895-L913
|
17,256
|
rhomobile/rhodes
|
res/build-tools/ruby-standalone/212/usr/local/lib/ruby/gems/2.1.0/gems/templater-1.0.0/lib/templater/discovery.rb
|
Templater.Discovery.discover!
|
def discover!(scope)
@scopes = {}
generator_files.each do |file|
load file
end
@scopes[scope].each { |block| block.call } if @scopes[scope]
end
|
ruby
|
def discover!(scope)
@scopes = {}
generator_files.each do |file|
load file
end
@scopes[scope].each { |block| block.call } if @scopes[scope]
end
|
[
"def",
"discover!",
"(",
"scope",
")",
"@scopes",
"=",
"{",
"}",
"generator_files",
".",
"each",
"do",
"|",
"file",
"|",
"load",
"file",
"end",
"@scopes",
"[",
"scope",
"]",
".",
"each",
"{",
"|",
"block",
"|",
"block",
".",
"call",
"}",
"if",
"@scopes",
"[",
"scope",
"]",
"end"
] |
Searches installed gems for Generators files and loads all code blocks in them that match
the given scope.
=== Parameters
scope<String>:: The name of the scope to search for
|
[
"Searches",
"installed",
"gems",
"for",
"Generators",
"files",
"and",
"loads",
"all",
"code",
"blocks",
"in",
"them",
"that",
"match",
"the",
"given",
"scope",
"."
] |
3c5f87b1a44f0ba2865ca0e1dd780dd202f64872
|
https://github.com/rhomobile/rhodes/blob/3c5f87b1a44f0ba2865ca0e1dd780dd202f64872/res/build-tools/ruby-standalone/212/usr/local/lib/ruby/gems/2.1.0/gems/templater-1.0.0/lib/templater/discovery.rb#L46-L52
|
17,257
|
rhomobile/rhodes
|
lib/extensions/rexml/rexml/node.rb
|
REXML.Node.each_recursive
|
def each_recursive(&block) # :yields: node
self.elements.each {|node|
block.call(node)
node.each_recursive(&block)
}
end
|
ruby
|
def each_recursive(&block) # :yields: node
self.elements.each {|node|
block.call(node)
node.each_recursive(&block)
}
end
|
[
"def",
"each_recursive",
"(",
"&",
"block",
")",
"# :yields: node",
"self",
".",
"elements",
".",
"each",
"{",
"|",
"node",
"|",
"block",
".",
"call",
"(",
"node",
")",
"node",
".",
"each_recursive",
"(",
"block",
")",
"}",
"end"
] |
Visit all subnodes of +self+ recursively
|
[
"Visit",
"all",
"subnodes",
"of",
"+",
"self",
"+",
"recursively"
] |
3c5f87b1a44f0ba2865ca0e1dd780dd202f64872
|
https://github.com/rhomobile/rhodes/blob/3c5f87b1a44f0ba2865ca0e1dd780dd202f64872/lib/extensions/rexml/rexml/node.rb#L53-L58
|
17,258
|
rhomobile/rhodes
|
res/build-tools/ruby-standalone/212/usr/local/lib/ruby/2.1.0/webrick/cookie.rb
|
WEBrick.Cookie.to_s
|
def to_s
ret = ""
ret << @name << "=" << @value
ret << "; " << "Version=" << @version.to_s if @version > 0
ret << "; " << "Domain=" << @domain if @domain
ret << "; " << "Expires=" << @expires if @expires
ret << "; " << "Max-Age=" << @max_age.to_s if @max_age
ret << "; " << "Comment=" << @comment if @comment
ret << "; " << "Path=" << @path if @path
ret << "; " << "Secure" if @secure
ret
end
|
ruby
|
def to_s
ret = ""
ret << @name << "=" << @value
ret << "; " << "Version=" << @version.to_s if @version > 0
ret << "; " << "Domain=" << @domain if @domain
ret << "; " << "Expires=" << @expires if @expires
ret << "; " << "Max-Age=" << @max_age.to_s if @max_age
ret << "; " << "Comment=" << @comment if @comment
ret << "; " << "Path=" << @path if @path
ret << "; " << "Secure" if @secure
ret
end
|
[
"def",
"to_s",
"ret",
"=",
"\"\"",
"ret",
"<<",
"@name",
"<<",
"\"=\"",
"<<",
"@value",
"ret",
"<<",
"\"; \"",
"<<",
"\"Version=\"",
"<<",
"@version",
".",
"to_s",
"if",
"@version",
">",
"0",
"ret",
"<<",
"\"; \"",
"<<",
"\"Domain=\"",
"<<",
"@domain",
"if",
"@domain",
"ret",
"<<",
"\"; \"",
"<<",
"\"Expires=\"",
"<<",
"@expires",
"if",
"@expires",
"ret",
"<<",
"\"; \"",
"<<",
"\"Max-Age=\"",
"<<",
"@max_age",
".",
"to_s",
"if",
"@max_age",
"ret",
"<<",
"\"; \"",
"<<",
"\"Comment=\"",
"<<",
"@comment",
"if",
"@comment",
"ret",
"<<",
"\"; \"",
"<<",
"\"Path=\"",
"<<",
"@path",
"if",
"@path",
"ret",
"<<",
"\"; \"",
"<<",
"\"Secure\"",
"if",
"@secure",
"ret",
"end"
] |
The cookie string suitable for use in an HTTP header
|
[
"The",
"cookie",
"string",
"suitable",
"for",
"use",
"in",
"an",
"HTTP",
"header"
] |
3c5f87b1a44f0ba2865ca0e1dd780dd202f64872
|
https://github.com/rhomobile/rhodes/blob/3c5f87b1a44f0ba2865ca0e1dd780dd202f64872/res/build-tools/ruby-standalone/212/usr/local/lib/ruby/2.1.0/webrick/cookie.rb#L93-L104
|
17,259
|
rhomobile/rhodes
|
res/build-tools/ruby-standalone/212/usr/local/lib/ruby/2.1.0/net/imap.rb
|
Net.IMAP.disconnect
|
def disconnect
begin
begin
# try to call SSL::SSLSocket#io.
@sock.io.shutdown
rescue NoMethodError
# @sock is not an SSL::SSLSocket.
@sock.shutdown
end
rescue Errno::ENOTCONN
# ignore `Errno::ENOTCONN: Socket is not connected' on some platforms.
rescue Exception => e
@receiver_thread.raise(e)
end
@receiver_thread.join
synchronize do
unless @sock.closed?
@sock.close
end
end
raise e if e
end
|
ruby
|
def disconnect
begin
begin
# try to call SSL::SSLSocket#io.
@sock.io.shutdown
rescue NoMethodError
# @sock is not an SSL::SSLSocket.
@sock.shutdown
end
rescue Errno::ENOTCONN
# ignore `Errno::ENOTCONN: Socket is not connected' on some platforms.
rescue Exception => e
@receiver_thread.raise(e)
end
@receiver_thread.join
synchronize do
unless @sock.closed?
@sock.close
end
end
raise e if e
end
|
[
"def",
"disconnect",
"begin",
"begin",
"# try to call SSL::SSLSocket#io.",
"@sock",
".",
"io",
".",
"shutdown",
"rescue",
"NoMethodError",
"# @sock is not an SSL::SSLSocket.",
"@sock",
".",
"shutdown",
"end",
"rescue",
"Errno",
"::",
"ENOTCONN",
"# ignore `Errno::ENOTCONN: Socket is not connected' on some platforms.",
"rescue",
"Exception",
"=>",
"e",
"@receiver_thread",
".",
"raise",
"(",
"e",
")",
"end",
"@receiver_thread",
".",
"join",
"synchronize",
"do",
"unless",
"@sock",
".",
"closed?",
"@sock",
".",
"close",
"end",
"end",
"raise",
"e",
"if",
"e",
"end"
] |
Disconnects from the server.
|
[
"Disconnects",
"from",
"the",
"server",
"."
] |
3c5f87b1a44f0ba2865ca0e1dd780dd202f64872
|
https://github.com/rhomobile/rhodes/blob/3c5f87b1a44f0ba2865ca0e1dd780dd202f64872/res/build-tools/ruby-standalone/212/usr/local/lib/ruby/2.1.0/net/imap.rb#L315-L336
|
17,260
|
rhomobile/rhodes
|
res/build-tools/ruby-standalone/212/usr/local/lib/ruby/2.1.0/net/imap.rb
|
Net.IMAP.starttls
|
def starttls(options = {}, verify = true)
send_command("STARTTLS") do |resp|
if resp.kind_of?(TaggedResponse) && resp.name == "OK"
begin
# for backward compatibility
certs = options.to_str
options = create_ssl_params(certs, verify)
rescue NoMethodError
end
start_tls_session(options)
end
end
end
|
ruby
|
def starttls(options = {}, verify = true)
send_command("STARTTLS") do |resp|
if resp.kind_of?(TaggedResponse) && resp.name == "OK"
begin
# for backward compatibility
certs = options.to_str
options = create_ssl_params(certs, verify)
rescue NoMethodError
end
start_tls_session(options)
end
end
end
|
[
"def",
"starttls",
"(",
"options",
"=",
"{",
"}",
",",
"verify",
"=",
"true",
")",
"send_command",
"(",
"\"STARTTLS\"",
")",
"do",
"|",
"resp",
"|",
"if",
"resp",
".",
"kind_of?",
"(",
"TaggedResponse",
")",
"&&",
"resp",
".",
"name",
"==",
"\"OK\"",
"begin",
"# for backward compatibility",
"certs",
"=",
"options",
".",
"to_str",
"options",
"=",
"create_ssl_params",
"(",
"certs",
",",
"verify",
")",
"rescue",
"NoMethodError",
"end",
"start_tls_session",
"(",
"options",
")",
"end",
"end",
"end"
] |
Sends a STARTTLS command to start TLS session.
|
[
"Sends",
"a",
"STARTTLS",
"command",
"to",
"start",
"TLS",
"session",
"."
] |
3c5f87b1a44f0ba2865ca0e1dd780dd202f64872
|
https://github.com/rhomobile/rhodes/blob/3c5f87b1a44f0ba2865ca0e1dd780dd202f64872/res/build-tools/ruby-standalone/212/usr/local/lib/ruby/2.1.0/net/imap.rb#L372-L384
|
17,261
|
rhomobile/rhodes
|
res/build-tools/ruby-standalone/212/usr/local/lib/ruby/2.1.0/net/imap.rb
|
Net.IMAP.idle
|
def idle(&response_handler)
raise LocalJumpError, "no block given" unless response_handler
response = nil
synchronize do
tag = Thread.current[:net_imap_tag] = generate_tag
put_string("#{tag} IDLE#{CRLF}")
begin
add_response_handler(response_handler)
@idle_done_cond = new_cond
@idle_done_cond.wait
@idle_done_cond = nil
if @receiver_thread_terminating
raise Net::IMAP::Error, "connection closed"
end
ensure
unless @receiver_thread_terminating
remove_response_handler(response_handler)
put_string("DONE#{CRLF}")
response = get_tagged_response(tag, "IDLE")
end
end
end
return response
end
|
ruby
|
def idle(&response_handler)
raise LocalJumpError, "no block given" unless response_handler
response = nil
synchronize do
tag = Thread.current[:net_imap_tag] = generate_tag
put_string("#{tag} IDLE#{CRLF}")
begin
add_response_handler(response_handler)
@idle_done_cond = new_cond
@idle_done_cond.wait
@idle_done_cond = nil
if @receiver_thread_terminating
raise Net::IMAP::Error, "connection closed"
end
ensure
unless @receiver_thread_terminating
remove_response_handler(response_handler)
put_string("DONE#{CRLF}")
response = get_tagged_response(tag, "IDLE")
end
end
end
return response
end
|
[
"def",
"idle",
"(",
"&",
"response_handler",
")",
"raise",
"LocalJumpError",
",",
"\"no block given\"",
"unless",
"response_handler",
"response",
"=",
"nil",
"synchronize",
"do",
"tag",
"=",
"Thread",
".",
"current",
"[",
":net_imap_tag",
"]",
"=",
"generate_tag",
"put_string",
"(",
"\"#{tag} IDLE#{CRLF}\"",
")",
"begin",
"add_response_handler",
"(",
"response_handler",
")",
"@idle_done_cond",
"=",
"new_cond",
"@idle_done_cond",
".",
"wait",
"@idle_done_cond",
"=",
"nil",
"if",
"@receiver_thread_terminating",
"raise",
"Net",
"::",
"IMAP",
"::",
"Error",
",",
"\"connection closed\"",
"end",
"ensure",
"unless",
"@receiver_thread_terminating",
"remove_response_handler",
"(",
"response_handler",
")",
"put_string",
"(",
"\"DONE#{CRLF}\"",
")",
"response",
"=",
"get_tagged_response",
"(",
"tag",
",",
"\"IDLE\"",
")",
"end",
"end",
"end",
"return",
"response",
"end"
] |
Sends an IDLE command that waits for notifications of new or expunged
messages. Yields responses from the server during the IDLE.
Use #idle_done() to leave IDLE.
|
[
"Sends",
"an",
"IDLE",
"command",
"that",
"waits",
"for",
"notifications",
"of",
"new",
"or",
"expunged",
"messages",
".",
"Yields",
"responses",
"from",
"the",
"server",
"during",
"the",
"IDLE",
"."
] |
3c5f87b1a44f0ba2865ca0e1dd780dd202f64872
|
https://github.com/rhomobile/rhodes/blob/3c5f87b1a44f0ba2865ca0e1dd780dd202f64872/res/build-tools/ruby-standalone/212/usr/local/lib/ruby/2.1.0/net/imap.rb#L910-L937
|
17,262
|
rhomobile/rhodes
|
res/build-tools/ruby-standalone/212/usr/local/lib/ruby/2.1.0/net/http.rb
|
Net.HTTP.get
|
def get(path, initheader = {}, dest = nil, &block) # :yield: +body_segment+
res = nil
request(Get.new(path, initheader)) {|r|
r.read_body dest, &block
res = r
}
res
end
|
ruby
|
def get(path, initheader = {}, dest = nil, &block) # :yield: +body_segment+
res = nil
request(Get.new(path, initheader)) {|r|
r.read_body dest, &block
res = r
}
res
end
|
[
"def",
"get",
"(",
"path",
",",
"initheader",
"=",
"{",
"}",
",",
"dest",
"=",
"nil",
",",
"&",
"block",
")",
"# :yield: +body_segment+",
"res",
"=",
"nil",
"request",
"(",
"Get",
".",
"new",
"(",
"path",
",",
"initheader",
")",
")",
"{",
"|",
"r",
"|",
"r",
".",
"read_body",
"dest",
",",
"block",
"res",
"=",
"r",
"}",
"res",
"end"
] |
Retrieves data from +path+ on the connected-to host which may be an
absolute path String or a URI to extract the path from.
+initheader+ must be a Hash like { 'Accept' => '*/*', ... },
and it defaults to an empty hash.
If +initheader+ doesn't have the key 'accept-encoding', then
a value of "gzip;q=1.0,deflate;q=0.6,identity;q=0.3" is used,
so that gzip compression is used in preference to deflate
compression, which is used in preference to no compression.
Ruby doesn't have libraries to support the compress (Lempel-Ziv)
compression, so that is not supported. The intent of this is
to reduce bandwidth by default. If this routine sets up
compression, then it does the decompression also, removing
the header as well to prevent confusion. Otherwise
it leaves the body as it found it.
This method returns a Net::HTTPResponse object.
If called with a block, yields each fragment of the
entity body in turn as a string as it is read from
the socket. Note that in this case, the returned response
object will *not* contain a (meaningful) body.
+dest+ argument is obsolete.
It still works but you must not use it.
This method never raises an exception.
response = http.get('/index.html')
# using block
File.open('result.txt', 'w') {|f|
http.get('/~foo/') do |str|
f.write str
end
}
|
[
"Retrieves",
"data",
"from",
"+",
"path",
"+",
"on",
"the",
"connected",
"-",
"to",
"host",
"which",
"may",
"be",
"an",
"absolute",
"path",
"String",
"or",
"a",
"URI",
"to",
"extract",
"the",
"path",
"from",
"."
] |
3c5f87b1a44f0ba2865ca0e1dd780dd202f64872
|
https://github.com/rhomobile/rhodes/blob/3c5f87b1a44f0ba2865ca0e1dd780dd202f64872/res/build-tools/ruby-standalone/212/usr/local/lib/ruby/2.1.0/net/http.rb#L1126-L1133
|
17,263
|
rhomobile/rhodes
|
res/build-tools/ruby-standalone/212/usr/local/lib/ruby/2.1.0/net/http.rb
|
Net.HTTP.patch
|
def patch(path, data, initheader = nil, dest = nil, &block) # :yield: +body_segment+
send_entity(path, data, initheader, dest, Patch, &block)
end
|
ruby
|
def patch(path, data, initheader = nil, dest = nil, &block) # :yield: +body_segment+
send_entity(path, data, initheader, dest, Patch, &block)
end
|
[
"def",
"patch",
"(",
"path",
",",
"data",
",",
"initheader",
"=",
"nil",
",",
"dest",
"=",
"nil",
",",
"&",
"block",
")",
"# :yield: +body_segment+",
"send_entity",
"(",
"path",
",",
"data",
",",
"initheader",
",",
"dest",
",",
"Patch",
",",
"block",
")",
"end"
] |
Sends a PATCH request to the +path+ and gets a response,
as an HTTPResponse object.
|
[
"Sends",
"a",
"PATCH",
"request",
"to",
"the",
"+",
"path",
"+",
"and",
"gets",
"a",
"response",
"as",
"an",
"HTTPResponse",
"object",
"."
] |
3c5f87b1a44f0ba2865ca0e1dd780dd202f64872
|
https://github.com/rhomobile/rhodes/blob/3c5f87b1a44f0ba2865ca0e1dd780dd202f64872/res/build-tools/ruby-standalone/212/usr/local/lib/ruby/2.1.0/net/http.rb#L1186-L1188
|
17,264
|
rhomobile/rhodes
|
res/build-tools/ruby-standalone/212/usr/local/lib/ruby/2.1.0/net/http.rb
|
Net.HTTP.proppatch
|
def proppatch(path, body, initheader = nil)
request(Proppatch.new(path, initheader), body)
end
|
ruby
|
def proppatch(path, body, initheader = nil)
request(Proppatch.new(path, initheader), body)
end
|
[
"def",
"proppatch",
"(",
"path",
",",
"body",
",",
"initheader",
"=",
"nil",
")",
"request",
"(",
"Proppatch",
".",
"new",
"(",
"path",
",",
"initheader",
")",
",",
"body",
")",
"end"
] |
Sends a PROPPATCH request to the +path+ and gets a response,
as an HTTPResponse object.
|
[
"Sends",
"a",
"PROPPATCH",
"request",
"to",
"the",
"+",
"path",
"+",
"and",
"gets",
"a",
"response",
"as",
"an",
"HTTPResponse",
"object",
"."
] |
3c5f87b1a44f0ba2865ca0e1dd780dd202f64872
|
https://github.com/rhomobile/rhodes/blob/3c5f87b1a44f0ba2865ca0e1dd780dd202f64872/res/build-tools/ruby-standalone/212/usr/local/lib/ruby/2.1.0/net/http.rb#L1196-L1198
|
17,265
|
rhomobile/rhodes
|
res/build-tools/ruby-standalone/212/usr/local/lib/ruby/2.1.0/net/http.rb
|
Net.HTTP.lock
|
def lock(path, body, initheader = nil)
request(Lock.new(path, initheader), body)
end
|
ruby
|
def lock(path, body, initheader = nil)
request(Lock.new(path, initheader), body)
end
|
[
"def",
"lock",
"(",
"path",
",",
"body",
",",
"initheader",
"=",
"nil",
")",
"request",
"(",
"Lock",
".",
"new",
"(",
"path",
",",
"initheader",
")",
",",
"body",
")",
"end"
] |
Sends a LOCK request to the +path+ and gets a response,
as an HTTPResponse object.
|
[
"Sends",
"a",
"LOCK",
"request",
"to",
"the",
"+",
"path",
"+",
"and",
"gets",
"a",
"response",
"as",
"an",
"HTTPResponse",
"object",
"."
] |
3c5f87b1a44f0ba2865ca0e1dd780dd202f64872
|
https://github.com/rhomobile/rhodes/blob/3c5f87b1a44f0ba2865ca0e1dd780dd202f64872/res/build-tools/ruby-standalone/212/usr/local/lib/ruby/2.1.0/net/http.rb#L1202-L1204
|
17,266
|
rhomobile/rhodes
|
res/build-tools/ruby-standalone/212/usr/local/lib/ruby/2.1.0/net/http.rb
|
Net.HTTP.unlock
|
def unlock(path, body, initheader = nil)
request(Unlock.new(path, initheader), body)
end
|
ruby
|
def unlock(path, body, initheader = nil)
request(Unlock.new(path, initheader), body)
end
|
[
"def",
"unlock",
"(",
"path",
",",
"body",
",",
"initheader",
"=",
"nil",
")",
"request",
"(",
"Unlock",
".",
"new",
"(",
"path",
",",
"initheader",
")",
",",
"body",
")",
"end"
] |
Sends a UNLOCK request to the +path+ and gets a response,
as an HTTPResponse object.
|
[
"Sends",
"a",
"UNLOCK",
"request",
"to",
"the",
"+",
"path",
"+",
"and",
"gets",
"a",
"response",
"as",
"an",
"HTTPResponse",
"object",
"."
] |
3c5f87b1a44f0ba2865ca0e1dd780dd202f64872
|
https://github.com/rhomobile/rhodes/blob/3c5f87b1a44f0ba2865ca0e1dd780dd202f64872/res/build-tools/ruby-standalone/212/usr/local/lib/ruby/2.1.0/net/http.rb#L1208-L1210
|
17,267
|
rhomobile/rhodes
|
res/build-tools/ruby-standalone/212/usr/local/lib/ruby/2.1.0/net/http.rb
|
Net.HTTP.propfind
|
def propfind(path, body = nil, initheader = {'Depth' => '0'})
request(Propfind.new(path, initheader), body)
end
|
ruby
|
def propfind(path, body = nil, initheader = {'Depth' => '0'})
request(Propfind.new(path, initheader), body)
end
|
[
"def",
"propfind",
"(",
"path",
",",
"body",
"=",
"nil",
",",
"initheader",
"=",
"{",
"'Depth'",
"=>",
"'0'",
"}",
")",
"request",
"(",
"Propfind",
".",
"new",
"(",
"path",
",",
"initheader",
")",
",",
"body",
")",
"end"
] |
Sends a PROPFIND request to the +path+ and gets a response,
as an HTTPResponse object.
|
[
"Sends",
"a",
"PROPFIND",
"request",
"to",
"the",
"+",
"path",
"+",
"and",
"gets",
"a",
"response",
"as",
"an",
"HTTPResponse",
"object",
"."
] |
3c5f87b1a44f0ba2865ca0e1dd780dd202f64872
|
https://github.com/rhomobile/rhodes/blob/3c5f87b1a44f0ba2865ca0e1dd780dd202f64872/res/build-tools/ruby-standalone/212/usr/local/lib/ruby/2.1.0/net/http.rb#L1220-L1222
|
17,268
|
rhomobile/rhodes
|
res/build-tools/ruby-standalone/212/usr/local/lib/ruby/2.1.0/net/http.rb
|
Net.HTTP.mkcol
|
def mkcol(path, body = nil, initheader = nil)
request(Mkcol.new(path, initheader), body)
end
|
ruby
|
def mkcol(path, body = nil, initheader = nil)
request(Mkcol.new(path, initheader), body)
end
|
[
"def",
"mkcol",
"(",
"path",
",",
"body",
"=",
"nil",
",",
"initheader",
"=",
"nil",
")",
"request",
"(",
"Mkcol",
".",
"new",
"(",
"path",
",",
"initheader",
")",
",",
"body",
")",
"end"
] |
Sends a MKCOL request to the +path+ and gets a response,
as an HTTPResponse object.
|
[
"Sends",
"a",
"MKCOL",
"request",
"to",
"the",
"+",
"path",
"+",
"and",
"gets",
"a",
"response",
"as",
"an",
"HTTPResponse",
"object",
"."
] |
3c5f87b1a44f0ba2865ca0e1dd780dd202f64872
|
https://github.com/rhomobile/rhodes/blob/3c5f87b1a44f0ba2865ca0e1dd780dd202f64872/res/build-tools/ruby-standalone/212/usr/local/lib/ruby/2.1.0/net/http.rb#L1244-L1246
|
17,269
|
rhomobile/rhodes
|
res/build-tools/ruby-standalone/212/usr/local/lib/ruby/2.1.0/net/http.rb
|
Net.HTTP.request_post
|
def request_post(path, data, initheader = nil, &block) # :yield: +response+
request Post.new(path, initheader), data, &block
end
|
ruby
|
def request_post(path, data, initheader = nil, &block) # :yield: +response+
request Post.new(path, initheader), data, &block
end
|
[
"def",
"request_post",
"(",
"path",
",",
"data",
",",
"initheader",
"=",
"nil",
",",
"&",
"block",
")",
"# :yield: +response+",
"request",
"Post",
".",
"new",
"(",
"path",
",",
"initheader",
")",
",",
"data",
",",
"block",
"end"
] |
Sends a POST request to the +path+.
Returns the response as a Net::HTTPResponse object.
When called with a block, the block is passed an HTTPResponse
object. The body of that response will not have been read yet;
the block can process it using HTTPResponse#read_body, if desired.
Returns the response.
This method never raises Net::* exceptions.
# example
response = http.request_post('/cgi-bin/nice.rb', 'datadatadata...')
p response.status
puts response.body # body is already read in this case
# using block
http.request_post('/cgi-bin/nice.rb', 'datadatadata...') {|response|
p response.status
p response['content-type']
response.read_body do |str| # read body now
print str
end
}
|
[
"Sends",
"a",
"POST",
"request",
"to",
"the",
"+",
"path",
"+",
"."
] |
3c5f87b1a44f0ba2865ca0e1dd780dd202f64872
|
https://github.com/rhomobile/rhodes/blob/3c5f87b1a44f0ba2865ca0e1dd780dd202f64872/res/build-tools/ruby-standalone/212/usr/local/lib/ruby/2.1.0/net/http.rb#L1323-L1325
|
17,270
|
rhomobile/rhodes
|
res/build-tools/ruby-standalone/212/usr/local/lib/ruby/2.1.0/net/http.rb
|
Net.HTTP.request
|
def request(req, body = nil, &block) # :yield: +response+
unless started?
start {
req['connection'] ||= 'close'
return request(req, body, &block)
}
end
if proxy_user()
req.proxy_basic_auth proxy_user(), proxy_pass() unless use_ssl?
end
req.set_body_internal body
res = transport_request(req, &block)
if sspi_auth?(res)
sspi_auth(req)
res = transport_request(req, &block)
end
res
end
|
ruby
|
def request(req, body = nil, &block) # :yield: +response+
unless started?
start {
req['connection'] ||= 'close'
return request(req, body, &block)
}
end
if proxy_user()
req.proxy_basic_auth proxy_user(), proxy_pass() unless use_ssl?
end
req.set_body_internal body
res = transport_request(req, &block)
if sspi_auth?(res)
sspi_auth(req)
res = transport_request(req, &block)
end
res
end
|
[
"def",
"request",
"(",
"req",
",",
"body",
"=",
"nil",
",",
"&",
"block",
")",
"# :yield: +response+",
"unless",
"started?",
"start",
"{",
"req",
"[",
"'connection'",
"]",
"||=",
"'close'",
"return",
"request",
"(",
"req",
",",
"body",
",",
"block",
")",
"}",
"end",
"if",
"proxy_user",
"(",
")",
"req",
".",
"proxy_basic_auth",
"proxy_user",
"(",
")",
",",
"proxy_pass",
"(",
")",
"unless",
"use_ssl?",
"end",
"req",
".",
"set_body_internal",
"body",
"res",
"=",
"transport_request",
"(",
"req",
",",
"block",
")",
"if",
"sspi_auth?",
"(",
"res",
")",
"sspi_auth",
"(",
"req",
")",
"res",
"=",
"transport_request",
"(",
"req",
",",
"block",
")",
"end",
"res",
"end"
] |
Sends an HTTPRequest object +req+ to the HTTP server.
If +req+ is a Net::HTTP::Post or Net::HTTP::Put request containing
data, the data is also sent. Providing data for a Net::HTTP::Head or
Net::HTTP::Get request results in an ArgumentError.
Returns an HTTPResponse object.
When called with a block, passes an HTTPResponse object to the block.
The body of the response will not have been read yet;
the block can process it using HTTPResponse#read_body,
if desired.
This method never raises Net::* exceptions.
|
[
"Sends",
"an",
"HTTPRequest",
"object",
"+",
"req",
"+",
"to",
"the",
"HTTP",
"server",
"."
] |
3c5f87b1a44f0ba2865ca0e1dd780dd202f64872
|
https://github.com/rhomobile/rhodes/blob/3c5f87b1a44f0ba2865ca0e1dd780dd202f64872/res/build-tools/ruby-standalone/212/usr/local/lib/ruby/2.1.0/net/http.rb#L1367-L1384
|
17,271
|
rhomobile/rhodes
|
res/build-tools/ruby-standalone/212/usr/local/lib/ruby/2.1.0/net/http.rb
|
Net.HTTP.send_entity
|
def send_entity(path, data, initheader, dest, type, &block)
res = nil
request(type.new(path, initheader), data) {|r|
r.read_body dest, &block
res = r
}
res
end
|
ruby
|
def send_entity(path, data, initheader, dest, type, &block)
res = nil
request(type.new(path, initheader), data) {|r|
r.read_body dest, &block
res = r
}
res
end
|
[
"def",
"send_entity",
"(",
"path",
",",
"data",
",",
"initheader",
",",
"dest",
",",
"type",
",",
"&",
"block",
")",
"res",
"=",
"nil",
"request",
"(",
"type",
".",
"new",
"(",
"path",
",",
"initheader",
")",
",",
"data",
")",
"{",
"|",
"r",
"|",
"r",
".",
"read_body",
"dest",
",",
"block",
"res",
"=",
"r",
"}",
"res",
"end"
] |
Executes a request which uses a representation
and returns its body.
|
[
"Executes",
"a",
"request",
"which",
"uses",
"a",
"representation",
"and",
"returns",
"its",
"body",
"."
] |
3c5f87b1a44f0ba2865ca0e1dd780dd202f64872
|
https://github.com/rhomobile/rhodes/blob/3c5f87b1a44f0ba2865ca0e1dd780dd202f64872/res/build-tools/ruby-standalone/212/usr/local/lib/ruby/2.1.0/net/http.rb#L1390-L1397
|
17,272
|
rhomobile/rhodes
|
lib/extensions/openssl/openssl/config.rb
|
OpenSSL.Config.get_value
|
def get_value(section, key)
if section.nil?
raise TypeError.new('nil not allowed')
end
section = 'default' if section.empty?
get_key_string(section, key)
end
|
ruby
|
def get_value(section, key)
if section.nil?
raise TypeError.new('nil not allowed')
end
section = 'default' if section.empty?
get_key_string(section, key)
end
|
[
"def",
"get_value",
"(",
"section",
",",
"key",
")",
"if",
"section",
".",
"nil?",
"raise",
"TypeError",
".",
"new",
"(",
"'nil not allowed'",
")",
"end",
"section",
"=",
"'default'",
"if",
"section",
".",
"empty?",
"get_key_string",
"(",
"section",
",",
"key",
")",
"end"
] |
Creates an instance of OpenSSL's configuration class.
This can be used in contexts like OpenSSL::X509::ExtensionFactory.config=
If the optional +filename+ parameter is provided, then it is read in and
parsed via #parse_config.
This can raise IO exceptions based on the access, or availability of the
file. A ConfigError exception may be raised depending on the validity of
the data being configured.
Gets the value of +key+ from the given +section+
Given the following configurating file being loaded:
config = OpenSSL::Config.load('foo.cnf')
#=> #<OpenSSL::Config sections=["default"]>
puts config.to_s
#=> [ default ]
# foo=bar
You can get a specific value from the config if you know the +section+
and +key+ like so:
config.get_value('default','foo')
#=> "bar"
|
[
"Creates",
"an",
"instance",
"of",
"OpenSSL",
"s",
"configuration",
"class",
"."
] |
3c5f87b1a44f0ba2865ca0e1dd780dd202f64872
|
https://github.com/rhomobile/rhodes/blob/3c5f87b1a44f0ba2865ca0e1dd780dd202f64872/lib/extensions/openssl/openssl/config.rb#L274-L280
|
17,273
|
rhomobile/rhodes
|
lib/extensions/openssl/openssl/config.rb
|
OpenSSL.Config.[]=
|
def []=(section, pairs)
check_modify
@data[section] ||= {}
pairs.each do |key, value|
self.add_value(section, key, value)
end
end
|
ruby
|
def []=(section, pairs)
check_modify
@data[section] ||= {}
pairs.each do |key, value|
self.add_value(section, key, value)
end
end
|
[
"def",
"[]=",
"(",
"section",
",",
"pairs",
")",
"check_modify",
"@data",
"[",
"section",
"]",
"||=",
"{",
"}",
"pairs",
".",
"each",
"do",
"|",
"key",
",",
"value",
"|",
"self",
".",
"add_value",
"(",
"section",
",",
"key",
",",
"value",
")",
"end",
"end"
] |
Sets a specific +section+ name with a Hash +pairs+
Given the following configuration being created:
config = OpenSSL::Config.new
#=> #<OpenSSL::Config sections=[]>
config['default'] = {"foo"=>"bar","baz"=>"buz"}
#=> {"foo"=>"bar", "baz"=>"buz"}
puts config.to_s
#=> [ default ]
# foo=bar
# baz=buz
It's important to note that this will essentially merge any of the keys
in +pairs+ with the existing +section+. For example:
config['default']
#=> {"foo"=>"bar", "baz"=>"buz"}
config['default'] = {"foo" => "changed"}
#=> {"foo"=>"changed"}
config['default']
#=> {"foo"=>"changed", "baz"=>"buz"}
|
[
"Sets",
"a",
"specific",
"+",
"section",
"+",
"name",
"with",
"a",
"Hash",
"+",
"pairs",
"+"
] |
3c5f87b1a44f0ba2865ca0e1dd780dd202f64872
|
https://github.com/rhomobile/rhodes/blob/3c5f87b1a44f0ba2865ca0e1dd780dd202f64872/lib/extensions/openssl/openssl/config.rb#L377-L383
|
17,274
|
rhomobile/rhodes
|
lib/extensions/openssl/openssl/config.rb
|
OpenSSL.Config.to_s
|
def to_s
ary = []
@data.keys.sort.each do |section|
ary << "[ #{section} ]\n"
@data[section].keys.each do |key|
ary << "#{key}=#{@data[section][key]}\n"
end
ary << "\n"
end
ary.join
end
|
ruby
|
def to_s
ary = []
@data.keys.sort.each do |section|
ary << "[ #{section} ]\n"
@data[section].keys.each do |key|
ary << "#{key}=#{@data[section][key]}\n"
end
ary << "\n"
end
ary.join
end
|
[
"def",
"to_s",
"ary",
"=",
"[",
"]",
"@data",
".",
"keys",
".",
"sort",
".",
"each",
"do",
"|",
"section",
"|",
"ary",
"<<",
"\"[ #{section} ]\\n\"",
"@data",
"[",
"section",
"]",
".",
"keys",
".",
"each",
"do",
"|",
"key",
"|",
"ary",
"<<",
"\"#{key}=#{@data[section][key]}\\n\"",
"end",
"ary",
"<<",
"\"\\n\"",
"end",
"ary",
".",
"join",
"end"
] |
Get the parsable form of the current configuration
Given the following configuration being created:
config = OpenSSL::Config.new
#=> #<OpenSSL::Config sections=[]>
config['default'] = {"foo"=>"bar","baz"=>"buz"}
#=> {"foo"=>"bar", "baz"=>"buz"}
puts config.to_s
#=> [ default ]
# foo=bar
# baz=buz
You can parse get the serialized configuration using #to_s and then parse
it later:
serialized_config = config.to_s
# much later...
new_config = OpenSSL::Config.parse(serialized_config)
#=> #<OpenSSL::Config sections=["default"]>
puts new_config
#=> [ default ]
foo=bar
baz=buz
|
[
"Get",
"the",
"parsable",
"form",
"of",
"the",
"current",
"configuration"
] |
3c5f87b1a44f0ba2865ca0e1dd780dd202f64872
|
https://github.com/rhomobile/rhodes/blob/3c5f87b1a44f0ba2865ca0e1dd780dd202f64872/lib/extensions/openssl/openssl/config.rb#L417-L427
|
17,275
|
rhomobile/rhodes
|
lib/extensions/openssl/openssl/config.rb
|
OpenSSL.Config.each
|
def each
@data.each do |section, hash|
hash.each do |key, value|
yield [section, key, value]
end
end
end
|
ruby
|
def each
@data.each do |section, hash|
hash.each do |key, value|
yield [section, key, value]
end
end
end
|
[
"def",
"each",
"@data",
".",
"each",
"do",
"|",
"section",
",",
"hash",
"|",
"hash",
".",
"each",
"do",
"|",
"key",
",",
"value",
"|",
"yield",
"[",
"section",
",",
"key",
",",
"value",
"]",
"end",
"end",
"end"
] |
For a block.
Receive the section and its pairs for the current configuration.
config.each do |section, key, value|
# ...
end
|
[
"For",
"a",
"block",
"."
] |
3c5f87b1a44f0ba2865ca0e1dd780dd202f64872
|
https://github.com/rhomobile/rhodes/blob/3c5f87b1a44f0ba2865ca0e1dd780dd202f64872/lib/extensions/openssl/openssl/config.rb#L438-L444
|
17,276
|
rhomobile/rhodes
|
lib/extensions/rexml/rexml/parent.rb
|
REXML.Parent.insert_before
|
def insert_before( child1, child2 )
if child1.kind_of? String
child1 = XPath.first( self, child1 )
child1.parent.insert_before child1, child2
else
ind = index(child1)
child2.parent.delete(child2) if child2.parent
@children[ind,0] = child2
child2.parent = self
end
self
end
|
ruby
|
def insert_before( child1, child2 )
if child1.kind_of? String
child1 = XPath.first( self, child1 )
child1.parent.insert_before child1, child2
else
ind = index(child1)
child2.parent.delete(child2) if child2.parent
@children[ind,0] = child2
child2.parent = self
end
self
end
|
[
"def",
"insert_before",
"(",
"child1",
",",
"child2",
")",
"if",
"child1",
".",
"kind_of?",
"String",
"child1",
"=",
"XPath",
".",
"first",
"(",
"self",
",",
"child1",
")",
"child1",
".",
"parent",
".",
"insert_before",
"child1",
",",
"child2",
"else",
"ind",
"=",
"index",
"(",
"child1",
")",
"child2",
".",
"parent",
".",
"delete",
"(",
"child2",
")",
"if",
"child2",
".",
"parent",
"@children",
"[",
"ind",
",",
"0",
"]",
"=",
"child2",
"child2",
".",
"parent",
"=",
"self",
"end",
"self",
"end"
] |
Inserts an child before another child
@param child1 this is either an xpath or an Element. If an Element,
child2 will be inserted before child1 in the child list of the parent.
If an xpath, child2 will be inserted before the first child to match
the xpath.
@param child2 the child to insert
@return the parent (self)
|
[
"Inserts",
"an",
"child",
"before",
"another",
"child"
] |
3c5f87b1a44f0ba2865ca0e1dd780dd202f64872
|
https://github.com/rhomobile/rhodes/blob/3c5f87b1a44f0ba2865ca0e1dd780dd202f64872/lib/extensions/rexml/rexml/parent.rb#L83-L94
|
17,277
|
rhomobile/rhodes
|
lib/extensions/rexml/rexml/parent.rb
|
REXML.Parent.index
|
def index( child )
count = -1
@children.find { |i| count += 1 ; i.hash == child.hash }
count
end
|
ruby
|
def index( child )
count = -1
@children.find { |i| count += 1 ; i.hash == child.hash }
count
end
|
[
"def",
"index",
"(",
"child",
")",
"count",
"=",
"-",
"1",
"@children",
".",
"find",
"{",
"|",
"i",
"|",
"count",
"+=",
"1",
";",
"i",
".",
"hash",
"==",
"child",
".",
"hash",
"}",
"count",
"end"
] |
Fetches the index of a given child
@param child the child to get the index of
@return the index of the child, or nil if the object is not a child
of this parent.
|
[
"Fetches",
"the",
"index",
"of",
"a",
"given",
"child"
] |
3c5f87b1a44f0ba2865ca0e1dd780dd202f64872
|
https://github.com/rhomobile/rhodes/blob/3c5f87b1a44f0ba2865ca0e1dd780dd202f64872/lib/extensions/rexml/rexml/parent.rb#L124-L128
|
17,278
|
rhomobile/rhodes
|
lib/extensions/rexml/rexml/parent.rb
|
REXML.Parent.replace_child
|
def replace_child( to_replace, replacement )
@children.map! {|c| c.equal?( to_replace ) ? replacement : c }
to_replace.parent = nil
replacement.parent = self
end
|
ruby
|
def replace_child( to_replace, replacement )
@children.map! {|c| c.equal?( to_replace ) ? replacement : c }
to_replace.parent = nil
replacement.parent = self
end
|
[
"def",
"replace_child",
"(",
"to_replace",
",",
"replacement",
")",
"@children",
".",
"map!",
"{",
"|",
"c",
"|",
"c",
".",
"equal?",
"(",
"to_replace",
")",
"?",
"replacement",
":",
"c",
"}",
"to_replace",
".",
"parent",
"=",
"nil",
"replacement",
".",
"parent",
"=",
"self",
"end"
] |
Replaces one child with another, making sure the nodelist is correct
@param to_replace the child to replace (must be a Child)
@param replacement the child to insert into the nodelist (must be a
Child)
|
[
"Replaces",
"one",
"child",
"with",
"another",
"making",
"sure",
"the",
"nodelist",
"is",
"correct"
] |
3c5f87b1a44f0ba2865ca0e1dd780dd202f64872
|
https://github.com/rhomobile/rhodes/blob/3c5f87b1a44f0ba2865ca0e1dd780dd202f64872/lib/extensions/rexml/rexml/parent.rb#L141-L145
|
17,279
|
rhomobile/rhodes
|
lib/extensions/rexml/rexml/parent.rb
|
REXML.Parent.deep_clone
|
def deep_clone
cl = clone()
each do |child|
if child.kind_of? Parent
cl << child.deep_clone
else
cl << child.clone
end
end
cl
end
|
ruby
|
def deep_clone
cl = clone()
each do |child|
if child.kind_of? Parent
cl << child.deep_clone
else
cl << child.clone
end
end
cl
end
|
[
"def",
"deep_clone",
"cl",
"=",
"clone",
"(",
")",
"each",
"do",
"|",
"child",
"|",
"if",
"child",
".",
"kind_of?",
"Parent",
"cl",
"<<",
"child",
".",
"deep_clone",
"else",
"cl",
"<<",
"child",
".",
"clone",
"end",
"end",
"cl",
"end"
] |
Deeply clones this object. This creates a complete duplicate of this
Parent, including all descendants.
|
[
"Deeply",
"clones",
"this",
"object",
".",
"This",
"creates",
"a",
"complete",
"duplicate",
"of",
"this",
"Parent",
"including",
"all",
"descendants",
"."
] |
3c5f87b1a44f0ba2865ca0e1dd780dd202f64872
|
https://github.com/rhomobile/rhodes/blob/3c5f87b1a44f0ba2865ca0e1dd780dd202f64872/lib/extensions/rexml/rexml/parent.rb#L149-L159
|
17,280
|
rhomobile/rhodes
|
lib/extensions/rexml/rexml/instruction.rb
|
REXML.Instruction.write
|
def write writer, indent=-1, transitive=false, ie_hack=false
Kernel.warn( "#{self.class.name}.write is deprecated" )
indent(writer, indent)
writer << START.sub(/\\/u, '')
writer << @target
writer << ' '
writer << @content
writer << STOP.sub(/\\/u, '')
end
|
ruby
|
def write writer, indent=-1, transitive=false, ie_hack=false
Kernel.warn( "#{self.class.name}.write is deprecated" )
indent(writer, indent)
writer << START.sub(/\\/u, '')
writer << @target
writer << ' '
writer << @content
writer << STOP.sub(/\\/u, '')
end
|
[
"def",
"write",
"writer",
",",
"indent",
"=",
"-",
"1",
",",
"transitive",
"=",
"false",
",",
"ie_hack",
"=",
"false",
"Kernel",
".",
"warn",
"(",
"\"#{self.class.name}.write is deprecated\"",
")",
"indent",
"(",
"writer",
",",
"indent",
")",
"writer",
"<<",
"START",
".",
"sub",
"(",
"/",
"\\\\",
"/u",
",",
"''",
")",
"writer",
"<<",
"@target",
"writer",
"<<",
"' '",
"writer",
"<<",
"@content",
"writer",
"<<",
"STOP",
".",
"sub",
"(",
"/",
"\\\\",
"/u",
",",
"''",
")",
"end"
] |
Constructs a new Instruction
@param target can be one of a number of things. If String, then
the target of this instruction is set to this. If an Instruction,
then the Instruction is shallowly cloned (target and content are
copied). If a Source, then the source is scanned and parsed for
an Instruction declaration.
@param content Must be either a String, or a Parent. Can only
be a Parent if the target argument is a Source. Otherwise, this
String is set as the content of this instruction.
== DEPRECATED
See the rexml/formatters package
|
[
"Constructs",
"a",
"new",
"Instruction"
] |
3c5f87b1a44f0ba2865ca0e1dd780dd202f64872
|
https://github.com/rhomobile/rhodes/blob/3c5f87b1a44f0ba2865ca0e1dd780dd202f64872/lib/extensions/rexml/rexml/instruction.rb#L44-L52
|
17,281
|
rhomobile/rhodes
|
res/build-tools/ruby-standalone/212/usr/local/lib/ruby/gems/2.1.0/gems/templater-1.0.0/lib/templater/description.rb
|
Templater.ArgumentDescription.valid?
|
def valid?(argument)
if argument.nil? and options[:required]
raise Templater::TooFewArgumentsError
elsif not argument.nil?
if options[:as] == :hash and not argument.is_a?(Hash)
raise Templater::MalformattedArgumentError, "Expected the argument to be a Hash, but was '#{argument.inspect}'"
elsif options[:as] == :array and not argument.is_a?(Array)
raise Templater::MalformattedArgumentError, "Expected the argument to be an Array, but was '#{argument.inspect}'"
end
invalid = catch :invalid do
block.call(argument) if block
throw :invalid, :not_invalid
end
raise Templater::ArgumentError, invalid unless invalid == :not_invalid
end
end
|
ruby
|
def valid?(argument)
if argument.nil? and options[:required]
raise Templater::TooFewArgumentsError
elsif not argument.nil?
if options[:as] == :hash and not argument.is_a?(Hash)
raise Templater::MalformattedArgumentError, "Expected the argument to be a Hash, but was '#{argument.inspect}'"
elsif options[:as] == :array and not argument.is_a?(Array)
raise Templater::MalformattedArgumentError, "Expected the argument to be an Array, but was '#{argument.inspect}'"
end
invalid = catch :invalid do
block.call(argument) if block
throw :invalid, :not_invalid
end
raise Templater::ArgumentError, invalid unless invalid == :not_invalid
end
end
|
[
"def",
"valid?",
"(",
"argument",
")",
"if",
"argument",
".",
"nil?",
"and",
"options",
"[",
":required",
"]",
"raise",
"Templater",
"::",
"TooFewArgumentsError",
"elsif",
"not",
"argument",
".",
"nil?",
"if",
"options",
"[",
":as",
"]",
"==",
":hash",
"and",
"not",
"argument",
".",
"is_a?",
"(",
"Hash",
")",
"raise",
"Templater",
"::",
"MalformattedArgumentError",
",",
"\"Expected the argument to be a Hash, but was '#{argument.inspect}'\"",
"elsif",
"options",
"[",
":as",
"]",
"==",
":array",
"and",
"not",
"argument",
".",
"is_a?",
"(",
"Array",
")",
"raise",
"Templater",
"::",
"MalformattedArgumentError",
",",
"\"Expected the argument to be an Array, but was '#{argument.inspect}'\"",
"end",
"invalid",
"=",
"catch",
":invalid",
"do",
"block",
".",
"call",
"(",
"argument",
")",
"if",
"block",
"throw",
":invalid",
",",
":not_invalid",
"end",
"raise",
"Templater",
"::",
"ArgumentError",
",",
"invalid",
"unless",
"invalid",
"==",
":not_invalid",
"end",
"end"
] |
Checks if the given argument is valid according to this description
=== Parameters
argument<Object>:: Checks if the given argument is valid.
=== Returns
Boolean:: Validity of the argument
|
[
"Checks",
"if",
"the",
"given",
"argument",
"is",
"valid",
"according",
"to",
"this",
"description"
] |
3c5f87b1a44f0ba2865ca0e1dd780dd202f64872
|
https://github.com/rhomobile/rhodes/blob/3c5f87b1a44f0ba2865ca0e1dd780dd202f64872/res/build-tools/ruby-standalone/212/usr/local/lib/ruby/gems/2.1.0/gems/templater-1.0.0/lib/templater/description.rb#L29-L45
|
17,282
|
rhomobile/rhodes
|
res/build-tools/ruby-standalone/212/usr/local/lib/ruby/2.1.0/net/ftp.rb
|
Net.FTP.open_socket
|
def open_socket(host, port) # :nodoc:
return Timeout.timeout(@open_timeout, Net::OpenTimeout) {
if defined? SOCKSSocket and ENV["SOCKS_SERVER"]
@passive = true
sock = SOCKSSocket.open(host, port)
else
sock = TCPSocket.open(host, port)
end
io = BufferedSocket.new(sock)
io.read_timeout = @read_timeout
io
}
end
|
ruby
|
def open_socket(host, port) # :nodoc:
return Timeout.timeout(@open_timeout, Net::OpenTimeout) {
if defined? SOCKSSocket and ENV["SOCKS_SERVER"]
@passive = true
sock = SOCKSSocket.open(host, port)
else
sock = TCPSocket.open(host, port)
end
io = BufferedSocket.new(sock)
io.read_timeout = @read_timeout
io
}
end
|
[
"def",
"open_socket",
"(",
"host",
",",
"port",
")",
"# :nodoc:",
"return",
"Timeout",
".",
"timeout",
"(",
"@open_timeout",
",",
"Net",
"::",
"OpenTimeout",
")",
"{",
"if",
"defined?",
"SOCKSSocket",
"and",
"ENV",
"[",
"\"SOCKS_SERVER\"",
"]",
"@passive",
"=",
"true",
"sock",
"=",
"SOCKSSocket",
".",
"open",
"(",
"host",
",",
"port",
")",
"else",
"sock",
"=",
"TCPSocket",
".",
"open",
"(",
"host",
",",
"port",
")",
"end",
"io",
"=",
"BufferedSocket",
".",
"new",
"(",
"sock",
")",
"io",
".",
"read_timeout",
"=",
"@read_timeout",
"io",
"}",
"end"
] |
Constructs a socket with +host+ and +port+.
If SOCKSSocket is defined and the environment (ENV) defines
SOCKS_SERVER, then a SOCKSSocket is returned, else a TCPSocket is
returned.
|
[
"Constructs",
"a",
"socket",
"with",
"+",
"host",
"+",
"and",
"+",
"port",
"+",
"."
] |
3c5f87b1a44f0ba2865ca0e1dd780dd202f64872
|
https://github.com/rhomobile/rhodes/blob/3c5f87b1a44f0ba2865ca0e1dd780dd202f64872/res/build-tools/ruby-standalone/212/usr/local/lib/ruby/2.1.0/net/ftp.rb#L222-L234
|
17,283
|
rhomobile/rhodes
|
res/build-tools/ruby-standalone/212/usr/local/lib/ruby/2.1.0/net/ftp.rb
|
Net.FTP.transfercmd
|
def transfercmd(cmd, rest_offset = nil) # :nodoc:
if @passive
host, port = makepasv
conn = open_socket(host, port)
if @resume and rest_offset
resp = sendcmd("REST " + rest_offset.to_s)
if resp[0] != ?3
raise FTPReplyError, resp
end
end
resp = sendcmd(cmd)
# skip 2XX for some ftp servers
resp = getresp if resp[0] == ?2
if resp[0] != ?1
raise FTPReplyError, resp
end
else
sock = makeport
if @resume and rest_offset
resp = sendcmd("REST " + rest_offset.to_s)
if resp[0] != ?3
raise FTPReplyError, resp
end
end
resp = sendcmd(cmd)
# skip 2XX for some ftp servers
resp = getresp if resp[0] == ?2
if resp[0] != ?1
raise FTPReplyError, resp
end
conn = BufferedSocket.new(sock.accept)
conn.read_timeout = @read_timeout
sock.shutdown(Socket::SHUT_WR) rescue nil
sock.read rescue nil
sock.close
end
return conn
end
|
ruby
|
def transfercmd(cmd, rest_offset = nil) # :nodoc:
if @passive
host, port = makepasv
conn = open_socket(host, port)
if @resume and rest_offset
resp = sendcmd("REST " + rest_offset.to_s)
if resp[0] != ?3
raise FTPReplyError, resp
end
end
resp = sendcmd(cmd)
# skip 2XX for some ftp servers
resp = getresp if resp[0] == ?2
if resp[0] != ?1
raise FTPReplyError, resp
end
else
sock = makeport
if @resume and rest_offset
resp = sendcmd("REST " + rest_offset.to_s)
if resp[0] != ?3
raise FTPReplyError, resp
end
end
resp = sendcmd(cmd)
# skip 2XX for some ftp servers
resp = getresp if resp[0] == ?2
if resp[0] != ?1
raise FTPReplyError, resp
end
conn = BufferedSocket.new(sock.accept)
conn.read_timeout = @read_timeout
sock.shutdown(Socket::SHUT_WR) rescue nil
sock.read rescue nil
sock.close
end
return conn
end
|
[
"def",
"transfercmd",
"(",
"cmd",
",",
"rest_offset",
"=",
"nil",
")",
"# :nodoc:",
"if",
"@passive",
"host",
",",
"port",
"=",
"makepasv",
"conn",
"=",
"open_socket",
"(",
"host",
",",
"port",
")",
"if",
"@resume",
"and",
"rest_offset",
"resp",
"=",
"sendcmd",
"(",
"\"REST \"",
"+",
"rest_offset",
".",
"to_s",
")",
"if",
"resp",
"[",
"0",
"]",
"!=",
"?3",
"raise",
"FTPReplyError",
",",
"resp",
"end",
"end",
"resp",
"=",
"sendcmd",
"(",
"cmd",
")",
"# skip 2XX for some ftp servers",
"resp",
"=",
"getresp",
"if",
"resp",
"[",
"0",
"]",
"==",
"?2",
"if",
"resp",
"[",
"0",
"]",
"!=",
"?1",
"raise",
"FTPReplyError",
",",
"resp",
"end",
"else",
"sock",
"=",
"makeport",
"if",
"@resume",
"and",
"rest_offset",
"resp",
"=",
"sendcmd",
"(",
"\"REST \"",
"+",
"rest_offset",
".",
"to_s",
")",
"if",
"resp",
"[",
"0",
"]",
"!=",
"?3",
"raise",
"FTPReplyError",
",",
"resp",
"end",
"end",
"resp",
"=",
"sendcmd",
"(",
"cmd",
")",
"# skip 2XX for some ftp servers",
"resp",
"=",
"getresp",
"if",
"resp",
"[",
"0",
"]",
"==",
"?2",
"if",
"resp",
"[",
"0",
"]",
"!=",
"?1",
"raise",
"FTPReplyError",
",",
"resp",
"end",
"conn",
"=",
"BufferedSocket",
".",
"new",
"(",
"sock",
".",
"accept",
")",
"conn",
".",
"read_timeout",
"=",
"@read_timeout",
"sock",
".",
"shutdown",
"(",
"Socket",
"::",
"SHUT_WR",
")",
"rescue",
"nil",
"sock",
".",
"read",
"rescue",
"nil",
"sock",
".",
"close",
"end",
"return",
"conn",
"end"
] |
Constructs a connection for transferring data
|
[
"Constructs",
"a",
"connection",
"for",
"transferring",
"data"
] |
3c5f87b1a44f0ba2865ca0e1dd780dd202f64872
|
https://github.com/rhomobile/rhodes/blob/3c5f87b1a44f0ba2865ca0e1dd780dd202f64872/res/build-tools/ruby-standalone/212/usr/local/lib/ruby/2.1.0/net/ftp.rb#L405-L442
|
17,284
|
rhomobile/rhodes
|
res/build-tools/ruby-standalone/212/usr/local/lib/ruby/2.1.0/net/ftp.rb
|
Net.FTP.getbinaryfile
|
def getbinaryfile(remotefile, localfile = File.basename(remotefile),
blocksize = DEFAULT_BLOCKSIZE) # :yield: data
result = nil
if localfile
if @resume
rest_offset = File.size?(localfile)
f = open(localfile, "a")
else
rest_offset = nil
f = open(localfile, "w")
end
elsif !block_given?
result = ""
end
begin
f.binmode if localfile
retrbinary("RETR " + remotefile.to_s, blocksize, rest_offset) do |data|
f.write(data) if localfile
yield(data) if block_given?
result.concat(data) if result
end
return result
ensure
f.close if localfile
end
end
|
ruby
|
def getbinaryfile(remotefile, localfile = File.basename(remotefile),
blocksize = DEFAULT_BLOCKSIZE) # :yield: data
result = nil
if localfile
if @resume
rest_offset = File.size?(localfile)
f = open(localfile, "a")
else
rest_offset = nil
f = open(localfile, "w")
end
elsif !block_given?
result = ""
end
begin
f.binmode if localfile
retrbinary("RETR " + remotefile.to_s, blocksize, rest_offset) do |data|
f.write(data) if localfile
yield(data) if block_given?
result.concat(data) if result
end
return result
ensure
f.close if localfile
end
end
|
[
"def",
"getbinaryfile",
"(",
"remotefile",
",",
"localfile",
"=",
"File",
".",
"basename",
"(",
"remotefile",
")",
",",
"blocksize",
"=",
"DEFAULT_BLOCKSIZE",
")",
"# :yield: data",
"result",
"=",
"nil",
"if",
"localfile",
"if",
"@resume",
"rest_offset",
"=",
"File",
".",
"size?",
"(",
"localfile",
")",
"f",
"=",
"open",
"(",
"localfile",
",",
"\"a\"",
")",
"else",
"rest_offset",
"=",
"nil",
"f",
"=",
"open",
"(",
"localfile",
",",
"\"w\"",
")",
"end",
"elsif",
"!",
"block_given?",
"result",
"=",
"\"\"",
"end",
"begin",
"f",
".",
"binmode",
"if",
"localfile",
"retrbinary",
"(",
"\"RETR \"",
"+",
"remotefile",
".",
"to_s",
",",
"blocksize",
",",
"rest_offset",
")",
"do",
"|",
"data",
"|",
"f",
".",
"write",
"(",
"data",
")",
"if",
"localfile",
"yield",
"(",
"data",
")",
"if",
"block_given?",
"result",
".",
"concat",
"(",
"data",
")",
"if",
"result",
"end",
"return",
"result",
"ensure",
"f",
".",
"close",
"if",
"localfile",
"end",
"end"
] |
Retrieves +remotefile+ in binary mode, storing the result in +localfile+.
If +localfile+ is nil, returns retrieved data.
If a block is supplied, it is passed the retrieved data in +blocksize+
chunks.
|
[
"Retrieves",
"+",
"remotefile",
"+",
"in",
"binary",
"mode",
"storing",
"the",
"result",
"in",
"+",
"localfile",
"+",
".",
"If",
"+",
"localfile",
"+",
"is",
"nil",
"returns",
"retrieved",
"data",
".",
"If",
"a",
"block",
"is",
"supplied",
"it",
"is",
"passed",
"the",
"retrieved",
"data",
"in",
"+",
"blocksize",
"+",
"chunks",
"."
] |
3c5f87b1a44f0ba2865ca0e1dd780dd202f64872
|
https://github.com/rhomobile/rhodes/blob/3c5f87b1a44f0ba2865ca0e1dd780dd202f64872/res/build-tools/ruby-standalone/212/usr/local/lib/ruby/2.1.0/net/ftp.rb#L602-L627
|
17,285
|
rhomobile/rhodes
|
res/build-tools/ruby-standalone/212/usr/local/lib/ruby/2.1.0/net/ftp.rb
|
Net.FTP.nlst
|
def nlst(dir = nil)
cmd = "NLST"
if dir
cmd = cmd + " " + dir
end
files = []
retrlines(cmd) do |line|
files.push(line)
end
return files
end
|
ruby
|
def nlst(dir = nil)
cmd = "NLST"
if dir
cmd = cmd + " " + dir
end
files = []
retrlines(cmd) do |line|
files.push(line)
end
return files
end
|
[
"def",
"nlst",
"(",
"dir",
"=",
"nil",
")",
"cmd",
"=",
"\"NLST\"",
"if",
"dir",
"cmd",
"=",
"cmd",
"+",
"\" \"",
"+",
"dir",
"end",
"files",
"=",
"[",
"]",
"retrlines",
"(",
"cmd",
")",
"do",
"|",
"line",
"|",
"files",
".",
"push",
"(",
"line",
")",
"end",
"return",
"files",
"end"
] |
Returns an array of filenames in the remote directory.
|
[
"Returns",
"an",
"array",
"of",
"filenames",
"in",
"the",
"remote",
"directory",
"."
] |
3c5f87b1a44f0ba2865ca0e1dd780dd202f64872
|
https://github.com/rhomobile/rhodes/blob/3c5f87b1a44f0ba2865ca0e1dd780dd202f64872/res/build-tools/ruby-standalone/212/usr/local/lib/ruby/2.1.0/net/ftp.rb#L739-L749
|
17,286
|
rhomobile/rhodes
|
res/build-tools/ruby-standalone/212/usr/local/lib/ruby/2.1.0/net/ftp.rb
|
Net.FTP.rename
|
def rename(fromname, toname)
resp = sendcmd("RNFR " + fromname)
if resp[0] != ?3
raise FTPReplyError, resp
end
voidcmd("RNTO " + toname)
end
|
ruby
|
def rename(fromname, toname)
resp = sendcmd("RNFR " + fromname)
if resp[0] != ?3
raise FTPReplyError, resp
end
voidcmd("RNTO " + toname)
end
|
[
"def",
"rename",
"(",
"fromname",
",",
"toname",
")",
"resp",
"=",
"sendcmd",
"(",
"\"RNFR \"",
"+",
"fromname",
")",
"if",
"resp",
"[",
"0",
"]",
"!=",
"?3",
"raise",
"FTPReplyError",
",",
"resp",
"end",
"voidcmd",
"(",
"\"RNTO \"",
"+",
"toname",
")",
"end"
] |
Renames a file on the server.
|
[
"Renames",
"a",
"file",
"on",
"the",
"server",
"."
] |
3c5f87b1a44f0ba2865ca0e1dd780dd202f64872
|
https://github.com/rhomobile/rhodes/blob/3c5f87b1a44f0ba2865ca0e1dd780dd202f64872/res/build-tools/ruby-standalone/212/usr/local/lib/ruby/2.1.0/net/ftp.rb#L776-L782
|
17,287
|
rhomobile/rhodes
|
res/build-tools/ruby-standalone/212/usr/local/lib/ruby/2.1.0/net/ftp.rb
|
Net.FTP.delete
|
def delete(filename)
resp = sendcmd("DELE " + filename)
if resp[0, 3] == "250"
return
elsif resp[0] == ?5
raise FTPPermError, resp
else
raise FTPReplyError, resp
end
end
|
ruby
|
def delete(filename)
resp = sendcmd("DELE " + filename)
if resp[0, 3] == "250"
return
elsif resp[0] == ?5
raise FTPPermError, resp
else
raise FTPReplyError, resp
end
end
|
[
"def",
"delete",
"(",
"filename",
")",
"resp",
"=",
"sendcmd",
"(",
"\"DELE \"",
"+",
"filename",
")",
"if",
"resp",
"[",
"0",
",",
"3",
"]",
"==",
"\"250\"",
"return",
"elsif",
"resp",
"[",
"0",
"]",
"==",
"?5",
"raise",
"FTPPermError",
",",
"resp",
"else",
"raise",
"FTPReplyError",
",",
"resp",
"end",
"end"
] |
Deletes a file on the server.
|
[
"Deletes",
"a",
"file",
"on",
"the",
"server",
"."
] |
3c5f87b1a44f0ba2865ca0e1dd780dd202f64872
|
https://github.com/rhomobile/rhodes/blob/3c5f87b1a44f0ba2865ca0e1dd780dd202f64872/res/build-tools/ruby-standalone/212/usr/local/lib/ruby/2.1.0/net/ftp.rb#L787-L796
|
17,288
|
rhomobile/rhodes
|
res/build-tools/ruby-standalone/212/usr/local/lib/ruby/2.1.0/webrick/cgi.rb
|
WEBrick.CGI.start
|
def start(env=ENV, stdin=$stdin, stdout=$stdout)
sock = WEBrick::CGI::Socket.new(@config, env, stdin, stdout)
req = HTTPRequest.new(@config)
res = HTTPResponse.new(@config)
unless @config[:NPH] or defined?(MOD_RUBY)
def res.setup_header
unless @header["status"]
phrase = HTTPStatus::reason_phrase(@status)
@header["status"] = "#{@status} #{phrase}"
end
super
end
def res.status_line
""
end
end
begin
req.parse(sock)
req.script_name = (env["SCRIPT_NAME"] || File.expand_path($0)).dup
req.path_info = (env["PATH_INFO"] || "").dup
req.query_string = env["QUERY_STRING"]
req.user = env["REMOTE_USER"]
res.request_method = req.request_method
res.request_uri = req.request_uri
res.request_http_version = req.http_version
res.keep_alive = req.keep_alive?
self.service(req, res)
rescue HTTPStatus::Error => ex
res.set_error(ex)
rescue HTTPStatus::Status => ex
res.status = ex.code
rescue Exception => ex
@logger.error(ex)
res.set_error(ex, true)
ensure
req.fixup
if defined?(MOD_RUBY)
res.setup_header
Apache.request.status_line = "#{res.status} #{res.reason_phrase}"
Apache.request.status = res.status
table = Apache.request.headers_out
res.header.each{|key, val|
case key
when /^content-encoding$/i
Apache::request.content_encoding = val
when /^content-type$/i
Apache::request.content_type = val
else
table[key] = val.to_s
end
}
res.cookies.each{|cookie|
table.add("Set-Cookie", cookie.to_s)
}
Apache.request.send_http_header
res.send_body(sock)
else
res.send_response(sock)
end
end
end
|
ruby
|
def start(env=ENV, stdin=$stdin, stdout=$stdout)
sock = WEBrick::CGI::Socket.new(@config, env, stdin, stdout)
req = HTTPRequest.new(@config)
res = HTTPResponse.new(@config)
unless @config[:NPH] or defined?(MOD_RUBY)
def res.setup_header
unless @header["status"]
phrase = HTTPStatus::reason_phrase(@status)
@header["status"] = "#{@status} #{phrase}"
end
super
end
def res.status_line
""
end
end
begin
req.parse(sock)
req.script_name = (env["SCRIPT_NAME"] || File.expand_path($0)).dup
req.path_info = (env["PATH_INFO"] || "").dup
req.query_string = env["QUERY_STRING"]
req.user = env["REMOTE_USER"]
res.request_method = req.request_method
res.request_uri = req.request_uri
res.request_http_version = req.http_version
res.keep_alive = req.keep_alive?
self.service(req, res)
rescue HTTPStatus::Error => ex
res.set_error(ex)
rescue HTTPStatus::Status => ex
res.status = ex.code
rescue Exception => ex
@logger.error(ex)
res.set_error(ex, true)
ensure
req.fixup
if defined?(MOD_RUBY)
res.setup_header
Apache.request.status_line = "#{res.status} #{res.reason_phrase}"
Apache.request.status = res.status
table = Apache.request.headers_out
res.header.each{|key, val|
case key
when /^content-encoding$/i
Apache::request.content_encoding = val
when /^content-type$/i
Apache::request.content_type = val
else
table[key] = val.to_s
end
}
res.cookies.each{|cookie|
table.add("Set-Cookie", cookie.to_s)
}
Apache.request.send_http_header
res.send_body(sock)
else
res.send_response(sock)
end
end
end
|
[
"def",
"start",
"(",
"env",
"=",
"ENV",
",",
"stdin",
"=",
"$stdin",
",",
"stdout",
"=",
"$stdout",
")",
"sock",
"=",
"WEBrick",
"::",
"CGI",
"::",
"Socket",
".",
"new",
"(",
"@config",
",",
"env",
",",
"stdin",
",",
"stdout",
")",
"req",
"=",
"HTTPRequest",
".",
"new",
"(",
"@config",
")",
"res",
"=",
"HTTPResponse",
".",
"new",
"(",
"@config",
")",
"unless",
"@config",
"[",
":NPH",
"]",
"or",
"defined?",
"(",
"MOD_RUBY",
")",
"def",
"res",
".",
"setup_header",
"unless",
"@header",
"[",
"\"status\"",
"]",
"phrase",
"=",
"HTTPStatus",
"::",
"reason_phrase",
"(",
"@status",
")",
"@header",
"[",
"\"status\"",
"]",
"=",
"\"#{@status} #{phrase}\"",
"end",
"super",
"end",
"def",
"res",
".",
"status_line",
"\"\"",
"end",
"end",
"begin",
"req",
".",
"parse",
"(",
"sock",
")",
"req",
".",
"script_name",
"=",
"(",
"env",
"[",
"\"SCRIPT_NAME\"",
"]",
"||",
"File",
".",
"expand_path",
"(",
"$0",
")",
")",
".",
"dup",
"req",
".",
"path_info",
"=",
"(",
"env",
"[",
"\"PATH_INFO\"",
"]",
"||",
"\"\"",
")",
".",
"dup",
"req",
".",
"query_string",
"=",
"env",
"[",
"\"QUERY_STRING\"",
"]",
"req",
".",
"user",
"=",
"env",
"[",
"\"REMOTE_USER\"",
"]",
"res",
".",
"request_method",
"=",
"req",
".",
"request_method",
"res",
".",
"request_uri",
"=",
"req",
".",
"request_uri",
"res",
".",
"request_http_version",
"=",
"req",
".",
"http_version",
"res",
".",
"keep_alive",
"=",
"req",
".",
"keep_alive?",
"self",
".",
"service",
"(",
"req",
",",
"res",
")",
"rescue",
"HTTPStatus",
"::",
"Error",
"=>",
"ex",
"res",
".",
"set_error",
"(",
"ex",
")",
"rescue",
"HTTPStatus",
"::",
"Status",
"=>",
"ex",
"res",
".",
"status",
"=",
"ex",
".",
"code",
"rescue",
"Exception",
"=>",
"ex",
"@logger",
".",
"error",
"(",
"ex",
")",
"res",
".",
"set_error",
"(",
"ex",
",",
"true",
")",
"ensure",
"req",
".",
"fixup",
"if",
"defined?",
"(",
"MOD_RUBY",
")",
"res",
".",
"setup_header",
"Apache",
".",
"request",
".",
"status_line",
"=",
"\"#{res.status} #{res.reason_phrase}\"",
"Apache",
".",
"request",
".",
"status",
"=",
"res",
".",
"status",
"table",
"=",
"Apache",
".",
"request",
".",
"headers_out",
"res",
".",
"header",
".",
"each",
"{",
"|",
"key",
",",
"val",
"|",
"case",
"key",
"when",
"/",
"/i",
"Apache",
"::",
"request",
".",
"content_encoding",
"=",
"val",
"when",
"/",
"/i",
"Apache",
"::",
"request",
".",
"content_type",
"=",
"val",
"else",
"table",
"[",
"key",
"]",
"=",
"val",
".",
"to_s",
"end",
"}",
"res",
".",
"cookies",
".",
"each",
"{",
"|",
"cookie",
"|",
"table",
".",
"add",
"(",
"\"Set-Cookie\"",
",",
"cookie",
".",
"to_s",
")",
"}",
"Apache",
".",
"request",
".",
"send_http_header",
"res",
".",
"send_body",
"(",
"sock",
")",
"else",
"res",
".",
"send_response",
"(",
"sock",
")",
"end",
"end",
"end"
] |
Starts the CGI process with the given environment +env+ and standard
input and output +stdin+ and +stdout+.
|
[
"Starts",
"the",
"CGI",
"process",
"with",
"the",
"given",
"environment",
"+",
"env",
"+",
"and",
"standard",
"input",
"and",
"output",
"+",
"stdin",
"+",
"and",
"+",
"stdout",
"+",
"."
] |
3c5f87b1a44f0ba2865ca0e1dd780dd202f64872
|
https://github.com/rhomobile/rhodes/blob/3c5f87b1a44f0ba2865ca0e1dd780dd202f64872/res/build-tools/ruby-standalone/212/usr/local/lib/ruby/2.1.0/webrick/cgi.rb#L89-L150
|
17,289
|
rhomobile/rhodes
|
res/build-tools/ruby-standalone/212/usr/local/lib/ruby/gems/2.1.0/gems/templater-1.0.0/lib/templater/manifold.rb
|
Templater.Manifold.remove
|
def remove(name)
public_generators.delete(name.to_sym)
private_generators.delete(name.to_sym)
end
|
ruby
|
def remove(name)
public_generators.delete(name.to_sym)
private_generators.delete(name.to_sym)
end
|
[
"def",
"remove",
"(",
"name",
")",
"public_generators",
".",
"delete",
"(",
"name",
".",
"to_sym",
")",
"private_generators",
".",
"delete",
"(",
"name",
".",
"to_sym",
")",
"end"
] |
Remove the generator with the given name from the manifold
=== Parameters
name<Symbol>:: The name of the generator to be removed.
|
[
"Remove",
"the",
"generator",
"with",
"the",
"given",
"name",
"from",
"the",
"manifold"
] |
3c5f87b1a44f0ba2865ca0e1dd780dd202f64872
|
https://github.com/rhomobile/rhodes/blob/3c5f87b1a44f0ba2865ca0e1dd780dd202f64872/res/build-tools/ruby-standalone/212/usr/local/lib/ruby/gems/2.1.0/gems/templater-1.0.0/lib/templater/manifold.rb#L56-L59
|
17,290
|
rhomobile/rhodes
|
res/build-tools/ruby-standalone/212/usr/local/lib/ruby/gems/2.1.0/gems/templater-1.0.0/lib/templater/manifold.rb
|
Templater.Manifold.run_cli
|
def run_cli(destination_root, name, version, args)
Templater::CLI::Manifold.run(destination_root, self, name, version, args)
end
|
ruby
|
def run_cli(destination_root, name, version, args)
Templater::CLI::Manifold.run(destination_root, self, name, version, args)
end
|
[
"def",
"run_cli",
"(",
"destination_root",
",",
"name",
",",
"version",
",",
"args",
")",
"Templater",
"::",
"CLI",
"::",
"Manifold",
".",
"run",
"(",
"destination_root",
",",
"self",
",",
"name",
",",
"version",
",",
"args",
")",
"end"
] |
A Shortcut method for invoking the command line interface provided with Templater.
=== Parameters
destination_root<String>:: Where the generated files should be put, this would usually be Dir.pwd
name<String>:: The name of the executable running this generator (such as 'merb-gen')
version<String>:: The version number of the executable.
args<Array[String]>:: An array of arguments to pass into the generator. This would usually be ARGV
|
[
"A",
"Shortcut",
"method",
"for",
"invoking",
"the",
"command",
"line",
"interface",
"provided",
"with",
"Templater",
"."
] |
3c5f87b1a44f0ba2865ca0e1dd780dd202f64872
|
https://github.com/rhomobile/rhodes/blob/3c5f87b1a44f0ba2865ca0e1dd780dd202f64872/res/build-tools/ruby-standalone/212/usr/local/lib/ruby/gems/2.1.0/gems/templater-1.0.0/lib/templater/manifold.rb#L79-L81
|
17,291
|
rhomobile/rhodes
|
lib/framework/rhom/rhom_object.rb
|
Rhom.RhomObject.djb_hash
|
def djb_hash(str, len)
hash = 5381
for i in (0..len)
hash = ((hash << 5) + hash) + str[i].to_i
end
return hash
end
|
ruby
|
def djb_hash(str, len)
hash = 5381
for i in (0..len)
hash = ((hash << 5) + hash) + str[i].to_i
end
return hash
end
|
[
"def",
"djb_hash",
"(",
"str",
",",
"len",
")",
"hash",
"=",
"5381",
"for",
"i",
"in",
"(",
"0",
"..",
"len",
")",
"hash",
"=",
"(",
"(",
"hash",
"<<",
"5",
")",
"+",
"hash",
")",
"+",
"str",
"[",
"i",
"]",
".",
"to_i",
"end",
"return",
"hash",
"end"
] |
use djb hash function to generate temp object id
|
[
"use",
"djb",
"hash",
"function",
"to",
"generate",
"temp",
"object",
"id"
] |
3c5f87b1a44f0ba2865ca0e1dd780dd202f64872
|
https://github.com/rhomobile/rhodes/blob/3c5f87b1a44f0ba2865ca0e1dd780dd202f64872/lib/framework/rhom/rhom_object.rb#L34-L40
|
17,292
|
rhomobile/rhodes
|
lib/extensions/rexml/rexml/namespace.rb
|
REXML.Namespace.has_name?
|
def has_name?( other, ns=nil )
if ns
return (namespace() == ns and name() == other)
elsif other.include? ":"
return fully_expanded_name == other
else
return name == other
end
end
|
ruby
|
def has_name?( other, ns=nil )
if ns
return (namespace() == ns and name() == other)
elsif other.include? ":"
return fully_expanded_name == other
else
return name == other
end
end
|
[
"def",
"has_name?",
"(",
"other",
",",
"ns",
"=",
"nil",
")",
"if",
"ns",
"return",
"(",
"namespace",
"(",
")",
"==",
"ns",
"and",
"name",
"(",
")",
"==",
"other",
")",
"elsif",
"other",
".",
"include?",
"\":\"",
"return",
"fully_expanded_name",
"==",
"other",
"else",
"return",
"name",
"==",
"other",
"end",
"end"
] |
Compares names optionally WITH namespaces
|
[
"Compares",
"names",
"optionally",
"WITH",
"namespaces"
] |
3c5f87b1a44f0ba2865ca0e1dd780dd202f64872
|
https://github.com/rhomobile/rhodes/blob/3c5f87b1a44f0ba2865ca0e1dd780dd202f64872/lib/extensions/rexml/rexml/namespace.rb#L27-L35
|
17,293
|
rhomobile/rhodes
|
res/build-tools/ruby-standalone/212/usr/local/lib/ruby/2.1.0/webrick/httprequest.rb
|
WEBrick.HTTPRequest.each
|
def each
if @header
@header.each{|k, v|
value = @header[k]
yield(k, value.empty? ? nil : value.join(", "))
}
end
end
|
ruby
|
def each
if @header
@header.each{|k, v|
value = @header[k]
yield(k, value.empty? ? nil : value.join(", "))
}
end
end
|
[
"def",
"each",
"if",
"@header",
"@header",
".",
"each",
"{",
"|",
"k",
",",
"v",
"|",
"value",
"=",
"@header",
"[",
"k",
"]",
"yield",
"(",
"k",
",",
"value",
".",
"empty?",
"?",
"nil",
":",
"value",
".",
"join",
"(",
"\", \"",
")",
")",
"}",
"end",
"end"
] |
Iterates over the request headers
|
[
"Iterates",
"over",
"the",
"request",
"headers"
] |
3c5f87b1a44f0ba2865ca0e1dd780dd202f64872
|
https://github.com/rhomobile/rhodes/blob/3c5f87b1a44f0ba2865ca0e1dd780dd202f64872/res/build-tools/ruby-standalone/212/usr/local/lib/ruby/2.1.0/webrick/httprequest.rb#L296-L303
|
17,294
|
rhomobile/rhodes
|
res/build-tools/ruby-standalone/212/usr/local/lib/ruby/2.1.0/webrick/httprequest.rb
|
WEBrick.HTTPRequest.fixup
|
def fixup() # :nodoc:
begin
body{|chunk| } # read remaining body
rescue HTTPStatus::Error => ex
@logger.error("HTTPRequest#fixup: #{ex.class} occurred.")
@keep_alive = false
rescue => ex
@logger.error(ex)
@keep_alive = false
end
end
|
ruby
|
def fixup() # :nodoc:
begin
body{|chunk| } # read remaining body
rescue HTTPStatus::Error => ex
@logger.error("HTTPRequest#fixup: #{ex.class} occurred.")
@keep_alive = false
rescue => ex
@logger.error(ex)
@keep_alive = false
end
end
|
[
"def",
"fixup",
"(",
")",
"# :nodoc:",
"begin",
"body",
"{",
"|",
"chunk",
"|",
"}",
"# read remaining body",
"rescue",
"HTTPStatus",
"::",
"Error",
"=>",
"ex",
"@logger",
".",
"error",
"(",
"\"HTTPRequest#fixup: #{ex.class} occurred.\"",
")",
"@keep_alive",
"=",
"false",
"rescue",
"=>",
"ex",
"@logger",
".",
"error",
"(",
"ex",
")",
"@keep_alive",
"=",
"false",
"end",
"end"
] |
Consumes any remaining body and updates keep-alive status
|
[
"Consumes",
"any",
"remaining",
"body",
"and",
"updates",
"keep",
"-",
"alive",
"status"
] |
3c5f87b1a44f0ba2865ca0e1dd780dd202f64872
|
https://github.com/rhomobile/rhodes/blob/3c5f87b1a44f0ba2865ca0e1dd780dd202f64872/res/build-tools/ruby-standalone/212/usr/local/lib/ruby/2.1.0/webrick/httprequest.rb#L358-L368
|
17,295
|
rhomobile/rhodes
|
res/build-tools/ruby-standalone/212/usr/local/lib/ruby/2.1.0/webrick/accesslog.rb
|
WEBrick.AccessLog.format
|
def format(format_string, params)
format_string.gsub(/\%(?:\{(.*?)\})?>?([a-zA-Z%])/){
param, spec = $1, $2
case spec[0]
when ?e, ?i, ?n, ?o
raise AccessLogError,
"parameter is required for \"#{spec}\"" unless param
(param = params[spec][param]) ? escape(param) : "-"
when ?t
params[spec].strftime(param || CLF_TIME_FORMAT)
when ?p
case param
when 'remote'
escape(params["i"].peeraddr[1].to_s)
else
escape(params["p"].to_s)
end
when ?%
"%"
else
escape(params[spec].to_s)
end
}
end
|
ruby
|
def format(format_string, params)
format_string.gsub(/\%(?:\{(.*?)\})?>?([a-zA-Z%])/){
param, spec = $1, $2
case spec[0]
when ?e, ?i, ?n, ?o
raise AccessLogError,
"parameter is required for \"#{spec}\"" unless param
(param = params[spec][param]) ? escape(param) : "-"
when ?t
params[spec].strftime(param || CLF_TIME_FORMAT)
when ?p
case param
when 'remote'
escape(params["i"].peeraddr[1].to_s)
else
escape(params["p"].to_s)
end
when ?%
"%"
else
escape(params[spec].to_s)
end
}
end
|
[
"def",
"format",
"(",
"format_string",
",",
"params",
")",
"format_string",
".",
"gsub",
"(",
"/",
"\\%",
"\\{",
"\\}",
"/",
")",
"{",
"param",
",",
"spec",
"=",
"$1",
",",
"$2",
"case",
"spec",
"[",
"0",
"]",
"when",
"?e",
",",
"?i",
",",
"?n",
",",
"?o",
"raise",
"AccessLogError",
",",
"\"parameter is required for \\\"#{spec}\\\"\"",
"unless",
"param",
"(",
"param",
"=",
"params",
"[",
"spec",
"]",
"[",
"param",
"]",
")",
"?",
"escape",
"(",
"param",
")",
":",
"\"-\"",
"when",
"?t",
"params",
"[",
"spec",
"]",
".",
"strftime",
"(",
"param",
"||",
"CLF_TIME_FORMAT",
")",
"when",
"?p",
"case",
"param",
"when",
"'remote'",
"escape",
"(",
"params",
"[",
"\"i\"",
"]",
".",
"peeraddr",
"[",
"1",
"]",
".",
"to_s",
")",
"else",
"escape",
"(",
"params",
"[",
"\"p\"",
"]",
".",
"to_s",
")",
"end",
"when",
"?%",
"\"%\"",
"else",
"escape",
"(",
"params",
"[",
"spec",
"]",
".",
"to_s",
")",
"end",
"}",
"end"
] |
Formats +params+ according to +format_string+ which is described in
setup_params.
|
[
"Formats",
"+",
"params",
"+",
"according",
"to",
"+",
"format_string",
"+",
"which",
"is",
"described",
"in",
"setup_params",
"."
] |
3c5f87b1a44f0ba2865ca0e1dd780dd202f64872
|
https://github.com/rhomobile/rhodes/blob/3c5f87b1a44f0ba2865ca0e1dd780dd202f64872/res/build-tools/ruby-standalone/212/usr/local/lib/ruby/2.1.0/webrick/accesslog.rb#L122-L145
|
17,296
|
rhomobile/rhodes
|
res/build-tools/ruby-standalone/212/usr/local/lib/ruby/2.1.0/rake/application.rb
|
Rake.Application.run_with_threads
|
def run_with_threads
thread_pool.gather_history if options.job_stats == :history
yield
thread_pool.join
if options.job_stats
stats = thread_pool.statistics
puts "Maximum active threads: #{stats[:max_active_threads]}"
puts "Total threads in play: #{stats[:total_threads_in_play]}"
end
ThreadHistoryDisplay.new(thread_pool.history).show if
options.job_stats == :history
end
|
ruby
|
def run_with_threads
thread_pool.gather_history if options.job_stats == :history
yield
thread_pool.join
if options.job_stats
stats = thread_pool.statistics
puts "Maximum active threads: #{stats[:max_active_threads]}"
puts "Total threads in play: #{stats[:total_threads_in_play]}"
end
ThreadHistoryDisplay.new(thread_pool.history).show if
options.job_stats == :history
end
|
[
"def",
"run_with_threads",
"thread_pool",
".",
"gather_history",
"if",
"options",
".",
"job_stats",
"==",
":history",
"yield",
"thread_pool",
".",
"join",
"if",
"options",
".",
"job_stats",
"stats",
"=",
"thread_pool",
".",
"statistics",
"puts",
"\"Maximum active threads: #{stats[:max_active_threads]}\"",
"puts",
"\"Total threads in play: #{stats[:total_threads_in_play]}\"",
"end",
"ThreadHistoryDisplay",
".",
"new",
"(",
"thread_pool",
".",
"history",
")",
".",
"show",
"if",
"options",
".",
"job_stats",
"==",
":history",
"end"
] |
Run the given block with the thread startup and shutdown.
|
[
"Run",
"the",
"given",
"block",
"with",
"the",
"thread",
"startup",
"and",
"shutdown",
"."
] |
3c5f87b1a44f0ba2865ca0e1dd780dd202f64872
|
https://github.com/rhomobile/rhodes/blob/3c5f87b1a44f0ba2865ca0e1dd780dd202f64872/res/build-tools/ruby-standalone/212/usr/local/lib/ruby/2.1.0/rake/application.rb#L112-L125
|
17,297
|
rhomobile/rhodes
|
res/build-tools/ruby-standalone/212/usr/local/lib/ruby/2.1.0/rake/application.rb
|
Rake.Application.standard_exception_handling
|
def standard_exception_handling
yield
rescue SystemExit
# Exit silently with current status
raise
rescue OptionParser::InvalidOption => ex
$stderr.puts ex.message
exit(false)
rescue Exception => ex
# Exit with error message
display_error_message(ex)
exit_because_of_exception(ex)
end
|
ruby
|
def standard_exception_handling
yield
rescue SystemExit
# Exit silently with current status
raise
rescue OptionParser::InvalidOption => ex
$stderr.puts ex.message
exit(false)
rescue Exception => ex
# Exit with error message
display_error_message(ex)
exit_because_of_exception(ex)
end
|
[
"def",
"standard_exception_handling",
"yield",
"rescue",
"SystemExit",
"# Exit silently with current status",
"raise",
"rescue",
"OptionParser",
"::",
"InvalidOption",
"=>",
"ex",
"$stderr",
".",
"puts",
"ex",
".",
"message",
"exit",
"(",
"false",
")",
"rescue",
"Exception",
"=>",
"ex",
"# Exit with error message",
"display_error_message",
"(",
"ex",
")",
"exit_because_of_exception",
"(",
"ex",
")",
"end"
] |
Provide standard exception handling for the given block.
|
[
"Provide",
"standard",
"exception",
"handling",
"for",
"the",
"given",
"block",
"."
] |
3c5f87b1a44f0ba2865ca0e1dd780dd202f64872
|
https://github.com/rhomobile/rhodes/blob/3c5f87b1a44f0ba2865ca0e1dd780dd202f64872/res/build-tools/ruby-standalone/212/usr/local/lib/ruby/2.1.0/rake/application.rb#L164-L176
|
17,298
|
rhomobile/rhodes
|
res/build-tools/ruby-standalone/212/usr/local/lib/ruby/2.1.0/rake/application.rb
|
Rake.Application.display_prerequisites
|
def display_prerequisites
tasks.each do |t|
puts "#{name} #{t.name}"
t.prerequisites.each { |pre| puts " #{pre}" }
end
end
|
ruby
|
def display_prerequisites
tasks.each do |t|
puts "#{name} #{t.name}"
t.prerequisites.each { |pre| puts " #{pre}" }
end
end
|
[
"def",
"display_prerequisites",
"tasks",
".",
"each",
"do",
"|",
"t",
"|",
"puts",
"\"#{name} #{t.name}\"",
"t",
".",
"prerequisites",
".",
"each",
"{",
"|",
"pre",
"|",
"puts",
"\" #{pre}\"",
"}",
"end",
"end"
] |
Display the tasks and prerequisites
|
[
"Display",
"the",
"tasks",
"and",
"prerequisites"
] |
3c5f87b1a44f0ba2865ca0e1dd780dd202f64872
|
https://github.com/rhomobile/rhodes/blob/3c5f87b1a44f0ba2865ca0e1dd780dd202f64872/res/build-tools/ruby-standalone/212/usr/local/lib/ruby/2.1.0/rake/application.rb#L331-L336
|
17,299
|
rhomobile/rhodes
|
res/build-tools/ruby-standalone/212/usr/local/lib/ruby/gems/2.1.0/gems/templater-1.0.0/lib/templater/generator.rb
|
Templater.Generator.invocations
|
def invocations
return [] unless self.class.manifold
self.class.invocations.map do |invocation|
invocation.get(self) if match_options?(invocation.options)
end.compact
end
|
ruby
|
def invocations
return [] unless self.class.manifold
self.class.invocations.map do |invocation|
invocation.get(self) if match_options?(invocation.options)
end.compact
end
|
[
"def",
"invocations",
"return",
"[",
"]",
"unless",
"self",
".",
"class",
".",
"manifold",
"self",
".",
"class",
".",
"invocations",
".",
"map",
"do",
"|",
"invocation",
"|",
"invocation",
".",
"get",
"(",
"self",
")",
"if",
"match_options?",
"(",
"invocation",
".",
"options",
")",
"end",
".",
"compact",
"end"
] |
Finds and returns all templates whose options match the generator options.
=== Returns
[Templater::Generator]:: The found templates.
|
[
"Finds",
"and",
"returns",
"all",
"templates",
"whose",
"options",
"match",
"the",
"generator",
"options",
"."
] |
3c5f87b1a44f0ba2865ca0e1dd780dd202f64872
|
https://github.com/rhomobile/rhodes/blob/3c5f87b1a44f0ba2865ca0e1dd780dd202f64872/res/build-tools/ruby-standalone/212/usr/local/lib/ruby/gems/2.1.0/gems/templater-1.0.0/lib/templater/generator.rb#L534-L540
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.