cyrax 0.5.13 → 0.6.0.beta

data/lib/cyrax/helpers/controller.rb

@@ -27,7 +27,7 @@ module Cyrax::ControllerHelper
           super(result, options, &block)
         end
         format.json do
-          render json: MultiJson.dump(response.as_json), status: options[:status] || 200
+          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

data/lib/cyrax/serializers/scope.rb

@@ -5,7 +5,6 @@ module Cyrax::Serializers
       @dynamic_attrs = {}
       @relation_attrs = {}
       @namespace_attrs = {}
-      @assigned_attrs = {}
       @default_attributes = false
       instance_eval(&block) if block_given?
     end
@@ -14,10 +13,6 @@ module Cyrax::Serializers
       @namespace_attrs[name] = self.class.new(&block)
     end
 
-    def assigned(name, &block)
-      @assigned_attrs[name] = self.class.new(&block)
-    end
-
     def relation(attribute, &block)
       if block_given?
         @relation_attrs[attribute] = self.class.new(&block)
@@ -25,8 +20,6 @@ module Cyrax::Serializers
         @attrs[attribute] = attribute
       end
     end
-    alias_method :has_many, :relation
-    alias_method :has_one, :relation
 
     def default_attributes
       @default_attributes = true
@@ -47,9 +40,7 @@ module Cyrax::Serializers
     end
 
     def serialize(resource, options = {})
-      if resource.nil?
-        nil
-      elsif resource.respond_to?(:to_a)
+      if resource.respond_to?(:to_a)
         resource.to_a.map{ |r| serialize_one(r, options) }
       else
         serialize_one(resource, options)
@@ -62,19 +53,14 @@ module Cyrax::Serializers
         result = resource.attributes rescue {}
       end
       @dynamic_attrs.map do |attribute, block|
-        result[attribute] = options[:serializer].instance_exec(resource, options, &block)
+        result[attribute] = options[:serializer].instance_exec(resource, &block)
       end
       @relation_attrs.map do |attribute, scope|
         value = resource.send(attribute)
-        result[attribute] = scope.serialize(value, options)
-      end
-      @assigned_attrs.map do |attribute, scope|
-        assignments = options[:assignments] || {}
-        value = assignments[attribute]
-        result[attribute] = scope.serialize(value, options)
+        result[attribute] = scope.serialize(value)
       end
       @namespace_attrs.map do |attribute, scope|
-        result[attribute] = scope.serialize(resource, options)
+        result[attribute] = scope.serialize(resource)
       end
       @attrs.map do |attribute, options|
         result[attribute] = resource.send(attribute)

data/lib/cyrax/version.rb

@@ -1,3 +1,3 @@
 module Cyrax
-  VERSION = "0.5.13"
+  VERSION = "0.6.0.beta"
 end

data/spec/cyrax/extensions/has_decorator_spec.rb

@@ -20,26 +20,26 @@ module Cyrax
     subject { BaseWithDecorator.new }
 
     describe 'class attributes' do
-      its(:class) { should respond_to(:decorator_class_name) }
+      its(:class) { should respond_to(:_decorator_class) }
     end
 
     describe 'class methods' do
       describe '#decorator' do
-        before { subject.class.decorator(:foo) }
+        before { subject.class.decorator(Foo) }
 
-        its(:decorator_class_name) { should eq('foo') }
+        its(:decorator_class) { should eq(Foo) }
       end
     end
 
     describe 'instance methods' do
       describe '#decorator_class' do
-        before { subject.class.decorator(:foo) }
+        before { subject.class.decorator(Foo) }
         its(:decorator_class) { should eq(Foo) }
       end
 
       describe '#decorable?' do
         context 'when `decorator_class_name` present' do
-          before { subject.class.decorator(:foo) }
+          before { subject.class.decorator(Foo) }
           its(:decorable?) { should be_true }
         end
 

data/spec/cyrax/extensions/has_repository_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+class Bar; end
+class Foo; end
+
+module Cyrax
+  class BaseWithRepository < Cyrax::Base
+    include Cyrax::Extensions::HasRepository
+  end
+
+  describe Cyrax::Extensions::HasRepository do
+    subject { BaseWithRepository.new }
+
+    describe 'class attributes' do
+      its(:class) { should respond_to(:_repository_class) }
+    end
+
+    describe 'class methods' do
+      describe '#repository' do
+        context "define repository class" do
+          before { subject.class.repository(Foo) }
+          
+          its(:repository_class) { should eq(Foo) }
+        end
+      end
+    end
+  end
+end

data/spec/cyrax/extensions/has_resource_spec.rb

@@ -18,16 +18,17 @@ module Cyrax
     subject { BaseWithResource.new }
 
     describe 'class attributes' do
-      its(:class) { should respond_to(:resource_name) }
-      its(:class) { should respond_to(:resource_class_name) }
+      its(:class) { should respond_to(:_resource_name) }
+      its(:class) { should respond_to(:_collection_name) }
+      its(:class) { should respond_to(:_resource_class) }
     end
 
     describe 'class methods' do
       describe '#resource' do
-        before { subject.class.resource(:foo, class_name:'bar', name:'bazz') }
+        before { subject.class.resource(:foo, class: Bar, name:'bazz') }
 
         its(:resource_name) { should eq('foo') }
-        its(:resource_class_name) { should eq('bar') }
+        its(:resource_class) { should eq(Bar) }
       end
     end
 
@@ -45,7 +46,7 @@ module Cyrax
 
       describe '#resource_class' do
         context 'when `class_name` option is supplied' do
-          before { subject.class.resource(:foo, class_name:'Bar') }
+          before { subject.class.resource(:foo, class: Bar) }
           its(:resource_class) { should eq(Bar) }
         end
 
@@ -55,11 +56,6 @@ module Cyrax
         end
       end
 
-      describe '#resource_scope' do
-        before { subject.stub(:resource_class).and_return(Foo) }
-        its(:resource_scope) { should eq(Foo) }
-      end
-
       describe '#resource_attributes' do
         let(:dirty_resource_attributes) { double }
         before { subject.stub(:dirty_resource_attributes).and_return(dirty_resource_attributes)}
@@ -88,11 +84,6 @@ module Cyrax
           end
         end
       end
-      describe '#default_resource_attributes' do
-        it 'should return empty hash by default' do
-          subject.send(:default_resource_attributes).should eq({})
-        end
-      end
 
       describe '#filter_attributes' do
         it 'should return supplied attributes by default' do

data/spec/cyrax/extensions/has_response_spec.rb

@@ -59,7 +59,7 @@ module Cyrax
     describe '#respond_with' do
       before { subject.stub(:response_name).and_return(:foo) }
       it 'calls Cyrax::Response' do
-        Cyrax::Response.should_receive(:new).with(:foo, 'bar', {as: nil, assignments: nil}).and_return(double.as_null_object)
+        Cyrax::Response.should_receive(:new).with(:foo, 'bar', {as: nil}).and_return(double.as_null_object)
         subject.respond_with('bar')
       end
 

data/spec/cyrax/extensions/has_service_spec.rb

@@ -16,48 +16,5 @@ module Cyrax
 
   describe Cyrax::Extensions::HasResource do
     subject { BaseWithService.new }
-
-    describe 'instance methods' do
-      describe '#build_collection' do
-        before { subject.stub(:resource_scope).and_return(Foo) }
-        its(:build_collection) { should eq(Foo) }
-      end
-
-      describe '#find_resource' do
-        let(:resource_scope) { double }
-        before { subject.stub(:resource_scope).and_return(resource_scope) }
-        it 'finds resource by id' do
-          allow_message_expectations_on_nil
-          resource_scope.should_receive(:find).with(123)
-          subject.find_resource(123)
-        end
-      end
-
-      describe '#build_resource' do
-        context 'when id is nil' do
-          let(:resource_scope) { double }
-          before { subject.stub(:resource_scope).and_return(resource_scope) }
-          before { subject.stub(:default_resource_attributes).and_return({}) }
-          it 'initializes new object' do
-            allow_message_expectations_on_nil
-            resource_scope.should_receive(:new).with({foo: 'bar'})
-            subject.build_resource(nil, {foo: 'bar'})
-          end
-        end
-        context 'when id is present' do
-          let(:resource) { double.as_null_object }
-          it 'finds resource' do
-            subject.should_receive(:find_resource).with(123).and_return(resource)
-            subject.build_resource(123, {foo: 'bar'})
-          end
-
-          it 'assigns provided attributes' do
-            subject.stub(:find_resource).and_return(resource)
-            resource.should_receive(:attributes=).with({foo: 'bar'})
-            subject.build_resource(123, {foo: 'bar'})
-          end
-        end
-      end
-    end
   end
 end

data/spec/cyrax/repository_spec.rb

@@ -0,0 +1,72 @@
+require 'spec_helper'
+
+class Foo; end
+module Cyrax
+  describe Repository do
+    describe 'it should behave like repository' do
+      context 'instance methods' do
+        subject { Cyrax::Repository.new }
+        it{ should respond_to(:resource_class) }
+        it{ should respond_to(:scope) }
+        it{ should respond_to(:build) }
+        it{ should respond_to(:find_all) }
+        it{ should respond_to(:find) }
+        it{ should respond_to(:save) }
+        it{ should respond_to(:delete) }
+      end
+    end
+
+    describe 'instance methods' do
+      describe '#find_all' do
+        let(:scope) { double }
+        before { subject.stub(:scope).and_return(scope) }
+        it 'finds all objects by default' do
+          scope.should_receive(:all)
+          subject.find_all
+        end
+      end
+
+      describe '#find_resource' do
+        let(:scope) { double }
+        before { subject.stub(:scope).and_return(scope) }
+        it 'finds resource by id' do
+          allow_message_expectations_on_nil
+          scope.should_receive(:find).with(123)
+          subject.find(123)
+        end
+      end
+
+      describe '#build_resource' do
+        context 'when id is nil' do
+          let(:scope) { double }
+          before { subject.stub(:scope).and_return(scope) }
+          before { subject.stub(:default_attributes).and_return({}) }
+          it 'initializes new object' do
+            allow_message_expectations_on_nil
+            scope.should_receive(:new).with({foo: 'bar'})
+            subject.build(nil, {foo: 'bar'})
+          end
+        end
+        context 'when id is present' do
+          let(:resource) { double.as_null_object }
+          it 'finds resource' do
+            subject.should_receive(:find).with(123).and_return(resource)
+            subject.build(123, {foo: 'bar'})
+          end
+
+          it 'assigns provided attributes' do
+            subject.stub(:find).and_return(resource)
+            resource.should_receive(:attributes=).with({foo: 'bar'})
+            subject.build(123, {foo: 'bar'})
+          end
+        end
+      end
+
+      describe '#default_attributes' do
+        it 'should return empty hash by default' do
+          subject.send(:default_attributes).should eq({})
+        end
+      end
+    end
+  end
+end