droid_services 0.0.1

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,29 @@
+# DroidServices
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'droid_services'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install droid_services
+
+## Usage
+
+TODO: Write usage instructions here
+
+## 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/droid_services/base.rb

@@ -0,0 +1,11 @@
+class DroidServices::Base
+  include DroidServices::Extensions::HasLogger
+  include DroidServices::Extensions::HasResponse
+
+  attr_accessor :params, :accessor
+
+  def initialize(options = {})
+    @accessor = options[:as]
+    @params = options[:params]
+  end
+end

data/lib/droid_services/base_resource.rb

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

data/lib/droid_services/callbacks.rb

@@ -0,0 +1,17 @@
+class DroidServices::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/droid_services/decorator.rb

@@ -0,0 +1,13 @@
+class DroidServices::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/droid_services/extensions/has_callbacks.rb

@@ -0,0 +1,24 @@
+require 'active_support/core_ext/object'
+require 'active_support/core_ext/class'
+
+module DroidServices::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/droid_services/extensions/has_decorator.rb

@@ -0,0 +1,49 @@
+module DroidServices::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/droid_services/extensions/has_logger.rb

@@ -0,0 +1,60 @@
+require 'yell'
+require 'active_support'
+require 'active_support/core_ext/kernel/reporting'
+require 'active_support/inflector'
+require 'json'
+
+module DroidServices::Extensions
+  module HasLogger
+    extend ActiveSupport::Concern
+
+    silence_warnings do
+      Yell::Formatter::PatternRegexp = /([^%]*)(%\d*)?(#{Yell::Formatter::PatternTable.keys.join('|')})?(.*)/m
+    end
+
+    included do
+      class << self
+        def logger
+          @logger ||= Yell.new do |l|
+            l.adapter :datefile, log_file,
+              level: (:debug..:fatal),
+              format: Yell.format( "%d [%5L] #%M at %F:%n\n%m\n\n", "%H:%M:%S" ),
+              date_pattern: "%Y-week-%V",
+              symlink_original_filename: true,
+              keep: 4
+          end
+        end
+
+        def format_message(message)
+          case message
+            when String
+              message
+            when Hash, Array
+              JSON::pretty_generate message
+            else message.inspect
+          end
+        end
+
+        private
+          def log_file
+            path = File.join(rails_log_path, "#{self.name.underscore}.log")
+            FileUtils.mkdir_p File.dirname(path)
+            path.to_s
+          end
+
+          def rails_log_path
+            File.join(Rails.root, 'log', Rails.env)
+          end
+      end
+
+      def logger
+        self.class.logger
+      end
+
+      def format_message(message)
+        self.class.format_message(message)
+      end
+    end
+
+  end
+end

data/lib/droid_services/extensions/has_resource.rb

@@ -0,0 +1,68 @@
+module DroidServices::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/droid_services/extensions/has_response.rb

@@ -0,0 +1,42 @@
+module DroidServices::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 = DroidServices::Response.new(name, result)
+      response.message = @_message
+      response.errors = @_errors
+      response.assignments = @_assignments
+      response
+    end
+  end
+end

data/lib/droid_services/extensions/has_service.rb

@@ -0,0 +1,55 @@
+module DroidServices::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/droid_services/response.rb

@@ -0,0 +1,46 @@
+class DroidServices::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/droid_services/version.rb

@@ -0,0 +1,3 @@
+module DroidServices
+  VERSION = "0.0.1"
+end

data/lib/droid_services.rb

@@ -0,0 +1,15 @@
+require "droid_services/version"
+require "droid_services/extensions/has_logger.rb"
+require "droid_services/extensions/has_resource.rb"
+require "droid_services/extensions/has_response.rb"
+require "droid_services/extensions/has_callbacks.rb"
+require "droid_services/extensions/has_service.rb"
+require "droid_services/extensions/has_decorator.rb"
+require "droid_services/base.rb"
+require "droid_services/base_resource.rb"
+require "droid_services/response.rb"
+require "droid_services/callbacks.rb"
+require "droid_services/decorator.rb"
+
+module DroidServices
+end

data/spec/services/base_resource_spec.rb

@@ -0,0 +1,180 @@
+require 'spec_helper'
+
+class Foo; end
+module DroidServices
+  describe BaseResource do
+    describe 'it should behave like resource' do
+      context 'class methods' do
+        subject { DroidServices::BaseResource }
+        it{ should respond_to(:new) }
+      end
+      context 'instance methods' do
+        subject { DroidServices::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 { DroidServices::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/services/base_spec.rb

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

data/spec/services/callbacks_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+module DroidServices
+  describe Callbacks do
+    subject { DroidServices::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