jsonapi-consumer 0.1.0.pre.1

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

@@ -0,0 +1,203 @@
+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

@@ -0,0 +1,70 @@
+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

@@ -0,0 +1,94 @@
+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
+        @connection ||= begin
+          Faraday.new(url: self.host, ssl: self.ssl) do |conn|
+            conn.request :json
+
+            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

@@ -0,0 +1,28 @@
+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

@@ -0,0 +1,28 @@
+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

@@ -0,0 +1,64 @@
+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] ||= {}
+        # unless options[:embed] == :ids
+          # @hash[:linked] ||= {}
+        # end
+
+        if association.respond_to?(:each)
+          add_links(name, association, options)
+        else
+          add_link(name, association, options)
+        end
+      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
+
+      # unless options[:embed] == :ids
+        # @hash[:linked][name] ||= []
+        # @hash[:linked][name] += association.map { |item| item.attributes(options) }
+      # 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
+
+      # unless options[:embed] == :ids
+        # plural_name = name.to_s.pluralize.to_sym
+
+        # @hash[:linked][plural_name] ||= []
+        # @hash[:linked][plural_name].push association.attributes(options)
+      # end
+    end
+
+    def to_json(options={})
+      serializable_hash(options).to_json
+    end
+
+  end
+end

data/lib/jsonapi/consumer/resource.rb

@@ -0,0 +1,88 @@
+module JSONAPI::Consumer
+  module Resource
+    extend ActiveSupport::Concern
+
+    included do
+      extend ActiveModel::Naming
+
+      attr_reader :errors
+      class_attribute :host
+    end
+
+    include ObjectBuildConcern
+    include AttributesConcern
+    include AssociationConcern
+    include FindersConcern
+    include SerializerConcern
+    include ConnectionConcern
+
+    module ClassMethods
+      def json_key
+        self.name.demodulize.pluralize.underscore
+      end
+
+      def host
+        @host || raise(NotImplementedError, 'host was not set')
+      end
+
+      def path
+        json_key
+      end
+
+      def ssl
+        {}
+      end
+
+    private
+
+      def human_attribute_name(attr, options = {})
+        attr
+      end
+
+      def lookup_ancestors
+        [self]
+      end
+    end
+
+    def initialize(params={})
+      (params || {}).slice(*association_names).each do |key, value|
+        send(:"#{key}=", value)
+      end
+
+      self.attributes = params.except(*association_names) if params
+      @errors = ActiveModel::Errors.new(self)
+      super()
+    end
+
+    # Returns an Enumerable of all key attributes if any is set, regardless
+    # if the object is persisted or not.
+    # Returns nil if there are no key attributes.
+    #
+    # (see ActiveModel::Conversion#to_key)
+    def to_key
+      to_param ? [to_param] : nil
+    end
+
+  private
+
+    def read_attribute_for_validation(attr)
+      read_attribute(attr)
+    end
+
+    def method_missing(method, *args, &block)
+      if respond_to_without_attributes?(method, true)
+        super
+      else
+        if method.to_s =~ /^(.*)=$/
+          set_attribute($1, args.first)
+        elsif has_attribute?(method)
+          read_attribute(method)
+        elsif has_association?(method)
+          read_assocation(method)
+        else
+          super
+        end
+      end
+    end
+  end
+end

data/lib/jsonapi/consumer/version.rb

@@ -0,0 +1,5 @@
+module Jsonapi
+  module Consumer
+    VERSION = "0.1.0.pre.1"
+  end
+end

data/lib/jsonapi/consumer.rb

@@ -0,0 +1,40 @@
+require "jsonapi/consumer/version"
+
+require 'faraday'
+require 'faraday_middleware'
+require 'active_model'
+
+require "active_support/concern"
+require "active_support/core_ext"
+require "active_support/inflector"
+
+module JSONAPI
+  module Consumer
+
+  end
+end
+
+require "jsonapi/consumer/errors"
+
+require "jsonapi/consumer/middleware"
+require "jsonapi/consumer/middleware/parse_json"
+require "jsonapi/consumer/middleware/raise_error"
+require "jsonapi/consumer/middleware/request_timeout"
+
+require "jsonapi/consumer/parser"
+
+require "jsonapi/consumer/query"
+require "jsonapi/consumer/query/base"
+require "jsonapi/consumer/query/create"
+require "jsonapi/consumer/query/delete"
+require "jsonapi/consumer/query/find"
+require "jsonapi/consumer/query/new"
+require "jsonapi/consumer/query/update"
+
+require "jsonapi/consumer/resource/association_concern"
+require "jsonapi/consumer/resource/attributes_concern"
+require "jsonapi/consumer/resource/connection_concern"
+require "jsonapi/consumer/resource/finders_concern"
+require "jsonapi/consumer/resource/object_build_concern"
+require "jsonapi/consumer/resource/serializer_concern"
+require "jsonapi/consumer/resource"

data/spec/fixtures/resources.rb

@@ -0,0 +1,33 @@
+class Base
+  include JSONAPI::Consumer::Resource
+
+  self.host = 'http://localhost:3000/api/'
+end
+
+
+class BasicResource < Base
+
+end
+
+class BuildRequest < Base
+  self.request_new_object_on_build = true
+end
+
+
+# BEGIN - Blog example
+module Blog
+  class Author < Base
+    has_many :posts, class_name: 'Blog::Post'
+  end
+
+  class Post < Base
+    has_one :author, class_name: 'Blog::Author'
+    has_many :comments, class_name: 'Blog::Comment'
+  end
+
+  class Comment < Base
+    # belongs_to :post, class_name: 'Blog::Post'
+    # has_one :author, class_name: 'Blog::Author'
+  end
+end
+# END - Blog example

data/spec/fixtures/responses.rb

@@ -0,0 +1,51 @@
+module Responses
+  def self.sideload
+    {
+      posts: [
+        {
+          links: {
+            comments: [
+              "82083863-bba9-480e-a281-f5d34e7dc0ca",
+              "3b402e8a-7c35-4915-8c72-07ea7779ab76"
+            ]
+          },
+          id: "e6d1b7ac-80d8-40dd-877d-f5bd40feabfb",
+          title: "Friday Post",
+          created_at: "2014-10-19T22:32:52.913Z",
+          updated_at: "2014-10-19T22:32:52.967Z"
+        },
+        {
+          links: {
+            comments: [
+              "9c9ba83b-024c-4d4c-9573-9fd41b95fc14",
+              "27fcf6e8-24b0-41db-94b1-812046a10f54"
+            ]
+          },
+          id: "ea006f14-6d05-4e87-bfe7-ee8ae3358840",
+          title: "Monday Post",
+          created_at: "2014-10-19T22:32:52.933Z",
+          updated_at: "2014-10-19T22:32:52.969Z"
+        }
+      ],
+      linked: {
+        comments: [
+          {
+            id: "82083863-bba9-480e-a281-f5d34e7dc0ca",
+            content: "Awesome article",
+            created_at: "2014-10-19T22:32:52.933Z",
+            updated_at: "2014-10-19T22:32:52.969Z"
+          },
+          {
+            id: "3b402e8a-7c35-4915-8c72-07ea7779ab76",
+            content: "Hated it",
+            created_at: "2014-10-19T22:32:52.933Z",
+            updated_at: "2014-10-19T22:32:52.969Z"
+          }
+        ]
+      },
+      links: {
+        :"posts.comments" => "http://localhost:3000/api/comments/{posts.comments}"
+      }
+    }.with_indifferent_access
+  end
+end