fluent_conditions 0.0.2 → 0.0.3

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/.rspec

@@ -0,0 +1 @@
+--colour

data/.travis.yml

@@ -0,0 +1,8 @@
+rvm:
+  - 1.8.7
+  - 1.9.2
+  - 1.9.3
+  - rbx-2.0
+  - jruby
+  - ruby-head
+  - ree

data/Gemfile

@@ -0,0 +1,5 @@
+source "http://rubygems.org"
+
+gem 'rake'
+
+gemspec

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2011 Tomasz Lipinski
+
+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,100 @@
+#Fluent Conditions
+Simplify your conditional expressions.
+
+[![Build Status](https://secure.travis-ci.org/pplcanfly/fluent_conditions.png)](http://travis-ci.org/pplcanfly/fluent_conditions)
+
+##Installation
+    gem install fluent_conditions
+
+##Examples
+
+###Basic usage with boolean fields
+
+    class User
+      include FluentConditions
+
+      attr_accessor :admin, :logged_in
+
+      fluent :admin
+      fluent :logged_in
+    end
+
+    user = User.new
+    user.admin = true
+    user.logged_in = true
+
+And instead of:
+
+    user.logged_in && user.admin
+
+Write it more fluently and DRY:
+
+    user.is.logged_in.admin? #=> true
+
+User class with FluentConditions module included provides *is* method and *is_not* method as well. It returns negated result of an expression. As an expression methods you may also use negated versions of *admin* and *logged_in* methods - *not_admin*, *not_logged_in*.
+
+*and* method is optional and in fact it does nothing except increasing readability in some cases.
+
+    user.is_not.logged_in.admin? #=> false
+    user.is.logged_in.and.not_admin? #=> false
+
+Only last method in expression should be followed by question mark.
+
+###:values
+
+This option defines a set of expression methods. It may be useful for fields with limited set of possible values:
+
+    class Product
+      include FluentConditions
+
+      attr_accessor :color
+
+      fluent :color, :values => [:red, :green, :blue]
+    end
+
+    product = Product.new
+    product.color = :red
+    product.is.red? # => true
+
+You can also use *or operator* in expressions:
+
+    product.is.red.or.green? #=> true
+    product.is.blue.or.green? #=> false
+
+*or operator* can be placed anywhere between two expression methods and it affects only them.
+
+So in the case below:
+
+    product.is.red.green.or.blue?
+
+Expression will be interpreted like:
+
+    product.color == :red && (product.color == :green || product.color == :blue)
+
+###:if
+
+The :if option allows you to define custom methods checking some conditions:
+
+    class Product
+      include FluentConditions
+
+      attr_accessor :price
+
+      fluent :price, :as => :cheap, :if => lambda {|price| price < 100}
+    end
+
+    product = Product.new
+    product.price = 1000
+    product.is.cheap? #=> false
+
+###OR
+
+With *big OR* you can build even more complex expressions. The difference between *OR* and *or* is how expression will be interpreted.
+
+For instance if we had a Fruit class with :name and :color attributes, each having some set of possible values, we could write expression like:
+
+    fruit.is.red.apple.OR.yellow.banana?
+
+This expression would be interpreted like:
+    
+    (fruit.color == :red && fruit.name == :apple) || (fruit.color == :yellow && fruit.name == :banana)

data/Rakefile

@@ -0,0 +1,10 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+desc 'Default: run specs.'
+task :default => :spec
+
+desc "Run specs"
+RSpec::Core::RakeTask.new do |t|
+  t.pattern = "./spec/**/*_spec.rb"
+end

data/fluent_conditions.gemspec

@@ -0,0 +1,20 @@
+$:.push File.expand_path("../lib", __FILE__)
+require 'fluent_conditions/version'
+
+Gem::Specification.new do |s|
+  s.name = "fluent_conditions"
+  s.version = FluentConditions::VERSION
+  s.required_ruby_version = '>= 1.8.7'
+
+  s.summary = "Simplifies complex conditions"
+
+  s.author = "pplcanfly"
+  s.homepage = "http://github.com/pplcanfly/fluent_conditions"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_development_dependency "rspec"
+end

data/lib/fluent_conditions.rb

@@ -1,7 +1,10 @@
+require File.expand_path('../fluent_conditions/condition_builder.rb', __FILE__)
+require File.expand_path('../fluent_conditions/accessor_definers.rb', __FILE__)
+
 module FluentConditions
 
   def self.included(base)
-    base.instance_variable_set(:@builder, Class.new(Builder))
+    base.instance_variable_set(:@builder, Class.new(ConditionBuilder))
 
     base.class_eval do
       include InstanceMethods
@@ -20,131 +23,14 @@ module FluentConditions
     end
   end
 
-  module ClassMethods
+   module ClassMethods
     def fluent(field, options = {})
-      builder = instance_variable_get(:@builder)
-
-      if options.include?(:values)
-        options[:values].each do |value|
-          builder.class_eval do
-            define_method(value) do
-              update_and_continue(instance_variable_get(:@object).send(field) == value)
-            end
-
-            define_method("#{value}?") do
-              update_and_finish(instance_variable_get(:@object).send(field) == value)
-            end
-
-            define_method("not_#{value}") do
-              update_and_continue(instance_variable_get(:@object).send(field) != value)
-            end
-
-            define_method("not_#{value}?") do
-              update_and_finish(instance_variable_get(:@object).send(field) != value)
-            end
-          end
-        end
-      elsif options.include?(:if)
-        field_name = options[:as]
-        condition_check = options[:if]
-
-        builder.class_eval do
-          define_method(field_name) do
-            update_and_continue(condition_check.call(instance_variable_get(:@object).send(field)))
-          end
-
-          define_method("#{field_name}?") do
-            update_and_finish(condition_check.call(instance_variable_get(:@object).send(field)))
-          end
-
-          define_method("not_#{field_name}") do
-            update_and_continue(!condition_check.call(instance_variable_get(:@object).send(field)))
-          end
+      accessor_definer = AccessorDefinerFactory.make_for(options)
+      condition_builder = instance_variable_get(:@builder)
 
-          define_method("not_#{field_name}?") do
-            update_and_finish(!condition_check.call(instance_variable_get(:@object).send(field)))
-          end
-        end
-      else 
-        builder.class_eval do
-          define_method(field) do
-            update_and_continue(instance_variable_get(:@object).send(field))
-          end
-
-          define_method("#{field}?") do
-            update_and_finish(instance_variable_get(:@object).send(field))
-          end
-
-          define_method("not_#{field}") do
-            update_and_continue(!instance_variable_get(:@object).send(field))
-          end
-
-          define_method("not_#{field}?") do
-            update_and_finish(!instance_variable_get(:@object).send(field))
-          end
-        end
-      end
+      accessor_definer.define(condition_builder, field)
     end
   end
 
-
-  class Builder
-    def initialize(object, type)
-      @object = object
-      @type = type
-      @previous, @current, @big_or = true, true, false
-    end
-
-    def or
-      @or_flag = true
-      self
-    end
-
-    def OR
-      @big_or = @big_or || result
-      @big_or_flag = true
-      @previous, @current = true, true
-      self
-    end
-
-    def and
-      self
-    end
-
-    private
-
-    def update_and_continue(field_value)
-      update_result(field_value)
-      self
-    end
-
-    def update_and_finish(field_value)
-      update_result(field_value)
-      end_result
-    end
-
-    def update_result(field_value)
-      if @or_flag
-        @current = @current || field_value
-        @or_flag = false
-      else
-        @previous, @current = @previous && @current, field_value
-      end
-    end
-
-    def end_result
-      if @big_or_flag
-        return (@big_or || result) if @type == :positive
-        return !(@big_or || result) if @type == :negative
-      end
-      return result if @type == :positive
-      return !result if @type == :negative
-    end
-
-    def result
-      @previous && @current 
-    end
-
-  end
 end
 

data/lib/fluent_conditions/accessor_definers.rb

@@ -0,0 +1,123 @@
+module FluentConditions
+  class AccessorDefinerFactory
+    def self.make_for(options)
+      if options.include?(:values)
+        TextValueAccessorDefiner.new(options)
+      elsif options.include?(:if)
+        CustomAccessorDefiner.new(options)
+      else
+        BooleanAccessorDefiner.new(options)
+      end
+    end
+  end
+
+  class FluentAccessorMethod
+    def initialize(name)
+      @name = name
+    end
+
+    def positive_check
+      @name
+    end
+
+    def negative_check
+      "not_#{@name}"
+    end
+
+    def positive_check_with_result
+      "#{@name}?"
+    end
+
+    def negative_check_with_result
+      "not_#{@name}?"
+    end
+  end
+
+  class TextValueAccessorDefiner
+    def initialize(options)
+      @options = options
+    end
+
+    def define(builder, field)
+      @options[:values].each do |value|
+        accessor_method = FluentAccessorMethod.new(value)
+
+        builder.class_eval do
+          define_method(accessor_method.positive_check) do
+            update_and_continue(instance_variable_get(:@object).send(field) == value)
+          end
+
+          define_method(accessor_method.positive_check_with_result) do
+            update_and_finish(instance_variable_get(:@object).send(field) == value)
+          end
+
+          define_method(accessor_method.negative_check) do
+            update_and_continue(instance_variable_get(:@object).send(field) != value)
+          end
+
+          define_method(accessor_method.negative_check_with_result) do
+            update_and_finish(instance_variable_get(:@object).send(field) != value)
+          end
+        end
+      end
+    end
+  end
+
+  class CustomAccessorDefiner
+    def initialize(options)
+      @options = options
+    end
+
+    def define(builder, field)
+      field_name = @options[:as]
+      condition_check = @options[:if]
+      accessor_method = FluentAccessorMethod.new(field_name)
+
+      builder.class_eval do
+        define_method(accessor_method.positive_check) do
+          update_and_continue(condition_check.call(instance_variable_get(:@object).send(field)))
+        end
+
+        define_method(accessor_method.positive_check_with_result) do
+          update_and_finish(condition_check.call(instance_variable_get(:@object).send(field)))
+        end
+
+        define_method(accessor_method.negative_check) do
+          update_and_continue(!condition_check.call(instance_variable_get(:@object).send(field)))
+        end
+
+        define_method(accessor_method.negative_check_with_result) do
+          update_and_finish(!condition_check.call(instance_variable_get(:@object).send(field)))
+        end
+      end
+    end
+  end
+
+  class BooleanAccessorDefiner
+    def initialize(options)
+      @options = options
+    end
+
+    def define(builder, field)
+      accessor_method = FluentAccessorMethod.new(field)
+
+      builder.class_eval do
+        define_method(accessor_method.positive_check) do
+          update_and_continue(instance_variable_get(:@object).send(field))
+        end
+
+        define_method(accessor_method.positive_check_with_result) do
+          update_and_finish(instance_variable_get(:@object).send(field))
+        end
+
+        define_method(accessor_method.negative_check) do
+          update_and_continue(!instance_variable_get(:@object).send(field))
+        end
+
+        define_method(accessor_method.negative_check_with_result) do
+          update_and_finish(!instance_variable_get(:@object).send(field))
+        end
+      end
+    end
+  end
+end

data/lib/fluent_conditions/condition_builder.rb

@@ -0,0 +1,64 @@
+module FluentConditions
+  class ConditionBuilder
+    def initialize(object, type)
+      @object = object
+      @type = type
+      @previous, @current, @big_or = true, true, false
+    end
+
+    def or
+      @or_used = true
+      self
+    end
+
+    def OR
+      update_big_or_result
+      @big_or_used = true
+      self
+    end
+
+    def and
+      self
+    end
+
+    private
+
+    def update_and_continue(field_value)
+      update_current_result(field_value)
+      self
+    end
+
+    def update_and_finish(field_value)
+      update_current_result(field_value)
+      update_big_or_result if @big_or_used
+      end_result
+    end
+
+    def update_current_result(field_value)
+      if @or_used
+        @current = @current || field_value
+        @or_used = false
+      else
+        @previous, @current = @previous && @current, field_value
+      end
+    end
+
+    def update_big_or_result
+      @big_or = @big_or || current_result
+      @previous, @current = true, true
+    end
+
+    def current_result
+      @previous && @current 
+    end
+
+    def end_result
+      @type == :positive ? sub_result : !sub_result
+    end
+
+    def sub_result
+      @big_or_used ? @big_or : current_result
+    end
+
+  end
+end

data/lib/fluent_conditions/version.rb

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

data/spec/fluent_conditions/accessor_definers_spec.rb

@@ -0,0 +1,63 @@
+require 'spec_helper'
+
+module FluentConditions
+
+  describe BooleanAccessorDefiner do
+    it "should add accessor methods" do
+      clazz = Class.new do
+        include FluentConditions
+        attr_accessor :admin
+        fluent :admin
+      end
+      @obj = clazz.new
+
+      @obj.is.should respond_to(:admin)
+      @obj.is.should respond_to(:admin?)
+      @obj.is.should respond_to(:not_admin)
+      @obj.is.should respond_to(:not_admin?)
+    end
+  end
+
+  describe TextValueAccessorDefiner do
+    it "should add accessor methods" do
+      clazz = Class.new do
+        include FluentConditions
+        attr_accessor :color
+        fluent :color, :values => [:red, :green]
+      end
+      @product = clazz.new
+
+      @product.is.should respond_to(:red)
+      @product.is.should respond_to(:green)
+      @product.is.should respond_to(:not_red)
+      @product.is.should respond_to(:not_green)
+
+      @product.is.should respond_to(:red?)
+      @product.is.should respond_to(:green?)
+      @product.is.should respond_to(:not_red?)
+      @product.is.should respond_to(:not_green?)
+    end
+  end
+
+  describe CustomAccessorDefiner do
+    it "should add accessor methods" do
+      clazz = Class.new do
+        include FluentConditions
+        attr_accessor :length
+        fluent :length, :as => :long, :if => proc { |length| length >= 500 }
+        fluent :length, :as => :short, :if => proc { |length| length < 500 }
+      end
+      @post = clazz.new
+      @post.is.should respond_to(:long)
+      @post.is.should respond_to(:not_long)
+      @post.is.should respond_to(:long?)
+      @post.is.should respond_to(:not_long?)
+
+      @post.is.should respond_to(:short)
+      @post.is.should respond_to(:not_short)
+      @post.is.should respond_to(:short?)
+      @post.is.should respond_to(:not_short?)
+    end
+  end
+
+end

data/spec/fluent_conditions/{builder_spec.rb → condition_builder_spec.rb}

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 module FluentConditions
 
-  describe Builder do
+  describe ConditionBuilder do
 
     describe "checking simple boolean conditions" do
       before(:each) do
@@ -14,13 +14,6 @@ module FluentConditions
         @obj = clazz.new
       end
 
-      it "should respond to added methods" do
-        @obj.is.should respond_to(:admin)
-        @obj.is.should respond_to(:admin?)
-        @obj.is.should respond_to(:not_admin)
-        @obj.is.should respond_to(:not_admin?)
-      end
-
       it "should check for admin user if it's admin or not" do
         @obj.admin = true
         @obj.is.admin?.should be_true
@@ -59,18 +52,27 @@ module FluentConditions
         @obj.good = true
         @obj.bad = true
         @obj.is.good.bad?.should be_true
+        @obj.is.not_good.bad?.should be_false
+        @obj.is.good.not_bad?.should be_false
+        @obj.is.not_good.not_bad?.should be_false
       end
 
       it "should check two true/false conditions" do
         @obj.good = true
         @obj.bad = false
         @obj.is.good.bad?.should be_false
+        @obj.is.not_good.bad?.should be_false
+        @obj.is.good.not_bad?.should be_true
+        @obj.is.not_good.not_bad?.should be_false
       end
 
       it "should check two false conditions" do
         @obj.good = false
         @obj.bad = false
         @obj.is.good.bad?.should be_false
+        @obj.is.not_good.bad?.should be_false
+        @obj.is.good.not_bad?.should be_false
+        @obj.is.not_good.not_bad?.should be_true
       end
     end
 
@@ -153,28 +155,21 @@ module FluentConditions
         @product = clazz.new
       end
 
-      it "should respond to accesor methods" do
-        @product.is.should respond_to(:red)
-        @product.is.should respond_to(:green)
-        @product.is.should respond_to(:not_red)
-        @product.is.should respond_to(:not_green)
-
-        @product.is.should respond_to(:red?)
-        @product.is.should respond_to(:green?)
-        @product.is.should respond_to(:not_red?)
-        @product.is.should respond_to(:not_green?)
-      end
-
       it "should check condition by value" do
         @product.color = :red
 
         @product.is.red?.should be_true
+        @product.is.not_red?.should be_false
+
         @product.is.green?.should be_false
+        @product.is.not_green?.should be_true
+
         @product.is.red.and.green?.should be_false
-        @product.is.red.or.green?.should be_true
+        @product.is.not_red.and.green?.should be_false
+        @product.is.red.and.not_green?.should be_true
+        @product.is.not_red.and.not_green?.should be_false
 
-        @product.is.not_red?.should be_false
-        @product.is.not_green?.should be_true
+        @product.is.red.or.green?.should be_true
       end
     end
 
@@ -189,25 +184,19 @@ module FluentConditions
         @post = clazz.new
       end
 
-      it "should respond to new methods" do
-        @post.is.should respond_to(:long)
-        @post.is.should respond_to(:not_long)
-        @post.is.should respond_to(:long?)
-        @post.is.should respond_to(:not_long?)
-
-        @post.is.should respond_to(:short)
-        @post.is.should respond_to(:not_short)
-        @post.is.should respond_to(:short?)
-        @post.is.should respond_to(:not_short?)
-      end
-
       it "should check condition defined by user" do
         @post.length = 600
 
         @post.is.long?.should be_true
         @post.is.not_long?.should be_false
+
         @post.is.short?.should be_false
         @post.is.short.or.long?.should be_true
+
+        @post.is.long.and.short?.should be_false
+        @post.is.long.and.not_short?.should be_true
+        @post.is.not_long.and.short?.should be_false
+        @post.is.not_long.and.not_short?.should be_false
       end
     end
 

data/spec/fluent_conditions/fluent_conditions_spec.rb

@@ -20,8 +20,8 @@ module FluentConditions
         @obj.should respond_to(:is)
       end
 
-      it "should return Builder object when calling 'is'" do
-        @obj.is.should be_kind_of(Builder)
+      it "should return ConditionBuilder object when calling 'is'" do
+        @obj.is.should be_kind_of(ConditionBuilder)
       end
 
       it "should return new builder each time" do

data/spec/spec_helper.rb

@@ -1 +1,4 @@
+require 'simplecov'
+SimpleCov.start
+
 require 'fluent_conditions'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fluent_conditions
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
   prerelease: 
 platform: ruby
 authors:
@@ -9,19 +9,42 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-09-18 00:00:00.000000000 +02:00
+date: 2011-11-09 00:00:00.000000000 +01:00
 default_executable: 
-dependencies: []
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &15565060 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *15565060
 description: 
 email: 
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- .gitignore
+- .rspec
+- .travis.yml
+- Gemfile
+- MIT-LICENSE
+- README.md
+- Rakefile
+- fluent_conditions.gemspec
 - lib/fluent_conditions.rb
-- spec/spec_helper.rb
+- lib/fluent_conditions/accessor_definers.rb
+- lib/fluent_conditions/condition_builder.rb
+- lib/fluent_conditions/version.rb
+- spec/fluent_conditions/accessor_definers_spec.rb
+- spec/fluent_conditions/condition_builder_spec.rb
 - spec/fluent_conditions/fluent_conditions_spec.rb
-- spec/fluent_conditions/builder_spec.rb
+- spec/spec_helper.rb
 has_rdoc: true
 homepage: http://github.com/pplcanfly/fluent_conditions
 licenses: []