fluent_conditions 0.0.2

data/lib/fluent_conditions.rb

@@ -0,0 +1,150 @@
+module FluentConditions
+
+  def self.included(base)
+    base.instance_variable_set(:@builder, Class.new(Builder))
+
+    base.class_eval do
+      include InstanceMethods
+    end
+
+    base.extend ClassMethods
+  end
+
+  module InstanceMethods
+    def is
+      self.class.instance_variable_get(:@builder).new(self, :positive)
+    end
+
+    def is_not
+      self.class.instance_variable_get(:@builder).new(self, :negative)
+    end
+  end
+
+  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
+
+          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
+    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/spec/fluent_conditions/builder_spec.rb

@@ -0,0 +1,240 @@
+require 'spec_helper'
+
+module FluentConditions
+
+  describe Builder do
+
+    describe "checking simple boolean conditions" do
+      before(:each) do
+        clazz = Class.new do
+          include FluentConditions
+          attr_accessor :admin
+          fluent :admin
+        end
+        @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
+        @obj.is.not_admin?.should be_false
+      end
+
+      it "should check for non admin user if it's admin or not" do
+        @obj.admin = false
+        @obj.is.admin?.should be_false
+        @obj.is.not_admin?.should be_true
+      end
+
+      it "should treat nil as false value" do
+        @obj.admin = nil
+        @obj.is.admin?.should be_false
+      end
+
+      it "should check negative condition" do
+        @obj.admin = false
+        @obj.is_not.admin?.should be_true
+      end
+    end
+
+    describe "more than one condition" do
+      before(:each) do
+        clazz = Class.new do
+          include FluentConditions
+          attr_accessor :good, :bad
+          fluent :good
+          fluent :bad
+        end
+        @obj = clazz.new
+      end
+
+      it "should check two true conditions" do
+        @obj.good = true
+        @obj.bad = true
+        @obj.is.good.bad?.should be_true
+      end
+
+      it "should check two true/false conditions" do
+        @obj.good = true
+        @obj.bad = false
+        @obj.is.good.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
+      end
+    end
+
+    describe "with or" do
+      before(:each) do
+        clazz = Class.new do
+          include FluentConditions
+          attr_accessor :good, :bad
+          fluent :good
+          fluent :bad
+        end
+        @obj = clazz.new
+      end
+
+      it "should check two true conditions" do
+        @obj.good = true
+        @obj.bad = true
+        @obj.is.good.or.bad?.should be_true
+      end
+
+      it "should check two true/false conditions" do
+        @obj.good = true
+        @obj.bad = false
+        @obj.is.good.or.bad?.should be_true
+      end
+
+      it "should check two false conditions" do
+        @obj.good = false
+        @obj.bad = false
+        @obj.is.good.or.bad?.should be_false
+      end
+    end
+
+    describe "complex conditions" do
+      before(:each) do
+        clazz = Class.new do
+          include FluentConditions
+          attr_accessor :good, :bad, :ugly
+          fluent :good
+          fluent :bad
+          fluent :ugly
+        end
+        @obj = clazz.new
+      end
+
+      it "should pass them all" do
+        @obj.good = true
+        @obj.bad = false
+        @obj.ugly = true
+
+        @obj.is.good.bad.ugly?.should be_false
+        @obj.is.good.ugly.bad?.should be_false
+        @obj.is.good.bad.or.ugly?.should be_true
+        @obj.is.good.or.bad.and.ugly?.should be_true
+        @obj.is.good.ugly.or.bad?.should be_true
+
+        @obj.is.bad.good.ugly?.should be_false
+        @obj.is.bad.ugly.good?.should be_false
+        @obj.is.bad.and.good.or.ugly?.should be_false
+        @obj.is.bad.ugly.or.good?.should be_false
+        @obj.is.bad.or.good.and.ugly?.should be_true
+
+        @obj.is.ugly.good.bad?.should be_false
+        @obj.is.ugly.bad.good?.should be_false
+        @obj.is.ugly.or.good.and.bad?.should be_false
+        @obj.is.ugly.good.and.bad?.should be_false
+        @obj.is.ugly.good.or.bad?.should be_true
+
+        @obj.is_not.good.bad.and.ugly?.should be_true
+      end
+    end
+
+    describe "when values were defined" do
+      before(:each) do
+        clazz = Class.new do
+          include FluentConditions
+          attr_accessor :color
+          fluent :color, :values => [:red, :green]
+        end
+        @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.green?.should be_false
+        @product.is.red.and.green?.should be_false
+        @product.is.red.or.green?.should be_true
+
+        @product.is.not_red?.should be_false
+        @product.is.not_green?.should be_true
+      end
+    end
+
+    describe "when condition check defined by user" do
+      before(:each) 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
+      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
+      end
+    end
+
+    describe "when big OR used" do
+      before(:each) do
+        clazz = Class.new do
+          include FluentConditions
+          attr_accessor :name, :color
+          fluent :name, :values => [:apple, :grass, :sky]
+          fluent :color, :values => [:red, :green, :blue]
+        end
+        @thing = clazz.new
+      end
+
+      it "should check conditions with OR" do
+        @thing.name = :apple
+        @thing.color = :red
+
+        @thing.is.green.grass.OR.red.apple?.should be_true
+        @thing.is.red.apple.OR.green.grass?.should be_true
+        @thing.is.blue.sky.OR.green.grass?.should be_false
+
+        @thing.is_not.red.apple.OR.green.grass?.should be_false
+        @thing.is_not.red.apple.OR.green.grass?.should be_false
+        @thing.is_not.blue.sky.OR.green.grass?.should be_true
+      end
+    end
+  end
+
+end

data/spec/fluent_conditions/fluent_conditions_spec.rb

@@ -0,0 +1,84 @@
+require 'spec_helper'
+
+module FluentConditions
+
+  describe FluentConditions do
+
+    describe "when module indluded" do
+      before(:each) do
+        clazz = Class.new do
+          include FluentConditions
+        end
+        @obj = clazz.new
+      end
+
+      it "should provide 'fluent' method now" do
+        @obj.class.should respond_to(:fluent)
+      end
+
+      it "should provide 'is' method now" do
+        @obj.should respond_to(:is)
+      end
+
+      it "should return Builder object when calling 'is'" do
+        @obj.is.should be_kind_of(Builder)
+      end
+
+      it "should return new builder each time" do
+        @obj.is.object_id.should_not == @obj.is.object_id
+      end
+    end
+
+    describe "when included to different classes" do
+      before(:each) do
+        class User
+          include FluentConditions
+          attr_accessor :admin
+          fluent :admin
+        end
+        @user = User.new
+      end
+
+      describe "not in hierarchy" do
+        before(:each) do
+          class Color
+            include FluentConditions
+            attr_accessor :blue
+            fluent :blue
+          end
+          @color = Color.new
+        end
+
+        it "should provide builders of different classes" do
+          @user.is.class.should_not == @color.is.class
+        end
+
+        it "should not respond to other's builder accessors" do
+          @user.is.should_not respond_to(:blue)
+          @color.is.should_not respond_to(:admin)
+        end
+      end
+
+      describe "in hierarchy" do
+        before(:each) do
+          class Employee < User
+            include FluentConditions
+            attr_accessor :manager
+            fluent :manager
+          end
+          @employee = Employee.new
+        end
+
+        it "should provide builders of different classes" do
+          @user.is.class.should_not == @employee.is.class
+        end
+
+        it "should not respond to other's builder accessors" do
+          @user.is.should_not respond_to(:manager)
+          @employee.is.should_not respond_to(:admin)
+        end
+      end
+    end
+
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1 @@
+require 'fluent_conditions'

metadata

@@ -0,0 +1,50 @@
+--- !ruby/object:Gem::Specification
+name: fluent_conditions
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+  prerelease: 
+platform: ruby
+authors:
+- pplcanfly
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-09-18 00:00:00.000000000 +02:00
+default_executable: 
+dependencies: []
+description: 
+email: 
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/fluent_conditions.rb
+- spec/spec_helper.rb
+- spec/fluent_conditions/fluent_conditions_spec.rb
+- spec/fluent_conditions/builder_spec.rb
+has_rdoc: true
+homepage: http://github.com/pplcanfly/fluent_conditions
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.8.7
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: Simplifies complex conditions
+test_files: []