resource_set 1.0.0

data/lib/resource_set/endpoint_resolver.rb

@@ -0,0 +1,46 @@
+require 'addressable/uri'
+
+module ResourceSet
+  class EndpointResolver
+    attr_reader :path, :query_param_keys
+
+    def initialize(options = {})
+      @path = options[:path]
+      @query_param_keys = options[:query_param_keys] || []
+    end
+
+    def resolve(values = {})
+      uri = Addressable::URI.parse(path)
+      new_path = generated_path(uri.path, values)
+
+      uri.path = normalized_path_components(new_path)
+      uri.query = append_query_values(uri, values) unless query_param_keys.empty?
+
+      uri.to_s
+    end
+
+    private
+
+    def generated_path(supplied_path, values)
+      values.inject(supplied_path) do |np, (key, value)|
+        np.gsub(":#{key}", value.to_s)
+      end
+    end
+
+    def normalized_path_components(*components)
+      components.reject(&:empty?).map do |piece|
+        # Remove leading and trailing forward slashes
+        piece.gsub(/(^\/)|(\/$)/, '')
+      end.join('/').insert(0, '/')
+    end
+
+    def append_query_values(uri, values)
+      pre_vals = uri.query_values || {}
+      params = query_param_keys.each_with_object(pre_vals) do |key, query_values|
+        query_values[key] = values[key] if values.has_key?(key)
+      end
+
+      URI.encode_www_form(params)
+    end
+  end
+end

data/lib/resource_set/inheritable_attribute.rb

@@ -0,0 +1,20 @@
+module ResourceSet
+  module InheritableAttribute
+    def inheritable_attr(name)
+      instance_eval <<-RUBY
+        def #{name}=(v)
+          @#{name} = v
+        end
+
+        def #{name}
+          @#{name} ||= InheritableAttribute.inherit(self, :#{name})
+        end
+      RUBY
+    end
+
+    def self.inherit(klass, name)
+      return unless klass.superclass.respond_to?(name) and value = klass.superclass.send(name)
+      value.clone
+    end
+  end
+end

data/lib/resource_set/method_factory.rb

@@ -0,0 +1,20 @@
+module ResourceSet
+  class MethodFactory
+    def self.construct(object, resource_collection, invoker = ActionInvoker)
+      resource_collection.each do |action|
+        if object.method_defined?(action.name)
+          raise ArgumentError, "Action '#{action.name}' is already defined on `#{object}`"
+        end
+        method_block = method_for_action(action, invoker)
+
+        object.send(:define_method, action.name, &method_block)
+      end
+    end
+
+    def self.method_for_action(action, invoker)
+      Proc.new do |*args|
+        invoker.call(action, self, *args)
+      end
+    end
+  end
+end

data/lib/resource_set/resource.rb

@@ -0,0 +1,40 @@
+require 'resource_set/inheritable_attribute'
+
+module ResourceSet
+  class Resource
+    extend InheritableAttribute
+    inheritable_attr :_resources
+
+    attr_reader :connection, :scope
+
+    def initialize(connection: nil, scope: nil)
+      @connection = connection
+      @scope = scope
+    end
+
+    def self.resources(&block)
+      self._resources ||= ResourceCollection.new
+
+      if block_given?
+        self._resources.instance_eval(&block)
+        MethodFactory.construct(self, self._resources)
+      end
+
+      self._resources
+    end
+
+    def action(name)
+      _resources.find_action(name)
+    end
+
+    def action_and_connection(action_name)
+      ActionConnection.new(action(action_name), connection)
+    end
+
+    private
+
+    def _resources
+      self.class._resources
+    end
+  end
+end

data/lib/resource_set/resource_collection.rb

@@ -0,0 +1,55 @@
+module ResourceSet
+  class ResourceCollection
+    extend Forwardable
+    def_delegators :@collection, :find, :<<, :each, :include?
+
+    def initialize
+      @collection = []
+    end
+
+    def action(name, verb_and_path = nil, &block)
+      action = Action.new(name, *parse_verb_and_path(verb_and_path))
+      action.handlers.merge!(default_handlers.dup)
+      action.instance_eval(&block) if block_given?
+      action.tap { |a| self << a }
+    end
+
+    ResourceSet::ALLOWED_VERBS.each do |verb|
+      define_method verb do |path_name, &block|
+        path, name = path_name.to_a.flatten
+        action(name, "#{verb.upcase} #{path}", &block)
+      end
+    end
+
+    def default_handler(*response_codes, &block)
+      if response_codes.empty?
+        default_handlers[:any] = block
+      else
+        response_codes.each do |code|
+          code = StatusCodeMapper.code_for(code) unless code.is_a?(Integer)
+          default_handlers[code] = block
+        end
+      end
+    end
+
+    def default_handlers
+      @default_handlers ||= {}
+    end
+
+    def find_action(name)
+      find do |action|
+        action.name == name
+      end
+    end
+
+    private
+
+    def parse_verb_and_path(verb_and_path)
+      return [] unless verb_and_path
+      regex = /(?<verb>GET|POST|HEAD|PUT|PATCH|DELETE|OPTIONS)?\s*(?<path>.+)?/i
+      matched = verb_and_path.match(regex)
+
+      return matched[:verb], matched[:path]
+    end
+  end
+end

data/lib/resource_set/status_code_mapper.rb

@@ -0,0 +1,59 @@
+module ResourceSet
+  class StatusCodeMapper
+    MAP = {
+      continue: 100,
+      switching_protocols: 101,
+      processing: 102,
+      ok: 200,
+      created: 201,
+      accepted: 202,
+      non_authoritative_information: 203,
+      no_content: 204,
+      reset_content: 205,
+      partial_content: 206,
+      multi_status: 207,
+      im_used: 226,
+      multiple_choices: 300,
+      moved_permanently: 301,
+      found: 302,
+      see_other: 303,
+      not_modified: 304,
+      use_proxy: 305,
+      temporary_redirect: 307,
+      bad_request: 400,
+      unauthorized: 401,
+      payment_required: 402,
+      forbidden: 403,
+      not_found: 404,
+      method_not_allowed: 405,
+      not_acceptable: 406,
+      proxy_authentication_required: 407,
+      request_timeout: 408,
+      conflict: 409,
+      gone: 410,
+      length_required: 411,
+      precondition_failed: 412,
+      request_entity_too_large: 413,
+      request_uri_too_long: 414,
+      unsupported_media_type: 415,
+      requested_range_not_satisfiable: 416,
+      expectation_failed: 417,
+      unprocessable_entity: 422,
+      locked: 423,
+      failed_dependency: 424,
+      upgrade_required: 426,
+      internal_server_error: 500,
+      not_implemented: 501,
+      bad_gateway: 502,
+      service_unavailable: 503,
+      gateway_timeout: 504,
+      http_version_not_supported: 505,
+      insufficient_storage: 507,
+      not_extended: 510
+    }
+
+    def self.code_for(symbol)
+      MAP[symbol] || symbol
+    end
+  end
+end

data/lib/resource_set/testing/action_handler_matchers.rb

@@ -0,0 +1,42 @@
+require 'ostruct'
+
+module ResourceSet
+  module Testing
+    class ActionHandlerMatchers
+      ResponseStub = Class.new(OpenStruct)
+
+      attr_reader :action, :response_stub, :failure_message
+
+      def initialize(action)
+        @action = action
+      end
+
+      def with(options, &block)
+        @response_stub = ResponseStub.new(options)
+        @handled_block = block
+
+        self
+      end
+
+      def matches?(subject, &block)
+        @handled_block ||= block
+        action = subject.resources.find_action(self.action)
+        unless action
+          @failure_message = "expected :#{self.action} to be handled by the class."
+          return false
+        end
+
+        status_code = response_stub.status || 200
+        unless action.handlers[status_code]
+          @failure_message = "expected the #{status_code} status code to be handled by the class."
+          return false
+        end
+
+        handled_response = action.handlers[status_code].call(response_stub)
+        @handled_block.call(handled_response)
+
+        true
+      end
+    end
+  end
+end

data/lib/resource_set/testing/have_action_matchers.rb

@@ -0,0 +1,85 @@
+module ResourceSet
+  module Testing
+    class HaveActionMatchers
+      attr_reader :action, :path, :verb
+
+      def initialize(action)
+        @action = action
+        @failures = []
+      end
+
+      def that_handles(*codes)
+        codes.each do |code|
+          handler_codes << StatusCodeMapper.code_for(code)
+        end
+
+        self
+      end
+
+      def at_path(path)
+        @path = path
+        self
+      end
+
+      def with_verb(verb)
+        @verb = verb
+        self
+      end
+
+      def matches?(subject)
+        action = subject.resources.find_action(self.action)
+        return false unless action
+
+        %i(check_keys check_path check_verb).inject(true) do |rv, method_name|
+          break false unless send(method_name, action)
+          true
+        end
+      end
+
+      def handler_codes
+        @handler_codes ||= []
+      end
+
+      def failure_message
+        return "expected class to have action #{action}." if failures.empty?
+
+        failures.map do |validation, expected, got|
+          "expected #{expected} #{validation}, got #{got} instead."
+        end.join('\n')
+      end
+
+      private
+      attr_reader :failures
+
+      def check_keys(action)
+        keys = action.handlers.keys
+
+        unless handler_codes.empty?
+          handler_codes.each do |handler_code|
+            unless keys.include?(handler_code)
+              return failed(:status_code, handler_code, keys)
+            end
+          end
+        end
+
+        true
+      end
+
+      def check_path(action)
+        return true unless self.path
+        action.path == self.path or failed(:path, self.path, action.path)
+      end
+
+      def check_verb(action)
+        return true unless self.verb
+        checked_verb = self.verb.kind_of?(String) ? self.verb.downcase.to_sym : self.verb
+        action.verb == checked_verb or failed(:verb, checked_verb, action.verb)
+      end
+
+      def failed(validation, expected, got)
+        failures << [validation, expected, got]
+        false
+      end
+    end
+  end
+end

data/lib/resource_set/testing.rb

@@ -0,0 +1,20 @@
+require 'resource_set/testing/have_action_matchers'
+require 'resource_set/testing/action_handler_matchers'
+
+module ResourceSet
+  module Testing
+    def have_action(action)
+      HaveActionMatchers.new(action)
+    end
+
+    def handle_response(action, &block)
+      ActionHandlerMatchers.new(action)
+    end
+  end
+end
+
+if defined?(RSpec)
+  RSpec.configure do |config|
+    config.include ResourceSet::Testing, resource_set: true
+  end
+end

data/lib/resource_set/version.rb

@@ -0,0 +1,3 @@
+module ResourceSet
+  VERSION = '1.0.0'
+end

data/lib/resource_set.rb

@@ -0,0 +1,17 @@
+require 'resource_set/version'
+
+module ResourceSet
+  ALLOWED_VERBS = [:get, :post, :put, :delete, :head, :patch, :options]
+  ActionConnection = Struct.new(:action, :connection)
+
+  autoload :Resource, 'resource_set/resource'
+  autoload :ResourceCollection, 'resource_set/resource_collection'
+
+  autoload :Action, 'resource_set/action'
+  autoload :ActionInvoker, 'resource_set/action_invoker'
+  autoload :MethodFactory, 'resource_set/method_factory'
+
+  autoload :StatusCodeMapper, 'resource_set/status_code_mapper'
+  autoload :EndpointResolver, 'resource_set/endpoint_resolver'
+
+end

data/resource_set.gemspec

@@ -0,0 +1,30 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'resource_set/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "resource_set"
+  spec.version       = ResourceSet::VERSION
+  spec.authors       = ["Robert Ross", "Ivan Vanderbyl", "Kyrylo Silin"]
+  spec.email         = ["engineering@digitalocean.com", "rross@digitalocean.com", "ivan@digitalocean.com", "silin@kyrylo.org"]
+  spec.summary       = %q{Resource Set provides tools to aid in making API Clients. Such as URL resolving, Request / Response layer, and more.}
+  spec.description   = ''
+  spec.homepage      = "https://github.com/kyrylo/resource_set"
+  spec.license       = "MIT"
+  spec.required_ruby_version = '>= 2.0'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency 'addressable', '< 3.0.0', '>= 2.3.6'
+
+  spec.add_development_dependency 'rake', '~> 12.0'
+  spec.add_development_dependency 'faraday'
+  spec.add_development_dependency 'rspec', '~> 3.6'
+  spec.add_development_dependency 'webmock', '~> 3.0'
+  spec.add_development_dependency 'cartograph', '~> 1.0'
+  spec.add_development_dependency 'pry', '~> 0'
+end