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

komoju 0.0.4 → 0.0.7

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

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