moonshine 0.2.1.pre → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: aae2eb56018f3507bd3d5f36ded77930c1b1c7e6
-  data.tar.gz: b240d7956adb487b96eee495552fe492ade864c4
+  metadata.gz: e1cbffb31dd0dcced747bb06c3cc6a6370599e6e
+  data.tar.gz: e8a3183d13be8f733e2d85fbd12cb95b336d3c8f
 SHA512:
-  metadata.gz: 47b2be0dd1bf28acf80a0bb3224e383398aaf6250e1047685089b9e41bef8a5950d9c9745ae37aeb3375e1bb51d350a8f27f31793c74851ef8daddd9f333c26e
-  data.tar.gz: 4867578bd37b75012ff1c23ca5e3f7da42b8d5db571dc511dda9fca2e5e382ba3ce4a5c9d831cae744a93adfd6771d635ebc9d81c1533156059c1753b107905f
+  metadata.gz: dc85d07677d1a4a4e634086e3c471e62552eb22e73c0ff063709b16aaf62d38ae915fb3b2c8198b95852f0e0d64c2d4273f90f1fedef4c781185128b751ff629
+  data.tar.gz: 14ab17f3c26783a930ffdd66dca33fbcfe0685bb03d2fd60acab3b8e602c7c622420ad182a02080717def56c05072ce20632f0b10f74b0936d7601a0390a81f1

data/README.md

@@ -1,24 +1,338 @@
-# Moonshine [![Gem Version](https://badge.fury.io/rb/moonshine.png)](http://badge.fury.io/rb/moonshine) [![Build Status](https://travis-ci.org/nebulab/moonshine.png?branch=master)](https://travis-ci.org/nebulab/moonshine) [![Coverage Status](https://coveralls.io/repos/nebulab/moonshine/badge.png?branch=master)](https://coveralls.io/r/nebulab/moonshine?branch=master) [![Code Climate](https://codeclimate.com/github/nebulab/moonshine.png)](https://codeclimate.com/github/nebulab/moonshine)
+# Moonshine 
+[![GemVersion](https://badge.fury.io/rb/moonshine.png)](http://badge.fury.io/rb/moonshine)
+[![BuildStatus](https://travis-ci.org/nebulab/moonshine.png?branch=master)](https://travis-ci.org/nebulab/moonshine)
+[![CoverageStatus](https://coveralls.io/repos/nebulab/moonshine/badge.png?branch=master)](https://coveralls.io/r/nebulab/moonshine?branch=master)
+[![CodeClimate](https://codeclimate.com/github/nebulab/moonshine.png)](https://codeclimate.com/github/nebulab/moonshine)
 
-TODO: Write a gem description
+Moonshine is a configuration driven method chain builder.
 
-## Installation
+Usually writing a conditional method chain requires a lot of if and case
+statements that increase code complexity, reduce code readability and make
+testing hard. Moonshine removes this complexity by providing a way to call a
+list of methods based on some input parameters. A completely object-oriented
+approach also ensures an easily testable interface.
+
+## Why Moonshine?
+
+Moonshine has been built to solve a problem which is particularly obvious when
+building complex REST APIs. A good API usually filters data based on parameters
+passed via a GET or POST request, from a Rails point of view controller
+`params[]` are used to filter down data kept in `ActiveRecord` models.
+
+Usually to achieve this task you use [Ransack](https://github.com/activerecord-hackery/ransack),
+or [HasScope](https://github.com/plataformatec/has_scope) or some hacky solution
+[like this](http://stackoverflow.com/questions/1658990/one-or-more-params-in-model-find-conditions-with-ruby-on-rails).
+With Moonshine you can do similar things without being restricted to using
+`ActiveRecord` and with code which is easy to test.
+
+A real world example with a Rails REST API is best to explain what Moonshine's
+power is. If you define a class like this:
+
+```ruby
+  class PostFilter < Moonshine::Base
+    subject -> { Post }
+
+    param :category
+    param :with_tags
+  end
+```
+
+Then in your controller you can:
+
+```ruby
+  class PostController < ApplicationController
+   def index
+      @posts = PostFilter.new(params).run
+    end
+  end
+```
+
+So when you receive a request like this:
 
-Add this line to your application's Gemfile:
+```
+  GET http://my.awesome-blog.com/posts?category=cats&with_tags=cute,lovely
+```
 
-    gem 'moonshine'
+Moonshine creates a method chain based on the parameters passed. In this case
+the `category` and `with_tags` methods are called on the `Post` class with
+`cats` and `cute,lovely` as argument values.
 
-And then execute:
+## Installation
+
+As usual you can install it using [Bundler](http://bundler.io) by adding it
+to your application's Gemfile:
+  
+```ruby
+  gem 'moonshine'
+```
+
+And then executing:
 
-    $ bundle
+```ruby
+  $ bundle
+```
 
-Or install it yourself as:
+Or you can install it yourself by running:
 
-    $ gem install moonshine
+```ruby
+  $ gem install moonshine
+```
 
 ## Usage
 
-TODO: Write usage instructions here
+Now we'll take a look at how we can use Moonshine in a Rails application.
+Moonshine supports any kind of object but probably its advantages on a Rails
+application are more obvious so we'll start with a quick example with Rails.
+
+Let's pretend we have an ActiveRecord model like this:
+
+```ruby
+  #
+  # The schema
+  #
+  create_table :posts do |t|
+    t.string :title
+    t.text :description
+    t.boolean :published
+
+    t.timestamps
+  end
+
+  #
+  # The model
+  #
+  class Post < ActiveRecord::Base
+    scope :title_starts, -> (title) { where('title LIKE ?', "#{title}%") }
+    scope :desc_like,    -> (desc)  { where('description LIKE ?', "%#{desc}%") }
+    scope :created_at,   -> (date)  { where(created_at: date) }
+    scope :published,    ->         { where( published: true ) }
+  end
+```
+
+we can add a `PostQuery` class inherited from `Moonshine::Base` somewhere in
+our Rails application (for example in the `/lib` directory) to manage method
+chaining, in this case we are mostly chaining scopes:
+
+```ruby
+  class PostQuery < Moonshine::Base
+    subject -> { Post }
+
+    param :title_starts
+    param :description_has, call: :desc_like
+    param :published, as_boolean: true
+    param :created_at, transform: :string_to_date
+    param :limit, default: 10
+
+    param :in_season do |subject, season|
+      date_range = case season
+        when :summer then Date.parse('2014/06/01')..Date.parse('2014/08/31')
+        when :winter then Date.parse('2014/12/01')..Date.parse('2014/02/28')
+        when :autumn then Date.parse('2014/09/01')..Date.parse('2014/11/30')
+        when :spring then Date.parse('2014/03/01')..Date.parse('2014/05/30')
+      end
+
+      subject.where( created_at: date_range )
+    end
+
+    def self.string_to_date(string_date)
+      string_date.to_date
+    end
+  end
+```
+
+### Running the chain
+
+After defining the `PostQuery` class we can run method chains with it on the 
+specified `subject`. An example run is like this:
+
+```ruby
+  PostQuery.new({ title_starts: 'moonshine', in_season: :summer }).run
+```
+
+In the end we'll have the result of the execution of the method chain on the
+`subject` object. In this case we'll have the `ActiveRecord::Relation` returned
+by the various scopes being called on `Post`. In case Moonshine has to run an
+empty chain (for example when no params are passed to it) the `subject` will be
+returned.
+
+### Configuring the chain
+
+Let's take a look at each line of code to understand what Moonshine is all
+about.
+
+### Subject
+
+```ruby
+  subject -> { Post }
+```
+
+The subject is what the chain will be called on. It must be a block, proc or
+lambda. When you run a method chain each method will be called on the `subject`
+(which is evaluated at every run) and the result of the chain of methods called
+will be the returned value.
+
+In our Rails example every method or scope which is added to the chain will be
+called, in order, on the `Post` subject. Since we're talking scopes here you can
+see where this is going, Moonshine will build a long list of scopes and call it
+for you.
+
+### Param
+
+The basic parameter is without arguments, when the chain is run it will look for
+a method defined on the `subject` and call it with given parameter value.
+
+```ruby
+  param :title_starts
+```
+
+Calling the chain like this:
+
+```ruby
+  PostQuery.new({ title_starts: 'moonshine' }).run
+```
+
+will run a `title_starts` scope on the `Post` model with 'moonshine' as an
+argument.
+
+### call
+
+When the `subject` doesn't have a method named after the `param` argument,
+you can add `call` to specify the actual method to call.
+
+```ruby
+  param :description_has, call: :desc_like
+```
+
+Calling the chain like this:
+
+```ruby
+  PostQuery.new({ description_has: 'cool stuff!' }).run
+```
+
+will run the `desc_like` scope on the `Post` model with 'cool stuff!' as an
+argument.
+
+### as_boolean
+
+When a method doesn't take any arguments you can add it to the method chain by
+setting the `as_boolean` to `true`. This will make Moonshine call the method
+based on the value passed to the `PostQuery` object.
+
+```ruby
+  param :published, as_boolean: true
+```
+
+This means that calling a chain like this:
+
+```ruby
+  PostQuery.new({ published: true }).run
+```
+
+will end up running the `published` scope on the `Post` model. In case it was
+`published: false` Moonshine would have just returned `Post` since the chain
+would be empty (no method needed to be called).
+
+### default
+
+If you need a method in the chain to return a default value you can use the
+`default` option. As you would expect this would return the default value when
+the chain is run whithout that parameter in the chain.
+
+```ruby
+  param :limit, default: 10
+```
+
+### transform
+
+At times you may need to transform the values you are passing to the chain for
+example when reading `params[]` you may need to transform something from string
+to whatever you need in your model. In such occasions you can use the `trasform`
+option.
+
+```ruby
+  param :created_at, transform: :string_to_date
+
+  def self.string_to_date(string_date)
+    string_date.to_date
+  end
+```
+
+So a run like:
+
+```ruby
+  PostQuery.new({ created_at: '2014/06/01' }).run
+```
+
+will end up using the `created_at` scope and passing in the actual `Date`
+object.
+
+### block
+
+When total customization needs to be achieved and you don't feel adding more
+code to the `Post` model, you can pass a block to execute that block instead of
+any other method.
+
+```ruby
+  param :in_season do |subject, season|
+    date_range = case season
+      when :summer then Date.parse('2014/06/01')..Date.parse('2014/08/31')
+      when :winter then Date.parse('2014/12/01')..Date.parse('2014/02/28')
+      when :autumn then Date.parse('2014/09/01')..Date.parse('2014/11/30')
+      when :spring then Date.parse('2014/03/01')..Date.parse('2014/05/30')
+    end
+
+    subject.where( created_at: date_range )
+  end
+```
+
+# Moonshine for everything!
+
+Even if this readme is heavily Rails-centered, remember that Moonshine can build
+method chains to be run on any object. This is because the `subject` can be any
+object you'd like.
+
+Take a look at this quick example with a string:
+
+```ruby
+  class StringQuery < Moonshine::Base
+    subject -> { 'a dog' }
+
+    param :upper, call: :upcase, as_boolean: true
+    param :capitalize, as_boolean: true
+    param :append, call: :concat
+    param :concat, transform: :reverse
+
+    param :exclaims, default: true, as_boolean: true do |subject, value|
+      subject.concat(value || '!')
+    end
+
+    param :append_a_cat do |subject, value|
+      "#{subject} #{value} with a cat"
+    end
+
+    def self.reverse(value)
+      value.reverse
+    end
+  end
+```
+
+```ruby
+  StringQuery.new({ upper: true }).run
+  => "A DOG"
+
+  StringQuery.new({}).run
+  => "a dog!"
+
+  StringQuery.new({ capitalize: true }).run
+  => "A dog"
+
+  StringQuery.new({ append: ' go aroud' }).run
+  => "a dog go aroud"
+
+  StringQuery.new({ concat: 'tac a dna ' }).run
+  => "a dog and a cat"
+```
+
 
 ## Contributing
 

data/lib/moonshine.rb

@@ -1,7 +1,7 @@
 require "moonshine/version"
-require "moonshine/base"
+require "moonshine/dsl"
 require "moonshine/filter"
+require "moonshine/base"
 
 module Moonshine
-  # Your code goes here...
 end

data/lib/moonshine/base.rb

@@ -1,36 +1,31 @@
 module Moonshine
   class Base
-
-    attr_accessor :filters
-    attr_reader :chain, :subject
-
-    def initialize(filters, subject = nil)
-      @filters = filters
-      @subject = subject || self.class.default_subject
-      @chain = self.class.default_chain || []
+    attr_reader :chain
+    attr_accessor :params, :subject
+
+    include DSL
+
+    def initialize(params, subject = nil)
+      @subject = subject || self.class.default_subject.call
+      @params = params
+      @chain = []
+      if self.class.default_chain
+        self.class.default_chain.each do |params|
+          add_filter_to_chain(params[:name], params[:options], &params[:block])
+        end
+      end
     end
 
-    def add(filter)
-      @chain << filter
+    def add_filter_to_chain(name, **options, &block)
+      @chain << Moonshine::Filter.new(name, options, &block)
     end
 
     def run
-      chain.each { |filter| @subject = filter.execute(self) }
-      @subject
-    end
-
-    class << self
-
-      attr_accessor :default_subject, :default_chain
-
-      def subject(subject)
-        self.default_subject = subject
-      end
-
-      def param(name, call: nil, **options, &block)
-        self.default_chain ||= []
-        self.default_chain << Moonshine::Filter.new(name, method_name: (call || name), **options, &block)
+      chain.inject(subject) do |subject, filter|
+        filter.params = params
+        subject = filter.execute(subject)
       end
     end
   end
 end
+

data/lib/moonshine/dsl.rb

@@ -0,0 +1,22 @@
+module Moonshine
+  module DSL
+    def self.included(base)
+      base.send :extend, ClassMethods
+    end
+
+    module ClassMethods
+      attr_accessor :default_subject, :default_chain
+
+      def subject(subject)
+        @default_subject = subject
+      end
+
+      def param(name, **options, &block)
+        @default_chain ||= []
+        options[:transform_class] ||= self
+        @default_chain << { name: name, options: options, block: block }
+      end
+    end
+  end
+end
+

data/lib/moonshine/filter.rb

@@ -1,41 +1,44 @@
 module Moonshine
   class Filter
 
-    attr_accessor :name, :method_name, :options, :klass
+    attr_accessor :name, :params, :options
 
-    def initialize(name, method_name: nil, **options, &block)
+    def initialize(name, **options, &block)
       @name = name
-      @method_name = block || method_name
+      options[:call] ||= block || name
       @options = options
     end
 
-    def execute(klass)
-      @klass = klass
-      return method_call if klass.filters[name] || options[:default]
-      klass.subject
-    end
-
-    private
-
-    def method_call
-      if method_name.is_a? Proc
-        method_name.call(klass.subject, *args)
+    def execute(subject)
+      return subject unless to_execute?
+      if options[:as_boolean]
+        subject.send(options[:call])
       else
-        klass.subject.send(method_name, *args)
+        if options[:call].is_a? Proc
+          options[:call].call(subject, args)
+        else
+          subject.send(options[:call], args)
+        end
       end
     end
 
+    def to_execute?
+      !!default
+    end
+
+    private
+
     def args
-      set_transform(set_default(klass.filters[name])) unless options[:as_boolean]
+      transform(default)
     end
 
-    def set_default value
-      value || options[:default]
+    def default
+      params[name] || options[:default]
     end
 
-    def set_transform value
-      return klass.send(options[:transform], value) if options[:transform]
-      value
+    def transform(params)
+      return params unless options[:transform]
+      options[:transform_class].send(options[:transform], params)
     end
   end
 end

data/lib/moonshine/version.rb

@@ -1,3 +1,3 @@
 module Moonshine
-  VERSION = "0.2.1.pre"
+  VERSION = "0.3.0"
 end

data/moonshine.gemspec

@@ -8,8 +8,8 @@ Gem::Specification.new do |spec|
   spec.version       = Moonshine::VERSION
   spec.authors       = ["Alessio Rocco"]
   spec.email         = ["alessio.rocco.lt@gmail.com"]
-  spec.summary       = %q{Conditional method chaining}
-  spec.description   = %q{Conditional method chaining}
+  spec.summary       = %q{A configuration driven method chain builder.}
+  spec.description   = %q{Moonshine removes the complexity in building conditional method chains by providing a way to call a list of methods based on some input parameters.}
   spec.homepage      = "https://github.com/nebulab/moonshine"
   spec.license       = "MIT"
 

data/test/lib/moonshine/base_test.rb

@@ -1,91 +1,64 @@
-require 'test_helper'
+ require 'test_helper'
 
 describe Moonshine::Base do
-  before(:each) do
-    @chain_builder = Class.new(Moonshine::Base)
-    @default_subject = mock('default_subject')
-  end
 
-  describe '.subject' do
-    before do
-      @chain_builder.default_subject = @default_subject
-    end
+  let(:tale) { Tale.new }
+  let(:tale_generator){ 
+    EmptyTaleGenerator.new({ beginning: true }, tale)
+  }
 
-    it 'sets default subject class attribute' do
-      @chain_builder.default_subject.must_equal @default_subject
-    end
+  describe '#add_filter_to_chain' do
 
-    describe 'when it is initialized without a subject' do
-      it 'sets subject as default subject' do
-        @chain_builder.new({}).subject.must_equal @default_subject
-      end
-    end
-
-    describe 'when it is initialized with a subject' do
-      let(:subject){ mock('subject') }
+    let(:params) { [:beginning] }
 
-      it 'sets subject as requested' do
-        @chain_builder.new({}, subject).subject.must_equal subject
-      end
+    it 'instantiates a Moonshine::Filter' do
+      Moonshine::Filter.expects(:new).with(*params.push({}))
+      tale_generator.add_filter_to_chain(:beginning)
     end
-  end
 
-  describe '.param' do
-    it 'instantiates a Moonshine::Filter class' do
-      Moonshine::Filter.expects(:new).with(:filter_name, method_name: :method)
-      @chain_builder.param :filter_name, call: :method
+    describe 'when params have options' do
+    it 'instantiates a Moonshine::Filter with options' do
+      Moonshine::Filter.expects(:new).with(*params.push({as_boolean: true}))
+      tale_generator.add_filter_to_chain(:beginning, as_boolean: true)
     end
 
-    describe 'when :call is not given' do
-      it 'instantiates a Moonshine::Filter class with call same as first param' do
-        Moonshine::Filter.expects(:new).with(:filter_name, method_name: :filter_name)
-        @chain_builder.param :filter_name
-      end
+    end
 
-      describe 'and a block is given' do
-        it 'instantiates a Moonshine::Filter call with block as call' do
-          block = Proc.new{ |subject| subject }
-          Moonshine::Filter.expects(:new).with(:filter_name, &block)
-          @chain_builder.param :filter_name, &block
-        end
+    describe 'when params have a block' do
+      it 'instantiates a Moonshine::Filter with a block' do
+        a_block = Proc.new {}
+        Moonshine::Filter.expects(:new).with(*params.push({}, &a_block))
+        tale_generator.add_filter_to_chain(:beginning, &a_block)
       end
     end
 
-    it 'adds filter to default_chain' do
-      filter =  mock('filter')
+    it 'adds a Moonshine:Filter instance to filter_chain' do
+      filter = mock('a filter')
       Moonshine::Filter.stubs(:new).returns(filter)
-      @chain_builder.param :filter_name, call: :scope
-      @chain_builder.default_chain.must_equal [filter]
-    end
-  end
-
-  describe '#add' do
-    it 'adds filter to chain' do
-      filter = mock('filter')
-      chain_builder_instance = @chain_builder.new({})
-      chain_builder_instance.add(filter)
-      chain_builder_instance.chain.must_equal [filter]
+      tale_generator.add_filter_to_chain(:beginning)
+      tale_generator.chain.must_include(filter)
     end
   end
 
   describe '#run' do
+    let(:tale_generator){ 
+      EmptyTaleGenerator.new({ beginning: true, conclusion: true }, tale)
+    }
 
-    it 'run execute on each filter' do
-      filter1 = mock('filter1')
-      filter1.stubs(:name).returns(:filter1)
-      filter2 = mock('filter2')
-      filter2.stubs(:name).returns(:filter2)
-      filters = [filter1, filter2]
-      @chain_builder.default_chain = filters
-      chain_builder_instance = @chain_builder.new({ filter1: 1, filter2: 2})
-      filter1.expects(:execute).with(chain_builder_instance)
-      filter2.expects(:execute).with(chain_builder_instance)
-      chain_builder_instance.run
+    before do
+      tale_generator.add_filter_to_chain(:beginning, as_boolean: true)
+      tale_generator.add_filter_to_chain(:conclusion, as_boolean: true)
+    end
+
+    it 'sends execute on each filter in chain' do
+      tale_generator.chain.first.expects(:execute)
+      tale_generator.chain.last.expects(:execute)
+      tale_generator.run
     end
 
-    it 'returns subject' do
-      chain_builder_instance = @chain_builder.new({})
-      chain_builder_instance.run.must_equal chain_builder_instance.subject
+    it 'returns execute result of last filter in chain' do
+      tale_generator.run.must_be_kind_of Tale
     end
   end
 end
+

data/test/lib/moonshine/filter_test.rb

@@ -1,91 +1,138 @@
 require 'test_helper'
 
 describe Moonshine::Filter do
-  before(:each) do
-    default_subject = mock('default_subject')
-    @chain_builder = Class.new(Moonshine::Base) do
-      subject default_subject
-      param :name, call: :scope
-      param :block do |subject, value|
-        subject.some_method(value)
+
+  let(:tale) { Tale.new }
+  let(:filter) { Moonshine::Filter.new(:character) }
+
+  describe '#to_execute?' do
+    describe 'when params have a key like filter name' do
+      it 'returns true' do
+        filter.params = { character: 'a developer' }
+        filter.to_execute?.must_equal true
       end
     end
-  end
 
-  describe '#execute' do
-    let(:filter) { Moonshine::Filter.new(:filter, method_name: :filter) }
-    let(:chain_builder_instance) { @chain_builder.new({ filter: 1 }) }
-
-    it 'sends scope to klass' do
-      chain_builder_instance.subject.expects(:filter).with(1)
-      filter.execute(chain_builder_instance)
+    describe 'when options have a default value' do
+      it 'returns true' do
+        filter.options[:default] = true
+        filter.params = { antagonist: 'a designer'}
+        filter.to_execute?.must_equal true
+      end
     end
 
-    it 'return subject when default and value are nil' do
-      filter.options[:default] = nil
-      chain_builder_instance.filters = {}
-      filter.execute(chain_builder_instance).must_equal chain_builder_instance.subject
+    describe 'when params does not have a key like filter name and does
+              not have a default value' do
+      it 'returns false' do
+        filter.params = { antagonist: 'a designer'}
+        filter.to_execute?.must_equal false
+      end
     end
+  end
 
-    describe 'when block is given' do
-      it 'calls block' do
-        block = Proc.new { |subject, value| subject.some_method(value) }
-        filter = Moonshine::Filter.new(:filter, &block)
-        chain_builder_instance = @chain_builder.new({ filter: 1 })
-        filter.method_name.expects(:call).with(chain_builder_instance.subject, 1)
-        filter.execute(chain_builder_instance)
+  describe '#execute' do
+    describe 'when to_execute? return false' do
+      it 'returns given subject' do
+        filter.params = { antagonist: 'a designer'}
+        filter.execute(tale).must_equal tale
       end
     end
 
-    describe 'options' do
-      describe 'transform' do
-        it 'changes value with transform method from klass' do
-          filter.options[:transform] = :transform_method
-          chain_builder_instance.subject.stubs(:filter)
-          chain_builder_instance.expects(:transform_method).with(1)
-          filter.execute(chain_builder_instance)
-        end
+    describe 'when to_execute? return true' do
+
+      before do
+        filter.params = { character: 'a developer' }
       end
 
-      describe 'default' do
-        it 'uses default value if filter is nil' do
-          filter.options[:default] = 2
-          chain_builder_instance.filters = {}
-          chain_builder_instance.subject.expects(:filter).with(2)
-          filter.execute(chain_builder_instance)
+      describe 'and call is a block' do
+        it 'calls given block' do
+          filter.options[:call] = -> (subject, params){}
+          filter.options[:call].expects(:call).with(tale, 'a developer')
+          filter.execute(tale)
         end
+      end
 
-        it 'not use default value if filter is not nil' do
-          filter.options[:default] = 2
-          chain_builder_instance.filters = { filter: 1 }
-          chain_builder_instance.subject.expects(:filter).with(1)
-          filter.execute(chain_builder_instance)
-        end
+      it 'sends method to given subject' do
+        tale.expects(:character).with('a developer')
+        filter.execute(tale)
+      end
 
-        it 'not sends filter if default and value are nil' do
-          filter.options[:default] = nil
-          chain_builder_instance.filters = {}
-          chain_builder_instance.subject.expects(:filter).never
-          filter.execute(chain_builder_instance)
-        end
+      it 'returns given subject' do
+        filter.execute(tale).must_equal tale
       end
 
-      describe 'as_boolean' do
-        it 'sends method without value when true' do
-          filter.options[:as_boolean] = true
-          chain_builder_instance.filters = { filter: true }
-          chain_builder_instance.subject.expects(:filter)
-          filter.execute(chain_builder_instance)
+      describe 'options' do
+        describe 'transform' do
+          before do
+            filter.options[:transform_class] = TaleTransform
+            filter.options[:transform] = :to_upper
+          end
+
+          it 'sends transform method on given transform class' do
+            TaleTransform.expects(:to_upper).with('a developer')
+            filter.execute(tale)
+          end
+
+          it 'sends method to given subject with transformed value' do
+            tale.expects(:character).with('A DEVELOPER')
+            filter.execute(tale)
+          end
         end
 
-        it 'sends method without value when false' do
-          filter.options[:as_boolean] = true
-          chain_builder_instance.filters = { filter: false }
-          chain_builder_instance.subject.expects(:filter).never
-          filter.execute(chain_builder_instance)
+        describe 'default' do
+          before do
+            filter.options[:default] = 'a designer'
+          end
+
+          describe 'when params have key like filter name' do
+            it 'sends method to given subject with given value' do
+              tale.expects(:character).with('a developer')
+              filter.execute(tale)
+            end
+          end
+
+          describe 'when params does not have key like filter name' do
+            it 'sends method to given subject with default value' do
+              tale.expects(:character).with('a designer')
+              filter.params = {}
+              filter.execute(tale)
+            end
+          end
+        end
+
+        describe 'as_boolean' do
+          before do
+            filter.options[:as_boolean] = true
+          end
+
+          describe 'when params have key like filter name' do
+            describe 'and value is true' do
+              it 'sends method to given subject whitout params' do
+                tale.expects(:character).with()
+                filter.params = { character: true }
+                filter.execute(tale)
+              end
+            end
+
+            describe 'and value is false' do
+              it 'do not sends method to given subject' do
+                tale.expects(:character).with().never
+                filter.params = { character: false }
+                filter.execute(tale)
+              end
+            end
+          end
+
+          describe 'when params does not have key like filter name' do
+            it 'do not sends method to given subject' do
+              tale.expects(:character).with().never
+              filter.params = {}
+              filter.execute(tale)
+            end
+          end
         end
       end
     end
   end
-
 end
+

data/test/lib/moonshine/version_test.rb

@@ -2,7 +2,7 @@ require 'test_helper'
 
 describe Moonshine::VERSION do
 
-  it 'is 0.2.1.pre' do
-    Moonshine::VERSION.must_equal '0.2.1.pre'
+  it 'is 0.3.0' do
+    Moonshine::VERSION.must_equal '0.3.0'
   end
 end

data/test/lib/moonshine_test.rb

@@ -0,0 +1,37 @@
+require 'test_helper'
+
+describe 'Given a class to generate a tale' do
+
+  let(:tale_generator){ TaleGenerator.new({}) }
+
+  describe 'when no params' do
+    it 'tell this story' do
+      tale_generator.run.story.must_equal "#{Tale::BEGINNING}"
+    end
+  end
+
+  describe "when params are { ending: true }" do
+    it 'tell this story' do
+      tale_generator.params = { ending: true }
+      tale_generator.run.story.must_equal "#{Tale::BEGINNING} #{Tale::CONCLUSION}"
+    end
+  end
+
+  describe "when params are { character: 'a developer' }" do
+    it 'tell this story' do
+      tale_generator.params = { character: 'a developer' }
+      tale_generator.run.story.must_equal "#{Tale::BEGINNING} a developer"
+    end
+  end
+
+  describe "when params are { character: 'a developer' }" do
+    it 'tell this story' do
+      tale_generator.params = { character: 'a developer',
+                                in_the_middle: 'that write a gem' }
+      tale_generator.run.story.must_equal(
+        "#{Tale::BEGINNING} a developer that write a gem"
+      )
+    end
+  end
+end
+

data/test/support/empty_tale_generator.rb

@@ -0,0 +1,2 @@
+class EmptyTaleGenerator < Moonshine::Base 
+end

data/test/support/tale.rb

@@ -0,0 +1,39 @@
+class Tale
+
+  BEGINNING = 'long time ago ther was'
+  CONCLUSION = 'and they lived happily ever after'
+
+  def initialize
+    @story = {}
+  end
+
+  def story
+    story = []
+    story << @story[:beginning]
+    story << @story[:character]
+    story << @story[:before_conclusion]
+    story << @story[:conclusion]
+    story.delete(nil)
+    story.join(' ')
+  end
+
+  def character(name)
+    @story[:character] = name
+    self
+  end
+
+  def beginning
+    @story[:beginning] = BEGINNING
+    self
+  end
+
+  def before_conclusion(value)
+    @story[:before_conclusion] = value
+    self
+  end
+
+  def conclusion
+    @story[:conclusion] = CONCLUSION
+    self
+  end
+end

data/test/support/tale_generator.rb

@@ -0,0 +1,7 @@
+class TaleGenerator < Moonshine::Base 
+  subject -> { Tale.new }
+  param :beginning, default: true, as_boolean: true
+  param :character
+  param :in_the_middle, call: :before_conclusion
+  param :ending, call: :conclusion, as_boolean: true
+end

data/test/support/tale_transform.rb

@@ -0,0 +1,6 @@
+class TaleTransform
+
+  def self.to_upper(value)
+    value.upcase
+  end
+end

data/test/test_helper.rb

@@ -7,6 +7,10 @@ require 'moonshine'
 require 'minitest/autorun'
 require 'mocha/mini_test'
 require 'minitest/pride'
+require 'support/tale_transform'
+require 'support/tale'
+require 'support/tale_generator'
+require 'support/empty_tale_generator'
 
 class MiniTest::Spec
 end

metadata

@@ -1,107 +1,114 @@
 --- !ruby/object:Gem::Specification
 name: moonshine
 version: !ruby/object:Gem::Version
-  version: 0.2.1.pre
+  version: 0.3.0
 platform: ruby
 authors:
 - Alessio Rocco
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-02-02 00:00:00.000000000 Z
+date: 2014-08-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.5'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.5'
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '5.2'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '5.2'
 - !ruby/object:Gem::Dependency
   name: mocha
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: coveralls
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '0.7'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '0.7'
-description: Conditional method chaining
+description: Moonshine removes the complexity in building conditional method chains
+  by providing a way to call a list of methods based on some input parameters.
 email:
 - alessio.rocco.lt@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
-- .ruby-version
-- .travis.yml
+- ".gitignore"
+- ".ruby-version"
+- ".travis.yml"
 - Gemfile
 - LICENSE.txt
 - README.md
 - Rakefile
 - lib/moonshine.rb
 - lib/moonshine/base.rb
+- lib/moonshine/dsl.rb
 - lib/moonshine/filter.rb
 - lib/moonshine/version.rb
 - moonshine.gemspec
 - test/lib/moonshine/base_test.rb
 - test/lib/moonshine/filter_test.rb
 - test/lib/moonshine/version_test.rb
+- test/lib/moonshine_test.rb
+- test/support/empty_tale_generator.rb
+- test/support/tale.rb
+- test/support/tale_generator.rb
+- test/support/tale_transform.rb
 - test/test_helper.rb
 homepage: https://github.com/nebulab/moonshine
 licenses:
@@ -113,22 +120,28 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '2.0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>'
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.14
+rubygems_version: 2.3.0
 signing_key: 
 specification_version: 4
-summary: Conditional method chaining
+summary: A configuration driven method chain builder.
 test_files:
 - test/lib/moonshine/base_test.rb
 - test/lib/moonshine/filter_test.rb
 - test/lib/moonshine/version_test.rb
+- test/lib/moonshine_test.rb
+- test/support/empty_tale_generator.rb
+- test/support/tale.rb
+- test/support/tale_generator.rb
+- test/support/tale_transform.rb
 - test/test_helper.rb
+has_rdoc: