gcloud 0.5.0 → 0.6.0

data/lib/gcloud/bigquery/table/schema.rb

@@ -79,15 +79,13 @@ module Gcloud
         #   The field name. The name must contain only letters (a-z, A-Z),
         #   numbers (0-9), or underscores (_), and must start with a letter or
         #   underscore. The maximum length is 128 characters. (+String+)
-        # +options+::
-        #   An optional Hash for controlling additional behavior. (+Hash+)
-        # <code>options[:description]</code>::
+        # +description+::
         #   A description of the field. (+String+)
-        # <code>options[:mode]</code>::
+        # +mode+::
         #   The field's mode. The possible values are +:nullable+, +:required+,
         #   and +:repeated+. The default value is +:nullable+. (+Symbol+)
-        def string name, options = {}
-          add_field name, :string, nil, options
+        def string name, description: nil, mode: nil
+          add_field name, :string, nil, description: description, mode: mode
         end
 
         ##
@@ -99,15 +97,13 @@ module Gcloud
         #   The field name. The name must contain only letters (a-z, A-Z),
         #   numbers (0-9), or underscores (_), and must start with a letter or
         #   underscore. The maximum length is 128 characters. (+String+)
-        # +options+::
-        #   An optional Hash for controlling additional behavior. (+Hash+)
-        # <code>options[:description]</code>::
+        # +description+::
         #   A description of the field. (+String+)
-        # <code>options[:mode]</code>::
+        # +mode+::
         #   The field's mode. The possible values are +:nullable+, +:required+,
         #   and +:repeated+. The default value is +:nullable+. (+Symbol+)
-        def integer name, options = {}
-          add_field name, :integer, nil, options
+        def integer name, description: nil, mode: nil
+          add_field name, :integer, nil, description: description, mode: mode
         end
 
         ##
@@ -119,15 +115,13 @@ module Gcloud
         #   The field name. The name must contain only letters (a-z, A-Z),
         #   numbers (0-9), or underscores (_), and must start with a letter or
         #   underscore. The maximum length is 128 characters. (+String+)
-        # +options+::
-        #   An optional Hash for controlling additional behavior. (+Hash+)
-        # <code>options[:description]</code>::
+        # +description+::
         #   A description of the field. (+String+)
-        # <code>options[:mode]</code>::
+        # +mode+::
         #   The field's mode. The possible values are +:nullable+, +:required+,
         #   and +:repeated+. The default value is +:nullable+. (+Symbol+)
-        def float name, options = {}
-          add_field name, :float, nil, options
+        def float name, description: nil, mode: nil
+          add_field name, :float, nil, description: description, mode: mode
         end
 
         ##
@@ -139,15 +133,13 @@ module Gcloud
         #   The field name. The name must contain only letters (a-z, A-Z),
         #   numbers (0-9), or underscores (_), and must start with a letter or
         #   underscore. The maximum length is 128 characters. (+String+)
-        # +options+::
-        #   An optional Hash for controlling additional behavior. (+Hash+)
-        # <code>options[:description]</code>::
+        # +description+::
         #   A description of the field. (+String+)
-        # <code>options[:mode]</code>::
+        # +mode+::
         #   The field's mode. The possible values are +:nullable+, +:required+,
         #   and +:repeated+. The default value is +:nullable+. (+Symbol+)
-        def boolean name, options = {}
-          add_field name, :boolean, nil, options
+        def boolean name, description: nil, mode: nil
+          add_field name, :boolean, nil, description: description, mode: mode
         end
 
         ##
@@ -159,15 +151,13 @@ module Gcloud
         #   The field name. The name must contain only letters (a-z, A-Z),
         #   numbers (0-9), or underscores (_), and must start with a letter or
         #   underscore. The maximum length is 128 characters. (+String+)
-        # +options+::
-        #   An optional Hash for controlling additional behavior. (+Hash+)
-        # <code>options[:description]</code>::
+        # +description+::
         #   A description of the field. (+String+)
-        # <code>options[:mode]</code>::
+        # +mode+::
         #   The field's mode. The possible values are +:nullable+, +:required+,
         #   and +:repeated+. The default value is +:nullable+. (+Symbol+)
-        def timestamp name, options = {}
-          add_field name, :timestamp, nil, options
+        def timestamp name, description: nil, mode: nil
+          add_field name, :timestamp, nil, description: description, mode: mode
         end
 
         ##
@@ -182,11 +172,9 @@ module Gcloud
         #   The field name. The name must contain only letters (a-z, A-Z),
         #   numbers (0-9), or underscores (_), and must start with a letter or
         #   underscore. The maximum length is 128 characters. (+String+)
-        # +options+::
-        #   An optional Hash for controlling additional behavior. (+Hash+)
-        # <code>options[:description]</code>::
+        # +description+::
         #   A description of the field. (+String+)
-        # <code>options[:mode]</code>::
+        # +mode+::
         #   The field's mode. The possible values are +:nullable+, +:required+,
         #   and +:repeated+. The default value is +:nullable+. (+Symbol+)
         #
@@ -207,12 +195,13 @@ module Gcloud
         #     end
         #   end
         #
-        def record name, options = {}
+        def record name, description: nil, mode: nil
           fail ArgumentError, "nested RECORD type is not permitted" if @nested
           fail ArgumentError, "a block is required" unless block_given?
           nested_schema = self.class.new nil, true
           yield nested_schema
-          add_field name, :record, nested_schema.fields, options
+          add_field name, :record, nested_schema.fields,
+                    description: description, mode: mode
         end
 
         protected
@@ -234,16 +223,17 @@ module Gcloud
           upcase_mode
         end
 
-        def add_field name, type, nested_fields, options
+        def add_field name, type, nested_fields, description: nil,
+                      mode: :nullable
           # Remove any existing field of this name
           @fields.reject! { |h| h["name"] == name }
           field = {
             "name" => name,
             "type" => upcase_type(type)
           }
-          field["mode"] = upcase_mode(options[:mode]) if options[:mode]
-          field["description"] =options[:description] if options[:description]
-          field["fields"] = nested_fields if nested_fields
+          field["fields"]      = nested_fields     if nested_fields
+          field["description"] = description       if description
+          field["mode"]        = upcase_mode(mode) if mode
           @fields << field
         end
       end

data/lib/gcloud/bigquery/view.rb

@@ -286,33 +286,31 @@ module Gcloud
       #
       # === Parameters
       #
-      # +options+::
-      #   An optional Hash for controlling additional behavior. (+Hash+)
-      # <code>options[:max]</code>::
+      # +max+::
       #   The maximum number of rows of data to return per page of results.
       #   Setting this flag to a small value such as 1000 and then paging
       #   through results might improve reliability when the query result set is
       #   large. In addition to this limit, responses are also limited to 10 MB.
       #   By default, there is no maximum row count, and only the byte limit
       #   applies. (+Integer+)
-      # <code>options[:timeout]</code>::
+      # +timeout+::
       #   How long to wait for the query to complete, in milliseconds, before
       #   the request times out and returns. Note that this is only a timeout
       #   for the request, not the query. If the query takes longer to run than
       #   the timeout value, the call returns without any results and with
       #   QueryData#complete? set to false. The default value is 10000
       #   milliseconds (10 seconds). (+Integer+)
-      # <code>options[:dryrun]</code>::
-      #   If set to +true+, BigQuery doesn't run the job. Instead, if the query
-      #   is valid, BigQuery returns statistics about the job such as how many
-      #   bytes would be processed. If the query is invalid, an error returns.
-      #   The default value is +false+. (+Boolean+)
-      # <code>options[:cache]</code>::
+      # +cache+::
       #   Whether to look for the result in the query cache. The query cache is
       #   a best-effort cache that will be flushed whenever tables in the query
       #   are modified. The default value is true. For more information, see
       #   {query caching}[https://developers.google.com/bigquery/querying-data].
       #   (+Boolean+)
+      # +dryrun+::
+      #   If set to +true+, BigQuery doesn't run the job. Instead, if the query
+      #   is valid, BigQuery returns statistics about the job such as how many
+      #   bytes would be processed. If the query is invalid, an error returns.
+      #   The default value is +false+. (+Boolean+)
       #
       # === Returns
       #
@@ -335,9 +333,10 @@ module Gcloud
       #
       # :category: Data
       #
-      def data options = {}
+      def data max: nil, timeout: nil, cache: nil, dryrun: nil
         sql = "SELECT * FROM #{@gapi['id']}"
         ensure_connection!
+        options = { max: max, timeout: timeout, cache: cache, dryrun: dryrun }
         resp = connection.query sql, options
         if resp.success?
           QueryData.from_gapi resp.data, connection

data/lib/gcloud/credentials.rb

@@ -42,15 +42,19 @@ module Gcloud
                    :token_credential_uri, :audience,
                    :scope, :issuer, :signing_key
 
-    def initialize keyfile, options = {}
+    def initialize keyfile, scope: nil
       verify_keyfile_provided! keyfile
       if keyfile.is_a? Signet::OAuth2::Client
         @client = keyfile
       elsif keyfile.is_a? Hash
-        @client = init_client keyfile, options
+        hash = stringify_hash_keys keyfile
+        hash["scope"] ||= scope
+        @client = init_client hash
       else
         verify_keyfile_exists! keyfile
-        @client = init_client JSON.parse(::File.read(keyfile)), options
+        json = JSON.parse ::File.read(keyfile)
+        json["scope"] ||= scope
+        @client = init_client json
       end
       @client.fetch_access_token!
     end
@@ -61,25 +65,25 @@ module Gcloud
     ##
     # Returns the default credentials.
     #
-    def self.default options = {}
+    def self.default scope: nil
       env  = ->(v) { ENV[v] }
       json = ->(v) { JSON.parse ENV[v] rescue nil unless ENV[v].nil? }
       path = ->(p) { ::File.file? p }
 
       # First try to find keyfile file from environment variables.
       self::PATH_ENV_VARS.map(&env).reject(&:nil?).select(&path).each do |file|
-        return new file, options
+        return new file, scope: scope
       end
       # Second try to find keyfile json from environment variables.
       self::JSON_ENV_VARS.map(&json).reject(&:nil?).each do |hash|
-        return new hash, options
+        return new hash, scope: scope
       end
       # Third try to find keyfile file from known file paths.
       self::DEFAULT_PATHS.select(&path).each do |file|
-        return new file, options
+        return new file, scope: scope
       end
       # Finally get instantiated client from Google::Auth.
-      scope = options[:scope] || options["scope"] || self::SCOPE
+      scope ||= self::SCOPE
       client = Google::Auth.get_application_default scope
       new client
     end
@@ -103,8 +107,8 @@ module Gcloud
 
     ##
     # Initializes the Signet client.
-    def init_client keyfile, options
-      client_opts = client_options keyfile, options
+    def init_client keyfile
+      client_opts = client_options keyfile
       Signet::OAuth2::Client.new client_opts
     end
 
@@ -114,21 +118,11 @@ module Gcloud
       Hash[hash.map { |(k, v)| [k.to_s, v] }]
     end
 
-    ##
-    # The default options using the values in the constants.
-    def default_options
-      { "token_credential_uri" => self.class::TOKEN_CREDENTIAL_URI,
-        "audience"             => self.class::AUDIENCE,
-        "scope"                => self.class::SCOPE }
-    end
-
-    def client_options keyfile, options
-      # Turn keys to strings
-      options = stringify_hash_keys options
-      # Constructor options override default options
-      options = default_options.merge options
-      # Keyfile options override everything
-      options = options.merge keyfile
+    def client_options options
+      # Keyfile options have higher priority over constructor defaults
+      options["token_credential_uri"] ||= self.class::TOKEN_CREDENTIAL_URI
+      options["audience"]             ||= self.class::AUDIENCE
+      options["scope"]                ||= self.class::SCOPE
 
       # client options for initializing signet client
       { token_credential_uri: options["token_credential_uri"],

data/lib/gcloud/datastore.rb

@@ -33,9 +33,7 @@ module Gcloud
   # +keyfile+::
   #   Keyfile downloaded from Google Cloud. If file path the file must be
   #   readable. (+String+ or +Hash+)
-  # +options+::
-  #   An optional Hash for controlling additional behavior. (+Hash+)
-  # <code>options[:scope]</code>::
+  # +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]. (+String+
@@ -64,12 +62,12 @@ module Gcloud
   #
   #   dataset.save entity
   #
-  def self.datastore project = nil, keyfile = nil, options = {}
+  def self.datastore project = nil, keyfile = nil, scope: nil
     project ||= Gcloud::Datastore::Dataset.default_project
     if keyfile.nil?
-      credentials = Gcloud::Datastore::Credentials.default options
+      credentials = Gcloud::Datastore::Credentials.default scope: scope
     else
-      credentials = Gcloud::Datastore::Credentials.new keyfile, options
+      credentials = Gcloud::Datastore::Credentials.new keyfile, scope: scope
     end
     Gcloud::Datastore::Dataset.new project, credentials
   end

data/lib/gcloud/datastore/dataset.rb

@@ -241,9 +241,7 @@ module Gcloud
       #
       # +query+::
       #   The Query object with the search criteria. (+Query+)
-      # +options+::
-      #   An optional Hash for controlling additional behavior. (+Hash+)
-      # <code>options[:namespace]</code>::
+      # +namespace+::
       #   The namespace the query is to run within. (+String+)
       #
       # === Returns
@@ -263,8 +261,8 @@ module Gcloud
       #     where("completed", "=", true)
       #   tasks = dataset.run query, namespace: "ns~todo-project"
       #
-      def run query, options = {}
-        partition = optional_partition_id options[:namespace]
+      def run query, namespace: nil
+        partition = optional_partition_id namespace
         response = connection.run_query query.to_proto, partition
         entities = to_gcloud_entities response.batch.entity_result
         cursor = Proto.encode_cursor response.batch.end_cursor

data/lib/gcloud/dns.rb

@@ -30,9 +30,7 @@ module Gcloud
   # +keyfile+::
   #   Keyfile downloaded from Google Cloud. If file path the file must be
   #   readable. (+String+ or +Hash+)
-  # +options+::
-  #   An optional Hash for controlling additional behavior. (+Hash+)
-  # <code>options[:scope]</code>::
+  # +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]. (+String+
@@ -55,12 +53,12 @@ module Gcloud
   #
   #   zone = dns.zone "example-com"
   #
-  def self.dns project = nil, keyfile = nil, options = {}
+  def self.dns project = nil, keyfile = nil, scope: nil
     project ||= Gcloud::Dns::Project.default_project
     if keyfile.nil?
-      credentials = Gcloud::Dns::Credentials.default options
+      credentials = Gcloud::Dns::Credentials.default scope: scope
     else
-      credentials = Gcloud::Dns::Credentials.new keyfile, options
+      credentials = Gcloud::Dns::Credentials.new keyfile, scope: scope
     end
     Gcloud::Dns::Project.new project, credentials
   end

data/lib/gcloud/dns/connection.rb

@@ -52,10 +52,10 @@ module Gcloud
         )
       end
 
-      def list_zones options = {}
+      def list_zones token: nil, max: nil
         params = { project: @project,
-                   pageToken: options.delete(:token),
-                   maxResults: options.delete(:max)
+                   pageToken: token,
+                   maxResults: max
                  }.delete_if { |_, v| v.nil? }
 
         @client.execute(
@@ -64,11 +64,12 @@ module Gcloud
         )
       end
 
-      def create_zone zone_name, zone_dns, options = {}
+      def create_zone zone_name, zone_dns, description: nil,
+                      name_server_set: nil
         body = { kind: "dns#managedZone",
                  name: zone_name, dnsName: zone_dns,
-                 description: (options[:description] || ""),
-                 nameServerSet: options[:name_server_set]
+                 description: (description || ""),
+                 nameServerSet: name_server_set
                }.delete_if { |_, v| v.nil? }
 
         @client.execute(
@@ -93,12 +94,12 @@ module Gcloud
         )
       end
 
-      def list_changes zone_id, options = {}
+      def list_changes zone_id, token: nil, max: nil, order: nil, sort: nil
         params = { project: @project, managedZone: zone_id,
-                   pageToken: options.delete(:token),
-                   maxResults: options.delete(:max),
-                   sortBy: options.delete(:sort),
-                   sortOrder: options.delete(:order)
+                   pageToken: token,
+                   maxResults: max,
+                   sortBy: sort,
+                   sortOrder: order
                  }.delete_if { |_, v| v.nil? }
 
         @client.execute(
@@ -119,12 +120,12 @@ module Gcloud
         )
       end
 
-      def list_records zone_id, options = {}
+      def list_records zone_id, name = nil, type = nil, token: nil, max: nil
         params = { project: @project, managedZone: zone_id,
-                   pageToken: options.delete(:token),
-                   maxResults: options.delete(:max),
-                   name: options.delete(:name),
-                   type: options.delete(:type)
+                   pageToken: token,
+                   maxResults: max,
+                   name: name,
+                   type: type
                  }.delete_if { |_, v| v.nil? }
 
         @client.execute(

data/lib/gcloud/dns/importer.rb

@@ -61,30 +61,24 @@ module Gcloud
       #
       # === Parameters
       #
-      # +options+::
-      #   An optional Hash for controlling additional behavior. (+Hash+)
-      # <code>options[:only]</code>::
+      # +only+::
       #   Include only records of this type or types. (+String+ or +Array+)
-      # <code>options[:except]</code>::
+      # +except+::
       #   Exclude records of this type or types. (+String+ or +Array+)
       #
       # === Returns
       #
       # An array of unsaved Record instances.
       #
-      def records options = {}
-        filtered_records options[:only], options[:except]
-      end
-
-      protected
-
-      def filtered_records only, except
+      def records only: nil, except: nil
         ret = @records
         ret = ret.select { |r| Array(only).include? r.type } if only
         ret = ret.reject { |r| Array(except).include? r.type } if except
         ret
       end
 
+      protected
+
       ##
       # The zonefile library returns a two-element array in which the first
       # element is a symbol type (:a, :mx, and so on), and the second element