conditions_fu 0.5.0

data/History.txt

@@ -0,0 +1,4 @@
+== 1.0.0 / 2010-01-03
+
+* 1 major enhancement
+  * Birthday!

data/README.txt

@@ -0,0 +1,74 @@
+conditions_fu
+    by Cameron Barrie
+    http://wiki.github.com/whalec/conditions_fu
+
+== DESCRIPTION:
+
+A little DSL to allow you to map url parameters to an Active Record conditions array.
+
+== TODO:
+Everything. I've only onlined my intentions here.
+
+== FEATURES/PROBLEMS:
+
+  allows you to map rules to url parameters when posting from a form with a get. 
+  
+  i.e. if you're request was:
+  http://local.host/users/search?admin=1&email=camwritescode
+  
+  it would map to an active record conditions array like
+  
+  ["admin IS ? and email ~* ?", true, 'camwritescode']
+
+== SYNOPSIS:
+
+ConditionsFu::Builder.blueprint(:user) do
+  is_true("admin" => params[:admin])
+  includes({:parents_last_name => params[:surname]}, :or) do
+    includes({:last_name => params[:surname]}, :or)
+    is_like("parent_email" => params[:email]) do
+      is_true(:child => params[:child])
+    end
+  end
+end
+params = {:surname => "Barrie", :email => "cam@snepo.com", :child => false, :admin => true}
+conditions = ConditionsFu::Builder.make(params) 
+# => ["admin = ? AND (parents_last_name ~* ? OR last_name ~* ? OR (parent_email ILIKE ? AND child = ?))", true, "Barrie", "Barrie", "%cam@snepo.com%", true]
+
+So then you can
+User.find(:all, :conditions => ConditionsFu::Builder.make(params))
+
+For more examples check the specs directory.
+
+== REQUIREMENTS:
+
+Currently it only works for Postgres as it's the only DB that I work with. Patches are happily accepted though :D
+
+== INSTALL:
+
+sudo gem install conditions_fu
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2009 FIXME (different 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/Rakefile

@@ -0,0 +1,22 @@
+
+begin
+  require 'bones'
+rescue LoadError
+  abort '### Please install the "bones" gem ###'
+end
+
+ensure_in_path 'lib'
+require 'conditions_fu'
+
+task :default => 'test:run'
+task 'gem:release' => 'test:run'
+
+Bones {
+  name  'conditions_fu'
+  authors  'Cameron Barrie'
+  email  'camwritescode@gmail.com'
+  url  'http://wiki.github.com/whalec/conditions_fu'
+  version  ConditionsFu::VERSION
+}
+
+# EOF

data/lib/conditions_fu/builder.rb

@@ -0,0 +1,184 @@
+module ConditionsFu
+  
+  class ConditionsArray < Array
+    
+    def initialize(*args)
+      super
+    end
+    
+    def create_active_record_conditions
+      conditions = ""
+      self.each do |condition|
+        if self.last == condition
+          conditions << "#{condition[0]}"
+        else
+          conditions << "#{condition[0]} #{condition[2]} "
+        end
+      end
+      [conditions.strip, self.map{|i| i[1]}].flatten
+    end
+    
+  end
+  
+  class Lathe
+    
+    def self.run(*args)
+      blueprint = Builder.blueprint
+      if args.first.is_a?(Symbol)
+        named_blueprint = Builder.blueprint(args.shift) 
+        raise "No blueprint found" if named_blueprint.nil?
+      end
+      lathe = self.new(args.shift)
+      lathe.instance_eval(&named_blueprint) if named_blueprint
+      lathe.conditions.create_active_record_conditions
+    end
+    
+    attr_reader :conditions 
+    
+    def initialize(_params)
+      @params = _params
+      @conditions = ConditionsArray.new
+    end
+    
+    def params
+      @params
+    end
+    
+    private
+    
+    # Warning: Postgres ONLY
+    def includes(options = {}, binding = :and, &block)
+      return if options.values.include?(nil)
+      if block_given?
+        @conditions << ["(#{options.keys.first} ~* ?", options.values.first, binding.to_s.upcase]
+        yield
+        @conditions.last.first << ")"
+      else
+        @conditions << ["#{options.keys.first} ~* ?", options.values.first, binding.to_s.upcase]
+      end
+    end
+
+    #Warning: Postgres ONLY
+    def is_like(options = {}, binding = :and, &block)
+      return if options.values.include?(nil)
+      if block_given?
+        @conditions << ["(#{options.keys.first} ILIKE ?", "%#{options.values.first}%", binding.to_s.upcase]
+        yield
+        @conditions.last.first << ")"
+      else
+        @conditions << ["#{options.keys.first} ILIKE ?", "%#{options.values.first}%", binding.to_s.upcase]
+      end
+    end
+
+    def not_equal_to(options = {}, binding = :and, &block)
+      return if options.values.include?(nil)
+      if block_given?
+        @conditions << ["(#{options.keys.first} != ?", options.values.first, binding.to_s.upcase]
+        yield
+        @conditions.last.first << ")"
+      else
+        @conditions << ["#{options.keys.first} != ?", options.values.first, binding.to_s.upcase]
+      end
+    end
+
+    def equal_to(options = {}, binding = :and, &block)
+      return if options.values.include?(nil)
+      if block_given?
+        @conditions << ["(#{options.keys.first} = ?", options.values.first, binding.to_s.upcase]
+        yield
+        @conditions.last.first << ")"
+      else
+        @conditions << ["#{options.keys.first} = ?", options.values.first, binding.to_s.upcase]
+      end
+    end
+
+    def greater_than_or_equal_to(options = {}, binding = :and, &block)
+      return if options.values.include?(nil)
+      if block_given?
+        @conditions << ["(#{options.keys.first} >= ?", options.values.first, binding.to_s.upcase]
+        yield
+        @conditions.last.first << ")"
+      else
+        @conditions << ["#{options.keys.first} >= ?", options.values.first, binding.to_s.upcase]
+      end
+    end
+
+    def greater_than(options = {}, binding = :and, &block)
+      return if options.values.include?(nil)
+      if block_given?
+        @conditions << ["(#{options.keys.first} > ?", options.values.first, binding.to_s.upcase]
+        yield
+        @conditions.last.first << ")"
+      else
+        @conditions << ["#{options.keys.first} > ?", options.values.first, binding.to_s.upcase]
+      end
+    end
+
+    def less_than_or_equal_to(options = {}, binding = :and, &block)
+      return if options.values.include?(nil)
+      if block_given?
+        @conditions << ["(#{options.keys.first} <= ?", options.values.first, binding.to_s.upcase]
+        yield
+        @conditions.last.first << ")"
+      else
+        @conditions << ["#{options.keys.first} <= ?", options.values.first, binding.to_s.upcase]
+      end
+    end
+
+    def less_than(options = {}, binding = :and, &block)
+      return if options.values.include?(nil)
+      if block_given?
+        @conditions << ["(#{options.keys.first} < ?", options.values.first, binding.to_s.upcase]
+        yield
+        @conditions.last.first << ")"
+      else
+        @conditions << ["#{options.keys.first} < ?", options.values.first, binding.to_s.upcase]
+      end
+    end
+
+    def is_true(options = {}, binding = :and, &block)
+      return if options.values.include?(nil)
+      if block_given?
+        @conditions << ["(#{options.keys.first} = ?", true, binding.to_s.upcase]
+        yield
+        @conditions.last.first << ")"
+      else
+        @conditions << ["#{options.keys.first} = ?", true, binding.to_s.upcase]
+      end
+    end
+
+    def is_false(options = {}, binding = :and, &block)
+      return if options.values.include?(nil)
+      if block_given?
+        @conditions << ["(#{options.keys.first} IS NOT ?", true, binding.to_s.upcase]
+        yield
+        @conditions.last.first << ")"
+      else
+        @conditions << ["#{options.keys.first} IS NOT ?", true, binding.to_s.upcase]
+      end
+    end
+    
+  end
+  
+  class Builder
+
+    def self.blueprint(name = :master, &blueprint)
+      @conditions = ConditionsArray.new
+      @prints ||= {}
+      @prints[name] = blueprint if block_given?
+      @prints[name]
+    end
+    
+    def self.make(blueprint, params)
+      Lathe.run(blueprint, params)
+    end
+    
+    def self.named_blueprints
+      @blueprints.reject{|name,_| name == :master }.keys
+    end
+  
+    def self.clear_blueprints!
+      @blueprints = {}
+    end
+  end
+end

data/lib/conditions_fu.rb

@@ -0,0 +1,48 @@
+
+module ConditionsFu
+
+  # :stopdoc:
+  VERSION = '0.5.0'
+  LIBPATH = ::File.expand_path(::File.dirname(__FILE__)) + ::File::SEPARATOR
+  PATH = ::File.dirname(LIBPATH) + ::File::SEPARATOR
+  # :startdoc:
+
+  # Returns the version string for the library.
+  #
+  def self.version
+    VERSION
+  end
+
+  # Returns the library path for the module. If any arguments are given,
+  # they will be joined to the end of the libray path using
+  # <tt>File.join</tt>.
+  #
+  def self.libpath( *args )
+    args.empty? ? LIBPATH : ::File.join(LIBPATH, args.flatten)
+  end
+
+  # Returns the lpath for the module. If any arguments are given,
+  # they will be joined to the end of the path using
+  # <tt>File.join</tt>.
+  #
+  def self.path( *args )
+    args.empty? ? PATH : ::File.join(PATH, args.flatten)
+  end
+
+  # Utility method used to require all files ending in .rb that lie in the
+  # directory below this file that has the same name as the filename passed
+  # in. Optionally, a specific _directory_ name can be passed in such that
+  # the _filename_ does not have to be equivalent to the directory.
+  #
+  def self.require_all_libs_relative_to( fname, dir = nil )
+    dir ||= ::File.basename(fname, '.*')
+    search_me = ::File.expand_path(
+        ::File.join(::File.dirname(fname), dir, '**', '*.rb'))
+
+    Dir.glob(search_me).sort.each {|rb| require rb}
+  end
+
+end  # module ConditionsFu
+
+ConditionsFu.require_all_libs_relative_to(__FILE__)
+

data/spec/conditions_fu/builder_spec.rb

@@ -0,0 +1,83 @@
+require File.join(File.dirname(__FILE__), %w[../ spec_helper])
+describe ConditionsFu::Builder do
+  
+  it "should initialize" do
+    ConditionsFu::Builder.blueprint(:user) do
+      is_true     "admin"             => params[:content] if params[:admin]  == "1"
+      includes    "parents_last_name" => params[:content] if params[:filter] == "surname" && !params[:content].nil?
+      is_like     "parent_email"      => params[:content] if params[:filter] == "emails" && !params[:content].nil?
+      is_like     "nickname"          => params[:content] if params[:filter] == "nickname" && !params[:content].nil?
+      is_like     "locations.name"    => params[:content] if params[:filter] == "location" && !params[:content].nil?
+    end
+  end
+  
+  it "should be able to return an ActiveRecord conditions array" do    
+    params = {:admin => "1", :filter => "emails", :content => "cameron@snepo.com"}
+    parameters = ConditionsFu::Builder.make(:user, params)
+    parameters.should eql(["admin = ? AND parent_email ILIKE ?", true, "%cameron@snepo.com%"])
+  end
+  
+  it "should bind conditions" do
+    ConditionsFu::Builder.blueprint(:master) do
+      is_true     "admin"             => params[:admin]
+      includes    "parents_last_name" => params[:surname]
+      is_like     "parent_email"      => params[:email]
+      is_like     "nick"              => params[:nickname]
+      is_like     "locations.name"    => params[:location]
+    end
+    
+    params = {:admin => "1", :surname => "Barrie", :email => "snepo.com", :nickname => "whalec", :location => "Annandale"}
+    parameters = ConditionsFu::Builder.make(:master, params)
+    parameters.should eql(["admin = ? AND parents_last_name ~* ? AND parent_email ILIKE ? AND nick ILIKE ? AND locations.name ILIKE ?", true, "Barrie", "%snepo.com%", "%whalec%", "%Annandale%"])
+  end
+  
+  it "should bind only conditions that are passed in" do
+    ConditionsFu::Builder.blueprint(:master) do
+      is_true     "admin"             => params[:admin]
+      includes    "parents_last_name" => params[:surname]
+      is_like     "parent_email"      => params[:email]
+      is_like     "nick"              => params[:nickname]
+      is_like     "locations.name"    => params[:location]
+    end
+    
+    params = {:admin => "1", :surname => "Barrie"}
+    parameters = ConditionsFu::Builder.make(:master, params)
+    parameters.should eql(["admin = ? AND parents_last_name ~* ?", true, "Barrie"])
+  end
+  
+  it "should be able to bind conditions with an OR statement" do
+    ConditionsFu::Builder.blueprint(:or_binding) do
+      is_true("admin" => params[:admin])
+      includes({:parents_last_name => params[:surname]}, :or) do
+        includes({:last_name => params[:surname]})
+      end
+      is_like("nick" => params[:nickname])
+      is_like("locations.name" => params[:location])
+      is_like("parent_email" => params[:email])
+    end
+    
+    params = {:surname => "Barrie", :email => "cam@snepo.com", :admin => true}
+    parameters = ConditionsFu::Builder.make(:or_binding, params)
+    parameters.should eql(["admin = ? AND (parents_last_name ~* ? OR last_name ~* ?) AND parent_email ILIKE ?", 
+                          true, "Barrie", "Barrie", "%cam@snepo.com%"])
+  end
+  
+  it "should bind and number of conditions together in parenthesis" do
+    ConditionsFu::Builder.blueprint(:or_binding) do
+      is_true("admin" => params[:admin])
+      includes({:parents_last_name => params[:surname]}, :or) do
+        includes({:last_name => params[:surname]}, :or)
+        is_like("parent_email" => params[:email]) do
+          is_true(:child => params[:child])
+        end
+      end
+    end
+    
+    params = {:surname => "Barrie", :email => "cam@snepo.com", :child => false, :admin => true}
+    parameters = ConditionsFu::Builder.make(:or_binding, params)
+    expectation = ["admin = ? AND (parents_last_name ~* ? OR last_name ~* ? OR (parent_email ILIKE ? AND child = ?))", 
+                    true, "Barrie", "Barrie", "%cam@snepo.com%", true]
+    parameters.should eql(expectation)
+  end
+  
+end

data/spec/conditions_fu_spec.rb

@@ -0,0 +1,6 @@
+
+require File.join(File.dirname(__FILE__), %w[spec_helper])
+
+describe ConditionsFu do
+end
+

data/spec/spec_helper.rb

@@ -0,0 +1,16 @@
+require 'rubygems'
+require 'spec'
+require File.expand_path(
+    File.join(File.dirname(__FILE__), %w[.. lib conditions_fu]))
+
+Spec::Runner.configure do |config|
+  # == Mock Framework
+  #
+  # RSpec uses it's own mocking framework by default. If you prefer to
+  # use mocha, flexmock or RR, uncomment the appropriate line:
+  #
+  # config.mock_with :mocha
+  # config.mock_with :flexmock
+  # config.mock_with :rr
+end
+

metadata

@@ -0,0 +1,74 @@
+--- !ruby/object:Gem::Specification 
+name: conditions_fu
+version: !ruby/object:Gem::Version 
+  version: 0.5.0
+platform: ruby
+authors: 
+- Cameron Barrie
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-01-06 00:00:00 +11:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: bones
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 3.2.0
+    version: 
+description: A little DSL to allow you to map url parameters to an Active Record conditions array.
+email: camwritescode@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- History.txt
+- README.txt
+files: 
+- History.txt
+- README.txt
+- Rakefile
+- lib/conditions_fu.rb
+- lib/conditions_fu/builder.rb
+- spec/conditions_fu/builder_spec.rb
+- spec/conditions_fu_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://wiki.github.com/whalec/conditions_fu
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --main
+- README.txt
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: conditions_fu
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: A little DSL to allow you to map url parameters to an Active Record conditions array
+test_files: 
+- spec/conditions_fu/builder_spec.rb
+- spec/conditions_fu_spec.rb