dicer 0.0.1

data/lib/dicer/railtie/action_controller.rb

@@ -0,0 +1,48 @@
+module Dicer
+  module ActionController
+    extend ActiveSupport::Concern
+
+    included do
+      prepend_before_filter do
+        Dicer::Context.current_controller = self
+
+        default_context = self.class.default_contexts[params[:action].to_sym]
+        Dicer::Context.current = default_context.new if default_context.present?
+      end
+
+      helper_method :context
+      helper_method :in_context
+    end
+
+    module ClassMethods
+      def context_for(action, context_class = nil, &context_define)
+        context = context_class || Class.new(Dicer::Context, &context_define)
+
+        default_contexts[action.to_s.to_sym] = context
+      end
+
+      def default_contexts
+        @default_contexts ||= {}.tap do |hash|
+          hash.default = ApplicationContext if defined?(ApplicationContext)
+        end
+      end
+    end
+
+    def context(context = nil)
+      context.present? ?
+        Dicer::Context.current = context :
+        Dicer::Context.current
+    end
+    private :context
+
+    def in_context(context, &block)
+      current_context = Dicer::Context.current
+      Dicer::Context.current = context.is_a?(Class) ? context.new : context
+
+      block.call(Dicer::Context.current)
+    ensure
+      Dicer::Context.current = current_context
+    end
+    private :in_context
+  end
+end

data/lib/dicer/railtie/active_record.rb

@@ -0,0 +1,29 @@
+module Dicer
+  module ActiveRecord
+    extend ActiveSupport::Concern
+    include Dicer::Contextable
+
+    included do
+      def self.new_with_dicer(*args, &block)
+        if Dicer.config.auto_supply && Dicer::Context.current.present?
+          new_without_dicer(*args, &block).in_context
+        else
+          new_without_dicer(*args, &block)
+        end
+      end
+
+      def self.instantiate_with_dicer(*args)
+        if Dicer.config.auto_supply && Dicer::Context.current.present?
+          instantiate_without_dicer(*args).in_context
+        else
+          instantiate_without_dicer(*args)
+        end
+      end
+
+      class << self
+        alias_method_chain :new, :dicer
+        alias_method_chain :instantiate, :dicer
+      end
+    end
+  end
+end

data/lib/dicer/railtie/context.rb

@@ -0,0 +1,30 @@
+require 'dicer/context'
+require 'forwardable'
+
+module Dicer
+  class Context
+    extend Forwardable
+
+    def self.current=(context)
+      Middleware.store[:context] = context
+    end
+
+    def self.current
+      Middleware.store[:context]
+    end
+
+    def self.current_controller=(controller)
+      Middleware.store[:current_controller] = controller
+    end
+
+    def self.current_controller
+      Middleware.store[:current_controller]
+    end
+
+    def controller
+      self.class.current_controller
+    end
+
+    def_delegators :controller, :request, :cookies, :session, :params
+  end
+end

data/lib/dicer/railtie/contextable.rb

@@ -0,0 +1,10 @@
+require 'dicer/contextable'
+
+module Dicer
+  module Contextable
+    def in_context_with_dicer(context = Dicer::Context.current, &block)
+      in_context_without_dicer(context, &block)
+    end
+    alias_method_chain :in_context, :dicer
+  end
+end

data/lib/dicer/railtie.rb

@@ -0,0 +1,65 @@
+require 'dicer/middleware'
+
+require 'dicer/railtie/action_controller'
+require 'dicer/railtie/active_record'
+
+require 'dicer/railtie/context'
+require 'dicer/railtie/contextable'
+
+module Dicer
+  class Railtie < ::Rails::Railtie
+    def self.generator
+      config.respond_to?(:app_generators) ? :app_generators : :generators
+    end
+
+    config.dicer = Dicer.config
+
+    initializer 'dicer' do |app|
+      config.after_initialize do
+        if Dicer.config.auto_supply && !defined?(ActiveRecord)
+          puts "Dicer's auto_supply option is supporting ActiveRecord only"
+        end
+      end
+
+      # Paths
+      app.config.paths.add('app/contexts', :eager_laod => true)
+      app.config.paths.add('app/behaviors', :eager_laod => true)
+
+      # Middleware
+      app.config.middleware.use Dicer::Middleware
+
+      # ActionController
+      ActiveSupport.on_load :action_controller do |controller|
+        Dicer.setup_action_controller(controller)
+      end
+
+      # ActiveRecord
+      ActiveSupport.on_load :active_record do |orm|
+        Dicer.setup_active_record(orm)
+      end
+
+      # Mongoid
+      ActiveSupport.on_load :mongoid do |orm|
+        Dicer.setup_mongoid(orm)
+      end
+    end
+  end
+
+  def self.setup_action_controller(controller)
+    controller.class_eval do
+      include Dicer::ActionController
+    end
+  end
+
+  def self.setup_active_record(orm)
+    orm.class_eval do
+      include Dicer::ActiveRecord
+    end
+  end
+
+  def self.setup_mongoid(orm)
+    orm.module_eval do
+      include Dicer::Contextable
+    end
+  end
+end

data/lib/dicer/version.rb

@@ -0,0 +1,3 @@
+module Dicer
+  VERSION = '0.0.1'
+end

data/lib/dicer.rb

@@ -0,0 +1,6 @@
+require 'dicer/version'
+require 'dicer/config'
+require 'dicer/context'
+require 'dicer/behavior'
+require 'dicer/contextable'
+require 'dicer/railtie' if defined?(Rails)

data/lib/generators/behavior/behavior_generator.rb

@@ -0,0 +1,20 @@
+require 'rails/generators'
+
+module Rails
+  module Generators
+    class BehaviorGenerator < NamedBase
+      source_root File.expand_path('../template', __FILE__)
+
+      def create_behavior_file
+        template(
+          'behavior.rb',
+          File.join(
+            'app/behaviors',
+            class_path,
+            "#{file_name}.rb"
+          )
+        )
+      end
+    end
+  end
+end

data/lib/generators/behavior/template/behavior.rb

@@ -0,0 +1,3 @@
+module <%= class_name %>
+  include Dicer::Behavior
+end

data/lib/generators/context/context_generator.rb

@@ -0,0 +1,32 @@
+require 'rails/generators'
+
+module Rails
+  module Generators
+    class ContextGenerator < NamedBase
+      source_root File.expand_path('../template', __FILE__)
+
+      check_class_collision :suffix => 'Context'
+
+      class_option :parent,
+        :type => :string,
+        :desc => 'The parent class for the generated context'
+
+      def create_context_file
+        template(
+          'context.rb',
+          File.join(
+            'app/contexts',
+            class_path,
+            "#{file_name}_context.rb"
+          )
+        )
+      end
+
+      private
+      def parent_class_name
+        options[:parent] || defined?(ApplicationContext) ?
+          'ApplicationContext' : 'Dicer::Context'
+      end
+    end
+  end
+end

data/lib/generators/context/template/context.rb

@@ -0,0 +1,2 @@
+class <%= class_name %>Context < <%= parent_class_name %>
+end

data/spec/dicer/behavior_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe Dicer::Behavior do
+  subject(:behavior) do
+    Module.new do
+      include Dicer::Behavior
+
+      def foo; 2; end
+    end
+  end
+
+  describe '.behavior_methods' do
+    subject { behavior.behavior_methods }
+
+    it { should have(1).item }
+    it { should include(:foo) }
+  end
+end

data/spec/dicer/context/description_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe Dicer::Context::Description do
+  subject(:description) do
+    Dicer::Context::Description.new(Entity) do
+      it_behaves_like Cleaner
+    end
+  end
+
+  describe '#described_class' do
+    subject { description.described_class }
+
+    it { should == Entity }
+  end
+
+  describe '#behaviors' do
+    subject { description.behaviors }
+
+    it { should have(1).behavior }
+    it { should include(Cleaner) }
+  end
+
+  describe '#delegator' do
+    subject { description.delegator }
+
+    it { should be_a(Class) }
+
+    describe 'decorated entity' do
+      subject(:entity) { description.delegator.new(Entity.new({})) }
+
+      it { should respond_to(:clean) }
+      it { should be_kind_of(Entity) }
+
+      describe '#class' do
+        subject { entity.class }
+
+        it { should == Entity }
+      end
+    end
+  end
+end

data/spec/dicer/context_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+
+describe Dicer::Context do
+  let(:context_class) do
+    Class.new(Dicer::Context) do
+      describe Entity do
+        it_behaves_like Cleaner
+      end
+
+      describe Entity do
+      end
+    end
+  end
+
+  subject(:context) { context_class.new }
+
+  describe '.descriptions' do
+    subject { context_class.descriptions }
+
+    it { should have(1).item }
+  end
+
+  describe '.describe' do
+    subject(:describe) do
+      context_class.describe(Value) {}
+    end
+
+    specify do
+      expect { describe }.to change { context_class.descriptions.size }.by(1)
+    end
+  end
+
+  describe '#supply' do
+    context 'with described class' do
+      let(:entity) { Entity.new({}) }
+
+      subject { context.supply(entity) }
+
+      it { should be_kind_of(Entity) }
+      it { should == entity }
+      it { should respond_to(:clean) }
+    end
+
+    context 'with not described class' do
+      let(:value) { Value.new({}) }
+
+      subject { context.supply(value) }
+
+      it { should be_kind_of(Value) }
+      it { should == value }
+      it { should_not respond_to(:clean) }
+    end
+  end
+end

data/spec/dicer/contextable_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+describe Dicer::Contextable do
+  let(:entity) { Entity.new({}) }
+  let(:cleaning_context) { CleaningContext.new }
+
+  describe '#in_context' do
+    subject { entity.in_context(cleaning_context) }
+
+    it { should respond_to(:clean) }
+    it { should == entity }
+
+    context 'with block' do
+      it do
+        entity.in_context(cleaning_context) do |cleaner|
+          cleaner.should respond_to(:clean)
+        end
+      end
+    end
+  end
+
+  describe '#as' do
+    subject { entity.as(Cleaner) }
+
+    it { should respond_to(:clean) }
+
+    context 'with block' do
+      it do
+        entity.as(Cleaner) do |cleaner|
+          cleaner.should respond_to(:clean)
+        end
+      end
+    end
+  end
+end

data/spec/dicer/delegator_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+describe Dicer::Delegator do
+  let(:delegator) { Dicer::Delegator.make(Entity, [Cleaner]) }
+  let(:entity) { Entity.new(:test => 1) }
+
+  subject(:delegated) { delegator.new(entity) }
+
+  it { should == entity }
+
+  describe '#__id__' do
+    subject { delegated.__id__ }
+
+    it { should_not == entity.__id__ }
+  end
+
+  describe '#test' do
+    subject { delegated.test }
+
+    it { should == 1 }
+  end
+
+  describe '#id' do
+    subject { delegated.id }
+
+    it { should == entity.id }
+  end
+
+  describe '#clean' do
+    subject { delegated.clean }
+
+    it { should be_true }
+  end
+end

data/spec/dicer/railtie/context_spec.rb

@@ -0,0 +1,106 @@
+require 'spec_helper'
+
+describe Dicer::Context do
+  let(:context) { Dicer::Context.new }
+  let(:controller) { ActionController::Base.new }
+
+  describe '.current' do
+    subject { described_class.current }
+
+    it { should be_nil }
+
+    context 'when set current context' do
+      before(:all) do
+        described_class.current = context
+      end
+
+      it { should == context }
+
+      context 'in another thread' do
+        around {|e| Thread.new(e) {|e| e.run }.join }
+
+        it { should_not == context }
+      end
+    end
+  end
+
+  describe '.current_controller' do
+    subject { described_class.current_controller }
+
+    it { should be_nil }
+
+    context 'when set current controller' do
+      before(:all) do
+        described_class.current_controller = controller
+      end
+
+      it { should == controller }
+
+      context 'when another thread' do
+        around {|e| Thread.new(e) {|e| e.run }.join }
+
+        it { should_not == controller }
+      end
+    end
+  end
+
+  describe '#controller' do
+    before { described_class.current_controller = controller }
+
+    subject { context.controller }
+
+    it { should == controller }
+  end
+
+  describe '#request' do
+    let(:request) { mock }
+
+    before do
+      controller.request = request
+      described_class.current_controller = controller
+    end
+
+    subject { context.request }
+
+    it { should == request }
+  end
+
+  describe '#params' do
+    let(:params) { mock }
+
+    before do
+      controller.params = params
+      described_class.current_controller = controller
+    end
+
+    subject { context.params }
+
+    it { should == params }
+  end
+
+  describe '#cookies' do
+    let(:cookies) { mock }
+
+    before do
+      controller.request = mock(:cookie_jar => cookies)
+      described_class.current_controller = controller
+    end
+
+    subject { context.cookies }
+
+    it { should == cookies }
+  end
+
+  describe '#session' do
+    let(:session) { mock }
+
+    before do
+      controller.request = mock(:session => session)
+      described_class.current_controller = controller
+    end
+
+    subject { context.session }
+
+    it { should == session }
+  end
+end

data/spec/dicer/railtie/contextable_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe Dicer::Contextable do
+  let(:entity) { Entity.new({}) }
+  let(:cleaning_context) { CleaningContext.new }
+
+  describe '#in_context' do
+    context 'current context is cleaning context' do
+      before do
+        Dicer::Context.current = cleaning_context
+      end
+
+      subject { entity.in_context }
+
+      it { should respond_to(:clean) }
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,27 @@
+require 'rubygems'
+require 'bundler'
+require 'rails'
+require 'action_controller'
+require 'action_controller/test_case'
+require 'active_record'
+
+require 'simplecov'
+SimpleCov.add_filter('spec')
+SimpleCov.start
+
+Bundler.require(:default, :test)
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+
+  config.before(:suite) do
+    Dir[File.expand_path('../support/**/*.rb', __FILE__)].each do |lib|
+      require lib
+    end
+  end
+
+  config.before(:all) do
+    Dicer::Middleware.clear!
+  end
+end

data/spec/support/cleaner.rb

@@ -0,0 +1,5 @@
+module Cleaner
+  include Dicer::Behavior
+
+  def clean; true; end
+end

data/spec/support/cleaning_context.rb

@@ -0,0 +1,8 @@
+require File.expand_path('../entity', __FILE__)
+require File.expand_path('../cleaner', __FILE__)
+
+class CleaningContext < Dicer::Context
+  describe Entity do
+    it_behaves_like Cleaner
+  end
+end

data/spec/support/entity.rb

@@ -0,0 +1,31 @@
+require 'securerandom'
+
+class Entity
+  include Dicer::Contextable
+
+  def initialize(data)
+    @id = SecureRandom.hex
+
+    data.each_pair do |key, val|
+      instance_variable_set(:"@#{key}", val)
+
+      if key.to_s != 'id'
+        (class << self; self; end).class_eval(<<-EOF)
+          def #{key}
+            @#{key}
+          end
+
+          def #{key}=(v)
+            @#{key} = v
+          end
+        EOF
+      end
+    end
+  end
+
+  attr_reader :id
+
+  def ==(other)
+    other.class == self.class && other.id == self.id
+  end
+end

data/spec/support/value.rb

@@ -0,0 +1,22 @@
+class Value < Hash
+  def [](val)
+    super(val.to_s)
+  end
+
+  def []=(name, val)
+    super(name.to_s, val)
+  end
+
+  def method_missing(name, *args)
+    if name.to_s[-1] == '='
+      name = name[0 .. -2]
+      self[name] = args[0]
+      (class << self; self; end).class_eval(<<-EOF)
+        def #{name}; self["#{name}"]; end
+        def #{name}=(v); self["#{name}"] = v; end
+      EOF
+    else
+      super
+    end
+  end
+end