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,500
|
mdp/gibberish
|
lib/gibberish/rsa.rb
|
Gibberish.RSA.decrypt
|
def decrypt(data, opts={})
data = data.to_s
raise "No private key set!" unless @key.private?
unless opts[:binary]
data = Base64.decode64(data)
end
@key.private_decrypt(data)
end
|
ruby
|
def decrypt(data, opts={})
data = data.to_s
raise "No private key set!" unless @key.private?
unless opts[:binary]
data = Base64.decode64(data)
end
@key.private_decrypt(data)
end
|
[
"def",
"decrypt",
"(",
"data",
",",
"opts",
"=",
"{",
"}",
")",
"data",
"=",
"data",
".",
"to_s",
"raise",
"\"No private key set!\"",
"unless",
"@key",
".",
"private?",
"unless",
"opts",
"[",
":binary",
"]",
"data",
"=",
"Base64",
".",
"decode64",
"(",
"data",
")",
"end",
"@key",
".",
"private_decrypt",
"(",
"data",
")",
"end"
] |
Decrypt data using the key
@param [#to_s] data
@param [Hash] opts
@option opts [Boolean] :binary (false) don't decode the data as Base64
|
[
"Decrypt",
"data",
"using",
"the",
"key"
] |
707bfc1f6c4ab17df8a980a9e2b80970768a41c6
|
https://github.com/mdp/gibberish/blob/707bfc1f6c4ab17df8a980a9e2b80970768a41c6/lib/gibberish/rsa.rb#L102-L109
|
17,501
|
fabrik42/acts_as_api
|
lib/acts_as_api/base.rb
|
ActsAsApi.Base.acts_as_api
|
def acts_as_api
class_eval do
include ActsAsApi::Base::InstanceMethods
extend ActsAsApi::Base::ClassMethods
end
if block_given?
yield ActsAsApi::Config
end
end
|
ruby
|
def acts_as_api
class_eval do
include ActsAsApi::Base::InstanceMethods
extend ActsAsApi::Base::ClassMethods
end
if block_given?
yield ActsAsApi::Config
end
end
|
[
"def",
"acts_as_api",
"class_eval",
"do",
"include",
"ActsAsApi",
"::",
"Base",
"::",
"InstanceMethods",
"extend",
"ActsAsApi",
"::",
"Base",
"::",
"ClassMethods",
"end",
"if",
"block_given?",
"yield",
"ActsAsApi",
"::",
"Config",
"end",
"end"
] |
When invoked, it enriches the current model with the
class and instance methods to act as api.
|
[
"When",
"invoked",
"it",
"enriches",
"the",
"current",
"model",
"with",
"the",
"class",
"and",
"instance",
"methods",
"to",
"act",
"as",
"api",
"."
] |
874ccfbcd5efcd90b6b56ec126b07c053675901e
|
https://github.com/fabrik42/acts_as_api/blob/874ccfbcd5efcd90b6b56ec126b07c053675901e/lib/acts_as_api/base.rb#L12-L21
|
17,502
|
fabrik42/acts_as_api
|
lib/acts_as_api/api_template.rb
|
ActsAsApi.ApiTemplate.add
|
def add(val, options = {})
item_key = (options[:as] || val).to_sym
self[item_key] = val
@options[item_key] = options
end
|
ruby
|
def add(val, options = {})
item_key = (options[:as] || val).to_sym
self[item_key] = val
@options[item_key] = options
end
|
[
"def",
"add",
"(",
"val",
",",
"options",
"=",
"{",
"}",
")",
"item_key",
"=",
"(",
"options",
"[",
":as",
"]",
"||",
"val",
")",
".",
"to_sym",
"self",
"[",
"item_key",
"]",
"=",
"val",
"@options",
"[",
"item_key",
"]",
"=",
"options",
"end"
] |
Adds a field to the api template
The value passed can be one of the following:
* Symbol - the method with the same name will be called on the model when rendering.
* String - must be in the form "method1.method2.method3", will call this method chain.
* Hash - will be added as a sub hash and all its items will be resolved the way described above.
Possible options to pass:
* :template - Determine the template that should be used to render the item if it is
+api_accessible+ itself.
|
[
"Adds",
"a",
"field",
"to",
"the",
"api",
"template"
] |
874ccfbcd5efcd90b6b56ec126b07c053675901e
|
https://github.com/fabrik42/acts_as_api/blob/874ccfbcd5efcd90b6b56ec126b07c053675901e/lib/acts_as_api/api_template.rb#L36-L42
|
17,503
|
fabrik42/acts_as_api
|
lib/acts_as_api/api_template.rb
|
ActsAsApi.ApiTemplate.allowed_to_render?
|
def allowed_to_render?(fieldset, field, model, options)
return true unless fieldset.is_a? ActsAsApi::ApiTemplate
fieldset_options = fieldset.options_for(field)
if fieldset_options[:unless]
!(condition_fulfilled?(model, fieldset_options[:unless], options))
elsif fieldset_options[:if]
condition_fulfilled?(model, fieldset_options[:if], options)
else
true
end
end
|
ruby
|
def allowed_to_render?(fieldset, field, model, options)
return true unless fieldset.is_a? ActsAsApi::ApiTemplate
fieldset_options = fieldset.options_for(field)
if fieldset_options[:unless]
!(condition_fulfilled?(model, fieldset_options[:unless], options))
elsif fieldset_options[:if]
condition_fulfilled?(model, fieldset_options[:if], options)
else
true
end
end
|
[
"def",
"allowed_to_render?",
"(",
"fieldset",
",",
"field",
",",
"model",
",",
"options",
")",
"return",
"true",
"unless",
"fieldset",
".",
"is_a?",
"ActsAsApi",
"::",
"ApiTemplate",
"fieldset_options",
"=",
"fieldset",
".",
"options_for",
"(",
"field",
")",
"if",
"fieldset_options",
"[",
":unless",
"]",
"!",
"(",
"condition_fulfilled?",
"(",
"model",
",",
"fieldset_options",
"[",
":unless",
"]",
",",
"options",
")",
")",
"elsif",
"fieldset_options",
"[",
":if",
"]",
"condition_fulfilled?",
"(",
"model",
",",
"fieldset_options",
"[",
":if",
"]",
",",
"options",
")",
"else",
"true",
"end",
"end"
] |
Decides if the passed item should be added to
the response based on the conditional options passed.
|
[
"Decides",
"if",
"the",
"passed",
"item",
"should",
"be",
"added",
"to",
"the",
"response",
"based",
"on",
"the",
"conditional",
"options",
"passed",
"."
] |
874ccfbcd5efcd90b6b56ec126b07c053675901e
|
https://github.com/fabrik42/acts_as_api/blob/874ccfbcd5efcd90b6b56ec126b07c053675901e/lib/acts_as_api/api_template.rb#L67-L79
|
17,504
|
fabrik42/acts_as_api
|
lib/acts_as_api/api_template.rb
|
ActsAsApi.ApiTemplate.to_response_hash
|
def to_response_hash(model, fieldset = self, options = {})
api_output = {}
fieldset.each do |field, value|
next unless allowed_to_render?(fieldset, field, model, options)
out = process_value(model, value, options)
if out.respond_to?(:as_api_response)
sub_template = api_template_for(fieldset, field)
out = out.as_api_response(sub_template, options)
end
api_output[field] = out
end
api_output
end
|
ruby
|
def to_response_hash(model, fieldset = self, options = {})
api_output = {}
fieldset.each do |field, value|
next unless allowed_to_render?(fieldset, field, model, options)
out = process_value(model, value, options)
if out.respond_to?(:as_api_response)
sub_template = api_template_for(fieldset, field)
out = out.as_api_response(sub_template, options)
end
api_output[field] = out
end
api_output
end
|
[
"def",
"to_response_hash",
"(",
"model",
",",
"fieldset",
"=",
"self",
",",
"options",
"=",
"{",
"}",
")",
"api_output",
"=",
"{",
"}",
"fieldset",
".",
"each",
"do",
"|",
"field",
",",
"value",
"|",
"next",
"unless",
"allowed_to_render?",
"(",
"fieldset",
",",
"field",
",",
"model",
",",
"options",
")",
"out",
"=",
"process_value",
"(",
"model",
",",
"value",
",",
"options",
")",
"if",
"out",
".",
"respond_to?",
"(",
":as_api_response",
")",
"sub_template",
"=",
"api_template_for",
"(",
"fieldset",
",",
"field",
")",
"out",
"=",
"out",
".",
"as_api_response",
"(",
"sub_template",
",",
"options",
")",
"end",
"api_output",
"[",
"field",
"]",
"=",
"out",
"end",
"api_output",
"end"
] |
Generates a hash that represents the api response based on this
template for the passed model instance.
|
[
"Generates",
"a",
"hash",
"that",
"represents",
"the",
"api",
"response",
"based",
"on",
"this",
"template",
"for",
"the",
"passed",
"model",
"instance",
"."
] |
874ccfbcd5efcd90b6b56ec126b07c053675901e
|
https://github.com/fabrik42/acts_as_api/blob/874ccfbcd5efcd90b6b56ec126b07c053675901e/lib/acts_as_api/api_template.rb#L95-L112
|
17,505
|
fabrik42/acts_as_api
|
lib/acts_as_api/rendering.rb
|
ActsAsApi.Rendering.render_for_api
|
def render_for_api(api_template_or_options, render_options)
if api_template_or_options.is_a?(Hash)
api_template = []
api_template << api_template_or_options.delete(:prefix)
api_template << api_template_or_options.delete(:template)
api_template << api_template_or_options.delete(:postfix)
api_template = api_template.reject(&:blank?).join('_')
else
api_template = api_template_or_options
end
# extract the api format and model
api_format_options = {}
ActsAsApi::Config.accepted_api_formats.each do |item|
if render_options.key?(item)
api_format_options[item] = render_options[item]
render_options.delete item
end
end
meta_hash = render_options[:meta] if render_options.key?(:meta)
api_format = api_format_options.keys.first
api_model = api_format_options.values.first
# set the params to render
output_params = render_options
api_root_name = nil
if !output_params[:root].nil?
api_root_name = output_params[:root].to_s
elsif api_model.class.respond_to?(:model_name)
api_root_name = api_model.class.model_name
elsif api_model.respond_to?(:collection_name)
api_root_name = api_model.collection_name
elsif api_model.is_a?(Array) && !api_model.empty? && api_model.first.class.respond_to?(:model_name)
api_root_name = api_model.first.class.model_name
elsif api_model.is_a?(Array) && !api_model.empty? && api_model.first.respond_to?(:model_name)
api_root_name = api_model.first.model_name
elsif api_model.respond_to?(:model_name)
api_root_name = api_model.model_name
else
api_root_name = ActsAsApi::Config.default_root.to_s
end
api_root_name = api_root_name.to_s.underscore.tr('/', '_')
if api_model.is_a?(Array) || (defined?(ActiveRecord) && api_model.is_a?(ActiveRecord::Relation))
api_root_name = api_root_name.pluralize
end
api_root_name = api_root_name.dasherize if ActsAsApi::Config.dasherize_for.include? api_format.to_sym
output_params[:root] = api_root_name
api_response = api_model.as_api_response(api_template)
if api_response.is_a?(Array) && api_format.to_sym == :json && ActsAsApi::Config.include_root_in_json_collections
api_response = api_response.collect { |f| { api_root_name.singularize => f } }
end
if meta_hash || ActsAsApi::Config.add_root_node_for.include?(api_format)
api_response = { api_root_name.to_sym => api_response }
end
api_response = meta_hash.merge api_response if meta_hash
if ActsAsApi::Config.allow_jsonp_callback && params[:callback]
output_params[:callback] = params[:callback]
api_format = :acts_as_api_jsonp if ActsAsApi::Config.add_http_status_to_jsonp_response
end
# create the Hash as response
output_params[api_format] = api_response
render output_params
end
|
ruby
|
def render_for_api(api_template_or_options, render_options)
if api_template_or_options.is_a?(Hash)
api_template = []
api_template << api_template_or_options.delete(:prefix)
api_template << api_template_or_options.delete(:template)
api_template << api_template_or_options.delete(:postfix)
api_template = api_template.reject(&:blank?).join('_')
else
api_template = api_template_or_options
end
# extract the api format and model
api_format_options = {}
ActsAsApi::Config.accepted_api_formats.each do |item|
if render_options.key?(item)
api_format_options[item] = render_options[item]
render_options.delete item
end
end
meta_hash = render_options[:meta] if render_options.key?(:meta)
api_format = api_format_options.keys.first
api_model = api_format_options.values.first
# set the params to render
output_params = render_options
api_root_name = nil
if !output_params[:root].nil?
api_root_name = output_params[:root].to_s
elsif api_model.class.respond_to?(:model_name)
api_root_name = api_model.class.model_name
elsif api_model.respond_to?(:collection_name)
api_root_name = api_model.collection_name
elsif api_model.is_a?(Array) && !api_model.empty? && api_model.first.class.respond_to?(:model_name)
api_root_name = api_model.first.class.model_name
elsif api_model.is_a?(Array) && !api_model.empty? && api_model.first.respond_to?(:model_name)
api_root_name = api_model.first.model_name
elsif api_model.respond_to?(:model_name)
api_root_name = api_model.model_name
else
api_root_name = ActsAsApi::Config.default_root.to_s
end
api_root_name = api_root_name.to_s.underscore.tr('/', '_')
if api_model.is_a?(Array) || (defined?(ActiveRecord) && api_model.is_a?(ActiveRecord::Relation))
api_root_name = api_root_name.pluralize
end
api_root_name = api_root_name.dasherize if ActsAsApi::Config.dasherize_for.include? api_format.to_sym
output_params[:root] = api_root_name
api_response = api_model.as_api_response(api_template)
if api_response.is_a?(Array) && api_format.to_sym == :json && ActsAsApi::Config.include_root_in_json_collections
api_response = api_response.collect { |f| { api_root_name.singularize => f } }
end
if meta_hash || ActsAsApi::Config.add_root_node_for.include?(api_format)
api_response = { api_root_name.to_sym => api_response }
end
api_response = meta_hash.merge api_response if meta_hash
if ActsAsApi::Config.allow_jsonp_callback && params[:callback]
output_params[:callback] = params[:callback]
api_format = :acts_as_api_jsonp if ActsAsApi::Config.add_http_status_to_jsonp_response
end
# create the Hash as response
output_params[api_format] = api_response
render output_params
end
|
[
"def",
"render_for_api",
"(",
"api_template_or_options",
",",
"render_options",
")",
"if",
"api_template_or_options",
".",
"is_a?",
"(",
"Hash",
")",
"api_template",
"=",
"[",
"]",
"api_template",
"<<",
"api_template_or_options",
".",
"delete",
"(",
":prefix",
")",
"api_template",
"<<",
"api_template_or_options",
".",
"delete",
"(",
":template",
")",
"api_template",
"<<",
"api_template_or_options",
".",
"delete",
"(",
":postfix",
")",
"api_template",
"=",
"api_template",
".",
"reject",
"(",
":blank?",
")",
".",
"join",
"(",
"'_'",
")",
"else",
"api_template",
"=",
"api_template_or_options",
"end",
"# extract the api format and model",
"api_format_options",
"=",
"{",
"}",
"ActsAsApi",
"::",
"Config",
".",
"accepted_api_formats",
".",
"each",
"do",
"|",
"item",
"|",
"if",
"render_options",
".",
"key?",
"(",
"item",
")",
"api_format_options",
"[",
"item",
"]",
"=",
"render_options",
"[",
"item",
"]",
"render_options",
".",
"delete",
"item",
"end",
"end",
"meta_hash",
"=",
"render_options",
"[",
":meta",
"]",
"if",
"render_options",
".",
"key?",
"(",
":meta",
")",
"api_format",
"=",
"api_format_options",
".",
"keys",
".",
"first",
"api_model",
"=",
"api_format_options",
".",
"values",
".",
"first",
"# set the params to render",
"output_params",
"=",
"render_options",
"api_root_name",
"=",
"nil",
"if",
"!",
"output_params",
"[",
":root",
"]",
".",
"nil?",
"api_root_name",
"=",
"output_params",
"[",
":root",
"]",
".",
"to_s",
"elsif",
"api_model",
".",
"class",
".",
"respond_to?",
"(",
":model_name",
")",
"api_root_name",
"=",
"api_model",
".",
"class",
".",
"model_name",
"elsif",
"api_model",
".",
"respond_to?",
"(",
":collection_name",
")",
"api_root_name",
"=",
"api_model",
".",
"collection_name",
"elsif",
"api_model",
".",
"is_a?",
"(",
"Array",
")",
"&&",
"!",
"api_model",
".",
"empty?",
"&&",
"api_model",
".",
"first",
".",
"class",
".",
"respond_to?",
"(",
":model_name",
")",
"api_root_name",
"=",
"api_model",
".",
"first",
".",
"class",
".",
"model_name",
"elsif",
"api_model",
".",
"is_a?",
"(",
"Array",
")",
"&&",
"!",
"api_model",
".",
"empty?",
"&&",
"api_model",
".",
"first",
".",
"respond_to?",
"(",
":model_name",
")",
"api_root_name",
"=",
"api_model",
".",
"first",
".",
"model_name",
"elsif",
"api_model",
".",
"respond_to?",
"(",
":model_name",
")",
"api_root_name",
"=",
"api_model",
".",
"model_name",
"else",
"api_root_name",
"=",
"ActsAsApi",
"::",
"Config",
".",
"default_root",
".",
"to_s",
"end",
"api_root_name",
"=",
"api_root_name",
".",
"to_s",
".",
"underscore",
".",
"tr",
"(",
"'/'",
",",
"'_'",
")",
"if",
"api_model",
".",
"is_a?",
"(",
"Array",
")",
"||",
"(",
"defined?",
"(",
"ActiveRecord",
")",
"&&",
"api_model",
".",
"is_a?",
"(",
"ActiveRecord",
"::",
"Relation",
")",
")",
"api_root_name",
"=",
"api_root_name",
".",
"pluralize",
"end",
"api_root_name",
"=",
"api_root_name",
".",
"dasherize",
"if",
"ActsAsApi",
"::",
"Config",
".",
"dasherize_for",
".",
"include?",
"api_format",
".",
"to_sym",
"output_params",
"[",
":root",
"]",
"=",
"api_root_name",
"api_response",
"=",
"api_model",
".",
"as_api_response",
"(",
"api_template",
")",
"if",
"api_response",
".",
"is_a?",
"(",
"Array",
")",
"&&",
"api_format",
".",
"to_sym",
"==",
":json",
"&&",
"ActsAsApi",
"::",
"Config",
".",
"include_root_in_json_collections",
"api_response",
"=",
"api_response",
".",
"collect",
"{",
"|",
"f",
"|",
"{",
"api_root_name",
".",
"singularize",
"=>",
"f",
"}",
"}",
"end",
"if",
"meta_hash",
"||",
"ActsAsApi",
"::",
"Config",
".",
"add_root_node_for",
".",
"include?",
"(",
"api_format",
")",
"api_response",
"=",
"{",
"api_root_name",
".",
"to_sym",
"=>",
"api_response",
"}",
"end",
"api_response",
"=",
"meta_hash",
".",
"merge",
"api_response",
"if",
"meta_hash",
"if",
"ActsAsApi",
"::",
"Config",
".",
"allow_jsonp_callback",
"&&",
"params",
"[",
":callback",
"]",
"output_params",
"[",
":callback",
"]",
"=",
"params",
"[",
":callback",
"]",
"api_format",
"=",
":acts_as_api_jsonp",
"if",
"ActsAsApi",
"::",
"Config",
".",
"add_http_status_to_jsonp_response",
"end",
"# create the Hash as response",
"output_params",
"[",
"api_format",
"]",
"=",
"api_response",
"render",
"output_params",
"end"
] |
Provides an alternative to the +render+ method used within the controller
to simply generate API outputs.
The default Rails serializers are used to serialize the data.
|
[
"Provides",
"an",
"alternative",
"to",
"the",
"+",
"render",
"+",
"method",
"used",
"within",
"the",
"controller",
"to",
"simply",
"generate",
"API",
"outputs",
"."
] |
874ccfbcd5efcd90b6b56ec126b07c053675901e
|
https://github.com/fabrik42/acts_as_api/blob/874ccfbcd5efcd90b6b56ec126b07c053675901e/lib/acts_as_api/rendering.rb#L9-L86
|
17,506
|
fabrik42/acts_as_api
|
lib/acts_as_api/collection.rb
|
ActsAsApi.Collection.as_api_response
|
def as_api_response(api_template, options = {})
collect do |item|
if item.respond_to?(:as_api_response)
item.as_api_response(api_template, options)
else
item
end
end
end
|
ruby
|
def as_api_response(api_template, options = {})
collect do |item|
if item.respond_to?(:as_api_response)
item.as_api_response(api_template, options)
else
item
end
end
end
|
[
"def",
"as_api_response",
"(",
"api_template",
",",
"options",
"=",
"{",
"}",
")",
"collect",
"do",
"|",
"item",
"|",
"if",
"item",
".",
"respond_to?",
"(",
":as_api_response",
")",
"item",
".",
"as_api_response",
"(",
"api_template",
",",
"options",
")",
"else",
"item",
"end",
"end",
"end"
] |
The collection checks all its items if they respond to the +as_api_response+ method.
If they do, the result of this method will be collected.
If they don't, the item itself will be collected.
|
[
"The",
"collection",
"checks",
"all",
"its",
"items",
"if",
"they",
"respond",
"to",
"the",
"+",
"as_api_response",
"+",
"method",
".",
"If",
"they",
"do",
"the",
"result",
"of",
"this",
"method",
"will",
"be",
"collected",
".",
"If",
"they",
"don",
"t",
"the",
"item",
"itself",
"will",
"be",
"collected",
"."
] |
874ccfbcd5efcd90b6b56ec126b07c053675901e
|
https://github.com/fabrik42/acts_as_api/blob/874ccfbcd5efcd90b6b56ec126b07c053675901e/lib/acts_as_api/collection.rb#L6-L14
|
17,507
|
ccocchi/rabl-rails
|
lib/rabl-rails/compiler.rb
|
RablRails.Compiler.condition
|
def condition(proc)
return unless block_given?
@template.add_node Nodes::Condition.new(proc, sub_compile(nil, true) { yield })
end
|
ruby
|
def condition(proc)
return unless block_given?
@template.add_node Nodes::Condition.new(proc, sub_compile(nil, true) { yield })
end
|
[
"def",
"condition",
"(",
"proc",
")",
"return",
"unless",
"block_given?",
"@template",
".",
"add_node",
"Nodes",
"::",
"Condition",
".",
"new",
"(",
"proc",
",",
"sub_compile",
"(",
"nil",
",",
"true",
")",
"{",
"yield",
"}",
")",
"end"
] |
Provide a conditionnal block
condition(->(u) { u.is_a?(Admin) }) do
attributes :secret
end
|
[
"Provide",
"a",
"conditionnal",
"block"
] |
8d4c7eef42b9721e0aa68fece24457368614334f
|
https://github.com/ccocchi/rabl-rails/blob/8d4c7eef42b9721e0aa68fece24457368614334f/lib/rabl-rails/compiler.rb#L160-L163
|
17,508
|
documentcloud/jammit
|
lib/jammit/command_line.rb
|
Jammit.CommandLine.ensure_configuration_file
|
def ensure_configuration_file
config = @options[:config_paths]
return true if File.exists?(config) && File.readable?(config)
puts "Could not find the asset configuration file \"#{config}\""
exit(1)
end
|
ruby
|
def ensure_configuration_file
config = @options[:config_paths]
return true if File.exists?(config) && File.readable?(config)
puts "Could not find the asset configuration file \"#{config}\""
exit(1)
end
|
[
"def",
"ensure_configuration_file",
"config",
"=",
"@options",
"[",
":config_paths",
"]",
"return",
"true",
"if",
"File",
".",
"exists?",
"(",
"config",
")",
"&&",
"File",
".",
"readable?",
"(",
"config",
")",
"puts",
"\"Could not find the asset configuration file \\\"#{config}\\\"\"",
"exit",
"(",
"1",
")",
"end"
] |
Make sure that we have a readable configuration file. The @jammit@
command can't run without one.
|
[
"Make",
"sure",
"that",
"we",
"have",
"a",
"readable",
"configuration",
"file",
".",
"The"
] |
dc866f1ac3eb069d65215599c451db39d66119a7
|
https://github.com/documentcloud/jammit/blob/dc866f1ac3eb069d65215599c451db39d66119a7/lib/jammit/command_line.rb#L37-L42
|
17,509
|
documentcloud/jammit
|
lib/jammit/packager.rb
|
Jammit.Packager.precache_all
|
def precache_all(output_dir=nil, base_url=nil)
output_dir ||= File.join(Jammit.public_root, Jammit.package_path)
cacheable(:js, output_dir).each {|p| cache(p, 'js', pack_javascripts(p), output_dir) }
cacheable(:css, output_dir).each do |p|
cache(p, 'css', pack_stylesheets(p), output_dir)
if Jammit.embed_assets
cache(p, 'css', pack_stylesheets(p, :datauri), output_dir, :datauri)
if Jammit.mhtml_enabled
raise MissingConfiguration, "A --base-url option is required in order to generate MHTML." unless base_url
mtime = latest_mtime package_for(p, :css)[:paths]
asset_url = "#{base_url}#{Jammit.asset_url(p, :css, :mhtml, mtime)}"
cache(p, 'css', pack_stylesheets(p, :mhtml, asset_url), output_dir, :mhtml, mtime)
end
end
end
end
|
ruby
|
def precache_all(output_dir=nil, base_url=nil)
output_dir ||= File.join(Jammit.public_root, Jammit.package_path)
cacheable(:js, output_dir).each {|p| cache(p, 'js', pack_javascripts(p), output_dir) }
cacheable(:css, output_dir).each do |p|
cache(p, 'css', pack_stylesheets(p), output_dir)
if Jammit.embed_assets
cache(p, 'css', pack_stylesheets(p, :datauri), output_dir, :datauri)
if Jammit.mhtml_enabled
raise MissingConfiguration, "A --base-url option is required in order to generate MHTML." unless base_url
mtime = latest_mtime package_for(p, :css)[:paths]
asset_url = "#{base_url}#{Jammit.asset_url(p, :css, :mhtml, mtime)}"
cache(p, 'css', pack_stylesheets(p, :mhtml, asset_url), output_dir, :mhtml, mtime)
end
end
end
end
|
[
"def",
"precache_all",
"(",
"output_dir",
"=",
"nil",
",",
"base_url",
"=",
"nil",
")",
"output_dir",
"||=",
"File",
".",
"join",
"(",
"Jammit",
".",
"public_root",
",",
"Jammit",
".",
"package_path",
")",
"cacheable",
"(",
":js",
",",
"output_dir",
")",
".",
"each",
"{",
"|",
"p",
"|",
"cache",
"(",
"p",
",",
"'js'",
",",
"pack_javascripts",
"(",
"p",
")",
",",
"output_dir",
")",
"}",
"cacheable",
"(",
":css",
",",
"output_dir",
")",
".",
"each",
"do",
"|",
"p",
"|",
"cache",
"(",
"p",
",",
"'css'",
",",
"pack_stylesheets",
"(",
"p",
")",
",",
"output_dir",
")",
"if",
"Jammit",
".",
"embed_assets",
"cache",
"(",
"p",
",",
"'css'",
",",
"pack_stylesheets",
"(",
"p",
",",
":datauri",
")",
",",
"output_dir",
",",
":datauri",
")",
"if",
"Jammit",
".",
"mhtml_enabled",
"raise",
"MissingConfiguration",
",",
"\"A --base-url option is required in order to generate MHTML.\"",
"unless",
"base_url",
"mtime",
"=",
"latest_mtime",
"package_for",
"(",
"p",
",",
":css",
")",
"[",
":paths",
"]",
"asset_url",
"=",
"\"#{base_url}#{Jammit.asset_url(p, :css, :mhtml, mtime)}\"",
"cache",
"(",
"p",
",",
"'css'",
",",
"pack_stylesheets",
"(",
"p",
",",
":mhtml",
",",
"asset_url",
")",
",",
"output_dir",
",",
":mhtml",
",",
"mtime",
")",
"end",
"end",
"end",
"end"
] |
Creating a new Packager will rebuild the list of assets from the
Jammit.configuration. When assets.yml is being changed on the fly,
create a new Packager.
Ask the packager to precache all defined assets, along with their gzip'd
versions. In order to prebuild the MHTML stylesheets, we need to know the
base_url, because IE only supports MHTML with absolute references.
Unless forced, will only rebuild assets whose source files have been
changed since their last package build.
|
[
"Creating",
"a",
"new",
"Packager",
"will",
"rebuild",
"the",
"list",
"of",
"assets",
"from",
"the",
"Jammit",
".",
"configuration",
".",
"When",
"assets",
".",
"yml",
"is",
"being",
"changed",
"on",
"the",
"fly",
"create",
"a",
"new",
"Packager",
".",
"Ask",
"the",
"packager",
"to",
"precache",
"all",
"defined",
"assets",
"along",
"with",
"their",
"gzip",
"d",
"versions",
".",
"In",
"order",
"to",
"prebuild",
"the",
"MHTML",
"stylesheets",
"we",
"need",
"to",
"know",
"the",
"base_url",
"because",
"IE",
"only",
"supports",
"MHTML",
"with",
"absolute",
"references",
".",
"Unless",
"forced",
"will",
"only",
"rebuild",
"assets",
"whose",
"source",
"files",
"have",
"been",
"changed",
"since",
"their",
"last",
"package",
"build",
"."
] |
dc866f1ac3eb069d65215599c451db39d66119a7
|
https://github.com/documentcloud/jammit/blob/dc866f1ac3eb069d65215599c451db39d66119a7/lib/jammit/packager.rb#L34-L49
|
17,510
|
documentcloud/jammit
|
lib/jammit/packager.rb
|
Jammit.Packager.cache
|
def cache(package, extension, contents, output_dir, suffix=nil, mtime=nil)
FileUtils.mkdir_p(output_dir) unless File.exists?(output_dir)
raise OutputNotWritable, "Jammit doesn't have permission to write to \"#{output_dir}\"" unless File.writable?(output_dir)
mtime ||= latest_mtime package_for(package, extension.to_sym)[:paths]
files = []
files << file_name = File.join(output_dir, Jammit.filename(package, extension, suffix))
File.open(file_name, 'wb+') {|f| f.write(contents) }
if Jammit.gzip_assets
files << zip_name = "#{file_name}.gz"
Zlib::GzipWriter.open(zip_name, Zlib::BEST_COMPRESSION) {|f| f.write(contents) }
end
File.utime(mtime, mtime, *files)
end
|
ruby
|
def cache(package, extension, contents, output_dir, suffix=nil, mtime=nil)
FileUtils.mkdir_p(output_dir) unless File.exists?(output_dir)
raise OutputNotWritable, "Jammit doesn't have permission to write to \"#{output_dir}\"" unless File.writable?(output_dir)
mtime ||= latest_mtime package_for(package, extension.to_sym)[:paths]
files = []
files << file_name = File.join(output_dir, Jammit.filename(package, extension, suffix))
File.open(file_name, 'wb+') {|f| f.write(contents) }
if Jammit.gzip_assets
files << zip_name = "#{file_name}.gz"
Zlib::GzipWriter.open(zip_name, Zlib::BEST_COMPRESSION) {|f| f.write(contents) }
end
File.utime(mtime, mtime, *files)
end
|
[
"def",
"cache",
"(",
"package",
",",
"extension",
",",
"contents",
",",
"output_dir",
",",
"suffix",
"=",
"nil",
",",
"mtime",
"=",
"nil",
")",
"FileUtils",
".",
"mkdir_p",
"(",
"output_dir",
")",
"unless",
"File",
".",
"exists?",
"(",
"output_dir",
")",
"raise",
"OutputNotWritable",
",",
"\"Jammit doesn't have permission to write to \\\"#{output_dir}\\\"\"",
"unless",
"File",
".",
"writable?",
"(",
"output_dir",
")",
"mtime",
"||=",
"latest_mtime",
"package_for",
"(",
"package",
",",
"extension",
".",
"to_sym",
")",
"[",
":paths",
"]",
"files",
"=",
"[",
"]",
"files",
"<<",
"file_name",
"=",
"File",
".",
"join",
"(",
"output_dir",
",",
"Jammit",
".",
"filename",
"(",
"package",
",",
"extension",
",",
"suffix",
")",
")",
"File",
".",
"open",
"(",
"file_name",
",",
"'wb+'",
")",
"{",
"|",
"f",
"|",
"f",
".",
"write",
"(",
"contents",
")",
"}",
"if",
"Jammit",
".",
"gzip_assets",
"files",
"<<",
"zip_name",
"=",
"\"#{file_name}.gz\"",
"Zlib",
"::",
"GzipWriter",
".",
"open",
"(",
"zip_name",
",",
"Zlib",
"::",
"BEST_COMPRESSION",
")",
"{",
"|",
"f",
"|",
"f",
".",
"write",
"(",
"contents",
")",
"}",
"end",
"File",
".",
"utime",
"(",
"mtime",
",",
"mtime",
",",
"files",
")",
"end"
] |
Caches a single prebuilt asset package and gzips it at the highest
compression level. Ensures that the modification time of both both
variants is identical, for web server caching modules, as well as MHTML.
|
[
"Caches",
"a",
"single",
"prebuilt",
"asset",
"package",
"and",
"gzips",
"it",
"at",
"the",
"highest",
"compression",
"level",
".",
"Ensures",
"that",
"the",
"modification",
"time",
"of",
"both",
"both",
"variants",
"is",
"identical",
"for",
"web",
"server",
"caching",
"modules",
"as",
"well",
"as",
"MHTML",
"."
] |
dc866f1ac3eb069d65215599c451db39d66119a7
|
https://github.com/documentcloud/jammit/blob/dc866f1ac3eb069d65215599c451db39d66119a7/lib/jammit/packager.rb#L54-L66
|
17,511
|
documentcloud/jammit
|
lib/jammit/packager.rb
|
Jammit.Packager.pack_stylesheets
|
def pack_stylesheets(package, variant=nil, asset_url=nil)
compressor.compress_css(package_for(package, :css)[:paths], variant, asset_url)
end
|
ruby
|
def pack_stylesheets(package, variant=nil, asset_url=nil)
compressor.compress_css(package_for(package, :css)[:paths], variant, asset_url)
end
|
[
"def",
"pack_stylesheets",
"(",
"package",
",",
"variant",
"=",
"nil",
",",
"asset_url",
"=",
"nil",
")",
"compressor",
".",
"compress_css",
"(",
"package_for",
"(",
"package",
",",
":css",
")",
"[",
":paths",
"]",
",",
"variant",
",",
"asset_url",
")",
"end"
] |
Return the compressed contents of a stylesheet package.
|
[
"Return",
"the",
"compressed",
"contents",
"of",
"a",
"stylesheet",
"package",
"."
] |
dc866f1ac3eb069d65215599c451db39d66119a7
|
https://github.com/documentcloud/jammit/blob/dc866f1ac3eb069d65215599c451db39d66119a7/lib/jammit/packager.rb#L78-L80
|
17,512
|
documentcloud/jammit
|
lib/jammit/packager.rb
|
Jammit.Packager.package_for
|
def package_for(package, extension)
pack = @packages[extension] && @packages[extension][package]
pack || not_found(package, extension)
end
|
ruby
|
def package_for(package, extension)
pack = @packages[extension] && @packages[extension][package]
pack || not_found(package, extension)
end
|
[
"def",
"package_for",
"(",
"package",
",",
"extension",
")",
"pack",
"=",
"@packages",
"[",
"extension",
"]",
"&&",
"@packages",
"[",
"extension",
"]",
"[",
"package",
"]",
"pack",
"||",
"not_found",
"(",
"package",
",",
"extension",
")",
"end"
] |
Look up a package asset list by name, raising an exception if the
package has gone missing.
|
[
"Look",
"up",
"a",
"package",
"asset",
"list",
"by",
"name",
"raising",
"an",
"exception",
"if",
"the",
"package",
"has",
"gone",
"missing",
"."
] |
dc866f1ac3eb069d65215599c451db39d66119a7
|
https://github.com/documentcloud/jammit/blob/dc866f1ac3eb069d65215599c451db39d66119a7/lib/jammit/packager.rb#L97-L100
|
17,513
|
documentcloud/jammit
|
lib/jammit/controller.rb
|
Jammit.Controller.package
|
def package
parse_request
template_ext = Jammit.template_extension.to_sym
case @extension
when :js
render :js => (@contents = Jammit.packager.pack_javascripts(@package))
when template_ext
render :js => (@contents = Jammit.packager.pack_templates(@package))
when :css
render :text => generate_stylesheets, :content_type => 'text/css'
end
cache_package if perform_caching && (@extension != template_ext)
rescue Jammit::PackageNotFound
package_not_found
end
|
ruby
|
def package
parse_request
template_ext = Jammit.template_extension.to_sym
case @extension
when :js
render :js => (@contents = Jammit.packager.pack_javascripts(@package))
when template_ext
render :js => (@contents = Jammit.packager.pack_templates(@package))
when :css
render :text => generate_stylesheets, :content_type => 'text/css'
end
cache_package if perform_caching && (@extension != template_ext)
rescue Jammit::PackageNotFound
package_not_found
end
|
[
"def",
"package",
"parse_request",
"template_ext",
"=",
"Jammit",
".",
"template_extension",
".",
"to_sym",
"case",
"@extension",
"when",
":js",
"render",
":js",
"=>",
"(",
"@contents",
"=",
"Jammit",
".",
"packager",
".",
"pack_javascripts",
"(",
"@package",
")",
")",
"when",
"template_ext",
"render",
":js",
"=>",
"(",
"@contents",
"=",
"Jammit",
".",
"packager",
".",
"pack_templates",
"(",
"@package",
")",
")",
"when",
":css",
"render",
":text",
"=>",
"generate_stylesheets",
",",
":content_type",
"=>",
"'text/css'",
"end",
"cache_package",
"if",
"perform_caching",
"&&",
"(",
"@extension",
"!=",
"template_ext",
")",
"rescue",
"Jammit",
"::",
"PackageNotFound",
"package_not_found",
"end"
] |
The "package" action receives all requests for asset packages that haven't
yet been cached. The package will be built, cached, and gzipped.
|
[
"The",
"package",
"action",
"receives",
"all",
"requests",
"for",
"asset",
"packages",
"that",
"haven",
"t",
"yet",
"been",
"cached",
".",
"The",
"package",
"will",
"be",
"built",
"cached",
"and",
"gzipped",
"."
] |
dc866f1ac3eb069d65215599c451db39d66119a7
|
https://github.com/documentcloud/jammit/blob/dc866f1ac3eb069d65215599c451db39d66119a7/lib/jammit/controller.rb#L19-L33
|
17,514
|
documentcloud/jammit
|
lib/jammit/helper.rb
|
Jammit.Helper.include_stylesheets
|
def include_stylesheets(*packages)
options = packages.extract_options!
return html_safe(individual_stylesheets(packages, options)) unless should_package?
disabled = (options.delete(:embed_assets) == false) || (options.delete(:embed_images) == false)
return html_safe(packaged_stylesheets(packages, options)) if disabled || !Jammit.embed_assets
return html_safe(embedded_image_stylesheets(packages, options))
end
|
ruby
|
def include_stylesheets(*packages)
options = packages.extract_options!
return html_safe(individual_stylesheets(packages, options)) unless should_package?
disabled = (options.delete(:embed_assets) == false) || (options.delete(:embed_images) == false)
return html_safe(packaged_stylesheets(packages, options)) if disabled || !Jammit.embed_assets
return html_safe(embedded_image_stylesheets(packages, options))
end
|
[
"def",
"include_stylesheets",
"(",
"*",
"packages",
")",
"options",
"=",
"packages",
".",
"extract_options!",
"return",
"html_safe",
"(",
"individual_stylesheets",
"(",
"packages",
",",
"options",
")",
")",
"unless",
"should_package?",
"disabled",
"=",
"(",
"options",
".",
"delete",
"(",
":embed_assets",
")",
"==",
"false",
")",
"||",
"(",
"options",
".",
"delete",
"(",
":embed_images",
")",
"==",
"false",
")",
"return",
"html_safe",
"(",
"packaged_stylesheets",
"(",
"packages",
",",
"options",
")",
")",
"if",
"disabled",
"||",
"!",
"Jammit",
".",
"embed_assets",
"return",
"html_safe",
"(",
"embedded_image_stylesheets",
"(",
"packages",
",",
"options",
")",
")",
"end"
] |
If embed_assets is turned on, writes out links to the Data-URI and MHTML
versions of the stylesheet package, otherwise the package is regular
compressed CSS, and in development the stylesheet URLs are passed verbatim.
|
[
"If",
"embed_assets",
"is",
"turned",
"on",
"writes",
"out",
"links",
"to",
"the",
"Data",
"-",
"URI",
"and",
"MHTML",
"versions",
"of",
"the",
"stylesheet",
"package",
"otherwise",
"the",
"package",
"is",
"regular",
"compressed",
"CSS",
"and",
"in",
"development",
"the",
"stylesheet",
"URLs",
"are",
"passed",
"verbatim",
"."
] |
dc866f1ac3eb069d65215599c451db39d66119a7
|
https://github.com/documentcloud/jammit/blob/dc866f1ac3eb069d65215599c451db39d66119a7/lib/jammit/helper.rb#L17-L23
|
17,515
|
documentcloud/jammit
|
lib/jammit/helper.rb
|
Jammit.Helper.include_javascripts
|
def include_javascripts(*packages)
options = packages.extract_options!
options.merge!(:extname=>false)
html_safe packages.map {|pack|
should_package? ? Jammit.asset_url(pack, :js) : Jammit.packager.individual_urls(pack.to_sym, :js)
}.flatten.map {|pack|
"<script src=\"#{pack}\"></script>"
}.join("\n")
end
|
ruby
|
def include_javascripts(*packages)
options = packages.extract_options!
options.merge!(:extname=>false)
html_safe packages.map {|pack|
should_package? ? Jammit.asset_url(pack, :js) : Jammit.packager.individual_urls(pack.to_sym, :js)
}.flatten.map {|pack|
"<script src=\"#{pack}\"></script>"
}.join("\n")
end
|
[
"def",
"include_javascripts",
"(",
"*",
"packages",
")",
"options",
"=",
"packages",
".",
"extract_options!",
"options",
".",
"merge!",
"(",
":extname",
"=>",
"false",
")",
"html_safe",
"packages",
".",
"map",
"{",
"|",
"pack",
"|",
"should_package?",
"?",
"Jammit",
".",
"asset_url",
"(",
"pack",
",",
":js",
")",
":",
"Jammit",
".",
"packager",
".",
"individual_urls",
"(",
"pack",
".",
"to_sym",
",",
":js",
")",
"}",
".",
"flatten",
".",
"map",
"{",
"|",
"pack",
"|",
"\"<script src=\\\"#{pack}\\\"></script>\"",
"}",
".",
"join",
"(",
"\"\\n\"",
")",
"end"
] |
Writes out the URL to the bundled and compressed javascript package,
except in development, where it references the individual scripts.
|
[
"Writes",
"out",
"the",
"URL",
"to",
"the",
"bundled",
"and",
"compressed",
"javascript",
"package",
"except",
"in",
"development",
"where",
"it",
"references",
"the",
"individual",
"scripts",
"."
] |
dc866f1ac3eb069d65215599c451db39d66119a7
|
https://github.com/documentcloud/jammit/blob/dc866f1ac3eb069d65215599c451db39d66119a7/lib/jammit/helper.rb#L27-L35
|
17,516
|
documentcloud/jammit
|
lib/jammit/helper.rb
|
Jammit.Helper.individual_stylesheets
|
def individual_stylesheets(packages, options)
tags_with_options(packages, options) {|p| Jammit.packager.individual_urls(p.to_sym, :css) }
end
|
ruby
|
def individual_stylesheets(packages, options)
tags_with_options(packages, options) {|p| Jammit.packager.individual_urls(p.to_sym, :css) }
end
|
[
"def",
"individual_stylesheets",
"(",
"packages",
",",
"options",
")",
"tags_with_options",
"(",
"packages",
",",
"options",
")",
"{",
"|",
"p",
"|",
"Jammit",
".",
"packager",
".",
"individual_urls",
"(",
"p",
".",
"to_sym",
",",
":css",
")",
"}",
"end"
] |
HTML tags, in order, for all of the individual stylesheets.
|
[
"HTML",
"tags",
"in",
"order",
"for",
"all",
"of",
"the",
"individual",
"stylesheets",
"."
] |
dc866f1ac3eb069d65215599c451db39d66119a7
|
https://github.com/documentcloud/jammit/blob/dc866f1ac3eb069d65215599c451db39d66119a7/lib/jammit/helper.rb#L55-L57
|
17,517
|
documentcloud/jammit
|
lib/jammit/helper.rb
|
Jammit.Helper.packaged_stylesheets
|
def packaged_stylesheets(packages, options)
tags_with_options(packages, options) {|p| Jammit.asset_url(p, :css) }
end
|
ruby
|
def packaged_stylesheets(packages, options)
tags_with_options(packages, options) {|p| Jammit.asset_url(p, :css) }
end
|
[
"def",
"packaged_stylesheets",
"(",
"packages",
",",
"options",
")",
"tags_with_options",
"(",
"packages",
",",
"options",
")",
"{",
"|",
"p",
"|",
"Jammit",
".",
"asset_url",
"(",
"p",
",",
":css",
")",
"}",
"end"
] |
HTML tags for the stylesheet packages.
|
[
"HTML",
"tags",
"for",
"the",
"stylesheet",
"packages",
"."
] |
dc866f1ac3eb069d65215599c451db39d66119a7
|
https://github.com/documentcloud/jammit/blob/dc866f1ac3eb069d65215599c451db39d66119a7/lib/jammit/helper.rb#L60-L62
|
17,518
|
documentcloud/jammit
|
lib/jammit/helper.rb
|
Jammit.Helper.embedded_image_stylesheets
|
def embedded_image_stylesheets(packages, options)
datauri_tags = tags_with_options(packages, options) {|p| Jammit.asset_url(p, :css, :datauri) }
ie_tags = Jammit.mhtml_enabled ?
tags_with_options(packages, options) {|p| Jammit.asset_url(p, :css, :mhtml) } :
packaged_stylesheets(packages, options)
[DATA_URI_START, datauri_tags, DATA_URI_END, MHTML_START, ie_tags, MHTML_END].join("\n")
end
|
ruby
|
def embedded_image_stylesheets(packages, options)
datauri_tags = tags_with_options(packages, options) {|p| Jammit.asset_url(p, :css, :datauri) }
ie_tags = Jammit.mhtml_enabled ?
tags_with_options(packages, options) {|p| Jammit.asset_url(p, :css, :mhtml) } :
packaged_stylesheets(packages, options)
[DATA_URI_START, datauri_tags, DATA_URI_END, MHTML_START, ie_tags, MHTML_END].join("\n")
end
|
[
"def",
"embedded_image_stylesheets",
"(",
"packages",
",",
"options",
")",
"datauri_tags",
"=",
"tags_with_options",
"(",
"packages",
",",
"options",
")",
"{",
"|",
"p",
"|",
"Jammit",
".",
"asset_url",
"(",
"p",
",",
":css",
",",
":datauri",
")",
"}",
"ie_tags",
"=",
"Jammit",
".",
"mhtml_enabled",
"?",
"tags_with_options",
"(",
"packages",
",",
"options",
")",
"{",
"|",
"p",
"|",
"Jammit",
".",
"asset_url",
"(",
"p",
",",
":css",
",",
":mhtml",
")",
"}",
":",
"packaged_stylesheets",
"(",
"packages",
",",
"options",
")",
"[",
"DATA_URI_START",
",",
"datauri_tags",
",",
"DATA_URI_END",
",",
"MHTML_START",
",",
"ie_tags",
",",
"MHTML_END",
"]",
".",
"join",
"(",
"\"\\n\"",
")",
"end"
] |
HTML tags for the 'datauri', and 'mhtml' versions of the packaged
stylesheets, using conditional comments to load the correct variant.
|
[
"HTML",
"tags",
"for",
"the",
"datauri",
"and",
"mhtml",
"versions",
"of",
"the",
"packaged",
"stylesheets",
"using",
"conditional",
"comments",
"to",
"load",
"the",
"correct",
"variant",
"."
] |
dc866f1ac3eb069d65215599c451db39d66119a7
|
https://github.com/documentcloud/jammit/blob/dc866f1ac3eb069d65215599c451db39d66119a7/lib/jammit/helper.rb#L66-L72
|
17,519
|
documentcloud/jammit
|
lib/jammit/helper.rb
|
Jammit.Helper.tags_with_options
|
def tags_with_options(packages, options)
packages.dup.map {|package|
yield package
}.flatten.map {|package|
stylesheet_link_tag package, options
}.join("\n")
end
|
ruby
|
def tags_with_options(packages, options)
packages.dup.map {|package|
yield package
}.flatten.map {|package|
stylesheet_link_tag package, options
}.join("\n")
end
|
[
"def",
"tags_with_options",
"(",
"packages",
",",
"options",
")",
"packages",
".",
"dup",
".",
"map",
"{",
"|",
"package",
"|",
"yield",
"package",
"}",
".",
"flatten",
".",
"map",
"{",
"|",
"package",
"|",
"stylesheet_link_tag",
"package",
",",
"options",
"}",
".",
"join",
"(",
"\"\\n\"",
")",
"end"
] |
Generate the stylesheet tags for a batch of packages, with options, by
yielding each package to a block.
|
[
"Generate",
"the",
"stylesheet",
"tags",
"for",
"a",
"batch",
"of",
"packages",
"with",
"options",
"by",
"yielding",
"each",
"package",
"to",
"a",
"block",
"."
] |
dc866f1ac3eb069d65215599c451db39d66119a7
|
https://github.com/documentcloud/jammit/blob/dc866f1ac3eb069d65215599c451db39d66119a7/lib/jammit/helper.rb#L76-L82
|
17,520
|
documentcloud/jammit
|
lib/jammit/compressor.rb
|
Jammit.Compressor.compile_jst
|
def compile_jst(paths)
namespace = Jammit.template_namespace
paths = paths.grep(Jammit.template_extension_matcher).sort
base_path = find_base_path(paths)
compiled = paths.map do |path|
contents = read_binary_file(path)
contents = contents.gsub(/\r?\n/, "\\n").gsub("'", '\\\\\'')
name = template_name(path, base_path)
"#{namespace}['#{name}'] = #{Jammit.template_function}('#{contents}');"
end
compiler = Jammit.include_jst_script ? read_binary_file(DEFAULT_JST_SCRIPT) : '';
setup_namespace = "#{namespace} = #{namespace} || {};"
[JST_START, setup_namespace, compiler, compiled, JST_END].flatten.join("\n")
end
|
ruby
|
def compile_jst(paths)
namespace = Jammit.template_namespace
paths = paths.grep(Jammit.template_extension_matcher).sort
base_path = find_base_path(paths)
compiled = paths.map do |path|
contents = read_binary_file(path)
contents = contents.gsub(/\r?\n/, "\\n").gsub("'", '\\\\\'')
name = template_name(path, base_path)
"#{namespace}['#{name}'] = #{Jammit.template_function}('#{contents}');"
end
compiler = Jammit.include_jst_script ? read_binary_file(DEFAULT_JST_SCRIPT) : '';
setup_namespace = "#{namespace} = #{namespace} || {};"
[JST_START, setup_namespace, compiler, compiled, JST_END].flatten.join("\n")
end
|
[
"def",
"compile_jst",
"(",
"paths",
")",
"namespace",
"=",
"Jammit",
".",
"template_namespace",
"paths",
"=",
"paths",
".",
"grep",
"(",
"Jammit",
".",
"template_extension_matcher",
")",
".",
"sort",
"base_path",
"=",
"find_base_path",
"(",
"paths",
")",
"compiled",
"=",
"paths",
".",
"map",
"do",
"|",
"path",
"|",
"contents",
"=",
"read_binary_file",
"(",
"path",
")",
"contents",
"=",
"contents",
".",
"gsub",
"(",
"/",
"\\r",
"\\n",
"/",
",",
"\"\\\\n\"",
")",
".",
"gsub",
"(",
"\"'\"",
",",
"'\\\\\\\\\\''",
")",
"name",
"=",
"template_name",
"(",
"path",
",",
"base_path",
")",
"\"#{namespace}['#{name}'] = #{Jammit.template_function}('#{contents}');\"",
"end",
"compiler",
"=",
"Jammit",
".",
"include_jst_script",
"?",
"read_binary_file",
"(",
"DEFAULT_JST_SCRIPT",
")",
":",
"''",
";",
"setup_namespace",
"=",
"\"#{namespace} = #{namespace} || {};\"",
"[",
"JST_START",
",",
"setup_namespace",
",",
"compiler",
",",
"compiled",
",",
"JST_END",
"]",
".",
"flatten",
".",
"join",
"(",
"\"\\n\"",
")",
"end"
] |
Compiles a single JST file by writing out a javascript that adds
template properties to a top-level template namespace object. Adds a
JST-compilation function to the top of the package, unless you've
specified your own preferred function, or turned it off.
JST templates are named with the basename of their file.
|
[
"Compiles",
"a",
"single",
"JST",
"file",
"by",
"writing",
"out",
"a",
"javascript",
"that",
"adds",
"template",
"properties",
"to",
"a",
"top",
"-",
"level",
"template",
"namespace",
"object",
".",
"Adds",
"a",
"JST",
"-",
"compilation",
"function",
"to",
"the",
"top",
"of",
"the",
"package",
"unless",
"you",
"ve",
"specified",
"your",
"own",
"preferred",
"function",
"or",
"turned",
"it",
"off",
".",
"JST",
"templates",
"are",
"named",
"with",
"the",
"basename",
"of",
"their",
"file",
"."
] |
dc866f1ac3eb069d65215599c451db39d66119a7
|
https://github.com/documentcloud/jammit/blob/dc866f1ac3eb069d65215599c451db39d66119a7/lib/jammit/compressor.rb#L110-L123
|
17,521
|
documentcloud/jammit
|
lib/jammit/compressor.rb
|
Jammit.Compressor.find_base_path
|
def find_base_path(paths)
return nil if paths.length <= 1
paths.sort!
first = paths.first.split('/')
last = paths.last.split('/')
i = 0
while first[i] == last[i] && i <= first.length
i += 1
end
res = first.slice(0, i).join('/')
res.empty? ? nil : res
end
|
ruby
|
def find_base_path(paths)
return nil if paths.length <= 1
paths.sort!
first = paths.first.split('/')
last = paths.last.split('/')
i = 0
while first[i] == last[i] && i <= first.length
i += 1
end
res = first.slice(0, i).join('/')
res.empty? ? nil : res
end
|
[
"def",
"find_base_path",
"(",
"paths",
")",
"return",
"nil",
"if",
"paths",
".",
"length",
"<=",
"1",
"paths",
".",
"sort!",
"first",
"=",
"paths",
".",
"first",
".",
"split",
"(",
"'/'",
")",
"last",
"=",
"paths",
".",
"last",
".",
"split",
"(",
"'/'",
")",
"i",
"=",
"0",
"while",
"first",
"[",
"i",
"]",
"==",
"last",
"[",
"i",
"]",
"&&",
"i",
"<=",
"first",
".",
"length",
"i",
"+=",
"1",
"end",
"res",
"=",
"first",
".",
"slice",
"(",
"0",
",",
"i",
")",
".",
"join",
"(",
"'/'",
")",
"res",
".",
"empty?",
"?",
"nil",
":",
"res",
"end"
] |
Given a set of paths, find a common prefix path.
|
[
"Given",
"a",
"set",
"of",
"paths",
"find",
"a",
"common",
"prefix",
"path",
"."
] |
dc866f1ac3eb069d65215599c451db39d66119a7
|
https://github.com/documentcloud/jammit/blob/dc866f1ac3eb069d65215599c451db39d66119a7/lib/jammit/compressor.rb#L129-L140
|
17,522
|
documentcloud/jammit
|
lib/jammit/compressor.rb
|
Jammit.Compressor.concatenate_and_tag_assets
|
def concatenate_and_tag_assets(paths, variant=nil)
stylesheets = [paths].flatten.map do |css_path|
contents = read_binary_file(css_path)
contents.gsub(EMBED_DETECTOR) do |url|
ipath, cpath = Pathname.new($1), Pathname.new(File.expand_path(css_path))
is_url = URI.parse($1).absolute?
is_url ? url : "url(#{construct_asset_path(ipath, cpath, variant)})"
end
end
stylesheets.join("\n")
end
|
ruby
|
def concatenate_and_tag_assets(paths, variant=nil)
stylesheets = [paths].flatten.map do |css_path|
contents = read_binary_file(css_path)
contents.gsub(EMBED_DETECTOR) do |url|
ipath, cpath = Pathname.new($1), Pathname.new(File.expand_path(css_path))
is_url = URI.parse($1).absolute?
is_url ? url : "url(#{construct_asset_path(ipath, cpath, variant)})"
end
end
stylesheets.join("\n")
end
|
[
"def",
"concatenate_and_tag_assets",
"(",
"paths",
",",
"variant",
"=",
"nil",
")",
"stylesheets",
"=",
"[",
"paths",
"]",
".",
"flatten",
".",
"map",
"do",
"|",
"css_path",
"|",
"contents",
"=",
"read_binary_file",
"(",
"css_path",
")",
"contents",
".",
"gsub",
"(",
"EMBED_DETECTOR",
")",
"do",
"|",
"url",
"|",
"ipath",
",",
"cpath",
"=",
"Pathname",
".",
"new",
"(",
"$1",
")",
",",
"Pathname",
".",
"new",
"(",
"File",
".",
"expand_path",
"(",
"css_path",
")",
")",
"is_url",
"=",
"URI",
".",
"parse",
"(",
"$1",
")",
".",
"absolute?",
"is_url",
"?",
"url",
":",
"\"url(#{construct_asset_path(ipath, cpath, variant)})\"",
"end",
"end",
"stylesheets",
".",
"join",
"(",
"\"\\n\"",
")",
"end"
] |
In order to support embedded assets from relative paths, we need to
expand the paths before contatenating the CSS together and losing the
location of the original stylesheet path. Validate the assets while we're
at it.
|
[
"In",
"order",
"to",
"support",
"embedded",
"assets",
"from",
"relative",
"paths",
"we",
"need",
"to",
"expand",
"the",
"paths",
"before",
"contatenating",
"the",
"CSS",
"together",
"and",
"losing",
"the",
"location",
"of",
"the",
"original",
"stylesheet",
"path",
".",
"Validate",
"the",
"assets",
"while",
"we",
"re",
"at",
"it",
"."
] |
dc866f1ac3eb069d65215599c451db39d66119a7
|
https://github.com/documentcloud/jammit/blob/dc866f1ac3eb069d65215599c451db39d66119a7/lib/jammit/compressor.rb#L153-L163
|
17,523
|
documentcloud/jammit
|
lib/jammit/compressor.rb
|
Jammit.Compressor.absolute_path
|
def absolute_path(asset_pathname, css_pathname)
(asset_pathname.absolute? ?
Pathname.new(File.join(Jammit.public_root, asset_pathname)) :
css_pathname.dirname + asset_pathname).cleanpath
end
|
ruby
|
def absolute_path(asset_pathname, css_pathname)
(asset_pathname.absolute? ?
Pathname.new(File.join(Jammit.public_root, asset_pathname)) :
css_pathname.dirname + asset_pathname).cleanpath
end
|
[
"def",
"absolute_path",
"(",
"asset_pathname",
",",
"css_pathname",
")",
"(",
"asset_pathname",
".",
"absolute?",
"?",
"Pathname",
".",
"new",
"(",
"File",
".",
"join",
"(",
"Jammit",
".",
"public_root",
",",
"asset_pathname",
")",
")",
":",
"css_pathname",
".",
"dirname",
"+",
"asset_pathname",
")",
".",
"cleanpath",
"end"
] |
Get the site-absolute public path for an asset file path that may or may
not be relative, given the path of the stylesheet that contains it.
|
[
"Get",
"the",
"site",
"-",
"absolute",
"public",
"path",
"for",
"an",
"asset",
"file",
"path",
"that",
"may",
"or",
"may",
"not",
"be",
"relative",
"given",
"the",
"path",
"of",
"the",
"stylesheet",
"that",
"contains",
"it",
"."
] |
dc866f1ac3eb069d65215599c451db39d66119a7
|
https://github.com/documentcloud/jammit/blob/dc866f1ac3eb069d65215599c451db39d66119a7/lib/jammit/compressor.rb#L201-L205
|
17,524
|
documentcloud/jammit
|
lib/jammit/compressor.rb
|
Jammit.Compressor.rails_asset_id
|
def rails_asset_id(path)
asset_id = ENV["RAILS_ASSET_ID"]
return asset_id if asset_id
File.exists?(path) ? File.mtime(path).to_i.to_s : ''
end
|
ruby
|
def rails_asset_id(path)
asset_id = ENV["RAILS_ASSET_ID"]
return asset_id if asset_id
File.exists?(path) ? File.mtime(path).to_i.to_s : ''
end
|
[
"def",
"rails_asset_id",
"(",
"path",
")",
"asset_id",
"=",
"ENV",
"[",
"\"RAILS_ASSET_ID\"",
"]",
"return",
"asset_id",
"if",
"asset_id",
"File",
".",
"exists?",
"(",
"path",
")",
"?",
"File",
".",
"mtime",
"(",
"path",
")",
".",
"to_i",
".",
"to_s",
":",
"''",
"end"
] |
Similar to the AssetTagHelper's method of the same name, this will
determine the correct asset id for a file.
|
[
"Similar",
"to",
"the",
"AssetTagHelper",
"s",
"method",
"of",
"the",
"same",
"name",
"this",
"will",
"determine",
"the",
"correct",
"asset",
"id",
"for",
"a",
"file",
"."
] |
dc866f1ac3eb069d65215599c451db39d66119a7
|
https://github.com/documentcloud/jammit/blob/dc866f1ac3eb069d65215599c451db39d66119a7/lib/jammit/compressor.rb#L222-L226
|
17,525
|
documentcloud/jammit
|
lib/jammit/compressor.rb
|
Jammit.Compressor.embeddable?
|
def embeddable?(asset_path, variant)
font = EMBED_FONTS.include?(asset_path.extname)
return false unless variant
return false unless asset_path.to_s.match(EMBEDDABLE) && asset_path.exist?
return false unless EMBED_EXTS.include?(asset_path.extname)
return false unless font || encoded_contents(asset_path).length < MAX_IMAGE_SIZE
return false if font && variant == :mhtml
return true
end
|
ruby
|
def embeddable?(asset_path, variant)
font = EMBED_FONTS.include?(asset_path.extname)
return false unless variant
return false unless asset_path.to_s.match(EMBEDDABLE) && asset_path.exist?
return false unless EMBED_EXTS.include?(asset_path.extname)
return false unless font || encoded_contents(asset_path).length < MAX_IMAGE_SIZE
return false if font && variant == :mhtml
return true
end
|
[
"def",
"embeddable?",
"(",
"asset_path",
",",
"variant",
")",
"font",
"=",
"EMBED_FONTS",
".",
"include?",
"(",
"asset_path",
".",
"extname",
")",
"return",
"false",
"unless",
"variant",
"return",
"false",
"unless",
"asset_path",
".",
"to_s",
".",
"match",
"(",
"EMBEDDABLE",
")",
"&&",
"asset_path",
".",
"exist?",
"return",
"false",
"unless",
"EMBED_EXTS",
".",
"include?",
"(",
"asset_path",
".",
"extname",
")",
"return",
"false",
"unless",
"font",
"||",
"encoded_contents",
"(",
"asset_path",
")",
".",
"length",
"<",
"MAX_IMAGE_SIZE",
"return",
"false",
"if",
"font",
"&&",
"variant",
"==",
":mhtml",
"return",
"true",
"end"
] |
An asset is valid for embedding if it exists, is less than 32K, and is
stored somewhere inside of a folder named "embed". IE does not support
Data-URIs larger than 32K, and you probably shouldn't be embedding assets
that large in any case. Because we need to check the base64 length here,
save it so that we don't have to compute it again later.
|
[
"An",
"asset",
"is",
"valid",
"for",
"embedding",
"if",
"it",
"exists",
"is",
"less",
"than",
"32K",
"and",
"is",
"stored",
"somewhere",
"inside",
"of",
"a",
"folder",
"named",
"embed",
".",
"IE",
"does",
"not",
"support",
"Data",
"-",
"URIs",
"larger",
"than",
"32K",
"and",
"you",
"probably",
"shouldn",
"t",
"be",
"embedding",
"assets",
"that",
"large",
"in",
"any",
"case",
".",
"Because",
"we",
"need",
"to",
"check",
"the",
"base64",
"length",
"here",
"save",
"it",
"so",
"that",
"we",
"don",
"t",
"have",
"to",
"compute",
"it",
"again",
"later",
"."
] |
dc866f1ac3eb069d65215599c451db39d66119a7
|
https://github.com/documentcloud/jammit/blob/dc866f1ac3eb069d65215599c451db39d66119a7/lib/jammit/compressor.rb#L233-L241
|
17,526
|
documentcloud/jammit
|
lib/jammit/compressor.rb
|
Jammit.Compressor.encoded_contents
|
def encoded_contents(asset_path)
return @asset_contents[asset_path] if @asset_contents[asset_path]
data = read_binary_file(asset_path)
@asset_contents[asset_path] = Base64.encode64(data).gsub(/\n/, '')
end
|
ruby
|
def encoded_contents(asset_path)
return @asset_contents[asset_path] if @asset_contents[asset_path]
data = read_binary_file(asset_path)
@asset_contents[asset_path] = Base64.encode64(data).gsub(/\n/, '')
end
|
[
"def",
"encoded_contents",
"(",
"asset_path",
")",
"return",
"@asset_contents",
"[",
"asset_path",
"]",
"if",
"@asset_contents",
"[",
"asset_path",
"]",
"data",
"=",
"read_binary_file",
"(",
"asset_path",
")",
"@asset_contents",
"[",
"asset_path",
"]",
"=",
"Base64",
".",
"encode64",
"(",
"data",
")",
".",
"gsub",
"(",
"/",
"\\n",
"/",
",",
"''",
")",
"end"
] |
Return the Base64-encoded contents of an asset on a single line.
|
[
"Return",
"the",
"Base64",
"-",
"encoded",
"contents",
"of",
"an",
"asset",
"on",
"a",
"single",
"line",
"."
] |
dc866f1ac3eb069d65215599c451db39d66119a7
|
https://github.com/documentcloud/jammit/blob/dc866f1ac3eb069d65215599c451db39d66119a7/lib/jammit/compressor.rb#L244-L248
|
17,527
|
progapandist/rubotnik
|
lib/rubotnik/helpers.rb
|
Rubotnik.Helpers.say
|
def say(text, quick_replies: [], user: @user)
message_options = {
recipient: { id: user.id },
message: { text: text }
}
if quick_replies && !quick_replies.empty?
message_options[:message][:quick_replies] = UI::QuickReplies
.build(*quick_replies)
end
send_message(message_options)
end
|
ruby
|
def say(text, quick_replies: [], user: @user)
message_options = {
recipient: { id: user.id },
message: { text: text }
}
if quick_replies && !quick_replies.empty?
message_options[:message][:quick_replies] = UI::QuickReplies
.build(*quick_replies)
end
send_message(message_options)
end
|
[
"def",
"say",
"(",
"text",
",",
"quick_replies",
":",
"[",
"]",
",",
"user",
":",
"@user",
")",
"message_options",
"=",
"{",
"recipient",
":",
"{",
"id",
":",
"user",
".",
"id",
"}",
",",
"message",
":",
"{",
"text",
":",
"text",
"}",
"}",
"if",
"quick_replies",
"&&",
"!",
"quick_replies",
".",
"empty?",
"message_options",
"[",
":message",
"]",
"[",
":quick_replies",
"]",
"=",
"UI",
"::",
"QuickReplies",
".",
"build",
"(",
"quick_replies",
")",
"end",
"send_message",
"(",
"message_options",
")",
"end"
] |
abstraction over Bot.deliver to send messages declaratively and directly
|
[
"abstraction",
"over",
"Bot",
".",
"deliver",
"to",
"send",
"messages",
"declaratively",
"and",
"directly"
] |
b79f54b5a3605339281508cb503fa0b6f84f3d07
|
https://github.com/progapandist/rubotnik/blob/b79f54b5a3605339281508cb503fa0b6f84f3d07/lib/rubotnik/helpers.rb#L12-L23
|
17,528
|
Homebrew/ruby-macho
|
lib/macho/fat_file.rb
|
MachO.FatFile.change_dylib_id
|
def change_dylib_id(new_id, options = {})
raise ArgumentError, "argument must be a String" unless new_id.is_a?(String)
return unless machos.all?(&:dylib?)
each_macho(options) do |macho|
macho.change_dylib_id(new_id, options)
end
repopulate_raw_machos
end
|
ruby
|
def change_dylib_id(new_id, options = {})
raise ArgumentError, "argument must be a String" unless new_id.is_a?(String)
return unless machos.all?(&:dylib?)
each_macho(options) do |macho|
macho.change_dylib_id(new_id, options)
end
repopulate_raw_machos
end
|
[
"def",
"change_dylib_id",
"(",
"new_id",
",",
"options",
"=",
"{",
"}",
")",
"raise",
"ArgumentError",
",",
"\"argument must be a String\"",
"unless",
"new_id",
".",
"is_a?",
"(",
"String",
")",
"return",
"unless",
"machos",
".",
"all?",
"(",
":dylib?",
")",
"each_macho",
"(",
"options",
")",
"do",
"|",
"macho",
"|",
"macho",
".",
"change_dylib_id",
"(",
"new_id",
",",
"options",
")",
"end",
"repopulate_raw_machos",
"end"
] |
Changes the file's dylib ID to `new_id`. If the file is not a dylib,
does nothing.
@example
file.change_dylib_id('libFoo.dylib')
@param new_id [String] the new dylib ID
@param options [Hash]
@option options [Boolean] :strict (true) if true, fail if one slice fails.
if false, fail only if all slices fail.
@return [void]
@raise [ArgumentError] if `new_id` is not a String
@see MachOFile#linked_dylibs
|
[
"Changes",
"the",
"file",
"s",
"dylib",
"ID",
"to",
"new_id",
".",
"If",
"the",
"file",
"is",
"not",
"a",
"dylib",
"does",
"nothing",
"."
] |
a1dedc25bc78a9bd6366988d12e122ee3d420e8c
|
https://github.com/Homebrew/ruby-macho/blob/a1dedc25bc78a9bd6366988d12e122ee3d420e8c/lib/macho/fat_file.rb#L180-L189
|
17,529
|
Homebrew/ruby-macho
|
lib/macho/fat_file.rb
|
MachO.FatFile.change_install_name
|
def change_install_name(old_name, new_name, options = {})
each_macho(options) do |macho|
macho.change_install_name(old_name, new_name, options)
end
repopulate_raw_machos
end
|
ruby
|
def change_install_name(old_name, new_name, options = {})
each_macho(options) do |macho|
macho.change_install_name(old_name, new_name, options)
end
repopulate_raw_machos
end
|
[
"def",
"change_install_name",
"(",
"old_name",
",",
"new_name",
",",
"options",
"=",
"{",
"}",
")",
"each_macho",
"(",
"options",
")",
"do",
"|",
"macho",
"|",
"macho",
".",
"change_install_name",
"(",
"old_name",
",",
"new_name",
",",
"options",
")",
"end",
"repopulate_raw_machos",
"end"
] |
Changes all dependent shared library install names from `old_name` to
`new_name`. In a fat file, this changes install names in all internal
Mach-Os.
@example
file.change_install_name('/usr/lib/libFoo.dylib', '/usr/lib/libBar.dylib')
@param old_name [String] the shared library name being changed
@param new_name [String] the new name
@param options [Hash]
@option options [Boolean] :strict (true) if true, fail if one slice fails.
if false, fail only if all slices fail.
@return [void]
@see MachOFile#change_install_name
|
[
"Changes",
"all",
"dependent",
"shared",
"library",
"install",
"names",
"from",
"old_name",
"to",
"new_name",
".",
"In",
"a",
"fat",
"file",
"this",
"changes",
"install",
"names",
"in",
"all",
"internal",
"Mach",
"-",
"Os",
"."
] |
a1dedc25bc78a9bd6366988d12e122ee3d420e8c
|
https://github.com/Homebrew/ruby-macho/blob/a1dedc25bc78a9bd6366988d12e122ee3d420e8c/lib/macho/fat_file.rb#L215-L221
|
17,530
|
Homebrew/ruby-macho
|
lib/macho/fat_file.rb
|
MachO.FatFile.change_rpath
|
def change_rpath(old_path, new_path, options = {})
each_macho(options) do |macho|
macho.change_rpath(old_path, new_path, options)
end
repopulate_raw_machos
end
|
ruby
|
def change_rpath(old_path, new_path, options = {})
each_macho(options) do |macho|
macho.change_rpath(old_path, new_path, options)
end
repopulate_raw_machos
end
|
[
"def",
"change_rpath",
"(",
"old_path",
",",
"new_path",
",",
"options",
"=",
"{",
"}",
")",
"each_macho",
"(",
"options",
")",
"do",
"|",
"macho",
"|",
"macho",
".",
"change_rpath",
"(",
"old_path",
",",
"new_path",
",",
"options",
")",
"end",
"repopulate_raw_machos",
"end"
] |
Change the runtime path `old_path` to `new_path` in the file's Mach-Os.
@param old_path [String] the old runtime path
@param new_path [String] the new runtime path
@param options [Hash]
@option options [Boolean] :strict (true) if true, fail if one slice fails.
if false, fail only if all slices fail.
@return [void]
@see MachOFile#change_rpath
|
[
"Change",
"the",
"runtime",
"path",
"old_path",
"to",
"new_path",
"in",
"the",
"file",
"s",
"Mach",
"-",
"Os",
"."
] |
a1dedc25bc78a9bd6366988d12e122ee3d420e8c
|
https://github.com/Homebrew/ruby-macho/blob/a1dedc25bc78a9bd6366988d12e122ee3d420e8c/lib/macho/fat_file.rb#L241-L247
|
17,531
|
Homebrew/ruby-macho
|
lib/macho/fat_file.rb
|
MachO.FatFile.add_rpath
|
def add_rpath(path, options = {})
each_macho(options) do |macho|
macho.add_rpath(path, options)
end
repopulate_raw_machos
end
|
ruby
|
def add_rpath(path, options = {})
each_macho(options) do |macho|
macho.add_rpath(path, options)
end
repopulate_raw_machos
end
|
[
"def",
"add_rpath",
"(",
"path",
",",
"options",
"=",
"{",
"}",
")",
"each_macho",
"(",
"options",
")",
"do",
"|",
"macho",
"|",
"macho",
".",
"add_rpath",
"(",
"path",
",",
"options",
")",
"end",
"repopulate_raw_machos",
"end"
] |
Add the given runtime path to the file's Mach-Os.
@param path [String] the new runtime path
@param options [Hash]
@option options [Boolean] :strict (true) if true, fail if one slice fails.
if false, fail only if all slices fail.
@return [void]
@see MachOFile#add_rpath
|
[
"Add",
"the",
"given",
"runtime",
"path",
"to",
"the",
"file",
"s",
"Mach",
"-",
"Os",
"."
] |
a1dedc25bc78a9bd6366988d12e122ee3d420e8c
|
https://github.com/Homebrew/ruby-macho/blob/a1dedc25bc78a9bd6366988d12e122ee3d420e8c/lib/macho/fat_file.rb#L256-L262
|
17,532
|
Homebrew/ruby-macho
|
lib/macho/fat_file.rb
|
MachO.FatFile.delete_rpath
|
def delete_rpath(path, options = {})
each_macho(options) do |macho|
macho.delete_rpath(path, options)
end
repopulate_raw_machos
end
|
ruby
|
def delete_rpath(path, options = {})
each_macho(options) do |macho|
macho.delete_rpath(path, options)
end
repopulate_raw_machos
end
|
[
"def",
"delete_rpath",
"(",
"path",
",",
"options",
"=",
"{",
"}",
")",
"each_macho",
"(",
"options",
")",
"do",
"|",
"macho",
"|",
"macho",
".",
"delete_rpath",
"(",
"path",
",",
"options",
")",
"end",
"repopulate_raw_machos",
"end"
] |
Delete the given runtime path from the file's Mach-Os.
@param path [String] the runtime path to delete
@param options [Hash]
@option options [Boolean] :strict (true) if true, fail if one slice fails.
if false, fail only if all slices fail.
@return void
@see MachOFile#delete_rpath
|
[
"Delete",
"the",
"given",
"runtime",
"path",
"from",
"the",
"file",
"s",
"Mach",
"-",
"Os",
"."
] |
a1dedc25bc78a9bd6366988d12e122ee3d420e8c
|
https://github.com/Homebrew/ruby-macho/blob/a1dedc25bc78a9bd6366988d12e122ee3d420e8c/lib/macho/fat_file.rb#L271-L277
|
17,533
|
Homebrew/ruby-macho
|
lib/macho/fat_file.rb
|
MachO.FatFile.populate_fat_header
|
def populate_fat_header
# the smallest fat Mach-O header is 8 bytes
raise TruncatedFileError if @raw_data.size < 8
fh = Headers::FatHeader.new_from_bin(:big, @raw_data[0, Headers::FatHeader.bytesize])
raise MagicError, fh.magic unless Utils.magic?(fh.magic)
raise MachOBinaryError unless Utils.fat_magic?(fh.magic)
# Rationale: Java classfiles have the same magic as big-endian fat
# Mach-Os. Classfiles encode their version at the same offset as
# `nfat_arch` and the lowest version number is 43, so we error out
# if a file claims to have over 30 internal architectures. It's
# technically possible for a fat Mach-O to have over 30 architectures,
# but this is extremely unlikely and in practice distinguishes the two
# formats.
raise JavaClassFileError if fh.nfat_arch > 30
fh
end
|
ruby
|
def populate_fat_header
# the smallest fat Mach-O header is 8 bytes
raise TruncatedFileError if @raw_data.size < 8
fh = Headers::FatHeader.new_from_bin(:big, @raw_data[0, Headers::FatHeader.bytesize])
raise MagicError, fh.magic unless Utils.magic?(fh.magic)
raise MachOBinaryError unless Utils.fat_magic?(fh.magic)
# Rationale: Java classfiles have the same magic as big-endian fat
# Mach-Os. Classfiles encode their version at the same offset as
# `nfat_arch` and the lowest version number is 43, so we error out
# if a file claims to have over 30 internal architectures. It's
# technically possible for a fat Mach-O to have over 30 architectures,
# but this is extremely unlikely and in practice distinguishes the two
# formats.
raise JavaClassFileError if fh.nfat_arch > 30
fh
end
|
[
"def",
"populate_fat_header",
"# the smallest fat Mach-O header is 8 bytes",
"raise",
"TruncatedFileError",
"if",
"@raw_data",
".",
"size",
"<",
"8",
"fh",
"=",
"Headers",
"::",
"FatHeader",
".",
"new_from_bin",
"(",
":big",
",",
"@raw_data",
"[",
"0",
",",
"Headers",
"::",
"FatHeader",
".",
"bytesize",
"]",
")",
"raise",
"MagicError",
",",
"fh",
".",
"magic",
"unless",
"Utils",
".",
"magic?",
"(",
"fh",
".",
"magic",
")",
"raise",
"MachOBinaryError",
"unless",
"Utils",
".",
"fat_magic?",
"(",
"fh",
".",
"magic",
")",
"# Rationale: Java classfiles have the same magic as big-endian fat",
"# Mach-Os. Classfiles encode their version at the same offset as",
"# `nfat_arch` and the lowest version number is 43, so we error out",
"# if a file claims to have over 30 internal architectures. It's",
"# technically possible for a fat Mach-O to have over 30 architectures,",
"# but this is extremely unlikely and in practice distinguishes the two",
"# formats.",
"raise",
"JavaClassFileError",
"if",
"fh",
".",
"nfat_arch",
">",
"30",
"fh",
"end"
] |
Obtain the fat header from raw file data.
@return [Headers::FatHeader] the fat header
@raise [TruncatedFileError] if the file is too small to have a
valid header
@raise [MagicError] if the magic is not valid Mach-O magic
@raise [MachOBinaryError] if the magic is for a non-fat Mach-O file
@raise [JavaClassFileError] if the file is a Java classfile
@api private
|
[
"Obtain",
"the",
"fat",
"header",
"from",
"raw",
"file",
"data",
"."
] |
a1dedc25bc78a9bd6366988d12e122ee3d420e8c
|
https://github.com/Homebrew/ruby-macho/blob/a1dedc25bc78a9bd6366988d12e122ee3d420e8c/lib/macho/fat_file.rb#L324-L343
|
17,534
|
Homebrew/ruby-macho
|
lib/macho/fat_file.rb
|
MachO.FatFile.populate_fat_archs
|
def populate_fat_archs
archs = []
fa_klass = Utils.fat_magic32?(header.magic) ? Headers::FatArch : Headers::FatArch64
fa_off = Headers::FatHeader.bytesize
fa_len = fa_klass.bytesize
header.nfat_arch.times do |i|
archs << fa_klass.new_from_bin(:big, @raw_data[fa_off + (fa_len * i), fa_len])
end
archs
end
|
ruby
|
def populate_fat_archs
archs = []
fa_klass = Utils.fat_magic32?(header.magic) ? Headers::FatArch : Headers::FatArch64
fa_off = Headers::FatHeader.bytesize
fa_len = fa_klass.bytesize
header.nfat_arch.times do |i|
archs << fa_klass.new_from_bin(:big, @raw_data[fa_off + (fa_len * i), fa_len])
end
archs
end
|
[
"def",
"populate_fat_archs",
"archs",
"=",
"[",
"]",
"fa_klass",
"=",
"Utils",
".",
"fat_magic32?",
"(",
"header",
".",
"magic",
")",
"?",
"Headers",
"::",
"FatArch",
":",
"Headers",
"::",
"FatArch64",
"fa_off",
"=",
"Headers",
"::",
"FatHeader",
".",
"bytesize",
"fa_len",
"=",
"fa_klass",
".",
"bytesize",
"header",
".",
"nfat_arch",
".",
"times",
"do",
"|",
"i",
"|",
"archs",
"<<",
"fa_klass",
".",
"new_from_bin",
"(",
":big",
",",
"@raw_data",
"[",
"fa_off",
"+",
"(",
"fa_len",
"*",
"i",
")",
",",
"fa_len",
"]",
")",
"end",
"archs",
"end"
] |
Obtain an array of fat architectures from raw file data.
@return [Array<Headers::FatArch>] an array of fat architectures
@api private
|
[
"Obtain",
"an",
"array",
"of",
"fat",
"architectures",
"from",
"raw",
"file",
"data",
"."
] |
a1dedc25bc78a9bd6366988d12e122ee3d420e8c
|
https://github.com/Homebrew/ruby-macho/blob/a1dedc25bc78a9bd6366988d12e122ee3d420e8c/lib/macho/fat_file.rb#L348-L360
|
17,535
|
Homebrew/ruby-macho
|
lib/macho/fat_file.rb
|
MachO.FatFile.populate_machos
|
def populate_machos
machos = []
fat_archs.each do |arch|
machos << MachOFile.new_from_bin(@raw_data[arch.offset, arch.size], **options)
end
machos
end
|
ruby
|
def populate_machos
machos = []
fat_archs.each do |arch|
machos << MachOFile.new_from_bin(@raw_data[arch.offset, arch.size], **options)
end
machos
end
|
[
"def",
"populate_machos",
"machos",
"=",
"[",
"]",
"fat_archs",
".",
"each",
"do",
"|",
"arch",
"|",
"machos",
"<<",
"MachOFile",
".",
"new_from_bin",
"(",
"@raw_data",
"[",
"arch",
".",
"offset",
",",
"arch",
".",
"size",
"]",
",",
"**",
"options",
")",
"end",
"machos",
"end"
] |
Obtain an array of Mach-O blobs from raw file data.
@return [Array<MachOFile>] an array of Mach-Os
@api private
|
[
"Obtain",
"an",
"array",
"of",
"Mach",
"-",
"O",
"blobs",
"from",
"raw",
"file",
"data",
"."
] |
a1dedc25bc78a9bd6366988d12e122ee3d420e8c
|
https://github.com/Homebrew/ruby-macho/blob/a1dedc25bc78a9bd6366988d12e122ee3d420e8c/lib/macho/fat_file.rb#L365-L373
|
17,536
|
Homebrew/ruby-macho
|
lib/macho/fat_file.rb
|
MachO.FatFile.repopulate_raw_machos
|
def repopulate_raw_machos
machos.each_with_index do |macho, i|
arch = fat_archs[i]
@raw_data[arch.offset, arch.size] = macho.serialize
end
end
|
ruby
|
def repopulate_raw_machos
machos.each_with_index do |macho, i|
arch = fat_archs[i]
@raw_data[arch.offset, arch.size] = macho.serialize
end
end
|
[
"def",
"repopulate_raw_machos",
"machos",
".",
"each_with_index",
"do",
"|",
"macho",
",",
"i",
"|",
"arch",
"=",
"fat_archs",
"[",
"i",
"]",
"@raw_data",
"[",
"arch",
".",
"offset",
",",
"arch",
".",
"size",
"]",
"=",
"macho",
".",
"serialize",
"end",
"end"
] |
Repopulate the raw Mach-O data with each internal Mach-O object.
@return [void]
@api private
|
[
"Repopulate",
"the",
"raw",
"Mach",
"-",
"O",
"data",
"with",
"each",
"internal",
"Mach",
"-",
"O",
"object",
"."
] |
a1dedc25bc78a9bd6366988d12e122ee3d420e8c
|
https://github.com/Homebrew/ruby-macho/blob/a1dedc25bc78a9bd6366988d12e122ee3d420e8c/lib/macho/fat_file.rb#L378-L384
|
17,537
|
Homebrew/ruby-macho
|
lib/macho/fat_file.rb
|
MachO.FatFile.each_macho
|
def each_macho(options = {})
strict = options.fetch(:strict, true)
errors = []
machos.each_with_index do |macho, index|
begin
yield macho
rescue RecoverableModificationError => e
e.macho_slice = index
# Strict mode: Immediately re-raise. Otherwise: Retain, check later.
raise e if strict
errors << e
end
end
# Non-strict mode: Raise first error if *all* Mach-O slices failed.
raise errors.first if errors.size == machos.size
end
|
ruby
|
def each_macho(options = {})
strict = options.fetch(:strict, true)
errors = []
machos.each_with_index do |macho, index|
begin
yield macho
rescue RecoverableModificationError => e
e.macho_slice = index
# Strict mode: Immediately re-raise. Otherwise: Retain, check later.
raise e if strict
errors << e
end
end
# Non-strict mode: Raise first error if *all* Mach-O slices failed.
raise errors.first if errors.size == machos.size
end
|
[
"def",
"each_macho",
"(",
"options",
"=",
"{",
"}",
")",
"strict",
"=",
"options",
".",
"fetch",
"(",
":strict",
",",
"true",
")",
"errors",
"=",
"[",
"]",
"machos",
".",
"each_with_index",
"do",
"|",
"macho",
",",
"index",
"|",
"begin",
"yield",
"macho",
"rescue",
"RecoverableModificationError",
"=>",
"e",
"e",
".",
"macho_slice",
"=",
"index",
"# Strict mode: Immediately re-raise. Otherwise: Retain, check later.",
"raise",
"e",
"if",
"strict",
"errors",
"<<",
"e",
"end",
"end",
"# Non-strict mode: Raise first error if *all* Mach-O slices failed.",
"raise",
"errors",
".",
"first",
"if",
"errors",
".",
"size",
"==",
"machos",
".",
"size",
"end"
] |
Yield each Mach-O object in the file, rescuing and accumulating errors.
@param options [Hash]
@option options [Boolean] :strict (true) whether or not to fail loudly
with an exception if at least one Mach-O raises an exception. If false,
only raises an exception if *all* Mach-Os raise exceptions.
@raise [RecoverableModificationError] under the conditions of
the `:strict` option above.
@api private
|
[
"Yield",
"each",
"Mach",
"-",
"O",
"object",
"in",
"the",
"file",
"rescuing",
"and",
"accumulating",
"errors",
"."
] |
a1dedc25bc78a9bd6366988d12e122ee3d420e8c
|
https://github.com/Homebrew/ruby-macho/blob/a1dedc25bc78a9bd6366988d12e122ee3d420e8c/lib/macho/fat_file.rb#L394-L413
|
17,538
|
Homebrew/ruby-macho
|
lib/macho/macho_file.rb
|
MachO.MachOFile.insert_command
|
def insert_command(offset, lc, options = {})
context = LoadCommands::LoadCommand::SerializationContext.context_for(self)
cmd_raw = lc.serialize(context)
fileoff = offset + cmd_raw.bytesize
raise OffsetInsertionError, offset if offset < header.class.bytesize || fileoff > low_fileoff
new_sizeofcmds = sizeofcmds + cmd_raw.bytesize
raise HeaderPadError, @filename if header.class.bytesize + new_sizeofcmds > low_fileoff
# update Mach-O header fields to account for inserted load command
update_ncmds(ncmds + 1)
update_sizeofcmds(new_sizeofcmds)
@raw_data.insert(offset, cmd_raw)
@raw_data.slice!(header.class.bytesize + new_sizeofcmds, cmd_raw.bytesize)
populate_fields if options.fetch(:repopulate, true)
end
|
ruby
|
def insert_command(offset, lc, options = {})
context = LoadCommands::LoadCommand::SerializationContext.context_for(self)
cmd_raw = lc.serialize(context)
fileoff = offset + cmd_raw.bytesize
raise OffsetInsertionError, offset if offset < header.class.bytesize || fileoff > low_fileoff
new_sizeofcmds = sizeofcmds + cmd_raw.bytesize
raise HeaderPadError, @filename if header.class.bytesize + new_sizeofcmds > low_fileoff
# update Mach-O header fields to account for inserted load command
update_ncmds(ncmds + 1)
update_sizeofcmds(new_sizeofcmds)
@raw_data.insert(offset, cmd_raw)
@raw_data.slice!(header.class.bytesize + new_sizeofcmds, cmd_raw.bytesize)
populate_fields if options.fetch(:repopulate, true)
end
|
[
"def",
"insert_command",
"(",
"offset",
",",
"lc",
",",
"options",
"=",
"{",
"}",
")",
"context",
"=",
"LoadCommands",
"::",
"LoadCommand",
"::",
"SerializationContext",
".",
"context_for",
"(",
"self",
")",
"cmd_raw",
"=",
"lc",
".",
"serialize",
"(",
"context",
")",
"fileoff",
"=",
"offset",
"+",
"cmd_raw",
".",
"bytesize",
"raise",
"OffsetInsertionError",
",",
"offset",
"if",
"offset",
"<",
"header",
".",
"class",
".",
"bytesize",
"||",
"fileoff",
">",
"low_fileoff",
"new_sizeofcmds",
"=",
"sizeofcmds",
"+",
"cmd_raw",
".",
"bytesize",
"raise",
"HeaderPadError",
",",
"@filename",
"if",
"header",
".",
"class",
".",
"bytesize",
"+",
"new_sizeofcmds",
">",
"low_fileoff",
"# update Mach-O header fields to account for inserted load command",
"update_ncmds",
"(",
"ncmds",
"+",
"1",
")",
"update_sizeofcmds",
"(",
"new_sizeofcmds",
")",
"@raw_data",
".",
"insert",
"(",
"offset",
",",
"cmd_raw",
")",
"@raw_data",
".",
"slice!",
"(",
"header",
".",
"class",
".",
"bytesize",
"+",
"new_sizeofcmds",
",",
"cmd_raw",
".",
"bytesize",
")",
"populate_fields",
"if",
"options",
".",
"fetch",
"(",
":repopulate",
",",
"true",
")",
"end"
] |
Inserts a load command at the given offset.
@param offset [Integer] the offset to insert at
@param lc [LoadCommands::LoadCommand] the load command to insert
@param options [Hash]
@option options [Boolean] :repopulate (true) whether or not to repopulate
the instance fields
@raise [OffsetInsertionError] if the offset is not in the load command region
@raise [HeaderPadError] if the new command exceeds the header pad buffer
@note Calling this method with an arbitrary offset in the load command
region **will leave the object in an inconsistent state**.
|
[
"Inserts",
"a",
"load",
"command",
"at",
"the",
"given",
"offset",
"."
] |
a1dedc25bc78a9bd6366988d12e122ee3d420e8c
|
https://github.com/Homebrew/ruby-macho/blob/a1dedc25bc78a9bd6366988d12e122ee3d420e8c/lib/macho/macho_file.rb#L155-L174
|
17,539
|
Homebrew/ruby-macho
|
lib/macho/macho_file.rb
|
MachO.MachOFile.replace_command
|
def replace_command(old_lc, new_lc)
context = LoadCommands::LoadCommand::SerializationContext.context_for(self)
cmd_raw = new_lc.serialize(context)
new_sizeofcmds = sizeofcmds + cmd_raw.bytesize - old_lc.cmdsize
raise HeaderPadError, @filename if header.class.bytesize + new_sizeofcmds > low_fileoff
delete_command(old_lc)
insert_command(old_lc.view.offset, new_lc)
end
|
ruby
|
def replace_command(old_lc, new_lc)
context = LoadCommands::LoadCommand::SerializationContext.context_for(self)
cmd_raw = new_lc.serialize(context)
new_sizeofcmds = sizeofcmds + cmd_raw.bytesize - old_lc.cmdsize
raise HeaderPadError, @filename if header.class.bytesize + new_sizeofcmds > low_fileoff
delete_command(old_lc)
insert_command(old_lc.view.offset, new_lc)
end
|
[
"def",
"replace_command",
"(",
"old_lc",
",",
"new_lc",
")",
"context",
"=",
"LoadCommands",
"::",
"LoadCommand",
"::",
"SerializationContext",
".",
"context_for",
"(",
"self",
")",
"cmd_raw",
"=",
"new_lc",
".",
"serialize",
"(",
"context",
")",
"new_sizeofcmds",
"=",
"sizeofcmds",
"+",
"cmd_raw",
".",
"bytesize",
"-",
"old_lc",
".",
"cmdsize",
"raise",
"HeaderPadError",
",",
"@filename",
"if",
"header",
".",
"class",
".",
"bytesize",
"+",
"new_sizeofcmds",
">",
"low_fileoff",
"delete_command",
"(",
"old_lc",
")",
"insert_command",
"(",
"old_lc",
".",
"view",
".",
"offset",
",",
"new_lc",
")",
"end"
] |
Replace a load command with another command in the Mach-O, preserving location.
@param old_lc [LoadCommands::LoadCommand] the load command being replaced
@param new_lc [LoadCommands::LoadCommand] the load command being added
@return [void]
@raise [HeaderPadError] if the new command exceeds the header pad buffer
@see #insert_command
@note This is public, but methods like {#dylib_id=} should be preferred.
|
[
"Replace",
"a",
"load",
"command",
"with",
"another",
"command",
"in",
"the",
"Mach",
"-",
"O",
"preserving",
"location",
"."
] |
a1dedc25bc78a9bd6366988d12e122ee3d420e8c
|
https://github.com/Homebrew/ruby-macho/blob/a1dedc25bc78a9bd6366988d12e122ee3d420e8c/lib/macho/macho_file.rb#L183-L192
|
17,540
|
Homebrew/ruby-macho
|
lib/macho/macho_file.rb
|
MachO.MachOFile.delete_command
|
def delete_command(lc, options = {})
@raw_data.slice!(lc.view.offset, lc.cmdsize)
# update Mach-O header fields to account for deleted load command
update_ncmds(ncmds - 1)
update_sizeofcmds(sizeofcmds - lc.cmdsize)
# pad the space after the load commands to preserve offsets
@raw_data.insert(header.class.bytesize + sizeofcmds - lc.cmdsize, Utils.nullpad(lc.cmdsize))
populate_fields if options.fetch(:repopulate, true)
end
|
ruby
|
def delete_command(lc, options = {})
@raw_data.slice!(lc.view.offset, lc.cmdsize)
# update Mach-O header fields to account for deleted load command
update_ncmds(ncmds - 1)
update_sizeofcmds(sizeofcmds - lc.cmdsize)
# pad the space after the load commands to preserve offsets
@raw_data.insert(header.class.bytesize + sizeofcmds - lc.cmdsize, Utils.nullpad(lc.cmdsize))
populate_fields if options.fetch(:repopulate, true)
end
|
[
"def",
"delete_command",
"(",
"lc",
",",
"options",
"=",
"{",
"}",
")",
"@raw_data",
".",
"slice!",
"(",
"lc",
".",
"view",
".",
"offset",
",",
"lc",
".",
"cmdsize",
")",
"# update Mach-O header fields to account for deleted load command",
"update_ncmds",
"(",
"ncmds",
"-",
"1",
")",
"update_sizeofcmds",
"(",
"sizeofcmds",
"-",
"lc",
".",
"cmdsize",
")",
"# pad the space after the load commands to preserve offsets",
"@raw_data",
".",
"insert",
"(",
"header",
".",
"class",
".",
"bytesize",
"+",
"sizeofcmds",
"-",
"lc",
".",
"cmdsize",
",",
"Utils",
".",
"nullpad",
"(",
"lc",
".",
"cmdsize",
")",
")",
"populate_fields",
"if",
"options",
".",
"fetch",
"(",
":repopulate",
",",
"true",
")",
"end"
] |
Delete a load command from the Mach-O.
@param lc [LoadCommands::LoadCommand] the load command being deleted
@param options [Hash]
@option options [Boolean] :repopulate (true) whether or not to repopulate
the instance fields
@return [void]
@note This is public, but methods like {#delete_rpath} should be preferred.
Setting `repopulate` to false **will leave the instance in an
inconsistent state** unless {#populate_fields} is called **immediately**
afterwards.
|
[
"Delete",
"a",
"load",
"command",
"from",
"the",
"Mach",
"-",
"O",
"."
] |
a1dedc25bc78a9bd6366988d12e122ee3d420e8c
|
https://github.com/Homebrew/ruby-macho/blob/a1dedc25bc78a9bd6366988d12e122ee3d420e8c/lib/macho/macho_file.rb#L219-L230
|
17,541
|
Homebrew/ruby-macho
|
lib/macho/macho_file.rb
|
MachO.MachOFile.segment_alignment
|
def segment_alignment
# special cases: 12 for x86/64/PPC/PP64, 14 for ARM/ARM64
return 12 if %i[i386 x86_64 ppc ppc64].include?(cputype)
return 14 if %i[arm arm64].include?(cputype)
cur_align = Sections::MAX_SECT_ALIGN
segments.each do |segment|
if filetype == :object
# start with the smallest alignment, and work our way up
align = magic32? ? 2 : 3
segment.sections.each do |section|
align = section.align unless section.align <= align
end
else
align = segment.guess_align
end
cur_align = align if align < cur_align
end
cur_align
end
|
ruby
|
def segment_alignment
# special cases: 12 for x86/64/PPC/PP64, 14 for ARM/ARM64
return 12 if %i[i386 x86_64 ppc ppc64].include?(cputype)
return 14 if %i[arm arm64].include?(cputype)
cur_align = Sections::MAX_SECT_ALIGN
segments.each do |segment|
if filetype == :object
# start with the smallest alignment, and work our way up
align = magic32? ? 2 : 3
segment.sections.each do |section|
align = section.align unless section.align <= align
end
else
align = segment.guess_align
end
cur_align = align if align < cur_align
end
cur_align
end
|
[
"def",
"segment_alignment",
"# special cases: 12 for x86/64/PPC/PP64, 14 for ARM/ARM64",
"return",
"12",
"if",
"%i[",
"i386",
"x86_64",
"ppc",
"ppc64",
"]",
".",
"include?",
"(",
"cputype",
")",
"return",
"14",
"if",
"%i[",
"arm",
"arm64",
"]",
".",
"include?",
"(",
"cputype",
")",
"cur_align",
"=",
"Sections",
"::",
"MAX_SECT_ALIGN",
"segments",
".",
"each",
"do",
"|",
"segment",
"|",
"if",
"filetype",
"==",
":object",
"# start with the smallest alignment, and work our way up",
"align",
"=",
"magic32?",
"?",
"2",
":",
"3",
"segment",
".",
"sections",
".",
"each",
"do",
"|",
"section",
"|",
"align",
"=",
"section",
".",
"align",
"unless",
"section",
".",
"align",
"<=",
"align",
"end",
"else",
"align",
"=",
"segment",
".",
"guess_align",
"end",
"cur_align",
"=",
"align",
"if",
"align",
"<",
"cur_align",
"end",
"cur_align",
"end"
] |
The segment alignment for the Mach-O. Guesses conservatively.
@return [Integer] the alignment, as a power of 2
@note This is **not** the same as {#alignment}!
@note See `get_align` and `get_align_64` in `cctools/misc/lipo.c`
|
[
"The",
"segment",
"alignment",
"for",
"the",
"Mach",
"-",
"O",
".",
"Guesses",
"conservatively",
"."
] |
a1dedc25bc78a9bd6366988d12e122ee3d420e8c
|
https://github.com/Homebrew/ruby-macho/blob/a1dedc25bc78a9bd6366988d12e122ee3d420e8c/lib/macho/macho_file.rb#L263-L284
|
17,542
|
Homebrew/ruby-macho
|
lib/macho/macho_file.rb
|
MachO.MachOFile.change_dylib_id
|
def change_dylib_id(new_id, _options = {})
raise ArgumentError, "new ID must be a String" unless new_id.is_a?(String)
return unless dylib?
old_lc = command(:LC_ID_DYLIB).first
raise DylibIdMissingError unless old_lc
new_lc = LoadCommands::LoadCommand.create(:LC_ID_DYLIB, new_id,
old_lc.timestamp,
old_lc.current_version,
old_lc.compatibility_version)
replace_command(old_lc, new_lc)
end
|
ruby
|
def change_dylib_id(new_id, _options = {})
raise ArgumentError, "new ID must be a String" unless new_id.is_a?(String)
return unless dylib?
old_lc = command(:LC_ID_DYLIB).first
raise DylibIdMissingError unless old_lc
new_lc = LoadCommands::LoadCommand.create(:LC_ID_DYLIB, new_id,
old_lc.timestamp,
old_lc.current_version,
old_lc.compatibility_version)
replace_command(old_lc, new_lc)
end
|
[
"def",
"change_dylib_id",
"(",
"new_id",
",",
"_options",
"=",
"{",
"}",
")",
"raise",
"ArgumentError",
",",
"\"new ID must be a String\"",
"unless",
"new_id",
".",
"is_a?",
"(",
"String",
")",
"return",
"unless",
"dylib?",
"old_lc",
"=",
"command",
"(",
":LC_ID_DYLIB",
")",
".",
"first",
"raise",
"DylibIdMissingError",
"unless",
"old_lc",
"new_lc",
"=",
"LoadCommands",
"::",
"LoadCommand",
".",
"create",
"(",
":LC_ID_DYLIB",
",",
"new_id",
",",
"old_lc",
".",
"timestamp",
",",
"old_lc",
".",
"current_version",
",",
"old_lc",
".",
"compatibility_version",
")",
"replace_command",
"(",
"old_lc",
",",
"new_lc",
")",
"end"
] |
Changes the Mach-O's dylib ID to `new_id`. Does nothing if not a dylib.
@example
file.change_dylib_id("libFoo.dylib")
@param new_id [String] the dylib's new ID
@param _options [Hash]
@return [void]
@raise [ArgumentError] if `new_id` is not a String
@note `_options` is currently unused and is provided for signature
compatibility with {MachO::FatFile#change_dylib_id}
|
[
"Changes",
"the",
"Mach",
"-",
"O",
"s",
"dylib",
"ID",
"to",
"new_id",
".",
"Does",
"nothing",
"if",
"not",
"a",
"dylib",
"."
] |
a1dedc25bc78a9bd6366988d12e122ee3d420e8c
|
https://github.com/Homebrew/ruby-macho/blob/a1dedc25bc78a9bd6366988d12e122ee3d420e8c/lib/macho/macho_file.rb#L307-L320
|
17,543
|
Homebrew/ruby-macho
|
lib/macho/macho_file.rb
|
MachO.MachOFile.change_install_name
|
def change_install_name(old_name, new_name, _options = {})
old_lc = dylib_load_commands.find { |d| d.name.to_s == old_name }
raise DylibUnknownError, old_name if old_lc.nil?
new_lc = LoadCommands::LoadCommand.create(old_lc.type, new_name,
old_lc.timestamp,
old_lc.current_version,
old_lc.compatibility_version)
replace_command(old_lc, new_lc)
end
|
ruby
|
def change_install_name(old_name, new_name, _options = {})
old_lc = dylib_load_commands.find { |d| d.name.to_s == old_name }
raise DylibUnknownError, old_name if old_lc.nil?
new_lc = LoadCommands::LoadCommand.create(old_lc.type, new_name,
old_lc.timestamp,
old_lc.current_version,
old_lc.compatibility_version)
replace_command(old_lc, new_lc)
end
|
[
"def",
"change_install_name",
"(",
"old_name",
",",
"new_name",
",",
"_options",
"=",
"{",
"}",
")",
"old_lc",
"=",
"dylib_load_commands",
".",
"find",
"{",
"|",
"d",
"|",
"d",
".",
"name",
".",
"to_s",
"==",
"old_name",
"}",
"raise",
"DylibUnknownError",
",",
"old_name",
"if",
"old_lc",
".",
"nil?",
"new_lc",
"=",
"LoadCommands",
"::",
"LoadCommand",
".",
"create",
"(",
"old_lc",
".",
"type",
",",
"new_name",
",",
"old_lc",
".",
"timestamp",
",",
"old_lc",
".",
"current_version",
",",
"old_lc",
".",
"compatibility_version",
")",
"replace_command",
"(",
"old_lc",
",",
"new_lc",
")",
"end"
] |
Changes the shared library `old_name` to `new_name`
@example
file.change_install_name("abc.dylib", "def.dylib")
@param old_name [String] the shared library's old name
@param new_name [String] the shared library's new name
@param _options [Hash]
@return [void]
@raise [DylibUnknownError] if no shared library has the old name
@note `_options` is currently unused and is provided for signature
compatibility with {MachO::FatFile#change_install_name}
|
[
"Changes",
"the",
"shared",
"library",
"old_name",
"to",
"new_name"
] |
a1dedc25bc78a9bd6366988d12e122ee3d420e8c
|
https://github.com/Homebrew/ruby-macho/blob/a1dedc25bc78a9bd6366988d12e122ee3d420e8c/lib/macho/macho_file.rb#L344-L354
|
17,544
|
Homebrew/ruby-macho
|
lib/macho/macho_file.rb
|
MachO.MachOFile.change_rpath
|
def change_rpath(old_path, new_path, _options = {})
old_lc = command(:LC_RPATH).find { |r| r.path.to_s == old_path }
raise RpathUnknownError, old_path if old_lc.nil?
raise RpathExistsError, new_path if rpaths.include?(new_path)
new_lc = LoadCommands::LoadCommand.create(:LC_RPATH, new_path)
delete_rpath(old_path)
insert_command(old_lc.view.offset, new_lc)
end
|
ruby
|
def change_rpath(old_path, new_path, _options = {})
old_lc = command(:LC_RPATH).find { |r| r.path.to_s == old_path }
raise RpathUnknownError, old_path if old_lc.nil?
raise RpathExistsError, new_path if rpaths.include?(new_path)
new_lc = LoadCommands::LoadCommand.create(:LC_RPATH, new_path)
delete_rpath(old_path)
insert_command(old_lc.view.offset, new_lc)
end
|
[
"def",
"change_rpath",
"(",
"old_path",
",",
"new_path",
",",
"_options",
"=",
"{",
"}",
")",
"old_lc",
"=",
"command",
"(",
":LC_RPATH",
")",
".",
"find",
"{",
"|",
"r",
"|",
"r",
".",
"path",
".",
"to_s",
"==",
"old_path",
"}",
"raise",
"RpathUnknownError",
",",
"old_path",
"if",
"old_lc",
".",
"nil?",
"raise",
"RpathExistsError",
",",
"new_path",
"if",
"rpaths",
".",
"include?",
"(",
"new_path",
")",
"new_lc",
"=",
"LoadCommands",
"::",
"LoadCommand",
".",
"create",
"(",
":LC_RPATH",
",",
"new_path",
")",
"delete_rpath",
"(",
"old_path",
")",
"insert_command",
"(",
"old_lc",
".",
"view",
".",
"offset",
",",
"new_lc",
")",
"end"
] |
Changes the runtime path `old_path` to `new_path`
@example
file.change_rpath("/usr/lib", "/usr/local/lib")
@param old_path [String] the old runtime path
@param new_path [String] the new runtime path
@param _options [Hash]
@return [void]
@raise [RpathUnknownError] if no such old runtime path exists
@raise [RpathExistsError] if the new runtime path already exists
@note `_options` is currently unused and is provided for signature
compatibility with {MachO::FatFile#change_rpath}
|
[
"Changes",
"the",
"runtime",
"path",
"old_path",
"to",
"new_path"
] |
a1dedc25bc78a9bd6366988d12e122ee3d420e8c
|
https://github.com/Homebrew/ruby-macho/blob/a1dedc25bc78a9bd6366988d12e122ee3d420e8c/lib/macho/macho_file.rb#L375-L384
|
17,545
|
Homebrew/ruby-macho
|
lib/macho/macho_file.rb
|
MachO.MachOFile.add_rpath
|
def add_rpath(path, _options = {})
raise RpathExistsError, path if rpaths.include?(path)
rpath_cmd = LoadCommands::LoadCommand.create(:LC_RPATH, path)
add_command(rpath_cmd)
end
|
ruby
|
def add_rpath(path, _options = {})
raise RpathExistsError, path if rpaths.include?(path)
rpath_cmd = LoadCommands::LoadCommand.create(:LC_RPATH, path)
add_command(rpath_cmd)
end
|
[
"def",
"add_rpath",
"(",
"path",
",",
"_options",
"=",
"{",
"}",
")",
"raise",
"RpathExistsError",
",",
"path",
"if",
"rpaths",
".",
"include?",
"(",
"path",
")",
"rpath_cmd",
"=",
"LoadCommands",
"::",
"LoadCommand",
".",
"create",
"(",
":LC_RPATH",
",",
"path",
")",
"add_command",
"(",
"rpath_cmd",
")",
"end"
] |
Add the given runtime path to the Mach-O.
@example
file.rpaths # => ["/lib"]
file.add_rpath("/usr/lib")
file.rpaths # => ["/lib", "/usr/lib"]
@param path [String] the new runtime path
@param _options [Hash]
@return [void]
@raise [RpathExistsError] if the runtime path already exists
@note `_options` is currently unused and is provided for signature
compatibility with {MachO::FatFile#add_rpath}
|
[
"Add",
"the",
"given",
"runtime",
"path",
"to",
"the",
"Mach",
"-",
"O",
"."
] |
a1dedc25bc78a9bd6366988d12e122ee3d420e8c
|
https://github.com/Homebrew/ruby-macho/blob/a1dedc25bc78a9bd6366988d12e122ee3d420e8c/lib/macho/macho_file.rb#L397-L402
|
17,546
|
Homebrew/ruby-macho
|
lib/macho/macho_file.rb
|
MachO.MachOFile.delete_rpath
|
def delete_rpath(path, _options = {})
rpath_cmds = command(:LC_RPATH).select { |r| r.path.to_s == path }
raise RpathUnknownError, path if rpath_cmds.empty?
# delete the commands in reverse order, offset descending. this
# allows us to defer (expensive) field population until the very end
rpath_cmds.reverse_each { |cmd| delete_command(cmd, :repopulate => false) }
populate_fields
end
|
ruby
|
def delete_rpath(path, _options = {})
rpath_cmds = command(:LC_RPATH).select { |r| r.path.to_s == path }
raise RpathUnknownError, path if rpath_cmds.empty?
# delete the commands in reverse order, offset descending. this
# allows us to defer (expensive) field population until the very end
rpath_cmds.reverse_each { |cmd| delete_command(cmd, :repopulate => false) }
populate_fields
end
|
[
"def",
"delete_rpath",
"(",
"path",
",",
"_options",
"=",
"{",
"}",
")",
"rpath_cmds",
"=",
"command",
"(",
":LC_RPATH",
")",
".",
"select",
"{",
"|",
"r",
"|",
"r",
".",
"path",
".",
"to_s",
"==",
"path",
"}",
"raise",
"RpathUnknownError",
",",
"path",
"if",
"rpath_cmds",
".",
"empty?",
"# delete the commands in reverse order, offset descending. this",
"# allows us to defer (expensive) field population until the very end",
"rpath_cmds",
".",
"reverse_each",
"{",
"|",
"cmd",
"|",
"delete_command",
"(",
"cmd",
",",
":repopulate",
"=>",
"false",
")",
"}",
"populate_fields",
"end"
] |
Delete the given runtime path from the Mach-O.
@example
file.rpaths # => ["/lib"]
file.delete_rpath("/lib")
file.rpaths # => []
@param path [String] the runtime path to delete
@param _options [Hash]
@return void
@raise [RpathUnknownError] if no such runtime path exists
@note `_options` is currently unused and is provided for signature
compatibility with {MachO::FatFile#delete_rpath}
|
[
"Delete",
"the",
"given",
"runtime",
"path",
"from",
"the",
"Mach",
"-",
"O",
"."
] |
a1dedc25bc78a9bd6366988d12e122ee3d420e8c
|
https://github.com/Homebrew/ruby-macho/blob/a1dedc25bc78a9bd6366988d12e122ee3d420e8c/lib/macho/macho_file.rb#L415-L424
|
17,547
|
Homebrew/ruby-macho
|
lib/macho/macho_file.rb
|
MachO.MachOFile.populate_mach_header
|
def populate_mach_header
# the smallest Mach-O header is 28 bytes
raise TruncatedFileError if @raw_data.size < 28
magic = populate_and_check_magic
mh_klass = Utils.magic32?(magic) ? Headers::MachHeader : Headers::MachHeader64
mh = mh_klass.new_from_bin(endianness, @raw_data[0, mh_klass.bytesize])
check_cputype(mh.cputype)
check_cpusubtype(mh.cputype, mh.cpusubtype)
check_filetype(mh.filetype)
mh
end
|
ruby
|
def populate_mach_header
# the smallest Mach-O header is 28 bytes
raise TruncatedFileError if @raw_data.size < 28
magic = populate_and_check_magic
mh_klass = Utils.magic32?(magic) ? Headers::MachHeader : Headers::MachHeader64
mh = mh_klass.new_from_bin(endianness, @raw_data[0, mh_klass.bytesize])
check_cputype(mh.cputype)
check_cpusubtype(mh.cputype, mh.cpusubtype)
check_filetype(mh.filetype)
mh
end
|
[
"def",
"populate_mach_header",
"# the smallest Mach-O header is 28 bytes",
"raise",
"TruncatedFileError",
"if",
"@raw_data",
".",
"size",
"<",
"28",
"magic",
"=",
"populate_and_check_magic",
"mh_klass",
"=",
"Utils",
".",
"magic32?",
"(",
"magic",
")",
"?",
"Headers",
"::",
"MachHeader",
":",
"Headers",
"::",
"MachHeader64",
"mh",
"=",
"mh_klass",
".",
"new_from_bin",
"(",
"endianness",
",",
"@raw_data",
"[",
"0",
",",
"mh_klass",
".",
"bytesize",
"]",
")",
"check_cputype",
"(",
"mh",
".",
"cputype",
")",
"check_cpusubtype",
"(",
"mh",
".",
"cputype",
",",
"mh",
".",
"cpusubtype",
")",
"check_filetype",
"(",
"mh",
".",
"filetype",
")",
"mh",
"end"
] |
The file's Mach-O header structure.
@return [Headers::MachHeader] if the Mach-O is 32-bit
@return [Headers::MachHeader64] if the Mach-O is 64-bit
@raise [TruncatedFileError] if the file is too small to have a valid header
@api private
|
[
"The",
"file",
"s",
"Mach",
"-",
"O",
"header",
"structure",
"."
] |
a1dedc25bc78a9bd6366988d12e122ee3d420e8c
|
https://github.com/Homebrew/ruby-macho/blob/a1dedc25bc78a9bd6366988d12e122ee3d420e8c/lib/macho/macho_file.rb#L458-L471
|
17,548
|
Homebrew/ruby-macho
|
lib/macho/macho_file.rb
|
MachO.MachOFile.populate_and_check_magic
|
def populate_and_check_magic
magic = @raw_data[0..3].unpack("N").first
raise MagicError, magic unless Utils.magic?(magic)
raise FatBinaryError if Utils.fat_magic?(magic)
@endianness = Utils.little_magic?(magic) ? :little : :big
magic
end
|
ruby
|
def populate_and_check_magic
magic = @raw_data[0..3].unpack("N").first
raise MagicError, magic unless Utils.magic?(magic)
raise FatBinaryError if Utils.fat_magic?(magic)
@endianness = Utils.little_magic?(magic) ? :little : :big
magic
end
|
[
"def",
"populate_and_check_magic",
"magic",
"=",
"@raw_data",
"[",
"0",
"..",
"3",
"]",
".",
"unpack",
"(",
"\"N\"",
")",
".",
"first",
"raise",
"MagicError",
",",
"magic",
"unless",
"Utils",
".",
"magic?",
"(",
"magic",
")",
"raise",
"FatBinaryError",
"if",
"Utils",
".",
"fat_magic?",
"(",
"magic",
")",
"@endianness",
"=",
"Utils",
".",
"little_magic?",
"(",
"magic",
")",
"?",
":little",
":",
":big",
"magic",
"end"
] |
Read just the file's magic number and check its validity.
@return [Integer] the magic
@raise [MagicError] if the magic is not valid Mach-O magic
@raise [FatBinaryError] if the magic is for a Fat file
@api private
|
[
"Read",
"just",
"the",
"file",
"s",
"magic",
"number",
"and",
"check",
"its",
"validity",
"."
] |
a1dedc25bc78a9bd6366988d12e122ee3d420e8c
|
https://github.com/Homebrew/ruby-macho/blob/a1dedc25bc78a9bd6366988d12e122ee3d420e8c/lib/macho/macho_file.rb#L478-L487
|
17,549
|
Homebrew/ruby-macho
|
lib/macho/macho_file.rb
|
MachO.MachOFile.populate_load_commands
|
def populate_load_commands
permissive = options.fetch(:permissive, false)
offset = header.class.bytesize
load_commands = []
header.ncmds.times do
fmt = Utils.specialize_format("L=", endianness)
cmd = @raw_data.slice(offset, 4).unpack(fmt).first
cmd_sym = LoadCommands::LOAD_COMMANDS[cmd]
raise LoadCommandError, cmd unless cmd_sym || permissive
# If we're here, then either cmd_sym represents a valid load
# command *or* we're in permissive mode.
klass = if (klass_str = LoadCommands::LC_STRUCTURES[cmd_sym])
LoadCommands.const_get klass_str
else
LoadCommands::LoadCommand
end
view = MachOView.new(@raw_data, endianness, offset)
command = klass.new_from_bin(view)
load_commands << command
offset += command.cmdsize
end
load_commands
end
|
ruby
|
def populate_load_commands
permissive = options.fetch(:permissive, false)
offset = header.class.bytesize
load_commands = []
header.ncmds.times do
fmt = Utils.specialize_format("L=", endianness)
cmd = @raw_data.slice(offset, 4).unpack(fmt).first
cmd_sym = LoadCommands::LOAD_COMMANDS[cmd]
raise LoadCommandError, cmd unless cmd_sym || permissive
# If we're here, then either cmd_sym represents a valid load
# command *or* we're in permissive mode.
klass = if (klass_str = LoadCommands::LC_STRUCTURES[cmd_sym])
LoadCommands.const_get klass_str
else
LoadCommands::LoadCommand
end
view = MachOView.new(@raw_data, endianness, offset)
command = klass.new_from_bin(view)
load_commands << command
offset += command.cmdsize
end
load_commands
end
|
[
"def",
"populate_load_commands",
"permissive",
"=",
"options",
".",
"fetch",
"(",
":permissive",
",",
"false",
")",
"offset",
"=",
"header",
".",
"class",
".",
"bytesize",
"load_commands",
"=",
"[",
"]",
"header",
".",
"ncmds",
".",
"times",
"do",
"fmt",
"=",
"Utils",
".",
"specialize_format",
"(",
"\"L=\"",
",",
"endianness",
")",
"cmd",
"=",
"@raw_data",
".",
"slice",
"(",
"offset",
",",
"4",
")",
".",
"unpack",
"(",
"fmt",
")",
".",
"first",
"cmd_sym",
"=",
"LoadCommands",
"::",
"LOAD_COMMANDS",
"[",
"cmd",
"]",
"raise",
"LoadCommandError",
",",
"cmd",
"unless",
"cmd_sym",
"||",
"permissive",
"# If we're here, then either cmd_sym represents a valid load",
"# command *or* we're in permissive mode.",
"klass",
"=",
"if",
"(",
"klass_str",
"=",
"LoadCommands",
"::",
"LC_STRUCTURES",
"[",
"cmd_sym",
"]",
")",
"LoadCommands",
".",
"const_get",
"klass_str",
"else",
"LoadCommands",
"::",
"LoadCommand",
"end",
"view",
"=",
"MachOView",
".",
"new",
"(",
"@raw_data",
",",
"endianness",
",",
"offset",
")",
"command",
"=",
"klass",
".",
"new_from_bin",
"(",
"view",
")",
"load_commands",
"<<",
"command",
"offset",
"+=",
"command",
".",
"cmdsize",
"end",
"load_commands",
"end"
] |
All load commands in the file.
@return [Array<LoadCommands::LoadCommand>] an array of load commands
@raise [LoadCommandError] if an unknown load command is encountered
@api private
|
[
"All",
"load",
"commands",
"in",
"the",
"file",
"."
] |
a1dedc25bc78a9bd6366988d12e122ee3d420e8c
|
https://github.com/Homebrew/ruby-macho/blob/a1dedc25bc78a9bd6366988d12e122ee3d420e8c/lib/macho/macho_file.rb#L518-L546
|
17,550
|
Homebrew/ruby-macho
|
lib/macho/macho_file.rb
|
MachO.MachOFile.update_ncmds
|
def update_ncmds(ncmds)
fmt = Utils.specialize_format("L=", endianness)
ncmds_raw = [ncmds].pack(fmt)
@raw_data[16..19] = ncmds_raw
end
|
ruby
|
def update_ncmds(ncmds)
fmt = Utils.specialize_format("L=", endianness)
ncmds_raw = [ncmds].pack(fmt)
@raw_data[16..19] = ncmds_raw
end
|
[
"def",
"update_ncmds",
"(",
"ncmds",
")",
"fmt",
"=",
"Utils",
".",
"specialize_format",
"(",
"\"L=\"",
",",
"endianness",
")",
"ncmds_raw",
"=",
"[",
"ncmds",
"]",
".",
"pack",
"(",
"fmt",
")",
"@raw_data",
"[",
"16",
"..",
"19",
"]",
"=",
"ncmds_raw",
"end"
] |
Updates the number of load commands in the raw data.
@param ncmds [Integer] the new number of commands
@return [void]
@api private
|
[
"Updates",
"the",
"number",
"of",
"load",
"commands",
"in",
"the",
"raw",
"data",
"."
] |
a1dedc25bc78a9bd6366988d12e122ee3d420e8c
|
https://github.com/Homebrew/ruby-macho/blob/a1dedc25bc78a9bd6366988d12e122ee3d420e8c/lib/macho/macho_file.rb#L572-L576
|
17,551
|
Homebrew/ruby-macho
|
lib/macho/macho_file.rb
|
MachO.MachOFile.update_sizeofcmds
|
def update_sizeofcmds(size)
fmt = Utils.specialize_format("L=", endianness)
size_raw = [size].pack(fmt)
@raw_data[20..23] = size_raw
end
|
ruby
|
def update_sizeofcmds(size)
fmt = Utils.specialize_format("L=", endianness)
size_raw = [size].pack(fmt)
@raw_data[20..23] = size_raw
end
|
[
"def",
"update_sizeofcmds",
"(",
"size",
")",
"fmt",
"=",
"Utils",
".",
"specialize_format",
"(",
"\"L=\"",
",",
"endianness",
")",
"size_raw",
"=",
"[",
"size",
"]",
".",
"pack",
"(",
"fmt",
")",
"@raw_data",
"[",
"20",
"..",
"23",
"]",
"=",
"size_raw",
"end"
] |
Updates the size of all load commands in the raw data.
@param size [Integer] the new size, in bytes
@return [void]
@api private
|
[
"Updates",
"the",
"size",
"of",
"all",
"load",
"commands",
"in",
"the",
"raw",
"data",
"."
] |
a1dedc25bc78a9bd6366988d12e122ee3d420e8c
|
https://github.com/Homebrew/ruby-macho/blob/a1dedc25bc78a9bd6366988d12e122ee3d420e8c/lib/macho/macho_file.rb#L582-L586
|
17,552
|
makaroni4/sandi_meter
|
lib/sandi_meter/analyzer.rb
|
SandiMeter.Analyzer.number_of_arguments
|
def number_of_arguments(method_sexp)
arguments = method_sexp[2]
arguments = arguments[1] if arguments.first == :paren
arguments[1] == nil ? 0 : arguments[1].size
end
|
ruby
|
def number_of_arguments(method_sexp)
arguments = method_sexp[2]
arguments = arguments[1] if arguments.first == :paren
arguments[1] == nil ? 0 : arguments[1].size
end
|
[
"def",
"number_of_arguments",
"(",
"method_sexp",
")",
"arguments",
"=",
"method_sexp",
"[",
"2",
"]",
"arguments",
"=",
"arguments",
"[",
"1",
"]",
"if",
"arguments",
".",
"first",
"==",
":paren",
"arguments",
"[",
"1",
"]",
"==",
"nil",
"?",
"0",
":",
"arguments",
"[",
"1",
"]",
".",
"size",
"end"
] |
MOVE
to method scanner class
|
[
"MOVE",
"to",
"method",
"scanner",
"class"
] |
a8d04630cc196edf748ae8cdd66b9c53f0878de0
|
https://github.com/makaroni4/sandi_meter/blob/a8d04630cc196edf748ae8cdd66b9c53f0878de0/lib/sandi_meter/analyzer.rb#L67-L72
|
17,553
|
dnsimple/dnsimple-ruby
|
lib/dnsimple/client.rb
|
Dnsimple.Client.execute
|
def execute(method, path, data = nil, options = {})
response = request(method, path, data, options)
case response.code
when 200..299
response
when 401
raise AuthenticationFailed, response["message"]
when 404
raise NotFoundError, response
else
raise RequestError, response
end
end
|
ruby
|
def execute(method, path, data = nil, options = {})
response = request(method, path, data, options)
case response.code
when 200..299
response
when 401
raise AuthenticationFailed, response["message"]
when 404
raise NotFoundError, response
else
raise RequestError, response
end
end
|
[
"def",
"execute",
"(",
"method",
",",
"path",
",",
"data",
"=",
"nil",
",",
"options",
"=",
"{",
"}",
")",
"response",
"=",
"request",
"(",
"method",
",",
"path",
",",
"data",
",",
"options",
")",
"case",
"response",
".",
"code",
"when",
"200",
"..",
"299",
"response",
"when",
"401",
"raise",
"AuthenticationFailed",
",",
"response",
"[",
"\"message\"",
"]",
"when",
"404",
"raise",
"NotFoundError",
",",
"response",
"else",
"raise",
"RequestError",
",",
"response",
"end",
"end"
] |
Executes a request, validates and returns the response.
@param [String] method The HTTP method
@param [String] path The path, relative to {#base_url}
@param [Hash] data The body for the request
@param [Hash] options The query and header params for the request
@return [HTTParty::Response]
@raise [RequestError]
@raise [NotFoundError]
@raise [AuthenticationFailed]
@raise [TwoFactorAuthenticationRequired]
|
[
"Executes",
"a",
"request",
"validates",
"and",
"returns",
"the",
"response",
"."
] |
cb75e47ec4de89954e56a80498796269717beb23
|
https://github.com/dnsimple/dnsimple-ruby/blob/cb75e47ec4de89954e56a80498796269717beb23/lib/dnsimple/client.rb#L154-L167
|
17,554
|
dnsimple/dnsimple-ruby
|
lib/dnsimple/client.rb
|
Dnsimple.Client.request
|
def request(method, path, data = nil, options = {})
request_options = request_options(options)
if data
request_options[:headers]["Content-Type"] = content_type(request_options[:headers])
request_options[:body] = content_data(request_options[:headers], data)
end
HTTParty.send(method, base_url + path, request_options)
end
|
ruby
|
def request(method, path, data = nil, options = {})
request_options = request_options(options)
if data
request_options[:headers]["Content-Type"] = content_type(request_options[:headers])
request_options[:body] = content_data(request_options[:headers], data)
end
HTTParty.send(method, base_url + path, request_options)
end
|
[
"def",
"request",
"(",
"method",
",",
"path",
",",
"data",
"=",
"nil",
",",
"options",
"=",
"{",
"}",
")",
"request_options",
"=",
"request_options",
"(",
"options",
")",
"if",
"data",
"request_options",
"[",
":headers",
"]",
"[",
"\"Content-Type\"",
"]",
"=",
"content_type",
"(",
"request_options",
"[",
":headers",
"]",
")",
"request_options",
"[",
":body",
"]",
"=",
"content_data",
"(",
"request_options",
"[",
":headers",
"]",
",",
"data",
")",
"end",
"HTTParty",
".",
"send",
"(",
"method",
",",
"base_url",
"+",
"path",
",",
"request_options",
")",
"end"
] |
Make a HTTP request.
This method doesn't validate the response and never raise errors
even in case of HTTP error codes, except for connection errors raised by
the underlying HTTP client.
Therefore, it's up to the caller to properly handle and validate the response.
@param [String] method The HTTP method
@param [String] path The path, relative to {#base_url}
@param [Hash] data The body for the request
@param [Hash] options The query and header params for the request
@return [HTTParty::Response]
|
[
"Make",
"a",
"HTTP",
"request",
"."
] |
cb75e47ec4de89954e56a80498796269717beb23
|
https://github.com/dnsimple/dnsimple-ruby/blob/cb75e47ec4de89954e56a80498796269717beb23/lib/dnsimple/client.rb#L182-L191
|
17,555
|
jpmobile/jpmobile
|
lib/jpmobile/request_with_mobile.rb
|
Jpmobile.RequestWithMobile.remote_addr
|
def remote_addr
if respond_to?(:remote_ip)
__send__(:remote_ip) # for Rails
elsif respond_to?(:ip)
__send__(:ip) # for Rack
else
if env['HTTP_X_FORWARDED_FOR']
env['HTTP_X_FORWARDED_FOR'].split(',').pop
else
env['REMOTE_ADDR']
end
end
end
|
ruby
|
def remote_addr
if respond_to?(:remote_ip)
__send__(:remote_ip) # for Rails
elsif respond_to?(:ip)
__send__(:ip) # for Rack
else
if env['HTTP_X_FORWARDED_FOR']
env['HTTP_X_FORWARDED_FOR'].split(',').pop
else
env['REMOTE_ADDR']
end
end
end
|
[
"def",
"remote_addr",
"if",
"respond_to?",
"(",
":remote_ip",
")",
"__send__",
"(",
":remote_ip",
")",
"# for Rails",
"elsif",
"respond_to?",
"(",
":ip",
")",
"__send__",
"(",
":ip",
")",
"# for Rack",
"else",
"if",
"env",
"[",
"'HTTP_X_FORWARDED_FOR'",
"]",
"env",
"[",
"'HTTP_X_FORWARDED_FOR'",
"]",
".",
"split",
"(",
"','",
")",
".",
"pop",
"else",
"env",
"[",
"'REMOTE_ADDR'",
"]",
"end",
"end",
"end"
] |
for reverse proxy.
|
[
"for",
"reverse",
"proxy",
"."
] |
4758f4a3fafbd8dc8c6051f3b79b231e4742612b
|
https://github.com/jpmobile/jpmobile/blob/4758f4a3fafbd8dc8c6051f3b79b231e4742612b/lib/jpmobile/request_with_mobile.rb#L13-L25
|
17,556
|
jpmobile/jpmobile
|
lib/jpmobile/mobile/abstract_mobile.rb
|
Jpmobile::Mobile.AbstractMobile.variants
|
def variants
return @_variants if @_variants
@_variants = self.class.ancestors.select {|c| c.to_s =~ /^Jpmobile/ && c.to_s !~ /Emoticon/ }.map do |klass|
klass = klass.to_s.
gsub(/Jpmobile::/, '').
gsub(/AbstractMobile::/, '').
gsub(/Mobile::SmartPhone/, 'smart_phone').
gsub(/Mobile::Tablet/, 'tablet').
gsub(/::/, '_').
gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2').
gsub(/([a-z\d])([A-Z])/, '\1_\2').
downcase
(klass =~ /abstract/) ? 'mobile' : klass
end
if @_variants.include?('tablet')
@_variants = @_variants.reject {|v| v == 'mobile' }.map {|v| v.gsub(/mobile_/, 'tablet_') }
elsif @_variants.include?('smart_phone')
@_variants = @_variants.reject {|v| v == 'mobile' }.map {|v| v.gsub(/mobile_/, 'smart_phone_') }
end
@_variants || []
end
|
ruby
|
def variants
return @_variants if @_variants
@_variants = self.class.ancestors.select {|c| c.to_s =~ /^Jpmobile/ && c.to_s !~ /Emoticon/ }.map do |klass|
klass = klass.to_s.
gsub(/Jpmobile::/, '').
gsub(/AbstractMobile::/, '').
gsub(/Mobile::SmartPhone/, 'smart_phone').
gsub(/Mobile::Tablet/, 'tablet').
gsub(/::/, '_').
gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2').
gsub(/([a-z\d])([A-Z])/, '\1_\2').
downcase
(klass =~ /abstract/) ? 'mobile' : klass
end
if @_variants.include?('tablet')
@_variants = @_variants.reject {|v| v == 'mobile' }.map {|v| v.gsub(/mobile_/, 'tablet_') }
elsif @_variants.include?('smart_phone')
@_variants = @_variants.reject {|v| v == 'mobile' }.map {|v| v.gsub(/mobile_/, 'smart_phone_') }
end
@_variants || []
end
|
[
"def",
"variants",
"return",
"@_variants",
"if",
"@_variants",
"@_variants",
"=",
"self",
".",
"class",
".",
"ancestors",
".",
"select",
"{",
"|",
"c",
"|",
"c",
".",
"to_s",
"=~",
"/",
"/",
"&&",
"c",
".",
"to_s",
"!~",
"/",
"/",
"}",
".",
"map",
"do",
"|",
"klass",
"|",
"klass",
"=",
"klass",
".",
"to_s",
".",
"gsub",
"(",
"/",
"/",
",",
"''",
")",
".",
"gsub",
"(",
"/",
"/",
",",
"''",
")",
".",
"gsub",
"(",
"/",
"/",
",",
"'smart_phone'",
")",
".",
"gsub",
"(",
"/",
"/",
",",
"'tablet'",
")",
".",
"gsub",
"(",
"/",
"/",
",",
"'_'",
")",
".",
"gsub",
"(",
"/",
"/",
",",
"'\\1_\\2'",
")",
".",
"gsub",
"(",
"/",
"\\d",
"/",
",",
"'\\1_\\2'",
")",
".",
"downcase",
"(",
"klass",
"=~",
"/",
"/",
")",
"?",
"'mobile'",
":",
"klass",
"end",
"if",
"@_variants",
".",
"include?",
"(",
"'tablet'",
")",
"@_variants",
"=",
"@_variants",
".",
"reject",
"{",
"|",
"v",
"|",
"v",
"==",
"'mobile'",
"}",
".",
"map",
"{",
"|",
"v",
"|",
"v",
".",
"gsub",
"(",
"/",
"/",
",",
"'tablet_'",
")",
"}",
"elsif",
"@_variants",
".",
"include?",
"(",
"'smart_phone'",
")",
"@_variants",
"=",
"@_variants",
".",
"reject",
"{",
"|",
"v",
"|",
"v",
"==",
"'mobile'",
"}",
".",
"map",
"{",
"|",
"v",
"|",
"v",
".",
"gsub",
"(",
"/",
"/",
",",
"'smart_phone_'",
")",
"}",
"end",
"@_variants",
"||",
"[",
"]",
"end"
] |
for view selector
|
[
"for",
"view",
"selector"
] |
4758f4a3fafbd8dc8c6051f3b79b231e4742612b
|
https://github.com/jpmobile/jpmobile/blob/4758f4a3fafbd8dc8c6051f3b79b231e4742612b/lib/jpmobile/mobile/abstract_mobile.rb#L94-L117
|
17,557
|
code-mancers/rapidfire
|
app/models/rapidfire/question.rb
|
Rapidfire.Question.validate_answer
|
def validate_answer(answer)
if rules[:presence] == "1"
answer.validates_presence_of :answer_text
end
if rules[:minimum].present? || rules[:maximum].present?
min_max = { minimum: rules[:minimum].to_i }
min_max[:maximum] = rules[:maximum].to_i if rules[:maximum].present?
answer.validates_length_of :answer_text, min_max
end
end
|
ruby
|
def validate_answer(answer)
if rules[:presence] == "1"
answer.validates_presence_of :answer_text
end
if rules[:minimum].present? || rules[:maximum].present?
min_max = { minimum: rules[:minimum].to_i }
min_max[:maximum] = rules[:maximum].to_i if rules[:maximum].present?
answer.validates_length_of :answer_text, min_max
end
end
|
[
"def",
"validate_answer",
"(",
"answer",
")",
"if",
"rules",
"[",
":presence",
"]",
"==",
"\"1\"",
"answer",
".",
"validates_presence_of",
":answer_text",
"end",
"if",
"rules",
"[",
":minimum",
"]",
".",
"present?",
"||",
"rules",
"[",
":maximum",
"]",
".",
"present?",
"min_max",
"=",
"{",
"minimum",
":",
"rules",
"[",
":minimum",
"]",
".",
"to_i",
"}",
"min_max",
"[",
":maximum",
"]",
"=",
"rules",
"[",
":maximum",
"]",
".",
"to_i",
"if",
"rules",
"[",
":maximum",
"]",
".",
"present?",
"answer",
".",
"validates_length_of",
":answer_text",
",",
"min_max",
"end",
"end"
] |
answer will delegate its validation to question, and question
will inturn add validations on answer on the fly!
|
[
"answer",
"will",
"delegate",
"its",
"validation",
"to",
"question",
"and",
"question",
"will",
"inturn",
"add",
"validations",
"on",
"answer",
"on",
"the",
"fly!"
] |
f536c489bd2a8a5195c19275f7dce6d3e980524d
|
https://github.com/code-mancers/rapidfire/blob/f536c489bd2a8a5195c19275f7dce6d3e980524d/app/models/rapidfire/question.rb#L31-L42
|
17,558
|
tdiary/tdiary-core
|
misc/plugin/category-legacy.rb
|
Category.Cache.replace_sections
|
def replace_sections(diary)
return if diary.nil? or !diary.categorizable?
categorized = categorize_diary(diary)
categories = restore_categories
deleted = []
ymd = diary.date.strftime('%Y%m%d')
@plugin.__send__(:transaction, 'category') do |db|
categories.each do |c|
cat = get(db, c) || {}
if diary.visible? and categorized[c]
cat.update(categorized[c])
set(db, c, cat)
else
# diary is invisible or sections of this category is deleted
cat.delete(ymd)
if cat.empty?
db.delete(c)
deleted << c
else
set(db, c, cat)
end
end
end
if !deleted.empty?
replace_categories(categories - deleted)
end
end
end
|
ruby
|
def replace_sections(diary)
return if diary.nil? or !diary.categorizable?
categorized = categorize_diary(diary)
categories = restore_categories
deleted = []
ymd = diary.date.strftime('%Y%m%d')
@plugin.__send__(:transaction, 'category') do |db|
categories.each do |c|
cat = get(db, c) || {}
if diary.visible? and categorized[c]
cat.update(categorized[c])
set(db, c, cat)
else
# diary is invisible or sections of this category is deleted
cat.delete(ymd)
if cat.empty?
db.delete(c)
deleted << c
else
set(db, c, cat)
end
end
end
if !deleted.empty?
replace_categories(categories - deleted)
end
end
end
|
[
"def",
"replace_sections",
"(",
"diary",
")",
"return",
"if",
"diary",
".",
"nil?",
"or",
"!",
"diary",
".",
"categorizable?",
"categorized",
"=",
"categorize_diary",
"(",
"diary",
")",
"categories",
"=",
"restore_categories",
"deleted",
"=",
"[",
"]",
"ymd",
"=",
"diary",
".",
"date",
".",
"strftime",
"(",
"'%Y%m%d'",
")",
"@plugin",
".",
"__send__",
"(",
":transaction",
",",
"'category'",
")",
"do",
"|",
"db",
"|",
"categories",
".",
"each",
"do",
"|",
"c",
"|",
"cat",
"=",
"get",
"(",
"db",
",",
"c",
")",
"||",
"{",
"}",
"if",
"diary",
".",
"visible?",
"and",
"categorized",
"[",
"c",
"]",
"cat",
".",
"update",
"(",
"categorized",
"[",
"c",
"]",
")",
"set",
"(",
"db",
",",
"c",
",",
"cat",
")",
"else",
"# diary is invisible or sections of this category is deleted",
"cat",
".",
"delete",
"(",
"ymd",
")",
"if",
"cat",
".",
"empty?",
"db",
".",
"delete",
"(",
"c",
")",
"deleted",
"<<",
"c",
"else",
"set",
"(",
"db",
",",
"c",
",",
"cat",
")",
"end",
"end",
"end",
"if",
"!",
"deleted",
".",
"empty?",
"replace_categories",
"(",
"categories",
"-",
"deleted",
")",
"end",
"end",
"end"
] |
cache each section of diary
used in update_proc
|
[
"cache",
"each",
"section",
"of",
"diary",
"used",
"in",
"update_proc"
] |
688b9378a872d6530ebd51788355fcd56b0f5b2d
|
https://github.com/tdiary/tdiary-core/blob/688b9378a872d6530ebd51788355fcd56b0f5b2d/misc/plugin/category-legacy.rb#L435-L465
|
17,559
|
tdiary/tdiary-core
|
misc/plugin/category-legacy.rb
|
Category.Cache.categorize
|
def categorize(category, years)
categories = category - ['ALL']
if categories.empty?
categories = restore_categories
else
categories &= restore_categories
end
categorized = {}
begin
categorized.clear
categories.each do |c|
@plugin.__send__(:transaction, 'category') do |db|
categorized[c] = get(db, c)
end
categorized[c].keys.each do |ymd|
y, m = ymd[0,4], ymd[4,2]
if years[y].nil? or !years[y].include?(m)
categorized[c].delete(ymd)
end
end
categorized.delete(c) if categorized[c].empty?
end
rescue NoMethodError # when categorized[c] is nil
recreate(years)
retry
end
categorized
end
|
ruby
|
def categorize(category, years)
categories = category - ['ALL']
if categories.empty?
categories = restore_categories
else
categories &= restore_categories
end
categorized = {}
begin
categorized.clear
categories.each do |c|
@plugin.__send__(:transaction, 'category') do |db|
categorized[c] = get(db, c)
end
categorized[c].keys.each do |ymd|
y, m = ymd[0,4], ymd[4,2]
if years[y].nil? or !years[y].include?(m)
categorized[c].delete(ymd)
end
end
categorized.delete(c) if categorized[c].empty?
end
rescue NoMethodError # when categorized[c] is nil
recreate(years)
retry
end
categorized
end
|
[
"def",
"categorize",
"(",
"category",
",",
"years",
")",
"categories",
"=",
"category",
"-",
"[",
"'ALL'",
"]",
"if",
"categories",
".",
"empty?",
"categories",
"=",
"restore_categories",
"else",
"categories",
"&=",
"restore_categories",
"end",
"categorized",
"=",
"{",
"}",
"begin",
"categorized",
".",
"clear",
"categories",
".",
"each",
"do",
"|",
"c",
"|",
"@plugin",
".",
"__send__",
"(",
":transaction",
",",
"'category'",
")",
"do",
"|",
"db",
"|",
"categorized",
"[",
"c",
"]",
"=",
"get",
"(",
"db",
",",
"c",
")",
"end",
"categorized",
"[",
"c",
"]",
".",
"keys",
".",
"each",
"do",
"|",
"ymd",
"|",
"y",
",",
"m",
"=",
"ymd",
"[",
"0",
",",
"4",
"]",
",",
"ymd",
"[",
"4",
",",
"2",
"]",
"if",
"years",
"[",
"y",
"]",
".",
"nil?",
"or",
"!",
"years",
"[",
"y",
"]",
".",
"include?",
"(",
"m",
")",
"categorized",
"[",
"c",
"]",
".",
"delete",
"(",
"ymd",
")",
"end",
"end",
"categorized",
".",
"delete",
"(",
"c",
")",
"if",
"categorized",
"[",
"c",
"]",
".",
"empty?",
"end",
"rescue",
"NoMethodError",
"# when categorized[c] is nil",
"recreate",
"(",
"years",
")",
"retry",
"end",
"categorized",
"end"
] |
categorize sections of category of years
{"category" => {"yyyymmdd" => [[idx, title, excerpt], ...], ...}, ...}
|
[
"categorize",
"sections",
"of",
"category",
"of",
"years"
] |
688b9378a872d6530ebd51788355fcd56b0f5b2d
|
https://github.com/tdiary/tdiary-core/blob/688b9378a872d6530ebd51788355fcd56b0f5b2d/misc/plugin/category-legacy.rb#L501-L530
|
17,560
|
tdiary/tdiary-core
|
misc/plugin/category-legacy.rb
|
Category.Cache.categorize_diary
|
def categorize_diary(diary)
categorized = {}
ymd = diary.date.strftime('%Y%m%d')
idx = 1
diary.each_section do |s|
shorten = begin
body = %Q|apply_plugin(#{s.body_to_html.dump}, true)|
@conf.shorten(eval(body, @binding))
rescue NameError
""
end
s.categories.each do |c|
categorized[c] = {} if categorized[c].nil?
categorized[c][ymd] = [] if categorized[c][ymd].nil?
categorized[c][ymd] << [idx, s.stripped_subtitle_to_html, shorten]
end
idx +=1
end
categorized
end
|
ruby
|
def categorize_diary(diary)
categorized = {}
ymd = diary.date.strftime('%Y%m%d')
idx = 1
diary.each_section do |s|
shorten = begin
body = %Q|apply_plugin(#{s.body_to_html.dump}, true)|
@conf.shorten(eval(body, @binding))
rescue NameError
""
end
s.categories.each do |c|
categorized[c] = {} if categorized[c].nil?
categorized[c][ymd] = [] if categorized[c][ymd].nil?
categorized[c][ymd] << [idx, s.stripped_subtitle_to_html, shorten]
end
idx +=1
end
categorized
end
|
[
"def",
"categorize_diary",
"(",
"diary",
")",
"categorized",
"=",
"{",
"}",
"ymd",
"=",
"diary",
".",
"date",
".",
"strftime",
"(",
"'%Y%m%d'",
")",
"idx",
"=",
"1",
"diary",
".",
"each_section",
"do",
"|",
"s",
"|",
"shorten",
"=",
"begin",
"body",
"=",
"%Q|apply_plugin(#{s.body_to_html.dump}, true)|",
"@conf",
".",
"shorten",
"(",
"eval",
"(",
"body",
",",
"@binding",
")",
")",
"rescue",
"NameError",
"\"\"",
"end",
"s",
".",
"categories",
".",
"each",
"do",
"|",
"c",
"|",
"categorized",
"[",
"c",
"]",
"=",
"{",
"}",
"if",
"categorized",
"[",
"c",
"]",
".",
"nil?",
"categorized",
"[",
"c",
"]",
"[",
"ymd",
"]",
"=",
"[",
"]",
"if",
"categorized",
"[",
"c",
"]",
"[",
"ymd",
"]",
".",
"nil?",
"categorized",
"[",
"c",
"]",
"[",
"ymd",
"]",
"<<",
"[",
"idx",
",",
"s",
".",
"stripped_subtitle_to_html",
",",
"shorten",
"]",
"end",
"idx",
"+=",
"1",
"end",
"categorized",
"end"
] |
categorize sections of diary
{"category" => {"yyyymmdd" => [[idx, title, excerpt], ...]}}
|
[
"categorize",
"sections",
"of",
"diary"
] |
688b9378a872d6530ebd51788355fcd56b0f5b2d
|
https://github.com/tdiary/tdiary-core/blob/688b9378a872d6530ebd51788355fcd56b0f5b2d/misc/plugin/category-legacy.rb#L546-L567
|
17,561
|
tdiary/tdiary-core
|
lib/tdiary/dispatcher.rb
|
TDiary.Dispatcher.dispatch_cgi
|
def dispatch_cgi(request, cgi)
result = @target.run( request, cgi )
result.headers.reject!{|k,v| k.to_s.downcase == "status" }
result.to_a
end
|
ruby
|
def dispatch_cgi(request, cgi)
result = @target.run( request, cgi )
result.headers.reject!{|k,v| k.to_s.downcase == "status" }
result.to_a
end
|
[
"def",
"dispatch_cgi",
"(",
"request",
",",
"cgi",
")",
"result",
"=",
"@target",
".",
"run",
"(",
"request",
",",
"cgi",
")",
"result",
".",
"headers",
".",
"reject!",
"{",
"|",
"k",
",",
"v",
"|",
"k",
".",
"to_s",
".",
"downcase",
"==",
"\"status\"",
"}",
"result",
".",
"to_a",
"end"
] |
FIXME rename method name to more suitable one.
|
[
"FIXME",
"rename",
"method",
"name",
"to",
"more",
"suitable",
"one",
"."
] |
688b9378a872d6530ebd51788355fcd56b0f5b2d
|
https://github.com/tdiary/tdiary-core/blob/688b9378a872d6530ebd51788355fcd56b0f5b2d/lib/tdiary/dispatcher.rb#L24-L28
|
17,562
|
tdiary/tdiary-core
|
lib/tdiary/dispatcher.rb
|
TDiary.Dispatcher.fake_stdin_as_params
|
def fake_stdin_as_params
stdin_spy = StringIO.new
if $RACK_ENV && $RACK_ENV['rack.input']
stdin_spy.print($RACK_ENV['rack.input'].read)
stdin_spy.rewind
end
$stdin = stdin_spy
end
|
ruby
|
def fake_stdin_as_params
stdin_spy = StringIO.new
if $RACK_ENV && $RACK_ENV['rack.input']
stdin_spy.print($RACK_ENV['rack.input'].read)
stdin_spy.rewind
end
$stdin = stdin_spy
end
|
[
"def",
"fake_stdin_as_params",
"stdin_spy",
"=",
"StringIO",
".",
"new",
"if",
"$RACK_ENV",
"&&",
"$RACK_ENV",
"[",
"'rack.input'",
"]",
"stdin_spy",
".",
"print",
"(",
"$RACK_ENV",
"[",
"'rack.input'",
"]",
".",
"read",
")",
"stdin_spy",
".",
"rewind",
"end",
"$stdin",
"=",
"stdin_spy",
"end"
] |
FIXME dirty hack
|
[
"FIXME",
"dirty",
"hack"
] |
688b9378a872d6530ebd51788355fcd56b0f5b2d
|
https://github.com/tdiary/tdiary-core/blob/688b9378a872d6530ebd51788355fcd56b0f5b2d/lib/tdiary/dispatcher.rb#L80-L87
|
17,563
|
tdiary/tdiary-core
|
lib/tdiary/configuration.rb
|
TDiary.Configuration.load_cgi_conf
|
def load_cgi_conf
def_vars1 = ''
def_vars2 = ''
[
:tdiary_version,
:html_title, :author_name, :author_mail, :index_page, :hour_offset,
:description, :icon, :banner, :x_frame_options,
:header, :footer,
:section_anchor, :comment_anchor, :date_format, :latest_limit, :show_nyear,
:theme, :css,
:show_comment, :comment_limit, :comment_limit_per_day,
:mail_on_comment, :mail_header,
:show_referer, :no_referer2, :only_volatile2, :referer_table2,
:options2,
].each do |var|
def_vars1 << "#{var} = nil\n"
def_vars2 << "@#{var} = #{var} unless #{var} == nil\n"
end
unless defined?(::TDiary::Cache) && ::TDiary::Cache.method_defined?(:store_cache)
require 'tdiary/cache/file'
end
unless @io_class
require 'tdiary/io/default'
@io_class = IO::Default
attr_reader :io_class
end
cgi_conf = @io_class.load_cgi_conf(self)
b = binding
eval( def_vars1, b )
begin
eval( cgi_conf, b, "(TDiary::Configuration#load_cgi_conf)", 1 )
rescue SyntaxError
enc = case @lang
when 'en'
'UTF-8'
else
'EUC-JP'
end
cgi_conf.force_encoding( enc )
retry
end if cgi_conf
eval( def_vars2, b )
end
|
ruby
|
def load_cgi_conf
def_vars1 = ''
def_vars2 = ''
[
:tdiary_version,
:html_title, :author_name, :author_mail, :index_page, :hour_offset,
:description, :icon, :banner, :x_frame_options,
:header, :footer,
:section_anchor, :comment_anchor, :date_format, :latest_limit, :show_nyear,
:theme, :css,
:show_comment, :comment_limit, :comment_limit_per_day,
:mail_on_comment, :mail_header,
:show_referer, :no_referer2, :only_volatile2, :referer_table2,
:options2,
].each do |var|
def_vars1 << "#{var} = nil\n"
def_vars2 << "@#{var} = #{var} unless #{var} == nil\n"
end
unless defined?(::TDiary::Cache) && ::TDiary::Cache.method_defined?(:store_cache)
require 'tdiary/cache/file'
end
unless @io_class
require 'tdiary/io/default'
@io_class = IO::Default
attr_reader :io_class
end
cgi_conf = @io_class.load_cgi_conf(self)
b = binding
eval( def_vars1, b )
begin
eval( cgi_conf, b, "(TDiary::Configuration#load_cgi_conf)", 1 )
rescue SyntaxError
enc = case @lang
when 'en'
'UTF-8'
else
'EUC-JP'
end
cgi_conf.force_encoding( enc )
retry
end if cgi_conf
eval( def_vars2, b )
end
|
[
"def",
"load_cgi_conf",
"def_vars1",
"=",
"''",
"def_vars2",
"=",
"''",
"[",
":tdiary_version",
",",
":html_title",
",",
":author_name",
",",
":author_mail",
",",
":index_page",
",",
":hour_offset",
",",
":description",
",",
":icon",
",",
":banner",
",",
":x_frame_options",
",",
":header",
",",
":footer",
",",
":section_anchor",
",",
":comment_anchor",
",",
":date_format",
",",
":latest_limit",
",",
":show_nyear",
",",
":theme",
",",
":css",
",",
":show_comment",
",",
":comment_limit",
",",
":comment_limit_per_day",
",",
":mail_on_comment",
",",
":mail_header",
",",
":show_referer",
",",
":no_referer2",
",",
":only_volatile2",
",",
":referer_table2",
",",
":options2",
",",
"]",
".",
"each",
"do",
"|",
"var",
"|",
"def_vars1",
"<<",
"\"#{var} = nil\\n\"",
"def_vars2",
"<<",
"\"@#{var} = #{var} unless #{var} == nil\\n\"",
"end",
"unless",
"defined?",
"(",
"::",
"TDiary",
"::",
"Cache",
")",
"&&",
"::",
"TDiary",
"::",
"Cache",
".",
"method_defined?",
"(",
":store_cache",
")",
"require",
"'tdiary/cache/file'",
"end",
"unless",
"@io_class",
"require",
"'tdiary/io/default'",
"@io_class",
"=",
"IO",
"::",
"Default",
"attr_reader",
":io_class",
"end",
"cgi_conf",
"=",
"@io_class",
".",
"load_cgi_conf",
"(",
"self",
")",
"b",
"=",
"binding",
"eval",
"(",
"def_vars1",
",",
"b",
")",
"begin",
"eval",
"(",
"cgi_conf",
",",
"b",
",",
"\"(TDiary::Configuration#load_cgi_conf)\"",
",",
"1",
")",
"rescue",
"SyntaxError",
"enc",
"=",
"case",
"@lang",
"when",
"'en'",
"'UTF-8'",
"else",
"'EUC-JP'",
"end",
"cgi_conf",
".",
"force_encoding",
"(",
"enc",
")",
"retry",
"end",
"if",
"cgi_conf",
"eval",
"(",
"def_vars2",
",",
"b",
")",
"end"
] |
loading tdiary.conf in @data_path.
|
[
"loading",
"tdiary",
".",
"conf",
"in"
] |
688b9378a872d6530ebd51788355fcd56b0f5b2d
|
https://github.com/tdiary/tdiary-core/blob/688b9378a872d6530ebd51788355fcd56b0f5b2d/lib/tdiary/configuration.rb#L83-L129
|
17,564
|
tdiary/tdiary-core
|
lib/tdiary/configuration.rb
|
TDiary.Configuration.configure_attrs
|
def configure_attrs
@options = {}
eval( File::open( 'tdiary.conf' ) {|f| f.read }, nil, "(tdiary.conf)", 1 )
# language setup
@lang = 'ja' unless @lang
begin
instance_eval( File::open( "#{TDiary::PATH}/tdiary/lang/#{@lang}.rb" ){|f| f.read }, "(tdiary/lang/#{@lang}.rb)", 1 )
rescue Errno::ENOENT
@lang = 'ja'
retry
end
@data_path += '/' if @data_path && /\/$/ !~ @data_path
@style = 'tDiary' unless @style
@index = './' unless @index
@update = 'update.rb' unless @update
@hide_comment_form = false unless defined?( @hide_comment_form )
@author_name = '' unless @author_name
@index_page = '' unless @index_page
@hour_offset = 0 unless @hour_offset
@html_title = '' unless @html_title
@x_frame_options = nil unless @x_frame_options
@header = '' unless @header
@footer = '' unless @footer
@section_anchor = '<span class="sanchor">_</span>' unless @section_anchor
@comment_anchor = '<span class="canchor">_</span>' unless @comment_anchor
@date_format = '%Y-%m-%d' unless @date_format
@latest_limit = 10 unless @latest_limit
@show_nyear = false unless @show_nyear
@theme = 'default' if not @theme and not @css
@theme = "local/#{@theme}" unless @theme.index('/')
@css = '' unless @css
@show_comment = true unless defined?( @show_comment )
@comment_limit = 3 unless @comment_limit
@comment_limit_per_day = 100 unless @comment_limit_per_day
@show_referer = true unless defined?( @show_referer )
@referer_limit = 10 unless @referer_limit
@referer_day_only = true unless defined?( @referer_day_only )
@no_referer = [] unless @no_referer
@no_referer2 = [] unless @no_referer2
@no_referer = @no_referer2 + @no_referer
@only_volatile = [] unless @only_volatile
@only_volatile2 = [] unless @only_volatile2
@only_volatile = @only_volatile2 + @only_volatile
@referer_table = [] unless @referer_table
@referer_table2 = [] unless @referer_table2
@referer_table = @referer_table2 + @referer_table
@options = {} unless @options.class == Hash
if @options2 then
@options.update( @options2 )
else
@options2 = {}
end
# for 1.4 compatibility
@section_anchor = @paragraph_anchor unless @section_anchor
end
|
ruby
|
def configure_attrs
@options = {}
eval( File::open( 'tdiary.conf' ) {|f| f.read }, nil, "(tdiary.conf)", 1 )
# language setup
@lang = 'ja' unless @lang
begin
instance_eval( File::open( "#{TDiary::PATH}/tdiary/lang/#{@lang}.rb" ){|f| f.read }, "(tdiary/lang/#{@lang}.rb)", 1 )
rescue Errno::ENOENT
@lang = 'ja'
retry
end
@data_path += '/' if @data_path && /\/$/ !~ @data_path
@style = 'tDiary' unless @style
@index = './' unless @index
@update = 'update.rb' unless @update
@hide_comment_form = false unless defined?( @hide_comment_form )
@author_name = '' unless @author_name
@index_page = '' unless @index_page
@hour_offset = 0 unless @hour_offset
@html_title = '' unless @html_title
@x_frame_options = nil unless @x_frame_options
@header = '' unless @header
@footer = '' unless @footer
@section_anchor = '<span class="sanchor">_</span>' unless @section_anchor
@comment_anchor = '<span class="canchor">_</span>' unless @comment_anchor
@date_format = '%Y-%m-%d' unless @date_format
@latest_limit = 10 unless @latest_limit
@show_nyear = false unless @show_nyear
@theme = 'default' if not @theme and not @css
@theme = "local/#{@theme}" unless @theme.index('/')
@css = '' unless @css
@show_comment = true unless defined?( @show_comment )
@comment_limit = 3 unless @comment_limit
@comment_limit_per_day = 100 unless @comment_limit_per_day
@show_referer = true unless defined?( @show_referer )
@referer_limit = 10 unless @referer_limit
@referer_day_only = true unless defined?( @referer_day_only )
@no_referer = [] unless @no_referer
@no_referer2 = [] unless @no_referer2
@no_referer = @no_referer2 + @no_referer
@only_volatile = [] unless @only_volatile
@only_volatile2 = [] unless @only_volatile2
@only_volatile = @only_volatile2 + @only_volatile
@referer_table = [] unless @referer_table
@referer_table2 = [] unless @referer_table2
@referer_table = @referer_table2 + @referer_table
@options = {} unless @options.class == Hash
if @options2 then
@options.update( @options2 )
else
@options2 = {}
end
# for 1.4 compatibility
@section_anchor = @paragraph_anchor unless @section_anchor
end
|
[
"def",
"configure_attrs",
"@options",
"=",
"{",
"}",
"eval",
"(",
"File",
"::",
"open",
"(",
"'tdiary.conf'",
")",
"{",
"|",
"f",
"|",
"f",
".",
"read",
"}",
",",
"nil",
",",
"\"(tdiary.conf)\"",
",",
"1",
")",
"# language setup",
"@lang",
"=",
"'ja'",
"unless",
"@lang",
"begin",
"instance_eval",
"(",
"File",
"::",
"open",
"(",
"\"#{TDiary::PATH}/tdiary/lang/#{@lang}.rb\"",
")",
"{",
"|",
"f",
"|",
"f",
".",
"read",
"}",
",",
"\"(tdiary/lang/#{@lang}.rb)\"",
",",
"1",
")",
"rescue",
"Errno",
"::",
"ENOENT",
"@lang",
"=",
"'ja'",
"retry",
"end",
"@data_path",
"+=",
"'/'",
"if",
"@data_path",
"&&",
"/",
"\\/",
"/",
"!~",
"@data_path",
"@style",
"=",
"'tDiary'",
"unless",
"@style",
"@index",
"=",
"'./'",
"unless",
"@index",
"@update",
"=",
"'update.rb'",
"unless",
"@update",
"@hide_comment_form",
"=",
"false",
"unless",
"defined?",
"(",
"@hide_comment_form",
")",
"@author_name",
"=",
"''",
"unless",
"@author_name",
"@index_page",
"=",
"''",
"unless",
"@index_page",
"@hour_offset",
"=",
"0",
"unless",
"@hour_offset",
"@html_title",
"=",
"''",
"unless",
"@html_title",
"@x_frame_options",
"=",
"nil",
"unless",
"@x_frame_options",
"@header",
"=",
"''",
"unless",
"@header",
"@footer",
"=",
"''",
"unless",
"@footer",
"@section_anchor",
"=",
"'<span class=\"sanchor\">_</span>'",
"unless",
"@section_anchor",
"@comment_anchor",
"=",
"'<span class=\"canchor\">_</span>'",
"unless",
"@comment_anchor",
"@date_format",
"=",
"'%Y-%m-%d'",
"unless",
"@date_format",
"@latest_limit",
"=",
"10",
"unless",
"@latest_limit",
"@show_nyear",
"=",
"false",
"unless",
"@show_nyear",
"@theme",
"=",
"'default'",
"if",
"not",
"@theme",
"and",
"not",
"@css",
"@theme",
"=",
"\"local/#{@theme}\"",
"unless",
"@theme",
".",
"index",
"(",
"'/'",
")",
"@css",
"=",
"''",
"unless",
"@css",
"@show_comment",
"=",
"true",
"unless",
"defined?",
"(",
"@show_comment",
")",
"@comment_limit",
"=",
"3",
"unless",
"@comment_limit",
"@comment_limit_per_day",
"=",
"100",
"unless",
"@comment_limit_per_day",
"@show_referer",
"=",
"true",
"unless",
"defined?",
"(",
"@show_referer",
")",
"@referer_limit",
"=",
"10",
"unless",
"@referer_limit",
"@referer_day_only",
"=",
"true",
"unless",
"defined?",
"(",
"@referer_day_only",
")",
"@no_referer",
"=",
"[",
"]",
"unless",
"@no_referer",
"@no_referer2",
"=",
"[",
"]",
"unless",
"@no_referer2",
"@no_referer",
"=",
"@no_referer2",
"+",
"@no_referer",
"@only_volatile",
"=",
"[",
"]",
"unless",
"@only_volatile",
"@only_volatile2",
"=",
"[",
"]",
"unless",
"@only_volatile2",
"@only_volatile",
"=",
"@only_volatile2",
"+",
"@only_volatile",
"@referer_table",
"=",
"[",
"]",
"unless",
"@referer_table",
"@referer_table2",
"=",
"[",
"]",
"unless",
"@referer_table2",
"@referer_table",
"=",
"@referer_table2",
"+",
"@referer_table",
"@options",
"=",
"{",
"}",
"unless",
"@options",
".",
"class",
"==",
"Hash",
"if",
"@options2",
"then",
"@options",
".",
"update",
"(",
"@options2",
")",
"else",
"@options2",
"=",
"{",
"}",
"end",
"# for 1.4 compatibility",
"@section_anchor",
"=",
"@paragraph_anchor",
"unless",
"@section_anchor",
"end"
] |
loading tdiary.conf in current directory
|
[
"loading",
"tdiary",
".",
"conf",
"in",
"current",
"directory"
] |
688b9378a872d6530ebd51788355fcd56b0f5b2d
|
https://github.com/tdiary/tdiary-core/blob/688b9378a872d6530ebd51788355fcd56b0f5b2d/lib/tdiary/configuration.rb#L132-L197
|
17,565
|
josevalim/rails-footnotes
|
lib/rails-footnotes/filter.rb
|
Footnotes.Filter.close!
|
def close!(controller)
self.each_with_rescue(@@klasses) {|klass| klass.close!(controller)}
self.each_with_rescue(Footnotes.after_hooks) {|hook| hook.call(controller, self)}
end
|
ruby
|
def close!(controller)
self.each_with_rescue(@@klasses) {|klass| klass.close!(controller)}
self.each_with_rescue(Footnotes.after_hooks) {|hook| hook.call(controller, self)}
end
|
[
"def",
"close!",
"(",
"controller",
")",
"self",
".",
"each_with_rescue",
"(",
"@@klasses",
")",
"{",
"|",
"klass",
"|",
"klass",
".",
"close!",
"(",
"controller",
")",
"}",
"self",
".",
"each_with_rescue",
"(",
"Footnotes",
".",
"after_hooks",
")",
"{",
"|",
"hook",
"|",
"hook",
".",
"call",
"(",
"controller",
",",
"self",
")",
"}",
"end"
] |
Calls the class method close! in each note
Sometimes notes need to finish their work even after being read
This method allows this kind of work
|
[
"Calls",
"the",
"class",
"method",
"close!",
"in",
"each",
"note",
"Sometimes",
"notes",
"need",
"to",
"finish",
"their",
"work",
"even",
"after",
"being",
"read",
"This",
"method",
"allows",
"this",
"kind",
"of",
"work"
] |
0ca9f4c4ce404113994f81552c304d8fd326ac1c
|
https://github.com/josevalim/rails-footnotes/blob/0ca9f4c4ce404113994f81552c304d8fd326ac1c/lib/rails-footnotes/filter.rb#L83-L86
|
17,566
|
josevalim/rails-footnotes
|
lib/rails-footnotes/filter.rb
|
Footnotes.Filter.close
|
def close
javascript = ''
each_with_rescue(@notes) do |note|
next unless note.has_fieldset?
javascript << close_helper(note)
end
javascript
end
|
ruby
|
def close
javascript = ''
each_with_rescue(@notes) do |note|
next unless note.has_fieldset?
javascript << close_helper(note)
end
javascript
end
|
[
"def",
"close",
"javascript",
"=",
"''",
"each_with_rescue",
"(",
"@notes",
")",
"do",
"|",
"note",
"|",
"next",
"unless",
"note",
".",
"has_fieldset?",
"javascript",
"<<",
"close_helper",
"(",
"note",
")",
"end",
"javascript",
"end"
] |
Process notes to get javascript code to close them.
This method is only used when multiple_notes is false.
|
[
"Process",
"notes",
"to",
"get",
"javascript",
"code",
"to",
"close",
"them",
".",
"This",
"method",
"is",
"only",
"used",
"when",
"multiple_notes",
"is",
"false",
"."
] |
0ca9f4c4ce404113994f81552c304d8fd326ac1c
|
https://github.com/josevalim/rails-footnotes/blob/0ca9f4c4ce404113994f81552c304d8fd326ac1c/lib/rails-footnotes/filter.rb#L300-L307
|
17,567
|
josevalim/rails-footnotes
|
lib/rails-footnotes/filter.rb
|
Footnotes.Filter.link_helper
|
def link_helper(note)
onclick = note.onclick
unless href = note.link
href = '#'
onclick ||= "Footnotes.hideAllAndToggle('#{note.to_sym}_debug_info');return false;" if note.has_fieldset?
end
"<a href=\"#{href}\" onclick=\"#{onclick}\">#{note.title}</a>"
end
|
ruby
|
def link_helper(note)
onclick = note.onclick
unless href = note.link
href = '#'
onclick ||= "Footnotes.hideAllAndToggle('#{note.to_sym}_debug_info');return false;" if note.has_fieldset?
end
"<a href=\"#{href}\" onclick=\"#{onclick}\">#{note.title}</a>"
end
|
[
"def",
"link_helper",
"(",
"note",
")",
"onclick",
"=",
"note",
".",
"onclick",
"unless",
"href",
"=",
"note",
".",
"link",
"href",
"=",
"'#'",
"onclick",
"||=",
"\"Footnotes.hideAllAndToggle('#{note.to_sym}_debug_info');return false;\"",
"if",
"note",
".",
"has_fieldset?",
"end",
"\"<a href=\\\"#{href}\\\" onclick=\\\"#{onclick}\\\">#{note.title}</a>\"",
"end"
] |
Helper that creates the link and javascript code when note is clicked
|
[
"Helper",
"that",
"creates",
"the",
"link",
"and",
"javascript",
"code",
"when",
"note",
"is",
"clicked"
] |
0ca9f4c4ce404113994f81552c304d8fd326ac1c
|
https://github.com/josevalim/rails-footnotes/blob/0ca9f4c4ce404113994f81552c304d8fd326ac1c/lib/rails-footnotes/filter.rb#L321-L329
|
17,568
|
apache/predictionio-sdk-ruby
|
lib/predictionio/connection.rb
|
PredictionIO.Connection.request
|
def request(method, request)
response = AsyncResponse.new(request)
@packages.push(method: method, request: request, response: response)
response
end
|
ruby
|
def request(method, request)
response = AsyncResponse.new(request)
@packages.push(method: method, request: request, response: response)
response
end
|
[
"def",
"request",
"(",
"method",
",",
"request",
")",
"response",
"=",
"AsyncResponse",
".",
"new",
"(",
"request",
")",
"@packages",
".",
"push",
"(",
"method",
":",
"method",
",",
"request",
":",
"request",
",",
"response",
":",
"response",
")",
"response",
"end"
] |
Spawns a number of threads with persistent HTTP connection to the specified URI.
Sets a default timeout of 60 seconds.
Create an asynchronous request and response package, put it in the pending queue, and return the response object.
|
[
"Spawns",
"a",
"number",
"of",
"threads",
"with",
"persistent",
"HTTP",
"connection",
"to",
"the",
"specified",
"URI",
".",
"Sets",
"a",
"default",
"timeout",
"of",
"60",
"seconds",
".",
"Create",
"an",
"asynchronous",
"request",
"and",
"response",
"package",
"put",
"it",
"in",
"the",
"pending",
"queue",
"and",
"return",
"the",
"response",
"object",
"."
] |
a1777db9f89a4287d252c8ca166a279fb2af64b7
|
https://github.com/apache/predictionio-sdk-ruby/blob/a1777db9f89a4287d252c8ca166a279fb2af64b7/lib/predictionio/connection.rb#L108-L112
|
17,569
|
apache/predictionio-sdk-ruby
|
lib/predictionio/event_client.rb
|
PredictionIO.EventClient.get_status
|
def get_status
status = @http.aget(PredictionIO::AsyncRequest.new('/')).get
begin
status.body
rescue
status
end
end
|
ruby
|
def get_status
status = @http.aget(PredictionIO::AsyncRequest.new('/')).get
begin
status.body
rescue
status
end
end
|
[
"def",
"get_status",
"status",
"=",
"@http",
".",
"aget",
"(",
"PredictionIO",
"::",
"AsyncRequest",
".",
"new",
"(",
"'/'",
")",
")",
".",
"get",
"begin",
"status",
".",
"body",
"rescue",
"status",
"end",
"end"
] |
Returns PredictionIO's status in string.
|
[
"Returns",
"PredictionIO",
"s",
"status",
"in",
"string",
"."
] |
a1777db9f89a4287d252c8ca166a279fb2af64b7
|
https://github.com/apache/predictionio-sdk-ruby/blob/a1777db9f89a4287d252c8ca166a279fb2af64b7/lib/predictionio/event_client.rb#L112-L119
|
17,570
|
remvee/exifr
|
lib/exifr/jpeg.rb
|
EXIFR.JPEG.to_hash
|
def to_hash
h = {:width => width, :height => height, :bits => bits, :comment => comment}
h.merge!(exif) if exif?
h
end
|
ruby
|
def to_hash
h = {:width => width, :height => height, :bits => bits, :comment => comment}
h.merge!(exif) if exif?
h
end
|
[
"def",
"to_hash",
"h",
"=",
"{",
":width",
"=>",
"width",
",",
":height",
"=>",
"height",
",",
":bits",
"=>",
"bits",
",",
":comment",
"=>",
"comment",
"}",
"h",
".",
"merge!",
"(",
"exif",
")",
"if",
"exif?",
"h",
"end"
] |
Get a hash presentation of the image.
|
[
"Get",
"a",
"hash",
"presentation",
"of",
"the",
"image",
"."
] |
1e7b29befed53be8e0bd59fc62e4a98ca603c44a
|
https://github.com/remvee/exifr/blob/1e7b29befed53be8e0bd59fc62e4a98ca603c44a/lib/exifr/jpeg.rb#L51-L55
|
17,571
|
remvee/exifr
|
lib/exifr/jpeg.rb
|
EXIFR.JPEG.method_missing
|
def method_missing(method, *args)
super unless args.empty?
super unless methods.include?(method)
@exif.send method if defined?(@exif) && @exif
end
|
ruby
|
def method_missing(method, *args)
super unless args.empty?
super unless methods.include?(method)
@exif.send method if defined?(@exif) && @exif
end
|
[
"def",
"method_missing",
"(",
"method",
",",
"*",
"args",
")",
"super",
"unless",
"args",
".",
"empty?",
"super",
"unless",
"methods",
".",
"include?",
"(",
"method",
")",
"@exif",
".",
"send",
"method",
"if",
"defined?",
"(",
"@exif",
")",
"&&",
"@exif",
"end"
] |
Dispatch to EXIF. When no EXIF data is available but the
+method+ does exist for EXIF data +nil+ will be returned.
|
[
"Dispatch",
"to",
"EXIF",
".",
"When",
"no",
"EXIF",
"data",
"is",
"available",
"but",
"the",
"+",
"method",
"+",
"does",
"exist",
"for",
"EXIF",
"data",
"+",
"nil",
"+",
"will",
"be",
"returned",
"."
] |
1e7b29befed53be8e0bd59fc62e4a98ca603c44a
|
https://github.com/remvee/exifr/blob/1e7b29befed53be8e0bd59fc62e4a98ca603c44a/lib/exifr/jpeg.rb#L59-L63
|
17,572
|
remvee/exifr
|
lib/exifr/tiff.rb
|
EXIFR.TIFF.method_missing
|
def method_missing(method, *args)
super unless args.empty?
if @ifds.first.respond_to?(method)
@ifds.first.send(method)
elsif TAGS.include?(method)
@ifds.first.to_hash[method]
else
super
end
end
|
ruby
|
def method_missing(method, *args)
super unless args.empty?
if @ifds.first.respond_to?(method)
@ifds.first.send(method)
elsif TAGS.include?(method)
@ifds.first.to_hash[method]
else
super
end
end
|
[
"def",
"method_missing",
"(",
"method",
",",
"*",
"args",
")",
"super",
"unless",
"args",
".",
"empty?",
"if",
"@ifds",
".",
"first",
".",
"respond_to?",
"(",
"method",
")",
"@ifds",
".",
"first",
".",
"send",
"(",
"method",
")",
"elsif",
"TAGS",
".",
"include?",
"(",
"method",
")",
"@ifds",
".",
"first",
".",
"to_hash",
"[",
"method",
"]",
"else",
"super",
"end",
"end"
] |
Dispatch to first image.
|
[
"Dispatch",
"to",
"first",
"image",
"."
] |
1e7b29befed53be8e0bd59fc62e4a98ca603c44a
|
https://github.com/remvee/exifr/blob/1e7b29befed53be8e0bd59fc62e4a98ca603c44a/lib/exifr/tiff.rb#L409-L419
|
17,573
|
remvee/exifr
|
lib/exifr/tiff.rb
|
EXIFR.TIFF.gps
|
def gps
return nil unless gps_latitude && gps_longitude
altitude = gps_altitude.is_a?(Array) ? gps_altitude.first : gps_altitude
GPS.new(gps_latitude.to_f * (gps_latitude_ref == 'S' ? -1 : 1),
gps_longitude.to_f * (gps_longitude_ref == 'W' ? -1 : 1),
altitude && (altitude.to_f * (gps_altitude_ref == "\1" ? -1 : 1)),
gps_img_direction && gps_img_direction.to_f)
end
|
ruby
|
def gps
return nil unless gps_latitude && gps_longitude
altitude = gps_altitude.is_a?(Array) ? gps_altitude.first : gps_altitude
GPS.new(gps_latitude.to_f * (gps_latitude_ref == 'S' ? -1 : 1),
gps_longitude.to_f * (gps_longitude_ref == 'W' ? -1 : 1),
altitude && (altitude.to_f * (gps_altitude_ref == "\1" ? -1 : 1)),
gps_img_direction && gps_img_direction.to_f)
end
|
[
"def",
"gps",
"return",
"nil",
"unless",
"gps_latitude",
"&&",
"gps_longitude",
"altitude",
"=",
"gps_altitude",
".",
"is_a?",
"(",
"Array",
")",
"?",
"gps_altitude",
".",
"first",
":",
"gps_altitude",
"GPS",
".",
"new",
"(",
"gps_latitude",
".",
"to_f",
"*",
"(",
"gps_latitude_ref",
"==",
"'S'",
"?",
"-",
"1",
":",
"1",
")",
",",
"gps_longitude",
".",
"to_f",
"*",
"(",
"gps_longitude_ref",
"==",
"'W'",
"?",
"-",
"1",
":",
"1",
")",
",",
"altitude",
"&&",
"(",
"altitude",
".",
"to_f",
"*",
"(",
"gps_altitude_ref",
"==",
"\"\\1\"",
"?",
"-",
"1",
":",
"1",
")",
")",
",",
"gps_img_direction",
"&&",
"gps_img_direction",
".",
"to_f",
")",
"end"
] |
Get GPS location, altitude and image direction return nil when not available.
|
[
"Get",
"GPS",
"location",
"altitude",
"and",
"image",
"direction",
"return",
"nil",
"when",
"not",
"available",
"."
] |
1e7b29befed53be8e0bd59fc62e4a98ca603c44a
|
https://github.com/remvee/exifr/blob/1e7b29befed53be8e0bd59fc62e4a98ca603c44a/lib/exifr/tiff.rb#L462-L471
|
17,574
|
nathanl/authority
|
lib/authority/controller.rb
|
Authority.Controller.authorize_action_for
|
def authorize_action_for(authority_resource, *options)
# `action_name` comes from ActionController
authority_action = self.class.authority_action_map[action_name.to_sym]
if authority_action.nil?
raise MissingAction.new("No authority action defined for #{action_name}")
end
Authority.enforce(authority_action, authority_resource, authority_user, *options)
# This method is always invoked, but will only log if it's overriden
authority_success(authority_user, authority_action, authority_resource)
self.authorization_performed = true
end
|
ruby
|
def authorize_action_for(authority_resource, *options)
# `action_name` comes from ActionController
authority_action = self.class.authority_action_map[action_name.to_sym]
if authority_action.nil?
raise MissingAction.new("No authority action defined for #{action_name}")
end
Authority.enforce(authority_action, authority_resource, authority_user, *options)
# This method is always invoked, but will only log if it's overriden
authority_success(authority_user, authority_action, authority_resource)
self.authorization_performed = true
end
|
[
"def",
"authorize_action_for",
"(",
"authority_resource",
",",
"*",
"options",
")",
"# `action_name` comes from ActionController",
"authority_action",
"=",
"self",
".",
"class",
".",
"authority_action_map",
"[",
"action_name",
".",
"to_sym",
"]",
"if",
"authority_action",
".",
"nil?",
"raise",
"MissingAction",
".",
"new",
"(",
"\"No authority action defined for #{action_name}\"",
")",
"end",
"Authority",
".",
"enforce",
"(",
"authority_action",
",",
"authority_resource",
",",
"authority_user",
",",
"options",
")",
"# This method is always invoked, but will only log if it's overriden",
"authority_success",
"(",
"authority_user",
",",
"authority_action",
",",
"authority_resource",
")",
"self",
".",
"authorization_performed",
"=",
"true",
"end"
] |
To be run in a `before_filter`; ensure this controller action is allowed for the user
Can be used directly within a controller action as well, given an instance or class with or
without options to delegate to the authorizer.
@param [Class] authority_resource, the model class associated with this controller
@param [Hash] options, arbitrary options hash to forward up the chain to the authorizer
@raise [MissingAction] if controller action isn't a key in `config.controller_action_map`
|
[
"To",
"be",
"run",
"in",
"a",
"before_filter",
";",
"ensure",
"this",
"controller",
"action",
"is",
"allowed",
"for",
"the",
"user",
"Can",
"be",
"used",
"directly",
"within",
"a",
"controller",
"action",
"as",
"well",
"given",
"an",
"instance",
"or",
"class",
"with",
"or",
"without",
"options",
"to",
"delegate",
"to",
"the",
"authorizer",
"."
] |
35176d8bffb99824bc49e8bb5f2ddfe54ff863ad
|
https://github.com/nathanl/authority/blob/35176d8bffb99824bc49e8bb5f2ddfe54ff863ad/lib/authority/controller.rb#L128-L141
|
17,575
|
nathanl/authority
|
lib/authority/controller.rb
|
Authority.Controller.authority_forbidden
|
def authority_forbidden(error)
Authority.logger.warn(error.message)
render :file => Rails.root.join('public', '403.html'), :status => 403, :layout => false
end
|
ruby
|
def authority_forbidden(error)
Authority.logger.warn(error.message)
render :file => Rails.root.join('public', '403.html'), :status => 403, :layout => false
end
|
[
"def",
"authority_forbidden",
"(",
"error",
")",
"Authority",
".",
"logger",
".",
"warn",
"(",
"error",
".",
"message",
")",
"render",
":file",
"=>",
"Rails",
".",
"root",
".",
"join",
"(",
"'public'",
",",
"'403.html'",
")",
",",
":status",
"=>",
"403",
",",
":layout",
"=>",
"false",
"end"
] |
Renders a static file to minimize the chances of further errors.
@param [Exception] error, an error that indicates the user tried to perform a forbidden action.
|
[
"Renders",
"a",
"static",
"file",
"to",
"minimize",
"the",
"chances",
"of",
"further",
"errors",
"."
] |
35176d8bffb99824bc49e8bb5f2ddfe54ff863ad
|
https://github.com/nathanl/authority/blob/35176d8bffb99824bc49e8bb5f2ddfe54ff863ad/lib/authority/controller.rb#L146-L149
|
17,576
|
nathanl/authority
|
lib/authority/controller.rb
|
Authority.Controller.run_authorization_check
|
def run_authorization_check
if instance_authority_resource.is_a?(Array)
# Array includes options; pass as separate args
authorize_action_for(*instance_authority_resource, *authority_arguments)
else
# *resource would be interpreted as resource.to_a, which is wrong and
# actually triggers a query if it's a Sequel model
authorize_action_for(instance_authority_resource, *authority_arguments)
end
end
|
ruby
|
def run_authorization_check
if instance_authority_resource.is_a?(Array)
# Array includes options; pass as separate args
authorize_action_for(*instance_authority_resource, *authority_arguments)
else
# *resource would be interpreted as resource.to_a, which is wrong and
# actually triggers a query if it's a Sequel model
authorize_action_for(instance_authority_resource, *authority_arguments)
end
end
|
[
"def",
"run_authorization_check",
"if",
"instance_authority_resource",
".",
"is_a?",
"(",
"Array",
")",
"# Array includes options; pass as separate args",
"authorize_action_for",
"(",
"instance_authority_resource",
",",
"authority_arguments",
")",
"else",
"# *resource would be interpreted as resource.to_a, which is wrong and",
"# actually triggers a query if it's a Sequel model",
"authorize_action_for",
"(",
"instance_authority_resource",
",",
"authority_arguments",
")",
"end",
"end"
] |
The `before_filter` that will be setup to run when the class method
`authorize_actions_for` is called
|
[
"The",
"before_filter",
"that",
"will",
"be",
"setup",
"to",
"run",
"when",
"the",
"class",
"method",
"authorize_actions_for",
"is",
"called"
] |
35176d8bffb99824bc49e8bb5f2ddfe54ff863ad
|
https://github.com/nathanl/authority/blob/35176d8bffb99824bc49e8bb5f2ddfe54ff863ad/lib/authority/controller.rb#L160-L169
|
17,577
|
theforeman/foreman_docker
|
app/models/service/registry_api.rb
|
Service.RegistryApi.search
|
def search(query)
get('/v1/search'.freeze, { q: query })
rescue => e
logger.warn "API v1 - Search failed #{e.backtrace}"
{ 'results' => catalog(query) }
end
|
ruby
|
def search(query)
get('/v1/search'.freeze, { q: query })
rescue => e
logger.warn "API v1 - Search failed #{e.backtrace}"
{ 'results' => catalog(query) }
end
|
[
"def",
"search",
"(",
"query",
")",
"get",
"(",
"'/v1/search'",
".",
"freeze",
",",
"{",
"q",
":",
"query",
"}",
")",
"rescue",
"=>",
"e",
"logger",
".",
"warn",
"\"API v1 - Search failed #{e.backtrace}\"",
"{",
"'results'",
"=>",
"catalog",
"(",
"query",
")",
"}",
"end"
] |
Since the Registry API v2 does not support a search the v1 endpoint is used
Newer registries will fail, the v2 catalog endpoint is used
|
[
"Since",
"the",
"Registry",
"API",
"v2",
"does",
"not",
"support",
"a",
"search",
"the",
"v1",
"endpoint",
"is",
"used",
"Newer",
"registries",
"will",
"fail",
"the",
"v2",
"catalog",
"endpoint",
"is",
"used"
] |
f785e5ae3f44e9f5c60f30dab351d30d2a1e1038
|
https://github.com/theforeman/foreman_docker/blob/f785e5ae3f44e9f5c60f30dab351d30d2a1e1038/app/models/service/registry_api.rb#L34-L39
|
17,578
|
NUBIC/surveyor
|
lib/surveyor/acts_as_response.rb
|
Surveyor.ActsAsResponse.as
|
def as(type_symbol)
return case type_symbol.to_sym
when :string, :text, :integer, :float, :datetime
self.send("#{type_symbol}_value".to_sym)
when :date
self.datetime_value.nil? ? nil : self.datetime_value.to_date
when :time
self.datetime_value.nil? ? nil : self.datetime_value.to_time
else # :answer_id
self.answer_id
end
end
|
ruby
|
def as(type_symbol)
return case type_symbol.to_sym
when :string, :text, :integer, :float, :datetime
self.send("#{type_symbol}_value".to_sym)
when :date
self.datetime_value.nil? ? nil : self.datetime_value.to_date
when :time
self.datetime_value.nil? ? nil : self.datetime_value.to_time
else # :answer_id
self.answer_id
end
end
|
[
"def",
"as",
"(",
"type_symbol",
")",
"return",
"case",
"type_symbol",
".",
"to_sym",
"when",
":string",
",",
":text",
",",
":integer",
",",
":float",
",",
":datetime",
"self",
".",
"send",
"(",
"\"#{type_symbol}_value\"",
".",
"to_sym",
")",
"when",
":date",
"self",
".",
"datetime_value",
".",
"nil?",
"?",
"nil",
":",
"self",
".",
"datetime_value",
".",
"to_date",
"when",
":time",
"self",
".",
"datetime_value",
".",
"nil?",
"?",
"nil",
":",
"self",
".",
"datetime_value",
".",
"to_time",
"else",
"# :answer_id",
"self",
".",
"answer_id",
"end",
"end"
] |
Returns the response as a particular response_class type
|
[
"Returns",
"the",
"response",
"as",
"a",
"particular",
"response_class",
"type"
] |
d4fe8df2586ba26126bac3c4b3498e67ba813baf
|
https://github.com/NUBIC/surveyor/blob/d4fe8df2586ba26126bac3c4b3498e67ba813baf/lib/surveyor/acts_as_response.rb#L6-L17
|
17,579
|
NUBIC/surveyor
|
lib/surveyor/parser.rb
|
Surveyor.Parser.method_missing
|
def method_missing(missing_method, *args, &block)
method_name, reference_identifier = missing_method.to_s.split("_", 2)
type = full(method_name)
Surveyor::Parser.raise_error( "\"#{type}\" is not a surveyor method." )if !%w(survey survey_translation survey_section question_group question dependency dependency_condition answer validation validation_condition).include?(type)
Surveyor::Parser.rake_trace(reference_identifier.blank? ? "#{type} #{args.map(&:inspect).join ', '}" : "#{type}_#{reference_identifier} #{args.map(&:inspect).join ', '}",
block_models.include?(type) ? 2 : 0)
# check for blocks
Surveyor::Parser.raise_error "A #{type.humanize.downcase} should take a block" if block_models.include?(type) && !block_given?
Surveyor::Parser.raise_error "A #{type.humanize.downcase} doesn't take a block" if !block_models.include?(type) && block_given?
# parse and build
type.classify.constantize.new.extend("SurveyorParser#{type.classify}Methods".constantize).parse_and_build(context, args, method_name, reference_identifier)
# evaluate and clear context for block models
if block_models.include?(type)
self.instance_eval(&block)
if type == 'survey'
resolve_dependency_condition_references
resolve_question_correct_answers
report_lost_and_duplicate_references
report_missing_default_locale
Surveyor::Parser.rake_trace("", -2)
if context[:survey].save
Surveyor::Parser.rake_trace "Survey saved."
else
Surveyor::Parser.raise_error "Survey not saved: #{context[:survey].errors.full_messages.join(", ")}"
end
else
Surveyor::Parser.rake_trace("", -2)
context[type.to_sym].clear(context)
end
end
end
|
ruby
|
def method_missing(missing_method, *args, &block)
method_name, reference_identifier = missing_method.to_s.split("_", 2)
type = full(method_name)
Surveyor::Parser.raise_error( "\"#{type}\" is not a surveyor method." )if !%w(survey survey_translation survey_section question_group question dependency dependency_condition answer validation validation_condition).include?(type)
Surveyor::Parser.rake_trace(reference_identifier.blank? ? "#{type} #{args.map(&:inspect).join ', '}" : "#{type}_#{reference_identifier} #{args.map(&:inspect).join ', '}",
block_models.include?(type) ? 2 : 0)
# check for blocks
Surveyor::Parser.raise_error "A #{type.humanize.downcase} should take a block" if block_models.include?(type) && !block_given?
Surveyor::Parser.raise_error "A #{type.humanize.downcase} doesn't take a block" if !block_models.include?(type) && block_given?
# parse and build
type.classify.constantize.new.extend("SurveyorParser#{type.classify}Methods".constantize).parse_and_build(context, args, method_name, reference_identifier)
# evaluate and clear context for block models
if block_models.include?(type)
self.instance_eval(&block)
if type == 'survey'
resolve_dependency_condition_references
resolve_question_correct_answers
report_lost_and_duplicate_references
report_missing_default_locale
Surveyor::Parser.rake_trace("", -2)
if context[:survey].save
Surveyor::Parser.rake_trace "Survey saved."
else
Surveyor::Parser.raise_error "Survey not saved: #{context[:survey].errors.full_messages.join(", ")}"
end
else
Surveyor::Parser.rake_trace("", -2)
context[type.to_sym].clear(context)
end
end
end
|
[
"def",
"method_missing",
"(",
"missing_method",
",",
"*",
"args",
",",
"&",
"block",
")",
"method_name",
",",
"reference_identifier",
"=",
"missing_method",
".",
"to_s",
".",
"split",
"(",
"\"_\"",
",",
"2",
")",
"type",
"=",
"full",
"(",
"method_name",
")",
"Surveyor",
"::",
"Parser",
".",
"raise_error",
"(",
"\"\\\"#{type}\\\" is not a surveyor method.\"",
")",
"if",
"!",
"%w(",
"survey",
"survey_translation",
"survey_section",
"question_group",
"question",
"dependency",
"dependency_condition",
"answer",
"validation",
"validation_condition",
")",
".",
"include?",
"(",
"type",
")",
"Surveyor",
"::",
"Parser",
".",
"rake_trace",
"(",
"reference_identifier",
".",
"blank?",
"?",
"\"#{type} #{args.map(&:inspect).join ', '}\"",
":",
"\"#{type}_#{reference_identifier} #{args.map(&:inspect).join ', '}\"",
",",
"block_models",
".",
"include?",
"(",
"type",
")",
"?",
"2",
":",
"0",
")",
"# check for blocks",
"Surveyor",
"::",
"Parser",
".",
"raise_error",
"\"A #{type.humanize.downcase} should take a block\"",
"if",
"block_models",
".",
"include?",
"(",
"type",
")",
"&&",
"!",
"block_given?",
"Surveyor",
"::",
"Parser",
".",
"raise_error",
"\"A #{type.humanize.downcase} doesn't take a block\"",
"if",
"!",
"block_models",
".",
"include?",
"(",
"type",
")",
"&&",
"block_given?",
"# parse and build",
"type",
".",
"classify",
".",
"constantize",
".",
"new",
".",
"extend",
"(",
"\"SurveyorParser#{type.classify}Methods\"",
".",
"constantize",
")",
".",
"parse_and_build",
"(",
"context",
",",
"args",
",",
"method_name",
",",
"reference_identifier",
")",
"# evaluate and clear context for block models",
"if",
"block_models",
".",
"include?",
"(",
"type",
")",
"self",
".",
"instance_eval",
"(",
"block",
")",
"if",
"type",
"==",
"'survey'",
"resolve_dependency_condition_references",
"resolve_question_correct_answers",
"report_lost_and_duplicate_references",
"report_missing_default_locale",
"Surveyor",
"::",
"Parser",
".",
"rake_trace",
"(",
"\"\"",
",",
"-",
"2",
")",
"if",
"context",
"[",
":survey",
"]",
".",
"save",
"Surveyor",
"::",
"Parser",
".",
"rake_trace",
"\"Survey saved.\"",
"else",
"Surveyor",
"::",
"Parser",
".",
"raise_error",
"\"Survey not saved: #{context[:survey].errors.full_messages.join(\", \")}\"",
"end",
"else",
"Surveyor",
"::",
"Parser",
".",
"rake_trace",
"(",
"\"\"",
",",
"-",
"2",
")",
"context",
"[",
"type",
".",
"to_sym",
"]",
".",
"clear",
"(",
"context",
")",
"end",
"end",
"end"
] |
This method_missing does all the heavy lifting for the DSL
|
[
"This",
"method_missing",
"does",
"all",
"the",
"heavy",
"lifting",
"for",
"the",
"DSL"
] |
d4fe8df2586ba26126bac3c4b3498e67ba813baf
|
https://github.com/NUBIC/surveyor/blob/d4fe8df2586ba26126bac3c4b3498e67ba813baf/lib/surveyor/parser.rb#L69-L103
|
17,580
|
rgrove/larch
|
lib/larch/config.rb
|
Larch.Config.validate
|
def validate
['from', 'to'].each do |s|
raise Error, "'#{s}' must be a valid IMAP URI (e.g. imap://example.com)" unless fetch(s) =~ IMAP::REGEX_URI
end
unless Logger::LEVELS.has_key?(verbosity.to_sym)
raise Error, "'verbosity' must be one of: #{Logger::LEVELS.keys.join(', ')}"
end
if exclude_file
raise Error, "exclude file not found: #{exclude_file}" unless File.file?(exclude_file)
raise Error, "exclude file cannot be read: #{exclude_file}" unless File.readable?(exclude_file)
end
if @cached['all'] || @cached['all-subscribed']
# A specific source folder wins over 'all' and 'all-subscribed'
if @cached['from-folder']
@cached['all'] = false
@cached['all-subscribed'] = false
@cached['to-folder'] ||= @cached['from-folder']
elsif @cached['all'] && @cached['all-subscribed']
# 'all' wins over 'all-subscribed'
@cached['all-subscribed'] = false
end
# 'no-recurse' is not compatible with 'all' and 'all-subscribed'
raise Error, "'no-recurse' option cannot be used with 'all' or 'all-subscribed'" if @cached['no-recurse']
else
@cached['from-folder'] ||= 'INBOX'
@cached['to-folder'] ||= 'INBOX'
end
@cached['exclude'].flatten!
end
|
ruby
|
def validate
['from', 'to'].each do |s|
raise Error, "'#{s}' must be a valid IMAP URI (e.g. imap://example.com)" unless fetch(s) =~ IMAP::REGEX_URI
end
unless Logger::LEVELS.has_key?(verbosity.to_sym)
raise Error, "'verbosity' must be one of: #{Logger::LEVELS.keys.join(', ')}"
end
if exclude_file
raise Error, "exclude file not found: #{exclude_file}" unless File.file?(exclude_file)
raise Error, "exclude file cannot be read: #{exclude_file}" unless File.readable?(exclude_file)
end
if @cached['all'] || @cached['all-subscribed']
# A specific source folder wins over 'all' and 'all-subscribed'
if @cached['from-folder']
@cached['all'] = false
@cached['all-subscribed'] = false
@cached['to-folder'] ||= @cached['from-folder']
elsif @cached['all'] && @cached['all-subscribed']
# 'all' wins over 'all-subscribed'
@cached['all-subscribed'] = false
end
# 'no-recurse' is not compatible with 'all' and 'all-subscribed'
raise Error, "'no-recurse' option cannot be used with 'all' or 'all-subscribed'" if @cached['no-recurse']
else
@cached['from-folder'] ||= 'INBOX'
@cached['to-folder'] ||= 'INBOX'
end
@cached['exclude'].flatten!
end
|
[
"def",
"validate",
"[",
"'from'",
",",
"'to'",
"]",
".",
"each",
"do",
"|",
"s",
"|",
"raise",
"Error",
",",
"\"'#{s}' must be a valid IMAP URI (e.g. imap://example.com)\"",
"unless",
"fetch",
"(",
"s",
")",
"=~",
"IMAP",
"::",
"REGEX_URI",
"end",
"unless",
"Logger",
"::",
"LEVELS",
".",
"has_key?",
"(",
"verbosity",
".",
"to_sym",
")",
"raise",
"Error",
",",
"\"'verbosity' must be one of: #{Logger::LEVELS.keys.join(', ')}\"",
"end",
"if",
"exclude_file",
"raise",
"Error",
",",
"\"exclude file not found: #{exclude_file}\"",
"unless",
"File",
".",
"file?",
"(",
"exclude_file",
")",
"raise",
"Error",
",",
"\"exclude file cannot be read: #{exclude_file}\"",
"unless",
"File",
".",
"readable?",
"(",
"exclude_file",
")",
"end",
"if",
"@cached",
"[",
"'all'",
"]",
"||",
"@cached",
"[",
"'all-subscribed'",
"]",
"# A specific source folder wins over 'all' and 'all-subscribed'",
"if",
"@cached",
"[",
"'from-folder'",
"]",
"@cached",
"[",
"'all'",
"]",
"=",
"false",
"@cached",
"[",
"'all-subscribed'",
"]",
"=",
"false",
"@cached",
"[",
"'to-folder'",
"]",
"||=",
"@cached",
"[",
"'from-folder'",
"]",
"elsif",
"@cached",
"[",
"'all'",
"]",
"&&",
"@cached",
"[",
"'all-subscribed'",
"]",
"# 'all' wins over 'all-subscribed'",
"@cached",
"[",
"'all-subscribed'",
"]",
"=",
"false",
"end",
"# 'no-recurse' is not compatible with 'all' and 'all-subscribed'",
"raise",
"Error",
",",
"\"'no-recurse' option cannot be used with 'all' or 'all-subscribed'\"",
"if",
"@cached",
"[",
"'no-recurse'",
"]",
"else",
"@cached",
"[",
"'from-folder'",
"]",
"||=",
"'INBOX'",
"@cached",
"[",
"'to-folder'",
"]",
"||=",
"'INBOX'",
"end",
"@cached",
"[",
"'exclude'",
"]",
".",
"flatten!",
"end"
] |
Validates the config and resolves conflicting settings.
|
[
"Validates",
"the",
"config",
"and",
"resolves",
"conflicting",
"settings",
"."
] |
64eb3bd1e3d3335a52e656c7641d9b5b10d6ed42
|
https://github.com/rgrove/larch/blob/64eb3bd1e3d3335a52e656c7641d9b5b10d6ed42/lib/larch/config.rb#L73-L108
|
17,581
|
rgrove/larch
|
lib/larch/config.rb
|
Larch.Config.cache_config
|
def cache_config
@cached = {}
@lookup.reverse.each do |c|
c.each {|k, v| @cached[k] = config_merge(@cached[k] || {}, v) }
end
end
|
ruby
|
def cache_config
@cached = {}
@lookup.reverse.each do |c|
c.each {|k, v| @cached[k] = config_merge(@cached[k] || {}, v) }
end
end
|
[
"def",
"cache_config",
"@cached",
"=",
"{",
"}",
"@lookup",
".",
"reverse",
".",
"each",
"do",
"|",
"c",
"|",
"c",
".",
"each",
"{",
"|",
"k",
",",
"v",
"|",
"@cached",
"[",
"k",
"]",
"=",
"config_merge",
"(",
"@cached",
"[",
"k",
"]",
"||",
"{",
"}",
",",
"v",
")",
"}",
"end",
"end"
] |
Merges configs such that those earlier in the lookup chain override those
later in the chain.
|
[
"Merges",
"configs",
"such",
"that",
"those",
"earlier",
"in",
"the",
"lookup",
"chain",
"override",
"those",
"later",
"in",
"the",
"chain",
"."
] |
64eb3bd1e3d3335a52e656c7641d9b5b10d6ed42
|
https://github.com/rgrove/larch/blob/64eb3bd1e3d3335a52e656c7641d9b5b10d6ed42/lib/larch/config.rb#L114-L120
|
17,582
|
rgrove/larch
|
lib/larch/imap.rb
|
Larch.IMAP.safely
|
def safely
safe_connect
retries = 0
begin
yield
rescue Errno::ECONNABORTED,
Errno::ECONNRESET,
Errno::ENOTCONN,
Errno::EPIPE,
Errno::ETIMEDOUT,
IOError,
Net::IMAP::ByeResponseError,
OpenSSL::SSL::SSLError => e
raise unless (retries += 1) <= @options[:max_retries]
warning "#{e.class.name}: #{e.message} (reconnecting)"
reset
sleep 1 * retries
safe_connect
retry
rescue Net::IMAP::BadResponseError,
Net::IMAP::NoResponseError,
Net::IMAP::ResponseParseError => e
raise unless (retries += 1) <= @options[:max_retries]
warning "#{e.class.name}: #{e.message} (will retry)"
sleep 1 * retries
retry
end
rescue Larch::Error => e
raise
rescue Net::IMAP::Error => e
raise Error, "#{e.class.name}: #{e.message} (giving up)"
rescue => e
raise FatalError, "#{e.class.name}: #{e.message} (cannot recover)"
end
|
ruby
|
def safely
safe_connect
retries = 0
begin
yield
rescue Errno::ECONNABORTED,
Errno::ECONNRESET,
Errno::ENOTCONN,
Errno::EPIPE,
Errno::ETIMEDOUT,
IOError,
Net::IMAP::ByeResponseError,
OpenSSL::SSL::SSLError => e
raise unless (retries += 1) <= @options[:max_retries]
warning "#{e.class.name}: #{e.message} (reconnecting)"
reset
sleep 1 * retries
safe_connect
retry
rescue Net::IMAP::BadResponseError,
Net::IMAP::NoResponseError,
Net::IMAP::ResponseParseError => e
raise unless (retries += 1) <= @options[:max_retries]
warning "#{e.class.name}: #{e.message} (will retry)"
sleep 1 * retries
retry
end
rescue Larch::Error => e
raise
rescue Net::IMAP::Error => e
raise Error, "#{e.class.name}: #{e.message} (giving up)"
rescue => e
raise FatalError, "#{e.class.name}: #{e.message} (cannot recover)"
end
|
[
"def",
"safely",
"safe_connect",
"retries",
"=",
"0",
"begin",
"yield",
"rescue",
"Errno",
"::",
"ECONNABORTED",
",",
"Errno",
"::",
"ECONNRESET",
",",
"Errno",
"::",
"ENOTCONN",
",",
"Errno",
"::",
"EPIPE",
",",
"Errno",
"::",
"ETIMEDOUT",
",",
"IOError",
",",
"Net",
"::",
"IMAP",
"::",
"ByeResponseError",
",",
"OpenSSL",
"::",
"SSL",
"::",
"SSLError",
"=>",
"e",
"raise",
"unless",
"(",
"retries",
"+=",
"1",
")",
"<=",
"@options",
"[",
":max_retries",
"]",
"warning",
"\"#{e.class.name}: #{e.message} (reconnecting)\"",
"reset",
"sleep",
"1",
"*",
"retries",
"safe_connect",
"retry",
"rescue",
"Net",
"::",
"IMAP",
"::",
"BadResponseError",
",",
"Net",
"::",
"IMAP",
"::",
"NoResponseError",
",",
"Net",
"::",
"IMAP",
"::",
"ResponseParseError",
"=>",
"e",
"raise",
"unless",
"(",
"retries",
"+=",
"1",
")",
"<=",
"@options",
"[",
":max_retries",
"]",
"warning",
"\"#{e.class.name}: #{e.message} (will retry)\"",
"sleep",
"1",
"*",
"retries",
"retry",
"end",
"rescue",
"Larch",
"::",
"Error",
"=>",
"e",
"raise",
"rescue",
"Net",
"::",
"IMAP",
"::",
"Error",
"=>",
"e",
"raise",
"Error",
",",
"\"#{e.class.name}: #{e.message} (giving up)\"",
"rescue",
"=>",
"e",
"raise",
"FatalError",
",",
"\"#{e.class.name}: #{e.message} (cannot recover)\"",
"end"
] |
Connect if necessary, execute the given block, retry if a recoverable error
occurs, die if an unrecoverable error occurs.
|
[
"Connect",
"if",
"necessary",
"execute",
"the",
"given",
"block",
"retry",
"if",
"a",
"recoverable",
"error",
"occurs",
"die",
"if",
"an",
"unrecoverable",
"error",
"occurs",
"."
] |
64eb3bd1e3d3335a52e656c7641d9b5b10d6ed42
|
https://github.com/rgrove/larch/blob/64eb3bd1e3d3335a52e656c7641d9b5b10d6ed42/lib/larch/imap.rb#L185-L231
|
17,583
|
rgrove/larch
|
lib/larch/imap.rb
|
Larch.IMAP.uri_mailbox
|
def uri_mailbox
mb = @uri.path[1..-1]
mb.nil? || mb.empty? ? nil : CGI.unescape(mb)
end
|
ruby
|
def uri_mailbox
mb = @uri.path[1..-1]
mb.nil? || mb.empty? ? nil : CGI.unescape(mb)
end
|
[
"def",
"uri_mailbox",
"mb",
"=",
"@uri",
".",
"path",
"[",
"1",
"..",
"-",
"1",
"]",
"mb",
".",
"nil?",
"||",
"mb",
".",
"empty?",
"?",
"nil",
":",
"CGI",
".",
"unescape",
"(",
"mb",
")",
"end"
] |
Gets the IMAP mailbox specified in the URI, or +nil+ if none.
|
[
"Gets",
"the",
"IMAP",
"mailbox",
"specified",
"in",
"the",
"URI",
"or",
"+",
"nil",
"+",
"if",
"none",
"."
] |
64eb3bd1e3d3335a52e656c7641d9b5b10d6ed42
|
https://github.com/rgrove/larch/blob/64eb3bd1e3d3335a52e656c7641d9b5b10d6ed42/lib/larch/imap.rb#L244-L247
|
17,584
|
rgrove/larch
|
lib/larch/imap.rb
|
Larch.IMAP.check_quirks
|
def check_quirks
return unless @conn &&
@conn.greeting.kind_of?(Net::IMAP::UntaggedResponse) &&
@conn.greeting.data.kind_of?(Net::IMAP::ResponseText)
if @conn.greeting.data.text =~ /^Gimap ready/
@quirks[:gmail] = true
debug "looks like Gmail"
elsif host =~ /^imap(?:-ssl)?\.mail\.yahoo\.com$/
@quirks[:yahoo] = true
debug "looks like Yahoo! Mail"
elsif host =~ /emailsrvr\.com/
@quirks[:rackspace] = true
debug "looks like Rackspace Mail"
end
end
|
ruby
|
def check_quirks
return unless @conn &&
@conn.greeting.kind_of?(Net::IMAP::UntaggedResponse) &&
@conn.greeting.data.kind_of?(Net::IMAP::ResponseText)
if @conn.greeting.data.text =~ /^Gimap ready/
@quirks[:gmail] = true
debug "looks like Gmail"
elsif host =~ /^imap(?:-ssl)?\.mail\.yahoo\.com$/
@quirks[:yahoo] = true
debug "looks like Yahoo! Mail"
elsif host =~ /emailsrvr\.com/
@quirks[:rackspace] = true
debug "looks like Rackspace Mail"
end
end
|
[
"def",
"check_quirks",
"return",
"unless",
"@conn",
"&&",
"@conn",
".",
"greeting",
".",
"kind_of?",
"(",
"Net",
"::",
"IMAP",
"::",
"UntaggedResponse",
")",
"&&",
"@conn",
".",
"greeting",
".",
"data",
".",
"kind_of?",
"(",
"Net",
"::",
"IMAP",
"::",
"ResponseText",
")",
"if",
"@conn",
".",
"greeting",
".",
"data",
".",
"text",
"=~",
"/",
"/",
"@quirks",
"[",
":gmail",
"]",
"=",
"true",
"debug",
"\"looks like Gmail\"",
"elsif",
"host",
"=~",
"/",
"\\.",
"\\.",
"\\.",
"/",
"@quirks",
"[",
":yahoo",
"]",
"=",
"true",
"debug",
"\"looks like Yahoo! Mail\"",
"elsif",
"host",
"=~",
"/",
"\\.",
"/",
"@quirks",
"[",
":rackspace",
"]",
"=",
"true",
"debug",
"\"looks like Rackspace Mail\"",
"end",
"end"
] |
Tries to identify server implementations with certain quirks that we'll need
to work around.
|
[
"Tries",
"to",
"identify",
"server",
"implementations",
"with",
"certain",
"quirks",
"that",
"we",
"ll",
"need",
"to",
"work",
"around",
"."
] |
64eb3bd1e3d3335a52e656c7641d9b5b10d6ed42
|
https://github.com/rgrove/larch/blob/64eb3bd1e3d3335a52e656c7641d9b5b10d6ed42/lib/larch/imap.rb#L258-L275
|
17,585
|
autoforce/APIcasso
|
app/controllers/apicasso/crud_controller.rb
|
Apicasso.CrudController.set_object
|
def set_object
id = params[:id]
@object = resource.friendly.find(id)
rescue NoMethodError
@object = resource.find(id)
ensure
authorize! action_to_cancancan, @object
end
|
ruby
|
def set_object
id = params[:id]
@object = resource.friendly.find(id)
rescue NoMethodError
@object = resource.find(id)
ensure
authorize! action_to_cancancan, @object
end
|
[
"def",
"set_object",
"id",
"=",
"params",
"[",
":id",
"]",
"@object",
"=",
"resource",
".",
"friendly",
".",
"find",
"(",
"id",
")",
"rescue",
"NoMethodError",
"@object",
"=",
"resource",
".",
"find",
"(",
"id",
")",
"ensure",
"authorize!",
"action_to_cancancan",
",",
"@object",
"end"
] |
Common setup to stablish which object this request is querying
|
[
"Common",
"setup",
"to",
"stablish",
"which",
"object",
"this",
"request",
"is",
"querying"
] |
a95b5fc894eeacd71271ccf33f05d286b5c32b9f
|
https://github.com/autoforce/APIcasso/blob/a95b5fc894eeacd71271ccf33f05d286b5c32b9f/app/controllers/apicasso/crud_controller.rb#L87-L94
|
17,586
|
autoforce/APIcasso
|
app/controllers/apicasso/crud_controller.rb
|
Apicasso.CrudController.set_records
|
def set_records
authorize! :read, resource.name.underscore.to_sym
@records = request_collection.ransack(parsed_query).result
@object = request_collection.new
key_scope_records
reorder_records if params[:sort].present?
select_fields if params[:select].present?
include_relations if params[:include].present?
end
|
ruby
|
def set_records
authorize! :read, resource.name.underscore.to_sym
@records = request_collection.ransack(parsed_query).result
@object = request_collection.new
key_scope_records
reorder_records if params[:sort].present?
select_fields if params[:select].present?
include_relations if params[:include].present?
end
|
[
"def",
"set_records",
"authorize!",
":read",
",",
"resource",
".",
"name",
".",
"underscore",
".",
"to_sym",
"@records",
"=",
"request_collection",
".",
"ransack",
"(",
"parsed_query",
")",
".",
"result",
"@object",
"=",
"request_collection",
".",
"new",
"key_scope_records",
"reorder_records",
"if",
"params",
"[",
":sort",
"]",
".",
"present?",
"select_fields",
"if",
"params",
"[",
":select",
"]",
".",
"present?",
"include_relations",
"if",
"params",
"[",
":include",
"]",
".",
"present?",
"end"
] |
Used to setup the records from the selected resource that are
going to be rendered, if authorized
|
[
"Used",
"to",
"setup",
"the",
"records",
"from",
"the",
"selected",
"resource",
"that",
"are",
"going",
"to",
"be",
"rendered",
"if",
"authorized"
] |
a95b5fc894eeacd71271ccf33f05d286b5c32b9f
|
https://github.com/autoforce/APIcasso/blob/a95b5fc894eeacd71271ccf33f05d286b5c32b9f/app/controllers/apicasso/crud_controller.rb#L98-L106
|
17,587
|
autoforce/APIcasso
|
app/controllers/apicasso/crud_controller.rb
|
Apicasso.CrudController.index_json
|
def index_json
if params[:group].present?
@records.group(params[:group][:by].split(','))
.send(:calculate,
params[:group][:calculate],
params[:group][:field])
else
collection_response
end
end
|
ruby
|
def index_json
if params[:group].present?
@records.group(params[:group][:by].split(','))
.send(:calculate,
params[:group][:calculate],
params[:group][:field])
else
collection_response
end
end
|
[
"def",
"index_json",
"if",
"params",
"[",
":group",
"]",
".",
"present?",
"@records",
".",
"group",
"(",
"params",
"[",
":group",
"]",
"[",
":by",
"]",
".",
"split",
"(",
"','",
")",
")",
".",
"send",
"(",
":calculate",
",",
"params",
"[",
":group",
"]",
"[",
":calculate",
"]",
",",
"params",
"[",
":group",
"]",
"[",
":field",
"]",
")",
"else",
"collection_response",
"end",
"end"
] |
The response for index action, which can be a pagination of a
record collection or a grouped count of attributes
|
[
"The",
"response",
"for",
"index",
"action",
"which",
"can",
"be",
"a",
"pagination",
"of",
"a",
"record",
"collection",
"or",
"a",
"grouped",
"count",
"of",
"attributes"
] |
a95b5fc894eeacd71271ccf33f05d286b5c32b9f
|
https://github.com/autoforce/APIcasso/blob/a95b5fc894eeacd71271ccf33f05d286b5c32b9f/app/controllers/apicasso/crud_controller.rb#L133-L142
|
17,588
|
autoforce/APIcasso
|
app/controllers/apicasso/application_controller.rb
|
Apicasso.ApplicationController.request_metadata
|
def request_metadata
{
uuid: request.uuid,
url: request.original_url,
headers: request.env.select { |key, _v| key =~ /^HTTP_/ },
ip: request.remote_ip
}
end
|
ruby
|
def request_metadata
{
uuid: request.uuid,
url: request.original_url,
headers: request.env.select { |key, _v| key =~ /^HTTP_/ },
ip: request.remote_ip
}
end
|
[
"def",
"request_metadata",
"{",
"uuid",
":",
"request",
".",
"uuid",
",",
"url",
":",
"request",
".",
"original_url",
",",
"headers",
":",
"request",
".",
"env",
".",
"select",
"{",
"|",
"key",
",",
"_v",
"|",
"key",
"=~",
"/",
"/",
"}",
",",
"ip",
":",
"request",
".",
"remote_ip",
"}",
"end"
] |
Information that gets inserted on `register_api_request` as auditing data
about the request. Returns a Hash with UUID, URL, HTTP Headers and IP
|
[
"Information",
"that",
"gets",
"inserted",
"on",
"register_api_request",
"as",
"auditing",
"data",
"about",
"the",
"request",
".",
"Returns",
"a",
"Hash",
"with",
"UUID",
"URL",
"HTTP",
"Headers",
"and",
"IP"
] |
a95b5fc894eeacd71271ccf33f05d286b5c32b9f
|
https://github.com/autoforce/APIcasso/blob/a95b5fc894eeacd71271ccf33f05d286b5c32b9f/app/controllers/apicasso/application_controller.rb#L49-L56
|
17,589
|
autoforce/APIcasso
|
app/models/apicasso/ability.rb
|
Apicasso.Ability.build_permissions
|
def build_permissions(opts = {})
permission = opts[:permission].to_sym
clearances = opts[:clearance]
# To have full read access to the whole APIcasso just set a
# true key scope operation.
# Usage:
# To have full read access to the system the scope would be:
# => `{read: true}`
if clearances == true
can permission, :all
else
clearances.to_h.each do |klass, clearance|
klass_module = klass.underscore.singularize.to_sym
klass = klass.classify.constantize
can permission, klass_module
if clearance == true
# Usage:
# To have a key reading all channels and all accouts
# you would have a scope:
# => `{read: {channel: true, accout: true}}`
can permission, klass
else
clear_for(permission, klass, clearance)
end
end
end
end
|
ruby
|
def build_permissions(opts = {})
permission = opts[:permission].to_sym
clearances = opts[:clearance]
# To have full read access to the whole APIcasso just set a
# true key scope operation.
# Usage:
# To have full read access to the system the scope would be:
# => `{read: true}`
if clearances == true
can permission, :all
else
clearances.to_h.each do |klass, clearance|
klass_module = klass.underscore.singularize.to_sym
klass = klass.classify.constantize
can permission, klass_module
if clearance == true
# Usage:
# To have a key reading all channels and all accouts
# you would have a scope:
# => `{read: {channel: true, accout: true}}`
can permission, klass
else
clear_for(permission, klass, clearance)
end
end
end
end
|
[
"def",
"build_permissions",
"(",
"opts",
"=",
"{",
"}",
")",
"permission",
"=",
"opts",
"[",
":permission",
"]",
".",
"to_sym",
"clearances",
"=",
"opts",
"[",
":clearance",
"]",
"# To have full read access to the whole APIcasso just set a",
"# true key scope operation.",
"# Usage:",
"# To have full read access to the system the scope would be:",
"# => `{read: true}`",
"if",
"clearances",
"==",
"true",
"can",
"permission",
",",
":all",
"else",
"clearances",
".",
"to_h",
".",
"each",
"do",
"|",
"klass",
",",
"clearance",
"|",
"klass_module",
"=",
"klass",
".",
"underscore",
".",
"singularize",
".",
"to_sym",
"klass",
"=",
"klass",
".",
"classify",
".",
"constantize",
"can",
"permission",
",",
"klass_module",
"if",
"clearance",
"==",
"true",
"# Usage:",
"# To have a key reading all channels and all accouts",
"# you would have a scope:",
"# => `{read: {channel: true, accout: true}}`",
"can",
"permission",
",",
"klass",
"else",
"clear_for",
"(",
"permission",
",",
"klass",
",",
"clearance",
")",
"end",
"end",
"end",
"end"
] |
Method that initializes CanCanCan with the scope of
permissions based on current key from request
@param key [Object] a key object by APIcasso to CanCanCan with ability
|
[
"Method",
"that",
"initializes",
"CanCanCan",
"with",
"the",
"scope",
"of",
"permissions",
"based",
"on",
"current",
"key",
"from",
"request"
] |
a95b5fc894eeacd71271ccf33f05d286b5c32b9f
|
https://github.com/autoforce/APIcasso/blob/a95b5fc894eeacd71271ccf33f05d286b5c32b9f/app/models/apicasso/ability.rb#L20-L46
|
17,590
|
rom-rb/rom-factory
|
lib/rom/factory/factories.rb
|
ROM::Factory.Factories.define
|
def define(spec, **opts, &block)
name, parent = spec.is_a?(Hash) ? spec.flatten(1) : spec
if registry.key?(name)
raise ArgumentError, "#{name.inspect} factory has been already defined"
end
builder =
if parent
extend_builder(name, registry[parent], &block)
else
relation_name = opts.fetch(:relation) { infer_relation(name) }
relation = rom.relations[relation_name]
DSL.new(name, relation: relation.struct_namespace(struct_namespace), factories: self, &block).call
end
registry[name] = builder
end
|
ruby
|
def define(spec, **opts, &block)
name, parent = spec.is_a?(Hash) ? spec.flatten(1) : spec
if registry.key?(name)
raise ArgumentError, "#{name.inspect} factory has been already defined"
end
builder =
if parent
extend_builder(name, registry[parent], &block)
else
relation_name = opts.fetch(:relation) { infer_relation(name) }
relation = rom.relations[relation_name]
DSL.new(name, relation: relation.struct_namespace(struct_namespace), factories: self, &block).call
end
registry[name] = builder
end
|
[
"def",
"define",
"(",
"spec",
",",
"**",
"opts",
",",
"&",
"block",
")",
"name",
",",
"parent",
"=",
"spec",
".",
"is_a?",
"(",
"Hash",
")",
"?",
"spec",
".",
"flatten",
"(",
"1",
")",
":",
"spec",
"if",
"registry",
".",
"key?",
"(",
"name",
")",
"raise",
"ArgumentError",
",",
"\"#{name.inspect} factory has been already defined\"",
"end",
"builder",
"=",
"if",
"parent",
"extend_builder",
"(",
"name",
",",
"registry",
"[",
"parent",
"]",
",",
"block",
")",
"else",
"relation_name",
"=",
"opts",
".",
"fetch",
"(",
":relation",
")",
"{",
"infer_relation",
"(",
"name",
")",
"}",
"relation",
"=",
"rom",
".",
"relations",
"[",
"relation_name",
"]",
"DSL",
".",
"new",
"(",
"name",
",",
"relation",
":",
"relation",
".",
"struct_namespace",
"(",
"struct_namespace",
")",
",",
"factories",
":",
"self",
",",
"block",
")",
".",
"call",
"end",
"registry",
"[",
"name",
"]",
"=",
"builder",
"end"
] |
Define a new builder
@example a simple builder
MyFactory.define(:user) do |f|
f.name "Jane"
f.email "jane@doe.org"
end
@example a builder using auto-generated fake values
MyFactory.define(:user) do |f|
f.name { fake(:name) }
f.email { fake(:internet, :email) }
end
@example a builder using sequenced values
MyFactory.define(:user) do |f|
f.sequence(:name) { |n| "user-#{n}" }
end
@example a builder using values from other attribute(s)
MyFactory.define(:user) do |f|
f.name "Jane"
f.email { |name| "#{name.downcase}@rom-rb.org" }
end
@example a builder with "belongs-to" association
MyFactory.define(:group) do |f|
f.name "Admins"
end
MyFactory.define(:user) do |f|
f.name "Jane"
f.association(:group)
end
@example a builder with "has-many" association
MyFactory.define(:group) do |f|
f.name "Admins"
f.association(:users, count: 2)
end
MyFactory.define(:user) do |f|
f.sequence(:name) { |n| "user-#{n}" }
end
@example a builder which extends another builder
MyFactory.define(:user) do |f|
f.name "Jane"
f.admin false
end
MyFactory.define(admin: :user) do |f|
f.admin true
end
@param [Symbol, Hash<Symbol=>Symbol>] spec Builder identifier, can point to a parent builder too
@param [Hash] opts Additional options
@option opts [Symbol] relation An optional relation name (defaults to pluralized builder name)
@return [ROM::Factory::Builder]
@api public
|
[
"Define",
"a",
"new",
"builder"
] |
ca7425bbc5fa0ff3ae1913d79fc84b1ef86ccf9f
|
https://github.com/rom-rb/rom-factory/blob/ca7425bbc5fa0ff3ae1913d79fc84b1ef86ccf9f/lib/rom/factory/factories.rb#L132-L149
|
17,591
|
rom-rb/rom-factory
|
lib/rom/factory/factories.rb
|
ROM::Factory.Factories.struct_namespace
|
def struct_namespace(namespace = Undefined)
if namespace.equal?(Undefined)
options[:struct_namespace]
else
with(struct_namespace: namespace)
end
end
|
ruby
|
def struct_namespace(namespace = Undefined)
if namespace.equal?(Undefined)
options[:struct_namespace]
else
with(struct_namespace: namespace)
end
end
|
[
"def",
"struct_namespace",
"(",
"namespace",
"=",
"Undefined",
")",
"if",
"namespace",
".",
"equal?",
"(",
"Undefined",
")",
"options",
"[",
":struct_namespace",
"]",
"else",
"with",
"(",
"struct_namespace",
":",
"namespace",
")",
"end",
"end"
] |
Get factories with a custom struct namespace
@example
EntityFactory = MyFactory.struct_namespace(MyApp::Entities)
EntityFactory[:user]
# => #<MyApp::Entities::User id=2 ...>
@param [Module] namespace
@return [Factories]
@api public
|
[
"Get",
"factories",
"with",
"a",
"custom",
"struct",
"namespace"
] |
ca7425bbc5fa0ff3ae1913d79fc84b1ef86ccf9f
|
https://github.com/rom-rb/rom-factory/blob/ca7425bbc5fa0ff3ae1913d79fc84b1ef86ccf9f/lib/rom/factory/factories.rb#L191-L197
|
17,592
|
kylewlacy/timerizer
|
lib/timerizer/wall_clock.rb
|
Timerizer.WallClock.hour
|
def hour(system = :twenty_four_hour)
hour = self.to_duration.to_units(:hour, :minute, :second).fetch(:hour)
if system == :twelve_hour
if hour == 0
12
elsif hour > 12
hour - 12
else
hour
end
elsif (system == :twenty_four_hour)
hour
else
raise ArgumentError, "system should be :twelve_hour or :twenty_four_hour"
end
end
|
ruby
|
def hour(system = :twenty_four_hour)
hour = self.to_duration.to_units(:hour, :minute, :second).fetch(:hour)
if system == :twelve_hour
if hour == 0
12
elsif hour > 12
hour - 12
else
hour
end
elsif (system == :twenty_four_hour)
hour
else
raise ArgumentError, "system should be :twelve_hour or :twenty_four_hour"
end
end
|
[
"def",
"hour",
"(",
"system",
"=",
":twenty_four_hour",
")",
"hour",
"=",
"self",
".",
"to_duration",
".",
"to_units",
"(",
":hour",
",",
":minute",
",",
":second",
")",
".",
"fetch",
"(",
":hour",
")",
"if",
"system",
"==",
":twelve_hour",
"if",
"hour",
"==",
"0",
"12",
"elsif",
"hour",
">",
"12",
"hour",
"-",
"12",
"else",
"hour",
"end",
"elsif",
"(",
"system",
"==",
":twenty_four_hour",
")",
"hour",
"else",
"raise",
"ArgumentError",
",",
"\"system should be :twelve_hour or :twenty_four_hour\"",
"end",
"end"
] |
Get the hour of the WallClock.
@param [Symbol] system The houring system to use (either `:twelve_hour` or `:twenty_four_hour`; default `:twenty_four_hour`)
@return [Integer] The hour component of the WallClock
|
[
"Get",
"the",
"hour",
"of",
"the",
"WallClock",
"."
] |
3d9949ad95d167e40a7b9b1f8b9d0817cdace4c8
|
https://github.com/kylewlacy/timerizer/blob/3d9949ad95d167e40a7b9b1f8b9d0817cdace4c8/lib/timerizer/wall_clock.rb#L136-L151
|
17,593
|
kylewlacy/timerizer
|
lib/timerizer/duration.rb
|
Timerizer.Duration.after
|
def after(time)
time = time.to_time
prev_day = time.mday
prev_month = time.month
prev_year = time.year
units = self.to_units(:years, :months, :days, :seconds)
date_in_month = self.class.build_date(
prev_year + units[:years],
prev_month + units[:months],
prev_day
)
date = date_in_month + units[:days]
Time.new(
date.year,
date.month,
date.day,
time.hour,
time.min,
time.sec
) + units[:seconds]
end
|
ruby
|
def after(time)
time = time.to_time
prev_day = time.mday
prev_month = time.month
prev_year = time.year
units = self.to_units(:years, :months, :days, :seconds)
date_in_month = self.class.build_date(
prev_year + units[:years],
prev_month + units[:months],
prev_day
)
date = date_in_month + units[:days]
Time.new(
date.year,
date.month,
date.day,
time.hour,
time.min,
time.sec
) + units[:seconds]
end
|
[
"def",
"after",
"(",
"time",
")",
"time",
"=",
"time",
".",
"to_time",
"prev_day",
"=",
"time",
".",
"mday",
"prev_month",
"=",
"time",
".",
"month",
"prev_year",
"=",
"time",
".",
"year",
"units",
"=",
"self",
".",
"to_units",
"(",
":years",
",",
":months",
",",
":days",
",",
":seconds",
")",
"date_in_month",
"=",
"self",
".",
"class",
".",
"build_date",
"(",
"prev_year",
"+",
"units",
"[",
":years",
"]",
",",
"prev_month",
"+",
"units",
"[",
":months",
"]",
",",
"prev_day",
")",
"date",
"=",
"date_in_month",
"+",
"units",
"[",
":days",
"]",
"Time",
".",
"new",
"(",
"date",
".",
"year",
",",
"date",
".",
"month",
",",
"date",
".",
"day",
",",
"time",
".",
"hour",
",",
"time",
".",
"min",
",",
"time",
".",
"sec",
")",
"+",
"units",
"[",
":seconds",
"]",
"end"
] |
Returns the time `self` later than the given time.
@param [Time] time The initial time.
@return [Time] The time after this {Duration} has elapsed past the
given time.
@example 5 minutes after January 1st, 2000 at noon
5.minutes.after(Time.new(2000, 1, 1, 12, 00, 00))
# => 2000-01-01 12:05:00 -0800
@see #ago
@see #before
@see #from_now
|
[
"Returns",
"the",
"time",
"self",
"later",
"than",
"the",
"given",
"time",
"."
] |
3d9949ad95d167e40a7b9b1f8b9d0817cdace4c8
|
https://github.com/kylewlacy/timerizer/blob/3d9949ad95d167e40a7b9b1f8b9d0817cdace4c8/lib/timerizer/duration.rb#L234-L258
|
17,594
|
kylewlacy/timerizer
|
lib/timerizer/duration.rb
|
Timerizer.Duration.to_unit
|
def to_unit(unit)
unit_details = self.class.resolve_unit(unit)
if unit_details.has_key?(:seconds)
seconds = self.normalize.get(:seconds)
self.class.div(seconds, unit_details.fetch(:seconds))
elsif unit_details.has_key?(:months)
months = self.denormalize.get(:months)
self.class.div(months, unit_details.fetch(:months))
else
raise "Unit should have key :seconds or :months"
end
end
|
ruby
|
def to_unit(unit)
unit_details = self.class.resolve_unit(unit)
if unit_details.has_key?(:seconds)
seconds = self.normalize.get(:seconds)
self.class.div(seconds, unit_details.fetch(:seconds))
elsif unit_details.has_key?(:months)
months = self.denormalize.get(:months)
self.class.div(months, unit_details.fetch(:months))
else
raise "Unit should have key :seconds or :months"
end
end
|
[
"def",
"to_unit",
"(",
"unit",
")",
"unit_details",
"=",
"self",
".",
"class",
".",
"resolve_unit",
"(",
"unit",
")",
"if",
"unit_details",
".",
"has_key?",
"(",
":seconds",
")",
"seconds",
"=",
"self",
".",
"normalize",
".",
"get",
"(",
":seconds",
")",
"self",
".",
"class",
".",
"div",
"(",
"seconds",
",",
"unit_details",
".",
"fetch",
"(",
":seconds",
")",
")",
"elsif",
"unit_details",
".",
"has_key?",
"(",
":months",
")",
"months",
"=",
"self",
".",
"denormalize",
".",
"get",
"(",
":months",
")",
"self",
".",
"class",
".",
"div",
"(",
"months",
",",
"unit_details",
".",
"fetch",
"(",
":months",
")",
")",
"else",
"raise",
"\"Unit should have key :seconds or :months\"",
"end",
"end"
] |
Convert the duration to a given unit.
@param [Symbol] unit The unit to convert to. See {UNIT_ALIASES} for a list
of valid unit names.
@return [Integer] The quantity of the given unit present in `self`. Note
that, if `self` cannot be represented exactly by `unit`, then the result
will be truncated (rounded toward 0 instead of rounding down, unlike
normal Ruby integer division).
@raise ArgumentError if the given unit could not be resolved.
@example
1.hour.to_unit(:minutes)
# => 60
121.seconds.to_unit(:minutes)
# => 2
@note The duration is normalized or denormalized first, depending on the
unit requested. This means that, by default, the returned unit will
be an approximation if it cannot be represented exactly by the duration,
such as when converting a duration of months to seconds, or vice versa.
@see #to_units
|
[
"Convert",
"the",
"duration",
"to",
"a",
"given",
"unit",
"."
] |
3d9949ad95d167e40a7b9b1f8b9d0817cdace4c8
|
https://github.com/kylewlacy/timerizer/blob/3d9949ad95d167e40a7b9b1f8b9d0817cdace4c8/lib/timerizer/duration.rb#L293-L305
|
17,595
|
kylewlacy/timerizer
|
lib/timerizer/duration.rb
|
Timerizer.Duration.-
|
def -(other)
case other
when 0
self
when Duration
Duration.new(
seconds: @seconds - other.get(:seconds),
months: @months - other.get(:months)
)
else
raise ArgumentError, "Cannot subtract #{other.inspect} from Duration #{self}"
end
end
|
ruby
|
def -(other)
case other
when 0
self
when Duration
Duration.new(
seconds: @seconds - other.get(:seconds),
months: @months - other.get(:months)
)
else
raise ArgumentError, "Cannot subtract #{other.inspect} from Duration #{self}"
end
end
|
[
"def",
"-",
"(",
"other",
")",
"case",
"other",
"when",
"0",
"self",
"when",
"Duration",
"Duration",
".",
"new",
"(",
"seconds",
":",
"@seconds",
"-",
"other",
".",
"get",
"(",
":seconds",
")",
",",
"months",
":",
"@months",
"-",
"other",
".",
"get",
"(",
":months",
")",
")",
"else",
"raise",
"ArgumentError",
",",
"\"Cannot subtract #{other.inspect} from Duration #{self}\"",
"end",
"end"
] |
Subtract two durations.
@param [Duration] other The duration to subtract.
@return [Duration] The resulting duration with each component subtracted
from the input duration.
@example
1.day - 1.hour == 23.hours
|
[
"Subtract",
"two",
"durations",
"."
] |
3d9949ad95d167e40a7b9b1f8b9d0817cdace4c8
|
https://github.com/kylewlacy/timerizer/blob/3d9949ad95d167e40a7b9b1f8b9d0817cdace4c8/lib/timerizer/duration.rb#L504-L516
|
17,596
|
kylewlacy/timerizer
|
lib/timerizer/duration.rb
|
Timerizer.Duration.*
|
def *(other)
case other
when Integer
Duration.new(
seconds: @seconds * other,
months: @months * other
)
else
raise ArgumentError, "Cannot multiply Duration #{self} by #{other.inspect}"
end
end
|
ruby
|
def *(other)
case other
when Integer
Duration.new(
seconds: @seconds * other,
months: @months * other
)
else
raise ArgumentError, "Cannot multiply Duration #{self} by #{other.inspect}"
end
end
|
[
"def",
"*",
"(",
"other",
")",
"case",
"other",
"when",
"Integer",
"Duration",
".",
"new",
"(",
"seconds",
":",
"@seconds",
"*",
"other",
",",
"months",
":",
"@months",
"*",
"other",
")",
"else",
"raise",
"ArgumentError",
",",
"\"Cannot multiply Duration #{self} by #{other.inspect}\"",
"end",
"end"
] |
Multiply a duration by a scalar.
@param [Integer] other The scalar to multiply by.
@return [Duration] The resulting duration with each component multiplied
by the scalar.
@example
1.day * 7 == 1.week
|
[
"Multiply",
"a",
"duration",
"by",
"a",
"scalar",
"."
] |
3d9949ad95d167e40a7b9b1f8b9d0817cdace4c8
|
https://github.com/kylewlacy/timerizer/blob/3d9949ad95d167e40a7b9b1f8b9d0817cdace4c8/lib/timerizer/duration.rb#L527-L537
|
17,597
|
kylewlacy/timerizer
|
lib/timerizer/duration.rb
|
Timerizer.Duration.to_s
|
def to_s(format = :long, options = nil)
format =
case format
when Symbol
FORMATS.fetch(format)
when Hash
FORMATS.fetch(:long).merge(format)
else
raise ArgumentError, "Expected #{format.inspect} to be a Symbol or Hash"
end
format = format.merge(options || {})
count =
if format[:count].nil? || format[:count] == :all
UNITS.count
else
format[:count]
end
format_units = format.fetch(:units)
units = self.to_units(*format_units.keys).select {|unit, n| n > 0}
if units.empty?
units = {seconds: 0}
end
separator = format[:separator] || ' '
delimiter = format[:delimiter] || ', '
units.take(count).map do |unit, n|
unit_label = format_units.fetch(unit)
singular, plural =
case unit_label
when Array
unit_label
else
[unit_label, unit_label]
end
unit_name =
if n == 1
singular
else
plural || singular
end
[n, unit_name].join(separator)
end.join(format[:delimiter] || ', ')
end
|
ruby
|
def to_s(format = :long, options = nil)
format =
case format
when Symbol
FORMATS.fetch(format)
when Hash
FORMATS.fetch(:long).merge(format)
else
raise ArgumentError, "Expected #{format.inspect} to be a Symbol or Hash"
end
format = format.merge(options || {})
count =
if format[:count].nil? || format[:count] == :all
UNITS.count
else
format[:count]
end
format_units = format.fetch(:units)
units = self.to_units(*format_units.keys).select {|unit, n| n > 0}
if units.empty?
units = {seconds: 0}
end
separator = format[:separator] || ' '
delimiter = format[:delimiter] || ', '
units.take(count).map do |unit, n|
unit_label = format_units.fetch(unit)
singular, plural =
case unit_label
when Array
unit_label
else
[unit_label, unit_label]
end
unit_name =
if n == 1
singular
else
plural || singular
end
[n, unit_name].join(separator)
end.join(format[:delimiter] || ', ')
end
|
[
"def",
"to_s",
"(",
"format",
"=",
":long",
",",
"options",
"=",
"nil",
")",
"format",
"=",
"case",
"format",
"when",
"Symbol",
"FORMATS",
".",
"fetch",
"(",
"format",
")",
"when",
"Hash",
"FORMATS",
".",
"fetch",
"(",
":long",
")",
".",
"merge",
"(",
"format",
")",
"else",
"raise",
"ArgumentError",
",",
"\"Expected #{format.inspect} to be a Symbol or Hash\"",
"end",
"format",
"=",
"format",
".",
"merge",
"(",
"options",
"||",
"{",
"}",
")",
"count",
"=",
"if",
"format",
"[",
":count",
"]",
".",
"nil?",
"||",
"format",
"[",
":count",
"]",
"==",
":all",
"UNITS",
".",
"count",
"else",
"format",
"[",
":count",
"]",
"end",
"format_units",
"=",
"format",
".",
"fetch",
"(",
":units",
")",
"units",
"=",
"self",
".",
"to_units",
"(",
"format_units",
".",
"keys",
")",
".",
"select",
"{",
"|",
"unit",
",",
"n",
"|",
"n",
">",
"0",
"}",
"if",
"units",
".",
"empty?",
"units",
"=",
"{",
"seconds",
":",
"0",
"}",
"end",
"separator",
"=",
"format",
"[",
":separator",
"]",
"||",
"' '",
"delimiter",
"=",
"format",
"[",
":delimiter",
"]",
"||",
"', '",
"units",
".",
"take",
"(",
"count",
")",
".",
"map",
"do",
"|",
"unit",
",",
"n",
"|",
"unit_label",
"=",
"format_units",
".",
"fetch",
"(",
"unit",
")",
"singular",
",",
"plural",
"=",
"case",
"unit_label",
"when",
"Array",
"unit_label",
"else",
"[",
"unit_label",
",",
"unit_label",
"]",
"end",
"unit_name",
"=",
"if",
"n",
"==",
"1",
"singular",
"else",
"plural",
"||",
"singular",
"end",
"[",
"n",
",",
"unit_name",
"]",
".",
"join",
"(",
"separator",
")",
"end",
".",
"join",
"(",
"format",
"[",
":delimiter",
"]",
"||",
"', '",
")",
"end"
] |
Convert a duration to a human-readable string.
@param [Symbol, Hash] format The format type to format the duration with.
`format` can either be a key from the {FORMATS} hash or a hash with
the same shape as `options`.
@param [Hash, nil] options Additional options to use to override default
format options.
@option options [Hash<Symbol, String>] :units The full list of unit names
to use. Keys are unit names (see {UNIT_ALIASES} for a full list) and
values are strings to use when converting that unit to a string. Values
can also be an array, where the first item of the array will be used
for singular unit names and the second item will be used for plural
unit names. Note that this option will completely override the input
formats' list of names, so all units that should be used must be
specified!
@option options [String] :separator The separator to use between a unit
quantity and the unit's name. For example, the string `"1 second"` uses
a separator of `" "`.
@option options [String] :delimiter The delimiter to use between separate
units. For example, the string `"1 minute, 1 second"` uses a separator
of `", "`
@option options [Integer, nil, :all] :count The number of significant
units to use in the string, or `nil` / `:all` to use all units.
For example, if the given duration is `1.day 1.week 1.month`, and
`options[:count]` is 2, then the resulting string will only include
the month and the week components of the string.
@return [String] The duration formatted as a string.
|
[
"Convert",
"a",
"duration",
"to",
"a",
"human",
"-",
"readable",
"string",
"."
] |
3d9949ad95d167e40a7b9b1f8b9d0817cdace4c8
|
https://github.com/kylewlacy/timerizer/blob/3d9949ad95d167e40a7b9b1f8b9d0817cdace4c8/lib/timerizer/duration.rb#L606-L654
|
17,598
|
kylewlacy/timerizer
|
lib/timerizer/duration.rb
|
Timerizer.Duration.to_rounded_s
|
def to_rounded_s(format = :min_long, options = nil)
format =
case format
when Symbol
FORMATS.fetch(format)
when Hash
FORMATS.fetch(:long).merge(format)
else
raise ArgumentError, "Expected #{format.inspect} to be a Symbol or Hash"
end
format = format.merge(Hash(options))
places = format[:count]
begin
places = Integer(places) # raise if nil or `:all` supplied as value
rescue TypeError
places = 2
end
q = RoundedTime.call(self, places)
q.to_s(format, options)
end
|
ruby
|
def to_rounded_s(format = :min_long, options = nil)
format =
case format
when Symbol
FORMATS.fetch(format)
when Hash
FORMATS.fetch(:long).merge(format)
else
raise ArgumentError, "Expected #{format.inspect} to be a Symbol or Hash"
end
format = format.merge(Hash(options))
places = format[:count]
begin
places = Integer(places) # raise if nil or `:all` supplied as value
rescue TypeError
places = 2
end
q = RoundedTime.call(self, places)
q.to_s(format, options)
end
|
[
"def",
"to_rounded_s",
"(",
"format",
"=",
":min_long",
",",
"options",
"=",
"nil",
")",
"format",
"=",
"case",
"format",
"when",
"Symbol",
"FORMATS",
".",
"fetch",
"(",
"format",
")",
"when",
"Hash",
"FORMATS",
".",
"fetch",
"(",
":long",
")",
".",
"merge",
"(",
"format",
")",
"else",
"raise",
"ArgumentError",
",",
"\"Expected #{format.inspect} to be a Symbol or Hash\"",
"end",
"format",
"=",
"format",
".",
"merge",
"(",
"Hash",
"(",
"options",
")",
")",
"places",
"=",
"format",
"[",
":count",
"]",
"begin",
"places",
"=",
"Integer",
"(",
"places",
")",
"# raise if nil or `:all` supplied as value",
"rescue",
"TypeError",
"places",
"=",
"2",
"end",
"q",
"=",
"RoundedTime",
".",
"call",
"(",
"self",
",",
"places",
")",
"q",
".",
"to_s",
"(",
"format",
",",
"options",
")",
"end"
] |
Convert a Duration to a human-readable string using a rounded value.
By 'rounded', we mean that the resulting value is rounded up if the input
includes a value of more than half of one of the least-significant unit to
be returned. For example, `(17.hours 43.minutes 31.seconds)`, when rounded
to two units (hours and minutes), would return "17 hours, 44 minutes". By
contrast, `#to_s`, with a `:count` option of 2, would return a value of
"17 hours, 43 minutes": truncating, rather than rounding.
Note that this method overloads the meaning of the `:count` option value
as documented below. If the passed-in option value is numeric, it will be
honored, and rounding will take place to that number of units. If the
value is either `:all` or the default `nil`, then _rounding_ will be done
to two units, and the rounded value will be passed on to `#to_s` with the
options specified (which will result in a maximum of two time units being
output).
@param [Symbol, Hash] format The format type to format the duration with.
`format` can either be a key from the {FORMATS} hash or a hash with
the same shape as `options`. The default is `:min_long`, which strongly
resembles `:long` with the omission of `:weeks` units and a default
`:count` of 2.
@param [Hash, nil] options Additional options to use to override default
format options.
@option options [Hash<Symbol, String>] :units The full list of unit names
to use. Keys are unit names (see {UNIT_ALIASES} for a full list) and
values are strings to use when converting that unit to a string. Values
can also be an array, where the first item of the array will be used
for singular unit names and the second item will be used for plural
unit names. Note that this option will completely override the input
formats' list of names, so all units that should be used must be
specified!
@option options [String] :separator The separator to use between a unit
quantity and the unit's name. For example, the string `"1 second"` uses
a separator of `" "`.
@option options [String] :delimiter The delimiter to use between separate
units. For example, the string `"1 minute, 1 second"` uses a separator
of `", "`
@option options [Integer, nil, :all] :count The number of significant
units to use in the string, or `nil` / `:all` to use all units.
For example, if the given duration is `1.day 1.week 1.month`, and
`options[:count]` is 2, then the resulting string will only include
the month and the week components of the string.
@return [String] The rounded duration formatted as a string.
|
[
"Convert",
"a",
"Duration",
"to",
"a",
"human",
"-",
"readable",
"string",
"using",
"a",
"rounded",
"value",
"."
] |
3d9949ad95d167e40a7b9b1f8b9d0817cdace4c8
|
https://github.com/kylewlacy/timerizer/blob/3d9949ad95d167e40a7b9b1f8b9d0817cdace4c8/lib/timerizer/duration.rb#L702-L722
|
17,599
|
github/elastomer-client
|
lib/elastomer/client/rest_api_spec/api_spec.rb
|
Elastomer::Client::RestApiSpec.ApiSpec.select_params
|
def select_params(api:, from:)
rest_api = get(api)
return from if rest_api.nil?
rest_api.select_params(from: from)
end
|
ruby
|
def select_params(api:, from:)
rest_api = get(api)
return from if rest_api.nil?
rest_api.select_params(from: from)
end
|
[
"def",
"select_params",
"(",
"api",
":",
",",
"from",
":",
")",
"rest_api",
"=",
"get",
"(",
"api",
")",
"return",
"from",
"if",
"rest_api",
".",
"nil?",
"rest_api",
".",
"select_params",
"(",
"from",
":",
"from",
")",
"end"
] |
Given an API descriptor name and a set of request parameters, select those
params that are accepted by the API endpoint.
api - the api descriptor name as a String
from - the Hash containing the request params
Returns a new Hash containing the valid params for the api
|
[
"Given",
"an",
"API",
"descriptor",
"name",
"and",
"a",
"set",
"of",
"request",
"parameters",
"select",
"those",
"params",
"that",
"are",
"accepted",
"by",
"the",
"API",
"endpoint",
"."
] |
b02aa42f23df9776443449d44c176f1dcea5e08d
|
https://github.com/github/elastomer-client/blob/b02aa42f23df9776443449d44c176f1dcea5e08d/lib/elastomer/client/rest_api_spec/api_spec.rb#L26-L30
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.