cyrax 0.5.15 → 0.6.0.beta

checksums.yaml

@@ -1,7 +1,15 @@
 ---
-SHA256:
-  metadata.gz: 9d1b6765085639d4473934d340f48c3dd72d519e3837b5af945dbdcd8c74ae89
-  data.tar.gz: 6239d1cf32f003eb211d3d3bafdb8fcbf441abaaafbd4140367c535664af518d
-SHA512:
-  metadata.gz: 59dc7b1b3207e35a7c5c27aff5e84fec4fdcbc35d0521bb73923c33109156c6c57a346806924cdcff7d71e2a886cd81e94cc260a017d515b52a4c74c38828d8d
-  data.tar.gz: '097ccfc3c5d7ba33098dd565da4c04813f082e5da11dff300c55e7908125507c64c1218cb3db35d944e0e8f79bc9c92bf5b777cef6a82f48eecd545d6b8a3187'
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    MzJlYTg3MDkzYjVjMzJhODVmODAwNTllMzVlM2Q2Y2Q4MDQ2NjUyNQ==
+  data.tar.gz: !binary |-
+    ODdlMjE1MGIxMzRkZTc1MmExMTFkZWUyYThlZGViM2RiNjEwYjZmZQ==
+!binary "U0hBNTEy":
+  metadata.gz: !binary |-
+    YzE2M2IzNjRmZTAzOGY2MjNlMmJhYzg0NzM2YjFhYjFhZTljNTZlYTMyMTE5
+    YjE0OGQ2ZjE3Y2IzYWIxMTg2MTA2MjFmMzdlYjhhNGFkN2IxOGQ1YzFlNWVi
+    YmY1ODAyM2FkNjdlODcxYTNmYjk3NjcyOGRhYWQxYjdlYjZlMjc=
+  data.tar.gz: !binary |-
+    NWM1NzBjNDEwM2E2NDc4ZGEyNmZhNGY3MTRiN2YyNThmYzQ3NzU1OWY5Mjg3
+    NzE2ZTEyZWEyMDAyNWU3NDE4MzRhYjNkOTI2NDRiMDFjZTQxNjBkMjU4NmQy
+    ZjA4ZWMzZmUwMjQ4MjJiNzgxYTY2NmZkNDYzMjhjNThkODcyNjQ=

data/lib/cyrax/decorator.rb

@@ -1,6 +1,4 @@
 require 'active_model'
-# require 'active_model/serializers/xml'
-
 class Cyrax::Decorator < Cyrax::Wrapper
   include ActiveModel::Serialization
   include ActiveModel::Serializers::JSON
@@ -23,28 +21,11 @@ class Cyrax::Decorator < Cyrax::Wrapper
     resource.send(method, *args, &block)
   end
 
-  def respond_to?(method_sym, include_private = false)
-    super || resource.respond_to?(method_sym, include_private)
-  end
-
   class << self
     alias_method :decorate, :new
 
     def decorate_collection(resource)
       Cyrax::Presenters::DecoratedCollection.decorate(resource, decorator: self)
     end
-
-    def respond_to?(method_sym, include_private = false)
-      super || @@decorated_class.respond_to?(method_sym, include_private)
-    end
-
-    def method_missing(method, *args, &block)
-      return super unless @@decorated_class.respond_to?(method)
-      @@decorated_class.send(method, *args, &block)
-    end
-
-    def decorated_class(klass)
-      @@decorated_class = klass
-    end
   end
 end

data/lib/cyrax/extensions/has_decorator.rb

@@ -3,24 +3,24 @@ module Cyrax::Extensions
     extend ActiveSupport::Concern
 
     included do
-      class_attribute :decorator_class_name
-    end
-
-    def decorator_class_name
-      options[:decorator] || self.class.decorator_class_name
+      class_attribute :_decorator_class
     end
 
     def decorable?
-      !decorator_class_name.nil?
+      !decorator_class.nil?
     end
 
     def decorator_class
-      decorator_class_name.to_s.classify.constantize
+      options[:decorator] || self.class._decorator_class
     end
 
     module ClassMethods
-      def decorator(name)
-        self.decorator_class_name = name ? name.to_s : nil
+      def decorator(klass)
+        if klass.is_a?(String)
+          ActiveSupport::Deprecation.warn "sending String in #decorator method is deprecated. send Class instead"
+          klass = klass.constantize
+        end
+        self._decorator_class = klass
       end
     end
   end

data/lib/cyrax/extensions/has_repository.rb

@@ -0,0 +1,43 @@
+module Cyrax::Extensions
+  module HasRepository
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :_repository_class
+      class_attribute :_repository_options
+    end
+
+    def repository_class
+      options[:repository] || self.class._repository_class || Cyrax::Repository
+    end
+
+    def repository
+      options = (self.class._repository_options || {}).merge(
+        as: accessor, resource_class: resource_class, params: params
+      )
+      repository_class.new(options)
+    end
+
+    module ClassMethods
+      def repository(name = nil, &block)
+        if name.is_a?(Symbol)
+          klass, finder_name = nil, name
+        elsif name.is_a?(String)
+          ActiveSupport::Deprecation.warn "sending String in #decorator method is deprecated. send Class instead"
+          klass, finder_name = name.constantize, nil
+        elsif name.present?
+          klass, finder_name = name, nil
+        end
+
+        if klass.present?
+          self._repository_class = klass
+        end
+        if block_given?
+          self._repository_options ||= {}
+          self._repository_options[:finder_blocks] = {}
+          self._repository_options[:finder_blocks][finder_name || :scope] = block
+        end
+      end
+    end
+  end
+end

data/lib/cyrax/extensions/has_resource.rb

@@ -4,39 +4,26 @@ module Cyrax::Extensions
     extend ActiveSupport::Concern
 
     included do
-      class_attribute :resource_name
-      class_attribute :resource_class_name
-      class_attribute :collection_name
+      class_attribute :_resource_name
+      class_attribute :_collection_name
+      class_attribute :_resource_class
     end
 
-    # Returns the resource class as a constant - e.g. Product
-    def resource_class
-      if self.resource_class_name
-        self.resource_class_name.constantize
-      else
-        resource_name.classify.constantize
-      end
+    def resource_name
+      self.class._resource_name
     end
 
-    # Returns the resource class - e.g. Product
-    # If you want your resource to return something interesting, you should override this in your resource by defining the method and returning your own scope
-    #
-    # @example Overriding resource_scope
-    #   class Products::UserResource < Products::BaseResource
-    #     def resource_scope
-    #       accessor.products
-    #     end
-    #   end
-    def resource_scope
-      resource_class
+    def collection_name
+      self.class._collection_name
     end
 
-    def resource_attributes
-      filter_attributes(dirty_resource_attributes)
+    # Returns the resource class as a constant - e.g. Product
+    def resource_class
+      self.class._resource_class || resource_name.classify.constantize
     end
 
-    def response_name
-      resource_name
+    def resource_attributes
+      filter_attributes(dirty_resource_attributes)
     end
 
     module ClassMethods
@@ -64,13 +51,21 @@ module Cyrax::Extensions
       # @param name [Symbol] The name of the resource
       # @param options Hash [Hash] Options
       def resource(name, options = {})
-        self.resource_name = name.to_s
-        self.resource_class_name = options[:class_name]
-        self.collection_name = name.to_s.pluralize
+        if options[:class_name].present?
+          ActiveSupport::Deprecation.warn "sending :class_name in #resource method is deprecated. send :class instead"
+          options[:class] = options[:class_name].to_s.constantize
+        end
+        self._resource_name = name.to_s
+        self._resource_class = options[:class]
+        self._collection_name = name.to_s.pluralize
       end
     end
 
     private
+      def response_name
+        resource_name
+      end
+
       def dirty_resource_attributes
         if Cyrax.strong_parameters
           params.require(resource_name)
@@ -79,10 +74,6 @@ module Cyrax::Extensions
         end
       end
 
-      def default_resource_attributes
-        {}
-      end
-
       def filter_attributes(attributes)
         if Cyrax.strong_parameters
           attributes.permit(self.class.accessible_attributes)

data/lib/cyrax/extensions/has_response.rb

@@ -82,7 +82,6 @@ module Cyrax::Extensions
     # @param options [Hash] Options
     def respond_with(result, options = {})
       options[:as] ||= accessor
-      options[:assignments] =  @_assignments
       name = options[:name] || response_name
       result = result.result.to_model if result.is_a?(Cyrax::Response)
       if sync_errors_with?(result)

data/lib/cyrax/extensions/has_serializer.rb

@@ -3,24 +3,24 @@ module Cyrax::Extensions
     extend ActiveSupport::Concern
 
     included do
-      class_attribute :serializer_class_name
-    end
-
-    def serializer_class_name
-      options[:serializer] || self.class.serializer_class_name
+      class_attribute :_serializer_class
     end
 
     def serializable?
-      !serializer_class_name.nil?
+      !serializer_class.nil?
     end
 
     def serializer_class
-      serializer_class_name.to_s.classify.constantize
+      options[:serializer] || self.class._serializer_class
     end
 
     module ClassMethods
-      def serializer(name)
-        self.serializer_class_name = name ? name.to_s : nil
+      def serializer(klass)
+        if klass.is_a?(String)
+          ActiveSupport::Deprecation.warn "sending String in #serializer method is deprecated. send Class instead"
+          klass = klass.constantize
+        end
+        self._serializer_class = klass
       end
     end
   end

data/lib/cyrax/extensions/has_service.rb

@@ -1,17 +1,15 @@
 module Cyrax::Extensions
   module HasService
-    VALIDATION_ERROR_STATUS = 422
     extend ActiveSupport::Concern
 
     # Builds and returns a collection response for Rails
     # @return [Cyrax::Response] response
     def read_all(&block)
       authorize_resource!(:read_all, resource_class)
-      collection = build_collection
+      collection = repository.find_all
       block.call(collection) if block_given?
       respond_with collection, name: collection_name, present: :collection
     end
-    # Overrides collection with read_all
     alias_method :read_all!, :read_all
 
     # Builds a new resource without saving to DB
@@ -19,7 +17,7 @@ module Cyrax::Extensions
     # Used for :new action in controller
     # @return [Cyrax::Response] response
     def build(&block)
-      resource = build_resource(nil)
+      resource = repository.build(nil)
       authorize_resource!(:build, resource)
       block.call(resource) if block_given?
       respond_with resource
@@ -30,14 +28,12 @@ module Cyrax::Extensions
     # Used for :create action in controller
     # @return [Cyrax::Response] response
     def create(custom_attributes = nil, &block)
-      resource = build_resource(nil, custom_attributes||resource_attributes)
+      resource = repository.build(nil, custom_attributes||resource_attributes)
       authorize_resource!(:create, resource)
       transaction do
-        if save_resource(resource)
+        if repository.save(resource)
           set_message(:created)
           block.call(resource) if block_given?
-        elsif Cyrax.automatically_set_invalid_status
-          set_status VALIDATION_ERROR_STATUS
         end
       end
       respond_with(resource)
@@ -48,7 +44,7 @@ module Cyrax::Extensions
     # Used for :show action in controller
     # @return [Cyrax::Response] response
     def read(&block)
-      resource = find_resource(resource_params_id)
+      resource = repository.find(resource_params_id)
       block.call(resource) if block_given?
       respond_with resource
     end
@@ -60,14 +56,12 @@ module Cyrax::Extensions
     # Used for :update action in controller
     # @return [Cyrax::Response] response
     def update(custom_attributes = nil, &block)
-      resource = build_resource(resource_params_id, custom_attributes||resource_attributes)
+      resource = repository.build(resource_params_id, custom_attributes||resource_attributes)
       authorize_resource!(:update, resource)
       transaction do
-        if save_resource(resource)
+        if repository.save(resource)
           set_message(:updated)
           block.call(resource) if block_given?
-        elsif Cyrax.automatically_set_invalid_status
-          set_status VALIDATION_ERROR_STATUS
         end
       end
       respond_with(resource)
@@ -78,50 +72,16 @@ module Cyrax::Extensions
     # Used for :destroy action in controller
     # @return [Cyrax::Response] response
     def destroy(&block)
-      resource = find_resource(resource_params_id)
+      resource = repository.find(resource_params_id)
       authorize_resource!(:destroy, resource)
       transaction do
-        delete_resource(resource)
+        repository.delete(resource)
         block.call(resource) if block_given?
       end
       respond_with(resource)
     end
     alias_method :destroy!, :destroy
 
-    # Finds and returns a single item from the DB
-    # @param id [int] ID of item
-    # @return [object] The object
-    def find_resource(id)
-      resource_scope.find(id)
-    end
-
-    # Instantiates the resource
-    # @param id [int] ID or nil if you want a new object
-    # @param attributes [hash] Attributes you want to add to the resource
-    # @return [object] The object
-    def build_resource(id, attributes = {})
-      if id.present?
-        resource = find_resource(id)
-        resource.attributes = attributes
-        resource
-      else
-        resource_scope.new(default_resource_attributes.merge(attributes))
-      end
-    end
-
-    # Saves a resource
-    # @param resource [object] The resource to save
-    def save_resource(resource)
-      resource.save
-    end
-
-    # Remove a resource
-    # Calls destroy method on resource
-    # @param resource [object] The resource to destroy
-    def delete_resource(resource)
-      resource.destroy
-    end
-
     # Authorize a resource
     # Should be called on each service method and should be implemented on each resource.
     # Implementation may raise an exception which may be handled by controller.
@@ -131,16 +91,6 @@ module Cyrax::Extensions
       # raise AuthorizationError
     end
 
-    # Returns a collection of the resource we are calling.
-    #
-    # If you want your resource to return something interesting, you should override the resource_scope method.
-    # Otherwise by default it will return the constantized model name and it will call .all on it during presentation.
-    #
-    # @return [type] The collection
-    def build_collection
-      resource_scope
-    end
-
     def transaction(&block)
       if defined?(ActiveRecord::Base)
         ActiveRecord::Base.transaction do
@@ -154,5 +104,22 @@ module Cyrax::Extensions
     def resource_params_id
       params[:id]
     end
+
+    # DEPRECATED METHODS
+    def resource_scope
+      respository.scope
+    end
+    def build_collection
+      respository.find_all
+    end
+    def find_resource(id)
+      respository.find(id)
+    end
+    def save_resource(resource)
+      respository.save(resource)
+    end
+    def delete_resource(resource)
+      respository.delete(resource)
+    end
   end
 end

data/lib/cyrax/helpers/controller.rb

@@ -15,7 +15,7 @@ module Cyrax::ControllerHelper
       result = result.to_model if result.respond_to?(:to_model)
 
       respond_to do |format|
-        format.html do
+        format.any do
           # set flashes
           if response.success?
             flash[:notice] = options[:notice] if options[:notice].present?
@@ -27,11 +27,7 @@ module Cyrax::ControllerHelper
           super(result, options, &block)
         end
         format.json do
-          render json: MultiJson.dump(response.as_json), status: options[:status] || 200
-        end
-        format.any do
-          set_resource_from(response)
-          super(response, options, &block)
+          render json: response.as_json
         end
       end
     else

data/lib/cyrax/presenter.rb

@@ -20,7 +20,7 @@ class Cyrax::Presenter < Cyrax::Wrapper
     if options[:present] == :collection
       Cyrax::Presenters::DecoratedCollection.new(resource, options)
     else
-      options[:decorator].decorate(resource, options)
+      options[:decorator].decorate(resource)
     end
   end
 

data/lib/cyrax/repository.rb

@@ -0,0 +1,102 @@
+class Cyrax::Repository
+  include HasActiveLogger::Mixin
+  attr_accessor :options
+  attr_accessor :accessor
+  attr_accessor :params
+  attr_accessor :resource_class
+  attr_accessor :finder_blocks
+
+  def initialize(options = {})
+    @options = options
+    @accessor = options[:as]
+    @params = options[:params]
+    @resource_class = options[:resource_class]
+    @finder_blocks = options[:finder_blocks] || {}
+  end
+
+  # Returns the resource class - e.g. Product by default.
+  # If you want your repository to scope with something interesting, 
+  # you should override this in your repository by defining the method and returning your own scope
+  #
+  # @example Overriding scope
+  #   class Products::Repository < Cyrax::Repository
+  #     def scope
+  #       accessor.products
+  #     end
+  #   end
+  def scope
+    if block = finder_blocks[:scope]
+      instance_exec(&block)
+    else
+      resource_class
+    end
+  end
+
+  # Instantiates the resource
+  # @param id [int] ID or nil if you want a new object
+  # @param attributes [hash] Attributes you want to add to the resource
+  # @return [object] The object
+  def build(id, attributes = {})
+    if block = finder_blocks[:build]
+      instance_exec(id, attributes, &block)
+    else
+      if id.present?
+        resource = find(id)
+        resource.attributes = attributes
+        resource
+      else
+        scope.new(default_attributes.merge(attributes))
+      end
+    end
+  end
+
+  # Finds and returns a multiple items within the scope from the DB
+  # @return [Array] Array of objects
+  def find_all
+    if block = finder_blocks[:find_all]
+      instance_exec(&block)
+    else
+      scope.is_a?(ActiveRecord::Relation) ? scope.load : scope.all
+    end
+  end
+
+  # Finds and returns a single item from the DB
+  # @param id [int] ID of item
+  # @return [object] The object
+  def find(id)
+    if block = finder_blocks[:find]
+      instance_exec(id, &block)
+    else
+      scope.find(id)
+    end
+  end
+
+  # Saves a resource
+  # @param resource [object] The resource to save
+  def save(resource)
+    if block = finder_blocks[:save]
+      instance_exec(resource, &block)
+    else
+      resource.save
+    end
+  end
+
+  # Removes a resource
+  # Calls destroy method on resource
+  # @param resource [object] The resource to destroy
+  def delete(resource)
+    if block = finder_blocks[:delete]
+      instance_exec(resource, &block)
+    else
+      resource.destroy
+    end
+  end
+
+  def default_attributes
+    if block = finder_blocks[:default_attributes]
+      instance_exec(&block)
+    else
+      {}
+    end
+  end
+end

data/lib/cyrax/resource.rb

@@ -1,5 +1,6 @@
 class Cyrax::Resource < Cyrax::Base
   include Cyrax::Extensions::HasResource
+  include Cyrax::Extensions::HasRepository
   include Cyrax::Extensions::HasService
   include Cyrax::Extensions::HasDecorator
   include Cyrax::Extensions::HasSerializer

data/lib/cyrax/response.rb

@@ -55,19 +55,14 @@ class Cyrax::Response
     if failure?
       {errors: @errors}
     elsif options[:serializer]
-      options[:serializer].new(result, options).serialize
+      options[:serializer].new(result, as: accessor).serialize
     else
       result.as_json
     end
   end
 
   def method_missing(method, *args, &block)
-    if method.to_s == resource_name
-      result
-    elsif assignments.has_key?(method)
-      assignments[method]
-    else
-      super
-    end
+    super unless assignments.has_key?(method)
+    assignments[method]
   end
 end

data/lib/cyrax/serializer.rb

@@ -1,45 +1,18 @@
 class Cyrax::Serializer < Cyrax::Wrapper
   def serialize
     options[:serializer] = self
-
-    if block = self.class.total_count_block
-      serialize_wrapped(options, &block)
-    else
-      serialize_simple(options)
-    end
-  end
-
-  def serialize_simple(options = {})
     self.class.scope.serialize(resource, options)
   end
 
-  def serialize_wrapped(options = {}, &counter_block)
-    total_count = self.instance_eval(&counter_block)
-    data = self.class.scope.serialize(resource, options)
-    {total_count: total_count, data: data}
-  end
-
   class << self
     def scope
       @scope ||= Cyrax::Serializers::Scope.new()
     end
 
-    def total_count(&block)
-      @total_count_block = block
-    end
-
-    def total_count_block
-      @total_count_block
-    end
-
     def namespace(name, &block)
       scope.namespace(name, &block)
     end
 
-    def assigned(name, &block)
-      scope.assigned(name, &block)
-    end
-
     def relation(name, &block)
       scope.relation(name, &block)
     end