RubyGems - komoju - Versions diffs - 0.0.4 → 0.0.7 - Mend

komoju 0.0.4 → 0.0.7

Files changed (30) hide show

checksums.yaml +4 -4
data/Gemfile.lock +13 -10
data/bin/generate-client +6 -2
data/komoju.gemspec +2 -6
data/lib/komoju.rb +1 -0
data/lib/komoju/client.rb +541 -111
data/lib/komoju/version.rb +1 -1
metadata +8 -74
data/vendor/heroics/lib/heroics.rb +0 -22
data/vendor/heroics/lib/heroics/cli.rb +0 -88
data/vendor/heroics/lib/heroics/client.rb +0 -109
data/vendor/heroics/lib/heroics/client_generator.rb +0 -99
data/vendor/heroics/lib/heroics/command.rb +0 -67
data/vendor/heroics/lib/heroics/errors.rb +0 -6
data/vendor/heroics/lib/heroics/link.rb +0 -120
data/vendor/heroics/lib/heroics/naming.rb +0 -19
data/vendor/heroics/lib/heroics/resource.rb +0 -30
data/vendor/heroics/lib/heroics/schema.rb +0 -444
data/vendor/heroics/lib/heroics/version.rb +0 -3
data/vendor/heroics/test.rb +0 -42
data/vendor/heroics/test/cli_test.rb +0 -236
data/vendor/heroics/test/client_generator_test.rb +0 -34
data/vendor/heroics/test/client_test.rb +0 -215
data/vendor/heroics/test/command_test.rb +0 -214
data/vendor/heroics/test/helper.rb +0 -204
data/vendor/heroics/test/link_test.rb +0 -398
data/vendor/heroics/test/naming_test.rb +0 -45
data/vendor/heroics/test/resource_test.rb +0 -35
data/vendor/heroics/test/schema_test.rb +0 -287
data/vendor/heroics/test/version_test.rb +0 -9

data/vendor/heroics/lib/heroics/command.rb DELETED

@@ -1,67 +0,0 @@
-module Heroics
-  class Command
-    # Instantiate a command.
-    #
-    # @param cli_name [String] The name of the CLI.
-    # @param link_schema [LinkSchema] The schema for the underlying link this
-    #   command represents.
-    # @param client [Client] The client to use when making requests.
-    # @param output [IO] The stream to write output to.
-    def initialize(cli_name, link_schema, client, output)
-      @cli_name = cli_name
-      @link_schema = link_schema
-      @client = client
-      @output = output
-    end
-    # The command name.
-    def name
-      "#{@link_schema.pretty_resource_name}:#{@link_schema.pretty_name}"
-    end
-    # The command description.
-    def description
-      @link_schema.description
-    end
-    # Write usage information to the output stream.
-    def usage
-      parameters = @link_schema.parameters.map { |parameter| "<#{parameter}>" }
-      parameters = parameters.empty? ? '' : " #{parameters.join(' ')}"
-      example_body = @link_schema.example_body
-      body_parameter = example_body.nil? ? '' : ' <body>'
-      @output.write <<-USAGE
-Usage: #{@cli_name} #{name}#{parameters}#{body_parameter}
-Description:
-  #{description}
-USAGE
-      if example_body
-        example_body = MultiJson.dump(example_body, pretty: true)
-        example_body = example_body.lines.map do |line|
-          "  #{line}"
-        end.join
-        @output.write <<-USAGE
-Body example:
-#{example_body}
-USAGE
-      end
-    end
-    # Run the command and write the results to the output stream.
-    #
-    # @param parameters [Array] The parameters to pass when making a request
-    #   to run the command.
-    def run(*parameters)
-      resource_name = @link_schema.resource_name
-      name = @link_schema.name
-      result = @client.send(resource_name).send(name, *parameters)
-      result = result.to_a if result.instance_of?(Enumerator)
-      if result && !result.instance_of?(String)
-        result = MultiJson.dump(result, pretty: true)
-      end
-      @output.puts(result) unless result.nil?
-    end
-  end
-end

data/vendor/heroics/lib/heroics/errors.rb DELETED

@@ -1,6 +0,0 @@
-module Heroics
-  # Raised when a schema has an error that prevents it from being parsed
-  # correctly.
-  class SchemaError < StandardError
-  end
-end

data/vendor/heroics/lib/heroics/link.rb DELETED

@@ -1,120 +0,0 @@
-module Heroics
-  # A link invokes requests with an HTTP server.
-  class Link
-    # Instantiate a link.
-    #
-    # @param url [String] The URL to use when making requests.  Include the
-    #   username and password to use with HTTP basic auth.
-    # @param link_schema [LinkSchema] The schema for this link.
-    # @param options [Hash] Configuration for the link.  Possible keys
-    #   include:
-    #   - default_headers: Optionally, a set of headers to include in every
-    #     request made by the client.  Default is no custom headers.
-    #   - cache: Optionally, a Moneta-compatible cache to store ETags.
-    #     Default is no caching.
-    def initialize(url, link_schema, options={})
-      @root_url, @path_prefix = unpack_url(url)
-      @link_schema = link_schema
-      @default_headers = options[:default_headers] || {}
-      @cache = options[:cache] || Moneta.new(:Null)
-    end
-    # Make a request to the server.
-    #
-    # JSON content received with an ETag is cached.  When the server returns a
-    # *304 Not Modified* status code content is loaded and returned from the
-    # cache.  The cache considers headers, in addition to the URL path, when
-    # creating keys so that requests to the same path, such as for paginated
-    # results, don't cause cache collisions.
-    #
-    # When the server returns a *206 Partial Content* status code the result
-    # is assumed to be an array and an enumerator is returned.  The enumerator
-    # yields results from the response until they've been consumed at which
-    # point, if additional content is available from the server, it blocks and
-    # makes a request to fetch the subsequent page of data.  This behaviour
-    # continues until the client stops iterating the enumerator or the dataset
-    # from the server has been entirely consumed.
-    #
-    # @param parameters [Array] The list of parameters to inject into the
-    #   path.  A request body can be passed as the final parameter and will
-    #   always be converted to JSON before being transmitted.
-    # @raise [ArgumentError] Raised if either too many or too few parameters
-    #   were provided.
-    # @return [String,Object,Enumerator] A string for text responses, an
-    #   object for JSON responses, or an enumerator for list responses.
-    def run(*parameters)
-      path, body = @link_schema.format_path(parameters)
-      path = "#{@path_prefix}#{path}" unless @path_prefix == '/'
-      headers = @default_headers
-      if body
-        headers = headers.merge({'Content-Type' => @link_schema.content_type})
-        body = @link_schema.encode(body)
-      end
-      cache_key = "#{path}:#{headers.hash}"
-      if @link_schema.method == :get
-        etag = @cache["etag:#{cache_key}"]
-        headers = headers.merge({'If-None-Match' => etag}) if etag
-      end
-      connection = Excon.new(@root_url, thread_safe_sockets: true)
-      response = connection.request(method: @link_schema.method, path: path,
-                                    headers: headers, body: body,
-                                    expects: [200, 201, 202, 204, 206, 304])
-      content_type = response.headers['Content-Type']
-      if response.status == 304
-        MultiJson.load(@cache["data:#{cache_key}"])
-      elsif content_type && content_type =~ /application\/.*json/
-        etag = response.headers['ETag']
-        if etag
-          @cache["etag:#{cache_key}"] = etag
-          @cache["data:#{cache_key}"] = response.body
-        end
-        body = MultiJson.load(response.body)
-        if response.status == 206
-          next_range = response.headers['Next-Range']
-          Enumerator.new do |yielder|
-            while true do
-              # Yield the results we got in the body.
-              body.each do |item|
-                yielder << item
-              end
-              # Only make a request to get the next page if we have a valid
-              # next range.
-              break unless next_range
-              headers = headers.merge({'Range' => next_range})
-              response = connection.request(method: @link_schema.method,
-                                            path: path, headers: headers,
-                                            expects: [200, 201, 206])
-              body = MultiJson.load(response.body)
-              next_range = response.headers['Next-Range']
-            end
-          end
-        else
-          body
-        end
-      elsif !response.body.empty?
-        response.body
-      end
-    end
-    private
-    # Unpack the URL and split it into a root URL and a path prefix, if one
-    # exists.
-    #
-    # @param url [String] The complete base URL to use when making requests.
-    # @return [String,String] A (root URL, path) prefix pair.
-    def unpack_url(url)
-      root_url = []
-      path_prefix = ''
-      parts = URI.split(url)
-      root_url << "#{parts[0]}://"
-      root_url << "#{parts[1]}@" unless parts[1].nil?
-      root_url << "#{parts[2]}"
-      root_url << ":#{parts[3]}" unless parts[3].nil?
-      path_prefix = parts[5]
-      return root_url.join(''), path_prefix
-    end
-  end
-end

data/vendor/heroics/lib/heroics/naming.rb DELETED

@@ -1,19 +0,0 @@
-module Heroics
-  # Process a name to make it suitable for use as a Ruby method name.
-  #
-  # @param name [String] The name to process.
-  # @return [String] The new name with capitals converted to lowercase, and
-  #   dashes and spaces converted to underscores.
-  def self.ruby_name(name)
-    name.downcase.gsub(/[- ]/, '_')
-  end
-  # Process a name to make it suitable for use as a pretty command name.
-  #
-  # @param name [String] The name to process.
-  # @return [String] The new name with capitals converted to lowercase, and
-  #   underscores and spaces converted to dashes.
-  def self.pretty_name(name)
-    name.downcase.gsub(/[_ ]/, '-')
-  end
-end

data/vendor/heroics/lib/heroics/resource.rb DELETED

@@ -1,30 +0,0 @@
-module Heroics
-  # A resource with methods mapped to API links.
-  class Resource
-    # Instantiate a resource.
-    #
-    # @param links [Hash<String,Link>] A hash that maps method names to links.
-    def initialize(links)
-      @links = links
-    end
-    private
-    # Find a link and invoke it.
-    #
-    # @param name [String] The name of the method to invoke.
-    # @param parameters [Array] The arguments to pass to the method.  This
-    #   should always be a `Hash` mapping parameter names to values.
-    # @raise [NoMethodError] Raised if the name doesn't match a known link.
-    # @return [String,Array,Hash] The response received from the server.  JSON
-    #   responses are automatically decoded into Ruby objects.
-    def method_missing(name, *parameters)
-      link = @links[name.to_s]
-      if link.nil?
-        address = "<#{self.class.name}:0x00#{(self.object_id << 1).to_s(16)}>"
-        raise NoMethodError.new("undefined method `#{name}' for ##{address}")
-      end
-      link.run(*parameters)
-    end
-  end
-end

data/vendor/heroics/lib/heroics/schema.rb DELETED

@@ -1,444 +0,0 @@
-module Heroics
-  # A wrapper around a bare JSON schema to make it easier to use.
-  class Schema
-    attr_reader :schema
-    # Instantiate a schema.
-    #
-    # @param schema [Hash] The bare JSON schema to wrap.
-    def initialize(schema)
-      @schema = schema
-      @resources = {}
-      @schema['properties'].each do |key, value|
-        @resources[key] = ResourceSchema.new(@schema, key)
-      end
-    end
-    # A description of the API.
-    def description
-      @schema['description']
-    end
-    # Get a schema for a named resource.
-    #
-    # @param name [String] The name of the resource.
-    # @raise [SchemaError] Raised if an unknown resource name is provided.
-    def resource(name)
-      if @schema['definitions'].has_key?(name)
-        ResourceSchema.new(@schema, name)
-      else
-        raise SchemaError.new("Unknown resource '#{name}'.")
-      end
-    end
-    # The resource schema children that are part of this schema.
-    #
-    # @return [Array<ResourceSchema>] The resource schema children.
-    def resources
-      @resources.values
-    end
-    # Get a simple human-readable representation of this client instance.
-    def inspect
-      "#<Heroics::Schema description=\"#{@schema['description']}\">"
-    end
-    alias to_s inspect
-  end
-  # A wrapper around a bare resource element in a JSON schema to make it
-  # easier to use.
-  class ResourceSchema
-    attr_reader :name
-    # Instantiate a resource schema.
-    #
-    # @param schema [Hash] The bare JSON schema to wrap.
-    # @param name [String] The name of the resource to identify in the schema.
-    def initialize(schema, name)
-      @schema = schema
-      @name = name
-      link_schema = schema['definitions'][name]['links'] || []
-      @links = Hash[link_schema.each_with_index.map do |link, link_index|
-                      link_name = Heroics.ruby_name(link['title'])
-                      [link_name, LinkSchema.new(schema, name, link_index)]
-                    end]
-    end
-    # A description of the resource.
-    def description
-      @schema['definitions'][name]['description']
-    end
-    # Get a schema for a named link.
-    #
-    # @param name [String] The name of the link.
-    # @raise [SchemaError] Raised if an unknown link name is provided.
-    def link(name)
-      schema = @links[name]
-      raise SchemaError.new("Unknown link '#{name}'.") unless schema
-      schema
-    end
-    # The link schema children that are part of this resource schema.
-    #
-    # @return [Array<LinkSchema>] The link schema children.
-    def links
-      @links.values
-    end
-  end
-  # A wrapper around a bare link element for a resource in a JSON schema to
-  # make it easier to use.
-  class LinkSchema
-    attr_reader :name, :resource_name, :description
-    # Instantiate a link schema.
-    #
-    # @param schema [Hash] The bare JSON schema to wrap.
-    # @param resource_name [String] The name of the resource to identify in
-    #   the schema.
-    # @param link_index [Fixnum] The index of the link in the resource schema.
-    def initialize(schema, resource_name, link_index)
-      @schema = schema
-      @resource_name = resource_name
-      @link_index = link_index
-      @name = Heroics.ruby_name(link_schema['title'])
-      @description = link_schema['description']
-    end
-    # Get the resource name in pretty form.
-    #
-    # @return [String] The pretty resource name.
-    def pretty_resource_name
-      Heroics.pretty_name(resource_name)
-    end
-    # Get the link name in pretty form.
-    #
-    # @return [String] The pretty link name.
-    def pretty_name
-      Heroics.pretty_name(name)
-    end
-    # Get the HTTP method for this link.
-    #
-    # @return [Symbol] The HTTP method.
-    def method
-      link_schema['method'].downcase.to_sym
-    end
-    # Get the Content-Type for this link.
-    #
-    # @return [String] The Content-Type value
-    def content_type
-      link_schema['encType'] || 'application/json'
-    end
-    def encode(body)
-      case content_type
-      when 'application/x-www-form-urlencoded'
-        URI.encode_www_form(body)
-      when /application\/.*json/
-        MultiJson.dump(body)
-      end
-    end
-    # Get the names of the parameters this link expects.
-    #
-    # @return [Array<String>] The parameters.
-    def parameters
-      parameter_names = link_schema['href'].scan(PARAMETER_REGEX)
-      resolve_parameters(parameter_names)
-    end
-    # Get the names and descriptions of the parameters this link expects.
-    #
-    # @return [Hash<String, String>] A list of hashes with `name` and
-    #   `description` key/value pairs describing parameters.
-    def parameter_details
-      parameter_names = link_schema['href'].scan(PARAMETER_REGEX)
-      parameters = resolve_parameter_details(parameter_names)
-      parameters << CollectionOptions.new if requires_collection_options?
-      parameters << BodyParameter.new if requires_request_body?
-      parameters
-    end
-    # Get an example request body.
-    #
-    # @return [Hash] A sample request body.
-    def example_body
-      if body_schema = link_schema['schema']
-        definitions = @schema['definitions'][@resource_name]['definitions']
-        Hash[body_schema['properties'].keys.map do |property|
-          # FIXME This is wrong! -jkakar
-          if definitions.has_key?(property)
-            example = definitions[property]['example']
-          else
-            example = ''
-          end
-          [property, example]
-        end]
-      end
-    end
-    # Inject parameters into the link href and return the body, if it exists.
-    #
-    # @param parameters [Array] The list of parameters to inject into the
-    #   path.
-    # @raise [ArgumentError] Raised if either too many or too few parameters
-    #   were provided.
-    # @return [String,Object] A path and request body pair.  The body value is
-    #   nil if a payload wasn't included in the list of parameters.
-    def format_path(parameters)
-      path = link_schema['href']
-      parameter_size = path.scan(PARAMETER_REGEX).size
-      too_few_parameters = parameter_size > parameters.size
-      # FIXME We should use the schema to detect when a request body is
-      # permitted and do the calculation correctly here. -jkakar
-      too_many_parameters = parameter_size < (parameters.size - 1)
-      if too_few_parameters || too_many_parameters
-        raise ArgumentError.new("wrong number of arguments " +
-                                "(#{parameters.size} for #{parameter_size})")
-      end
-      (0..parameter_size).each do |i|
-        path = path.sub(PARAMETER_REGEX, format_parameter(parameters[i]))
-      end
-      body = parameters.slice(parameter_size)
-      return path, body
-    end
-    private
-    # Match parameters in definition strings.
-    PARAMETER_REGEX = /\{\([%\/a-zA-Z0-9_-]*\)\}/
-    # Get the raw link schema.
-    #
-    # @param [Hash] The raw link schema.
-    def link_schema
-      @schema['definitions'][@resource_name]['links'][@link_index]
-    end
-    def requires_collection_options?
-      return link_schema['rel'] == 'instances'
-    end
-    def requires_request_body?
-      return link_schema.has_key?('schema')
-    end
-    # Get the names of the parameters this link expects.
-    #
-    # @param parameters [Array] The names of the parameter definitions to
-    #   convert to parameter names.
-    # @return [Array<String>] The parameters.
-    def resolve_parameters(parameters)
-      properties = @schema['definitions'][@resource_name]['properties']
-      return [''] if properties.nil?
-      definitions = Hash[properties.each_pair.map do |key, value|
-                           [value['$ref'], key]
-                         end]
-      parameters.map do |parameter|
-        definition_name = URI.unescape(parameter[2..-3])
-        if definitions.has_key?(definition_name)
-          definitions[definition_name]
-        else
-          definition_name = definition_name.split('/')[-1]
-          resource_definitions = @schema[
-            'definitions'][@resource_name]['definitions'][definition_name]
-          if resource_definitions.has_key?('anyOf')
-            resource_definitions['anyOf'].map do |property|
-              definitions[property['$ref']]
-            end.join('|')
-          else
-            resource_definitions['oneOf'].map do |property|
-              definitions[property['$ref']]
-            end.join('|')
-          end
-        end
-      end
-    end
-    # Get the parameters this link expects.
-    #
-    # @param parameters [Array] The names of the parameter definitions to
-    #   convert to parameter names.
-    # @return [Array<Parameter|ParameterChoice>] A list of parameter instances
-    #   that represent parameters to be injected into the link URL.
-    def resolve_parameter_details(parameters)
-      parameters.map do |parameter|
-        # URI decode parameters and strip the leading '{(' and trailing ')}'.
-        parameter = URI.unescape(parameter[2..-3])
-        # Split the path into components and discard the leading '#' that
-        # represents the root of the schema.
-        path = parameter.split('/')[1..-1]
-        info = lookup_parameter(path, @schema)
-        # The reference can be one of several values.
-        resource_name = path[1].gsub('-', '_')
-        if info.has_key?('anyOf')
-          ParameterChoice.new(resource_name,
-                              unpack_multiple_parameters(info['anyOf']))
-        elsif info.has_key?('oneOf')
-          ParameterChoice.new(resource_name,
-                              unpack_multiple_parameters(info['oneOf']))
-        else
-          name = path[-1]
-          Parameter.new(resource_name, name, info['description'])
-        end
-      end
-    end
-    # Unpack an 'anyOf' or 'oneOf' multi-parameter blob.
-    #
-    # @param parameters [Array<Hash>] An array of hashes containing '$ref'
-    #   keys and definition values.
-    # @return [Array<Parameter>] An array of parameters extracted from the
-    #   blob.
-    def unpack_multiple_parameters(parameters)
-      parameters.map do |info|
-        parameter = info['$ref']
-        path = parameter.split('/')[1..-1]
-        info = lookup_parameter(path, @schema)
-        resource_name = path.size > 2 ? path[1].gsub('-', '_') : nil
-        name = path[-1]
-        Parameter.new(resource_name, name, info['description'])
-      end
-    end
-    # Recursively walk the object hierarchy in the schema to resolve a given
-    # path.  This is used to find property information related to definitions
-    # in link hrefs.
-    #
-    # @param path [Array<String>] An array of paths to walk, such as
-    #   ['definitions', 'resource', 'definitions', 'property'].
-    # @param schema [Hash] The schema to walk.
-    def lookup_parameter(path, schema)
-      key = path[0]
-      remaining = path[1..-1]
-      if remaining.empty?
-        return schema[key]
-      else
-        lookup_parameter(remaining, schema[key])
-      end
-    end
-    # Convert a path parameter to a format suitable for use in a path.
-    #
-    # @param [Fixnum,String,TrueClass,FalseClass,Time] The parameter to format.
-    # @return [String] The formatted parameter.
-    def format_parameter(parameter)
-      formatted_parameter = parameter.instance_of?(Time) ? iso_format(parameter) : parameter.to_s
-      URI.escape formatted_parameter
-    end
-    # Convert a time to an ISO 8601 combined data and time format.
-    #
-    # @param time [Time] The time to convert to ISO 8601 format.
-    # @return [String] An ISO 8601 date in `YYYY-MM-DDTHH:MM:SSZ` format.
-    def iso_format(time)
-      time.getutc.strftime('%Y-%m-%dT%H:%M:%SZ')
-    end
-  end
-  # Download a JSON schema from a URL.
-  #
-  # @param url [String] The URL for the schema.
-  # @param options [Hash] Configuration for links.  Possible keys include:
-  #   - default_headers: Optionally, a set of headers to include in every
-  #     request made by the client.  Default is no custom headers.
-  # @return [Schema] The downloaded JSON schema.
-  def self.download_schema(url, options={})
-    default_headers = options.fetch(:default_headers, {})
-    response = Excon.get(url, headers: default_headers, expects: [200, 201])
-    Schema.new(MultiJson.load(response.body))
-  end
-  # The base parameter class
-  class BaseParameter
-    attr_reader :resource_name, :name, :description
-    # This is the used for generating the function signature
-    def signature
-      [@resource_name, @name].compact.join("_")
-    end
-    # A pretty representation of a parameter instance
-    def inspect
-      "#{self.class}(name=#{@name}, description=#{@description})"
-    end
-  end
-  # A representation of a parameter.
-  class Parameter < BaseParameter
-    def initialize(resource_name, name, description)
-      @resource_name = resource_name
-      @name = name
-      @description = description
-    end
-    # The name of the parameter, with the resource included, suitable for use
-    # in a function signature.
-    def name
-      [@resource_name, @name].compact.join("_")
-    end
-  end
-  # A representation of a body parameter.
-  class BodyParameter < BaseParameter
-    def initialize
-      @name = 'body'
-      @description = 'the object to pass as the request payload'
-    end
-  end
-  # Additional options to pass with a request
-  class CollectionOptions < BaseParameter
-    def initialize
-      @name = 'collection_options'
-      @description = 'additional collection options to pass with the request'
-    end
-    def signature
-      "#{@name} = {}"
-    end
-  end
-  # A representation of a set of parameters.
-  class ParameterChoice < BaseParameter
-    attr_reader :parameters
-    def initialize(resource_name, parameters)
-      @resource_name = resource_name
-      @parameters = parameters
-    end
-    # A name created by merging individual parameter descriptions, suitable
-    # for use in a function signature.
-    def name
-      @parameters.map do |parameter|
-        if parameter.resource_name
-          parameter.name
-        else
-          "#{@resource_name}_#{parameter.name}"
-        end
-      end.join('_or_')
-    end
-    def signature
-      name
-    end
-    # A description created by merging individual parameter descriptions.
-    def description
-      @parameters.map { |parameter| parameter.description }.join(' or ')
-    end
-    # A pretty representation of this instance.
-    def inspect
-      "ParameterChoice(parameters=#{@parameters})"
-    end
-  end
-end