railswhere 0.1

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+All portions Copyright (c) 2007 Tim Harper
+
+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/lib/search_builder.rb

@@ -0,0 +1,134 @@
+require 'ostruct'
+class SearchBuilder
+  attr_reader :object
+  attr_accessor :where
+  
+  def object=(value)
+    value=OpenStruct.new(value) if Hash===value
+    @object = value
+  end
+  
+  def initialize(target_object, options={})
+    self.object = target_object.is_a?(Hash) ? OpenStruct.new(target_object) : target_object
+    self.where = options[:append_to] || Where.new
+    @table_prefix = ""
+  end
+  
+  def self.delegate_to(object_name, methods = [])
+    for method_name in methods
+      class_eval <<-EOF, __FILE__, __LINE__ +1
+        def #{method_name}(*params, &block)
+          #{object_name} && #{object_name}.#{method_name}(*params, &block)
+        end
+      EOF
+    end
+  end
+  
+  delegate_to "@where", %w[and or to_sql to_s empty?]
+  
+  def range_on(field, options={})
+    options = options.clone
+    min_param = options[:min_param] || "#{options[:param] || field}_min"
+    max_param = options[:max_param] || "#{options[:param] || field}_max"
+    cast = options[:cast] || :string
+    
+    process_clause(field, ">= ?", options.merge(:param => min_param))
+    process_clause(field, "<= ?", options.merge(:param => max_param))
+    
+    self
+  end
+  
+  def like_on(field, options={})
+    options = options.clone
+    options[:suffix] ||= "%"
+    
+    process_clause(field, "like ?", options)
+  end
+  
+  def for_table(table, &block)
+    if block_given?
+      last_table_prefix = @table_prefix
+    end
+    
+    @table_prefix = "#{table}."
+      
+    if block_given?
+      yield
+      
+      @table_prefix = last_table_prefix
+    end
+    
+  end
+  
+  def equal_on(field, options={})
+    options = options.clone
+    options[:cast] = :string
+    process_clause(field, "= ?", options)
+  end
+  
+  def in_on(field, options={})
+    options = options.clone
+    options[:cast] ||= :array
+    process_clause(field, "in (?)", options)
+  end
+  
+  def process_clause(field, operator_clause, options={})
+    param = options[:param] || field
+    self.and_unless_blank("#{@table_prefix}#{field} #{operator_clause}", value_for(param, options[:cast]), options)
+    
+    self
+  end
+
+  def and_unless_blank(condition, value, options={})
+    value = value.compact if (Array === value)
+    
+    # if value is an empty array or a blank string, don't filter on it
+    return self if value.blank?
+    
+    prefix = options[:prefix]
+    suffix = options[:suffix]
+    if prefix || suffix
+      @where.and(condition, [prefix, value, suffix].compact.to_s )
+    else
+      @where.and(condition, value)
+    end
+    
+    self
+  end
+  
+  def value_for(param, cast=:string)
+    param = param.to_s
+    if param.include?(".")
+      param=param.split(".").last
+    end
+    cast_to( object.send(param), cast)
+  end
+  
+  def cast_to(value, type)
+    self.class.cast_to(value, type)
+  end
+  
+  def self.cast_to(value, type)
+    return value if value.nil?
+    
+    case type
+    when nil
+      value
+    when :array
+      value = Array===value ? value : [value]
+    when :time
+      Time.parse(value)
+    when :date
+      Time.parse(value).to_date
+    when :i, :int, :integer
+      value.to_i
+    when :f, :float
+      value.to_f
+    when :string
+      value.to_s
+    else
+      raise "unknown cast type: #{type}"
+    end
+    
+  end
+end

data/lib/where.rb

@@ -0,0 +1,207 @@
+# = Where clause generator
+# == Author: Tim Harper ( "timseeharperATgmail.seeom".gsub("see", "c").gsub("AT", "@") )
+#
+# <b>Usage example</b>
+# === Returning SQL
+#
+#  sql = Where.new('x=?',5).and( Where.new('x=?',6).or('x=?',7)).to_s
+#  # returns (x=5) and ( ( x=6 ) or ( x=7 ) ) 
+#  
+# === Building a complicated where clause made easy
+#  
+#  def get_search_query_string
+#  
+#    where = Where.new
+#    where.and('users.first_name like ?', params[:search_first_name] + '%') unless params[:search_first_name].blank?
+#    where.and('users.last_name like ?', params[:search_last_name] + '%') unless params[:search_last_name].blank?
+#  
+#    status_where = Where.new
+#    for status in params[search_statuses].split(',')
+#      status_where.or 'status=?', status
+#    end
+#    where.and status_where unless status_where.blank?
+#  
+#    where.to_s
+#  end
+#  
+# User.find(:all, :conditions => get_search_query_string)
+#  
+# ===  Inline
+#  
+#    User.find(:all, :conditions => Where.new('first_name like ?', 'Tim').and('last_name like ?', 'Harper') )
+#    # Sweet chaining action!
+
+
+class Where
+  attr_accessor :default_params
+  attr_reader :clauses, :target
+  # Constructs a new where clause
+  # 
+  # optionally, you can provide a criteria, like the following:
+  #   
+  #   Where.initialize "joke_title = ?", "He says, 'Under there', to which I reply, 'under where?'"
+  def initialize(criteria_or_options=nil, *params, &block)
+    @clauses=Array.new
+    @target = self
+    if criteria_or_options.is_a?(Hash)
+      criteria = nil
+      options = criteria_or_options
+    else
+      criteria = criteria_or_options
+      options = {}
+    end
+    self.and(criteria, *params) unless criteria.nil?
+    self.default_params = options[:default_params] || {}
+    
+    yield(self) if block_given?
+  end
+  
+  def initialize_copy(from)
+    @clauses = from.instance_variable_get("@clauses").clone
+  end
+  
+  # Appends an <b>and</b> expression to your where clause
+  # 
+  # Example:
+  #   
+  #   where = Where.new
+  #   where.and("name = ?", "Tim O'brien")
+  #   where.to_s
+  #   
+  #   # => "(name = 'Tim O''brien')
+  def and(*params, &block)
+    @target.append_clause(params, "AND", &block)
+  end
+  
+  alias << and
+  
+  # Appends an <b>or</b> expression to your where clause
+  # 
+  # Example:
+  #   
+  #   where = Where.new
+  #   where.or("name = ?", "Tim O'brien")
+  #   where.or("name = ?", "Tim O'neal")
+  #   where.to_s
+  #   
+  #   # => "(name = 'Tim O''brien') or (name = 'Tim O''neal')"
+  def or(*params, &block)
+    @target.append_clause(params, "OR", &block)
+  end
+  
+  # Same as or, but negates the whole expression
+  def or_not(*params, &block)
+    @target.append_clause(params, "OR NOT", &block)
+  end
+  
+  # Same as and, but negates the whole expression
+  def and_not(*params, &block)
+    @target.append_clause(params, "AND NOT", &block)
+  end
+  
+  def &(params)
+    self.and(*params)
+  end
+  
+  def |(params)
+    self.or(*params)
+  end
+  
+  def self.&(params)
+    Where.new(*params)
+  end
+  
+  def self.|(params)
+    Where.new.or(*params)
+  end
+  
+  # Converts the where clause to a SQL string.
+  def to_s(format=nil)
+    output=""
+    
+    @clauses.each_index{|index|
+      omit_conjuction = (index==0)
+      output << @clauses[index].to_s(omit_conjuction)  # Omit the clause if index=0
+    }
+    case format
+    when :where
+      output.empty? ? "" : " WHERE #{output}"
+    else
+      output.empty? ? "(true)" : output
+    end
+  end
+  
+  alias :to_sql :to_s
+  
+  # Determines if any clauses have been added.
+  # 
+  #   where = Where.new
+  #   where.blank?
+  #   # => true
+  #   
+  #   where.and(nil)
+  #   where.blank?
+  #   # => true
+  #   
+  #   where.and(Where.new(nil))
+  #   where.blank?
+  #   # => true
+  #   
+  #   where.and("name=1")
+  #   where.blank?
+  #   # => false
+  def blank?
+    @clauses.empty?
+  end
+  
+  alias :empty? :blank? 
+   
+protected  
+  def append_clause(params, conjuction = "AND", &block) # :nodoc:
+    if block_given?
+      previous_target = @target
+      @target = Where.new(:default_params => default_params)
+      yield
+      previous_target.clauses << Clause.new(@target, conjuction)
+      @target = previous_target
+    else
+      params = params + [default_params] if params.length == 1 && params.first.is_a?(String)
+      @target.clauses << Clause.new(params, conjuction) unless params.first.blank?
+    end
+    self
+  end
+  
+  # Used internally to +Where+.   You shouldn't have any reason to interact with this class. 
+  class Clause 
+    
+    def initialize(criteria, conjuction = "AND") # :nodoc:
+      @conjuction=conjuction.upcase
+      criteria = criteria.first if criteria.class==Array && criteria.length==1
+        
+      case criteria
+      when Array # if it's an array, sanitize it
+        @criteria = ActiveRecord::Base.send(:sanitize_sql_array, criteria)
+      when Hash
+        return nil if criteria.empty?
+        @criteria = criteria.keys.sort_by { |v| v.to_s }.map do |field|
+          ActiveRecord::Base.send(:sanitize_sql_array, ["#{field} = ?", criteria[field]])
+        end.join(' AND ')
+      else
+        @criteria = criteria.to_s   # otherwise, run to_s.  If it's a recursive Where clause, it will return the sql we need
+      end
+    end
+    
+    def to_s(omit_conjuction=false) # :nodoc:
+      if omit_conjuction
+        output = @conjuction.include?("NOT") ? "NOT " : ""
+        output << "(#{@criteria})"
+      else
+        " #{@conjuction} (#{@criteria})"
+      end
+    end
+  end
+end
+
+def Where(*params, &block)
+  Where.new(*params, &block)
+end

metadata

@@ -0,0 +1,129 @@
+--- !ruby/object:Gem::Specification 
+name: railswhere
+version: !ruby/object:Gem::Version 
+  hash: 9
+  prerelease: 
+  segments: 
+  - 0
+  - 1
+  version: "0.1"
+platform: ruby
+authors: 
+- Tim Harper
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-07-21 00:00:00 -06:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activerecord
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">"
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 3
+        - 0
+        version: "3.0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: sqlite3-ruby
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        hash: 27
+        segments: 
+        - 2
+        - 5
+        - 0
+        version: 2.5.0
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: ruby-debug
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id004
+description: Obligatory description when the summary suits.
+email: 
+- timcharper@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/search_builder.rb
+- lib/where.rb
+- MIT-LICENSE
+has_rdoc: true
+homepage: http://tim.theenchanter.com/
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 23
+      segments: 
+      - 1
+      - 3
+      - 6
+      version: 1.3.6
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.5.0
+signing_key: 
+specification_version: 3
+summary: Easily generate SQL statements
+test_files: []
+