wcc-api 0.3.1 → 0.5.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 7bedfb36a9e68268018251cd3eed45b74c874e56
-  data.tar.gz: 32a2c0d92acef030ba5f8c36f4f851352798fc0d
+SHA256:
+  metadata.gz: 28ce3f8ce50bf220052fdf1f607457725083577e2085927ac565aa6f2c7a1c93
+  data.tar.gz: 16c1f3e5329e8b711c0cdab943d4c270c35b186f71875278776499b4e47b4323
 SHA512:
-  metadata.gz: 6b8ea49a7dc7753e303fff2304bcade5fd9ea9090fc8b8c42d806cd007adaec3297828e20e154989f082206a5c65d7205728b6746117acbd0afb9c4ddfe065a8
-  data.tar.gz: 4429bff8721f6677c354d97cec257f516af79aa9433c772696cad5be3395ac18c8305ba6d81988fcaf9125ba88f6458bee775dad96f6eb0ad9a760ae36d987e6
+  metadata.gz: da429643f12efb3b7c136324ce7598980efc85192c06fc566790a7e9440bd54a6051c646a1f931b80a15f0da0b52f40a6df60f53d2733b0195a3d1a963f26581
+  data.tar.gz: 1866949150576051ed35474f0f1b165c377ebcb5e3678d752eb01b2c5411a210b6ad1a0ca38e05cbd5ad1c1a6c320195ae0595d6de6935e98608510a17ed3708

data/lib/wcc/api/active_record_shim.rb

@@ -0,0 +1,69 @@
+module WCC::API::ActiveRecordShim
+  def self.included(base)
+    base.public_send :include, InstanceMethods
+    base.extend ClassMethods
+  end
+
+  module InstanceMethods
+    def attributes
+      raw.keys.each_with_object({}) do |key, h|
+        next unless respond_to?(key)
+
+        val = public_send(key)
+        h[key] =
+          if val.is_a? Array
+            val.map { |v| v.respond_to?(:to_h) ? v.to_h : v }
+          else
+            val.respond_to?(:to_h) ? val.to_h : val
+          end
+      end
+    end
+  end
+
+  module ClassMethods
+    def find(id)
+      client.public_send(endpoint).find(id)
+    end
+
+    def find_all(**filters)
+      client.public_send(endpoint).list(filters)
+    end
+
+    def find_by(**filters)
+      raise ArgumentError, "You must provide at least one filter" if filters.empty?
+
+      find_all(filters).first
+    end
+
+    def model_name
+      name
+    end
+
+    def table_name
+      endpoint
+    end
+
+    def unscoped
+      yield
+    end
+
+    def find_in_batches(options, &block)
+      options = options ? options.dup : {}
+      batch_size = options.delete(:batch_size) || 1000
+      skip_param = [:skip, :offset]
+
+      filter = {
+        limit: batch_size,
+        offset: options.delete(:start) || 0
+      }
+
+      find_all(filter).each_slice(batch_size, &block)
+    end
+
+    def where(**conditions)
+      # TODO: return a Query object that implements more of the ActiveRecord query interface
+      # https://guides.rubyonrails.org/active_record_querying.html#conditions
+      find_all(conditions)
+    end
+  end
+end

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

@@ -0,0 +1,82 @@
+module WCC::API
+  class RestClient
+    class Builder
+      def initialize(klass)
+        @klass = klass
+      end
+
+      def params(*params)
+        @params = params.map(&:to_s)
+      end
+
+      attr_writer :resource_class
+      def resource_class
+        @resource_class ||=
+          @klass.const_get("Resource") || WCC::API::RestClient::Resource
+      end
+
+      def resource(endpoint, model:, **options, &block)
+        @resources ||= {}
+
+        resource_class = options[:resource_class] || self.resource_class
+        if block_given?
+          resource_class = Class.new(resource_class, &block)
+        end
+        @resources[endpoint] = options.merge({
+          resource_class: resource_class,
+          model: model,
+        })
+      end
+
+      def apply
+        closed_params = (@params || []).freeze
+        resources = @resources
+        klass = @klass
+
+        klass.class_exec do
+          define_singleton_method :params do
+            closed_params
+          end
+
+          define_singleton_method :default do
+            @default ||= new
+          end
+
+          define_singleton_method :default= do |client|
+            @default = client
+          end
+
+          resources.each do |(endpoint, options)|
+            attr_name = options[:attribute] || endpoint.downcase
+            resource_class = options[:resource_class]
+
+            define_method attr_name do
+              instance_variable_get("@#{attr_name}") ||
+                instance_variable_set("@#{attr_name}", 
+                  resource_class.new(self, endpoint, options[:model], @options.merge(options))
+                )
+            end
+          end
+        end
+
+        resources.each do |(endpoint, options)|
+          options[:model].class_exec do
+            define_singleton_method :client do
+              klass.default
+            end
+
+            define_singleton_method :endpoint do
+              endpoint
+            end
+
+            define_singleton_method :key do
+              options[:key]
+            end
+          end
+
+          options[:model].send(:include, WCC::API::ActiveRecordShim)
+        end
+      end
+    end
+  end
+end

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

@@ -13,7 +13,8 @@ module WCC::API
       attr_reader :client
       attr_reader :request
 
-      def_delegators :raw_response, :code, :headers
+      def_delegators :raw_response, :status, :headers
+      alias_method :code, :status
 
       def body
         @body ||= ::JSON.parse(raw_body)
@@ -55,6 +56,7 @@ module WCC::API
 
       def next_page?
         return false unless collection_response?
+        return false if count.nil?
 
         page_items.length + skip < count
       end
@@ -62,11 +64,11 @@ module WCC::API
       def next_page
         return unless next_page?
 
-        @next_page ||= @client.get(
+        next_page ||= @client.get(
           @request[:url],
           (@request[:query] || {}).merge(next_page_query)
         )
-        @next_page.assert_ok!
+        next_page.assert_ok!
       end
 
       def assert_ok!
@@ -79,16 +81,7 @@ module WCC::API
       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
+        ret = PaginatingEnumerable.new(self)
 
         if block_given?
           ret.map(&block)
@@ -131,5 +124,25 @@ module WCC::API
         body['items']
       end
     end
+
+    class PaginatingEnumerable
+      include Enumerable
+  
+      def initialize(initial_page)
+        raise ArgumentError, 'Must provide initial page' unless initial_page
+  
+        @initial_page = initial_page
+      end
+  
+      def each
+        page = @initial_page
+        yield page
+  
+        while page.next_page?
+          page = page.next_page
+          yield page
+        end
+      end
+    end
   end
 end

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

@@ -4,31 +4,60 @@ 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
+class WCC::API::RestClient::TyphoeusAdapter
+  def get(url, params = {}, headers = {})
+    req = OpenStruct.new(params: params, headers: headers)
+    yield req if block_given?
+    Response.new(
+      Typhoeus.get(
+        url,
+        params: req.params,
+        headers: req.headers
+      )
+    )
+  end
+
+  def post(url, body, headers = {})
+    Response.new(
+      Typhoeus.post(
+        url,
+        body: body.is_a?(String) ? body : body.to_json,
+        headers: headers
+      )
+    )
+  end
+
+  def put(url, body, headers = {})
+    Response.new(
+      Typhoeus.put(
+        url,
+        body: body.is_a?(String) ? body : body.to_json,
+        headers: headers
+      )
+    )
+  end
+
+  def delete(url, query = {}, headers = {})
+    Response.new(
+      Typhoeus.delete(
+        url,
+        headers: headers
+      )
+    )
+  end
+
+  class Response < SimpleDelegator
+    def raw
+      __getobj__
+    end
+
+    def to_s
+      body&.to_s
+    end
+
+    def status
+      code
     end
   end
 end
+

data/lib/wcc/api/rest_client.rb

@@ -2,11 +2,23 @@
 
 require 'wcc'
 require_relative 'rest_client/response'
+require_relative 'rest_client/builder'
+require_relative 'active_record_shim'
 
 module WCC::API
   class RestClient
     attr_reader :api_url
 
+    class << self
+      attr_reader :resources, :params
+
+      def rest_client(&block)
+        builder = Builder.new(self)
+        builder.instance_exec(&block)
+        builder.apply
+      end
+    end
+
     def initialize(api_url:, headers: nil, **options)
       # normalizes a URL to have a slash on the end
       @api_url = api_url.gsub(/\/+$/, '') + '/'
@@ -32,13 +44,39 @@ module WCC::API
         get_http(url, query))
     end
 
+    def post(path, body = {})
+      url = URI.join(@api_url, path)
+
+      @response_class.new(self,
+        { url: url },
+        post_http(url,
+          body.to_json,
+          headers: { 'Content-Type': 'application/json' }))
+    end
+
+    def put(path, body = {})
+      url = URI.join(@api_url, path)
+
+      @response_class.new(self,
+        { url: url },
+        put_http(url,
+          body.to_json,
+          headers: { 'Content-Type': 'application/json' }))
+    end
+
+    def delete(path)
+      url = URI.join(@api_url, path)
+
+      @response_class.new(self,
+        { url: url },
+        delete_http(url))
+    end
+
     ADAPTERS = {
-      http: ['http', '> 1.0', '< 3.0'],
+      faraday: ['faraday', '~> 0.9'],
       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
@@ -52,16 +90,19 @@ module WCC::API
         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 :faraday
+        require 'faraday'
+        ::Faraday.new do |faraday|
+          faraday.response :logger, (Rails.logger if defined?(Rails)), { headers: false, bodies: false }
+          faraday.adapter :net_http
+        end
       when :typhoeus
         require_relative 'rest_client/typhoeus_adapter'
         TyphoeusAdapter.new
       else
-        unless adapter.respond_to?(:call)
+        unless adapter.respond_to?(:get)
           raise ArgumentError, "Adapter #{adapter} is not invokeable!  Please "\
-            "pass a proc or use one of #{ADAPTERS.keys}"
+            "pass use one of #{ADAPTERS.keys} or create a Faraday-compatible adapter"
         end
         adapter
       end
@@ -69,16 +110,129 @@ module WCC::API
 
     private
 
-    def get_http(url, query, headers = {}, proxy = {})
+    def get_http(url, query, headers = {})
       headers = @headers.merge(headers || {})
 
       q = @query_defaults.dup
       q = q.merge(query) if query
 
-      resp = @adapter.call(url, q, headers, proxy)
+      resp = @adapter.get(url, q, headers)
 
-      resp = get_http(resp.headers['location'], nil, headers, proxy) if [301, 302, 307].include?(resp.code) && !@options[:no_follow_redirects]
+      resp = get_http(resp.headers['location'], nil, headers) if [301, 302, 307].include?(resp.status) && !@options[:no_follow_redirects]
       resp
     end
+
+    def post_http(url, body, headers: {})
+      headers = @headers.merge(headers || {})
+
+      resp = @adapter.post(url, body, headers)
+
+      resp = get_http(resp.headers['location'], nil, headers) if [301, 302, 307].include?(resp.status) && !@options[:no_follow_redirects]
+      resp
+    end
+
+    def put_http(url, body, headers: {})
+      headers = @headers.merge(headers || {})
+
+      resp = @adapter.put(url, body, headers)
+
+      resp = get_http(resp.headers['location'], nil, headers) if [301, 302, 307].include?(resp.status) && !@options[:no_follow_redirects]
+      resp
+    end
+
+    def delete_http(url, headers: {})
+      headers = @headers.merge(headers || {})
+
+      resp = @adapter.delete(url, {}, headers)
+
+      resp = get_http(resp.headers['location'], nil, headers) if [301, 302, 307].include?(resp.status) && !@options[:no_follow_redirects]
+      resp
+    end
+
+    class Resource
+      attr_reader :client, :endpoint, :model, :options
+
+      def initialize(client, endpoint, model, options)
+        @client = client
+        @endpoint = endpoint
+        @model = model
+        @options = options
+      end
+
+      def find(id, query = {})
+        query = (options[:query] || {}).merge(query)
+        resp = client.get("#{endpoint}/#{id}", query)
+        resp.assert_ok!
+        body = options[:key] ? resp.body[options[:key]] : resp.body
+        model.new(body, resp.headers.freeze)
+      end
+
+      def list(**filters)
+        query = extract_params(filters)
+        query = (options[:query] || {}).merge(query)
+        query = query.merge!(apply_filters(filters, options[:filters]))
+        resp = client.get(endpoint, query)
+        resp.assert_ok!
+        resp.items.map { |s| model.new(s) }
+      end
+
+      def create(body)
+        resp = client.post(endpoint, body)
+        resp.assert_ok!
+        maybe_model_from_response(resp)
+      end
+
+      def update(id, body)
+        resp = client.put("#{endpoint}/#{id}", body)
+        resp.assert_ok!
+        maybe_model_from_response(resp)
+      end
+
+      def destroy(id)
+        resp = client.delete("#{endpoint}/#{id}")
+        resp.assert_ok!
+        maybe_model_from_response(resp)
+      end
+
+      protected
+
+      def maybe_model_from_response(resp)
+        return true if resp.status == 204
+        return true unless resp.raw_body.present?
+
+        body = options[:key] ? resp.body[options[:key]] : resp.body
+        return true unless body.present?
+
+        model.new(body, resp.headers.freeze)
+      end
+
+      def extract_params(filters)
+        filters.each_with_object({}) do |(k, _v), h|
+          k_s = k.to_s
+          h[k_s] = filters.delete(k) if client.class.params.include?(k_s)
+        end
+      end
+
+      def filter_key(filter_name)
+        filter_name
+      end
+
+      def apply_filters(filters, expected_filters)
+        defaults = default_filters(expected_filters) || {}
+        filters.each_with_object(defaults) do |(k, v), h|
+          k = k.to_s
+          raise ArgumentError, "Unknown filter '#{k}'" unless expected_filters.include?(k)
+
+          h[filter_key(k)] = v
+        end
+      end
+
+      def default_filters(expected_filters)
+        options[:default_filters]&.each_with_object({}) do |(k, v), h|
+          k = k.to_s
+          h[filter_key(k)] = v if expected_filters.include?(k)
+        end
+      end
+    end
   end
 end

data/lib/wcc/api/version.rb

@@ -2,6 +2,6 @@
 
 module WCC
   module API
-    VERSION = '0.3.1'
+    VERSION = '0.5.2'
   end
 end

data/wcc-api.gemspec

@@ -15,21 +15,22 @@ Gem::Specification.new do |spec|
   spec.homepage      = 'https://github.com/watermarkchurch/wcc-api'
   spec.license       = 'MIT'
 
-  spec.files         = `git ls-files -z`.split("\x0")
-  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.files         = Dir['lib/**/*'] + %w[LICENSE.txt README.md wcc-api.gemspec]
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ['lib']
 
   spec.add_dependency 'wcc-base'
 
-  spec.add_development_dependency 'bundler', '~> 1.6'
   spec.add_development_dependency 'dotenv', '~> 0.10.0'
-  spec.add_development_dependency 'http', '> 1.0', '< 3.0'
+  spec.add_development_dependency 'faraday', '~> 0.9'
+  spec.add_development_dependency 'guard', '~> 2.15'
+  spec.add_development_dependency 'guard-rspec', '~> 4.7'
+  spec.add_development_dependency 'guard-rubocop', '~> 1.3'
   spec.add_development_dependency 'httplog', '~> 1.0'
   spec.add_development_dependency 'rake', '~> 12.3'
   spec.add_development_dependency 'rspec', '~> 3.3'
   spec.add_development_dependency 'rspec_junit_formatter', '~> 0.3.0'
-  spec.add_development_dependency 'rubocop'
+  spec.add_development_dependency 'rubocop', '0.69.0'
   spec.add_development_dependency 'typhoeus', '~> 1.3'
   spec.add_development_dependency 'webmock', '~> 3.0'
 end