cyrax 0.0.3

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Droidlabs
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,31 @@
+# Cyrax
+![Cyrax](http://images2.wikia.nocookie.net/__cb20121118042055/mk/images/thumb/4/44/CyraxMK9Render.png/322px-CyraxMK9Render.png)
+> Safeties disabled; combat mode engaged.
+
+Cyrax is microframework to build layered architecture, one of the core concepts of Domain Driven Design
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'cyrax'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install cyrax
+
+## Usage
+
+Look at `example` folder.
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/cyrax.rb

@@ -0,0 +1,14 @@
+require "cyrax/version"
+require "cyrax/extensions/has_resource.rb"
+require "cyrax/extensions/has_response.rb"
+require "cyrax/extensions/has_callbacks.rb"
+require "cyrax/extensions/has_service.rb"
+require "cyrax/extensions/has_decorator.rb"
+require "cyrax/base.rb"
+require "cyrax/base_resource.rb"
+require "cyrax/response.rb"
+require "cyrax/callbacks.rb"
+require "cyrax/decorator.rb"
+
+module Cyrax
+end

data/lib/cyrax/base.rb

@@ -0,0 +1,12 @@
+require 'has_active_logger'
+class Cyrax::Base
+  include HasActiveLogger::Mixin
+  include Cyrax::Extensions::HasResponse
+
+  attr_accessor :params, :accessor
+
+  def initialize(options = {})
+    @accessor = options[:as]
+    @params = options[:params]
+  end
+end

data/lib/cyrax/base_resource.rb

@@ -0,0 +1,6 @@
+class Cyrax::BaseResource < Cyrax::Base
+  include Cyrax::Extensions::HasResource
+  include Cyrax::Extensions::HasCallbacks
+  include Cyrax::Extensions::HasService
+  include Cyrax::Extensions::HasDecorator
+end

data/lib/cyrax/callbacks.rb

@@ -0,0 +1,17 @@
+class Cyrax::Callbacks
+  attr_accessor :resource
+
+  def initialize(resource)
+    @resource = resource
+  end
+
+  def before_save;    end
+  def before_create;  end
+  def before_update;  end
+  def before_destroy; end
+
+  def after_save;    end
+  def after_create;  end
+  def after_update;  end
+  def after_destroy; end
+end

data/lib/cyrax/decorator.rb

@@ -0,0 +1,13 @@
+class Cyrax::Decorator
+  attr_accessor :resource
+
+  def initialize(resource)
+    @resource = resource
+  end
+
+  def method_missing(method, *args, &block)
+    return super unless resource.respond_to?(method)
+
+    resource.send(method, *args, &block)
+  end
+end

data/lib/cyrax/extensions/has_callbacks.rb

@@ -0,0 +1,24 @@
+require 'active_support/core_ext/object'
+require 'active_support/core_ext/class'
+
+module Cyrax::Extensions
+  module HasCallbacks
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :resource_callbacks_handler_class
+    end
+
+    def invoke_callback(name, resource)
+      if resource_callbacks_handler_class
+        resource_callbacks_handler_class.new(resource).send(name)
+      end
+    end
+
+    module ClassMethods
+      def callbacks_handler(name, options = {})
+        self.resource_callbacks_handler_class = name
+      end
+    end
+  end
+end

data/lib/cyrax/extensions/has_decorator.rb

@@ -0,0 +1,49 @@
+module Cyrax::Extensions
+  module HasDecorator
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :decorator_class_name
+    end
+
+    module ClassMethods
+      def decorator(name)
+        self.decorator_class_name = name.to_s
+      end
+    end
+
+    def decorated_collection
+      if decorable?
+        build_decorated_collection
+      else
+        build_collection
+      end
+    end
+
+    private
+
+    def decorable?
+      !self.class.decorator_class_name.nil?
+    end
+
+    def decorator_class
+      self.class.decorator_class_name.to_s.classify.constantize
+    end
+
+    def prepare_collection_for_decorate
+      collection = build_collection
+
+      if collection.kind_of?(Array)
+        return collection
+      elsif collection.respond_to?(:all)
+        return collection.all
+      else
+        return Array.wrap(collection)
+      end
+    end
+
+    def build_decorated_collection
+      prepare_collection_for_decorate.map{|i| decorator_class.new(i)}
+    end
+  end
+end

data/lib/cyrax/extensions/has_resource.rb

@@ -0,0 +1,69 @@
+require 'active_support'
+module Cyrax::Extensions
+  module HasResource
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :resource_name
+      class_attribute :resource_class_name
+    end
+
+    def resource_class
+      if self.class.resource_class_name
+        self.class.resource_class_name.constantize
+      else
+        resource_name.classify.constantize
+      end
+    end
+
+    def resource_scope
+      resource_class
+    end
+
+    def collection_name
+      resource_name.pluralize
+    end
+
+    def resource_attributes
+      filter_attributes(dirty_resource_attributes)
+    end
+
+    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
+
+    def build_collection
+      resource_scope
+    end
+
+    def find_resource(id)
+      resource_scope.find(id)
+    end
+
+    module ClassMethods
+      def resource(name, options = {})
+        self.resource_name = name.to_s
+        self.resource_class_name = options[:class_name]
+      end
+    end
+
+    private
+      def dirty_resource_attributes
+        params[resource_name] || {}
+      end
+
+      def default_resource_attributes
+        {}
+      end
+
+      def filter_attributes(attributes)
+        attributes
+      end
+  end
+end

data/lib/cyrax/extensions/has_response.rb

@@ -0,0 +1,42 @@
+module Cyrax::Extensions
+  module HasResponse
+    extend ActiveSupport::Concern
+
+    def add_error(error)
+      @_errors ||= []
+      @_errors << error
+    end
+
+    def assign_resource(resource_name, resource)
+      @_assignments ||= {}
+      @_assignments[resource_name.to_sym] = resource
+    end
+
+    def add_error_unless(error, condition)
+      add_error(error) unless condition
+    end
+
+    def add_errors_from(model)
+      @_errors ||= []
+      if model && model.errors.messages.present?
+        model.errors.messages.each do |key, value|
+          add_error "#{key}: #{value}"
+        end
+      end
+    end
+
+    def set_message(message)
+      @_message = message
+    end
+
+    def respond_with(resource, custom_resource_name=nil)
+      name = custom_resource_name||resource_name
+      result = respond_to?(:decorator_class) ? decorator_class.new(resource) : resource
+      response = Cyrax::Response.new(name, result)
+      response.message = @_message
+      response.errors = @_errors
+      response.assignments = @_assignments
+      response
+    end
+  end
+end

data/lib/cyrax/extensions/has_service.rb

@@ -0,0 +1,55 @@
+module Cyrax::Extensions
+  module HasService
+    extend ActiveSupport::Concern
+
+    def collection
+      respond_with decorated_collection, collection_name
+    end
+
+    def build
+      respond_with build_resource(nil)
+    end
+
+    def create(custom_attributes=nil)
+      resource = build_resource(nil, custom_attributes||resource_attributes)
+      invoke_callback(:before_create, resource)
+      invoke_callback(:before_save, resource)
+      if resource.save
+        invoke_callback(:after_create, resource)
+        invoke_callback(:after_save, resource)
+        set_message("#{resource_name.titleize} successfully created")
+      else
+        add_errors_from(resource)
+      end
+      respond_with(resource)
+    end
+
+    def read
+      respond_with find_resource(params[:id])
+    end
+    alias_method :edit, :read
+
+
+    def update(custom_attributes=nil)
+      resource = build_resource(params[:id], custom_attributes||resource_attributes)
+      invoke_callback(:before_update, resource)
+      invoke_callback(:before_save, resource)
+      if resource.save
+        invoke_callback(:after_update, resource)
+        invoke_callback(:after_save, resource)
+        set_message("#{resource_name.titleize} successfully updated")
+      else
+        add_errors_from(resource)
+      end
+      respond_with(resource)
+    end
+
+    def destroy
+      resource = find_resource(params[:id])
+      invoke_callback(:before_destroy, resource)
+      resource.destroy
+      invoke_callback(:after_destroy, resource)
+      respond_with(resource)
+    end
+  end
+end

data/lib/cyrax/response.rb

@@ -0,0 +1,46 @@
+class Cyrax::Response
+  attr_accessor :message, :errors, :assignments, :result, :resource_name
+
+  def initialize(resource_name, result)
+    @resource_name = resource_name
+    @result = result
+    @message = nil
+    @errors = []
+    @assignments = []
+  end
+
+  def with_errors(errors)
+    @errors = errors
+    self
+  end
+
+  def with_message(message)
+    @message = message
+    self
+  end
+
+  def success?
+    @errors.nil? || @errors.empty?
+  end
+
+  def failure?
+    !success?
+  end
+
+  def notice
+    message if success?
+  end
+
+  def error
+    message || errors.first if failure?
+  end
+
+  def has_error?(error)
+    errors && errors.include?(error)
+  end
+
+  def method_missing(method, *args, &block)
+    super unless assignments.has_key?(method)
+    assignments[method]
+  end
+end

data/lib/cyrax/version.rb

@@ -0,0 +1,3 @@
+module Cyrax
+  VERSION = "0.0.3"
+end

data/spec/cyrax/base_resource_spec.rb

@@ -0,0 +1,180 @@
+require 'spec_helper'
+
+class Foo; end
+module Cyrax
+  describe BaseResource do
+    describe 'it should behave like resource' do
+      context 'class methods' do
+        subject { Cyrax::BaseResource }
+        it{ should respond_to(:new) }
+      end
+      context 'instance methods' do
+        subject { Cyrax::BaseResource.new }
+        it{ should respond_to(:accessor) }
+        it{ should respond_to(:params) }
+        it{ should respond_to(:resource_name) }
+        it{ should respond_to(:resource_class) }
+        it{ should respond_to(:resource_scope) }
+        it{ should respond_to(:resource_attributes) }
+        it{ should respond_to(:build_resource) }
+        it{ should respond_to(:build_collection) }
+        it{ should respond_to(:find_resource) }
+        it{ should respond_to(:assign_resource) }
+        it{ should respond_to(:respond_with) }
+        it{ should respond_to(:set_message) }
+        it{ should respond_to(:add_error) }
+        it{ should respond_to(:add_error_unless) }
+        it{ should respond_to(:add_errors_from) }
+        it{ should respond_to(:invoke_callback) }
+      end
+    end
+
+    subject { Cyrax::BaseResource.new }
+    let(:resource) { mock.as_null_object }
+    let(:collection) { mock }
+    before do
+      subject.stub!(:params).and_return({id:123})
+      subject.stub!(:find_resource).and_return(resource)
+      subject.stub!(:resource_name).and_return('foo')
+    end
+
+    describe '#collection' do
+      it 'responds with decorated collection' do
+        subject.should_receive(:build_collection).and_return(collection)
+        subject.should_receive(:respond_with).with(collection, 'foos')
+        subject.collection
+      end
+    end
+
+    describe '#build' do
+      it 'responds with resource' do
+        subject.should_receive(:build_resource).with(nil).and_return(resource)
+        subject.should_receive(:respond_with).with(resource)
+        subject.build
+      end
+    end
+
+    describe '#edit' do
+      it 'responds with resource' do
+        subject.should_receive(:find_resource)
+        subject.should_receive(:respond_with).with(resource)
+        subject.edit
+      end
+    end
+
+    describe '#read' do
+      it 'responds with resource' do
+        subject.should_receive(:find_resource)
+        subject.should_receive(:respond_with).with(resource)
+        subject.read
+      end
+    end
+
+    describe '#destroy' do
+      it 'responds with resource' do
+        subject.should_receive(:find_resource)
+        subject.should_receive(:respond_with).with(resource)
+        subject.destroy
+      end
+
+      it 'destroys resource' do
+        resource.should_receive(:destroy)
+        subject.destroy
+      end
+
+      it 'invokes callbacks' do
+        subject.should_receive(:invoke_callback).with(:before_destroy, resource)
+        subject.should_receive(:invoke_callback).with(:after_destroy, resource)
+        subject.destroy
+      end
+    end
+
+    describe '#create' do
+      let(:params) { {foo: 'bar'} }
+      before { subject.stub!(:build_resource).and_return(resource) }
+      it 'responds with resource' do
+        subject.should_receive(:build_resource).with(nil, params)
+        subject.should_receive(:respond_with).with(resource)
+        subject.create(params)
+      end
+
+      context 'when resource successfully saved' do
+        before { resource.stub!(:save).and_return(true) }
+
+        it 'invokes callbacks' do
+          subject.should_receive(:invoke_callback).with(:before_save, resource)
+          subject.should_receive(:invoke_callback).with(:before_create, resource)
+          subject.should_receive(:invoke_callback).with(:after_save, resource)
+          subject.should_receive(:invoke_callback).with(:after_create, resource)
+          subject.create(params)
+        end
+
+        it 'sets message' do
+          subject.should_receive(:set_message).with('Foo successfully created')
+          subject.create(params)
+        end
+      end
+
+      context 'when resource could not be saved' do
+        before { resource.stub!(:save).and_return(false) }
+
+        it 'invokes callbacks' do
+          subject.should_receive(:invoke_callback).with(:before_save, resource)
+          subject.should_receive(:invoke_callback).with(:before_create, resource)
+          subject.should_not_receive(:invoke_callback).with(:after_save, resource)
+          subject.should_not_receive(:invoke_callback).with(:after_create, resource)
+          subject.create(params)
+        end
+
+        it 'sets error messages' do
+          subject.should_receive(:add_errors_from).with(resource)
+          subject.create(params)
+        end
+      end
+    end
+
+    describe '#update' do
+      let(:params) { {foo: 'bar'} }
+      before { subject.stub!(:build_resource).and_return(resource) }
+      it 'responds with resource' do
+        subject.should_receive(:build_resource).with(123, params)
+        subject.should_receive(:respond_with).with(resource)
+        subject.update(params)
+      end
+
+      context 'when resource successfully saved' do
+        before { resource.stub!(:save).and_return(true) }
+
+        it 'invokes callbacks' do
+          subject.should_receive(:invoke_callback).with(:before_save, resource)
+          subject.should_receive(:invoke_callback).with(:before_update, resource)
+          subject.should_receive(:invoke_callback).with(:after_save, resource)
+          subject.should_receive(:invoke_callback).with(:after_update, resource)
+          subject.update(params)
+        end
+
+        it 'sets message' do
+          subject.should_receive(:set_message).with('Foo successfully updated')
+          subject.update(params)
+        end
+      end
+
+      context 'when resource could not be saved' do
+        before { resource.stub!(:save).and_return(false) }
+
+        it 'invokes callbacks' do
+          subject.should_receive(:invoke_callback).with(:before_save, resource)
+          subject.should_receive(:invoke_callback).with(:before_update, resource)
+          subject.should_not_receive(:invoke_callback).with(:after_save, resource)
+          subject.should_not_receive(:invoke_callback).with(:after_update, resource)
+          subject.update(params)
+        end
+
+        it 'sets error messages' do
+          subject.should_receive(:add_errors_from).with(resource)
+          subject.update(params)
+        end
+      end
+    end
+  end
+end

data/spec/cyrax/base_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+module Cyrax
+  describe Base do
+    describe '#new' do
+      subject { Cyrax::Base.new({as: :john, params: {foo: 'bar'}})}
+      its(:accessor) { should eq(:john) }
+      its(:params) { should eq({foo: 'bar'}) }
+    end
+  end
+end

data/spec/cyrax/callbacks_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+module Cyrax
+  describe Callbacks do
+    subject { Cyrax::Callbacks.new(mock) }
+
+    it { should respond_to(:before_create) }
+    it { should respond_to(:after_create) }
+
+    it { should respond_to(:before_save) }
+    it { should respond_to(:after_save) }
+
+    it { should respond_to(:before_update) }
+    it { should respond_to(:after_update) }
+
+    it { should respond_to(:before_destroy) }
+    it { should respond_to(:after_destroy) }
+  end
+end

data/spec/cyrax/decorator_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+module Cyrax
+  describe Decorator do
+    let(:decorable) { mock(foo:'bar') }
+    subject { Cyrax::Decorator.new(decorable) }
+
+    its(:resource) { should eq(decorable) }
+
+    it 'should translate missing methods to decorable' do
+      subject.foo.should eq('bar')
+    end
+
+    it 'should not translate missing methods' do
+      expect {
+        subject.bar
+      }.to raise_error(NoMethodError)
+    end
+  end
+end

data/spec/cyrax/extensions/has_callbacks_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+module Cyrax
+  describe Cyrax::Extensions::HasCallbacks do
+    include Cyrax::Extensions::HasCallbacks
+
+    describe '#invoke_callback' do
+      context 'when callback handler class is not defined' do
+        let(:name) { mock }
+        let(:resource) { mock }
+        before { self.class.stub!(:resource_callbacks_handler_class) }
+        it { invoke_callback(name, resource).should be_nil }
+      end
+
+      context 'when callback handler class is defined' do
+        let(:name) { "foo" }
+        let(:resource) { mock }
+        let(:handle_class) { double.as_null_object }
+        before { self.class.stub!(:resource_callbacks_handler_class).and_return(handle_class) }
+
+        it 'initializes handle class instance' do
+          handle_class.should_receive(:new).with(resource)
+          invoke_callback(name, resource)
+        end
+
+        it 'calls corresponding method on instance' do
+          instance = double.as_null_object
+          handle_class.stub!(:new).and_return(instance)
+          instance.should_receive(:foo)
+          invoke_callback(name, resource)
+        end
+      end
+    end
+
+    describe '#callbacks_handler' do
+      it 'should define callbacks handler class' do
+        self.class.callbacks_handler('Foo')
+        self.class.resource_callbacks_handler_class.should eq('Foo')
+      end
+    end
+  end
+end

data/spec/cyrax/extensions/has_decorator_spec.rb

@@ -0,0 +1,102 @@
+require 'spec_helper'
+
+class Foo;
+  attr_accessor :a
+  def initialize(arg)
+    @a = arg
+  end
+
+  def ==(other)
+    self.a == other.a
+  end
+end
+
+module Cyrax
+  describe Cyrax::Extensions::HasDecorator do
+    include Cyrax::Extensions::HasDecorator
+
+    describe 'class attributes' do
+      subject { self.class }
+      it { should respond_to(:decorator_class_name) }
+    end
+
+    describe 'class methods' do
+      describe '#decorator' do
+        before { self.class.decorator(:foo) }
+        subject { self }
+
+        its(:decorator_class_name) { should eq('foo') }
+      end
+    end
+
+    describe 'instance methods' do
+      subject { self }
+
+      describe '#decorator_class' do
+        before { self.class.decorator(:foo) }
+        its(:decorator_class) { should eq(Foo) }
+      end
+
+      describe '#decorable?' do
+        context 'when `decorator_class_name` present' do
+          before { self.class.decorator(:foo) }
+          its(:decorable?) { should be_true }
+        end
+
+        context 'when `decorator_class_name` empty' do
+          its(:decorable?) { should be_false }
+        end
+      end
+
+      describe '#decorated_collection' do
+        context 'when `decorable?`' do
+          before { subject.stub!(:decorable?).and_return(true) }
+          it 'should return decorated result' do
+            subject.should_receive(:build_decorated_collection)
+            subject.decorated_collection
+          end
+        end
+        context 'when not `decorable?`' do
+          before { subject.stub!(:decorable?).and_return(false) }
+          it 'should return raw result' do
+            subject.should_not_receive(:build_decorated_collection)
+            subject.should_receive(:build_collection)
+            subject.decorated_collection
+          end
+        end
+      end
+
+      describe '#build_decorated_collection' do
+        before do
+          self.class.decorator(:foo)
+          subject.stub!(:prepare_collection_for_decorate).and_return([:bar])
+        end
+
+        it 'returns array of decorator instances' do
+          subject.send(:build_decorated_collection).should eq([Foo.new(:bar)])
+        end
+      end
+
+      describe '#prepare_collection_for_decorate' do
+        subject { self.send(:prepare_collection_for_decorate) }
+
+        context 'when #build_collection returns array' do
+          before { self.stub!(:build_collection).and_return([:bar]) }
+          it { should eq([:bar]) }
+        end
+
+        context 'when #build_collection returns any object except array' do
+          before { self.stub!(:build_collection).and_return(:bar) }
+          it { should eq([:bar]) }
+        end
+
+        context 'when #build_collection returns any object which responds to #all method' do
+          let(:obj) { mock(:all => [:bar] ) }
+          before { self.stub!(:build_collection).and_return(obj) }
+
+          it { should eq([:bar]) }
+        end
+      end
+    end
+  end
+end

data/spec/cyrax/extensions/has_resource_spec.rb

@@ -0,0 +1,138 @@
+require 'spec_helper'
+
+class Bar; end
+class Foo; end
+
+module Cyrax
+  describe Cyrax::Extensions::HasResource do
+    include Cyrax::Extensions::HasResource
+
+    describe 'class attributes' do
+      subject { self.class }
+      it { should respond_to(:resource_name) }
+      it { should respond_to(:resource_class_name) }
+    end
+
+    describe 'class methods' do
+      describe '#resource' do
+        before { self.class.resource(:foo, class_name:'bar', name:'bazz') }
+        subject { self }
+
+        its(:resource_name) { should eq('foo') }
+        its(:resource_class_name) { should eq('bar') }
+      end
+    end
+
+    describe 'instance methods' do
+      subject { self }
+
+      describe '#resource_name' do
+        before { self.class.resource(:foo) }
+        its(:resource_name) { should eq('foo') }
+      end
+
+      describe '#collection_name' do
+        before { self.class.resource(:foo) }
+        its(:collection_name) { should eq('foos') }
+      end
+
+      describe '#resource_class' do
+        context 'when `class_name` option is supplied' do
+          before { self.class.resource(:foo, class_name:'Bar') }
+          its(:resource_class) { should eq(Bar) }
+        end
+
+        context 'when `class_name` option is omited' do
+          before { self.class.resource(:foo) }
+          its(:resource_class) { should eq(Foo) }
+        end
+      end
+
+      describe '#resource_scope' do
+        before { subject.stub!(:resource_class).and_return(Foo) }
+        its(:resource_scope) { should eq(Foo) }
+      end
+
+      describe '#build_collection' do
+        before { subject.stub!(:resource_class).and_return(Foo) }
+        its(:build_collection) { should eq(Foo) }
+      end
+
+      describe '#find_resource' do
+        let(:resource_scope) { mock }
+        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) { mock }
+          before { subject.stub!(:resource_scope).and_return(resource_scope) }
+          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) { mock.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
+
+      describe '#resource_attributes' do
+        let(:dirty_resource_attributes) { mock }
+        before { subject.stub!(:dirty_resource_attributes).and_return(dirty_resource_attributes)}
+        it 'filters dirty attributes' do
+          subject.should_receive(:filter_attributes).with(dirty_resource_attributes)
+          subject.resource_attributes
+        end
+      end
+    end
+
+    describe 'private methods' do
+      subject { self }
+      describe '#dirty_resource_attributes' do
+        context 'when params are present' do
+          it 'should return from params by resource_name' do
+            subject.stub!(:resource_name).and_return(:foo)
+            subject.stub!(:params).and_return({foo: {bar: 'bazz'}})
+            subject.send(:dirty_resource_attributes).should eq({bar: 'bazz'})
+          end
+        end
+        context 'when there are no params' do
+          it 'should return empty hash' do
+            subject.stub!(:resource_name).and_return(:foo)
+            subject.stub!(:params).and_return({})
+            subject.send(:dirty_resource_attributes).should eq({})
+          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
+          subject.send(:filter_attributes, {foo: 'bar'}).should eq({foo: 'bar'})
+        end
+      end
+    end
+
+  end
+end

data/spec/cyrax/extensions/has_response_spec.rb

@@ -0,0 +1,74 @@
+require 'spec_helper'
+
+module Cyrax
+  describe Cyrax::Extensions::HasResponse do
+    include Cyrax::Extensions::HasResponse
+
+    subject { self }
+
+    describe '#set_message' do
+      it 'should set message' do
+        subject.set_message('foo')
+        subject.instance_variable_get(:@_message).should eq('foo')
+      end
+    end
+
+    describe '#add_error' do
+      it 'should add error' do
+        subject.add_error('foo')
+        subject.instance_variable_get(:@_errors).should include('foo')
+      end
+    end
+
+    describe '#add_error_unless' do
+      it 'should add error when condition false' do
+        subject.add_error_unless('foo', 1==0)
+        subject.instance_variable_get(:@_errors).should include('foo')
+      end
+
+      it 'should not add error when condition true' do
+        subject.add_error_unless('foo', 1==1)
+        subject.instance_variable_get(:@_errors).should be_nil
+      end
+    end
+
+    describe '#add_errors_from' do
+      let(:messages) { [[:foo, 'bar'], [:bar, 'bazz']]}
+      let(:errors) { mock(messages: messages)}
+      let(:model) { mock(errors: errors) }
+
+      it 'should add errors from model error messages' do
+        subject.add_errors_from(model)
+        subject.instance_variable_get(:@_errors).should eq(['foo: bar', 'bar: bazz'])
+      end
+    end
+
+    describe '#assign_resource' do
+      it 'should set assignments' do
+        subject.assign_resource('foo', 'bar')
+        subject.instance_variable_get(:@_assignments).should eq({foo: 'bar'})
+      end
+    end
+
+    describe '#respond_with' do
+      before { subject.stub!(:resource_name).and_return(:foo) }
+      it 'calls Cyrax::Response' do
+        Cyrax::Response.should_receive(:new).with(:foo, 'bar').and_return(mock.as_null_object)
+        subject.respond_with('bar')
+      end
+
+      it 'should return Cyrax::Response instance' do
+        subject.respond_with('bar').should be_a_kind_of(Cyrax::Response)
+      end
+
+      it 'should assign message, errors and additional assignments to response object' do
+        response = mock
+        Cyrax::Response.should_receive(:new).and_return(response)
+        response.should_receive(:message=)
+        response.should_receive(:errors=)
+        response.should_receive(:assignments=)
+        subject.respond_with('bar')
+      end
+    end
+  end
+end

data/spec/cyrax/response_spec.rb

@@ -0,0 +1,97 @@
+require 'spec_helper'
+
+module Cyrax
+  describe Response do
+    subject { Cyrax::Response.new('some_resource', 'some_result')}
+
+    describe '#with_message' do
+      before { subject.with_message('some message') }
+      it { should be_kind_of(Cyrax::Response) }
+      its(:message) { should be }
+      its(:message) { should eq('some message') }
+    end
+
+    describe '#with_errors' do
+      before { subject.with_errors(['some', 'errors']) }
+      it { should be_kind_of(Cyrax::Response) }
+      its(:errors) { should be }
+      its(:errors) { should eq(['some', 'errors']) }
+    end
+
+    describe '#success?' do
+      context 'when there are no errors' do
+        before { subject.with_errors([]) }
+        its(:success?) { should be_true }
+      end
+
+      context 'when there are errors' do
+        before { subject.with_errors(['some', 'errors']) }
+        its(:success?) { should be_false }
+      end
+    end
+
+    describe '#failure?' do
+      context 'when there are no errors' do
+        before { subject.with_errors([]) }
+        its(:failure?) { should be_false }
+      end
+
+      context 'when there are errors' do
+        before { subject.with_errors(['some', 'errors']) }
+        its(:failure?) { should be_true }
+      end
+    end
+
+    describe '#notice' do
+      before { subject.with_message('some message') }
+      context 'when there are no errors' do
+        before { subject.with_errors([]) }
+        its(:notice) { should be }
+        its(:notice) { should eq('some message') }
+      end
+
+      context 'when there are errors' do
+        before { subject.with_errors(['some', 'errors']) }
+        its(:notice) { should be_nil }
+      end
+    end
+
+    describe '#error' do
+      context 'when there are no errors' do
+        before { subject.with_errors([]) }
+        its(:error) { should be_nil }
+      end
+
+      context 'when there are errors' do
+        before { subject.with_errors(['some', 'message']) }
+        its(:error) { should be }
+        its(:error) { should eq('some') }
+      end
+
+      context 'when message is present' do
+        before { subject.with_message('some message').with_errors(['some', 'message']) }
+        its(:error) { should be }
+        its(:error) { should eq('some message') }
+      end
+    end
+
+    describe '#has_error?' do
+      context 'when there are no errors' do
+        before { subject.with_errors([]) }
+        specify { subject.has_error?('foo').should be_false }
+      end
+
+      context 'when there are errors' do
+        before { subject.with_errors(['some', 'message']) }
+        specify { subject.has_error?('some').should be_true }
+        specify { subject.has_error?('foo').should be_false }
+      end
+    end
+
+    describe '#method_missing' do
+      before { subject.assignments = {foo: 'bar'} }
+      its(:foo) { should eq('bar') }
+      specify { expect{ subject.bar }.to raise_error(NoMethodError) }
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,6 @@
+if ENV['COVERAGE']
+  require 'simplecov'
+  SimpleCov.start
+end
+
+require 'cyrax'

metadata

@@ -0,0 +1,128 @@
+--- !ruby/object:Gem::Specification
+name: cyrax
+version: !ruby/object:Gem::Version
+  version: 0.0.3
+  prerelease: 
+platform: ruby
+authors:
+- Droidlabs
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-05-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: has_active_logger
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Small library for adding service layer to Rails projects
+email: 
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/cyrax/base.rb
+- lib/cyrax/base_resource.rb
+- lib/cyrax/callbacks.rb
+- lib/cyrax/decorator.rb
+- lib/cyrax/extensions/has_callbacks.rb
+- lib/cyrax/extensions/has_decorator.rb
+- lib/cyrax/extensions/has_resource.rb
+- lib/cyrax/extensions/has_response.rb
+- lib/cyrax/extensions/has_service.rb
+- lib/cyrax/response.rb
+- lib/cyrax/version.rb
+- lib/cyrax.rb
+- LICENSE.txt
+- Rakefile
+- README.md
+- spec/cyrax/base_resource_spec.rb
+- spec/cyrax/base_spec.rb
+- spec/cyrax/callbacks_spec.rb
+- spec/cyrax/decorator_spec.rb
+- spec/cyrax/extensions/has_callbacks_spec.rb
+- spec/cyrax/extensions/has_decorator_spec.rb
+- spec/cyrax/extensions/has_resource_spec.rb
+- spec/cyrax/extensions/has_response_spec.rb
+- spec/cyrax/response_spec.rb
+- spec/spec_helper.rb
+homepage: 
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.25
+signing_key: 
+specification_version: 3
+summary: Small library for adding service layer to Rails projects
+test_files:
+- spec/cyrax/base_resource_spec.rb
+- spec/cyrax/base_spec.rb
+- spec/cyrax/callbacks_spec.rb
+- spec/cyrax/decorator_spec.rb
+- spec/cyrax/extensions/has_callbacks_spec.rb
+- spec/cyrax/extensions/has_decorator_spec.rb
+- spec/cyrax/extensions/has_resource_spec.rb
+- spec/cyrax/extensions/has_response_spec.rb
+- spec/cyrax/response_spec.rb
+- spec/spec_helper.rb