arke 0.0.5 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5b3281422d62185613f9368f145ddbc9192f0669
-  data.tar.gz: 142e2947403ef5a321e75f14d771666ed920925b
+  metadata.gz: a479182f0944a9b4041d8824b676b584e11a0aa8
+  data.tar.gz: 7a792983ca76b4dc5ffd1cc49b0efe5f136be516
 SHA512:
-  metadata.gz: 0543d2459695ed6991d780eebc4dc2d403998015b0271e900e17a64945ff1c421b2734a74736587ef4644367759668e2e85d1821fc35dae6e345c774526a6b87
-  data.tar.gz: cb569d2bff2197ef76825b4e46283f77b8457fa1783b039371d73201966022ad7033e41f2426358faa73e9735d5465a1e593dbc3612d468597bdafc841c8f79b
+  metadata.gz: b355fa1a09f486c2185a354b9884345be3a32ae208925fd6d1a2b6072c52a7c8a16bfe07e445e7b678723107a84c8ab205308d132b03da3e9dd137a9301e1d90
+  data.tar.gz: ce01399d29ba4b73a745a2354155dd2cd7599b2da5f4065e71186dfd043ac80bf86c9801f74eb7e309e2198cf87fd97e715d5fe75677a69c8985f1caf0a78e4f

data/lib/arke/resource.rb

@@ -6,5 +6,12 @@ require 'addressable/template'
 require 'arke/resource/errors'
 require 'arke/resource/fields'
 require 'arke/resource/collection'
-require 'arke/resource/model'
+require 'arke/resource/collections'
+require 'arke/resource/persistence'
+require 'arke/resource/callbacks'
 require 'arke/resource/associations'
+require 'arke/resource/requests'
+require 'arke/resource/url'
+require 'arke/resource/naming'
+require 'arke/resource/finders'
+require 'arke/resource/model'

data/lib/arke/resource/associations.rb

@@ -1,2 +1,79 @@
-require_relative './associations/base'
-require_relative './associations/has_many_association'
+module Arke
+  module Resource
+    module Associations
+      extend ActiveSupport::Concern
+
+      TEMPLATES = {
+        :has_many => "/{parent_resource_name}/{relation_id}/{resource_name}"
+      }
+
+      included do |base|
+        base.class_eval do
+          class_attribute :associations
+
+        end
+
+      end
+
+
+      module ClassMethods
+
+        def belongs_to(name, options={})
+          # self.associations ||= {}
+          # self.associations[name] = {class: infer_class(name, options), options: options}
+          # define_method name do
+          #   if self.persisted?
+          #     instance_variable_set "@#{name}".to_sym, self.class.associations[name][:class].
+          #       new(id: self.send("#{name}_id".to_sym)).reload unless instance_variable_get("@#{name}".to_sym)
+          #     instance_variable_get("@#{name}".to_sym)
+          #   else
+          #     nil
+          #   end
+          # end
+        end
+
+        def has_many(name, options={})
+          build_association(:has_many, name, '/{parent_resource_name}/{relation_id}/{resource_name}?{query*}', self._collection, options)
+        end
+
+        private
+
+        def build_association(type, name, template, klass, options)
+          self.associations ||= {}
+          self.associations[name] = {
+            template:   (options[:template] || template),
+            class_name: infer_class_name(options.delete(:class_name)|| name.to_s.classify)
+          }.merge(options).merge({
+                                   type:           type,
+                                   instance_class: klass
+                                 })
+          define_method name do
+            association = self.class.associations[name]
+            k = association[:class_name].constantize
+            set_instance_variable_if_nil("@#{name}", association[:instance_class].new(k, k.send(:get, {
+              _template:             association[:template],
+              _relation_id:          self.id,
+              _resource_name:        k.resource_name,
+              _parent_resource_name: self.resource_name
+            })))
+
+          end
+        end
+
+        def infer_class_name(class_name)
+          "#{self.name.split('::')[0..-2].unshift('').join('::')}::#{class_name}"
+        end
+
+      end
+
+
+      def set_instance_variable_if_nil(name, value)
+        instance_variable_set(name, value) unless instance_variable_get(name)
+        instance_variable_get(name)
+      end
+
+
+
+    end
+  end
+end

data/lib/arke/resource/callbacks.rb

@@ -0,0 +1,48 @@
+module Arke
+  module Resource
+    module Callbacks
+      extend ActiveSupport::Concern
+
+      included do
+        class_attribute    :after_initialize_callbacks
+
+        alias_method_chain :initialize, :after_initializers
+
+      end
+
+
+      module ClassMethods
+
+        def after_initialize(method=nil, &block)
+          self.after_initializers ||= []
+          if block_given?
+            self.after_initializers << block
+          else
+            self.after_initializers << method
+          end
+        end
+
+      end
+
+      private
+
+      def initialize_with_after_initializers(attributes={})
+        initialize_without_after_initializers attributes
+        self.class.after_initialize_callbacks ||= []
+        self.class.after_initialize_callbacks.each do |callback|
+          execute_callback(callback, attributes)
+        end
+      end
+
+      def execute_callback(callback, *args)
+        if callback.is_a? Symbol
+          self.send(callback, *args)
+        else
+          callback.call(*args)
+        end
+      end
+
+
+    end
+  end
+end

data/lib/arke/resource/collection.rb

@@ -3,10 +3,14 @@ module Arke
     class Collection
       include Enumerable
 
+      attr_reader :parent
+      delegate :delete_all, to: :parent
+
       def initialize(parent, array)
         raise Errors::UnexpectedResponse.
                 new("#all expected to receive an Array from the resource, instead a #{array.class} was received.") unless array.is_a? Array
-        @array = array.collect { |item| parent.new(item) }
+        @parent = parent
+        @array = array.collect { |item| @parent.new(item) }
       end
 
       def each(&block)

data/lib/arke/resource/collections.rb

@@ -0,0 +1,21 @@
+module Arke
+  module Resource
+    module Collections
+      extend ActiveSupport::Concern
+
+      included do
+        class_attribute :_collection
+      end
+
+      module ClassMethods
+
+        def collection(collection=nil)
+          self._collection = collection if collection
+          self._collection || Arke::Resource::Collection
+        end
+
+      end
+
+    end
+  end
+end

data/lib/arke/resource/finders.rb

@@ -0,0 +1,22 @@
+module Arke
+  module Resource
+    module Finders
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+
+        def find(id, params={})
+          body = get({id: id}.merge(params))
+          new(body)
+        end
+
+        def all(params={})
+          body = get(params)
+          self.collection.new(self, body)
+        end
+
+      end
+
+    end
+  end
+end

data/lib/arke/resource/model.rb

@@ -4,227 +4,56 @@ module Arke
 
       extend ActiveSupport::Concern
 
-      included do |base|
-        base.class_eval do
-          include ActiveModel
-          include ActiveModel::Conversion
-          include ActiveModel::Validations
-          include HTTParty
+      included do
+        include ActiveModel
+        include ActiveModel::Conversion
 
-          extend ActiveModel::Naming
+        extend ActiveModel::Naming
 
-          include Resource::Fields
+        include Resource::Fields
+        include Resource::Associations
+        include Resource::Requests
+        include Resource::Collections
+        include Resource::URL
+        include Resource::Persistence
+        include Resource::Callbacks
+        include Resource::Naming
+        include Resource::Finders
 
-          class_attribute :_collection, :_url_template, :_deserializer
+        deserializer  { |body| JSON.parse(body) }
 
-          class << self
+        field :id, type: String
 
-            attr_accessor  :associations, :after_initializers
 
-          end
-
-          collection    Arke::Resource::Collection
-          url_template  DEFAULT_URL_TEMPLATE
-          deserializer  { |body| JSON.parse(body) }
-
-          handle([200, 201]) { |response| JSON.parse(response.body) }
-          
-          handle(404) { raise Errors::NotFound }
-          handle(405) { raise Errors::MethodNotAllowed }
-          handle(422) { raise Errors::UnprocessableEntity }
-          handle(500) { raise Errors::InternalServerError }
-
-          field :id, type: String
-
-
-        end
       end
 
-      # The default template used for generating resource urls.
-      DEFAULT_URL_TEMPLATE     = '/{endpoint}{/id}{?query*}'
-
-      RESPONSE_HANDLERS        = {}
-
       module ClassMethods
 
-        def find(id)
-          body = make_request(:get, {}, id: id)
-          new(body)
-        end
-
         def all(params={})
           body = make_request(:get, {}, params)
-          self._collection.new(self, body)
-        end
-
-        def has_many(name, options={})
-          self.associations ||= {}
-          self.associations[name] = {
-            association: Associations::HasManyAssociation,
-            options:     options
-          }
-        end
-
-        def after_initialize(&block)
-          @after_initializers ||= []
-          @after_initializers << block
-        end
-
-        def handle(code, &block)
-          raise Arke::Errors::MissingHandlerBlock unless block_given?
-          case code
-            when String, Integer, Fixnum
-              response_handlers[code.to_i] = block
-              return true
-            when Range, Array
-              code.to_a.each do |c|
-                response_handlers[c.to_i] = block
-              end
-              return true
-            else
-              raise Errors::InvalidHandler.
-                      new("#{code.class.name} is an invalid class, please user an Integer, Fixnum, String, Range or Array")
-          end
-        end
-
-        def response_handlers
-          RESPONSE_HANDLERS
-        end
-
-        def collection(collection)
-          self._collection = collection if collection
+          self.collection.new(self, body)
         end
 
-        # Gets or sets the url template for the resource. The url template is a
-        # {https://github.com/sporkmonger/addressable Addressable} template and defaults to {DEFAULT_URL_TEMPLATE}.
-        # If a parameter is passed to this method it will set the url template to the passed parameter, otherwise
-        # it will just return the URL template.
-        #
-        # @param [String] template the url template to set, if left nil, the method will simply return the current
-        # url template
-        #
-        # @return [Addressable::Template] the url template. If none has been set, it references {DEFAULT_URL_TEMPLATE}
-        def url_template(template)
-          self._url_template  = Addressable::Template.new(template)
-        end
-
-        # Gets or sets the resource host.
-        #
-        # @param [String] host the resource host. if left nil, the method will simply return the current resource host
-        #
-        # @return [String] the current resource host
-        def host(host=nil)
-          @host = host if host
-          @host
-        end
-
-        # Gets the resource url. This compiles the url template using the passed options and returns the resulting
-        # string.
-        #
-        # @param [Hash] options the url options to pass to the template. By default the template looks for a an id and a
-        # query.
-        #
-        # @return [String] the full resource url
-        def url(options={})
-          template = options[:template] ? Addressable::Template.new(options.delete(:template)) : nil || _url_template
-          host + template.expand(options.merge(endpoint: endpoint)).to_s
-        end
-
-        # Gets or sets the device endpoint. By default the endpoint uses {#resource_name} if an endpoint has not been
-        # provided.
-        #
-        # @param [String] the service endpoint. if left nil it will simply return the existing endpoint
-        #
-        # @return [String] the service endpoint
-        def endpoint(endpoint=nil)
-          @endpoint = endpoint if endpoint
-          @endpoint ||= resource_name
-        end
-
-        def deserializer(&block)
-          self._deserializer = block if block_given?
-        end
-
-        def deserialize(body)
-          begin
-            self._deserializer.call(body)
-          rescue => e
-            raise Errors::DeserializationError.new(e)
-          end
-        end
-
-        def table_name
-          self.name.split('::')[-1].tableize
-        end
-
-        private
-
-        def resource_name
-          @resource_name ||= self.name.tableize
-        end
-
-        def make_request(method, body={}, params={})
-          begin
-            response = send(method, url(params), body)
-          rescue Errno::ECONNREFUSED
-            raise Errors::ConnectionRefused.new(host)
-          end
-          handle_response(response)
-        end
-
-        def handle_response(response)
-          response_handlers[response.code.to_i].call(response)
+        def find(id, params={})
+          body = make_request(:get, {}, {id: id}.merge(params))
+          new(body)
         end
 
       end
 
       def initialize(attributes={})
         @_attributes = attributes
-        self.class.after_initializers.each { |ai| ai.call } if self.class.after_initializers
       end
 
       def to_param
         self.id
       end
 
-      def persisted?
-        !self.id.empty?
-      end
-
-      def save
-        unless self.persisted?
-          return make_request(:post, @_attributes)  && true
-        end
-        false
-      end
-
-
       def inspect
         id = "id: ''#{self.id}'" if try(:id)
         "#<#{self.class.name}:0x%08x>" % (object_id * 2)
       end
 
-      private
-
-      def make_request(method, body={}, params={})
-        begin
-          response = self.class.send(method, self.class.url(params.empty? ? body : params), {body: body})
-        rescue Errno::ECONNREFUSED
-          raise Errors::ConnectionRefused.new(host)
-        end
-        handle_response(response)
-      end
-
-      def handle_response(response)
-        self.class.response_handlers[response.code.to_i].call(response, self)
-      end
-
-
-      def method_missing(meth, *args)
-        return self.class.associations[meth.to_sym][:association].
-          new(self, meth.to_sym, self.class.associations[meth.to_sym][:options]) if self.class.associations && self.class.associations[meth.to_sym]
-        super
-      end
     end
   end
 end

data/lib/arke/resource/naming.rb

@@ -0,0 +1,24 @@
+module Arke
+  module Resource
+    module Naming
+      extend ActiveSupport::Concern
+
+      included do
+        delegate :singular_name, :resource_name, to: :class
+      end
+
+      module ClassMethods
+
+        def resource_name
+          self.name.tableize.split('/')[-1]
+        end
+
+
+        def singular_name
+          resource_name.singularize
+        end
+
+      end
+    end
+  end
+end

data/lib/arke/resource/persistence.rb

@@ -0,0 +1,88 @@
+module Arke
+  module Resource
+    module Persistence
+      extend ActiveSupport::Concern
+
+      module Callbacks
+        extend ActiveSupport::Concern
+
+        included do
+          class_attribute :after_destroy_callbacks
+
+          alias_method_chain :destroy, :after_destroy
+        end
+
+
+        module ClassMethods
+
+          def after_destroy(method=nil, &block)
+            self.after_destroy_callbacks ||= []
+            self.after_destroy_callbacks << method if method
+            self.after_destroy_callbacks << block  if block_given?
+          end
+
+        end
+
+      end
+
+      included do
+        include Callbacks
+        include ActiveModel::Validations
+
+      end
+
+      module ClassMethods
+
+        def destroy(id)
+          new(id).destroy
+        end
+
+        def destroy_all(params={})
+          puts 'making delete request'
+          make_request(:delete, params)
+        end
+
+      end
+
+      def destroy
+        delete @_attributes
+      end
+
+      def save
+        unless self.persisted?
+          return true if (@_attributes = post(@_attributes))
+        else
+          return update(@_attributes)
+        end
+        false
+      end
+
+      def update(attributes)
+        @_attributes = attributes
+        return true if (@_attributes = put(@_attributes))
+        false
+      end
+
+      def reload
+        @_attributes = self.get(@_attributes.clone)
+        self
+      end
+
+      def persisted?
+        !self.id.empty?
+      end
+
+      private
+
+      def destroy_with_after_destroy
+        destroy_without_after_destroy
+        self.after_destroy_callbacks ||= []
+        self.after_destroy_callbacks.each do |callback|
+          execute_callback(callback)
+        end
+      end
+
+
+    end
+  end
+end

data/lib/arke/resource/requests.rb

@@ -0,0 +1,77 @@
+module Arke
+  module Resource
+    module Requests
+      extend ActiveSupport::Concern
+
+      included do
+
+        class_attribute :response_handlers
+
+        delegate :url, :post, :get, :delete, :put, :handle_response, to: :class
+
+        handle([200, 201, 204]) { |response| deserialize(response.body) }
+
+        handle(404) { raise Errors::NotFound }
+        handle(405) { raise Errors::MethodNotAllowed }
+        handle(422) { raise Errors::UnprocessableEntity }
+        handle(500) { raise Errors::InternalServerError }
+
+      end
+
+      module ClassMethods
+
+        def deserializer(&block)
+          @deserializer = block
+        end
+
+        def delete(params={})
+          HTTParty.delete url(params)
+        end
+
+        def post(body={}, params={})
+          handle_response(HTTParty.post(url(params.empty? ? body : params), body: body))
+        end
+
+        def get(params={})
+          handle_response(HTTParty.get url(params))
+        end
+
+        def put(body={}, params={})
+          handle_response(HTTParty.put(url(params.empty? ? body : params), body: body))
+        end
+
+        def handle_response(response)
+          self.response_handlers[response.code.to_i].call(response)
+        end
+
+        def deserialize(body)
+          begin
+            @deserializer.call(body)
+          rescue => e
+            raise Errors::DeserializationError.new(e)
+          end
+        end
+
+        def handle(code, &block)
+          self.response_handlers ||= {}
+          raise Arke::Errors::MissingHandlerBlock unless block_given?
+          case code
+            when String, Integer, Fixnum
+              self.response_handlers[code.to_i] = block
+              return true
+            when Range, Array
+              code.to_a.each do |c|
+                self.response_handlers[c.to_i] = block
+              end
+              return true
+            else
+              raise Errors::InvalidHandler.
+                new("#{code.class.name} is an invalid class, please user an Integer, Fixnum, String, Range or Array")
+          end
+        end
+
+      end
+
+    end
+  end
+end

data/lib/arke/resource/url.rb

@@ -0,0 +1,63 @@
+module Arke
+  module Resource
+    module URL
+      extend ActiveSupport::Concern
+
+      # The default template used for generating resource urls.
+      DEFAULT_URL_TEMPLATE     = '/{endpoint}{/id}{?query*}'
+
+      module ClassMethods
+
+        # Gets or sets the url template for the resource. The url template is a
+        # {https://github.com/sporkmonger/addressable Addressable} template and defaults to {DEFAULT_URL_TEMPLATE}.
+        # If a parameter is passed to this method it will set the url template to the passed parameter, otherwise
+        # it will just return the URL template.
+        #
+        # @param [String] template the url template to set, if left nil, the method will simply return the current
+        # url template
+        #
+        # @return [Addressable::Template] the url template. If none has been set, it references {DEFAULT_URL_TEMPLATE}
+        def url_template(template=nil)
+          @url_template = Addressable::Template.new(template) if template
+          @url_template || Addressable::Template.new(DEFAULT_URL_TEMPLATE)
+        end
+
+        # Gets or sets the resource host.
+        #
+        # @param [String] host the resource host. if left nil, the method will simply return the current resource host
+        #
+        # @return [String] the current resource host
+        def host(host=nil)
+          @host = host if host
+          @host
+        end
+
+        # Gets the resource url. This compiles the url template using the passed options and returns the resulting
+        # string.
+        #
+        # @param [Hash] options the url options to pass to the template. By default the template looks for a an id and a
+        # query.
+        #
+        # @return [String] the full resource url
+        def url(options={})
+          template = options[:_template] ? Addressable::Template.new(options.delete(:_template)) : nil ||self.url_template
+          association_options = {parent_resource_name: options.delete(:_parent_resource_name), relation_id: options.delete(:_relation_id), resource_name: options.delete(:_resource_name)}
+          host + template.expand(association_options.merge(options.merge(endpoint: endpoint))).to_s
+        end
+
+        # Gets or sets the device endpoint. By default the endpoint uses {#resource_name} if an endpoint has not been
+        # provided.
+        #
+        # @param [String] the service endpoint. if left nil it will simply return the existing endpoint
+        #
+        # @return [String] the service endpoint
+        def endpoint(endpoint=nil)
+          @endpoint = endpoint if endpoint
+          @endpoint ||= resource_name
+        end
+
+      end
+
+    end
+  end
+end

data/lib/arke/version.rb

@@ -1,3 +1,3 @@
 module Arke
-  VERSION = '0.0.5'
-end
+  VERSION = '0.1.0'
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: arke
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 0.1.0
 platform: ruby
 authors:
 - Jarod Reid
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-05-19 00:00:00.000000000 Z
+date: 2014-06-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: httparty
@@ -156,12 +156,17 @@ files:
 - lib/arke/mime_types.rb
 - lib/arke/resource.rb
 - lib/arke/resource/associations.rb
-- lib/arke/resource/associations/base.rb
-- lib/arke/resource/associations/has_many_association.rb
+- lib/arke/resource/callbacks.rb
 - lib/arke/resource/collection.rb
+- lib/arke/resource/collections.rb
 - lib/arke/resource/errors.rb
 - lib/arke/resource/fields.rb
+- lib/arke/resource/finders.rb
 - lib/arke/resource/model.rb
+- lib/arke/resource/naming.rb
+- lib/arke/resource/persistence.rb
+- lib/arke/resource/requests.rb
+- lib/arke/resource/url.rb
 - lib/arke/version.rb
 - spec/resource_spec.rb
 homepage: ''

data/lib/arke/resource/associations/base.rb

@@ -1,27 +0,0 @@
-module Arke
-  module Resource
-    module Associations
-      class Base
-
-        attr_reader :name, :options
-
-        def initialize(parent, name, options={})
-          @parent  = parent
-          @name    = name
-          @options = options
-        end
-
-        def target
-          klass.constantize
-        end
-
-        private
-
-        def klass
-          "#{@parent.class.name.split('::')[0..-2].join('::')}::#{@options[:class_name] || name.to_s.classify}"
-        end
-
-      end
-    end
-  end
-end

data/lib/arke/resource/associations/has_many_association.rb

@@ -1,27 +0,0 @@
-module Arke
-  module Resource
-    module Associations
-
-      class HasManyAssociation < Base
-        include Enumerable
-        delegate :find, to: :target
-
-        def all(params={})
-          target.all(params.merge({
-            template: "/#{@parent.class.table_name}/#{@parent.send(options[:foreign_key] || :id)}/{endpoint}"
-                                           }))
-        end
-
-        def each(&block)
-          self.all.each &block
-        end
-
-        def count(params={})
-          all(params).count
-        end
-
-      end
-
-    end
-  end
-end