wcc-api 0.2.0 → 0.3.0

data/lib/wcc/api/json.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module WCC::API
   module JSON
   end

data/lib/wcc/api/json/pagination.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module WCC::API::JSON
   class Pagination
     attr_reader :query, :url_for
@@ -19,12 +21,12 @@ module WCC::API::JSON
         json.sort query.sort if query.respond_to?(:sort)
         json.filter query.filter
         json._links do
-          json.self url_for.(base_url_params)
+          json.self url_for.call(base_url_params)
           if has_previous_page?
-            json.previous url_for.(base_url_params.merge(offset: query.offset - query.limit))
+            json.previous url_for.call(base_url_params.merge(offset: query.offset - query.limit))
           end
           if has_next_page?
-            json.next url_for.(base_url_params.merge(offset: query.offset + query.limit))
+            json.next url_for.call(base_url_params.merge(offset: query.offset + query.limit))
           end
         end
       end
@@ -41,17 +43,18 @@ module WCC::API::JSON
     end
 
     def base_url_params
-      @base_url_params ||= {
-        filter: query.filter,
-        only_path: false
-      }.tap do |params|
-        if query.paging
-          params[:limit] = query.limit
-          params[:offset] = query.offset
+      @base_url_params ||=
+        {
+          filter: query.filter,
+          only_path: false
+        }.tap do |params|
+          if query.paging
+            params[:limit] = query.limit
+            params[:offset] = query.offset
+          end
+          params[:order_by] = query.order_by if query.respond_to?(:order_by)
+          params[:sort] = query.sort if query.respond_to?(:sort)
         end
-        params[:order_by] = query.order_by if query.respond_to?(:order_by)
-        params[:sort] = query.sort if query.respond_to?(:sort)
-      end
     end
   end
 end

data/lib/wcc/api/railtie.rb

@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 require 'wcc/api'
 
 module WCC
   module API
     class Railtie < Rails::Railtie
-      initializer 'wcc.api railtie initializer', group: :all do |app|
+      initializer 'wcc.api railtie initializer', group: :all do |_app|
         ActiveSupport::Inflector.inflections(:en) do |inflect|
           inflect.acronym 'API'
         end

data/lib/wcc/api/rest_client.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require_relative 'rest_client/response'
+
+module WCC::API
+  class RestClient
+    attr_reader :api_url
+
+    def initialize(api_url:, headers: nil, **options)
+      # normalizes a URL to have a slash on the end
+      @api_url = api_url.gsub(/\/+$/, '') + '/'
+
+      @adapter = RestClient.load_adapter(options[:adapter])
+
+      @options = options
+      @query_defaults = {}
+      @headers = {
+        'Accept' => 'application/json'
+      }.merge(headers || {}).freeze
+      @response_class = options[:response_class] || DefaultResponse
+    end
+
+    # performs an HTTP GET request to the specified path within the configured
+    # space and environment.  Query parameters are merged with the defaults and
+    # appended to the request.
+    def get(path, query = {})
+      url = URI.join(@api_url, path)
+
+      @response_class.new(self,
+        { url: url, query: query },
+        get_http(url, query))
+    end
+
+    ADAPTERS = {
+      http: ['http', '> 1.0', '< 3.0'],
+      typhoeus: ['typhoeus', '~> 1.0']
+    }.freeze
+
+    # This method is long due to the case statement,
+    # not really a better way to do it
+    def self.load_adapter(adapter)
+      case adapter
+      when nil
+        ADAPTERS.each do |a, spec|
+          begin
+            gem(*spec)
+            return load_adapter(a)
+          rescue Gem::LoadError
+            next
+          end
+        end
+        raise ArgumentError, 'Unable to load adapter!  Please install one of '\
+          "#{ADAPTERS.values.map(&:join).join(',')}"
+      when :http
+        require_relative 'rest_client/http_adapter'
+        HttpAdapter.new
+      when :typhoeus
+        require_relative 'rest_client/typhoeus_adapter'
+        TyphoeusAdapter.new
+      else
+        unless adapter.respond_to?(:call)
+          raise ArgumentError, "Adapter #{adapter} is not invokeable!  Please "\
+            "pass a proc or use one of #{ADAPTERS.keys}"
+        end
+        adapter
+      end
+    end
+
+    private
+
+    def get_http(url, query, headers = {}, proxy = {})
+      headers = @headers.merge(headers || {})
+
+      q = @query_defaults.dup
+      q = q.merge(query) if query
+
+      resp = @adapter.call(url, q, headers, proxy)
+
+      resp = get_http(resp.headers['location'], nil, headers, proxy) if [301, 302, 307].include?(resp.code) && !@options[:no_follow_redirects]
+      resp
+    end
+  end
+end

data/lib/wcc/api/rest_client/api_error.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module WCC::API
+  class RestClient
+    class ApiError < StandardError
+      attr_reader :response
+
+      def self.[](code)
+        case code
+        when 404
+          NotFoundError
+        else
+          ApiError
+        end
+      end
+
+      def initialize(response)
+        @response = response
+        super(response.error_message)
+      end
+    end
+
+    class NotFoundError < ApiError
+    end
+  end
+end

data/lib/wcc/api/rest_client/http_adapter.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+gem 'http'
+require 'http'
+
+module WCC::API
+  class RestClient
+    class HttpAdapter
+      def call(url, query, headers = {}, proxy = {})
+        if proxy[:host]
+          HTTP[headers].via(proxy[:host], proxy[:port], proxy[:username], proxy[:password])
+            .get(url, params: query)
+        else
+          HTTP[headers].get(url, params: query)
+        end
+      end
+    end
+  end
+end

data/lib/wcc/api/rest_client/response.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+require_relative 'api_error'
+
+module WCC::API
+  class RestClient
+    class AbstractResponse
+      extend ::Forwardable
+
+      attr_reader :raw_response
+      attr_reader :raw_body
+      attr_reader :client
+      attr_reader :request
+
+      def_delegators :raw_response, :code, :headers
+
+      def body
+        @body ||= ::JSON.parse(raw_body)
+      end
+      alias_method :to_json, :body
+
+      def initialize(client, request, raw_response)
+        @client = client
+        @request = request
+        @raw_response = raw_response
+        @raw_body = raw_response.body.to_s
+      end
+
+      def skip
+        throw new NotImplementedError, 'Please implement "skip" parsing in response class'
+      end
+
+      def count
+        throw new NotImplementedError, 'Please implement "count" parsing in response class'
+      end
+
+      def collection_response?
+        page_items.nil? ? false : true
+      end
+
+      def page_items
+        throw new NotImplementedError, 'Please implement "page_items" parsing in response class'
+      end
+
+      def error_message
+        parsed_message =
+          begin
+            body.dig('error', 'message') || body.dig('message')
+          rescue ::JSON::ParserError
+            nil
+          end
+        parsed_message || "#{code}: #{raw_response.body}"
+      end
+
+      def next_page?
+        return false unless collection_response?
+
+        page_items.length + skip < count
+      end
+
+      def next_page
+        return unless next_page?
+
+        @next_page ||= @client.get(
+          @request[:url],
+          (@request[:query] || {}).merge(next_page_query)
+        )
+        @next_page.assert_ok!
+      end
+
+      def assert_ok!
+        return self if code >= 200 && code < 300
+
+        raise ApiError[code], self
+      end
+
+      # This method has a bit of complexity that is better kept in one location
+      def each_page(&block)
+        raise ArgumentError, 'Not a collection response' unless collection_response?
+
+        ret =
+          Enumerator.new do |y|
+            y << self
+
+            if next_page?
+              next_page.each_page.each do |page|
+                y << page
+              end
+            end
+          end
+
+        if block_given?
+          ret.map(&block)
+        else
+          ret.lazy
+        end
+      end
+
+      def items
+        return unless collection_response?
+
+        each_page.flat_map(&:page_items)
+      end
+
+      def first
+        raise ArgumentError, 'Not a collection response' unless collection_response?
+
+        page_items.first
+      end
+
+      def next_page_query
+        return unless collection_response?
+
+        {
+          skip: page_items.length + skip
+        }
+      end
+    end
+
+    class DefaultResponse < AbstractResponse
+      def skip
+        body['skip']
+      end
+
+      def count
+        body['total']
+      end
+
+      def page_items
+        body['items']
+      end
+    end
+  end
+end

data/lib/wcc/api/rest_client/typhoeus_adapter.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+gem 'typhoeus'
+require 'typhoeus'
+
+module WCC::API
+  class RestClient
+    class TyphoeusAdapter
+      def call(url, query, headers = {}, proxy = {})
+        raise NotImplementedError, 'Proxying Not Yet Implemented' if proxy[:host]
+
+        TyphoeusAdapter::Response.new(
+          Typhoeus.get(
+            url,
+            params: query,
+            headers: headers
+          )
+        )
+      end
+
+      Response =
+        Struct.new(:raw) do
+          extend Forwardable
+
+          def_delegators :raw, :body, :to_s, :code, :headers
+
+          def status
+            raw.code
+          end
+        end
+    end
+  end
+end

data/lib/wcc/api/rspec.rb

@@ -1,4 +1,5 @@
+# frozen_string_literal: true
+
 require 'wcc/api/rspec/cache_header_examples'
 require 'wcc/api/rspec/collection_matchers'
 require 'wcc/api/rspec/pagination_examples'
-

data/lib/wcc/api/rspec/cache_header_examples.rb

@@ -1,41 +1,43 @@
-RSpec.shared_examples_for "cached resource defaults" do
-  it "sets etag" do
+# frozen_string_literal: true
+
+RSpec.shared_examples_for 'cached resource defaults' do
+  it 'sets etag' do
     expect(response.etag).to_not be_nil
   end
 
-  it "sets public: true" do
+  it 'sets public: true' do
     expect(response.cache_control[:public]).to be_truthy
   end
 end
 
-RSpec.shared_examples_for "cached member resource" do
-  include_examples "cached resource defaults"
+RSpec.shared_examples_for 'cached member resource' do
+  include_examples 'cached resource defaults'
 
-  it "sets last modified" do
+  it 'sets last modified' do
     expect(response.last_modified).to_not be_nil
   end
 
-  it "does not set max age" do
+  it 'does not set max age' do
     expect(response.cache_control[:max_age]).to be_nil
   end
 
-  it "does not set must_revalidate" do
+  it 'does not set must_revalidate' do
     expect(response.cache_control[:must_revalidate]).to be_nil
   end
 end
 
-RSpec.shared_examples_for "cached collection resource" do |max_age|
-  include_examples "cached resource defaults"
+RSpec.shared_examples_for 'cached collection resource' do |max_age|
+  include_examples 'cached resource defaults'
 
-  it "sets max age" do
+  it 'sets max age' do
     expect(response.cache_control[:max_age]).to eq(max_age.to_s)
   end
 
-  it "sets must_revalidate: true" do
+  it 'sets must_revalidate: true' do
     expect(response.cache_control[:must_revalidate]).to be_truthy
   end
 
-  it "does not set last modified" do
+  it 'does not set last modified' do
     expect(response.last_modified).to be_nil
   end
 end

data/lib/wcc/api/rspec/collection_matchers.rb

@@ -1,7 +1,10 @@
+# frozen_string_literal: true
+
 module WCC::API::RSpec
   module CollectionMatchers
     def collection_match(coll1, coll2, matcher = :eq)
-      coll1, coll2 = coll1.to_a, coll2.to_a
+      coll1 = coll1.to_a
+      coll2 = coll2.to_a
       expect(coll1.size).to eq(coll2.size)
 
       coll1.zip(coll2).each do |actual, expected|
@@ -10,4 +13,3 @@ module WCC::API::RSpec
     end
   end
 end
-