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
|
|---|---|---|---|---|---|---|---|---|---|---|---|
11,300
|
TrestleAdmin/trestle
|
app/helpers/trestle/table_helper.rb
|
Trestle.TableHelper.table
|
def table(name=nil, options={}, &block)
if block_given?
if name.is_a?(Hash)
options = name
else
collection = name
end
table = Table::Builder.build(options, &block)
elsif name.is_a?(Trestle::Table)
table = name
else
table = admin.tables.fetch(name) { raise ArgumentError, "Unable to find table named #{name.inspect}" }
end
collection ||= options[:collection] || table.options[:collection]
collection = collection.call if collection.respond_to?(:call)
render "trestle/table/table", table: table, collection: collection
end
|
ruby
|
def table(name=nil, options={}, &block)
if block_given?
if name.is_a?(Hash)
options = name
else
collection = name
end
table = Table::Builder.build(options, &block)
elsif name.is_a?(Trestle::Table)
table = name
else
table = admin.tables.fetch(name) { raise ArgumentError, "Unable to find table named #{name.inspect}" }
end
collection ||= options[:collection] || table.options[:collection]
collection = collection.call if collection.respond_to?(:call)
render "trestle/table/table", table: table, collection: collection
end
|
[
"def",
"table",
"(",
"name",
"=",
"nil",
",",
"options",
"=",
"{",
"}",
",",
"&",
"block",
")",
"if",
"block_given?",
"if",
"name",
".",
"is_a?",
"(",
"Hash",
")",
"options",
"=",
"name",
"else",
"collection",
"=",
"name",
"end",
"table",
"=",
"Table",
"::",
"Builder",
".",
"build",
"(",
"options",
",",
"block",
")",
"elsif",
"name",
".",
"is_a?",
"(",
"Trestle",
"::",
"Table",
")",
"table",
"=",
"name",
"else",
"table",
"=",
"admin",
".",
"tables",
".",
"fetch",
"(",
"name",
")",
"{",
"raise",
"ArgumentError",
",",
"\"Unable to find table named #{name.inspect}\"",
"}",
"end",
"collection",
"||=",
"options",
"[",
":collection",
"]",
"||",
"table",
".",
"options",
"[",
":collection",
"]",
"collection",
"=",
"collection",
".",
"call",
"if",
"collection",
".",
"respond_to?",
"(",
":call",
")",
"render",
"\"trestle/table/table\"",
",",
"table",
":",
"table",
",",
"collection",
":",
"collection",
"end"
] |
Renders an existing named table or builds and renders a custom table if a block is provided.
name - The (optional) name of the table to render (as a Symbol), or the actual Trestle::Table instance itself.
options - Hash of options that will be passed to the table builder (default: {}):
:collection - The collection that should be rendered within the table. It should be an
Array-like object, but will most likely be an ActiveRecord scope. It can
also be a callable object (i.e. a Proc) in which case the result of calling
the block will be used as the collection.
See Trestle::Table::Builder for additional options.
block - An optional block that is passed to Trestle::Table::Builder to define a custom table.
One of either the name or block must be provided, but not both.
Examples
<%= table collection: -> { Account.all }, admin: :accounts do %>
<% column(:name) %>
<% column(:balance) { |account| account.balance.format } %>
<% column(:created_at, align: :center)
<% end %>
<%= table :accounts %>
Returns the HTML representation of the table as a HTML-safe String.
|
[
"Renders",
"an",
"existing",
"named",
"table",
"or",
"builds",
"and",
"renders",
"a",
"custom",
"table",
"if",
"a",
"block",
"is",
"provided",
"."
] |
fd5b8aeb5077e13d539cb5ddd99db1dd279f19ca
|
https://github.com/TrestleAdmin/trestle/blob/fd5b8aeb5077e13d539cb5ddd99db1dd279f19ca/app/helpers/trestle/table_helper.rb#L26-L45
|
11,301
|
TrestleAdmin/trestle
|
app/helpers/trestle/pagination_helper.rb
|
Trestle.PaginationHelper.page_entries_info
|
def page_entries_info(collection, options = {})
entry_name = options[:entry_name] || "entry"
entry_name = entry_name.pluralize unless collection.total_count == 1
if collection.total_pages < 2
t('trestle.helpers.page_entries_info.one_page.display_entries', entry_name: entry_name, count: collection.total_count, default: "Displaying <strong>all %{count}</strong> %{entry_name}")
else
first = number_with_delimiter(collection.offset_value + 1)
last = number_with_delimiter((sum = collection.offset_value + collection.limit_value) > collection.total_count ? collection.total_count : sum)
total = number_with_delimiter(collection.total_count)
t('trestle.helpers.page_entries_info.more_pages.display_entries', entry_name: entry_name, first: first, last: last, total: total, default: "Displaying %{entry_name} <strong>%{first} - %{last}</strong> of <b>%{total}</b>")
end.html_safe
end
|
ruby
|
def page_entries_info(collection, options = {})
entry_name = options[:entry_name] || "entry"
entry_name = entry_name.pluralize unless collection.total_count == 1
if collection.total_pages < 2
t('trestle.helpers.page_entries_info.one_page.display_entries', entry_name: entry_name, count: collection.total_count, default: "Displaying <strong>all %{count}</strong> %{entry_name}")
else
first = number_with_delimiter(collection.offset_value + 1)
last = number_with_delimiter((sum = collection.offset_value + collection.limit_value) > collection.total_count ? collection.total_count : sum)
total = number_with_delimiter(collection.total_count)
t('trestle.helpers.page_entries_info.more_pages.display_entries', entry_name: entry_name, first: first, last: last, total: total, default: "Displaying %{entry_name} <strong>%{first} - %{last}</strong> of <b>%{total}</b>")
end.html_safe
end
|
[
"def",
"page_entries_info",
"(",
"collection",
",",
"options",
"=",
"{",
"}",
")",
"entry_name",
"=",
"options",
"[",
":entry_name",
"]",
"||",
"\"entry\"",
"entry_name",
"=",
"entry_name",
".",
"pluralize",
"unless",
"collection",
".",
"total_count",
"==",
"1",
"if",
"collection",
".",
"total_pages",
"<",
"2",
"t",
"(",
"'trestle.helpers.page_entries_info.one_page.display_entries'",
",",
"entry_name",
":",
"entry_name",
",",
"count",
":",
"collection",
".",
"total_count",
",",
"default",
":",
"\"Displaying <strong>all %{count}</strong> %{entry_name}\"",
")",
"else",
"first",
"=",
"number_with_delimiter",
"(",
"collection",
".",
"offset_value",
"+",
"1",
")",
"last",
"=",
"number_with_delimiter",
"(",
"(",
"sum",
"=",
"collection",
".",
"offset_value",
"+",
"collection",
".",
"limit_value",
")",
">",
"collection",
".",
"total_count",
"?",
"collection",
".",
"total_count",
":",
"sum",
")",
"total",
"=",
"number_with_delimiter",
"(",
"collection",
".",
"total_count",
")",
"t",
"(",
"'trestle.helpers.page_entries_info.more_pages.display_entries'",
",",
"entry_name",
":",
"entry_name",
",",
"first",
":",
"first",
",",
"last",
":",
"last",
",",
"total",
":",
"total",
",",
"default",
":",
"\"Displaying %{entry_name} <strong>%{first} - %{last}</strong> of <b>%{total}</b>\"",
")",
"end",
".",
"html_safe",
"end"
] |
Custom version of Kaminari's page_entries_info helper to use a
Trestle-scoped I18n key and add a delimiter to the total count.
|
[
"Custom",
"version",
"of",
"Kaminari",
"s",
"page_entries_info",
"helper",
"to",
"use",
"a",
"Trestle",
"-",
"scoped",
"I18n",
"key",
"and",
"add",
"a",
"delimiter",
"to",
"the",
"total",
"count",
"."
] |
fd5b8aeb5077e13d539cb5ddd99db1dd279f19ca
|
https://github.com/TrestleAdmin/trestle/blob/fd5b8aeb5077e13d539cb5ddd99db1dd279f19ca/app/helpers/trestle/pagination_helper.rb#L5-L18
|
11,302
|
TrestleAdmin/trestle
|
lib/trestle/configuration.rb
|
Trestle.Configuration.hook
|
def hook(name, options={}, &block)
hooks[name.to_s] << Hook.new(name.to_s, options, &block)
end
|
ruby
|
def hook(name, options={}, &block)
hooks[name.to_s] << Hook.new(name.to_s, options, &block)
end
|
[
"def",
"hook",
"(",
"name",
",",
"options",
"=",
"{",
"}",
",",
"&",
"block",
")",
"hooks",
"[",
"name",
".",
"to_s",
"]",
"<<",
"Hook",
".",
"new",
"(",
"name",
".",
"to_s",
",",
"options",
",",
"block",
")",
"end"
] |
Register an extension hook
|
[
"Register",
"an",
"extension",
"hook"
] |
fd5b8aeb5077e13d539cb5ddd99db1dd279f19ca
|
https://github.com/TrestleAdmin/trestle/blob/fd5b8aeb5077e13d539cb5ddd99db1dd279f19ca/lib/trestle/configuration.rb#L90-L92
|
11,303
|
Shopify/shipit-engine
|
app/models/shipit/deploy.rb
|
Shipit.Deploy.trigger_rollback
|
def trigger_rollback(user = AnonymousUser.new, env: nil, force: false)
rollback = build_rollback(user, env: env, force: force)
rollback.save!
rollback.enqueue
lock_reason = "A rollback for #{rollback.since_commit.sha} has been triggered. " \
"Please make sure the reason for the rollback has been addressed before deploying again."
stack.update!(lock_reason: lock_reason, lock_author_id: user.id)
rollback
end
|
ruby
|
def trigger_rollback(user = AnonymousUser.new, env: nil, force: false)
rollback = build_rollback(user, env: env, force: force)
rollback.save!
rollback.enqueue
lock_reason = "A rollback for #{rollback.since_commit.sha} has been triggered. " \
"Please make sure the reason for the rollback has been addressed before deploying again."
stack.update!(lock_reason: lock_reason, lock_author_id: user.id)
rollback
end
|
[
"def",
"trigger_rollback",
"(",
"user",
"=",
"AnonymousUser",
".",
"new",
",",
"env",
":",
"nil",
",",
"force",
":",
"false",
")",
"rollback",
"=",
"build_rollback",
"(",
"user",
",",
"env",
":",
"env",
",",
"force",
":",
"force",
")",
"rollback",
".",
"save!",
"rollback",
".",
"enqueue",
"lock_reason",
"=",
"\"A rollback for #{rollback.since_commit.sha} has been triggered. \"",
"\"Please make sure the reason for the rollback has been addressed before deploying again.\"",
"stack",
".",
"update!",
"(",
"lock_reason",
":",
"lock_reason",
",",
"lock_author_id",
":",
"user",
".",
"id",
")",
"rollback",
"end"
] |
Rolls the stack back to this deploy
|
[
"Rolls",
"the",
"stack",
"back",
"to",
"this",
"deploy"
] |
f6b93d8a242962016e0f82e99c2eb223bdc75003
|
https://github.com/Shopify/shipit-engine/blob/f6b93d8a242962016e0f82e99c2eb223bdc75003/app/models/shipit/deploy.rb#L76-L86
|
11,304
|
realm/jazzy
|
lib/jazzy/podspec_documenter.rb
|
Jazzy.PodspecDocumenter.compiler_swift_version
|
def compiler_swift_version(user_version)
return LATEST_SWIFT_VERSION unless user_version
LONG_SWIFT_VERSIONS.select do |version|
user_version.start_with?(version)
end.last || "#{user_version[0]}.0"
end
|
ruby
|
def compiler_swift_version(user_version)
return LATEST_SWIFT_VERSION unless user_version
LONG_SWIFT_VERSIONS.select do |version|
user_version.start_with?(version)
end.last || "#{user_version[0]}.0"
end
|
[
"def",
"compiler_swift_version",
"(",
"user_version",
")",
"return",
"LATEST_SWIFT_VERSION",
"unless",
"user_version",
"LONG_SWIFT_VERSIONS",
".",
"select",
"do",
"|",
"version",
"|",
"user_version",
".",
"start_with?",
"(",
"version",
")",
"end",
".",
"last",
"||",
"\"#{user_version[0]}.0\"",
"end"
] |
Go from a full Swift version like 4.2.1 to
something valid for SWIFT_VERSION.
|
[
"Go",
"from",
"a",
"full",
"Swift",
"version",
"like",
"4",
".",
"2",
".",
"1",
"to",
"something",
"valid",
"for",
"SWIFT_VERSION",
"."
] |
e8744dbdb78814b237e8d57a82d40953560e9143
|
https://github.com/realm/jazzy/blob/e8744dbdb78814b237e8d57a82d40953560e9143/lib/jazzy/podspec_documenter.rb#L109-L115
|
11,305
|
cerebris/jsonapi-resources
|
lib/jsonapi/resource_id_tree.rb
|
JSONAPI.ResourceIdTree.fetch_related_resource_id_tree
|
def fetch_related_resource_id_tree(relationship)
relationship_name = relationship.name.to_sym
@related_resource_id_trees[relationship_name] ||= RelatedResourceIdTree.new(relationship, self)
end
|
ruby
|
def fetch_related_resource_id_tree(relationship)
relationship_name = relationship.name.to_sym
@related_resource_id_trees[relationship_name] ||= RelatedResourceIdTree.new(relationship, self)
end
|
[
"def",
"fetch_related_resource_id_tree",
"(",
"relationship",
")",
"relationship_name",
"=",
"relationship",
".",
"name",
".",
"to_sym",
"@related_resource_id_trees",
"[",
"relationship_name",
"]",
"||=",
"RelatedResourceIdTree",
".",
"new",
"(",
"relationship",
",",
"self",
")",
"end"
] |
Gets the related Resource Id Tree for a relationship, and creates it first if it does not exist
@param relationship [JSONAPI::Relationship]
@return [JSONAPI::RelatedResourceIdTree] the new or existing resource id tree for the requested relationship
|
[
"Gets",
"the",
"related",
"Resource",
"Id",
"Tree",
"for",
"a",
"relationship",
"and",
"creates",
"it",
"first",
"if",
"it",
"does",
"not",
"exist"
] |
1ac6bba777e364eaa36706f888792b99b63d8d1a
|
https://github.com/cerebris/jsonapi-resources/blob/1ac6bba777e364eaa36706f888792b99b63d8d1a/lib/jsonapi/resource_id_tree.rb#L15-L18
|
11,306
|
cerebris/jsonapi-resources
|
lib/jsonapi/resource_id_tree.rb
|
JSONAPI.PrimaryResourceIdTree.add_resource_fragment
|
def add_resource_fragment(fragment, include_related)
fragment.primary = true
init_included_relationships(fragment, include_related)
@fragments[fragment.identity] = fragment
end
|
ruby
|
def add_resource_fragment(fragment, include_related)
fragment.primary = true
init_included_relationships(fragment, include_related)
@fragments[fragment.identity] = fragment
end
|
[
"def",
"add_resource_fragment",
"(",
"fragment",
",",
"include_related",
")",
"fragment",
".",
"primary",
"=",
"true",
"init_included_relationships",
"(",
"fragment",
",",
"include_related",
")",
"@fragments",
"[",
"fragment",
".",
"identity",
"]",
"=",
"fragment",
"end"
] |
Adds a Resource Fragment to the Resources hash
@param fragment [JSONAPI::ResourceFragment]
@param include_related [Hash]
@return [null]
|
[
"Adds",
"a",
"Resource",
"Fragment",
"to",
"the",
"Resources",
"hash"
] |
1ac6bba777e364eaa36706f888792b99b63d8d1a
|
https://github.com/cerebris/jsonapi-resources/blob/1ac6bba777e364eaa36706f888792b99b63d8d1a/lib/jsonapi/resource_id_tree.rb#L55-L61
|
11,307
|
cerebris/jsonapi-resources
|
lib/jsonapi/resource_id_tree.rb
|
JSONAPI.RelatedResourceIdTree.add_resource_fragment
|
def add_resource_fragment(fragment, include_related)
init_included_relationships(fragment, include_related)
fragment.related_from.each do |rid|
@source_resource_id_tree.fragments[rid].add_related_identity(parent_relationship.name, fragment.identity)
end
@fragments[fragment.identity] = fragment
end
|
ruby
|
def add_resource_fragment(fragment, include_related)
init_included_relationships(fragment, include_related)
fragment.related_from.each do |rid|
@source_resource_id_tree.fragments[rid].add_related_identity(parent_relationship.name, fragment.identity)
end
@fragments[fragment.identity] = fragment
end
|
[
"def",
"add_resource_fragment",
"(",
"fragment",
",",
"include_related",
")",
"init_included_relationships",
"(",
"fragment",
",",
"include_related",
")",
"fragment",
".",
"related_from",
".",
"each",
"do",
"|",
"rid",
"|",
"@source_resource_id_tree",
".",
"fragments",
"[",
"rid",
"]",
".",
"add_related_identity",
"(",
"parent_relationship",
".",
"name",
",",
"fragment",
".",
"identity",
")",
"end",
"@fragments",
"[",
"fragment",
".",
"identity",
"]",
"=",
"fragment",
"end"
] |
Adds a Resource Fragment to the fragments hash
@param fragment [JSONAPI::ResourceFragment]
@param include_related [Hash]
@return [null]
|
[
"Adds",
"a",
"Resource",
"Fragment",
"to",
"the",
"fragments",
"hash"
] |
1ac6bba777e364eaa36706f888792b99b63d8d1a
|
https://github.com/cerebris/jsonapi-resources/blob/1ac6bba777e364eaa36706f888792b99b63d8d1a/lib/jsonapi/resource_id_tree.rb#L102-L110
|
11,308
|
googleapis/google-cloud-ruby
|
google-cloud-error_reporting/lib/google-cloud-error_reporting.rb
|
Google.Cloud.error_reporting
|
def error_reporting scope: nil, timeout: nil, client_config: nil
Google::Cloud.error_reporting @project, @keyfile,
scope: scope,
timeout: (timeout || @timeout),
client_config: client_config
end
|
ruby
|
def error_reporting scope: nil, timeout: nil, client_config: nil
Google::Cloud.error_reporting @project, @keyfile,
scope: scope,
timeout: (timeout || @timeout),
client_config: client_config
end
|
[
"def",
"error_reporting",
"scope",
":",
"nil",
",",
"timeout",
":",
"nil",
",",
"client_config",
":",
"nil",
"Google",
"::",
"Cloud",
".",
"error_reporting",
"@project",
",",
"@keyfile",
",",
"scope",
":",
"scope",
",",
"timeout",
":",
"(",
"timeout",
"||",
"@timeout",
")",
",",
"client_config",
":",
"client_config",
"end"
] |
Create a new object for connecting to the Stackdriver Error Reporting
service. Each call creates a new connection.
For more information on connecting to Google Cloud see the
{file:AUTHENTICATION.md Authentication Guide}.
@param [String, Array<String>] scope The OAuth 2.0 scopes controlling the
set of resources and operations that the connection can access. See
[Using OAuth 2.0 to Access Google
APIs](https://developers.google.com/identity/protocols/OAuth2).
The default scope is:
* `https://www.googleapis.com/auth/cloud-platform`
@param [Integer] timeout Default timeout to use in requests. Optional.
@param [Hash] client_config A hash of values to override the default
behavior of the API client. Optional.
@return [Google::Cloud::ErrorReporting::Project]
@example
require "google/cloud/error_reporting"
gcloud = Google::Cloud.new "GCP_Project_ID",
"/path/to/gcp/secretkey.json"
error_reporting = gcloud.error_reporting
error_event = error_reporting.error_event "Error with Backtrace",
event_time: Time.now,
service_name: "my_app_name",
service_version: "v8"
error_reporting.report error_event
|
[
"Create",
"a",
"new",
"object",
"for",
"connecting",
"to",
"the",
"Stackdriver",
"Error",
"Reporting",
"service",
".",
"Each",
"call",
"creates",
"a",
"new",
"connection",
"."
] |
846c1a57250ac860ef4de1b54853a480ab2ff702
|
https://github.com/googleapis/google-cloud-ruby/blob/846c1a57250ac860ef4de1b54853a480ab2ff702/google-cloud-error_reporting/lib/google-cloud-error_reporting.rb#L62-L67
|
11,309
|
googleapis/google-cloud-ruby
|
google-cloud-dns/lib/google-cloud-dns.rb
|
Google.Cloud.dns
|
def dns scope: nil, retries: nil, timeout: nil
Google::Cloud.dns @project, @keyfile, scope: scope,
retries: (retries || @retries),
timeout: (timeout || @timeout)
end
|
ruby
|
def dns scope: nil, retries: nil, timeout: nil
Google::Cloud.dns @project, @keyfile, scope: scope,
retries: (retries || @retries),
timeout: (timeout || @timeout)
end
|
[
"def",
"dns",
"scope",
":",
"nil",
",",
"retries",
":",
"nil",
",",
"timeout",
":",
"nil",
"Google",
"::",
"Cloud",
".",
"dns",
"@project",
",",
"@keyfile",
",",
"scope",
":",
"scope",
",",
"retries",
":",
"(",
"retries",
"||",
"@retries",
")",
",",
"timeout",
":",
"(",
"timeout",
"||",
"@timeout",
")",
"end"
] |
Creates a new object for connecting to the DNS service.
Each call creates a new connection.
For more information on connecting to Google Cloud see the
{file:AUTHENTICATION.md Authentication Guide}.
@param [String, Array<String>] scope The OAuth 2.0 scopes controlling the
set of resources and operations that the connection can access. See
[Using OAuth 2.0 to Access Google
APIs](https://developers.google.com/identity/protocols/OAuth2).
The default scope is:
* `https://www.googleapis.com/auth/ndev.clouddns.readwrite`
@param [Integer] retries Number of times to retry requests on server
error. The default value is `3`. Optional.
@param [Integer] timeout Default timeout to use in requests. Optional.
@return [Google::Cloud::Dns::Project]
@example
require "google/cloud"
gcloud = Google::Cloud.new
dns = gcloud.dns
zone = dns.zone "example-com"
zone.records.each do |record|
puts record.name
end
@example The default scope can be overridden with the `scope` option:
require "google/cloud"
gcloud = Google::Cloud.new
dns_readonly = "https://www.googleapis.com/auth/ndev.clouddns.readonly"
dns = gcloud.dns scope: dns_readonly
|
[
"Creates",
"a",
"new",
"object",
"for",
"connecting",
"to",
"the",
"DNS",
"service",
".",
"Each",
"call",
"creates",
"a",
"new",
"connection",
"."
] |
846c1a57250ac860ef4de1b54853a480ab2ff702
|
https://github.com/googleapis/google-cloud-ruby/blob/846c1a57250ac860ef4de1b54853a480ab2ff702/google-cloud-dns/lib/google-cloud-dns.rb#L66-L70
|
11,310
|
googleapis/google-cloud-ruby
|
google-cloud-spanner/lib/google-cloud-spanner.rb
|
Google.Cloud.spanner
|
def spanner scope: nil, timeout: nil, client_config: nil
Google::Cloud.spanner @project, @keyfile, scope: scope,
timeout: (timeout || @timeout),
client_config: client_config
end
|
ruby
|
def spanner scope: nil, timeout: nil, client_config: nil
Google::Cloud.spanner @project, @keyfile, scope: scope,
timeout: (timeout || @timeout),
client_config: client_config
end
|
[
"def",
"spanner",
"scope",
":",
"nil",
",",
"timeout",
":",
"nil",
",",
"client_config",
":",
"nil",
"Google",
"::",
"Cloud",
".",
"spanner",
"@project",
",",
"@keyfile",
",",
"scope",
":",
"scope",
",",
"timeout",
":",
"(",
"timeout",
"||",
"@timeout",
")",
",",
"client_config",
":",
"client_config",
"end"
] |
Creates a new object for connecting to the Spanner service.
Each call creates a new connection.
For more information on connecting to Google Cloud see the
{file:AUTHENTICATION.md Authentication Guide}.
@param [String, Array<String>] scope The OAuth 2.0 scopes controlling the
set of resources and operations that the connection can access. See
[Using OAuth 2.0 to Access Google
APIs](https://developers.google.com/identity/protocols/OAuth2).
The default scopes are:
* `https://www.googleapis.com/auth/spanner`
* `https://www.googleapis.com/auth/spanner.data`
@param [Integer] timeout Default timeout to use in requests. Optional.
@param [Hash] client_config A hash of values to override the default
behavior of the API client. Optional.
@return [Google::Cloud::Spanner::Project]
@example
require "google/cloud"
gcloud = Google::Cloud.new
spanner = gcloud.spanner
@example The default scope can be overridden with the `scope` option:
require "google/cloud"
gcloud = Google::Cloud.new
platform_scope = "https://www.googleapis.com/auth/cloud-platform"
spanner = gcloud.spanner scope: platform_scope
|
[
"Creates",
"a",
"new",
"object",
"for",
"connecting",
"to",
"the",
"Spanner",
"service",
".",
"Each",
"call",
"creates",
"a",
"new",
"connection",
"."
] |
846c1a57250ac860ef4de1b54853a480ab2ff702
|
https://github.com/googleapis/google-cloud-ruby/blob/846c1a57250ac860ef4de1b54853a480ab2ff702/google-cloud-spanner/lib/google-cloud-spanner.rb#L64-L68
|
11,311
|
googleapis/google-cloud-ruby
|
google-cloud-logging/lib/google-cloud-logging.rb
|
Google.Cloud.logging
|
def logging scope: nil, timeout: nil, client_config: nil
timeout ||= @timeout
Google::Cloud.logging @project, @keyfile, scope: scope,
timeout: timeout,
client_config: client_config
end
|
ruby
|
def logging scope: nil, timeout: nil, client_config: nil
timeout ||= @timeout
Google::Cloud.logging @project, @keyfile, scope: scope,
timeout: timeout,
client_config: client_config
end
|
[
"def",
"logging",
"scope",
":",
"nil",
",",
"timeout",
":",
"nil",
",",
"client_config",
":",
"nil",
"timeout",
"||=",
"@timeout",
"Google",
"::",
"Cloud",
".",
"logging",
"@project",
",",
"@keyfile",
",",
"scope",
":",
"scope",
",",
"timeout",
":",
"timeout",
",",
"client_config",
":",
"client_config",
"end"
] |
Creates a new object for connecting to the Stackdriver Logging service.
Each call creates a new connection.
For more information on connecting to Google Cloud see the
{file:AUTHENTICATION.md Authentication Guide}.
@param [String, Array<String>] scope The OAuth 2.0 scopes controlling the
set of resources and operations that the connection can access. See
[Using OAuth 2.0 to Access Google
APIs](https://developers.google.com/identity/protocols/OAuth2).
The default scope is:
* `https://www.googleapis.com/auth/logging.admin`
@param [Integer] timeout Default timeout to use in requests. Optional.
@param [Hash] client_config A hash of values to override the default
behavior of the API client. Optional.
@return [Google::Cloud::Logging::Project]
@example
require "google/cloud"
gcloud = Google::Cloud.new
logging = gcloud.logging
entries = logging.entries
entries.each do |e|
puts "[#{e.timestamp}] #{e.log_name} #{e.payload.inspect}"
end
@example The default scope can be overridden with the `scope` option:
require "google/cloud"
gcloud = Google::Cloud.new
platform_scope = "https://www.googleapis.com/auth/cloud-platform"
logging = gcloud.logging scope: platform_scope
|
[
"Creates",
"a",
"new",
"object",
"for",
"connecting",
"to",
"the",
"Stackdriver",
"Logging",
"service",
".",
"Each",
"call",
"creates",
"a",
"new",
"connection",
"."
] |
846c1a57250ac860ef4de1b54853a480ab2ff702
|
https://github.com/googleapis/google-cloud-ruby/blob/846c1a57250ac860ef4de1b54853a480ab2ff702/google-cloud-logging/lib/google-cloud-logging.rb#L69-L74
|
11,312
|
googleapis/google-cloud-ruby
|
google-cloud-bigquery/lib/google-cloud-bigquery.rb
|
Google.Cloud.bigquery
|
def bigquery scope: nil, retries: nil, timeout: nil
Google::Cloud.bigquery @project, @keyfile, scope: scope,
retries: (retries || @retries),
timeout: (timeout || @timeout)
end
|
ruby
|
def bigquery scope: nil, retries: nil, timeout: nil
Google::Cloud.bigquery @project, @keyfile, scope: scope,
retries: (retries || @retries),
timeout: (timeout || @timeout)
end
|
[
"def",
"bigquery",
"scope",
":",
"nil",
",",
"retries",
":",
"nil",
",",
"timeout",
":",
"nil",
"Google",
"::",
"Cloud",
".",
"bigquery",
"@project",
",",
"@keyfile",
",",
"scope",
":",
"scope",
",",
"retries",
":",
"(",
"retries",
"||",
"@retries",
")",
",",
"timeout",
":",
"(",
"timeout",
"||",
"@timeout",
")",
"end"
] |
Creates a new object for connecting to the BigQuery service.
Each call creates a new connection.
For more information on connecting to Google Cloud see the
{file:AUTHENTICATION.md Authentication Guide}.
@param [String, Array<String>] scope The OAuth 2.0 scopes controlling the
set of resources and operations that the connection can access. See
[Using OAuth 2.0 to Access Google
APIs](https://developers.google.com/identity/protocols/OAuth2).
The default scope is:
* `https://www.googleapis.com/auth/bigquery`
@param [Integer] retries Number of times to retry requests on server
error. The default value is `5`. Optional.
@param [Integer] timeout Default request timeout in seconds. Optional.
@return [Google::Cloud::Bigquery::Project]
@example
require "google/cloud"
gcloud = Google::Cloud.new
bigquery = gcloud.bigquery
dataset = bigquery.dataset "my_dataset"
table = dataset.table "my_table"
table.data.each do |row|
puts row
end
@example The default scope can be overridden with the `scope` option:
require "google/cloud"
gcloud = Google::Cloud.new
platform_scope = "https://www.googleapis.com/auth/cloud-platform"
bigquery = gcloud.bigquery scope: platform_scope
|
[
"Creates",
"a",
"new",
"object",
"for",
"connecting",
"to",
"the",
"BigQuery",
"service",
".",
"Each",
"call",
"creates",
"a",
"new",
"connection",
"."
] |
846c1a57250ac860ef4de1b54853a480ab2ff702
|
https://github.com/googleapis/google-cloud-ruby/blob/846c1a57250ac860ef4de1b54853a480ab2ff702/google-cloud-bigquery/lib/google-cloud-bigquery.rb#L67-L71
|
11,313
|
googleapis/google-cloud-ruby
|
google-cloud-debugger/lib/google-cloud-debugger.rb
|
Google.Cloud.debugger
|
def debugger service_name: nil, service_version: nil, scope: nil,
timeout: nil, client_config: nil
Google::Cloud.debugger @project, @keyfile,
service_name: service_name,
service_version: service_version,
scope: scope,
timeout: (timeout || @timeout),
client_config: client_config
end
|
ruby
|
def debugger service_name: nil, service_version: nil, scope: nil,
timeout: nil, client_config: nil
Google::Cloud.debugger @project, @keyfile,
service_name: service_name,
service_version: service_version,
scope: scope,
timeout: (timeout || @timeout),
client_config: client_config
end
|
[
"def",
"debugger",
"service_name",
":",
"nil",
",",
"service_version",
":",
"nil",
",",
"scope",
":",
"nil",
",",
"timeout",
":",
"nil",
",",
"client_config",
":",
"nil",
"Google",
"::",
"Cloud",
".",
"debugger",
"@project",
",",
"@keyfile",
",",
"service_name",
":",
"service_name",
",",
"service_version",
":",
"service_version",
",",
"scope",
":",
"scope",
",",
"timeout",
":",
"(",
"timeout",
"||",
"@timeout",
")",
",",
"client_config",
":",
"client_config",
"end"
] |
Creates a new debugger object for instrumenting Stackdriver Debugger for
an application. Each call creates a new debugger agent with independent
connection service.
For more information on connecting to Google Cloud see the
{file:AUTHENTICATION.md Authentication Guide}.
@param [String] service_name Name for the debuggee application. Optional.
@param [String] service_version Version identifier for the debuggee
application. Optional.
@param [String, Array<String>] scope The OAuth 2.0 scopes controlling the
set of resources and operations that the connection can access. See
[Using OAuth 2.0 to Access Google
APIs](https://developers.google.com/identity/protocols/OAuth2).
The default scope is:
* `https://www.googleapis.com/auth/cloud_debugger`
* `https://www.googleapis.com/auth/logging.admin`
@param [Integer] timeout Default timeout to use in requests. Optional.
@param [Hash] client_config A hash of values to override the default
behavior of the API client. Optional.
@return [Google::Cloud::Debugger::Project]
@example
require "google/cloud"
gcloud = Google::Cloud.new
debugger = gcloud.debugger
debugger.start
@example The default scope can be overridden with the `scope` option:
require "google/cloud"
gcloud = Google::Cloud.new
platform_scope = "https://www.googleapis.com/auth/cloud-platform"
debugger = gcloud.debugger scope: platform_scope
|
[
"Creates",
"a",
"new",
"debugger",
"object",
"for",
"instrumenting",
"Stackdriver",
"Debugger",
"for",
"an",
"application",
".",
"Each",
"call",
"creates",
"a",
"new",
"debugger",
"agent",
"with",
"independent",
"connection",
"service",
"."
] |
846c1a57250ac860ef4de1b54853a480ab2ff702
|
https://github.com/googleapis/google-cloud-ruby/blob/846c1a57250ac860ef4de1b54853a480ab2ff702/google-cloud-debugger/lib/google-cloud-debugger.rb#L71-L79
|
11,314
|
googleapis/google-cloud-ruby
|
google-cloud-datastore/lib/google-cloud-datastore.rb
|
Google.Cloud.datastore
|
def datastore scope: nil, timeout: nil, client_config: nil
Google::Cloud.datastore @project, @keyfile,
scope: scope, timeout: (timeout || @timeout),
client_config: client_config
end
|
ruby
|
def datastore scope: nil, timeout: nil, client_config: nil
Google::Cloud.datastore @project, @keyfile,
scope: scope, timeout: (timeout || @timeout),
client_config: client_config
end
|
[
"def",
"datastore",
"scope",
":",
"nil",
",",
"timeout",
":",
"nil",
",",
"client_config",
":",
"nil",
"Google",
"::",
"Cloud",
".",
"datastore",
"@project",
",",
"@keyfile",
",",
"scope",
":",
"scope",
",",
"timeout",
":",
"(",
"timeout",
"||",
"@timeout",
")",
",",
"client_config",
":",
"client_config",
"end"
] |
Creates a new object for connecting to the Datastore service.
Each call creates a new connection.
For more information on connecting to Google Cloud see the
{file:AUTHENTICATION.md Authentication Guide}.
@param [String, Array<String>] scope The OAuth 2.0 scopes controlling the
set of resources and operations that the connection can access. See
[Using OAuth 2.0 to Access Google
APIs](https://developers.google.com/identity/protocols/OAuth2).
The default scope is:
* `https://www.googleapis.com/auth/datastore`
@param [Integer] timeout Default timeout to use in requests. Optional.
@param [Hash] client_config A hash of values to override the default
behavior of the API client. See Google::Gax::CallSettings. Optional.
@return [Google::Cloud::Datastore::Dataset]
@example
require "google/cloud"
gcloud = Google::Cloud.new
datastore = gcloud.datastore
task = datastore.entity "Task" do |t|
t["type"] = "Personal"
t["done"] = false
t["priority"] = 4
t["description"] = "Learn Cloud Datastore"
end
datastore.save task
@example You shouldn't need to override the default scope, but you can:
require "google/cloud"
gcloud = Google::Cloud.new
platform_scope = "https://www.googleapis.com/auth/cloud-platform"
datastore = gcloud.datastore scope: platform_scope
|
[
"Creates",
"a",
"new",
"object",
"for",
"connecting",
"to",
"the",
"Datastore",
"service",
".",
"Each",
"call",
"creates",
"a",
"new",
"connection",
"."
] |
846c1a57250ac860ef4de1b54853a480ab2ff702
|
https://github.com/googleapis/google-cloud-ruby/blob/846c1a57250ac860ef4de1b54853a480ab2ff702/google-cloud-datastore/lib/google-cloud-datastore.rb#L72-L76
|
11,315
|
googleapis/google-cloud-ruby
|
google-cloud-resource_manager/lib/google-cloud-resource_manager.rb
|
Google.Cloud.resource_manager
|
def resource_manager scope: nil, retries: nil, timeout: nil
Google::Cloud.resource_manager @keyfile, scope: scope,
retries: (retries || @retries),
timeout: (timeout || @timeout)
end
|
ruby
|
def resource_manager scope: nil, retries: nil, timeout: nil
Google::Cloud.resource_manager @keyfile, scope: scope,
retries: (retries || @retries),
timeout: (timeout || @timeout)
end
|
[
"def",
"resource_manager",
"scope",
":",
"nil",
",",
"retries",
":",
"nil",
",",
"timeout",
":",
"nil",
"Google",
"::",
"Cloud",
".",
"resource_manager",
"@keyfile",
",",
"scope",
":",
"scope",
",",
"retries",
":",
"(",
"retries",
"||",
"@retries",
")",
",",
"timeout",
":",
"(",
"timeout",
"||",
"@timeout",
")",
"end"
] |
Creates a new object for connecting to the Resource Manager service.
Each call creates a new connection.
For more information on connecting to Google Cloud see the
{file:AUTHENTICATION.md Authentication Guide}.
@param [String, Array<String>] scope The OAuth 2.0 scopes controlling the
set of resources and operations that the connection can access. See
[Using OAuth 2.0 to Access Google
APIs](https://developers.google.com/identity/protocols/OAuth2).
The default scope is:
* `https://www.googleapis.com/auth/cloud-platform`
@param [Integer] retries Number of times to retry requests on server
error. The default value is `3`. Optional.
@param [Integer] timeout Default timeout to use in requests. Optional.
@return [Google::Cloud::ResourceManager::Manager]
@example
require "google/cloud"
gcloud = Google::Cloud.new
resource_manager = gcloud.resource_manager
resource_manager.projects.each do |project|
puts projects.project_id
end
@example The default scope can be overridden with the `scope` option:
require "google/cloud"
gcloud = Google::Cloud.new
readonly_scope = \
"https://www.googleapis.com/auth/cloudresourcemanager.readonly"
resource_manager = gcloud.resource_manager scope: readonly_scope
|
[
"Creates",
"a",
"new",
"object",
"for",
"connecting",
"to",
"the",
"Resource",
"Manager",
"service",
".",
"Each",
"call",
"creates",
"a",
"new",
"connection",
"."
] |
846c1a57250ac860ef4de1b54853a480ab2ff702
|
https://github.com/googleapis/google-cloud-ruby/blob/846c1a57250ac860ef4de1b54853a480ab2ff702/google-cloud-resource_manager/lib/google-cloud-resource_manager.rb#L67-L71
|
11,316
|
googleapis/google-cloud-ruby
|
google-cloud-storage/lib/google-cloud-storage.rb
|
Google.Cloud.storage
|
def storage scope: nil, retries: nil, timeout: nil
Google::Cloud.storage @project, @keyfile, scope: scope,
retries: (retries || @retries),
timeout: (timeout || @timeout)
end
|
ruby
|
def storage scope: nil, retries: nil, timeout: nil
Google::Cloud.storage @project, @keyfile, scope: scope,
retries: (retries || @retries),
timeout: (timeout || @timeout)
end
|
[
"def",
"storage",
"scope",
":",
"nil",
",",
"retries",
":",
"nil",
",",
"timeout",
":",
"nil",
"Google",
"::",
"Cloud",
".",
"storage",
"@project",
",",
"@keyfile",
",",
"scope",
":",
"scope",
",",
"retries",
":",
"(",
"retries",
"||",
"@retries",
")",
",",
"timeout",
":",
"(",
"timeout",
"||",
"@timeout",
")",
"end"
] |
Creates a new object for connecting to the Storage service.
Each call creates a new connection.
For more information on connecting to Google Cloud see the
{file:AUTHENTICATION.md Authentication Guide}.
@see https://cloud.google.com/storage/docs/authentication#oauth Storage
OAuth 2.0 Authentication
@param [String, Array<String>] scope The OAuth 2.0 scopes controlling the
set of resources and operations that the connection can access. See
[Using OAuth 2.0 to Access Google
APIs](https://developers.google.com/identity/protocols/OAuth2).
The default scope is:
* `https://www.googleapis.com/auth/devstorage.full_control`
@param [Integer] retries Number of times to retry requests on server
error. The default value is `3`. Optional.
@param [Integer] timeout Default timeout to use in requests. Optional.
@return [Google::Cloud::Storage::Project]
@example
require "google/cloud"
gcloud = Google::Cloud.new
storage = gcloud.storage
bucket = storage.bucket "my-bucket"
file = bucket.file "path/to/my-file.ext"
@example The default scope can be overridden with the `scope` option:
require "google/cloud"
gcloud = Google::Cloud.new
readonly_scope = "https://www.googleapis.com/auth/devstorage.read_only"
readonly_storage = gcloud.storage scope: readonly_scope
|
[
"Creates",
"a",
"new",
"object",
"for",
"connecting",
"to",
"the",
"Storage",
"service",
".",
"Each",
"call",
"creates",
"a",
"new",
"connection",
"."
] |
846c1a57250ac860ef4de1b54853a480ab2ff702
|
https://github.com/googleapis/google-cloud-ruby/blob/846c1a57250ac860ef4de1b54853a480ab2ff702/google-cloud-storage/lib/google-cloud-storage.rb#L67-L71
|
11,317
|
googleapis/google-cloud-ruby
|
google-cloud-translate/lib/google-cloud-translate.rb
|
Google.Cloud.translate
|
def translate key = nil, scope: nil, retries: nil, timeout: nil
Google::Cloud.translate key, project_id: @project, credentials: @keyfile,
scope: scope,
retries: (retries || @retries),
timeout: (timeout || @timeout)
end
|
ruby
|
def translate key = nil, scope: nil, retries: nil, timeout: nil
Google::Cloud.translate key, project_id: @project, credentials: @keyfile,
scope: scope,
retries: (retries || @retries),
timeout: (timeout || @timeout)
end
|
[
"def",
"translate",
"key",
"=",
"nil",
",",
"scope",
":",
"nil",
",",
"retries",
":",
"nil",
",",
"timeout",
":",
"nil",
"Google",
"::",
"Cloud",
".",
"translate",
"key",
",",
"project_id",
":",
"@project",
",",
"credentials",
":",
"@keyfile",
",",
"scope",
":",
"scope",
",",
"retries",
":",
"(",
"retries",
"||",
"@retries",
")",
",",
"timeout",
":",
"(",
"timeout",
"||",
"@timeout",
")",
"end"
] |
Creates a new object for connecting to the Cloud Translation API. Each
call creates a new connection.
Like other Cloud Platform services, Google Cloud Translation API supports
authentication using a project ID and OAuth 2.0 credentials. In addition,
it supports authentication using a public API access key. (If both the API
key and the project and OAuth 2.0 credentials are provided, the API key
will be used.) Instructions and configuration options are covered in the
{file:AUTHENTICATION.md Authentication Guide}.
@param [String] key a public API access key (not an OAuth 2.0 token)
@param [String, Array<String>] scope The OAuth 2.0 scopes controlling the
set of resources and operations that the connection can access. See
[Using OAuth 2.0 to Access Google
APIs](https://developers.google.com/identity/protocols/OAuth2).
The default scope is:
* `https://www.googleapis.com/auth/cloud-platform`
@param [Integer] retries Number of times to retry requests on server
error. The default value is `3`. Optional.
@param [Integer] timeout Default timeout to use in requests. Optional.
@return [Google::Cloud::Translate::Api]
@example
require "google/cloud"
gcloud = Google::Cloud.new
translate = gcloud.translate "api-key-abc123XYZ789"
translation = translate.translate "Hello world!", to: "la"
translation.text #=> "Salve mundi!"
@example Using API Key from the environment variable.
require "google/cloud"
ENV["TRANSLATE_KEY"] = "api-key-abc123XYZ789"
gcloud = Google::Cloud.new
translate = gcloud.translate
translation = translate.translate "Hello world!", to: "la"
translation.text #=> "Salve mundi!"
|
[
"Creates",
"a",
"new",
"object",
"for",
"connecting",
"to",
"the",
"Cloud",
"Translation",
"API",
".",
"Each",
"call",
"creates",
"a",
"new",
"connection",
"."
] |
846c1a57250ac860ef4de1b54853a480ab2ff702
|
https://github.com/googleapis/google-cloud-ruby/blob/846c1a57250ac860ef4de1b54853a480ab2ff702/google-cloud-translate/lib/google-cloud-translate.rb#L74-L79
|
11,318
|
googleapis/google-cloud-ruby
|
google-cloud-firestore/lib/google-cloud-firestore.rb
|
Google.Cloud.firestore
|
def firestore scope: nil, timeout: nil, client_config: nil
Google::Cloud.firestore @project, @keyfile,
scope: scope, timeout: (timeout || @timeout),
client_config: client_config
end
|
ruby
|
def firestore scope: nil, timeout: nil, client_config: nil
Google::Cloud.firestore @project, @keyfile,
scope: scope, timeout: (timeout || @timeout),
client_config: client_config
end
|
[
"def",
"firestore",
"scope",
":",
"nil",
",",
"timeout",
":",
"nil",
",",
"client_config",
":",
"nil",
"Google",
"::",
"Cloud",
".",
"firestore",
"@project",
",",
"@keyfile",
",",
"scope",
":",
"scope",
",",
"timeout",
":",
"(",
"timeout",
"||",
"@timeout",
")",
",",
"client_config",
":",
"client_config",
"end"
] |
Creates a new object for connecting to the Firestore service.
Each call creates a new connection.
For more information on connecting to Google Cloud see the
{file:AUTHENTICATION.md Authentication Guide}.
@param [String, Array<String>] scope The OAuth 2.0 scopes controlling the
set of resources and operations that the connection can access. See
[Using OAuth 2.0 to Access Google
APIs](https://developers.google.com/identity/protocols/OAuth2).
The default scope is:
* `https://www.googleapis.com/auth/datastore`
@param [Integer] timeout Default timeout to use in requests. Optional.
@param [Hash] client_config A hash of values to override the default
behavior of the API client. Optional.
@return [Google::Cloud::Firestore::Client]
@example
require "google/cloud"
gcloud = Google::Cloud.new
firestore = gcloud.firestore
@example The default scope can be overridden with the `scope` option:
require "google/cloud"
gcloud = Google::Cloud.new
platform_scope = "https://www.googleapis.com/auth/cloud-platform"
firestore = gcloud.firestore scope: platform_scope
|
[
"Creates",
"a",
"new",
"object",
"for",
"connecting",
"to",
"the",
"Firestore",
"service",
".",
"Each",
"call",
"creates",
"a",
"new",
"connection",
"."
] |
846c1a57250ac860ef4de1b54853a480ab2ff702
|
https://github.com/googleapis/google-cloud-ruby/blob/846c1a57250ac860ef4de1b54853a480ab2ff702/google-cloud-firestore/lib/google-cloud-firestore.rb#L63-L67
|
11,319
|
googleapis/google-cloud-ruby
|
google-cloud-trace/lib/google-cloud-trace.rb
|
Google.Cloud.trace
|
def trace scope: nil, timeout: nil, client_config: nil
Google::Cloud.trace @project, @keyfile, scope: scope,
timeout: (timeout || @timeout),
client_config: client_config
end
|
ruby
|
def trace scope: nil, timeout: nil, client_config: nil
Google::Cloud.trace @project, @keyfile, scope: scope,
timeout: (timeout || @timeout),
client_config: client_config
end
|
[
"def",
"trace",
"scope",
":",
"nil",
",",
"timeout",
":",
"nil",
",",
"client_config",
":",
"nil",
"Google",
"::",
"Cloud",
".",
"trace",
"@project",
",",
"@keyfile",
",",
"scope",
":",
"scope",
",",
"timeout",
":",
"(",
"timeout",
"||",
"@timeout",
")",
",",
"client_config",
":",
"client_config",
"end"
] |
Creates a new object for connecting to the Stackdriver Trace service.
Each call creates a new connection.
For more information on connecting to Google Cloud see the
{file:AUTHENTICATION.md Authentication Guide}.
@param [String, Array<String>] scope The OAuth 2.0 scopes controlling the
set of resources and operations that the connection can access. See
[Using OAuth 2.0 to Access Google
APIs](https://developers.google.com/identity/protocols/OAuth2).
The default scope is:
* `https://www.googleapis.com/auth/cloud-platform`
@param [Integer] timeout Default timeout to use in requests. Optional.
@return [Google::Cloud::Trace::Project]
@example
require "google/cloud"
gcloud = Google::Cloud.new
trace_client = gcloud.trace
traces = trace_client.list_traces Time.now - 3600, Time.now
traces.each do |trace|
puts "Retrieved trace ID: #{trace.trace_id}"
end
|
[
"Creates",
"a",
"new",
"object",
"for",
"connecting",
"to",
"the",
"Stackdriver",
"Trace",
"service",
".",
"Each",
"call",
"creates",
"a",
"new",
"connection",
"."
] |
846c1a57250ac860ef4de1b54853a480ab2ff702
|
https://github.com/googleapis/google-cloud-ruby/blob/846c1a57250ac860ef4de1b54853a480ab2ff702/google-cloud-trace/lib/google-cloud-trace.rb#L60-L64
|
11,320
|
googleapis/google-cloud-ruby
|
google-cloud-bigtable/lib/google-cloud-bigtable.rb
|
Google.Cloud.bigtable
|
def bigtable scope: nil, timeout: nil, credentials: nil, client_config: nil
Google::Cloud.bigtable(
project_id: @project,
credentials: (credentials || @keyfile),
scope: scope,
timeout: (timeout || @timeout),
client_config: client_config
)
end
|
ruby
|
def bigtable scope: nil, timeout: nil, credentials: nil, client_config: nil
Google::Cloud.bigtable(
project_id: @project,
credentials: (credentials || @keyfile),
scope: scope,
timeout: (timeout || @timeout),
client_config: client_config
)
end
|
[
"def",
"bigtable",
"scope",
":",
"nil",
",",
"timeout",
":",
"nil",
",",
"credentials",
":",
"nil",
",",
"client_config",
":",
"nil",
"Google",
"::",
"Cloud",
".",
"bigtable",
"(",
"project_id",
":",
"@project",
",",
"credentials",
":",
"(",
"credentials",
"||",
"@keyfile",
")",
",",
"scope",
":",
"scope",
",",
"timeout",
":",
"(",
"timeout",
"||",
"@timeout",
")",
",",
"client_config",
":",
"client_config",
")",
"end"
] |
Creates a new object for connecting to the Cloud Bigtable service.
For more information on connecting to Google Cloud Platform, see the
{file:AUTHENTICATION.md Authentication Guide}.
@param scope [Array<String>]
The OAuth 2.0 scopes controlling the set of resources and operations
that the connection can access. See [Using OAuth 2.0 to Access Google
APIs](https://developers.google.com/identity/protocols/OAuth2).
The OAuth scopes for this service. This parameter is ignored if an
updater_proc is supplied.
@param timeout [Integer]
The default timeout, in seconds, for calls made through this client.
@param credentials [Google::Auth::Credentials, String, Hash, GRPC::Core::Channel, GRPC::Core::ChannelCredentials, Proc]
Provides the means for authenticating requests made by the client. This parameter can
be one of the following types.
`Google::Auth::Credentials` uses the properties of its represented keyfile for
authenticating requests made by this client.
`String` will be treated as the path to the keyfile to use to construct
credentials for this client.
`Hash` will be treated as the contents of a keyfile to use to construct
credentials for this client.
`GRPC::Core::Channel` will be used to make calls through.
`GRPC::Core::ChannelCredentials` will be used to set up the gRPC client. The channel credentials
should already be composed with a `GRPC::Core::CallCredentials` object.
`Proc` will be used as an updater_proc for the gRPC channel. The proc transforms the
metadata for requests, generally, to give OAuth credentials.
@param client_config [Hash]
A hash for call options for each method.
See Google::Gax#construct_settings for the structure of
this data. Falls back to the default config if not specified
or the specified config is missing data points.
@return [Google::Cloud::Bigtable::Project]
@example
require "google/cloud"
gcloud = Google::Cloud.new
bigtable = gcloud.bigtable
|
[
"Creates",
"a",
"new",
"object",
"for",
"connecting",
"to",
"the",
"Cloud",
"Bigtable",
"service",
"."
] |
846c1a57250ac860ef4de1b54853a480ab2ff702
|
https://github.com/googleapis/google-cloud-ruby/blob/846c1a57250ac860ef4de1b54853a480ab2ff702/google-cloud-bigtable/lib/google-cloud-bigtable.rb#L71-L79
|
11,321
|
bblimke/webmock
|
lib/webmock/request_pattern.rb
|
WebMock.BodyPattern.matching_body_hashes?
|
def matching_body_hashes?(query_parameters, pattern, content_type)
return false unless query_parameters.is_a?(Hash)
return false unless query_parameters.keys.sort == pattern.keys.sort
query_parameters.each do |key, actual|
expected = pattern[key]
if actual.is_a?(Hash) && expected.is_a?(Hash)
return false unless matching_body_hashes?(actual, expected, content_type)
else
expected = WebMock::Util::ValuesStringifier.stringify_values(expected) if url_encoded_body?(content_type)
return false unless expected === actual
end
end
true
end
|
ruby
|
def matching_body_hashes?(query_parameters, pattern, content_type)
return false unless query_parameters.is_a?(Hash)
return false unless query_parameters.keys.sort == pattern.keys.sort
query_parameters.each do |key, actual|
expected = pattern[key]
if actual.is_a?(Hash) && expected.is_a?(Hash)
return false unless matching_body_hashes?(actual, expected, content_type)
else
expected = WebMock::Util::ValuesStringifier.stringify_values(expected) if url_encoded_body?(content_type)
return false unless expected === actual
end
end
true
end
|
[
"def",
"matching_body_hashes?",
"(",
"query_parameters",
",",
"pattern",
",",
"content_type",
")",
"return",
"false",
"unless",
"query_parameters",
".",
"is_a?",
"(",
"Hash",
")",
"return",
"false",
"unless",
"query_parameters",
".",
"keys",
".",
"sort",
"==",
"pattern",
".",
"keys",
".",
"sort",
"query_parameters",
".",
"each",
"do",
"|",
"key",
",",
"actual",
"|",
"expected",
"=",
"pattern",
"[",
"key",
"]",
"if",
"actual",
".",
"is_a?",
"(",
"Hash",
")",
"&&",
"expected",
".",
"is_a?",
"(",
"Hash",
")",
"return",
"false",
"unless",
"matching_body_hashes?",
"(",
"actual",
",",
"expected",
",",
"content_type",
")",
"else",
"expected",
"=",
"WebMock",
"::",
"Util",
"::",
"ValuesStringifier",
".",
"stringify_values",
"(",
"expected",
")",
"if",
"url_encoded_body?",
"(",
"content_type",
")",
"return",
"false",
"unless",
"expected",
"===",
"actual",
"end",
"end",
"true",
"end"
] |
Compare two hashes for equality
For two hashes to match they must have the same length and all
values must match when compared using `#===`.
The following hashes are examples of matches:
{a: /\d+/} and {a: '123'}
{a: '123'} and {a: '123'}
{a: {b: /\d+/}} and {a: {b: '123'}}
{a: {b: 'wow'}} and {a: {b: 'wow'}}
@param [Hash] query_parameters typically the result of parsing
JSON, XML or URL encoded parameters.
@param [Hash] pattern which contains keys with a string, hash or
regular expression value to use for comparison.
@return [Boolean] true if the paramaters match the comparison
hash, false if not.
|
[
"Compare",
"two",
"hashes",
"for",
"equality"
] |
c0bcc09af372286cd110ec4159112ce583007951
|
https://github.com/bblimke/webmock/blob/c0bcc09af372286cd110ec4159112ce583007951/lib/webmock/request_pattern.rb#L310-L324
|
11,322
|
jch/html-pipeline
|
lib/html/pipeline.rb
|
HTML.Pipeline.call
|
def call(html, context = {}, result = nil)
context = @default_context.merge(context)
context = context.freeze
result ||= @result_class.new
payload = default_payload filters: @filters.map(&:name),
context: context, result: result
instrument 'call_pipeline.html_pipeline', payload do
result[:output] =
@filters.inject(html) do |doc, filter|
perform_filter(filter, doc, context, result)
end
end
result
end
|
ruby
|
def call(html, context = {}, result = nil)
context = @default_context.merge(context)
context = context.freeze
result ||= @result_class.new
payload = default_payload filters: @filters.map(&:name),
context: context, result: result
instrument 'call_pipeline.html_pipeline', payload do
result[:output] =
@filters.inject(html) do |doc, filter|
perform_filter(filter, doc, context, result)
end
end
result
end
|
[
"def",
"call",
"(",
"html",
",",
"context",
"=",
"{",
"}",
",",
"result",
"=",
"nil",
")",
"context",
"=",
"@default_context",
".",
"merge",
"(",
"context",
")",
"context",
"=",
"context",
".",
"freeze",
"result",
"||=",
"@result_class",
".",
"new",
"payload",
"=",
"default_payload",
"filters",
":",
"@filters",
".",
"map",
"(",
":name",
")",
",",
"context",
":",
"context",
",",
"result",
":",
"result",
"instrument",
"'call_pipeline.html_pipeline'",
",",
"payload",
"do",
"result",
"[",
":output",
"]",
"=",
"@filters",
".",
"inject",
"(",
"html",
")",
"do",
"|",
"doc",
",",
"filter",
"|",
"perform_filter",
"(",
"filter",
",",
"doc",
",",
"context",
",",
"result",
")",
"end",
"end",
"result",
"end"
] |
Apply all filters in the pipeline to the given HTML.
html - A String containing HTML or a DocumentFragment object.
context - The context hash passed to each filter. See the Filter docs
for more info on possible values. This object MUST NOT be modified
in place by filters. Use the Result for passing state back.
result - The result Hash passed to each filter for modification. This
is where Filters store extracted information from the content.
Returns the result Hash after being filtered by this Pipeline. Contains an
:output key with the DocumentFragment or String HTML markup based on the
output of the last filter in the pipeline.
|
[
"Apply",
"all",
"filters",
"in",
"the",
"pipeline",
"to",
"the",
"given",
"HTML",
"."
] |
f1bbce4858876dc2619c61a8b18637b5d3321b1c
|
https://github.com/jch/html-pipeline/blob/f1bbce4858876dc2619c61a8b18637b5d3321b1c/lib/html/pipeline.rb#L107-L120
|
11,323
|
jch/html-pipeline
|
lib/html/pipeline.rb
|
HTML.Pipeline.to_document
|
def to_document(input, context = {}, result = nil)
result = call(input, context, result)
HTML::Pipeline.parse(result[:output])
end
|
ruby
|
def to_document(input, context = {}, result = nil)
result = call(input, context, result)
HTML::Pipeline.parse(result[:output])
end
|
[
"def",
"to_document",
"(",
"input",
",",
"context",
"=",
"{",
"}",
",",
"result",
"=",
"nil",
")",
"result",
"=",
"call",
"(",
"input",
",",
"context",
",",
"result",
")",
"HTML",
"::",
"Pipeline",
".",
"parse",
"(",
"result",
"[",
":output",
"]",
")",
"end"
] |
Like call but guarantee the value returned is a DocumentFragment.
Pipelines may return a DocumentFragment or a String. Callers that need a
DocumentFragment should use this method.
|
[
"Like",
"call",
"but",
"guarantee",
"the",
"value",
"returned",
"is",
"a",
"DocumentFragment",
".",
"Pipelines",
"may",
"return",
"a",
"DocumentFragment",
"or",
"a",
"String",
".",
"Callers",
"that",
"need",
"a",
"DocumentFragment",
"should",
"use",
"this",
"method",
"."
] |
f1bbce4858876dc2619c61a8b18637b5d3321b1c
|
https://github.com/jch/html-pipeline/blob/f1bbce4858876dc2619c61a8b18637b5d3321b1c/lib/html/pipeline.rb#L138-L141
|
11,324
|
jch/html-pipeline
|
lib/html/pipeline.rb
|
HTML.Pipeline.to_html
|
def to_html(input, context = {}, result = nil)
result = call(input, context, result = nil)
output = result[:output]
if output.respond_to?(:to_html)
output.to_html
else
output.to_s
end
end
|
ruby
|
def to_html(input, context = {}, result = nil)
result = call(input, context, result = nil)
output = result[:output]
if output.respond_to?(:to_html)
output.to_html
else
output.to_s
end
end
|
[
"def",
"to_html",
"(",
"input",
",",
"context",
"=",
"{",
"}",
",",
"result",
"=",
"nil",
")",
"result",
"=",
"call",
"(",
"input",
",",
"context",
",",
"result",
"=",
"nil",
")",
"output",
"=",
"result",
"[",
":output",
"]",
"if",
"output",
".",
"respond_to?",
"(",
":to_html",
")",
"output",
".",
"to_html",
"else",
"output",
".",
"to_s",
"end",
"end"
] |
Like call but guarantee the value returned is a string of HTML markup.
|
[
"Like",
"call",
"but",
"guarantee",
"the",
"value",
"returned",
"is",
"a",
"string",
"of",
"HTML",
"markup",
"."
] |
f1bbce4858876dc2619c61a8b18637b5d3321b1c
|
https://github.com/jch/html-pipeline/blob/f1bbce4858876dc2619c61a8b18637b5d3321b1c/lib/html/pipeline.rb#L144-L152
|
11,325
|
kaminari/kaminari
|
kaminari-core/lib/kaminari/models/page_scope_methods.rb
|
Kaminari.PageScopeMethods.total_pages
|
def total_pages
count_without_padding = total_count
count_without_padding -= @_padding if defined?(@_padding) && @_padding
count_without_padding = 0 if count_without_padding < 0
total_pages_count = (count_without_padding.to_f / limit_value).ceil
max_pages && (max_pages < total_pages_count) ? max_pages : total_pages_count
rescue FloatDomainError
raise ZeroPerPageOperation, "The number of total pages was incalculable. Perhaps you called .per(0)?"
end
|
ruby
|
def total_pages
count_without_padding = total_count
count_without_padding -= @_padding if defined?(@_padding) && @_padding
count_without_padding = 0 if count_without_padding < 0
total_pages_count = (count_without_padding.to_f / limit_value).ceil
max_pages && (max_pages < total_pages_count) ? max_pages : total_pages_count
rescue FloatDomainError
raise ZeroPerPageOperation, "The number of total pages was incalculable. Perhaps you called .per(0)?"
end
|
[
"def",
"total_pages",
"count_without_padding",
"=",
"total_count",
"count_without_padding",
"-=",
"@_padding",
"if",
"defined?",
"(",
"@_padding",
")",
"&&",
"@_padding",
"count_without_padding",
"=",
"0",
"if",
"count_without_padding",
"<",
"0",
"total_pages_count",
"=",
"(",
"count_without_padding",
".",
"to_f",
"/",
"limit_value",
")",
".",
"ceil",
"max_pages",
"&&",
"(",
"max_pages",
"<",
"total_pages_count",
")",
"?",
"max_pages",
":",
"total_pages_count",
"rescue",
"FloatDomainError",
"raise",
"ZeroPerPageOperation",
",",
"\"The number of total pages was incalculable. Perhaps you called .per(0)?\"",
"end"
] |
Total number of pages
|
[
"Total",
"number",
"of",
"pages"
] |
e2078ce46b145b811423dc8b5993e4bc87dc88b8
|
https://github.com/kaminari/kaminari/blob/e2078ce46b145b811423dc8b5993e4bc87dc88b8/kaminari-core/lib/kaminari/models/page_scope_methods.rb#L35-L44
|
11,326
|
kaminari/kaminari
|
kaminari-core/lib/kaminari/models/page_scope_methods.rb
|
Kaminari.PageScopeMethods.current_page
|
def current_page
offset_without_padding = offset_value
offset_without_padding -= @_padding if defined?(@_padding) && @_padding
offset_without_padding = 0 if offset_without_padding < 0
(offset_without_padding / limit_value) + 1
rescue ZeroDivisionError
raise ZeroPerPageOperation, "Current page was incalculable. Perhaps you called .per(0)?"
end
|
ruby
|
def current_page
offset_without_padding = offset_value
offset_without_padding -= @_padding if defined?(@_padding) && @_padding
offset_without_padding = 0 if offset_without_padding < 0
(offset_without_padding / limit_value) + 1
rescue ZeroDivisionError
raise ZeroPerPageOperation, "Current page was incalculable. Perhaps you called .per(0)?"
end
|
[
"def",
"current_page",
"offset_without_padding",
"=",
"offset_value",
"offset_without_padding",
"-=",
"@_padding",
"if",
"defined?",
"(",
"@_padding",
")",
"&&",
"@_padding",
"offset_without_padding",
"=",
"0",
"if",
"offset_without_padding",
"<",
"0",
"(",
"offset_without_padding",
"/",
"limit_value",
")",
"+",
"1",
"rescue",
"ZeroDivisionError",
"raise",
"ZeroPerPageOperation",
",",
"\"Current page was incalculable. Perhaps you called .per(0)?\"",
"end"
] |
Current page number
|
[
"Current",
"page",
"number"
] |
e2078ce46b145b811423dc8b5993e4bc87dc88b8
|
https://github.com/kaminari/kaminari/blob/e2078ce46b145b811423dc8b5993e4bc87dc88b8/kaminari-core/lib/kaminari/models/page_scope_methods.rb#L47-L55
|
11,327
|
kaminari/kaminari
|
kaminari-activerecord/lib/kaminari/activerecord/active_record_relation_methods.rb
|
Kaminari.ActiveRecordRelationMethods.entry_name
|
def entry_name(options = {})
default = options[:count] == 1 ? model_name.human : model_name.human.pluralize
model_name.human(options.reverse_merge(default: default))
end
|
ruby
|
def entry_name(options = {})
default = options[:count] == 1 ? model_name.human : model_name.human.pluralize
model_name.human(options.reverse_merge(default: default))
end
|
[
"def",
"entry_name",
"(",
"options",
"=",
"{",
"}",
")",
"default",
"=",
"options",
"[",
":count",
"]",
"==",
"1",
"?",
"model_name",
".",
"human",
":",
"model_name",
".",
"human",
".",
"pluralize",
"model_name",
".",
"human",
"(",
"options",
".",
"reverse_merge",
"(",
"default",
":",
"default",
")",
")",
"end"
] |
Used for page_entry_info
|
[
"Used",
"for",
"page_entry_info"
] |
e2078ce46b145b811423dc8b5993e4bc87dc88b8
|
https://github.com/kaminari/kaminari/blob/e2078ce46b145b811423dc8b5993e4bc87dc88b8/kaminari-activerecord/lib/kaminari/activerecord/active_record_relation_methods.rb#L7-L10
|
11,328
|
guard/guard
|
lib/guard/watcher.rb
|
Guard.Watcher.call_action
|
def call_action(matches)
@action.arity > 0 ? @action.call(matches) : @action.call
rescue => ex
UI.error "Problem with watch action!\n#{ex.message}"
UI.error ex.backtrace.join("\n")
end
|
ruby
|
def call_action(matches)
@action.arity > 0 ? @action.call(matches) : @action.call
rescue => ex
UI.error "Problem with watch action!\n#{ex.message}"
UI.error ex.backtrace.join("\n")
end
|
[
"def",
"call_action",
"(",
"matches",
")",
"@action",
".",
"arity",
">",
"0",
"?",
"@action",
".",
"call",
"(",
"matches",
")",
":",
"@action",
".",
"call",
"rescue",
"=>",
"ex",
"UI",
".",
"error",
"\"Problem with watch action!\\n#{ex.message}\"",
"UI",
".",
"error",
"ex",
".",
"backtrace",
".",
"join",
"(",
"\"\\n\"",
")",
"end"
] |
Executes a watcher action.
@param [String, MatchData] matches the matched path or the match from the
Regex
@return [String] the final paths
|
[
"Executes",
"a",
"watcher",
"action",
"."
] |
e2508cd83badf0d537dbaba35d307adc35d92e4f
|
https://github.com/guard/guard/blob/e2508cd83badf0d537dbaba35d307adc35d92e4f/lib/guard/watcher.rb#L81-L86
|
11,329
|
guard/guard
|
lib/guard/cli.rb
|
Guard.CLI.start
|
def start
if defined?(JRUBY_VERSION)
unless options[:no_interactions]
abort "\nSorry, JRuby and interactive mode are incompatible.\n"\
"As a workaround, use the '-i' option instead.\n\n"\
"More info: \n"\
" * https://github.com/guard/guard/issues/754\n"\
" * https://github.com/jruby/jruby/issues/2383\n\n"
end
end
exit(Cli::Environments::Valid.new(options).start_guard)
end
|
ruby
|
def start
if defined?(JRUBY_VERSION)
unless options[:no_interactions]
abort "\nSorry, JRuby and interactive mode are incompatible.\n"\
"As a workaround, use the '-i' option instead.\n\n"\
"More info: \n"\
" * https://github.com/guard/guard/issues/754\n"\
" * https://github.com/jruby/jruby/issues/2383\n\n"
end
end
exit(Cli::Environments::Valid.new(options).start_guard)
end
|
[
"def",
"start",
"if",
"defined?",
"(",
"JRUBY_VERSION",
")",
"unless",
"options",
"[",
":no_interactions",
"]",
"abort",
"\"\\nSorry, JRuby and interactive mode are incompatible.\\n\"",
"\"As a workaround, use the '-i' option instead.\\n\\n\"",
"\"More info: \\n\"",
"\" * https://github.com/guard/guard/issues/754\\n\"",
"\" * https://github.com/jruby/jruby/issues/2383\\n\\n\"",
"end",
"end",
"exit",
"(",
"Cli",
"::",
"Environments",
"::",
"Valid",
".",
"new",
"(",
"options",
")",
".",
"start_guard",
")",
"end"
] |
Start Guard by initializing the defined Guard plugins and watch the file
system.
This is the default task, so calling `guard` is the same as calling
`guard start`.
@see Guard.start
|
[
"Start",
"Guard",
"by",
"initializing",
"the",
"defined",
"Guard",
"plugins",
"and",
"watch",
"the",
"file",
"system",
"."
] |
e2508cd83badf0d537dbaba35d307adc35d92e4f
|
https://github.com/guard/guard/blob/e2508cd83badf0d537dbaba35d307adc35d92e4f/lib/guard/cli.rb#L112-L123
|
11,330
|
guard/guard
|
lib/guard/cli.rb
|
Guard.CLI.notifiers
|
def notifiers
Cli::Environments::EvaluateOnly.new(options).evaluate
# TODO: pass the data directly to the notifiers?
DslDescriber.new.notifiers
end
|
ruby
|
def notifiers
Cli::Environments::EvaluateOnly.new(options).evaluate
# TODO: pass the data directly to the notifiers?
DslDescriber.new.notifiers
end
|
[
"def",
"notifiers",
"Cli",
"::",
"Environments",
"::",
"EvaluateOnly",
".",
"new",
"(",
"options",
")",
".",
"evaluate",
"# TODO: pass the data directly to the notifiers?",
"DslDescriber",
".",
"new",
".",
"notifiers",
"end"
] |
List the Notifiers for use in your system.
@see Guard::DslDescriber.notifiers
|
[
"List",
"the",
"Notifiers",
"for",
"use",
"in",
"your",
"system",
"."
] |
e2508cd83badf0d537dbaba35d307adc35d92e4f
|
https://github.com/guard/guard/blob/e2508cd83badf0d537dbaba35d307adc35d92e4f/lib/guard/cli.rb#L143-L147
|
11,331
|
guard/guard
|
lib/guard/cli.rb
|
Guard.CLI.init
|
def init(*plugin_names)
env = Cli::Environments::Valid.new(options)
exitcode = env.initialize_guardfile(plugin_names)
exit(exitcode)
end
|
ruby
|
def init(*plugin_names)
env = Cli::Environments::Valid.new(options)
exitcode = env.initialize_guardfile(plugin_names)
exit(exitcode)
end
|
[
"def",
"init",
"(",
"*",
"plugin_names",
")",
"env",
"=",
"Cli",
"::",
"Environments",
"::",
"Valid",
".",
"new",
"(",
"options",
")",
"exitcode",
"=",
"env",
".",
"initialize_guardfile",
"(",
"plugin_names",
")",
"exit",
"(",
"exitcode",
")",
"end"
] |
Initializes the templates of all installed Guard plugins and adds them
to the `Guardfile` when no Guard name is passed. When passing
Guard plugin names it does the same but only for those Guard plugins.
@see Guard::Guardfile.initialize_template
@see Guard::Guardfile.initialize_all_templates
@param [Array<String>] plugin_names the name of the Guard plugins to
initialize
|
[
"Initializes",
"the",
"templates",
"of",
"all",
"installed",
"Guard",
"plugins",
"and",
"adds",
"them",
"to",
"the",
"Guardfile",
"when",
"no",
"Guard",
"name",
"is",
"passed",
".",
"When",
"passing",
"Guard",
"plugin",
"names",
"it",
"does",
"the",
"same",
"but",
"only",
"for",
"those",
"Guard",
"plugins",
"."
] |
e2508cd83badf0d537dbaba35d307adc35d92e4f
|
https://github.com/guard/guard/blob/e2508cd83badf0d537dbaba35d307adc35d92e4f/lib/guard/cli.rb#L181-L185
|
11,332
|
guard/guard
|
lib/guard/cli.rb
|
Guard.CLI.show
|
def show
Cli::Environments::EvaluateOnly.new(options).evaluate
DslDescriber.new.show
end
|
ruby
|
def show
Cli::Environments::EvaluateOnly.new(options).evaluate
DslDescriber.new.show
end
|
[
"def",
"show",
"Cli",
"::",
"Environments",
"::",
"EvaluateOnly",
".",
"new",
"(",
"options",
")",
".",
"evaluate",
"DslDescriber",
".",
"new",
".",
"show",
"end"
] |
Shows all Guard plugins and their options that are defined in
the `Guardfile`
@see Guard::DslDescriber.show
|
[
"Shows",
"all",
"Guard",
"plugins",
"and",
"their",
"options",
"that",
"are",
"defined",
"in",
"the",
"Guardfile"
] |
e2508cd83badf0d537dbaba35d307adc35d92e4f
|
https://github.com/guard/guard/blob/e2508cd83badf0d537dbaba35d307adc35d92e4f/lib/guard/cli.rb#L195-L198
|
11,333
|
guard/guard
|
lib/guard/plugin_util.rb
|
Guard.PluginUtil.add_to_guardfile
|
def add_to_guardfile
klass = plugin_class # call here to avoid failing later
require_relative "guardfile/evaluator"
# TODO: move this to Generator?
options = Guard.state.session.evaluator_options
evaluator = Guardfile::Evaluator.new(options)
begin
evaluator.evaluate
rescue Guard::Guardfile::Evaluator::NoPluginsError
end
if evaluator.guardfile_include?(name)
UI.info "Guardfile already includes #{ name } guard"
else
content = File.read("Guardfile")
File.open("Guardfile", "wb") do |f|
f.puts(content)
f.puts("")
f.puts(klass.template(plugin_location))
end
UI.info INFO_ADDED_GUARD_TO_GUARDFILE % name
end
end
|
ruby
|
def add_to_guardfile
klass = plugin_class # call here to avoid failing later
require_relative "guardfile/evaluator"
# TODO: move this to Generator?
options = Guard.state.session.evaluator_options
evaluator = Guardfile::Evaluator.new(options)
begin
evaluator.evaluate
rescue Guard::Guardfile::Evaluator::NoPluginsError
end
if evaluator.guardfile_include?(name)
UI.info "Guardfile already includes #{ name } guard"
else
content = File.read("Guardfile")
File.open("Guardfile", "wb") do |f|
f.puts(content)
f.puts("")
f.puts(klass.template(plugin_location))
end
UI.info INFO_ADDED_GUARD_TO_GUARDFILE % name
end
end
|
[
"def",
"add_to_guardfile",
"klass",
"=",
"plugin_class",
"# call here to avoid failing later",
"require_relative",
"\"guardfile/evaluator\"",
"# TODO: move this to Generator?",
"options",
"=",
"Guard",
".",
"state",
".",
"session",
".",
"evaluator_options",
"evaluator",
"=",
"Guardfile",
"::",
"Evaluator",
".",
"new",
"(",
"options",
")",
"begin",
"evaluator",
".",
"evaluate",
"rescue",
"Guard",
"::",
"Guardfile",
"::",
"Evaluator",
"::",
"NoPluginsError",
"end",
"if",
"evaluator",
".",
"guardfile_include?",
"(",
"name",
")",
"UI",
".",
"info",
"\"Guardfile already includes #{ name } guard\"",
"else",
"content",
"=",
"File",
".",
"read",
"(",
"\"Guardfile\"",
")",
"File",
".",
"open",
"(",
"\"Guardfile\"",
",",
"\"wb\"",
")",
"do",
"|",
"f",
"|",
"f",
".",
"puts",
"(",
"content",
")",
"f",
".",
"puts",
"(",
"\"\"",
")",
"f",
".",
"puts",
"(",
"klass",
".",
"template",
"(",
"plugin_location",
")",
")",
"end",
"UI",
".",
"info",
"INFO_ADDED_GUARD_TO_GUARDFILE",
"%",
"name",
"end",
"end"
] |
Adds a plugin's template to the Guardfile.
|
[
"Adds",
"a",
"plugin",
"s",
"template",
"to",
"the",
"Guardfile",
"."
] |
e2508cd83badf0d537dbaba35d307adc35d92e4f
|
https://github.com/guard/guard/blob/e2508cd83badf0d537dbaba35d307adc35d92e4f/lib/guard/plugin_util.rb#L126-L150
|
11,334
|
guard/guard
|
lib/guard/plugin_util.rb
|
Guard.PluginUtil._plugin_constant
|
def _plugin_constant
@_plugin_constant ||= Guard.constants.detect do |c|
c.to_s.casecmp(_constant_name.downcase).zero?
end
end
|
ruby
|
def _plugin_constant
@_plugin_constant ||= Guard.constants.detect do |c|
c.to_s.casecmp(_constant_name.downcase).zero?
end
end
|
[
"def",
"_plugin_constant",
"@_plugin_constant",
"||=",
"Guard",
".",
"constants",
".",
"detect",
"do",
"|",
"c",
"|",
"c",
".",
"to_s",
".",
"casecmp",
"(",
"_constant_name",
".",
"downcase",
")",
".",
"zero?",
"end",
"end"
] |
Returns the constant for the current plugin.
@example Returns the constant for a plugin
> Guard::PluginUtil.new('rspec').send(:_plugin_constant)
=> Guard::RSpec
|
[
"Returns",
"the",
"constant",
"for",
"the",
"current",
"plugin",
"."
] |
e2508cd83badf0d537dbaba35d307adc35d92e4f
|
https://github.com/guard/guard/blob/e2508cd83badf0d537dbaba35d307adc35d92e4f/lib/guard/plugin_util.rb#L160-L164
|
11,335
|
guard/guard
|
lib/guard/dsl.rb
|
Guard.Dsl.interactor
|
def interactor(options)
# TODO: remove dependency on Interactor (let session handle this)
case options
when :off
Interactor.enabled = false
when Hash
Interactor.options = options
end
end
|
ruby
|
def interactor(options)
# TODO: remove dependency on Interactor (let session handle this)
case options
when :off
Interactor.enabled = false
when Hash
Interactor.options = options
end
end
|
[
"def",
"interactor",
"(",
"options",
")",
"# TODO: remove dependency on Interactor (let session handle this)",
"case",
"options",
"when",
":off",
"Interactor",
".",
"enabled",
"=",
"false",
"when",
"Hash",
"Interactor",
".",
"options",
"=",
"options",
"end",
"end"
] |
Sets the interactor options or disable the interactor.
@example Pass options to the interactor
interactor option1: 'value1', option2: 'value2'
@example Turn off interactions
interactor :off
@param [Symbol, Hash] options either `:off` or a Hash with interactor
options
|
[
"Sets",
"the",
"interactor",
"options",
"or",
"disable",
"the",
"interactor",
"."
] |
e2508cd83badf0d537dbaba35d307adc35d92e4f
|
https://github.com/guard/guard/blob/e2508cd83badf0d537dbaba35d307adc35d92e4f/lib/guard/dsl.rb#L90-L98
|
11,336
|
guard/guard
|
lib/guard/dsl.rb
|
Guard.Dsl.guard
|
def guard(name, options = {})
@plugin_options = options.merge(watchers: [], callbacks: [])
yield if block_given?
@current_groups ||= []
groups = @current_groups && @current_groups.last || [:default]
groups.each do |group|
opts = @plugin_options.merge(group: group)
# TODO: let plugins be added *after* evaluation
Guard.state.session.plugins.add(name, opts)
end
@plugin_options = nil
end
|
ruby
|
def guard(name, options = {})
@plugin_options = options.merge(watchers: [], callbacks: [])
yield if block_given?
@current_groups ||= []
groups = @current_groups && @current_groups.last || [:default]
groups.each do |group|
opts = @plugin_options.merge(group: group)
# TODO: let plugins be added *after* evaluation
Guard.state.session.plugins.add(name, opts)
end
@plugin_options = nil
end
|
[
"def",
"guard",
"(",
"name",
",",
"options",
"=",
"{",
"}",
")",
"@plugin_options",
"=",
"options",
".",
"merge",
"(",
"watchers",
":",
"[",
"]",
",",
"callbacks",
":",
"[",
"]",
")",
"yield",
"if",
"block_given?",
"@current_groups",
"||=",
"[",
"]",
"groups",
"=",
"@current_groups",
"&&",
"@current_groups",
".",
"last",
"||",
"[",
":default",
"]",
"groups",
".",
"each",
"do",
"|",
"group",
"|",
"opts",
"=",
"@plugin_options",
".",
"merge",
"(",
"group",
":",
"group",
")",
"# TODO: let plugins be added *after* evaluation",
"Guard",
".",
"state",
".",
"session",
".",
"plugins",
".",
"add",
"(",
"name",
",",
"opts",
")",
"end",
"@plugin_options",
"=",
"nil",
"end"
] |
Declares a Guard plugin to be used when running `guard start`.
The name parameter is usually the name of the gem without
the 'guard-' prefix.
The available options are different for each Guard implementation.
@example Declare a Guard without `watch` patterns
guard :rspec
@example Declare a Guard with a `watch` pattern
guard :rspec do
watch %r{.*_spec.rb}
end
@param [String] name the Guard plugin name
@param [Hash] options the options accepted by the Guard plugin
@yield a block where you can declare several watch patterns and actions
@see Plugin
@see Guard.add_plugin
@see #watch
@see #group
|
[
"Declares",
"a",
"Guard",
"plugin",
"to",
"be",
"used",
"when",
"running",
"guard",
"start",
"."
] |
e2508cd83badf0d537dbaba35d307adc35d92e4f
|
https://github.com/guard/guard/blob/e2508cd83badf0d537dbaba35d307adc35d92e4f/lib/guard/dsl.rb#L175-L189
|
11,337
|
guard/guard
|
lib/guard/dsl.rb
|
Guard.Dsl.watch
|
def watch(pattern, &action)
# Allow watches in the global scope (to execute arbitrary commands) by
# building a generic Guard::Plugin.
@plugin_options ||= nil
return guard(:plugin) { watch(pattern, &action) } unless @plugin_options
@plugin_options[:watchers] << Watcher.new(pattern, action)
end
|
ruby
|
def watch(pattern, &action)
# Allow watches in the global scope (to execute arbitrary commands) by
# building a generic Guard::Plugin.
@plugin_options ||= nil
return guard(:plugin) { watch(pattern, &action) } unless @plugin_options
@plugin_options[:watchers] << Watcher.new(pattern, action)
end
|
[
"def",
"watch",
"(",
"pattern",
",",
"&",
"action",
")",
"# Allow watches in the global scope (to execute arbitrary commands) by",
"# building a generic Guard::Plugin.",
"@plugin_options",
"||=",
"nil",
"return",
"guard",
"(",
":plugin",
")",
"{",
"watch",
"(",
"pattern",
",",
"action",
")",
"}",
"unless",
"@plugin_options",
"@plugin_options",
"[",
":watchers",
"]",
"<<",
"Watcher",
".",
"new",
"(",
"pattern",
",",
"action",
")",
"end"
] |
Defines a pattern to be watched in order to run actions on file
modification.
@example Declare watchers for a Guard
guard :rspec do
watch('spec/spec_helper.rb')
watch(%r{^.+_spec.rb})
watch(%r{^app/controllers/(.+).rb}) do |m|
'spec/acceptance/#{m[1]}s_spec.rb'
end
end
@example Declare global watchers outside of a Guard
watch(%r{^(.+)$}) { |m| puts "#{m[1]} changed." }
@param [String, Regexp] pattern the pattern that Guard must watch for
modification
@yield a block to be run when the pattern is matched
@yieldparam [MatchData] m matches of the pattern
@yieldreturn a directory, a filename, an array of
directories / filenames, or nothing (can be an arbitrary command)
@see Guard::Watcher
@see #guard
|
[
"Defines",
"a",
"pattern",
"to",
"be",
"watched",
"in",
"order",
"to",
"run",
"actions",
"on",
"file",
"modification",
"."
] |
e2508cd83badf0d537dbaba35d307adc35d92e4f
|
https://github.com/guard/guard/blob/e2508cd83badf0d537dbaba35d307adc35d92e4f/lib/guard/dsl.rb#L217-L224
|
11,338
|
guard/guard
|
lib/guard/dsl.rb
|
Guard.Dsl.callback
|
def callback(*args, &block)
@plugin_options ||= nil
fail "callback must be called within a guard block" unless @plugin_options
block, events = if args.size > 1
# block must be the first argument in that case, the
# yielded block is ignored
args
else
[block, args[0]]
end
@plugin_options[:callbacks] << { events: events, listener: block }
end
|
ruby
|
def callback(*args, &block)
@plugin_options ||= nil
fail "callback must be called within a guard block" unless @plugin_options
block, events = if args.size > 1
# block must be the first argument in that case, the
# yielded block is ignored
args
else
[block, args[0]]
end
@plugin_options[:callbacks] << { events: events, listener: block }
end
|
[
"def",
"callback",
"(",
"*",
"args",
",",
"&",
"block",
")",
"@plugin_options",
"||=",
"nil",
"fail",
"\"callback must be called within a guard block\"",
"unless",
"@plugin_options",
"block",
",",
"events",
"=",
"if",
"args",
".",
"size",
">",
"1",
"# block must be the first argument in that case, the",
"# yielded block is ignored",
"args",
"else",
"[",
"block",
",",
"args",
"[",
"0",
"]",
"]",
"end",
"@plugin_options",
"[",
":callbacks",
"]",
"<<",
"{",
"events",
":",
"events",
",",
"listener",
":",
"block",
"}",
"end"
] |
Defines a callback to execute arbitrary code before or after any of
the `start`, `stop`, `reload`, `run_all`, `run_on_changes`,
`run_on_additions`, `run_on_modifications` and `run_on_removals` plugin
method.
@example Add callback before the `reload` action.
callback(:reload_begin) { puts "Let's reload!" }
@example Add callback before the `start` and `stop` actions.
my_lambda = lambda do |plugin, event, *args|
puts "Let's #{event} #{plugin} with #{args}!"
end
callback(my_lambda, [:start_begin, :start_end])
@param [Array] args the callback arguments
@yield a callback block
|
[
"Defines",
"a",
"callback",
"to",
"execute",
"arbitrary",
"code",
"before",
"or",
"after",
"any",
"of",
"the",
"start",
"stop",
"reload",
"run_all",
"run_on_changes",
"run_on_additions",
"run_on_modifications",
"and",
"run_on_removals",
"plugin",
"method",
"."
] |
e2508cd83badf0d537dbaba35d307adc35d92e4f
|
https://github.com/guard/guard/blob/e2508cd83badf0d537dbaba35d307adc35d92e4f/lib/guard/dsl.rb#L245-L257
|
11,339
|
guard/guard
|
lib/guard/dsl.rb
|
Guard.Dsl.logger
|
def logger(options)
if options[:level]
options[:level] = options[:level].to_sym
unless [:debug, :info, :warn, :error].include? options[:level]
UI.warning(format(WARN_INVALID_LOG_LEVEL, options[:level]))
options.delete :level
end
end
if options[:only] && options[:except]
UI.warning WARN_INVALID_LOG_OPTIONS
options.delete :only
options.delete :except
end
# Convert the :only and :except options to a regular expression
[:only, :except].each do |name|
next unless options[name]
list = [].push(options[name]).flatten.map do |plugin|
Regexp.escape(plugin.to_s)
end
options[name] = Regexp.new(list.join("|"), Regexp::IGNORECASE)
end
UI.options = UI.options.merge(options)
end
|
ruby
|
def logger(options)
if options[:level]
options[:level] = options[:level].to_sym
unless [:debug, :info, :warn, :error].include? options[:level]
UI.warning(format(WARN_INVALID_LOG_LEVEL, options[:level]))
options.delete :level
end
end
if options[:only] && options[:except]
UI.warning WARN_INVALID_LOG_OPTIONS
options.delete :only
options.delete :except
end
# Convert the :only and :except options to a regular expression
[:only, :except].each do |name|
next unless options[name]
list = [].push(options[name]).flatten.map do |plugin|
Regexp.escape(plugin.to_s)
end
options[name] = Regexp.new(list.join("|"), Regexp::IGNORECASE)
end
UI.options = UI.options.merge(options)
end
|
[
"def",
"logger",
"(",
"options",
")",
"if",
"options",
"[",
":level",
"]",
"options",
"[",
":level",
"]",
"=",
"options",
"[",
":level",
"]",
".",
"to_sym",
"unless",
"[",
":debug",
",",
":info",
",",
":warn",
",",
":error",
"]",
".",
"include?",
"options",
"[",
":level",
"]",
"UI",
".",
"warning",
"(",
"format",
"(",
"WARN_INVALID_LOG_LEVEL",
",",
"options",
"[",
":level",
"]",
")",
")",
"options",
".",
"delete",
":level",
"end",
"end",
"if",
"options",
"[",
":only",
"]",
"&&",
"options",
"[",
":except",
"]",
"UI",
".",
"warning",
"WARN_INVALID_LOG_OPTIONS",
"options",
".",
"delete",
":only",
"options",
".",
"delete",
":except",
"end",
"# Convert the :only and :except options to a regular expression",
"[",
":only",
",",
":except",
"]",
".",
"each",
"do",
"|",
"name",
"|",
"next",
"unless",
"options",
"[",
"name",
"]",
"list",
"=",
"[",
"]",
".",
"push",
"(",
"options",
"[",
"name",
"]",
")",
".",
"flatten",
".",
"map",
"do",
"|",
"plugin",
"|",
"Regexp",
".",
"escape",
"(",
"plugin",
".",
"to_s",
")",
"end",
"options",
"[",
"name",
"]",
"=",
"Regexp",
".",
"new",
"(",
"list",
".",
"join",
"(",
"\"|\"",
")",
",",
"Regexp",
"::",
"IGNORECASE",
")",
"end",
"UI",
".",
"options",
"=",
"UI",
".",
"options",
".",
"merge",
"(",
"options",
")",
"end"
] |
Configures the Guard logger.
* Log level must be either `:debug`, `:info`, `:warn` or `:error`.
* Template supports the following placeholders: `:time`, `:severity`,
`:progname`, `:pid`, `:unit_of_work_id` and `:message`.
* Time format directives are the same as `Time#strftime` or
`:milliseconds`.
* The `:only` and `:except` options must be a `RegExp`.
@example Set the log level
logger level: :warn
@example Set a custom log template
logger template: '[Guard - :severity - :progname - :time] :message'
@example Set a custom time format
logger time_format: '%h'
@example Limit logging to a Guard plugin
logger only: :jasmine
@example Log all but not the messages from a specific Guard plugin
logger except: :jasmine
@param [Hash] options the log options
@option options [String, Symbol] level the log level
@option options [String] template the logger template
@option options [String, Symbol] time_format the time format
@option options [Regexp] only show only messages from the matching Guard
plugin
@option options [Regexp] except does not show messages from the matching
Guard plugin
|
[
"Configures",
"the",
"Guard",
"logger",
"."
] |
e2508cd83badf0d537dbaba35d307adc35d92e4f
|
https://github.com/guard/guard/blob/e2508cd83badf0d537dbaba35d307adc35d92e4f/lib/guard/dsl.rb#L324-L353
|
11,340
|
guard/guard
|
lib/guard/dsl.rb
|
Guard.Dsl.directories
|
def directories(directories)
directories.each do |dir|
fail "Directory #{dir.inspect} does not exist!" unless Dir.exist?(dir)
end
Guard.state.session.watchdirs = directories
end
|
ruby
|
def directories(directories)
directories.each do |dir|
fail "Directory #{dir.inspect} does not exist!" unless Dir.exist?(dir)
end
Guard.state.session.watchdirs = directories
end
|
[
"def",
"directories",
"(",
"directories",
")",
"directories",
".",
"each",
"do",
"|",
"dir",
"|",
"fail",
"\"Directory #{dir.inspect} does not exist!\"",
"unless",
"Dir",
".",
"exist?",
"(",
"dir",
")",
"end",
"Guard",
".",
"state",
".",
"session",
".",
"watchdirs",
"=",
"directories",
"end"
] |
Sets the directories to pass to Listen
@example watch only given directories
directories %w(lib specs)
@param [Array] directories directories for Listen to watch
|
[
"Sets",
"the",
"directories",
"to",
"pass",
"to",
"Listen"
] |
e2508cd83badf0d537dbaba35d307adc35d92e4f
|
https://github.com/guard/guard/blob/e2508cd83badf0d537dbaba35d307adc35d92e4f/lib/guard/dsl.rb#L393-L398
|
11,341
|
guard/guard
|
lib/guard/commander.rb
|
Guard.Commander.start
|
def start(options = {})
setup(options)
UI.debug "Guard starts all plugins"
Runner.new.run(:start)
listener.start
watched = Guard.state.session.watchdirs.join("', '")
UI.info "Guard is now watching at '#{ watched }'"
exitcode = 0
begin
while interactor.foreground != :exit
Guard.queue.process while Guard.queue.pending?
end
rescue Interrupt
rescue SystemExit => e
exitcode = e.status
end
exitcode
ensure
stop
end
|
ruby
|
def start(options = {})
setup(options)
UI.debug "Guard starts all plugins"
Runner.new.run(:start)
listener.start
watched = Guard.state.session.watchdirs.join("', '")
UI.info "Guard is now watching at '#{ watched }'"
exitcode = 0
begin
while interactor.foreground != :exit
Guard.queue.process while Guard.queue.pending?
end
rescue Interrupt
rescue SystemExit => e
exitcode = e.status
end
exitcode
ensure
stop
end
|
[
"def",
"start",
"(",
"options",
"=",
"{",
"}",
")",
"setup",
"(",
"options",
")",
"UI",
".",
"debug",
"\"Guard starts all plugins\"",
"Runner",
".",
"new",
".",
"run",
"(",
":start",
")",
"listener",
".",
"start",
"watched",
"=",
"Guard",
".",
"state",
".",
"session",
".",
"watchdirs",
".",
"join",
"(",
"\"', '\"",
")",
"UI",
".",
"info",
"\"Guard is now watching at '#{ watched }'\"",
"exitcode",
"=",
"0",
"begin",
"while",
"interactor",
".",
"foreground",
"!=",
":exit",
"Guard",
".",
"queue",
".",
"process",
"while",
"Guard",
".",
"queue",
".",
"pending?",
"end",
"rescue",
"Interrupt",
"rescue",
"SystemExit",
"=>",
"e",
"exitcode",
"=",
"e",
".",
"status",
"end",
"exitcode",
"ensure",
"stop",
"end"
] |
Start Guard by evaluating the `Guardfile`, initializing declared Guard
plugins and starting the available file change listener.
Main method for Guard that is called from the CLI when Guard starts.
- Setup Guard internals
- Evaluate the `Guardfile`
- Configure Notifiers
- Initialize the declared Guard plugins
- Start the available file change listener
@option options [Boolean] clear if auto clear the UI should be done
@option options [Boolean] notify if system notifications should be shown
@option options [Boolean] debug if debug output should be shown
@option options [Array<String>] group the list of groups to start
@option options [String] watchdir the director to watch
@option options [String] guardfile the path to the Guardfile
@see CLI#start
|
[
"Start",
"Guard",
"by",
"evaluating",
"the",
"Guardfile",
"initializing",
"declared",
"Guard",
"plugins",
"and",
"starting",
"the",
"available",
"file",
"change",
"listener",
".",
"Main",
"method",
"for",
"Guard",
"that",
"is",
"called",
"from",
"the",
"CLI",
"when",
"Guard",
"starts",
"."
] |
e2508cd83badf0d537dbaba35d307adc35d92e4f
|
https://github.com/guard/guard/blob/e2508cd83badf0d537dbaba35d307adc35d92e4f/lib/guard/commander.rb#L31-L53
|
11,342
|
guard/guard
|
lib/guard/commander.rb
|
Guard.Commander.run_all
|
def run_all(scopes = {})
UI.clear(force: true)
UI.action_with_scopes("Run", scopes)
Runner.new.run(:run_all, scopes)
end
|
ruby
|
def run_all(scopes = {})
UI.clear(force: true)
UI.action_with_scopes("Run", scopes)
Runner.new.run(:run_all, scopes)
end
|
[
"def",
"run_all",
"(",
"scopes",
"=",
"{",
"}",
")",
"UI",
".",
"clear",
"(",
"force",
":",
"true",
")",
"UI",
".",
"action_with_scopes",
"(",
"\"Run\"",
",",
"scopes",
")",
"Runner",
".",
"new",
".",
"run",
"(",
":run_all",
",",
"scopes",
")",
"end"
] |
Trigger `run_all` on all Guard plugins currently enabled.
@param [Hash] scopes hash with a Guard plugin or a group scope
|
[
"Trigger",
"run_all",
"on",
"all",
"Guard",
"plugins",
"currently",
"enabled",
"."
] |
e2508cd83badf0d537dbaba35d307adc35d92e4f
|
https://github.com/guard/guard/blob/e2508cd83badf0d537dbaba35d307adc35d92e4f/lib/guard/commander.rb#L80-L84
|
11,343
|
guard/guard
|
lib/guard/commander.rb
|
Guard.Commander.pause
|
def pause(expected = nil)
paused = listener.paused?
states = { paused: true, unpaused: false, toggle: !paused }
pause = states[expected || :toggle]
fail ArgumentError, "invalid mode: #{expected.inspect}" if pause.nil?
return if pause == paused
listener.public_send(pause ? :pause : :start)
UI.info "File event handling has been #{pause ? 'paused' : 'resumed'}"
end
|
ruby
|
def pause(expected = nil)
paused = listener.paused?
states = { paused: true, unpaused: false, toggle: !paused }
pause = states[expected || :toggle]
fail ArgumentError, "invalid mode: #{expected.inspect}" if pause.nil?
return if pause == paused
listener.public_send(pause ? :pause : :start)
UI.info "File event handling has been #{pause ? 'paused' : 'resumed'}"
end
|
[
"def",
"pause",
"(",
"expected",
"=",
"nil",
")",
"paused",
"=",
"listener",
".",
"paused?",
"states",
"=",
"{",
"paused",
":",
"true",
",",
"unpaused",
":",
"false",
",",
"toggle",
":",
"!",
"paused",
"}",
"pause",
"=",
"states",
"[",
"expected",
"||",
":toggle",
"]",
"fail",
"ArgumentError",
",",
"\"invalid mode: #{expected.inspect}\"",
"if",
"pause",
".",
"nil?",
"return",
"if",
"pause",
"==",
"paused",
"listener",
".",
"public_send",
"(",
"pause",
"?",
":pause",
":",
":start",
")",
"UI",
".",
"info",
"\"File event handling has been #{pause ? 'paused' : 'resumed'}\"",
"end"
] |
Pause Guard listening to file changes.
|
[
"Pause",
"Guard",
"listening",
"to",
"file",
"changes",
"."
] |
e2508cd83badf0d537dbaba35d307adc35d92e4f
|
https://github.com/guard/guard/blob/e2508cd83badf0d537dbaba35d307adc35d92e4f/lib/guard/commander.rb#L88-L97
|
11,344
|
guard/guard
|
lib/guard/dsl_describer.rb
|
Guard.DslDescriber.show
|
def show
# collect metadata
groups = Guard.state.session.groups.all
objects = []
empty_plugin = OpenStruct.new
empty_plugin.options = [["", nil]]
groups.each do |group|
plugins = Array(Guard.state.session.plugins.all(group: group.name))
plugins = [empty_plugin] if plugins.empty?
plugins.each do |plugin|
options = plugin.options
options = [["", nil]] if options.empty?
options.each do |option, raw_value|
value = raw_value.nil? ? "" : raw_value.inspect
objects << [group.title, plugin.title, option.to_s, value]
end
end
end
# presentation
rows = []
prev_group = prev_plugin = prev_option = prev_value = nil
objects.each do |group, plugin, option, value|
group_changed = prev_group != group
plugin_changed = (prev_plugin != plugin || group_changed)
rows << :split if group_changed || plugin_changed
rows << {
Group: group_changed ? group : "",
Plugin: plugin_changed ? plugin : "",
Option: option,
Value: value
}
prev_group = group
prev_plugin = plugin
prev_option = option
prev_value = value
end
# render
Formatador.display_compact_table(
rows.drop(1),
[:Group, :Plugin, :Option, :Value]
)
end
|
ruby
|
def show
# collect metadata
groups = Guard.state.session.groups.all
objects = []
empty_plugin = OpenStruct.new
empty_plugin.options = [["", nil]]
groups.each do |group|
plugins = Array(Guard.state.session.plugins.all(group: group.name))
plugins = [empty_plugin] if plugins.empty?
plugins.each do |plugin|
options = plugin.options
options = [["", nil]] if options.empty?
options.each do |option, raw_value|
value = raw_value.nil? ? "" : raw_value.inspect
objects << [group.title, plugin.title, option.to_s, value]
end
end
end
# presentation
rows = []
prev_group = prev_plugin = prev_option = prev_value = nil
objects.each do |group, plugin, option, value|
group_changed = prev_group != group
plugin_changed = (prev_plugin != plugin || group_changed)
rows << :split if group_changed || plugin_changed
rows << {
Group: group_changed ? group : "",
Plugin: plugin_changed ? plugin : "",
Option: option,
Value: value
}
prev_group = group
prev_plugin = plugin
prev_option = option
prev_value = value
end
# render
Formatador.display_compact_table(
rows.drop(1),
[:Group, :Plugin, :Option, :Value]
)
end
|
[
"def",
"show",
"# collect metadata",
"groups",
"=",
"Guard",
".",
"state",
".",
"session",
".",
"groups",
".",
"all",
"objects",
"=",
"[",
"]",
"empty_plugin",
"=",
"OpenStruct",
".",
"new",
"empty_plugin",
".",
"options",
"=",
"[",
"[",
"\"\"",
",",
"nil",
"]",
"]",
"groups",
".",
"each",
"do",
"|",
"group",
"|",
"plugins",
"=",
"Array",
"(",
"Guard",
".",
"state",
".",
"session",
".",
"plugins",
".",
"all",
"(",
"group",
":",
"group",
".",
"name",
")",
")",
"plugins",
"=",
"[",
"empty_plugin",
"]",
"if",
"plugins",
".",
"empty?",
"plugins",
".",
"each",
"do",
"|",
"plugin",
"|",
"options",
"=",
"plugin",
".",
"options",
"options",
"=",
"[",
"[",
"\"\"",
",",
"nil",
"]",
"]",
"if",
"options",
".",
"empty?",
"options",
".",
"each",
"do",
"|",
"option",
",",
"raw_value",
"|",
"value",
"=",
"raw_value",
".",
"nil?",
"?",
"\"\"",
":",
"raw_value",
".",
"inspect",
"objects",
"<<",
"[",
"group",
".",
"title",
",",
"plugin",
".",
"title",
",",
"option",
".",
"to_s",
",",
"value",
"]",
"end",
"end",
"end",
"# presentation",
"rows",
"=",
"[",
"]",
"prev_group",
"=",
"prev_plugin",
"=",
"prev_option",
"=",
"prev_value",
"=",
"nil",
"objects",
".",
"each",
"do",
"|",
"group",
",",
"plugin",
",",
"option",
",",
"value",
"|",
"group_changed",
"=",
"prev_group",
"!=",
"group",
"plugin_changed",
"=",
"(",
"prev_plugin",
"!=",
"plugin",
"||",
"group_changed",
")",
"rows",
"<<",
":split",
"if",
"group_changed",
"||",
"plugin_changed",
"rows",
"<<",
"{",
"Group",
":",
"group_changed",
"?",
"group",
":",
"\"\"",
",",
"Plugin",
":",
"plugin_changed",
"?",
"plugin",
":",
"\"\"",
",",
"Option",
":",
"option",
",",
"Value",
":",
"value",
"}",
"prev_group",
"=",
"group",
"prev_plugin",
"=",
"plugin",
"prev_option",
"=",
"option",
"prev_value",
"=",
"value",
"end",
"# render",
"Formatador",
".",
"display_compact_table",
"(",
"rows",
".",
"drop",
"(",
"1",
")",
",",
"[",
":Group",
",",
":Plugin",
",",
":Option",
",",
":Value",
"]",
")",
"end"
] |
Shows all Guard plugins and their options that are defined in
the `Guardfile`.
@see CLI#show
|
[
"Shows",
"all",
"Guard",
"plugins",
"and",
"their",
"options",
"that",
"are",
"defined",
"in",
"the",
"Guardfile",
"."
] |
e2508cd83badf0d537dbaba35d307adc35d92e4f
|
https://github.com/guard/guard/blob/e2508cd83badf0d537dbaba35d307adc35d92e4f/lib/guard/dsl_describer.rb#L53-L102
|
11,345
|
guard/guard
|
lib/guard/dsl_describer.rb
|
Guard.DslDescriber.notifiers
|
def notifiers
supported = Notifier.supported
Notifier.connect(notify: true, silent: true)
detected = Notifier.detected
Notifier.disconnect
detected_names = detected.map { |item| item[:name] }
final_rows = supported.each_with_object([]) do |(name, _), rows|
available = detected_names.include?(name) ? "✔" : "✘"
notifier = detected.detect { |n| n[:name] == name }
used = notifier ? "✔" : "✘"
options = notifier ? notifier[:options] : {}
if options.empty?
rows << :split
_add_row(rows, name, available, used, "", "")
else
options.each_with_index do |(option, value), index|
if index == 0
rows << :split
_add_row(rows, name, available, used, option.to_s, value.inspect)
else
_add_row(rows, "", "", "", option.to_s, value.inspect)
end
end
end
rows
end
Formatador.display_compact_table(
final_rows.drop(1),
[:Name, :Available, :Used, :Option, :Value]
)
end
|
ruby
|
def notifiers
supported = Notifier.supported
Notifier.connect(notify: true, silent: true)
detected = Notifier.detected
Notifier.disconnect
detected_names = detected.map { |item| item[:name] }
final_rows = supported.each_with_object([]) do |(name, _), rows|
available = detected_names.include?(name) ? "✔" : "✘"
notifier = detected.detect { |n| n[:name] == name }
used = notifier ? "✔" : "✘"
options = notifier ? notifier[:options] : {}
if options.empty?
rows << :split
_add_row(rows, name, available, used, "", "")
else
options.each_with_index do |(option, value), index|
if index == 0
rows << :split
_add_row(rows, name, available, used, option.to_s, value.inspect)
else
_add_row(rows, "", "", "", option.to_s, value.inspect)
end
end
end
rows
end
Formatador.display_compact_table(
final_rows.drop(1),
[:Name, :Available, :Used, :Option, :Value]
)
end
|
[
"def",
"notifiers",
"supported",
"=",
"Notifier",
".",
"supported",
"Notifier",
".",
"connect",
"(",
"notify",
":",
"true",
",",
"silent",
":",
"true",
")",
"detected",
"=",
"Notifier",
".",
"detected",
"Notifier",
".",
"disconnect",
"detected_names",
"=",
"detected",
".",
"map",
"{",
"|",
"item",
"|",
"item",
"[",
":name",
"]",
"}",
"final_rows",
"=",
"supported",
".",
"each_with_object",
"(",
"[",
"]",
")",
"do",
"|",
"(",
"name",
",",
"_",
")",
",",
"rows",
"|",
"available",
"=",
"detected_names",
".",
"include?",
"(",
"name",
")",
"?",
"\"✔\" :",
"\"",
"\"",
"notifier",
"=",
"detected",
".",
"detect",
"{",
"|",
"n",
"|",
"n",
"[",
":name",
"]",
"==",
"name",
"}",
"used",
"=",
"notifier",
"?",
"\"✔\" :",
"\"",
"\"",
"options",
"=",
"notifier",
"?",
"notifier",
"[",
":options",
"]",
":",
"{",
"}",
"if",
"options",
".",
"empty?",
"rows",
"<<",
":split",
"_add_row",
"(",
"rows",
",",
"name",
",",
"available",
",",
"used",
",",
"\"\"",
",",
"\"\"",
")",
"else",
"options",
".",
"each_with_index",
"do",
"|",
"(",
"option",
",",
"value",
")",
",",
"index",
"|",
"if",
"index",
"==",
"0",
"rows",
"<<",
":split",
"_add_row",
"(",
"rows",
",",
"name",
",",
"available",
",",
"used",
",",
"option",
".",
"to_s",
",",
"value",
".",
"inspect",
")",
"else",
"_add_row",
"(",
"rows",
",",
"\"\"",
",",
"\"\"",
",",
"\"\"",
",",
"option",
".",
"to_s",
",",
"value",
".",
"inspect",
")",
"end",
"end",
"end",
"rows",
"end",
"Formatador",
".",
"display_compact_table",
"(",
"final_rows",
".",
"drop",
"(",
"1",
")",
",",
"[",
":Name",
",",
":Available",
",",
":Used",
",",
":Option",
",",
":Value",
"]",
")",
"end"
] |
Shows all notifiers and their options that are defined in
the `Guardfile`.
@see CLI#show
|
[
"Shows",
"all",
"notifiers",
"and",
"their",
"options",
"that",
"are",
"defined",
"in",
"the",
"Guardfile",
"."
] |
e2508cd83badf0d537dbaba35d307adc35d92e4f
|
https://github.com/guard/guard/blob/e2508cd83badf0d537dbaba35d307adc35d92e4f/lib/guard/dsl_describer.rb#L109-L146
|
11,346
|
guard/guard
|
lib/guard/runner.rb
|
Guard.Runner.run
|
def run(task, scope_hash = {})
Lumberjack.unit_of_work do
items = Guard.state.scope.grouped_plugins(scope_hash || {})
items.each do |_group, plugins|
_run_group_plugins(plugins) do |plugin|
_supervise(plugin, task) if plugin.respond_to?(task)
end
end
end
end
|
ruby
|
def run(task, scope_hash = {})
Lumberjack.unit_of_work do
items = Guard.state.scope.grouped_plugins(scope_hash || {})
items.each do |_group, plugins|
_run_group_plugins(plugins) do |plugin|
_supervise(plugin, task) if plugin.respond_to?(task)
end
end
end
end
|
[
"def",
"run",
"(",
"task",
",",
"scope_hash",
"=",
"{",
"}",
")",
"Lumberjack",
".",
"unit_of_work",
"do",
"items",
"=",
"Guard",
".",
"state",
".",
"scope",
".",
"grouped_plugins",
"(",
"scope_hash",
"||",
"{",
"}",
")",
"items",
".",
"each",
"do",
"|",
"_group",
",",
"plugins",
"|",
"_run_group_plugins",
"(",
"plugins",
")",
"do",
"|",
"plugin",
"|",
"_supervise",
"(",
"plugin",
",",
"task",
")",
"if",
"plugin",
".",
"respond_to?",
"(",
"task",
")",
"end",
"end",
"end",
"end"
] |
Runs a Guard-task on all registered plugins.
@param [Symbol] task the task to run
@param [Hash] scope_hash either the Guard plugin or the group to run the task
on
|
[
"Runs",
"a",
"Guard",
"-",
"task",
"on",
"all",
"registered",
"plugins",
"."
] |
e2508cd83badf0d537dbaba35d307adc35d92e4f
|
https://github.com/guard/guard/blob/e2508cd83badf0d537dbaba35d307adc35d92e4f/lib/guard/runner.rb#L17-L26
|
11,347
|
guard/guard
|
lib/guard/runner.rb
|
Guard.Runner.run_on_changes
|
def run_on_changes(modified, added, removed)
types = {
MODIFICATION_TASKS => modified,
ADDITION_TASKS => added,
REMOVAL_TASKS => removed
}
UI.clearable
Guard.state.scope.grouped_plugins.each do |_group, plugins|
_run_group_plugins(plugins) do |plugin|
UI.clear
types.each do |tasks, unmatched_paths|
next if unmatched_paths.empty?
match_result = Watcher.match_files(plugin, unmatched_paths)
next if match_result.empty?
task = tasks.detect { |meth| plugin.respond_to?(meth) }
_supervise(plugin, task, match_result) if task
end
end
end
end
|
ruby
|
def run_on_changes(modified, added, removed)
types = {
MODIFICATION_TASKS => modified,
ADDITION_TASKS => added,
REMOVAL_TASKS => removed
}
UI.clearable
Guard.state.scope.grouped_plugins.each do |_group, plugins|
_run_group_plugins(plugins) do |plugin|
UI.clear
types.each do |tasks, unmatched_paths|
next if unmatched_paths.empty?
match_result = Watcher.match_files(plugin, unmatched_paths)
next if match_result.empty?
task = tasks.detect { |meth| plugin.respond_to?(meth) }
_supervise(plugin, task, match_result) if task
end
end
end
end
|
[
"def",
"run_on_changes",
"(",
"modified",
",",
"added",
",",
"removed",
")",
"types",
"=",
"{",
"MODIFICATION_TASKS",
"=>",
"modified",
",",
"ADDITION_TASKS",
"=>",
"added",
",",
"REMOVAL_TASKS",
"=>",
"removed",
"}",
"UI",
".",
"clearable",
"Guard",
".",
"state",
".",
"scope",
".",
"grouped_plugins",
".",
"each",
"do",
"|",
"_group",
",",
"plugins",
"|",
"_run_group_plugins",
"(",
"plugins",
")",
"do",
"|",
"plugin",
"|",
"UI",
".",
"clear",
"types",
".",
"each",
"do",
"|",
"tasks",
",",
"unmatched_paths",
"|",
"next",
"if",
"unmatched_paths",
".",
"empty?",
"match_result",
"=",
"Watcher",
".",
"match_files",
"(",
"plugin",
",",
"unmatched_paths",
")",
"next",
"if",
"match_result",
".",
"empty?",
"task",
"=",
"tasks",
".",
"detect",
"{",
"|",
"meth",
"|",
"plugin",
".",
"respond_to?",
"(",
"meth",
")",
"}",
"_supervise",
"(",
"plugin",
",",
"task",
",",
"match_result",
")",
"if",
"task",
"end",
"end",
"end",
"end"
] |
Runs the appropriate tasks on all registered plugins
based on the passed changes.
@param [Array<String>] modified the modified paths.
@param [Array<String>] added the added paths.
@param [Array<String>] removed the removed paths.
|
[
"Runs",
"the",
"appropriate",
"tasks",
"on",
"all",
"registered",
"plugins",
"based",
"on",
"the",
"passed",
"changes",
"."
] |
e2508cd83badf0d537dbaba35d307adc35d92e4f
|
https://github.com/guard/guard/blob/e2508cd83badf0d537dbaba35d307adc35d92e4f/lib/guard/runner.rb#L44-L65
|
11,348
|
guard/guard
|
lib/guard/runner.rb
|
Guard.Runner._supervise
|
def _supervise(plugin, task, *args)
catch self.class.stopping_symbol_for(plugin) do
plugin.hook("#{ task }_begin", *args)
result = UI.options.with_progname(plugin.class.name) do
begin
plugin.send(task, *args)
rescue Interrupt
throw(:task_has_failed)
end
end
plugin.hook("#{ task }_end", result)
result
end
rescue ScriptError, StandardError, RuntimeError
UI.error("#{ plugin.class.name } failed to achieve its"\
" <#{ task }>, exception was:" \
"\n#{ $!.class }: #{ $!.message }" \
"\n#{ $!.backtrace.join("\n") }")
Guard.state.session.plugins.remove(plugin)
UI.info("\n#{ plugin.class.name } has just been fired")
$!
end
|
ruby
|
def _supervise(plugin, task, *args)
catch self.class.stopping_symbol_for(plugin) do
plugin.hook("#{ task }_begin", *args)
result = UI.options.with_progname(plugin.class.name) do
begin
plugin.send(task, *args)
rescue Interrupt
throw(:task_has_failed)
end
end
plugin.hook("#{ task }_end", result)
result
end
rescue ScriptError, StandardError, RuntimeError
UI.error("#{ plugin.class.name } failed to achieve its"\
" <#{ task }>, exception was:" \
"\n#{ $!.class }: #{ $!.message }" \
"\n#{ $!.backtrace.join("\n") }")
Guard.state.session.plugins.remove(plugin)
UI.info("\n#{ plugin.class.name } has just been fired")
$!
end
|
[
"def",
"_supervise",
"(",
"plugin",
",",
"task",
",",
"*",
"args",
")",
"catch",
"self",
".",
"class",
".",
"stopping_symbol_for",
"(",
"plugin",
")",
"do",
"plugin",
".",
"hook",
"(",
"\"#{ task }_begin\"",
",",
"args",
")",
"result",
"=",
"UI",
".",
"options",
".",
"with_progname",
"(",
"plugin",
".",
"class",
".",
"name",
")",
"do",
"begin",
"plugin",
".",
"send",
"(",
"task",
",",
"args",
")",
"rescue",
"Interrupt",
"throw",
"(",
":task_has_failed",
")",
"end",
"end",
"plugin",
".",
"hook",
"(",
"\"#{ task }_end\"",
",",
"result",
")",
"result",
"end",
"rescue",
"ScriptError",
",",
"StandardError",
",",
"RuntimeError",
"UI",
".",
"error",
"(",
"\"#{ plugin.class.name } failed to achieve its\"",
"\" <#{ task }>, exception was:\"",
"\"\\n#{ $!.class }: #{ $!.message }\"",
"\"\\n#{ $!.backtrace.join(\"\\n\") }\"",
")",
"Guard",
".",
"state",
".",
"session",
".",
"plugins",
".",
"remove",
"(",
"plugin",
")",
"UI",
".",
"info",
"(",
"\"\\n#{ plugin.class.name } has just been fired\"",
")",
"$!",
"end"
] |
Run a Guard plugin task, but remove the Guard plugin when his work leads
to a system failure.
When the Group has `:halt_on_fail` disabled, we've to catch
`:task_has_failed` here in order to avoid an uncaught throw error.
@param [Guard::Plugin] plugin guard the Guard to execute
@param [Symbol] task the task to run
@param [Array] args the arguments for the task
@raise [:task_has_failed] when task has failed
|
[
"Run",
"a",
"Guard",
"plugin",
"task",
"but",
"remove",
"the",
"Guard",
"plugin",
"when",
"his",
"work",
"leads",
"to",
"a",
"system",
"failure",
"."
] |
e2508cd83badf0d537dbaba35d307adc35d92e4f
|
https://github.com/guard/guard/blob/e2508cd83badf0d537dbaba35d307adc35d92e4f/lib/guard/runner.rb#L78-L99
|
11,349
|
httprb/http
|
lib/http/response.rb
|
HTTP.Response.content_length
|
def content_length
# http://greenbytes.de/tech/webdav/rfc7230.html#rfc.section.3.3.3
# Clause 3: "If a message is received with both a Transfer-Encoding
# and a Content-Length header field, the Transfer-Encoding overrides the Content-Length.
return nil if @headers.include?(Headers::TRANSFER_ENCODING)
value = @headers[Headers::CONTENT_LENGTH]
return nil unless value
begin
Integer(value)
rescue ArgumentError
nil
end
end
|
ruby
|
def content_length
# http://greenbytes.de/tech/webdav/rfc7230.html#rfc.section.3.3.3
# Clause 3: "If a message is received with both a Transfer-Encoding
# and a Content-Length header field, the Transfer-Encoding overrides the Content-Length.
return nil if @headers.include?(Headers::TRANSFER_ENCODING)
value = @headers[Headers::CONTENT_LENGTH]
return nil unless value
begin
Integer(value)
rescue ArgumentError
nil
end
end
|
[
"def",
"content_length",
"# http://greenbytes.de/tech/webdav/rfc7230.html#rfc.section.3.3.3",
"# Clause 3: \"If a message is received with both a Transfer-Encoding",
"# and a Content-Length header field, the Transfer-Encoding overrides the Content-Length.",
"return",
"nil",
"if",
"@headers",
".",
"include?",
"(",
"Headers",
"::",
"TRANSFER_ENCODING",
")",
"value",
"=",
"@headers",
"[",
"Headers",
"::",
"CONTENT_LENGTH",
"]",
"return",
"nil",
"unless",
"value",
"begin",
"Integer",
"(",
"value",
")",
"rescue",
"ArgumentError",
"nil",
"end",
"end"
] |
Value of the Content-Length header.
@return [nil] if Content-Length was not given, or it's value was invalid
(not an integer, e.g. empty string or string with non-digits).
@return [Integer] otherwise
|
[
"Value",
"of",
"the",
"Content",
"-",
"Length",
"header",
"."
] |
f37a10ea4fab3ee411907ea2e4251ddf0ca33a93
|
https://github.com/httprb/http/blob/f37a10ea4fab3ee411907ea2e4251ddf0ca33a93/lib/http/response.rb#L103-L117
|
11,350
|
httprb/http
|
lib/http/connection.rb
|
HTTP.Connection.readpartial
|
def readpartial(size = BUFFER_SIZE)
return unless @pending_response
chunk = @parser.read(size)
return chunk if chunk
finished = (read_more(size) == :eof) || @parser.finished?
chunk = @parser.read(size)
finish_response if finished
chunk.to_s
end
|
ruby
|
def readpartial(size = BUFFER_SIZE)
return unless @pending_response
chunk = @parser.read(size)
return chunk if chunk
finished = (read_more(size) == :eof) || @parser.finished?
chunk = @parser.read(size)
finish_response if finished
chunk.to_s
end
|
[
"def",
"readpartial",
"(",
"size",
"=",
"BUFFER_SIZE",
")",
"return",
"unless",
"@pending_response",
"chunk",
"=",
"@parser",
".",
"read",
"(",
"size",
")",
"return",
"chunk",
"if",
"chunk",
"finished",
"=",
"(",
"read_more",
"(",
"size",
")",
"==",
":eof",
")",
"||",
"@parser",
".",
"finished?",
"chunk",
"=",
"@parser",
".",
"read",
"(",
"size",
")",
"finish_response",
"if",
"finished",
"chunk",
".",
"to_s",
"end"
] |
Read a chunk of the body
@return [String] data chunk
@return [nil] when no more data left
|
[
"Read",
"a",
"chunk",
"of",
"the",
"body"
] |
f37a10ea4fab3ee411907ea2e4251ddf0ca33a93
|
https://github.com/httprb/http/blob/f37a10ea4fab3ee411907ea2e4251ddf0ca33a93/lib/http/connection.rb#L86-L97
|
11,351
|
httprb/http
|
lib/http/connection.rb
|
HTTP.Connection.start_tls
|
def start_tls(req, options)
return unless req.uri.https? && !failed_proxy_connect?
ssl_context = options.ssl_context
unless ssl_context
ssl_context = OpenSSL::SSL::SSLContext.new
ssl_context.set_params(options.ssl || {})
end
@socket.start_tls(req.uri.host, options.ssl_socket_class, ssl_context)
end
|
ruby
|
def start_tls(req, options)
return unless req.uri.https? && !failed_proxy_connect?
ssl_context = options.ssl_context
unless ssl_context
ssl_context = OpenSSL::SSL::SSLContext.new
ssl_context.set_params(options.ssl || {})
end
@socket.start_tls(req.uri.host, options.ssl_socket_class, ssl_context)
end
|
[
"def",
"start_tls",
"(",
"req",
",",
"options",
")",
"return",
"unless",
"req",
".",
"uri",
".",
"https?",
"&&",
"!",
"failed_proxy_connect?",
"ssl_context",
"=",
"options",
".",
"ssl_context",
"unless",
"ssl_context",
"ssl_context",
"=",
"OpenSSL",
"::",
"SSL",
"::",
"SSLContext",
".",
"new",
"ssl_context",
".",
"set_params",
"(",
"options",
".",
"ssl",
"||",
"{",
"}",
")",
"end",
"@socket",
".",
"start_tls",
"(",
"req",
".",
"uri",
".",
"host",
",",
"options",
".",
"ssl_socket_class",
",",
"ssl_context",
")",
"end"
] |
Sets up SSL context and starts TLS if needed.
@param (see #initialize)
@return [void]
|
[
"Sets",
"up",
"SSL",
"context",
"and",
"starts",
"TLS",
"if",
"needed",
"."
] |
f37a10ea4fab3ee411907ea2e4251ddf0ca33a93
|
https://github.com/httprb/http/blob/f37a10ea4fab3ee411907ea2e4251ddf0ca33a93/lib/http/connection.rb#L148-L159
|
11,352
|
httprb/http
|
lib/http/connection.rb
|
HTTP.Connection.send_proxy_connect_request
|
def send_proxy_connect_request(req)
return unless req.uri.https? && req.using_proxy?
@pending_request = true
req.connect_using_proxy @socket
@pending_request = false
@pending_response = true
read_headers!
@proxy_response_headers = @parser.headers
if @parser.status_code != 200
@failed_proxy_connect = true
return
end
@parser.reset
@pending_response = false
end
|
ruby
|
def send_proxy_connect_request(req)
return unless req.uri.https? && req.using_proxy?
@pending_request = true
req.connect_using_proxy @socket
@pending_request = false
@pending_response = true
read_headers!
@proxy_response_headers = @parser.headers
if @parser.status_code != 200
@failed_proxy_connect = true
return
end
@parser.reset
@pending_response = false
end
|
[
"def",
"send_proxy_connect_request",
"(",
"req",
")",
"return",
"unless",
"req",
".",
"uri",
".",
"https?",
"&&",
"req",
".",
"using_proxy?",
"@pending_request",
"=",
"true",
"req",
".",
"connect_using_proxy",
"@socket",
"@pending_request",
"=",
"false",
"@pending_response",
"=",
"true",
"read_headers!",
"@proxy_response_headers",
"=",
"@parser",
".",
"headers",
"if",
"@parser",
".",
"status_code",
"!=",
"200",
"@failed_proxy_connect",
"=",
"true",
"return",
"end",
"@parser",
".",
"reset",
"@pending_response",
"=",
"false",
"end"
] |
Open tunnel through proxy
|
[
"Open",
"tunnel",
"through",
"proxy"
] |
f37a10ea4fab3ee411907ea2e4251ddf0ca33a93
|
https://github.com/httprb/http/blob/f37a10ea4fab3ee411907ea2e4251ddf0ca33a93/lib/http/connection.rb#L162-L182
|
11,353
|
httprb/http
|
lib/http/connection.rb
|
HTTP.Connection.set_keep_alive
|
def set_keep_alive
return @keep_alive = false unless @persistent
@keep_alive =
case @parser.http_version
when HTTP_1_0 # HTTP/1.0 requires opt in for Keep Alive
@parser.headers[Headers::CONNECTION] == KEEP_ALIVE
when HTTP_1_1 # HTTP/1.1 is opt-out
@parser.headers[Headers::CONNECTION] != CLOSE
else # Anything else we assume doesn't supportit
false
end
end
|
ruby
|
def set_keep_alive
return @keep_alive = false unless @persistent
@keep_alive =
case @parser.http_version
when HTTP_1_0 # HTTP/1.0 requires opt in for Keep Alive
@parser.headers[Headers::CONNECTION] == KEEP_ALIVE
when HTTP_1_1 # HTTP/1.1 is opt-out
@parser.headers[Headers::CONNECTION] != CLOSE
else # Anything else we assume doesn't supportit
false
end
end
|
[
"def",
"set_keep_alive",
"return",
"@keep_alive",
"=",
"false",
"unless",
"@persistent",
"@keep_alive",
"=",
"case",
"@parser",
".",
"http_version",
"when",
"HTTP_1_0",
"# HTTP/1.0 requires opt in for Keep Alive",
"@parser",
".",
"headers",
"[",
"Headers",
"::",
"CONNECTION",
"]",
"==",
"KEEP_ALIVE",
"when",
"HTTP_1_1",
"# HTTP/1.1 is opt-out",
"@parser",
".",
"headers",
"[",
"Headers",
"::",
"CONNECTION",
"]",
"!=",
"CLOSE",
"else",
"# Anything else we assume doesn't supportit",
"false",
"end",
"end"
] |
Store whether the connection should be kept alive.
Once we reset the parser, we lose all of this state.
@return [void]
|
[
"Store",
"whether",
"the",
"connection",
"should",
"be",
"kept",
"alive",
".",
"Once",
"we",
"reset",
"the",
"parser",
"we",
"lose",
"all",
"of",
"this",
"state",
"."
] |
f37a10ea4fab3ee411907ea2e4251ddf0ca33a93
|
https://github.com/httprb/http/blob/f37a10ea4fab3ee411907ea2e4251ddf0ca33a93/lib/http/connection.rb#L193-L205
|
11,354
|
httprb/http
|
lib/http/connection.rb
|
HTTP.Connection.read_more
|
def read_more(size)
return if @parser.finished?
value = @socket.readpartial(size, @buffer)
if value == :eof
@parser << ""
:eof
elsif value
@parser << value
end
rescue IOError, SocketError, SystemCallError => ex
raise ConnectionError, "error reading from socket: #{ex}", ex.backtrace
end
|
ruby
|
def read_more(size)
return if @parser.finished?
value = @socket.readpartial(size, @buffer)
if value == :eof
@parser << ""
:eof
elsif value
@parser << value
end
rescue IOError, SocketError, SystemCallError => ex
raise ConnectionError, "error reading from socket: #{ex}", ex.backtrace
end
|
[
"def",
"read_more",
"(",
"size",
")",
"return",
"if",
"@parser",
".",
"finished?",
"value",
"=",
"@socket",
".",
"readpartial",
"(",
"size",
",",
"@buffer",
")",
"if",
"value",
"==",
":eof",
"@parser",
"<<",
"\"\"",
":eof",
"elsif",
"value",
"@parser",
"<<",
"value",
"end",
"rescue",
"IOError",
",",
"SocketError",
",",
"SystemCallError",
"=>",
"ex",
"raise",
"ConnectionError",
",",
"\"error reading from socket: #{ex}\"",
",",
"ex",
".",
"backtrace",
"end"
] |
Feeds some more data into parser
@return [void]
|
[
"Feeds",
"some",
"more",
"data",
"into",
"parser"
] |
f37a10ea4fab3ee411907ea2e4251ddf0ca33a93
|
https://github.com/httprb/http/blob/f37a10ea4fab3ee411907ea2e4251ddf0ca33a93/lib/http/connection.rb#L209-L221
|
11,355
|
httprb/http
|
lib/http/chainable.rb
|
HTTP.Chainable.via
|
def via(*proxy)
proxy_hash = {}
proxy_hash[:proxy_address] = proxy[0] if proxy[0].is_a?(String)
proxy_hash[:proxy_port] = proxy[1] if proxy[1].is_a?(Integer)
proxy_hash[:proxy_username] = proxy[2] if proxy[2].is_a?(String)
proxy_hash[:proxy_password] = proxy[3] if proxy[3].is_a?(String)
proxy_hash[:proxy_headers] = proxy[2] if proxy[2].is_a?(Hash)
proxy_hash[:proxy_headers] = proxy[4] if proxy[4].is_a?(Hash)
raise(RequestError, "invalid HTTP proxy: #{proxy_hash}") unless (2..5).cover?(proxy_hash.keys.size)
branch default_options.with_proxy(proxy_hash)
end
|
ruby
|
def via(*proxy)
proxy_hash = {}
proxy_hash[:proxy_address] = proxy[0] if proxy[0].is_a?(String)
proxy_hash[:proxy_port] = proxy[1] if proxy[1].is_a?(Integer)
proxy_hash[:proxy_username] = proxy[2] if proxy[2].is_a?(String)
proxy_hash[:proxy_password] = proxy[3] if proxy[3].is_a?(String)
proxy_hash[:proxy_headers] = proxy[2] if proxy[2].is_a?(Hash)
proxy_hash[:proxy_headers] = proxy[4] if proxy[4].is_a?(Hash)
raise(RequestError, "invalid HTTP proxy: #{proxy_hash}") unless (2..5).cover?(proxy_hash.keys.size)
branch default_options.with_proxy(proxy_hash)
end
|
[
"def",
"via",
"(",
"*",
"proxy",
")",
"proxy_hash",
"=",
"{",
"}",
"proxy_hash",
"[",
":proxy_address",
"]",
"=",
"proxy",
"[",
"0",
"]",
"if",
"proxy",
"[",
"0",
"]",
".",
"is_a?",
"(",
"String",
")",
"proxy_hash",
"[",
":proxy_port",
"]",
"=",
"proxy",
"[",
"1",
"]",
"if",
"proxy",
"[",
"1",
"]",
".",
"is_a?",
"(",
"Integer",
")",
"proxy_hash",
"[",
":proxy_username",
"]",
"=",
"proxy",
"[",
"2",
"]",
"if",
"proxy",
"[",
"2",
"]",
".",
"is_a?",
"(",
"String",
")",
"proxy_hash",
"[",
":proxy_password",
"]",
"=",
"proxy",
"[",
"3",
"]",
"if",
"proxy",
"[",
"3",
"]",
".",
"is_a?",
"(",
"String",
")",
"proxy_hash",
"[",
":proxy_headers",
"]",
"=",
"proxy",
"[",
"2",
"]",
"if",
"proxy",
"[",
"2",
"]",
".",
"is_a?",
"(",
"Hash",
")",
"proxy_hash",
"[",
":proxy_headers",
"]",
"=",
"proxy",
"[",
"4",
"]",
"if",
"proxy",
"[",
"4",
"]",
".",
"is_a?",
"(",
"Hash",
")",
"raise",
"(",
"RequestError",
",",
"\"invalid HTTP proxy: #{proxy_hash}\"",
")",
"unless",
"(",
"2",
"..",
"5",
")",
".",
"cover?",
"(",
"proxy_hash",
".",
"keys",
".",
"size",
")",
"branch",
"default_options",
".",
"with_proxy",
"(",
"proxy_hash",
")",
"end"
] |
Make a request through an HTTP proxy
@param [Array] proxy
@raise [Request::Error] if HTTP proxy is invalid
|
[
"Make",
"a",
"request",
"through",
"an",
"HTTP",
"proxy"
] |
f37a10ea4fab3ee411907ea2e4251ddf0ca33a93
|
https://github.com/httprb/http/blob/f37a10ea4fab3ee411907ea2e4251ddf0ca33a93/lib/http/chainable.rb#L155-L167
|
11,356
|
httprb/http
|
lib/http/chainable.rb
|
HTTP.Chainable.basic_auth
|
def basic_auth(opts)
user = opts.fetch :user
pass = opts.fetch :pass
auth("Basic " + Base64.strict_encode64("#{user}:#{pass}"))
end
|
ruby
|
def basic_auth(opts)
user = opts.fetch :user
pass = opts.fetch :pass
auth("Basic " + Base64.strict_encode64("#{user}:#{pass}"))
end
|
[
"def",
"basic_auth",
"(",
"opts",
")",
"user",
"=",
"opts",
".",
"fetch",
":user",
"pass",
"=",
"opts",
".",
"fetch",
":pass",
"auth",
"(",
"\"Basic \"",
"+",
"Base64",
".",
"strict_encode64",
"(",
"\"#{user}:#{pass}\"",
")",
")",
"end"
] |
Make a request with the given Basic authorization header
@see http://tools.ietf.org/html/rfc2617
@param [#fetch] opts
@option opts [#to_s] :user
@option opts [#to_s] :pass
|
[
"Make",
"a",
"request",
"with",
"the",
"given",
"Basic",
"authorization",
"header"
] |
f37a10ea4fab3ee411907ea2e4251ddf0ca33a93
|
https://github.com/httprb/http/blob/f37a10ea4fab3ee411907ea2e4251ddf0ca33a93/lib/http/chainable.rb#L211-L216
|
11,357
|
httprb/http
|
lib/http/client.rb
|
HTTP.Client.request
|
def request(verb, uri, opts = {}) # rubocop:disable Style/OptionHash
opts = @default_options.merge(opts)
req = build_request(verb, uri, opts)
res = perform(req, opts)
return res unless opts.follow
Redirector.new(opts.follow).perform(req, res) do |request|
perform(request, opts)
end
end
|
ruby
|
def request(verb, uri, opts = {}) # rubocop:disable Style/OptionHash
opts = @default_options.merge(opts)
req = build_request(verb, uri, opts)
res = perform(req, opts)
return res unless opts.follow
Redirector.new(opts.follow).perform(req, res) do |request|
perform(request, opts)
end
end
|
[
"def",
"request",
"(",
"verb",
",",
"uri",
",",
"opts",
"=",
"{",
"}",
")",
"# rubocop:disable Style/OptionHash",
"opts",
"=",
"@default_options",
".",
"merge",
"(",
"opts",
")",
"req",
"=",
"build_request",
"(",
"verb",
",",
"uri",
",",
"opts",
")",
"res",
"=",
"perform",
"(",
"req",
",",
"opts",
")",
"return",
"res",
"unless",
"opts",
".",
"follow",
"Redirector",
".",
"new",
"(",
"opts",
".",
"follow",
")",
".",
"perform",
"(",
"req",
",",
"res",
")",
"do",
"|",
"request",
"|",
"perform",
"(",
"request",
",",
"opts",
")",
"end",
"end"
] |
Make an HTTP request
|
[
"Make",
"an",
"HTTP",
"request"
] |
f37a10ea4fab3ee411907ea2e4251ddf0ca33a93
|
https://github.com/httprb/http/blob/f37a10ea4fab3ee411907ea2e4251ddf0ca33a93/lib/http/client.rb#L28-L37
|
11,358
|
httprb/http
|
lib/http/client.rb
|
HTTP.Client.build_request
|
def build_request(verb, uri, opts = {}) # rubocop:disable Style/OptionHash
opts = @default_options.merge(opts)
uri = make_request_uri(uri, opts)
headers = make_request_headers(opts)
body = make_request_body(opts, headers)
req = HTTP::Request.new(
:verb => verb,
:uri => uri,
:uri_normalizer => opts.feature(:normalize_uri)&.normalizer,
:proxy => opts.proxy,
:headers => headers,
:body => body
)
opts.features.inject(req) do |request, (_name, feature)|
feature.wrap_request(request)
end
end
|
ruby
|
def build_request(verb, uri, opts = {}) # rubocop:disable Style/OptionHash
opts = @default_options.merge(opts)
uri = make_request_uri(uri, opts)
headers = make_request_headers(opts)
body = make_request_body(opts, headers)
req = HTTP::Request.new(
:verb => verb,
:uri => uri,
:uri_normalizer => opts.feature(:normalize_uri)&.normalizer,
:proxy => opts.proxy,
:headers => headers,
:body => body
)
opts.features.inject(req) do |request, (_name, feature)|
feature.wrap_request(request)
end
end
|
[
"def",
"build_request",
"(",
"verb",
",",
"uri",
",",
"opts",
"=",
"{",
"}",
")",
"# rubocop:disable Style/OptionHash",
"opts",
"=",
"@default_options",
".",
"merge",
"(",
"opts",
")",
"uri",
"=",
"make_request_uri",
"(",
"uri",
",",
"opts",
")",
"headers",
"=",
"make_request_headers",
"(",
"opts",
")",
"body",
"=",
"make_request_body",
"(",
"opts",
",",
"headers",
")",
"req",
"=",
"HTTP",
"::",
"Request",
".",
"new",
"(",
":verb",
"=>",
"verb",
",",
":uri",
"=>",
"uri",
",",
":uri_normalizer",
"=>",
"opts",
".",
"feature",
"(",
":normalize_uri",
")",
"&.",
"normalizer",
",",
":proxy",
"=>",
"opts",
".",
"proxy",
",",
":headers",
"=>",
"headers",
",",
":body",
"=>",
"body",
")",
"opts",
".",
"features",
".",
"inject",
"(",
"req",
")",
"do",
"|",
"request",
",",
"(",
"_name",
",",
"feature",
")",
"|",
"feature",
".",
"wrap_request",
"(",
"request",
")",
"end",
"end"
] |
Prepare an HTTP request
|
[
"Prepare",
"an",
"HTTP",
"request"
] |
f37a10ea4fab3ee411907ea2e4251ddf0ca33a93
|
https://github.com/httprb/http/blob/f37a10ea4fab3ee411907ea2e4251ddf0ca33a93/lib/http/client.rb#L40-L58
|
11,359
|
httprb/http
|
lib/http/client.rb
|
HTTP.Client.verify_connection!
|
def verify_connection!(uri)
if default_options.persistent? && uri.origin != default_options.persistent
raise StateError, "Persistence is enabled for #{default_options.persistent}, but we got #{uri.origin}"
# We re-create the connection object because we want to let prior requests
# lazily load the body as long as possible, and this mimics prior functionality.
elsif @connection && (!@connection.keep_alive? || @connection.expired?)
close
# If we get into a bad state (eg, Timeout.timeout ensure being killed)
# close the connection to prevent potential for mixed responses.
elsif @state == :dirty
close
end
end
|
ruby
|
def verify_connection!(uri)
if default_options.persistent? && uri.origin != default_options.persistent
raise StateError, "Persistence is enabled for #{default_options.persistent}, but we got #{uri.origin}"
# We re-create the connection object because we want to let prior requests
# lazily load the body as long as possible, and this mimics prior functionality.
elsif @connection && (!@connection.keep_alive? || @connection.expired?)
close
# If we get into a bad state (eg, Timeout.timeout ensure being killed)
# close the connection to prevent potential for mixed responses.
elsif @state == :dirty
close
end
end
|
[
"def",
"verify_connection!",
"(",
"uri",
")",
"if",
"default_options",
".",
"persistent?",
"&&",
"uri",
".",
"origin",
"!=",
"default_options",
".",
"persistent",
"raise",
"StateError",
",",
"\"Persistence is enabled for #{default_options.persistent}, but we got #{uri.origin}\"",
"# We re-create the connection object because we want to let prior requests",
"# lazily load the body as long as possible, and this mimics prior functionality.",
"elsif",
"@connection",
"&&",
"(",
"!",
"@connection",
".",
"keep_alive?",
"||",
"@connection",
".",
"expired?",
")",
"close",
"# If we get into a bad state (eg, Timeout.timeout ensure being killed)",
"# close the connection to prevent potential for mixed responses.",
"elsif",
"@state",
"==",
":dirty",
"close",
"end",
"end"
] |
Verify our request isn't going to be made against another URI
|
[
"Verify",
"our",
"request",
"isn",
"t",
"going",
"to",
"be",
"made",
"against",
"another",
"URI"
] |
f37a10ea4fab3ee411907ea2e4251ddf0ca33a93
|
https://github.com/httprb/http/blob/f37a10ea4fab3ee411907ea2e4251ddf0ca33a93/lib/http/client.rb#L110-L122
|
11,360
|
httprb/http
|
lib/http/client.rb
|
HTTP.Client.make_request_uri
|
def make_request_uri(uri, opts)
uri = uri.to_s
if default_options.persistent? && uri !~ HTTP_OR_HTTPS_RE
uri = "#{default_options.persistent}#{uri}"
end
uri = HTTP::URI.parse uri
if opts.params && !opts.params.empty?
uri.query_values = uri.query_values(Array).to_a.concat(opts.params.to_a)
end
# Some proxies (seen on WEBRick) fail if URL has
# empty path (e.g. `http://example.com`) while it's RFC-complaint:
# http://tools.ietf.org/html/rfc1738#section-3.1
uri.path = "/" if uri.path.empty?
uri
end
|
ruby
|
def make_request_uri(uri, opts)
uri = uri.to_s
if default_options.persistent? && uri !~ HTTP_OR_HTTPS_RE
uri = "#{default_options.persistent}#{uri}"
end
uri = HTTP::URI.parse uri
if opts.params && !opts.params.empty?
uri.query_values = uri.query_values(Array).to_a.concat(opts.params.to_a)
end
# Some proxies (seen on WEBRick) fail if URL has
# empty path (e.g. `http://example.com`) while it's RFC-complaint:
# http://tools.ietf.org/html/rfc1738#section-3.1
uri.path = "/" if uri.path.empty?
uri
end
|
[
"def",
"make_request_uri",
"(",
"uri",
",",
"opts",
")",
"uri",
"=",
"uri",
".",
"to_s",
"if",
"default_options",
".",
"persistent?",
"&&",
"uri",
"!~",
"HTTP_OR_HTTPS_RE",
"uri",
"=",
"\"#{default_options.persistent}#{uri}\"",
"end",
"uri",
"=",
"HTTP",
"::",
"URI",
".",
"parse",
"uri",
"if",
"opts",
".",
"params",
"&&",
"!",
"opts",
".",
"params",
".",
"empty?",
"uri",
".",
"query_values",
"=",
"uri",
".",
"query_values",
"(",
"Array",
")",
".",
"to_a",
".",
"concat",
"(",
"opts",
".",
"params",
".",
"to_a",
")",
"end",
"# Some proxies (seen on WEBRick) fail if URL has",
"# empty path (e.g. `http://example.com`) while it's RFC-complaint:",
"# http://tools.ietf.org/html/rfc1738#section-3.1",
"uri",
".",
"path",
"=",
"\"/\"",
"if",
"uri",
".",
"path",
".",
"empty?",
"uri",
"end"
] |
Merges query params if needed
@param [#to_s] uri
@return [URI]
|
[
"Merges",
"query",
"params",
"if",
"needed"
] |
f37a10ea4fab3ee411907ea2e4251ddf0ca33a93
|
https://github.com/httprb/http/blob/f37a10ea4fab3ee411907ea2e4251ddf0ca33a93/lib/http/client.rb#L128-L147
|
11,361
|
httprb/http
|
lib/http/client.rb
|
HTTP.Client.make_request_body
|
def make_request_body(opts, headers)
case
when opts.body
opts.body
when opts.form
form = HTTP::FormData.create opts.form
headers[Headers::CONTENT_TYPE] ||= form.content_type
form
when opts.json
body = MimeType[:json].encode opts.json
headers[Headers::CONTENT_TYPE] ||= "application/json; charset=#{body.encoding.name}"
body
end
end
|
ruby
|
def make_request_body(opts, headers)
case
when opts.body
opts.body
when opts.form
form = HTTP::FormData.create opts.form
headers[Headers::CONTENT_TYPE] ||= form.content_type
form
when opts.json
body = MimeType[:json].encode opts.json
headers[Headers::CONTENT_TYPE] ||= "application/json; charset=#{body.encoding.name}"
body
end
end
|
[
"def",
"make_request_body",
"(",
"opts",
",",
"headers",
")",
"case",
"when",
"opts",
".",
"body",
"opts",
".",
"body",
"when",
"opts",
".",
"form",
"form",
"=",
"HTTP",
"::",
"FormData",
".",
"create",
"opts",
".",
"form",
"headers",
"[",
"Headers",
"::",
"CONTENT_TYPE",
"]",
"||=",
"form",
".",
"content_type",
"form",
"when",
"opts",
".",
"json",
"body",
"=",
"MimeType",
"[",
":json",
"]",
".",
"encode",
"opts",
".",
"json",
"headers",
"[",
"Headers",
"::",
"CONTENT_TYPE",
"]",
"||=",
"\"application/json; charset=#{body.encoding.name}\"",
"body",
"end",
"end"
] |
Create the request body object to send
|
[
"Create",
"the",
"request",
"body",
"object",
"to",
"send"
] |
f37a10ea4fab3ee411907ea2e4251ddf0ca33a93
|
https://github.com/httprb/http/blob/f37a10ea4fab3ee411907ea2e4251ddf0ca33a93/lib/http/client.rb#L167-L180
|
11,362
|
httprb/http
|
lib/http/headers.rb
|
HTTP.Headers.delete
|
def delete(name)
name = normalize_header name.to_s
@pile.delete_if { |k, _| k == name }
end
|
ruby
|
def delete(name)
name = normalize_header name.to_s
@pile.delete_if { |k, _| k == name }
end
|
[
"def",
"delete",
"(",
"name",
")",
"name",
"=",
"normalize_header",
"name",
".",
"to_s",
"@pile",
".",
"delete_if",
"{",
"|",
"k",
",",
"_",
"|",
"k",
"==",
"name",
"}",
"end"
] |
Removes header.
@param [#to_s] name header name
@return [void]
|
[
"Removes",
"header",
"."
] |
f37a10ea4fab3ee411907ea2e4251ddf0ca33a93
|
https://github.com/httprb/http/blob/f37a10ea4fab3ee411907ea2e4251ddf0ca33a93/lib/http/headers.rb#L41-L44
|
11,363
|
httprb/http
|
lib/http/headers.rb
|
HTTP.Headers.add
|
def add(name, value)
name = normalize_header name.to_s
Array(value).each { |v| @pile << [name, validate_value(v)] }
end
|
ruby
|
def add(name, value)
name = normalize_header name.to_s
Array(value).each { |v| @pile << [name, validate_value(v)] }
end
|
[
"def",
"add",
"(",
"name",
",",
"value",
")",
"name",
"=",
"normalize_header",
"name",
".",
"to_s",
"Array",
"(",
"value",
")",
".",
"each",
"{",
"|",
"v",
"|",
"@pile",
"<<",
"[",
"name",
",",
"validate_value",
"(",
"v",
")",
"]",
"}",
"end"
] |
Appends header.
@param [#to_s] name header name
@param [Array<#to_s>, #to_s] value header value(s) to be appended
@return [void]
|
[
"Appends",
"header",
"."
] |
f37a10ea4fab3ee411907ea2e4251ddf0ca33a93
|
https://github.com/httprb/http/blob/f37a10ea4fab3ee411907ea2e4251ddf0ca33a93/lib/http/headers.rb#L51-L54
|
11,364
|
httprb/http
|
lib/http/headers.rb
|
HTTP.Headers.get
|
def get(name)
name = normalize_header name.to_s
@pile.select { |k, _| k == name }.map { |_, v| v }
end
|
ruby
|
def get(name)
name = normalize_header name.to_s
@pile.select { |k, _| k == name }.map { |_, v| v }
end
|
[
"def",
"get",
"(",
"name",
")",
"name",
"=",
"normalize_header",
"name",
".",
"to_s",
"@pile",
".",
"select",
"{",
"|",
"k",
",",
"_",
"|",
"k",
"==",
"name",
"}",
".",
"map",
"{",
"|",
"_",
",",
"v",
"|",
"v",
"}",
"end"
] |
Returns list of header values if any.
@return [Array<String>]
|
[
"Returns",
"list",
"of",
"header",
"values",
"if",
"any",
"."
] |
f37a10ea4fab3ee411907ea2e4251ddf0ca33a93
|
https://github.com/httprb/http/blob/f37a10ea4fab3ee411907ea2e4251ddf0ca33a93/lib/http/headers.rb#L59-L62
|
11,365
|
httprb/http
|
lib/http/headers.rb
|
HTTP.Headers.include?
|
def include?(name)
name = normalize_header name.to_s
@pile.any? { |k, _| k == name }
end
|
ruby
|
def include?(name)
name = normalize_header name.to_s
@pile.any? { |k, _| k == name }
end
|
[
"def",
"include?",
"(",
"name",
")",
"name",
"=",
"normalize_header",
"name",
".",
"to_s",
"@pile",
".",
"any?",
"{",
"|",
"k",
",",
"_",
"|",
"k",
"==",
"name",
"}",
"end"
] |
Tells whenever header with given `name` is set or not.
@return [Boolean]
|
[
"Tells",
"whenever",
"header",
"with",
"given",
"name",
"is",
"set",
"or",
"not",
"."
] |
f37a10ea4fab3ee411907ea2e4251ddf0ca33a93
|
https://github.com/httprb/http/blob/f37a10ea4fab3ee411907ea2e4251ddf0ca33a93/lib/http/headers.rb#L82-L85
|
11,366
|
httprb/http
|
lib/http/headers.rb
|
HTTP.Headers.merge!
|
def merge!(other)
self.class.coerce(other).to_h.each { |name, values| set name, values }
end
|
ruby
|
def merge!(other)
self.class.coerce(other).to_h.each { |name, values| set name, values }
end
|
[
"def",
"merge!",
"(",
"other",
")",
"self",
".",
"class",
".",
"coerce",
"(",
"other",
")",
".",
"to_h",
".",
"each",
"{",
"|",
"name",
",",
"values",
"|",
"set",
"name",
",",
"values",
"}",
"end"
] |
Merges `other` headers into `self`.
@see #merge
@return [void]
|
[
"Merges",
"other",
"headers",
"into",
"self",
"."
] |
f37a10ea4fab3ee411907ea2e4251ddf0ca33a93
|
https://github.com/httprb/http/blob/f37a10ea4fab3ee411907ea2e4251ddf0ca33a93/lib/http/headers.rb#L160-L162
|
11,367
|
httprb/http
|
lib/http/headers.rb
|
HTTP.Headers.normalize_header
|
def normalize_header(name)
return name if name =~ CANONICAL_NAME_RE
normalized = name.split(/[\-_]/).each(&:capitalize!).join("-")
return normalized if normalized =~ COMPLIANT_NAME_RE
raise HeaderError, "Invalid HTTP header field name: #{name.inspect}"
end
|
ruby
|
def normalize_header(name)
return name if name =~ CANONICAL_NAME_RE
normalized = name.split(/[\-_]/).each(&:capitalize!).join("-")
return normalized if normalized =~ COMPLIANT_NAME_RE
raise HeaderError, "Invalid HTTP header field name: #{name.inspect}"
end
|
[
"def",
"normalize_header",
"(",
"name",
")",
"return",
"name",
"if",
"name",
"=~",
"CANONICAL_NAME_RE",
"normalized",
"=",
"name",
".",
"split",
"(",
"/",
"\\-",
"/",
")",
".",
"each",
"(",
":capitalize!",
")",
".",
"join",
"(",
"\"-\"",
")",
"return",
"normalized",
"if",
"normalized",
"=~",
"COMPLIANT_NAME_RE",
"raise",
"HeaderError",
",",
"\"Invalid HTTP header field name: #{name.inspect}\"",
"end"
] |
Transforms `name` to canonical HTTP header capitalization
@param [String] name
@raise [HeaderError] if normalized name does not
match {HEADER_NAME_RE}
@return [String] canonical HTTP header name
|
[
"Transforms",
"name",
"to",
"canonical",
"HTTP",
"header",
"capitalization"
] |
f37a10ea4fab3ee411907ea2e4251ddf0ca33a93
|
https://github.com/httprb/http/blob/f37a10ea4fab3ee411907ea2e4251ddf0ca33a93/lib/http/headers.rb#L203-L211
|
11,368
|
httprb/http
|
lib/http/headers.rb
|
HTTP.Headers.validate_value
|
def validate_value(value)
v = value.to_s
return v unless v.include?("\n")
raise HeaderError, "Invalid HTTP header field value: #{v.inspect}"
end
|
ruby
|
def validate_value(value)
v = value.to_s
return v unless v.include?("\n")
raise HeaderError, "Invalid HTTP header field value: #{v.inspect}"
end
|
[
"def",
"validate_value",
"(",
"value",
")",
"v",
"=",
"value",
".",
"to_s",
"return",
"v",
"unless",
"v",
".",
"include?",
"(",
"\"\\n\"",
")",
"raise",
"HeaderError",
",",
"\"Invalid HTTP header field value: #{v.inspect}\"",
"end"
] |
Ensures there is no new line character in the header value
@param [String] value
@raise [HeaderError] if value includes new line character
@return [String] stringified header value
|
[
"Ensures",
"there",
"is",
"no",
"new",
"line",
"character",
"in",
"the",
"header",
"value"
] |
f37a10ea4fab3ee411907ea2e4251ddf0ca33a93
|
https://github.com/httprb/http/blob/f37a10ea4fab3ee411907ea2e4251ddf0ca33a93/lib/http/headers.rb#L218-L222
|
11,369
|
httprb/http
|
lib/http/redirector.rb
|
HTTP.Redirector.redirect_to
|
def redirect_to(uri)
raise StateError, "no Location header in redirect" unless uri
verb = @request.verb
code = @response.status.code
if UNSAFE_VERBS.include?(verb) && STRICT_SENSITIVE_CODES.include?(code)
raise StateError, "can't follow #{@response.status} redirect" if @strict
verb = :get
end
verb = :get if !SEE_OTHER_ALLOWED_VERBS.include?(verb) && 303 == code
@request.redirect(uri, verb)
end
|
ruby
|
def redirect_to(uri)
raise StateError, "no Location header in redirect" unless uri
verb = @request.verb
code = @response.status.code
if UNSAFE_VERBS.include?(verb) && STRICT_SENSITIVE_CODES.include?(code)
raise StateError, "can't follow #{@response.status} redirect" if @strict
verb = :get
end
verb = :get if !SEE_OTHER_ALLOWED_VERBS.include?(verb) && 303 == code
@request.redirect(uri, verb)
end
|
[
"def",
"redirect_to",
"(",
"uri",
")",
"raise",
"StateError",
",",
"\"no Location header in redirect\"",
"unless",
"uri",
"verb",
"=",
"@request",
".",
"verb",
"code",
"=",
"@response",
".",
"status",
".",
"code",
"if",
"UNSAFE_VERBS",
".",
"include?",
"(",
"verb",
")",
"&&",
"STRICT_SENSITIVE_CODES",
".",
"include?",
"(",
"code",
")",
"raise",
"StateError",
",",
"\"can't follow #{@response.status} redirect\"",
"if",
"@strict",
"verb",
"=",
":get",
"end",
"verb",
"=",
":get",
"if",
"!",
"SEE_OTHER_ALLOWED_VERBS",
".",
"include?",
"(",
"verb",
")",
"&&",
"303",
"==",
"code",
"@request",
".",
"redirect",
"(",
"uri",
",",
"verb",
")",
"end"
] |
Redirect policy for follow
@return [Request]
|
[
"Redirect",
"policy",
"for",
"follow"
] |
f37a10ea4fab3ee411907ea2e4251ddf0ca33a93
|
https://github.com/httprb/http/blob/f37a10ea4fab3ee411907ea2e4251ddf0ca33a93/lib/http/redirector.rb#L84-L98
|
11,370
|
httprb/http
|
lib/http/request.rb
|
HTTP.Request.stream
|
def stream(socket)
include_proxy_headers if using_proxy? && !@uri.https?
Request::Writer.new(socket, body, headers, headline).stream
end
|
ruby
|
def stream(socket)
include_proxy_headers if using_proxy? && !@uri.https?
Request::Writer.new(socket, body, headers, headline).stream
end
|
[
"def",
"stream",
"(",
"socket",
")",
"include_proxy_headers",
"if",
"using_proxy?",
"&&",
"!",
"@uri",
".",
"https?",
"Request",
"::",
"Writer",
".",
"new",
"(",
"socket",
",",
"body",
",",
"headers",
",",
"headline",
")",
".",
"stream",
"end"
] |
Stream the request to a socket
|
[
"Stream",
"the",
"request",
"to",
"a",
"socket"
] |
f37a10ea4fab3ee411907ea2e4251ddf0ca33a93
|
https://github.com/httprb/http/blob/f37a10ea4fab3ee411907ea2e4251ddf0ca33a93/lib/http/request.rb#L116-L119
|
11,371
|
httprb/http
|
lib/http/request.rb
|
HTTP.Request.proxy_connect_headers
|
def proxy_connect_headers
connect_headers = HTTP::Headers.coerce(
Headers::HOST => headers[Headers::HOST],
Headers::USER_AGENT => headers[Headers::USER_AGENT]
)
connect_headers[Headers::PROXY_AUTHORIZATION] = proxy_authorization_header if using_authenticated_proxy?
connect_headers.merge!(proxy[:proxy_headers]) if proxy.key?(:proxy_headers)
connect_headers
end
|
ruby
|
def proxy_connect_headers
connect_headers = HTTP::Headers.coerce(
Headers::HOST => headers[Headers::HOST],
Headers::USER_AGENT => headers[Headers::USER_AGENT]
)
connect_headers[Headers::PROXY_AUTHORIZATION] = proxy_authorization_header if using_authenticated_proxy?
connect_headers.merge!(proxy[:proxy_headers]) if proxy.key?(:proxy_headers)
connect_headers
end
|
[
"def",
"proxy_connect_headers",
"connect_headers",
"=",
"HTTP",
"::",
"Headers",
".",
"coerce",
"(",
"Headers",
"::",
"HOST",
"=>",
"headers",
"[",
"Headers",
"::",
"HOST",
"]",
",",
"Headers",
"::",
"USER_AGENT",
"=>",
"headers",
"[",
"Headers",
"::",
"USER_AGENT",
"]",
")",
"connect_headers",
"[",
"Headers",
"::",
"PROXY_AUTHORIZATION",
"]",
"=",
"proxy_authorization_header",
"if",
"using_authenticated_proxy?",
"connect_headers",
".",
"merge!",
"(",
"proxy",
"[",
":proxy_headers",
"]",
")",
"if",
"proxy",
".",
"key?",
"(",
":proxy_headers",
")",
"connect_headers",
"end"
] |
Headers to send with proxy connect request
|
[
"Headers",
"to",
"send",
"with",
"proxy",
"connect",
"request"
] |
f37a10ea4fab3ee411907ea2e4251ddf0ca33a93
|
https://github.com/httprb/http/blob/f37a10ea4fab3ee411907ea2e4251ddf0ca33a93/lib/http/request.rb#L169-L178
|
11,372
|
roo-rb/roo
|
lib/roo/excelx.rb
|
Roo.Excelx.column
|
def column(column_number, sheet = nil)
if column_number.is_a?(::String)
column_number = ::Roo::Utils.letter_to_number(column_number)
end
sheet_for(sheet).column(column_number)
end
|
ruby
|
def column(column_number, sheet = nil)
if column_number.is_a?(::String)
column_number = ::Roo::Utils.letter_to_number(column_number)
end
sheet_for(sheet).column(column_number)
end
|
[
"def",
"column",
"(",
"column_number",
",",
"sheet",
"=",
"nil",
")",
"if",
"column_number",
".",
"is_a?",
"(",
"::",
"String",
")",
"column_number",
"=",
"::",
"Roo",
"::",
"Utils",
".",
"letter_to_number",
"(",
"column_number",
")",
"end",
"sheet_for",
"(",
"sheet",
")",
".",
"column",
"(",
"column_number",
")",
"end"
] |
returns all values in this column as an array
column numbers are 1,2,3,... like in the spreadsheet
|
[
"returns",
"all",
"values",
"in",
"this",
"column",
"as",
"an",
"array",
"column",
"numbers",
"are",
"1",
"2",
"3",
"...",
"like",
"in",
"the",
"spreadsheet"
] |
4ec1104f0c3c2a29711c0c907371cd2be12bcc3c
|
https://github.com/roo-rb/roo/blob/4ec1104f0c3c2a29711c0c907371cd2be12bcc3c/lib/roo/excelx.rb#L124-L129
|
11,373
|
roo-rb/roo
|
lib/roo/excelx.rb
|
Roo.Excelx.excelx_format
|
def excelx_format(row, col, sheet = nil)
key = normalize(row, col)
sheet_for(sheet).excelx_format(key)
end
|
ruby
|
def excelx_format(row, col, sheet = nil)
key = normalize(row, col)
sheet_for(sheet).excelx_format(key)
end
|
[
"def",
"excelx_format",
"(",
"row",
",",
"col",
",",
"sheet",
"=",
"nil",
")",
"key",
"=",
"normalize",
"(",
"row",
",",
"col",
")",
"sheet_for",
"(",
"sheet",
")",
".",
"excelx_format",
"(",
"key",
")",
"end"
] |
returns the internal format of an excel cell
|
[
"returns",
"the",
"internal",
"format",
"of",
"an",
"excel",
"cell"
] |
4ec1104f0c3c2a29711c0c907371cd2be12bcc3c
|
https://github.com/roo-rb/roo/blob/4ec1104f0c3c2a29711c0c907371cd2be12bcc3c/lib/roo/excelx.rb#L226-L229
|
11,374
|
roo-rb/roo
|
lib/roo/excelx.rb
|
Roo.Excelx.process_zipfile
|
def process_zipfile(zipfilename_or_stream)
@sheet_files = []
unless is_stream?(zipfilename_or_stream)
zip_file = Zip::File.open(zipfilename_or_stream)
else
zip_file = Zip::CentralDirectory.new
zip_file.read_from_stream zipfilename_or_stream
end
process_zipfile_entries zip_file.to_a.sort_by(&:name)
end
|
ruby
|
def process_zipfile(zipfilename_or_stream)
@sheet_files = []
unless is_stream?(zipfilename_or_stream)
zip_file = Zip::File.open(zipfilename_or_stream)
else
zip_file = Zip::CentralDirectory.new
zip_file.read_from_stream zipfilename_or_stream
end
process_zipfile_entries zip_file.to_a.sort_by(&:name)
end
|
[
"def",
"process_zipfile",
"(",
"zipfilename_or_stream",
")",
"@sheet_files",
"=",
"[",
"]",
"unless",
"is_stream?",
"(",
"zipfilename_or_stream",
")",
"zip_file",
"=",
"Zip",
"::",
"File",
".",
"open",
"(",
"zipfilename_or_stream",
")",
"else",
"zip_file",
"=",
"Zip",
"::",
"CentralDirectory",
".",
"new",
"zip_file",
".",
"read_from_stream",
"zipfilename_or_stream",
"end",
"process_zipfile_entries",
"zip_file",
".",
"to_a",
".",
"sort_by",
"(",
":name",
")",
"end"
] |
Extracts all needed files from the zip file
|
[
"Extracts",
"all",
"needed",
"files",
"from",
"the",
"zip",
"file"
] |
4ec1104f0c3c2a29711c0c907371cd2be12bcc3c
|
https://github.com/roo-rb/roo/blob/4ec1104f0c3c2a29711c0c907371cd2be12bcc3c/lib/roo/excelx.rb#L394-L405
|
11,375
|
roo-rb/roo
|
lib/roo/open_office.rb
|
Roo.OpenOffice.decrypt_if_necessary
|
def decrypt_if_necessary(
zip_file,
content_entry,
roo_content_xml_path, options
)
# Check if content.xml is encrypted by extracting manifest.xml
# and searching for a manifest:encryption-data element
if (manifest_entry = zip_file.glob('META-INF/manifest.xml').first)
roo_manifest_xml_path = File.join(@tmpdir, 'roo_manifest.xml')
manifest_entry.extract(roo_manifest_xml_path)
manifest = ::Roo::Utils.load_xml(roo_manifest_xml_path)
# XPath search for manifest:encryption-data only for the content.xml
# file
encryption_data = manifest.xpath(
"//manifest:file-entry[@manifest:full-path='content.xml']"\
"/manifest:encryption-data"
).first
# If XPath returns a node, then we know content.xml is encrypted
unless encryption_data.nil?
# Since we know it's encrypted, we check for the password option
# and if it doesn't exist, raise an argument error
password = options[:password]
if !password.nil?
perform_decryption(
encryption_data,
password,
content_entry,
roo_content_xml_path
)
else
fail ArgumentError, 'file is encrypted but password was not supplied'
end
end
else
fail ArgumentError, 'file missing required META-INF/manifest.xml'
end
end
|
ruby
|
def decrypt_if_necessary(
zip_file,
content_entry,
roo_content_xml_path, options
)
# Check if content.xml is encrypted by extracting manifest.xml
# and searching for a manifest:encryption-data element
if (manifest_entry = zip_file.glob('META-INF/manifest.xml').first)
roo_manifest_xml_path = File.join(@tmpdir, 'roo_manifest.xml')
manifest_entry.extract(roo_manifest_xml_path)
manifest = ::Roo::Utils.load_xml(roo_manifest_xml_path)
# XPath search for manifest:encryption-data only for the content.xml
# file
encryption_data = manifest.xpath(
"//manifest:file-entry[@manifest:full-path='content.xml']"\
"/manifest:encryption-data"
).first
# If XPath returns a node, then we know content.xml is encrypted
unless encryption_data.nil?
# Since we know it's encrypted, we check for the password option
# and if it doesn't exist, raise an argument error
password = options[:password]
if !password.nil?
perform_decryption(
encryption_data,
password,
content_entry,
roo_content_xml_path
)
else
fail ArgumentError, 'file is encrypted but password was not supplied'
end
end
else
fail ArgumentError, 'file missing required META-INF/manifest.xml'
end
end
|
[
"def",
"decrypt_if_necessary",
"(",
"zip_file",
",",
"content_entry",
",",
"roo_content_xml_path",
",",
"options",
")",
"# Check if content.xml is encrypted by extracting manifest.xml",
"# and searching for a manifest:encryption-data element",
"if",
"(",
"manifest_entry",
"=",
"zip_file",
".",
"glob",
"(",
"'META-INF/manifest.xml'",
")",
".",
"first",
")",
"roo_manifest_xml_path",
"=",
"File",
".",
"join",
"(",
"@tmpdir",
",",
"'roo_manifest.xml'",
")",
"manifest_entry",
".",
"extract",
"(",
"roo_manifest_xml_path",
")",
"manifest",
"=",
"::",
"Roo",
"::",
"Utils",
".",
"load_xml",
"(",
"roo_manifest_xml_path",
")",
"# XPath search for manifest:encryption-data only for the content.xml",
"# file",
"encryption_data",
"=",
"manifest",
".",
"xpath",
"(",
"\"//manifest:file-entry[@manifest:full-path='content.xml']\"",
"\"/manifest:encryption-data\"",
")",
".",
"first",
"# If XPath returns a node, then we know content.xml is encrypted",
"unless",
"encryption_data",
".",
"nil?",
"# Since we know it's encrypted, we check for the password option",
"# and if it doesn't exist, raise an argument error",
"password",
"=",
"options",
"[",
":password",
"]",
"if",
"!",
"password",
".",
"nil?",
"perform_decryption",
"(",
"encryption_data",
",",
"password",
",",
"content_entry",
",",
"roo_content_xml_path",
")",
"else",
"fail",
"ArgumentError",
",",
"'file is encrypted but password was not supplied'",
"end",
"end",
"else",
"fail",
"ArgumentError",
",",
"'file missing required META-INF/manifest.xml'",
"end",
"end"
] |
If the ODS file has an encryption-data element, then try to decrypt.
If successful, the temporary content.xml will be overwritten with
decrypted contents.
|
[
"If",
"the",
"ODS",
"file",
"has",
"an",
"encryption",
"-",
"data",
"element",
"then",
"try",
"to",
"decrypt",
".",
"If",
"successful",
"the",
"temporary",
"content",
".",
"xml",
"will",
"be",
"overwritten",
"with",
"decrypted",
"contents",
"."
] |
4ec1104f0c3c2a29711c0c907371cd2be12bcc3c
|
https://github.com/roo-rb/roo/blob/4ec1104f0c3c2a29711c0c907371cd2be12bcc3c/lib/roo/open_office.rb#L227-L270
|
11,376
|
roo-rb/roo
|
lib/roo/open_office.rb
|
Roo.OpenOffice.perform_decryption
|
def perform_decryption(
encryption_data,
password,
content_entry,
roo_content_xml_path
)
# Extract various expected attributes from the manifest that
# describe the encryption
algorithm_node = encryption_data.xpath('manifest:algorithm').first
key_derivation_node =
encryption_data.xpath('manifest:key-derivation').first
start_key_generation_node =
encryption_data.xpath('manifest:start-key-generation').first
# If we have all the expected elements, then we can perform
# the decryption.
if !algorithm_node.nil? && !key_derivation_node.nil? &&
!start_key_generation_node.nil?
# The algorithm is a URI describing the algorithm used
algorithm = algorithm_node['manifest:algorithm-name']
# The initialization vector is base-64 encoded
iv = Base64.decode64(
algorithm_node['manifest:initialisation-vector']
)
key_derivation_name = key_derivation_node['manifest:key-derivation-name']
iteration_count = key_derivation_node['manifest:iteration-count'].to_i
salt = Base64.decode64(key_derivation_node['manifest:salt'])
# The key is hashed with an algorithm represented by this URI
key_generation_name =
start_key_generation_node[
'manifest:start-key-generation-name'
]
hashed_password = password
if key_generation_name == 'http://www.w3.org/2000/09/xmldsig#sha256'
hashed_password = Digest::SHA256.digest(password)
else
fail ArgumentError, "Unknown key generation algorithm #{key_generation_name}"
end
cipher = find_cipher(
algorithm,
key_derivation_name,
hashed_password,
salt,
iteration_count,
iv
)
begin
decrypted = decrypt(content_entry, cipher)
# Finally, inflate the decrypted stream and overwrite
# content.xml
IO.binwrite(
roo_content_xml_path,
Zlib::Inflate.new(-Zlib::MAX_WBITS).inflate(decrypted)
)
rescue StandardError => error
raise ArgumentError, "Invalid password or other data error: #{error}"
end
else
fail ArgumentError, 'manifest.xml missing encryption-data elements'
end
end
|
ruby
|
def perform_decryption(
encryption_data,
password,
content_entry,
roo_content_xml_path
)
# Extract various expected attributes from the manifest that
# describe the encryption
algorithm_node = encryption_data.xpath('manifest:algorithm').first
key_derivation_node =
encryption_data.xpath('manifest:key-derivation').first
start_key_generation_node =
encryption_data.xpath('manifest:start-key-generation').first
# If we have all the expected elements, then we can perform
# the decryption.
if !algorithm_node.nil? && !key_derivation_node.nil? &&
!start_key_generation_node.nil?
# The algorithm is a URI describing the algorithm used
algorithm = algorithm_node['manifest:algorithm-name']
# The initialization vector is base-64 encoded
iv = Base64.decode64(
algorithm_node['manifest:initialisation-vector']
)
key_derivation_name = key_derivation_node['manifest:key-derivation-name']
iteration_count = key_derivation_node['manifest:iteration-count'].to_i
salt = Base64.decode64(key_derivation_node['manifest:salt'])
# The key is hashed with an algorithm represented by this URI
key_generation_name =
start_key_generation_node[
'manifest:start-key-generation-name'
]
hashed_password = password
if key_generation_name == 'http://www.w3.org/2000/09/xmldsig#sha256'
hashed_password = Digest::SHA256.digest(password)
else
fail ArgumentError, "Unknown key generation algorithm #{key_generation_name}"
end
cipher = find_cipher(
algorithm,
key_derivation_name,
hashed_password,
salt,
iteration_count,
iv
)
begin
decrypted = decrypt(content_entry, cipher)
# Finally, inflate the decrypted stream and overwrite
# content.xml
IO.binwrite(
roo_content_xml_path,
Zlib::Inflate.new(-Zlib::MAX_WBITS).inflate(decrypted)
)
rescue StandardError => error
raise ArgumentError, "Invalid password or other data error: #{error}"
end
else
fail ArgumentError, 'manifest.xml missing encryption-data elements'
end
end
|
[
"def",
"perform_decryption",
"(",
"encryption_data",
",",
"password",
",",
"content_entry",
",",
"roo_content_xml_path",
")",
"# Extract various expected attributes from the manifest that",
"# describe the encryption",
"algorithm_node",
"=",
"encryption_data",
".",
"xpath",
"(",
"'manifest:algorithm'",
")",
".",
"first",
"key_derivation_node",
"=",
"encryption_data",
".",
"xpath",
"(",
"'manifest:key-derivation'",
")",
".",
"first",
"start_key_generation_node",
"=",
"encryption_data",
".",
"xpath",
"(",
"'manifest:start-key-generation'",
")",
".",
"first",
"# If we have all the expected elements, then we can perform",
"# the decryption.",
"if",
"!",
"algorithm_node",
".",
"nil?",
"&&",
"!",
"key_derivation_node",
".",
"nil?",
"&&",
"!",
"start_key_generation_node",
".",
"nil?",
"# The algorithm is a URI describing the algorithm used",
"algorithm",
"=",
"algorithm_node",
"[",
"'manifest:algorithm-name'",
"]",
"# The initialization vector is base-64 encoded",
"iv",
"=",
"Base64",
".",
"decode64",
"(",
"algorithm_node",
"[",
"'manifest:initialisation-vector'",
"]",
")",
"key_derivation_name",
"=",
"key_derivation_node",
"[",
"'manifest:key-derivation-name'",
"]",
"iteration_count",
"=",
"key_derivation_node",
"[",
"'manifest:iteration-count'",
"]",
".",
"to_i",
"salt",
"=",
"Base64",
".",
"decode64",
"(",
"key_derivation_node",
"[",
"'manifest:salt'",
"]",
")",
"# The key is hashed with an algorithm represented by this URI",
"key_generation_name",
"=",
"start_key_generation_node",
"[",
"'manifest:start-key-generation-name'",
"]",
"hashed_password",
"=",
"password",
"if",
"key_generation_name",
"==",
"'http://www.w3.org/2000/09/xmldsig#sha256'",
"hashed_password",
"=",
"Digest",
"::",
"SHA256",
".",
"digest",
"(",
"password",
")",
"else",
"fail",
"ArgumentError",
",",
"\"Unknown key generation algorithm #{key_generation_name}\"",
"end",
"cipher",
"=",
"find_cipher",
"(",
"algorithm",
",",
"key_derivation_name",
",",
"hashed_password",
",",
"salt",
",",
"iteration_count",
",",
"iv",
")",
"begin",
"decrypted",
"=",
"decrypt",
"(",
"content_entry",
",",
"cipher",
")",
"# Finally, inflate the decrypted stream and overwrite",
"# content.xml",
"IO",
".",
"binwrite",
"(",
"roo_content_xml_path",
",",
"Zlib",
"::",
"Inflate",
".",
"new",
"(",
"-",
"Zlib",
"::",
"MAX_WBITS",
")",
".",
"inflate",
"(",
"decrypted",
")",
")",
"rescue",
"StandardError",
"=>",
"error",
"raise",
"ArgumentError",
",",
"\"Invalid password or other data error: #{error}\"",
"end",
"else",
"fail",
"ArgumentError",
",",
"'manifest.xml missing encryption-data elements'",
"end",
"end"
] |
Process the ODS encryption manifest and perform the decryption
|
[
"Process",
"the",
"ODS",
"encryption",
"manifest",
"and",
"perform",
"the",
"decryption"
] |
4ec1104f0c3c2a29711c0c907371cd2be12bcc3c
|
https://github.com/roo-rb/roo/blob/4ec1104f0c3c2a29711c0c907371cd2be12bcc3c/lib/roo/open_office.rb#L273-L344
|
11,377
|
roo-rb/roo
|
lib/roo/open_office.rb
|
Roo.OpenOffice.find_cipher_key
|
def find_cipher_key(*args)
fail ArgumentError, 'Unknown key derivation name ', args[1] unless args[1] == 'PBKDF2'
::OpenSSL::PKCS5.pbkdf2_hmac_sha1(args[2], args[3], args[4], args[0].key_len)
end
|
ruby
|
def find_cipher_key(*args)
fail ArgumentError, 'Unknown key derivation name ', args[1] unless args[1] == 'PBKDF2'
::OpenSSL::PKCS5.pbkdf2_hmac_sha1(args[2], args[3], args[4], args[0].key_len)
end
|
[
"def",
"find_cipher_key",
"(",
"*",
"args",
")",
"fail",
"ArgumentError",
",",
"'Unknown key derivation name '",
",",
"args",
"[",
"1",
"]",
"unless",
"args",
"[",
"1",
"]",
"==",
"'PBKDF2'",
"::",
"OpenSSL",
"::",
"PKCS5",
".",
"pbkdf2_hmac_sha1",
"(",
"args",
"[",
"2",
"]",
",",
"args",
"[",
"3",
"]",
",",
"args",
"[",
"4",
"]",
",",
"args",
"[",
"0",
"]",
".",
"key_len",
")",
"end"
] |
Create a cipher key based on an ODS algorithm string from manifest.xml
|
[
"Create",
"a",
"cipher",
"key",
"based",
"on",
"an",
"ODS",
"algorithm",
"string",
"from",
"manifest",
".",
"xml"
] |
4ec1104f0c3c2a29711c0c907371cd2be12bcc3c
|
https://github.com/roo-rb/roo/blob/4ec1104f0c3c2a29711c0c907371cd2be12bcc3c/lib/roo/open_office.rb#L361-L365
|
11,378
|
roo-rb/roo
|
lib/roo/open_office.rb
|
Roo.OpenOffice.decrypt
|
def decrypt(content_entry, cipher)
# Zip::Entry.extract writes a 0-length file when trying
# to extract an encrypted stream, so we read the
# raw bytes based on the offset and lengths
decrypted = ''
File.open(@filename, 'rb') do |zipfile|
zipfile.seek(
content_entry.local_header_offset +
content_entry.calculate_local_header_size
)
total_to_read = content_entry.compressed_size
block_size = 4096
block_size = total_to_read if block_size > total_to_read
while (buffer = zipfile.read(block_size))
decrypted += cipher.update(buffer)
total_to_read -= buffer.length
break if total_to_read == 0
block_size = total_to_read if block_size > total_to_read
end
end
decrypted + cipher.final
end
|
ruby
|
def decrypt(content_entry, cipher)
# Zip::Entry.extract writes a 0-length file when trying
# to extract an encrypted stream, so we read the
# raw bytes based on the offset and lengths
decrypted = ''
File.open(@filename, 'rb') do |zipfile|
zipfile.seek(
content_entry.local_header_offset +
content_entry.calculate_local_header_size
)
total_to_read = content_entry.compressed_size
block_size = 4096
block_size = total_to_read if block_size > total_to_read
while (buffer = zipfile.read(block_size))
decrypted += cipher.update(buffer)
total_to_read -= buffer.length
break if total_to_read == 0
block_size = total_to_read if block_size > total_to_read
end
end
decrypted + cipher.final
end
|
[
"def",
"decrypt",
"(",
"content_entry",
",",
"cipher",
")",
"# Zip::Entry.extract writes a 0-length file when trying",
"# to extract an encrypted stream, so we read the",
"# raw bytes based on the offset and lengths",
"decrypted",
"=",
"''",
"File",
".",
"open",
"(",
"@filename",
",",
"'rb'",
")",
"do",
"|",
"zipfile",
"|",
"zipfile",
".",
"seek",
"(",
"content_entry",
".",
"local_header_offset",
"+",
"content_entry",
".",
"calculate_local_header_size",
")",
"total_to_read",
"=",
"content_entry",
".",
"compressed_size",
"block_size",
"=",
"4096",
"block_size",
"=",
"total_to_read",
"if",
"block_size",
">",
"total_to_read",
"while",
"(",
"buffer",
"=",
"zipfile",
".",
"read",
"(",
"block_size",
")",
")",
"decrypted",
"+=",
"cipher",
".",
"update",
"(",
"buffer",
")",
"total_to_read",
"-=",
"buffer",
".",
"length",
"break",
"if",
"total_to_read",
"==",
"0",
"block_size",
"=",
"total_to_read",
"if",
"block_size",
">",
"total_to_read",
"end",
"end",
"decrypted",
"+",
"cipher",
".",
"final",
"end"
] |
Block decrypt raw bytes from the zip file based on the cipher
|
[
"Block",
"decrypt",
"raw",
"bytes",
"from",
"the",
"zip",
"file",
"based",
"on",
"the",
"cipher"
] |
4ec1104f0c3c2a29711c0c907371cd2be12bcc3c
|
https://github.com/roo-rb/roo/blob/4ec1104f0c3c2a29711c0c907371cd2be12bcc3c/lib/roo/open_office.rb#L368-L394
|
11,379
|
roo-rb/roo
|
lib/roo/open_office.rb
|
Roo.OpenOffice.set_cell_values
|
def set_cell_values(sheet, x, y, i, v, value_type, formula, table_cell, str_v, style_name)
key = [y, x + i]
@cell_type[sheet] ||= {}
@cell_type[sheet][key] = value_type.to_sym if value_type
@formula[sheet] ||= {}
if formula
['of:', 'oooc:'].each do |prefix|
if formula[0, prefix.length] == prefix
formula = formula[prefix.length..-1]
end
end
@formula[sheet][key] = formula
end
@cell[sheet] ||= {}
@style[sheet] ||= {}
@style[sheet][key] = style_name
case @cell_type[sheet][key]
when :float
@cell[sheet][key] = (table_cell.attributes['value'].to_s.include?(".") || table_cell.children.first.text.include?(".")) ? v.to_f : v.to_i
when :percentage
@cell[sheet][key] = v.to_f
when :string
@cell[sheet][key] = str_v
when :date
# TODO: if table_cell.attributes['date-value'].size != "XXXX-XX-XX".size
if attribute(table_cell, 'date-value').size != 'XXXX-XX-XX'.size
#-- dann ist noch eine Uhrzeit vorhanden
#-- "1961-11-21T12:17:18"
@cell[sheet][key] = DateTime.parse(attribute(table_cell, 'date-value').to_s)
@cell_type[sheet][key] = :datetime
else
@cell[sheet][key] = table_cell.attributes['date-value']
end
when :time
hms = v.split(':')
@cell[sheet][key] = hms[0].to_i * 3600 + hms[1].to_i * 60 + hms[2].to_i
else
@cell[sheet][key] = v
end
end
|
ruby
|
def set_cell_values(sheet, x, y, i, v, value_type, formula, table_cell, str_v, style_name)
key = [y, x + i]
@cell_type[sheet] ||= {}
@cell_type[sheet][key] = value_type.to_sym if value_type
@formula[sheet] ||= {}
if formula
['of:', 'oooc:'].each do |prefix|
if formula[0, prefix.length] == prefix
formula = formula[prefix.length..-1]
end
end
@formula[sheet][key] = formula
end
@cell[sheet] ||= {}
@style[sheet] ||= {}
@style[sheet][key] = style_name
case @cell_type[sheet][key]
when :float
@cell[sheet][key] = (table_cell.attributes['value'].to_s.include?(".") || table_cell.children.first.text.include?(".")) ? v.to_f : v.to_i
when :percentage
@cell[sheet][key] = v.to_f
when :string
@cell[sheet][key] = str_v
when :date
# TODO: if table_cell.attributes['date-value'].size != "XXXX-XX-XX".size
if attribute(table_cell, 'date-value').size != 'XXXX-XX-XX'.size
#-- dann ist noch eine Uhrzeit vorhanden
#-- "1961-11-21T12:17:18"
@cell[sheet][key] = DateTime.parse(attribute(table_cell, 'date-value').to_s)
@cell_type[sheet][key] = :datetime
else
@cell[sheet][key] = table_cell.attributes['date-value']
end
when :time
hms = v.split(':')
@cell[sheet][key] = hms[0].to_i * 3600 + hms[1].to_i * 60 + hms[2].to_i
else
@cell[sheet][key] = v
end
end
|
[
"def",
"set_cell_values",
"(",
"sheet",
",",
"x",
",",
"y",
",",
"i",
",",
"v",
",",
"value_type",
",",
"formula",
",",
"table_cell",
",",
"str_v",
",",
"style_name",
")",
"key",
"=",
"[",
"y",
",",
"x",
"+",
"i",
"]",
"@cell_type",
"[",
"sheet",
"]",
"||=",
"{",
"}",
"@cell_type",
"[",
"sheet",
"]",
"[",
"key",
"]",
"=",
"value_type",
".",
"to_sym",
"if",
"value_type",
"@formula",
"[",
"sheet",
"]",
"||=",
"{",
"}",
"if",
"formula",
"[",
"'of:'",
",",
"'oooc:'",
"]",
".",
"each",
"do",
"|",
"prefix",
"|",
"if",
"formula",
"[",
"0",
",",
"prefix",
".",
"length",
"]",
"==",
"prefix",
"formula",
"=",
"formula",
"[",
"prefix",
".",
"length",
"..",
"-",
"1",
"]",
"end",
"end",
"@formula",
"[",
"sheet",
"]",
"[",
"key",
"]",
"=",
"formula",
"end",
"@cell",
"[",
"sheet",
"]",
"||=",
"{",
"}",
"@style",
"[",
"sheet",
"]",
"||=",
"{",
"}",
"@style",
"[",
"sheet",
"]",
"[",
"key",
"]",
"=",
"style_name",
"case",
"@cell_type",
"[",
"sheet",
"]",
"[",
"key",
"]",
"when",
":float",
"@cell",
"[",
"sheet",
"]",
"[",
"key",
"]",
"=",
"(",
"table_cell",
".",
"attributes",
"[",
"'value'",
"]",
".",
"to_s",
".",
"include?",
"(",
"\".\"",
")",
"||",
"table_cell",
".",
"children",
".",
"first",
".",
"text",
".",
"include?",
"(",
"\".\"",
")",
")",
"?",
"v",
".",
"to_f",
":",
"v",
".",
"to_i",
"when",
":percentage",
"@cell",
"[",
"sheet",
"]",
"[",
"key",
"]",
"=",
"v",
".",
"to_f",
"when",
":string",
"@cell",
"[",
"sheet",
"]",
"[",
"key",
"]",
"=",
"str_v",
"when",
":date",
"# TODO: if table_cell.attributes['date-value'].size != \"XXXX-XX-XX\".size",
"if",
"attribute",
"(",
"table_cell",
",",
"'date-value'",
")",
".",
"size",
"!=",
"'XXXX-XX-XX'",
".",
"size",
"#-- dann ist noch eine Uhrzeit vorhanden",
"#-- \"1961-11-21T12:17:18\"",
"@cell",
"[",
"sheet",
"]",
"[",
"key",
"]",
"=",
"DateTime",
".",
"parse",
"(",
"attribute",
"(",
"table_cell",
",",
"'date-value'",
")",
".",
"to_s",
")",
"@cell_type",
"[",
"sheet",
"]",
"[",
"key",
"]",
"=",
":datetime",
"else",
"@cell",
"[",
"sheet",
"]",
"[",
"key",
"]",
"=",
"table_cell",
".",
"attributes",
"[",
"'date-value'",
"]",
"end",
"when",
":time",
"hms",
"=",
"v",
".",
"split",
"(",
"':'",
")",
"@cell",
"[",
"sheet",
"]",
"[",
"key",
"]",
"=",
"hms",
"[",
"0",
"]",
".",
"to_i",
"*",
"3600",
"+",
"hms",
"[",
"1",
"]",
".",
"to_i",
"*",
"60",
"+",
"hms",
"[",
"2",
"]",
".",
"to_i",
"else",
"@cell",
"[",
"sheet",
"]",
"[",
"key",
"]",
"=",
"v",
"end",
"end"
] |
helper function to set the internal representation of cells
|
[
"helper",
"function",
"to",
"set",
"the",
"internal",
"representation",
"of",
"cells"
] |
4ec1104f0c3c2a29711c0c907371cd2be12bcc3c
|
https://github.com/roo-rb/roo/blob/4ec1104f0c3c2a29711c0c907371cd2be12bcc3c/lib/roo/open_office.rb#L408-L447
|
11,380
|
roo-rb/roo
|
lib/roo/utils.rb
|
Roo.Utils.num_cells_in_range
|
def num_cells_in_range(str)
cells = str.split(':')
return 1 if cells.count == 1
raise ArgumentError.new("invalid range string: #{str}. Supported range format 'A1:B2'") if cells.count != 2
x1, y1 = extract_coordinate(cells[0])
x2, y2 = extract_coordinate(cells[1])
(x2 - (x1 - 1)) * (y2 - (y1 - 1))
end
|
ruby
|
def num_cells_in_range(str)
cells = str.split(':')
return 1 if cells.count == 1
raise ArgumentError.new("invalid range string: #{str}. Supported range format 'A1:B2'") if cells.count != 2
x1, y1 = extract_coordinate(cells[0])
x2, y2 = extract_coordinate(cells[1])
(x2 - (x1 - 1)) * (y2 - (y1 - 1))
end
|
[
"def",
"num_cells_in_range",
"(",
"str",
")",
"cells",
"=",
"str",
".",
"split",
"(",
"':'",
")",
"return",
"1",
"if",
"cells",
".",
"count",
"==",
"1",
"raise",
"ArgumentError",
".",
"new",
"(",
"\"invalid range string: #{str}. Supported range format 'A1:B2'\"",
")",
"if",
"cells",
".",
"count",
"!=",
"2",
"x1",
",",
"y1",
"=",
"extract_coordinate",
"(",
"cells",
"[",
"0",
"]",
")",
"x2",
",",
"y2",
"=",
"extract_coordinate",
"(",
"cells",
"[",
"1",
"]",
")",
"(",
"x2",
"-",
"(",
"x1",
"-",
"1",
")",
")",
"*",
"(",
"y2",
"-",
"(",
"y1",
"-",
"1",
")",
")",
"end"
] |
Compute upper bound for cells in a given cell range.
|
[
"Compute",
"upper",
"bound",
"for",
"cells",
"in",
"a",
"given",
"cell",
"range",
"."
] |
4ec1104f0c3c2a29711c0c907371cd2be12bcc3c
|
https://github.com/roo-rb/roo/blob/4ec1104f0c3c2a29711c0c907371cd2be12bcc3c/lib/roo/utils.rb#L69-L76
|
11,381
|
castwide/solargraph
|
lib/solargraph/api_map.rb
|
Solargraph.ApiMap.catalog
|
def catalog bundle
new_map_hash = {}
# Bundle always needs to be merged if it adds or removes sources
merged = (bundle.sources.length == source_map_hash.values.length)
bundle.sources.each do |source|
if source_map_hash.key?(source.filename)
if source_map_hash[source.filename].code == source.code && source_map_hash[source.filename].source.synchronized? && source.synchronized?
new_map_hash[source.filename] = source_map_hash[source.filename]
elsif !source.synchronized?
new_map_hash[source.filename] = source_map_hash[source.filename]
# @todo Smelly instance variable access
new_map_hash[source.filename].instance_variable_set(:@source, source)
else
map = Solargraph::SourceMap.map(source)
if source_map_hash[source.filename].try_merge!(map)
new_map_hash[source.filename] = source_map_hash[source.filename]
else
new_map_hash[source.filename] = map
merged = false
end
end
else
map = Solargraph::SourceMap.map(source)
new_map_hash[source.filename] = map
merged = false
end
end
return self if merged
pins = []
reqs = []
# @param map [SourceMap]
new_map_hash.values.each do |map|
pins.concat map.pins
reqs.concat map.requires.map(&:name)
end
reqs.concat bundle.workspace.config.required
unless bundle.workspace.require_paths.empty?
reqs.delete_if do |r|
result = false
bundle.workspace.require_paths.each do |l|
pn = Pathname.new(bundle.workspace.directory).join(l, "#{r}.rb")
if new_map_hash.keys.include?(pn.to_s)
result = true
break
end
end
result
end
end
yard_map.change(reqs)
new_store = Store.new(pins + yard_map.pins)
@mutex.synchronize {
@cache.clear
@source_map_hash = new_map_hash
@store = new_store
@unresolved_requires = yard_map.unresolved_requires
}
# resolve_method_aliases
self
end
|
ruby
|
def catalog bundle
new_map_hash = {}
# Bundle always needs to be merged if it adds or removes sources
merged = (bundle.sources.length == source_map_hash.values.length)
bundle.sources.each do |source|
if source_map_hash.key?(source.filename)
if source_map_hash[source.filename].code == source.code && source_map_hash[source.filename].source.synchronized? && source.synchronized?
new_map_hash[source.filename] = source_map_hash[source.filename]
elsif !source.synchronized?
new_map_hash[source.filename] = source_map_hash[source.filename]
# @todo Smelly instance variable access
new_map_hash[source.filename].instance_variable_set(:@source, source)
else
map = Solargraph::SourceMap.map(source)
if source_map_hash[source.filename].try_merge!(map)
new_map_hash[source.filename] = source_map_hash[source.filename]
else
new_map_hash[source.filename] = map
merged = false
end
end
else
map = Solargraph::SourceMap.map(source)
new_map_hash[source.filename] = map
merged = false
end
end
return self if merged
pins = []
reqs = []
# @param map [SourceMap]
new_map_hash.values.each do |map|
pins.concat map.pins
reqs.concat map.requires.map(&:name)
end
reqs.concat bundle.workspace.config.required
unless bundle.workspace.require_paths.empty?
reqs.delete_if do |r|
result = false
bundle.workspace.require_paths.each do |l|
pn = Pathname.new(bundle.workspace.directory).join(l, "#{r}.rb")
if new_map_hash.keys.include?(pn.to_s)
result = true
break
end
end
result
end
end
yard_map.change(reqs)
new_store = Store.new(pins + yard_map.pins)
@mutex.synchronize {
@cache.clear
@source_map_hash = new_map_hash
@store = new_store
@unresolved_requires = yard_map.unresolved_requires
}
# resolve_method_aliases
self
end
|
[
"def",
"catalog",
"bundle",
"new_map_hash",
"=",
"{",
"}",
"# Bundle always needs to be merged if it adds or removes sources",
"merged",
"=",
"(",
"bundle",
".",
"sources",
".",
"length",
"==",
"source_map_hash",
".",
"values",
".",
"length",
")",
"bundle",
".",
"sources",
".",
"each",
"do",
"|",
"source",
"|",
"if",
"source_map_hash",
".",
"key?",
"(",
"source",
".",
"filename",
")",
"if",
"source_map_hash",
"[",
"source",
".",
"filename",
"]",
".",
"code",
"==",
"source",
".",
"code",
"&&",
"source_map_hash",
"[",
"source",
".",
"filename",
"]",
".",
"source",
".",
"synchronized?",
"&&",
"source",
".",
"synchronized?",
"new_map_hash",
"[",
"source",
".",
"filename",
"]",
"=",
"source_map_hash",
"[",
"source",
".",
"filename",
"]",
"elsif",
"!",
"source",
".",
"synchronized?",
"new_map_hash",
"[",
"source",
".",
"filename",
"]",
"=",
"source_map_hash",
"[",
"source",
".",
"filename",
"]",
"# @todo Smelly instance variable access",
"new_map_hash",
"[",
"source",
".",
"filename",
"]",
".",
"instance_variable_set",
"(",
":@source",
",",
"source",
")",
"else",
"map",
"=",
"Solargraph",
"::",
"SourceMap",
".",
"map",
"(",
"source",
")",
"if",
"source_map_hash",
"[",
"source",
".",
"filename",
"]",
".",
"try_merge!",
"(",
"map",
")",
"new_map_hash",
"[",
"source",
".",
"filename",
"]",
"=",
"source_map_hash",
"[",
"source",
".",
"filename",
"]",
"else",
"new_map_hash",
"[",
"source",
".",
"filename",
"]",
"=",
"map",
"merged",
"=",
"false",
"end",
"end",
"else",
"map",
"=",
"Solargraph",
"::",
"SourceMap",
".",
"map",
"(",
"source",
")",
"new_map_hash",
"[",
"source",
".",
"filename",
"]",
"=",
"map",
"merged",
"=",
"false",
"end",
"end",
"return",
"self",
"if",
"merged",
"pins",
"=",
"[",
"]",
"reqs",
"=",
"[",
"]",
"# @param map [SourceMap]",
"new_map_hash",
".",
"values",
".",
"each",
"do",
"|",
"map",
"|",
"pins",
".",
"concat",
"map",
".",
"pins",
"reqs",
".",
"concat",
"map",
".",
"requires",
".",
"map",
"(",
":name",
")",
"end",
"reqs",
".",
"concat",
"bundle",
".",
"workspace",
".",
"config",
".",
"required",
"unless",
"bundle",
".",
"workspace",
".",
"require_paths",
".",
"empty?",
"reqs",
".",
"delete_if",
"do",
"|",
"r",
"|",
"result",
"=",
"false",
"bundle",
".",
"workspace",
".",
"require_paths",
".",
"each",
"do",
"|",
"l",
"|",
"pn",
"=",
"Pathname",
".",
"new",
"(",
"bundle",
".",
"workspace",
".",
"directory",
")",
".",
"join",
"(",
"l",
",",
"\"#{r}.rb\"",
")",
"if",
"new_map_hash",
".",
"keys",
".",
"include?",
"(",
"pn",
".",
"to_s",
")",
"result",
"=",
"true",
"break",
"end",
"end",
"result",
"end",
"end",
"yard_map",
".",
"change",
"(",
"reqs",
")",
"new_store",
"=",
"Store",
".",
"new",
"(",
"pins",
"+",
"yard_map",
".",
"pins",
")",
"@mutex",
".",
"synchronize",
"{",
"@cache",
".",
"clear",
"@source_map_hash",
"=",
"new_map_hash",
"@store",
"=",
"new_store",
"@unresolved_requires",
"=",
"yard_map",
".",
"unresolved_requires",
"}",
"# resolve_method_aliases",
"self",
"end"
] |
Catalog a bundle.
@param bundle [Bundle]
@return [self]
|
[
"Catalog",
"a",
"bundle",
"."
] |
47badb5d151aca775ccbe6c470236089eae7839d
|
https://github.com/castwide/solargraph/blob/47badb5d151aca775ccbe6c470236089eae7839d/lib/solargraph/api_map.rb#L64-L123
|
11,382
|
castwide/solargraph
|
lib/solargraph/api_map.rb
|
Solargraph.ApiMap.clip_at
|
def clip_at filename, position
position = Position.normalize(position)
SourceMap::Clip.new(self, cursor_at(filename, position))
end
|
ruby
|
def clip_at filename, position
position = Position.normalize(position)
SourceMap::Clip.new(self, cursor_at(filename, position))
end
|
[
"def",
"clip_at",
"filename",
",",
"position",
"position",
"=",
"Position",
".",
"normalize",
"(",
"position",
")",
"SourceMap",
"::",
"Clip",
".",
"new",
"(",
"self",
",",
"cursor_at",
"(",
"filename",
",",
"position",
")",
")",
"end"
] |
Get a clip by filename and position.
@param filename [String]
@param position [Position, Array(Integer, Integer)]
@return [SourceMap::Clip]
|
[
"Get",
"a",
"clip",
"by",
"filename",
"and",
"position",
"."
] |
47badb5d151aca775ccbe6c470236089eae7839d
|
https://github.com/castwide/solargraph/blob/47badb5d151aca775ccbe6c470236089eae7839d/lib/solargraph/api_map.rb#L139-L142
|
11,383
|
castwide/solargraph
|
lib/solargraph/api_map.rb
|
Solargraph.ApiMap.get_constants
|
def get_constants namespace, context = ''
namespace ||= ''
cached = cache.get_constants(namespace, context)
return cached.clone unless cached.nil?
skip = []
result = []
bases = context.split('::')
while bases.length > 0
built = bases.join('::')
fqns = qualify(namespace, built)
visibility = [:public]
visibility.push :private if fqns == context
result.concat inner_get_constants(fqns, visibility, skip)
bases.pop
end
fqns = qualify(namespace, '')
visibility = [:public]
visibility.push :private if fqns == context
result.concat inner_get_constants(fqns, visibility, skip)
cache.set_constants(namespace, context, result)
result
end
|
ruby
|
def get_constants namespace, context = ''
namespace ||= ''
cached = cache.get_constants(namespace, context)
return cached.clone unless cached.nil?
skip = []
result = []
bases = context.split('::')
while bases.length > 0
built = bases.join('::')
fqns = qualify(namespace, built)
visibility = [:public]
visibility.push :private if fqns == context
result.concat inner_get_constants(fqns, visibility, skip)
bases.pop
end
fqns = qualify(namespace, '')
visibility = [:public]
visibility.push :private if fqns == context
result.concat inner_get_constants(fqns, visibility, skip)
cache.set_constants(namespace, context, result)
result
end
|
[
"def",
"get_constants",
"namespace",
",",
"context",
"=",
"''",
"namespace",
"||=",
"''",
"cached",
"=",
"cache",
".",
"get_constants",
"(",
"namespace",
",",
"context",
")",
"return",
"cached",
".",
"clone",
"unless",
"cached",
".",
"nil?",
"skip",
"=",
"[",
"]",
"result",
"=",
"[",
"]",
"bases",
"=",
"context",
".",
"split",
"(",
"'::'",
")",
"while",
"bases",
".",
"length",
">",
"0",
"built",
"=",
"bases",
".",
"join",
"(",
"'::'",
")",
"fqns",
"=",
"qualify",
"(",
"namespace",
",",
"built",
")",
"visibility",
"=",
"[",
":public",
"]",
"visibility",
".",
"push",
":private",
"if",
"fqns",
"==",
"context",
"result",
".",
"concat",
"inner_get_constants",
"(",
"fqns",
",",
"visibility",
",",
"skip",
")",
"bases",
".",
"pop",
"end",
"fqns",
"=",
"qualify",
"(",
"namespace",
",",
"''",
")",
"visibility",
"=",
"[",
":public",
"]",
"visibility",
".",
"push",
":private",
"if",
"fqns",
"==",
"context",
"result",
".",
"concat",
"inner_get_constants",
"(",
"fqns",
",",
"visibility",
",",
"skip",
")",
"cache",
".",
"set_constants",
"(",
"namespace",
",",
"context",
",",
"result",
")",
"result",
"end"
] |
Get suggestions for constants in the specified namespace. The result
may contain both constant and namespace pins.
@param namespace [String] The namespace
@param context [String] The context
@return [Array<Solargraph::Pin::Base>]
|
[
"Get",
"suggestions",
"for",
"constants",
"in",
"the",
"specified",
"namespace",
".",
"The",
"result",
"may",
"contain",
"both",
"constant",
"and",
"namespace",
"pins",
"."
] |
47badb5d151aca775ccbe6c470236089eae7839d
|
https://github.com/castwide/solargraph/blob/47badb5d151aca775ccbe6c470236089eae7839d/lib/solargraph/api_map.rb#L191-L212
|
11,384
|
castwide/solargraph
|
lib/solargraph/api_map.rb
|
Solargraph.ApiMap.qualify
|
def qualify namespace, context = ''
# @todo The return for self might work better elsewhere
return nil if namespace.nil?
return qualify(context) if namespace == 'self'
cached = cache.get_qualified_namespace(namespace, context)
return cached.clone unless cached.nil?
result = if namespace.start_with?('::')
inner_qualify(namespace[2..-1], '', [])
else
inner_qualify(namespace, context, [])
end
cache.set_qualified_namespace(namespace, context, result)
result
end
|
ruby
|
def qualify namespace, context = ''
# @todo The return for self might work better elsewhere
return nil if namespace.nil?
return qualify(context) if namespace == 'self'
cached = cache.get_qualified_namespace(namespace, context)
return cached.clone unless cached.nil?
result = if namespace.start_with?('::')
inner_qualify(namespace[2..-1], '', [])
else
inner_qualify(namespace, context, [])
end
cache.set_qualified_namespace(namespace, context, result)
result
end
|
[
"def",
"qualify",
"namespace",
",",
"context",
"=",
"''",
"# @todo The return for self might work better elsewhere",
"return",
"nil",
"if",
"namespace",
".",
"nil?",
"return",
"qualify",
"(",
"context",
")",
"if",
"namespace",
"==",
"'self'",
"cached",
"=",
"cache",
".",
"get_qualified_namespace",
"(",
"namespace",
",",
"context",
")",
"return",
"cached",
".",
"clone",
"unless",
"cached",
".",
"nil?",
"result",
"=",
"if",
"namespace",
".",
"start_with?",
"(",
"'::'",
")",
"inner_qualify",
"(",
"namespace",
"[",
"2",
"..",
"-",
"1",
"]",
",",
"''",
",",
"[",
"]",
")",
"else",
"inner_qualify",
"(",
"namespace",
",",
"context",
",",
"[",
"]",
")",
"end",
"cache",
".",
"set_qualified_namespace",
"(",
"namespace",
",",
"context",
",",
"result",
")",
"result",
"end"
] |
Get a fully qualified namespace name. This method will start the search
in the specified context until it finds a match for the name.
@param namespace [String, nil] The namespace to match
@param context [String] The context to search
@return [String]
|
[
"Get",
"a",
"fully",
"qualified",
"namespace",
"name",
".",
"This",
"method",
"will",
"start",
"the",
"search",
"in",
"the",
"specified",
"context",
"until",
"it",
"finds",
"a",
"match",
"for",
"the",
"name",
"."
] |
47badb5d151aca775ccbe6c470236089eae7839d
|
https://github.com/castwide/solargraph/blob/47badb5d151aca775ccbe6c470236089eae7839d/lib/solargraph/api_map.rb#L220-L233
|
11,385
|
castwide/solargraph
|
lib/solargraph/api_map.rb
|
Solargraph.ApiMap.get_instance_variable_pins
|
def get_instance_variable_pins(namespace, scope = :instance)
result = []
result.concat store.get_instance_variables(namespace, scope)
sc = qualify(store.get_superclass(namespace), namespace)
until sc.nil?
result.concat store.get_instance_variables(sc, scope)
sc = qualify(store.get_superclass(sc), sc)
end
result
end
|
ruby
|
def get_instance_variable_pins(namespace, scope = :instance)
result = []
result.concat store.get_instance_variables(namespace, scope)
sc = qualify(store.get_superclass(namespace), namespace)
until sc.nil?
result.concat store.get_instance_variables(sc, scope)
sc = qualify(store.get_superclass(sc), sc)
end
result
end
|
[
"def",
"get_instance_variable_pins",
"(",
"namespace",
",",
"scope",
"=",
":instance",
")",
"result",
"=",
"[",
"]",
"result",
".",
"concat",
"store",
".",
"get_instance_variables",
"(",
"namespace",
",",
"scope",
")",
"sc",
"=",
"qualify",
"(",
"store",
".",
"get_superclass",
"(",
"namespace",
")",
",",
"namespace",
")",
"until",
"sc",
".",
"nil?",
"result",
".",
"concat",
"store",
".",
"get_instance_variables",
"(",
"sc",
",",
"scope",
")",
"sc",
"=",
"qualify",
"(",
"store",
".",
"get_superclass",
"(",
"sc",
")",
",",
"sc",
")",
"end",
"result",
"end"
] |
Get an array of instance variable pins defined in specified namespace
and scope.
@param namespace [String] A fully qualified namespace
@param scope [Symbol] :instance or :class
@return [Array<Solargraph::Pin::InstanceVariable>]
|
[
"Get",
"an",
"array",
"of",
"instance",
"variable",
"pins",
"defined",
"in",
"specified",
"namespace",
"and",
"scope",
"."
] |
47badb5d151aca775ccbe6c470236089eae7839d
|
https://github.com/castwide/solargraph/blob/47badb5d151aca775ccbe6c470236089eae7839d/lib/solargraph/api_map.rb#L241-L250
|
11,386
|
castwide/solargraph
|
lib/solargraph/api_map.rb
|
Solargraph.ApiMap.get_methods
|
def get_methods fqns, scope: :instance, visibility: [:public], deep: true
cached = cache.get_methods(fqns, scope, visibility, deep)
return cached.clone unless cached.nil?
result = []
skip = []
if fqns == ''
# @todo Implement domains
# domains.each do |domain|
# type = ComplexType.parse(domain).first
# result.concat inner_get_methods(type.name, type.scope, [:public], deep, skip)
# end
result.concat inner_get_methods(fqns, :class, visibility, deep, skip)
result.concat inner_get_methods(fqns, :instance, visibility, deep, skip)
result.concat inner_get_methods('Kernel', :instance, visibility, deep, skip)
else
result.concat inner_get_methods(fqns, scope, visibility, deep, skip)
end
# live = live_map.get_methods(fqns, '', scope.to_s, visibility.include?(:private))
# unless live.empty?
# exist = result.map(&:name)
# result.concat live.reject{|p| exist.include?(p.name)}
# end
resolved = resolve_method_aliases(result)
cache.set_methods(fqns, scope, visibility, deep, resolved)
resolved
end
|
ruby
|
def get_methods fqns, scope: :instance, visibility: [:public], deep: true
cached = cache.get_methods(fqns, scope, visibility, deep)
return cached.clone unless cached.nil?
result = []
skip = []
if fqns == ''
# @todo Implement domains
# domains.each do |domain|
# type = ComplexType.parse(domain).first
# result.concat inner_get_methods(type.name, type.scope, [:public], deep, skip)
# end
result.concat inner_get_methods(fqns, :class, visibility, deep, skip)
result.concat inner_get_methods(fqns, :instance, visibility, deep, skip)
result.concat inner_get_methods('Kernel', :instance, visibility, deep, skip)
else
result.concat inner_get_methods(fqns, scope, visibility, deep, skip)
end
# live = live_map.get_methods(fqns, '', scope.to_s, visibility.include?(:private))
# unless live.empty?
# exist = result.map(&:name)
# result.concat live.reject{|p| exist.include?(p.name)}
# end
resolved = resolve_method_aliases(result)
cache.set_methods(fqns, scope, visibility, deep, resolved)
resolved
end
|
[
"def",
"get_methods",
"fqns",
",",
"scope",
":",
":instance",
",",
"visibility",
":",
"[",
":public",
"]",
",",
"deep",
":",
"true",
"cached",
"=",
"cache",
".",
"get_methods",
"(",
"fqns",
",",
"scope",
",",
"visibility",
",",
"deep",
")",
"return",
"cached",
".",
"clone",
"unless",
"cached",
".",
"nil?",
"result",
"=",
"[",
"]",
"skip",
"=",
"[",
"]",
"if",
"fqns",
"==",
"''",
"# @todo Implement domains",
"# domains.each do |domain|",
"# type = ComplexType.parse(domain).first",
"# result.concat inner_get_methods(type.name, type.scope, [:public], deep, skip)",
"# end",
"result",
".",
"concat",
"inner_get_methods",
"(",
"fqns",
",",
":class",
",",
"visibility",
",",
"deep",
",",
"skip",
")",
"result",
".",
"concat",
"inner_get_methods",
"(",
"fqns",
",",
":instance",
",",
"visibility",
",",
"deep",
",",
"skip",
")",
"result",
".",
"concat",
"inner_get_methods",
"(",
"'Kernel'",
",",
":instance",
",",
"visibility",
",",
"deep",
",",
"skip",
")",
"else",
"result",
".",
"concat",
"inner_get_methods",
"(",
"fqns",
",",
"scope",
",",
"visibility",
",",
"deep",
",",
"skip",
")",
"end",
"# live = live_map.get_methods(fqns, '', scope.to_s, visibility.include?(:private))",
"# unless live.empty?",
"# exist = result.map(&:name)",
"# result.concat live.reject{|p| exist.include?(p.name)}",
"# end",
"resolved",
"=",
"resolve_method_aliases",
"(",
"result",
")",
"cache",
".",
"set_methods",
"(",
"fqns",
",",
"scope",
",",
"visibility",
",",
"deep",
",",
"resolved",
")",
"resolved",
"end"
] |
Get an array of methods available in a particular context.
@param fqns [String] The fully qualified namespace to search for methods
@param scope [Symbol] :class or :instance
@param visibility [Array<Symbol>] :public, :protected, and/or :private
@param deep [Boolean] True to include superclasses, mixins, etc.
@return [Array<Solargraph::Pin::Base>]
|
[
"Get",
"an",
"array",
"of",
"methods",
"available",
"in",
"a",
"particular",
"context",
"."
] |
47badb5d151aca775ccbe6c470236089eae7839d
|
https://github.com/castwide/solargraph/blob/47badb5d151aca775ccbe6c470236089eae7839d/lib/solargraph/api_map.rb#L278-L303
|
11,387
|
castwide/solargraph
|
lib/solargraph/api_map.rb
|
Solargraph.ApiMap.get_complex_type_methods
|
def get_complex_type_methods type, context = '', internal = false
# This method does not qualify the complex type's namespace because
# it can cause conflicts between similar names, e.g., `Foo` vs.
# `Other::Foo`. It still takes a context argument to determine whether
# protected and private methods are visible.
return [] if type.undefined? || type.void?
result = []
if type.duck_type?
type.select(&:duck_type?).each do |t|
result.push Pin::DuckMethod.new(nil, t.tag[1..-1])
end
result.concat get_methods('Object')
else
unless type.nil? || type.name == 'void'
visibility = [:public]
if type.namespace == context || super_and_sub?(type.namespace, context)
visibility.push :protected
visibility.push :private if internal
end
result.concat get_methods(type.namespace, scope: type.scope, visibility: visibility)
end
end
result
end
|
ruby
|
def get_complex_type_methods type, context = '', internal = false
# This method does not qualify the complex type's namespace because
# it can cause conflicts between similar names, e.g., `Foo` vs.
# `Other::Foo`. It still takes a context argument to determine whether
# protected and private methods are visible.
return [] if type.undefined? || type.void?
result = []
if type.duck_type?
type.select(&:duck_type?).each do |t|
result.push Pin::DuckMethod.new(nil, t.tag[1..-1])
end
result.concat get_methods('Object')
else
unless type.nil? || type.name == 'void'
visibility = [:public]
if type.namespace == context || super_and_sub?(type.namespace, context)
visibility.push :protected
visibility.push :private if internal
end
result.concat get_methods(type.namespace, scope: type.scope, visibility: visibility)
end
end
result
end
|
[
"def",
"get_complex_type_methods",
"type",
",",
"context",
"=",
"''",
",",
"internal",
"=",
"false",
"# This method does not qualify the complex type's namespace because",
"# it can cause conflicts between similar names, e.g., `Foo` vs.",
"# `Other::Foo`. It still takes a context argument to determine whether",
"# protected and private methods are visible.",
"return",
"[",
"]",
"if",
"type",
".",
"undefined?",
"||",
"type",
".",
"void?",
"result",
"=",
"[",
"]",
"if",
"type",
".",
"duck_type?",
"type",
".",
"select",
"(",
":duck_type?",
")",
".",
"each",
"do",
"|",
"t",
"|",
"result",
".",
"push",
"Pin",
"::",
"DuckMethod",
".",
"new",
"(",
"nil",
",",
"t",
".",
"tag",
"[",
"1",
"..",
"-",
"1",
"]",
")",
"end",
"result",
".",
"concat",
"get_methods",
"(",
"'Object'",
")",
"else",
"unless",
"type",
".",
"nil?",
"||",
"type",
".",
"name",
"==",
"'void'",
"visibility",
"=",
"[",
":public",
"]",
"if",
"type",
".",
"namespace",
"==",
"context",
"||",
"super_and_sub?",
"(",
"type",
".",
"namespace",
",",
"context",
")",
"visibility",
".",
"push",
":protected",
"visibility",
".",
"push",
":private",
"if",
"internal",
"end",
"result",
".",
"concat",
"get_methods",
"(",
"type",
".",
"namespace",
",",
"scope",
":",
"type",
".",
"scope",
",",
"visibility",
":",
"visibility",
")",
"end",
"end",
"result",
"end"
] |
Get an array of method pins for a complex type.
The type's namespace and the context should be fully qualified. If the
context matches the namespace type or is a subclass of the type,
protected methods are included in the results. If protected methods are
included and internal is true, private methods are also included.
@example
api_map = Solargraph::ApiMap.new
type = Solargraph::ComplexType.parse('String')
api_map.get_complex_type_methods(type)
@param type [Solargraph::ComplexType] The complex type of the namespace
@param context [String] The context from which the type is referenced
@param internal [Boolean] True to include private methods
@return [Array<Solargraph::Pin::Base>]
|
[
"Get",
"an",
"array",
"of",
"method",
"pins",
"for",
"a",
"complex",
"type",
"."
] |
47badb5d151aca775ccbe6c470236089eae7839d
|
https://github.com/castwide/solargraph/blob/47badb5d151aca775ccbe6c470236089eae7839d/lib/solargraph/api_map.rb#L321-L344
|
11,388
|
castwide/solargraph
|
lib/solargraph/api_map.rb
|
Solargraph.ApiMap.get_method_stack
|
def get_method_stack fqns, name, scope: :instance
get_methods(fqns, scope: scope, visibility: [:private, :protected, :public]).select{|p| p.name == name}
end
|
ruby
|
def get_method_stack fqns, name, scope: :instance
get_methods(fqns, scope: scope, visibility: [:private, :protected, :public]).select{|p| p.name == name}
end
|
[
"def",
"get_method_stack",
"fqns",
",",
"name",
",",
"scope",
":",
":instance",
"get_methods",
"(",
"fqns",
",",
"scope",
":",
"scope",
",",
"visibility",
":",
"[",
":private",
",",
":protected",
",",
":public",
"]",
")",
".",
"select",
"{",
"|",
"p",
"|",
"p",
".",
"name",
"==",
"name",
"}",
"end"
] |
Get a stack of method pins for a method name in a namespace. The order
of the pins corresponds to the ancestry chain, with highest precedence
first.
@example
api_map.get_method_stack('Subclass', 'method_name')
#=> [ <Subclass#method_name pin>, <Superclass#method_name pin> ]
@param fqns [String]
@param name [String]
@param scope [Symbol] :instance or :class
@return [Array<Solargraph::Pin::Base>]
|
[
"Get",
"a",
"stack",
"of",
"method",
"pins",
"for",
"a",
"method",
"name",
"in",
"a",
"namespace",
".",
"The",
"order",
"of",
"the",
"pins",
"corresponds",
"to",
"the",
"ancestry",
"chain",
"with",
"highest",
"precedence",
"first",
"."
] |
47badb5d151aca775ccbe6c470236089eae7839d
|
https://github.com/castwide/solargraph/blob/47badb5d151aca775ccbe6c470236089eae7839d/lib/solargraph/api_map.rb#L358-L360
|
11,389
|
castwide/solargraph
|
lib/solargraph/api_map.rb
|
Solargraph.ApiMap.get_path_suggestions
|
def get_path_suggestions path
return [] if path.nil?
result = []
result.concat store.get_path_pins(path)
# if result.empty?
# lp = live_map.get_path_pin(path)
# result.push lp unless lp.nil?
# end
resolve_method_aliases(result)
end
|
ruby
|
def get_path_suggestions path
return [] if path.nil?
result = []
result.concat store.get_path_pins(path)
# if result.empty?
# lp = live_map.get_path_pin(path)
# result.push lp unless lp.nil?
# end
resolve_method_aliases(result)
end
|
[
"def",
"get_path_suggestions",
"path",
"return",
"[",
"]",
"if",
"path",
".",
"nil?",
"result",
"=",
"[",
"]",
"result",
".",
"concat",
"store",
".",
"get_path_pins",
"(",
"path",
")",
"# if result.empty?",
"# lp = live_map.get_path_pin(path)",
"# result.push lp unless lp.nil?",
"# end",
"resolve_method_aliases",
"(",
"result",
")",
"end"
] |
Get an array of all suggestions that match the specified path.
@deprecated Use #get_path_pins instead.
@param path [String] The path to find
@return [Array<Solargraph::Pin::Base>]
|
[
"Get",
"an",
"array",
"of",
"all",
"suggestions",
"that",
"match",
"the",
"specified",
"path",
"."
] |
47badb5d151aca775ccbe6c470236089eae7839d
|
https://github.com/castwide/solargraph/blob/47badb5d151aca775ccbe6c470236089eae7839d/lib/solargraph/api_map.rb#L368-L377
|
11,390
|
castwide/solargraph
|
lib/solargraph/api_map.rb
|
Solargraph.ApiMap.search
|
def search query
rake_yard(store)
found = []
code_object_paths.each do |k|
if found.empty? || (query.include?('.') || query.include?('#')) || !(k.include?('.') || k.include?('#'))
found.push k if k.downcase.include?(query.downcase)
end
end
found
end
|
ruby
|
def search query
rake_yard(store)
found = []
code_object_paths.each do |k|
if found.empty? || (query.include?('.') || query.include?('#')) || !(k.include?('.') || k.include?('#'))
found.push k if k.downcase.include?(query.downcase)
end
end
found
end
|
[
"def",
"search",
"query",
"rake_yard",
"(",
"store",
")",
"found",
"=",
"[",
"]",
"code_object_paths",
".",
"each",
"do",
"|",
"k",
"|",
"if",
"found",
".",
"empty?",
"||",
"(",
"query",
".",
"include?",
"(",
"'.'",
")",
"||",
"query",
".",
"include?",
"(",
"'#'",
")",
")",
"||",
"!",
"(",
"k",
".",
"include?",
"(",
"'.'",
")",
"||",
"k",
".",
"include?",
"(",
"'#'",
")",
")",
"found",
".",
"push",
"k",
"if",
"k",
".",
"downcase",
".",
"include?",
"(",
"query",
".",
"downcase",
")",
"end",
"end",
"found",
"end"
] |
Get a list of documented paths that match the query.
@example
api_map.query('str') # Results will include `String` and `Struct`
@param query [String] The text to match
@return [Array<String>]
|
[
"Get",
"a",
"list",
"of",
"documented",
"paths",
"that",
"match",
"the",
"query",
"."
] |
47badb5d151aca775ccbe6c470236089eae7839d
|
https://github.com/castwide/solargraph/blob/47badb5d151aca775ccbe6c470236089eae7839d/lib/solargraph/api_map.rb#L394-L403
|
11,391
|
castwide/solargraph
|
lib/solargraph/api_map.rb
|
Solargraph.ApiMap.document
|
def document path
rake_yard(store)
docs = []
docs.push code_object_at(path) unless code_object_at(path).nil?
docs
end
|
ruby
|
def document path
rake_yard(store)
docs = []
docs.push code_object_at(path) unless code_object_at(path).nil?
docs
end
|
[
"def",
"document",
"path",
"rake_yard",
"(",
"store",
")",
"docs",
"=",
"[",
"]",
"docs",
".",
"push",
"code_object_at",
"(",
"path",
")",
"unless",
"code_object_at",
"(",
"path",
")",
".",
"nil?",
"docs",
"end"
] |
Get YARD documentation for the specified path.
@example
api_map.document('String#split')
@param path [String] The path to find
@return [Array<YARD::CodeObject::Base>]
|
[
"Get",
"YARD",
"documentation",
"for",
"the",
"specified",
"path",
"."
] |
47badb5d151aca775ccbe6c470236089eae7839d
|
https://github.com/castwide/solargraph/blob/47badb5d151aca775ccbe6c470236089eae7839d/lib/solargraph/api_map.rb#L412-L417
|
11,392
|
castwide/solargraph
|
lib/solargraph/api_map.rb
|
Solargraph.ApiMap.query_symbols
|
def query_symbols query
result = []
source_map_hash.values.each do |s|
result.concat s.query_symbols(query)
end
result
end
|
ruby
|
def query_symbols query
result = []
source_map_hash.values.each do |s|
result.concat s.query_symbols(query)
end
result
end
|
[
"def",
"query_symbols",
"query",
"result",
"=",
"[",
"]",
"source_map_hash",
".",
"values",
".",
"each",
"do",
"|",
"s",
"|",
"result",
".",
"concat",
"s",
".",
"query_symbols",
"(",
"query",
")",
"end",
"result",
"end"
] |
Get an array of all symbols in the workspace that match the query.
@param query [String]
@return [Array<Pin::Base>]
|
[
"Get",
"an",
"array",
"of",
"all",
"symbols",
"in",
"the",
"workspace",
"that",
"match",
"the",
"query",
"."
] |
47badb5d151aca775ccbe6c470236089eae7839d
|
https://github.com/castwide/solargraph/blob/47badb5d151aca775ccbe6c470236089eae7839d/lib/solargraph/api_map.rb#L423-L429
|
11,393
|
castwide/solargraph
|
lib/solargraph/api_map.rb
|
Solargraph.ApiMap.require_extensions
|
def require_extensions
Gem::Specification.all_names.select{|n| n.match(/^solargraph\-[a-z0-9_\-]*?\-ext\-[0-9\.]*$/)}.each do |n|
Solargraph::Logging.logger.info "Loading extension #{n}"
require n.match(/^(solargraph\-[a-z0-9_\-]*?\-ext)\-[0-9\.]*$/)[1]
end
end
|
ruby
|
def require_extensions
Gem::Specification.all_names.select{|n| n.match(/^solargraph\-[a-z0-9_\-]*?\-ext\-[0-9\.]*$/)}.each do |n|
Solargraph::Logging.logger.info "Loading extension #{n}"
require n.match(/^(solargraph\-[a-z0-9_\-]*?\-ext)\-[0-9\.]*$/)[1]
end
end
|
[
"def",
"require_extensions",
"Gem",
"::",
"Specification",
".",
"all_names",
".",
"select",
"{",
"|",
"n",
"|",
"n",
".",
"match",
"(",
"/",
"\\-",
"\\-",
"\\-",
"\\-",
"\\.",
"/",
")",
"}",
".",
"each",
"do",
"|",
"n",
"|",
"Solargraph",
"::",
"Logging",
".",
"logger",
".",
"info",
"\"Loading extension #{n}\"",
"require",
"n",
".",
"match",
"(",
"/",
"\\-",
"\\-",
"\\-",
"\\-",
"\\.",
"/",
")",
"[",
"1",
"]",
"end",
"end"
] |
Require extensions for the experimental plugin architecture. Any
installed gem with a name that starts with "solargraph-" is considered
an extension.
@return [void]
|
[
"Require",
"extensions",
"for",
"the",
"experimental",
"plugin",
"architecture",
".",
"Any",
"installed",
"gem",
"with",
"a",
"name",
"that",
"starts",
"with",
"solargraph",
"-",
"is",
"considered",
"an",
"extension",
"."
] |
47badb5d151aca775ccbe6c470236089eae7839d
|
https://github.com/castwide/solargraph/blob/47badb5d151aca775ccbe6c470236089eae7839d/lib/solargraph/api_map.rb#L556-L561
|
11,394
|
castwide/solargraph
|
lib/solargraph/api_map.rb
|
Solargraph.ApiMap.prefer_non_nil_variables
|
def prefer_non_nil_variables pins
result = []
nil_pins = []
pins.each do |pin|
if pin.variable? && pin.nil_assignment?
nil_pins.push pin
else
result.push pin
end
end
result + nil_pins
end
|
ruby
|
def prefer_non_nil_variables pins
result = []
nil_pins = []
pins.each do |pin|
if pin.variable? && pin.nil_assignment?
nil_pins.push pin
else
result.push pin
end
end
result + nil_pins
end
|
[
"def",
"prefer_non_nil_variables",
"pins",
"result",
"=",
"[",
"]",
"nil_pins",
"=",
"[",
"]",
"pins",
".",
"each",
"do",
"|",
"pin",
"|",
"if",
"pin",
".",
"variable?",
"&&",
"pin",
".",
"nil_assignment?",
"nil_pins",
".",
"push",
"pin",
"else",
"result",
".",
"push",
"pin",
"end",
"end",
"result",
"+",
"nil_pins",
"end"
] |
Sort an array of pins to put nil or undefined variables last.
@param pins [Array<Solargraph::Pin::Base>]
@return [Array<Solargraph::Pin::Base>]
|
[
"Sort",
"an",
"array",
"of",
"pins",
"to",
"put",
"nil",
"or",
"undefined",
"variables",
"last",
"."
] |
47badb5d151aca775ccbe6c470236089eae7839d
|
https://github.com/castwide/solargraph/blob/47badb5d151aca775ccbe6c470236089eae7839d/lib/solargraph/api_map.rb#L620-L631
|
11,395
|
castwide/solargraph
|
lib/solargraph/api_map.rb
|
Solargraph.ApiMap.super_and_sub?
|
def super_and_sub?(sup, sub)
fqsup = qualify(sup)
cls = qualify(store.get_superclass(sub), sub)
until cls.nil?
return true if cls == fqsup
cls = qualify(store.get_superclass(cls), cls)
end
false
end
|
ruby
|
def super_and_sub?(sup, sub)
fqsup = qualify(sup)
cls = qualify(store.get_superclass(sub), sub)
until cls.nil?
return true if cls == fqsup
cls = qualify(store.get_superclass(cls), cls)
end
false
end
|
[
"def",
"super_and_sub?",
"(",
"sup",
",",
"sub",
")",
"fqsup",
"=",
"qualify",
"(",
"sup",
")",
"cls",
"=",
"qualify",
"(",
"store",
".",
"get_superclass",
"(",
"sub",
")",
",",
"sub",
")",
"until",
"cls",
".",
"nil?",
"return",
"true",
"if",
"cls",
"==",
"fqsup",
"cls",
"=",
"qualify",
"(",
"store",
".",
"get_superclass",
"(",
"cls",
")",
",",
"cls",
")",
"end",
"false",
"end"
] |
Check if a class is a superclass of another class.
@param sup [String] The superclass
@param sub [String] The subclass
@return [Boolean]
|
[
"Check",
"if",
"a",
"class",
"is",
"a",
"superclass",
"of",
"another",
"class",
"."
] |
47badb5d151aca775ccbe6c470236089eae7839d
|
https://github.com/castwide/solargraph/blob/47badb5d151aca775ccbe6c470236089eae7839d/lib/solargraph/api_map.rb#L638-L646
|
11,396
|
castwide/solargraph
|
lib/solargraph/range.rb
|
Solargraph.Range.contain?
|
def contain? position
position = Position.normalize(position)
return false if position.line < start.line || position.line > ending.line
return false if position.line == start.line && position.character < start.character
return false if position.line == ending.line && position.character > ending.character
true
end
|
ruby
|
def contain? position
position = Position.normalize(position)
return false if position.line < start.line || position.line > ending.line
return false if position.line == start.line && position.character < start.character
return false if position.line == ending.line && position.character > ending.character
true
end
|
[
"def",
"contain?",
"position",
"position",
"=",
"Position",
".",
"normalize",
"(",
"position",
")",
"return",
"false",
"if",
"position",
".",
"line",
"<",
"start",
".",
"line",
"||",
"position",
".",
"line",
">",
"ending",
".",
"line",
"return",
"false",
"if",
"position",
".",
"line",
"==",
"start",
".",
"line",
"&&",
"position",
".",
"character",
"<",
"start",
".",
"character",
"return",
"false",
"if",
"position",
".",
"line",
"==",
"ending",
".",
"line",
"&&",
"position",
".",
"character",
">",
"ending",
".",
"character",
"true",
"end"
] |
True if the specified position is inside the range.
@param position [Position, Array(Integer, Integer)]
@return [Boolean]
|
[
"True",
"if",
"the",
"specified",
"position",
"is",
"inside",
"the",
"range",
"."
] |
47badb5d151aca775ccbe6c470236089eae7839d
|
https://github.com/castwide/solargraph/blob/47badb5d151aca775ccbe6c470236089eae7839d/lib/solargraph/range.rb#L33-L39
|
11,397
|
castwide/solargraph
|
lib/solargraph/range.rb
|
Solargraph.Range.include?
|
def include? position
position = Position.normalize(position)
contain?(position) && !(position.line == start.line && position.character == start.character)
end
|
ruby
|
def include? position
position = Position.normalize(position)
contain?(position) && !(position.line == start.line && position.character == start.character)
end
|
[
"def",
"include?",
"position",
"position",
"=",
"Position",
".",
"normalize",
"(",
"position",
")",
"contain?",
"(",
"position",
")",
"&&",
"!",
"(",
"position",
".",
"line",
"==",
"start",
".",
"line",
"&&",
"position",
".",
"character",
"==",
"start",
".",
"character",
")",
"end"
] |
True if the range contains the specified position and the position does not precede it.
@param position [Position, Array(Integer, Integer)]
@return [Boolean]
|
[
"True",
"if",
"the",
"range",
"contains",
"the",
"specified",
"position",
"and",
"the",
"position",
"does",
"not",
"precede",
"it",
"."
] |
47badb5d151aca775ccbe6c470236089eae7839d
|
https://github.com/castwide/solargraph/blob/47badb5d151aca775ccbe6c470236089eae7839d/lib/solargraph/range.rb#L45-L48
|
11,398
|
castwide/solargraph
|
lib/solargraph/source.rb
|
Solargraph.Source.tree_at
|
def tree_at(line, column)
# offset = Position.line_char_to_offset(@code, line, column)
position = Position.new(line, column)
stack = []
inner_tree_at @node, position, stack
stack
end
|
ruby
|
def tree_at(line, column)
# offset = Position.line_char_to_offset(@code, line, column)
position = Position.new(line, column)
stack = []
inner_tree_at @node, position, stack
stack
end
|
[
"def",
"tree_at",
"(",
"line",
",",
"column",
")",
"# offset = Position.line_char_to_offset(@code, line, column)",
"position",
"=",
"Position",
".",
"new",
"(",
"line",
",",
"column",
")",
"stack",
"=",
"[",
"]",
"inner_tree_at",
"@node",
",",
"position",
",",
"stack",
"stack",
"end"
] |
Get an array of nodes containing the specified index, starting with the
nearest node and ending with the root.
@param line [Integer]
@param column [Integer]
@return [Array<AST::Node>]
|
[
"Get",
"an",
"array",
"of",
"nodes",
"containing",
"the",
"specified",
"index",
"starting",
"with",
"the",
"nearest",
"node",
"and",
"ending",
"with",
"the",
"root",
"."
] |
47badb5d151aca775ccbe6c470236089eae7839d
|
https://github.com/castwide/solargraph/blob/47badb5d151aca775ccbe6c470236089eae7839d/lib/solargraph/source.rb#L99-L105
|
11,399
|
castwide/solargraph
|
lib/solargraph/source.rb
|
Solargraph.Source.synchronize
|
def synchronize updater
raise 'Invalid synchronization' unless updater.filename == filename
real_code = updater.write(@code)
if real_code == @code
@version = updater.version
return self
end
synced = Source.new(real_code, filename)
if synced.parsed?
synced.version = updater.version
return synced
end
incr_code = updater.repair(@repaired)
synced = Source.new(incr_code, filename)
synced.error_ranges.concat (error_ranges + updater.changes.map(&:range))
synced.code = real_code
synced.version = updater.version
synced
end
|
ruby
|
def synchronize updater
raise 'Invalid synchronization' unless updater.filename == filename
real_code = updater.write(@code)
if real_code == @code
@version = updater.version
return self
end
synced = Source.new(real_code, filename)
if synced.parsed?
synced.version = updater.version
return synced
end
incr_code = updater.repair(@repaired)
synced = Source.new(incr_code, filename)
synced.error_ranges.concat (error_ranges + updater.changes.map(&:range))
synced.code = real_code
synced.version = updater.version
synced
end
|
[
"def",
"synchronize",
"updater",
"raise",
"'Invalid synchronization'",
"unless",
"updater",
".",
"filename",
"==",
"filename",
"real_code",
"=",
"updater",
".",
"write",
"(",
"@code",
")",
"if",
"real_code",
"==",
"@code",
"@version",
"=",
"updater",
".",
"version",
"return",
"self",
"end",
"synced",
"=",
"Source",
".",
"new",
"(",
"real_code",
",",
"filename",
")",
"if",
"synced",
".",
"parsed?",
"synced",
".",
"version",
"=",
"updater",
".",
"version",
"return",
"synced",
"end",
"incr_code",
"=",
"updater",
".",
"repair",
"(",
"@repaired",
")",
"synced",
"=",
"Source",
".",
"new",
"(",
"incr_code",
",",
"filename",
")",
"synced",
".",
"error_ranges",
".",
"concat",
"(",
"error_ranges",
"+",
"updater",
".",
"changes",
".",
"map",
"(",
":range",
")",
")",
"synced",
".",
"code",
"=",
"real_code",
"synced",
".",
"version",
"=",
"updater",
".",
"version",
"synced",
"end"
] |
Synchronize the Source with an update. This method applies changes to the
code, parses the new code's AST, and returns the resulting Source object.
@param updater [Source::Updater]
@return [Source]
|
[
"Synchronize",
"the",
"Source",
"with",
"an",
"update",
".",
"This",
"method",
"applies",
"changes",
"to",
"the",
"code",
"parses",
"the",
"new",
"code",
"s",
"AST",
"and",
"returns",
"the",
"resulting",
"Source",
"object",
"."
] |
47badb5d151aca775ccbe6c470236089eae7839d
|
https://github.com/castwide/solargraph/blob/47badb5d151aca775ccbe6c470236089eae7839d/lib/solargraph/source.rb#L156-L174
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.