jsonapi-consumer 0.1.1 → 1.0.0

data/lib/jsonapi/consumer/parser.rb

@@ -1,75 +0,0 @@
-module JSONAPI::Consumer
-  class Parser
-    attr_reader :response, :klass
-
-    def initialize(klass, response)
-      @klass = klass
-      @response = response
-    end
-
-    def attributes(item)
-      item.except(:links)
-    end
-
-    def associations(item)
-      associations = {}
-      item.fetch(:links, {}).each do |assoc_name, ids|
-        associations[assoc_name] = if ids.is_a?(Array)
-                                     ids.collect {|id| find_linked(assoc_name, id) }
-                                   else
-                                     find_linked(assoc_name, ids)
-                                   end
-      end
-      associations
-    end
-
-    def fetch_resource
-      link_body = _body.fetch(:links, {})
-
-      links = {}
-
-      link_body.each do |key, url|
-        links[key.split('.').last] = url
-      end
-
-      links
-    end
-
-    def fetch_linked(assoc_name, id)
-      klass._association_class_name(assoc_name).find(id)
-    end
-
-    def find_linked(assoc_name, id)
-      if found = linked.fetch(assoc_name.pluralize, []).detect {|h| h.fetch(:id) == id }
-        klass._association_class_name(assoc_name).new(found)
-      else
-        fetch_linked(assoc_name, id)
-      end
-    end
-
-    def linked
-      linked_body = _body.fetch(:linked, {})
-
-      linked = {}
-      linked_body.each do |key, obj_attrs|
-        linked[key] = obj_attrs
-      end
-      linked
-    end
-
-    def build
-      _body.fetch(klass.json_key, []).collect do |attrs|
-        attrs_hash = attributes(attrs).merge(associations(attrs))
-        klass.new(attrs_hash)
-      end
-    end
-
-    def _body
-      response.body.with_indifferent_access
-    end
-
-    def _status
-      reponse.status
-    end
-  end
-end

data/lib/jsonapi/consumer/query/base.rb

@@ -1,34 +0,0 @@
-module JSONAPI::Consumer::Query
-  class Base
-    class << self
-      attr_accessor :request_method
-    end
-    attr_reader :klass, :headers, :path, :params
-
-    def initialize(klass, payload)
-      @klass = klass
-      build_params(payload) if payload.is_a?(Hash) && payload.keys != [klass.primary_key]
-
-      @path = begin
-                if payload.is_a?(Hash) && payload.has_key?(klass.primary_key)
-                  [klass.path, payload.delete(klass.primary_key)].join('/')
-                else
-                  klass.path
-                end
-              end
-    end
-
-    def build_params(args)
-      @params = args.dup
-    end
-
-    def request_method
-      self.class.request_method
-    end
-
-    def inspect
-      "#{self.class.name}: method: #{request_method}; path: #{path}; params: #{params}, headers: #{headers}"
-    end
-
-  end
-end

data/lib/jsonapi/consumer/query/create.rb

@@ -1,9 +0,0 @@
-module JSONAPI::Consumer::Query
-  class Create < Base
-    self.request_method = :post
-
-    def build_params(args)
-      @params = {klass.json_key => args}
-    end
-  end
-end

data/lib/jsonapi/consumer/query/delete.rb

@@ -1,10 +0,0 @@
-module JSONAPI::Consumer::Query
-  class Delete < Base
-    self.request_method = :delete
-
-    def params
-      nil
-    end
-  end
-end
-

data/lib/jsonapi/consumer/query/find.rb

@@ -1,16 +0,0 @@
-module JSONAPI::Consumer::Query
-  class Find < Base
-    self.request_method = :get
-
-    def build_params(args)
-      @params = case args
-                when Hash
-                  args
-                when Array
-                  {klass.primary_key.to_s.pluralize.to_sym => args.join(",")}
-                else
-                  {klass.primary_key => args}
-                end
-    end
-  end
-end

data/lib/jsonapi/consumer/query/new.rb

@@ -1,15 +0,0 @@
-module JSONAPI::Consumer::Query
-  class New < Base
-    self.request_method = :get
-
-    def initialize(klass, payload)
-      super
-      @path = [klass.path, 'new'].join('/')
-    end
-
-    # def build_params(args)
-      # @params = {klass.json_key => args}
-    # end
-  end
-end
-

data/lib/jsonapi/consumer/query/update.rb

@@ -1,11 +0,0 @@
-module JSONAPI::Consumer::Query
-  class Update < Base
-    self.request_method = :put
-
-    def build_params(args)
-      args = args.dup
-      @params = {klass.json_key => args.except(klass.primary_key)}
-    end
-  end
-end
-

data/lib/jsonapi/consumer/query.rb

@@ -1,5 +0,0 @@
-module JSONAPI::Consumer
-  module Query
-
-  end
-end

data/lib/jsonapi/consumer/resource/association_concern.rb

@@ -1,203 +0,0 @@
-module JSONAPI::Consumer::Resource
-  class MisconfiguredAssociation < StandardError; end
-
-  module AssociationConcern
-    extend ActiveSupport::Concern
-
-    module ClassMethods
-      attr_writer :_associations
-
-      # Defines a has many relationship.
-      #
-      # @example
-      #   class User
-      #     include JSONAPI::Consumer::Resource
-      #     has_many :articles, class_name: 'Article'
-      #   end
-      def has_many(*attrs)
-        associate(:has_many, attrs)
-      end
-
-      # @todo belongs to is not supported yet.
-      #
-      def belongs_to(*attrs)
-        associate(:belongs_to, attrs)
-      end
-
-      # Defines a single relationship.
-      #
-      # @example
-      #   class Article
-      #     include JSONAPI::Consumer::Resource
-      #     has_one :user, class_name: 'User'
-      #   end
-      def has_one(*attrs)
-        associate(:has_one, attrs)
-      end
-
-      # :nodoc:
-      def _associations
-        @_associations ||= {}
-      end
-
-      # :nodoc:
-      def _association_for(name)
-        _associations[name.to_sym]
-      end
-
-      # :nodoc:
-      def _association_type(name)
-        _association_for(name).fetch(:type)
-      end
-
-      # :nodoc:
-      def _association_class_name(name)
-        if class_name = _association_for(name).fetch(:class_name)
-          begin
-            class_name.constantize
-          rescue NameError
-            raise MisconfiguredAssociation,
-              "#{self}##{_association_type(name)} #{name} has a class_name specified that does not exist."
-          end
-        else
-          raise MisconfiguredAssociation,
-            "#{self}##{_association_type(name)} #{name} is missing an explicit `:class_name` value."
-        end
-      end
-
-      # :nodoc:
-      def associate(type, attrs)
-        options = attrs.extract_options!
-
-        self._associations =  _associations.dup
-
-        attrs.each do |attr|
-          unless method_defined?(attr)
-            define_method attr do
-              read_association(attr)
-            end
-          end
-
-          if type == :has_many
-            unless method_defined?(:"#{attr.to_s.singularize}_ids")
-              define_method :"#{attr.to_s.singularize}_ids" do
-                if objs = read_association(attr)
-                  objs.collect {|o| o.send(o.primary_key)}
-                end
-              end
-            end
-          else
-            unless method_defined?(:"#{attr.to_s.singularize}_id")
-              define_method :"#{attr.to_s.singularize}_id" do
-                if obj = read_association(attr)
-                  obj.send(obj.primary_key)
-                end
-              end
-            end
-          end
-          unless method_defined?(:"#{attr}=")
-            define_method :"#{attr}=" do |val|
-              val = [val].flatten if type == :has_many && !val.nil?
-              set_association(attr, val)
-            end
-          end
-
-          self._associations[attr] = {type: type, class_name: options.delete(:class_name), options: options}
-        end
-      end
-    end
-
-    # :nodoc:
-    def each_association(&block)
-      self.class._associations.dup.each do |name, options|
-        association = self.send(name)
-
-        if block_given?
-          block.call(name, association, options[:options])
-        end
-      end
-    end
-
-    # Helper method that returns the names of defined associations.
-    #
-    # @return [Array<Symbol>] a list of association names
-    def association_names
-      self.class._associations.keys
-    end
-
-  protected
-
-
-    # Read the specified association.
-    #
-    # @param name [Symbol, String] the association name, `:users` or `:author`
-    #
-    # @return [Array, Object, nil] the value(s) of that association.
-    def read_association(name)
-      type = _association_type(name)
-      _associations.fetch(name, nil)
-    end
-
-    # Set values for the key'd association.
-    #
-    # @param key [Symbol] the association name, `:users` or `:author`
-    # @param value the value to set on the specified association
-    def set_association(key, value)
-      _associations[key.to_sym] = _cast_association(key, value)
-    end
-
-
-    # Helper method that verifies a given association exists.
-    #
-    # @param attr_name [String, Symbol] the association name
-    #
-    # @return [true, false]
-    def has_association?(attr_name)
-      _associations.has_key?(attr_name.to_sym)
-    end
-
-  private
-
-    # :nodoc:
-    def _cast_association(name, value)
-      return if value.is_a?(Array) && _association_type(name) != :has_many
-      return value if value.nil?
-
-      association_class = _association_class_name(name)
-
-      case value
-      when association_class
-        value
-      when Array
-        value.collect {|i| _cast_association(name, i) }
-      when Hash
-        association_class.new(value)
-      when NilClass
-        nil
-      else
-        association_class.new({association_class.primary_key => value})
-      end
-    end
-
-    # :nodoc:
-    def _association_for(name)
-      self.class._association_for(name)
-    end
-
-    # :nodoc:
-    def _association_type(name)
-      self.class._association_type(name)
-    end
-
-    # :nodoc:
-    def _association_class_name(name)
-      self.class._association_class_name(name)
-    end
-
-    # :nodoc:
-    def _associations
-      @associations ||= {}
-    end
-
-  end
-end

data/lib/jsonapi/consumer/resource/attributes_concern.rb

@@ -1,70 +0,0 @@
-module JSONAPI::Consumer::Resource
-  module AttributesConcern
-    extend ActiveSupport::Concern
-
-    include ActiveModel::AttributeMethods
-    include ActiveModel::Dirty
-
-    included do
-      attr_reader :attributes
-    end
-
-    def attributes=(attrs={})
-      @attributes ||= {}
-
-      return @attributes unless attrs.present?
-      attrs.each do |key, value|
-        set_attribute(key, value)
-      end
-    end
-
-    def update_attributes(attrs={})
-      self.attributes = attrs
-      # FIXME save
-    end
-
-    def persisted?
-      !self.to_param.blank?
-    end
-
-    def to_param
-      attributes.fetch(primary_key, '').to_s
-    end
-
-    # def [](key)
-      # read_attribute(key)
-    # end
-
-    # def []=(key, value)
-      # set_attribute(key, value)
-    # end
-
-    alias :respond_to_without_attributes? :respond_to?
-    def respond_to?(method, include_private_methods=false)
-      if super
-        true
-      elsif !include_private_methods && super(method, true)
-        # If we're here then we haven't found among non-private methods
-        # but found among all methods. Which means that the given method is private.
-        false
-      else
-        has_attribute?(method)
-      end
-    end
-
-  private
-
-    def read_attribute(name)
-      attributes.fetch(name, nil)
-    end
-
-    def set_attribute(key, value)
-      attributes[key.to_sym] = value
-    end
-
-    def has_attribute?(attr_name)
-      attributes.has_key?(attr_name.to_sym)
-    end
-
-  end
-end

data/lib/jsonapi/consumer/resource/connection_concern.rb

@@ -1,99 +0,0 @@
-module JSONAPI::Consumer
-  module ConnectionConcern
-    extend ActiveSupport::Concern
-
-    module ClassMethods
-      def parser_class
-        @parser ||= Parser
-      end
-
-      def parse(response)
-        parser = parser_class.new(self, response)
-
-        if response.status && response.status == 204
-          true
-        else
-          parser.build
-        end
-      end
-
-      # :nodoc:
-      def _run_request(query_object)
-        parse(_connection.send(query_object.request_method, query_object.path, query_object.params, query_object.headers))
-      end
-
-      # :nodoc:
-      def _connection(reload=false)
-        self.connection = nil if !!reload
-        self.connection ||= begin
-          Faraday.new(url: self.host, ssl: self.ssl) do |conn|
-            conn.request :json
-            conn.request :request_headers, accept: "application/json"
-
-            yield(conn) if block_given?
-
-            conn.use Middleware::RequestTimeout
-            conn.use Middleware::ParseJson
-
-            conn.use Middleware::RaiseError
-            conn.adapter Faraday.default_adapter
-          end
-
-        end
-      end
-    end
-
-    def is_valid?
-      errors.empty?
-    end
-
-    def save
-      query = persisted? ?
-        Query::Update.new(self.class, self.serializable_hash) :
-        Query::Create.new(self.class, self.serializable_hash)
-
-      results = run_request(query)
-
-      if self.errors.empty?
-        self.attributes = results.first.attributes
-        true
-      else
-        false
-      end
-    end
-
-    def destroy
-      if run_request(Query::Delete.new(self.class, self.serializable_hash))
-        self.attributes.clear
-        true
-      else
-        false
-      end
-    end
-
-  private
-
-    # :nodoc:
-    def run_request(*args)
-      begin
-        self.errors.clear
-        request = self.class._run_request(*args)
-      rescue JSONAPI::Consumer::Errors::BadRequest => e
-        e.errors.map do |error|
-          process_error(error.dup)
-        end
-      end
-    end
-
-    # :nodoc:
-    def process_error(err)
-      field = err.fetch('path', '')
-      attr = field.match(/\A\/(\w+)\z/)
-      if attr[1] && has_attribute?(attr[1])
-        self.errors.add(attr[1].to_sym, err.fetch('detail', ''))
-      else
-        self.errors.add(:base, err.fetch('detail', ''))
-      end
-    end
-  end
-end

data/lib/jsonapi/consumer/resource/finders_concern.rb

@@ -1,28 +0,0 @@
-module JSONAPI::Consumer::Resource
-  module FindersConcern
-    extend ActiveSupport::Concern
-
-    module ClassMethods
-      def all(options={})
-        _run_request(JSONAPI::Consumer::Query::Find.new(self, options))
-      end
-
-      def find(options)
-        options = {self.primary_key => options} unless options.is_a?(Hash)
-        _run_request(JSONAPI::Consumer::Query::Find.new(self, options))
-      end
-
-      def primary_key
-        @primary_key ||= :id
-      end
-
-      def primary_key=(val)
-        @primary_key = val.to_sym
-      end
-    end
-
-    def primary_key
-      self.class.primary_key
-    end
-  end
-end

data/lib/jsonapi/consumer/resource/object_build_concern.rb

@@ -1,28 +0,0 @@
-module JSONAPI::Consumer::Resource
-  module ObjectBuildConcern
-    extend ActiveSupport::Concern
-
-    included do
-      class_attribute :request_new_object_on_build
-    end
-
-    module ClassMethods
-
-      # If class attribute `request_new_object_on_build`:
-      #
-      # True:
-      #   will send a request to `{path}/new` to get an attributes list
-      #
-      # False:
-      #   acts as an alias for `new`
-      #
-      def build
-        if !!self.request_new_object_on_build
-          _run_request(JSONAPI::Consumer::Query::New.new(self, {})).first
-        else
-          new
-        end
-      end
-    end
-  end
-end

data/lib/jsonapi/consumer/resource/serializer_concern.rb

@@ -1,63 +0,0 @@
-module JSONAPI::Consumer::Resource
-  module SerializerConcern
-    extend ActiveSupport::Concern
-
-    def serializable_hash(options={})
-      @hash = persisted? ? attributes : attributes.except(self.class.primary_key)
-
-      self.each_association do |name, association, options|
-        @hash[:links] ||= {}
-
-        if association.respond_to?(:each) or _association_type(name) == :has_many
-          add_links(name, association, options)
-        else
-          add_link(name, association, options)
-        end
-        @hash.delete(:links) if remove_links?
-      end
-
-      @hash
-    end
-
-    def add_links(name, association, options)
-      @hash[:links][name] ||= []
-      @hash[:links][name] += (association || []).map do |obj|
-        case obj.class
-        when String, Integer
-          obj
-        else
-          obj.to_param
-        end
-      end
-    end
-
-    def add_link(name, association, options)
-      return if association.nil?
-
-      @hash[:links][name] = case association.class
-                            when String, Integer
-                              association
-                            else
-                              association.to_param
-                            end
-    end
-
-    def to_json(options={})
-      serializable_hash(options).to_json
-    end
-
-  private
-
-    def remove_links?
-      if persisted?
-        false
-      else # not persisted, new object
-        if @hash[:links].length == 0 or @hash[:links].values.flatten.empty?
-          true
-        else
-          false
-        end
-      end
-    end
-  end
-end