specifind 0.1.0

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2013 YOURNAME
+
+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,55 @@
+Specifind
+=========
+
+[![Code Climate](https://codeclimate.com/github/maxwells/specifind.png)](https://codeclimate.com/github/maxwells/specifind)
+[![Build Status](https://travis-ci.org/maxwells/specifind.png?branch=master)](https://travis-ci.org/maxwells/specifind)
+
+Specifind offers advanced ActiveRecord dynamic find\_by_* methods that include comparators (like the grails ORM). Coupled with some solid SQL injection mitigation through strict verification of type and string escaping, your find methods will be much more readable. If an object of the wrong type (based on the type of the corresponding column of the db) is passed into a finder, it will raise an exception. Ruby 1.9.2 and above are supported
+
+#### Installation
+
+Include specifind in your Rails Gemfile
+
+	gem 'specifind'
+	
+and
+
+	$ bundle
+
+#### Comparators
+1. in\_list (list)
+2. less\_than (value)
+3. less\_than\_equals (value)
+4. greater\_than (value)
+5. greater\_than\_equals (value)
+6. like (String) - as you'd enter it as SQL (eg. 'alpha%' for items starting with alpha)
+7. ilike (String) - case insensitive like
+8. not\_equal (value)
+9. between (lower value, upper value)
+10. is\_not\_null
+11. is\_null
+12. equals (value) - shorthand is to leave comparator blank (eg. find\_by\_name would mean find\_by\_name\_equals)
+
+#### Usage
+
+Here is an example person class:
+
+    class Person < ActiveRecord::Base
+      attr_accessible :age, :birthday, :name
+    end
+
+Specifind is automatically included in ActiveRecord once it is added to your Gemfile. Given the three attributes above, here are some examples of methods you could use to slice your data:
+
+`Person.find_by_age_greater_than_and_birthday_between 15, DateTime.new(1985, 1, 1), DateTime.new(1987,3,6)`
+
+`Person.find_by_name_like '%a%'`
+
+`Person.find_by_name_is_not_null`
+
+#### Notes
+1. Currently, the ilike comparator only works with mysql (to the best of my knowledge)
+2. Unlike built in ActiveRecord methods, Specifind methods will always return a list, even if it only has one instance in it
+
+### Todos
+1. Implement boolean operator logic (eg. find\_by\_age\_greater\_than\_or\_name\_like)
+2. Implement ability to use the same parameter multiple times (currently find_by_age_greater_than_and_age_less_than will choke)

data/Rakefile

@@ -0,0 +1,37 @@
+#!/usr/bin/env rake
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+begin
+  require 'rdoc/task'
+rescue LoadError
+  require 'rdoc/rdoc'
+  require 'rake/rdoctask'
+  RDoc::Task = Rake::RDocTask
+end
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Specifind'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+
+desc "Run all metrics"
+task :metrics do
+  puts "Generating Metrics with metric_fu.\nCheck your browser for output."
+  `metric_fu -r`
+end
+
+
+Bundler::GemHelper.install_tasks
+
+desc "Run all specs"
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/lib/specifind/attribute_phrase.rb

@@ -0,0 +1,101 @@
+module Specifind
+
+  ##
+  # The AttributePhrase class is a component of the {MethodBuilder} -> {QueryBuilder} -> SQL flow. See {MethodBuilder}
+  # for more detail on how that works. AttributePhrase objects have search parameters specific to the attribute
+  # (ie. name of attribute and value(s) associated with it), sometimes a {Comparator} (specifying how to query
+  # those attributes in relation to the provided values), and sometimes an {Operator} (specifying how to link)
+  # this attribute in the query to the next attribute (ie. 'and', 'or').
+  #
+  # Example AttributePhrase:
+  # - name: :first_name
+  # - type: :varchar
+  # - value: 'Steve'
+  # - comparator: Comparator matching 'equals'
+  # - operator: Operator matching 'and'
+  #
+  # will be used by the QueryBuilder, as delegated by MethodBuilder to construct a sql fragment that will find
+  # object ids that have a first_name property equal to 'Steve' and link it with whatever AttributePhrase follows
+  # with an and Operator.
+  #
+  class AttributePhrase
+    attr_accessor :name, :value, :type, :comparator, :operator
+
+    ##
+    # Class factory method to build AttributePhrase objects from a String (which contains an attribute name and sometimes a comparator) and an Operator object.
+    # If no comparator is included in the string, it is assumed to mean equals. If no operator is included in the args, then the AttributePhrase is assumed
+    # to be the terminal part of the query
+    #
+    # @param [Hash] args requires [:string] and [:operator]. String is of form 'attribute(_comparator)' and operator is of type Operator or nil
+    def self.from_string_and_operator(args)
+      raise 'AttributePhrase.from_string_and_operator requires a hash with [:string]' unless args[:string]
+      comparator_patterns = Regexp.new Specifind.comparator.patterns.map{|c| c = "(#{c})"}.join '|'
+      attribute_with_comparator = args[:string].split comparator_patterns
+      name = attribute_with_comparator[0]
+      comparator = attribute_with_comparator[1] || '_equals'
+      AttributePhrase.new :name => name, :comparator => comparator, :operator => args[:operator]
+    end
+
+    ##
+    # A new instance of AttributePhrase
+    #
+    # @param [Hash] args requires [:name], specifying the name of the class's attribute that is being searched on. Can also take [:type], which will
+    # set the type of the object to any of (:boolean, :varchar, :datetime, :num). Can take [:value], which sets the value(s) to be queried (per the
+    # terms of the comparator). Can take [:comparator] and [:operator]. These values can also be set after creation time but before query building
+    # in case the values are not known by the instantiating object
+    def initialize(args)
+      @name = args[:name]
+      @type = args[:type] || nil
+      @value = args[:value] || nil
+      @comparator = Specifind.comparator.find(args[:comparator]) || nil
+      @operator = Operator.find(args[:operator]) || nil
+    end
+
+    def build_comparator_sql
+      comparator.build_sql
+    end
+
+    ##
+    # Constructs a constructor call for this AttributePhrase object.
+    #
+    # Used in a special case by MethodBuilder, which needs to create a block of code (dynamically) to match the method passed. As such,
+    # we cannot pass a pointer to the object, so this method dehydrates it with directions for recreating itself.
+    def to_where
+
+      ".where(\"#{@name} #{@comparator.to_where(@name, @type == :boolean)}\")"
+    end
+
+    ##
+    # Converts this attribute to the parameters it requires (based on it's {Comparator}) for {MethodBuilder}.
+    #
+    # Example:
+    # An AttributePhrase object first_name equals 'Steve' will generate it's portion of the magic method signature
+    # search_by_first_name_equals(first_name_val), where first_name_val is the signature
+    #
+    # An AttributePhrase object with age between 15 and 25 will generate it's portion of the magic method signature
+    # search_by_age_between(age_bound_one, age_bound_two), where age_bound_one, age_bound_two is it's signature
+    def to_signature
+      @comparator ? @comparator.to_signature(@name) : nil
+    end
+
+    ##
+    # Converts this attribute to the parameters that the search_by method in the Searchable concern takes
+    # and passes to QueryBuilder
+    def to_params
+      @comparator ? @comparator.to_params(@name) : nil
+    end
+
+    def to_assertion
+      @comparator.to_type_test @name, @type
+    end
+
+    ##
+    # rearrange any parameter thats passed to necessary values
+    #
+    # example: sql lists are formatted as (val1, val2, val3), while ruby will export (strings) as ['val1', 'val2', 'val3']
+    def to_rearrangement
+      @comparator.to_rearrangement @name, @type
+    end
+
+  end
+end

data/lib/specifind/comparators/mysql2.rb

@@ -0,0 +1,120 @@
+module Specifind
+
+  module Comparators
+    # Comparator holds the logic for each type of comparator that is use in {MethodBuilder} definition.
+    #
+    # The data are held in the class definition as [identifier (String), number of parameters (int), parameter suffixes (list of String), and sql creators (Procs)].
+    class Mysql2
+      @@comparators = []
+      attr_accessor :pattern, :num_params, :param_suffixes, :values, :sql_proc
+
+      # Getter for comparator list
+      def self.comparators
+        @@comparators
+      end
+
+      # Setter for comparator list
+      def self.comparators=(c)
+        @@comparators = c
+      end
+
+      # list of comparator's patterns
+      def self.patterns
+        a = []
+        comparators.each{|c| a << c.pattern}
+        a
+      end
+
+      # find and return a (new) comparator by it's identifying string
+      def self.find(s)
+        comparators.each{|c| return c.clone if c.pattern == s}
+        nil
+      end
+
+      # From the data listed in the Comparator class definition, Comparator.generate_comparators constructs each type of Comparators
+      # and adds it to Comparator.comparators
+      def self.generate_comparators
+        self.comparators_data.each{|c| c = Mysql2.new :pattern => c[0], :num_params => c[1], :param_suffixes => c[2], :sql_proc => c[3] }
+      end
+
+      def self.comparators_data
+        [
+          ['_in_list',              1, %w(_list),                     Proc.new{|v| "in (#{v[0]})"}],
+          ['_less_than_equals',     1, %w(_val),                      Proc.new{|v| "<= #{v[0]}"}],
+          ['_less_than',            1, %w(_val),                      Proc.new{|v| "< #{v[0]}"}],
+          ['_greater_than_equals',  1, %w(_val),                      Proc.new{|v| ">= #{v[0]}"}],
+          ['_greater_than',         1, %w(_val),                      Proc.new{|v| "> #{v[0]}"}],
+          ['_like',                 1, %w(_val),                      Proc.new{|v| "like #{v[0]} collate #{@@encoding}_bin"}],
+          ['_ilike',                1, %w(_val),                      Proc.new{|v| "like #{v[0]}"}],
+          ['_not_equal',            1, %w(_val),                      Proc.new{|v| "!= #{v[0]}"}],
+          ['_between',              2, %w(_bound_one _bound_two),     Proc.new{|v| "between #{v[0]} and #{v[1]}"}],
+          ['_is_not_null',          0, [],                            Proc.new{|v| "is not null"}],
+          ['_is_null',              0, [],                            Proc.new{|v| "is null"}],
+          ['_equals',               1, %w(_val),                      Proc.new{|v| "= #{v[0]}"}]
+        ]
+      end
+
+      def initialize(args)
+        @pattern = args[:pattern]
+        @num_params = args[:num_params]
+        @param_suffixes = @num_params > 0 ? args[:param_suffixes] : []
+        @sql_proc = args[:sql_proc]
+        @@encoding = ActiveRecord::Base.connection.instance_variable_get('@config')[:encoding]
+        Mysql2.comparators << self
+      end
+
+      # Creates the values list for this comparator so that when it's build_sql method is called,
+      # the sql building proc will know how to build the appropriate where clause
+      def set_values(property_name, attribute_hash)
+        @values = []
+        param_suffixes.each{|s| @values << attribute_hash["#{property_name}#{s}".to_sym]} if num_params > 0
+      end
+
+      # builds sql (through @sql_proc) for values that corresponds with this type of comparator
+      def to_where(name, remove_quotes = false)
+        #raise 'values for comparator are not defined' if !values
+        response = @sql_proc.call param_suffixes.map{|p| "\#{#{name}#{p}}" }
+        response.delete! "'" if remove_quotes
+        response
+      end
+
+      # builds signature (the parameter definitions for a method) based on the type of suffixes
+      # that are required for this type of Comparator. See {AttributePhrase#to_signature} for further detail
+      def to_signature(name)
+        return '' if num_params == 0
+        param_suffixes.map{|p| "#{name}#{p}" }.join(',')
+      end
+
+      # builds hash component (the parameters for the search_by method) based on the type of suffixes
+      # that are required for this type of Comparator. See {AttributePhrase#to_params} for further detail
+      def to_params(name)
+        return '' if num_params == 0
+        param_suffixes.map { |p| ":#{name}#{p} => #{name}#{p}" }.join(',')
+      end
+
+      def to_type_test(name, type)
+        out = ""
+        # assert that each variable associated with this comparator is of type passed.
+        # if its not a list
+        if @pattern != '_in_list'
+          param_suffixes.each do |p|
+            out += "#{name}#{p} = Type.assert_#{type}(#{name}#{p})\n"
+          end
+        else # is list - will only have one parameter, which is a list
+          out += "#{name}#{param_suffixes[0]}.each do |v|
+                    v = Type.assert_#{type}(v)
+                  end"
+        end
+        out
+      end
+
+      def to_rearrangement(name, type)
+        out = ''
+        if @pattern == '_in_list'
+          out += "#{name}#{param_suffixes[0]} = #{name}#{param_suffixes[0]}.map{|el| '\"'+el+'\"'}.join ','"
+        end
+        out
+      end
+    end
+  end
+end

data/lib/specifind/comparators/postgre_sql.rb

@@ -0,0 +1,119 @@
+module Specifind
+
+  module Comparators
+    # Comparator holds the logic for each type of comparator that is use in {MethodBuilder} definition.
+    #
+    # The data are held in the class definition as [identifier (String), number of parameters (int), parameter suffixes (list of String), and sql creators (Procs)].
+    class PostgreSQL
+      @@comparators = []
+      attr_accessor :pattern, :num_params, :param_suffixes, :values, :sql_proc
+
+      # Getter for comparator list
+      def self.comparators
+        @@comparators
+      end
+
+      # Setter for comparator list
+      def self.comparators=(c)
+        @@comparators = c
+      end
+
+      # list of comparator's patterns
+      def self.patterns
+        a = []
+        comparators.each{|c| a << c.pattern}
+        a
+      end
+
+      # find and return a (new) comparator by it's identifying string
+      def self.find(s)
+        comparators.each{|c| return c.clone if c.pattern == s}
+        nil
+      end
+
+      # From the data listed in the Comparator class definition, Comparator.generate_comparators constructs each type of Comparators
+      # and adds it to Comparator.comparators
+      def self.generate_comparators
+        self.comparators_data.each{|c| c = PostgreSQL.new :pattern => c[0], :num_params => c[1], :param_suffixes => c[2], :sql_proc => c[3] }
+      end
+
+      def self.comparators_data
+        [
+          ['_in_list',              1, %w(_list),                     Proc.new{|v| "in (#{v[0]})"}],
+          ['_less_than_equals',     1, %w(_val),                      Proc.new{|v| "<= #{v[0]}"}],
+          ['_less_than',            1, %w(_val),                      Proc.new{|v| "< #{v[0]}"}],
+          ['_greater_than_equals',  1, %w(_val),                      Proc.new{|v| ">= #{v[0]}"}],
+          ['_greater_than',         1, %w(_val),                      Proc.new{|v| "> #{v[0]}"}],
+          ['_like',                 1, %w(_val),                      Proc.new{|v| "like #{v[0]}"}],
+          ['_ilike',                1, %w(_val),                      Proc.new{|v| "ilike #{v[0]}"}],
+          ['_not_equal',            1, %w(_val),                      Proc.new{|v| "!= #{v[0]}"}],
+          ['_between',              2, %w(_bound_one _bound_two),     Proc.new{|v| "between #{v[0]} and #{v[1]}"}],
+          ['_is_not_null',          0, [],                            Proc.new{|v| "is not null"}],
+          ['_is_null',              0, [],                            Proc.new{|v| "is null"}],
+          ['_equals',               1, %w(_val),                      Proc.new{|v| "= #{v[0]}"}]
+        ]
+      end
+
+      def initialize(args)
+        @pattern = args[:pattern]
+        @num_params = args[:num_params]
+        @param_suffixes = @num_params > 0 ? args[:param_suffixes] : []
+        @sql_proc = args[:sql_proc]
+        PostgreSQL.comparators << self
+      end
+
+      # Creates the values list for this comparator so that when it's build_sql method is called,
+      # the sql building proc will know how to build the appropriate where clause
+      def set_values(property_name, attribute_hash)
+        @values = []
+        param_suffixes.each{|s| @values << attribute_hash["#{property_name}#{s}".to_sym]} if num_params > 0
+      end
+
+      # builds sql (through @sql_proc) for values that corresponds with this type of comparator
+      def to_where(name, remove_quotes = false)
+        #raise 'values for comparator are not defined' if !values
+        response = @sql_proc.call param_suffixes.map{|p| "\#{#{name}#{p}}" }
+        response.delete! "'" if remove_quotes
+        response
+      end
+
+      # builds signature (the parameter definitions for a method) based on the type of suffixes
+      # that are required for this type of Comparator. See {AttributePhrase#to_signature} for further detail
+      def to_signature(name)
+        return '' if num_params == 0
+        param_suffixes.map{|p| "#{name}#{p}" }.join(',')
+      end
+
+      # builds hash component (the parameters for the search_by method) based on the type of suffixes
+      # that are required for this type of Comparator. See {AttributePhrase#to_params} for further detail
+      def to_params(name)
+        return '' if num_params == 0
+        param_suffixes.map { |p| ":#{name}#{p} => #{name}#{p}" }.join(',')
+      end
+
+      def to_type_test(name, type)
+        out = ""
+        # assert that each variable associated with this comparator is of type passed.
+        # if its not a list
+        if @pattern != '_in_list'
+          param_suffixes.each do |p|
+            out += "#{name}#{p} = Type.assert_#{type}(#{name}#{p})\n"
+          end
+        else # is list - will only have one parameter, which is a list
+          out += "#{name}#{param_suffixes[0]}.each do |v|
+                    v = Type.assert_#{type}(v)
+                  end"
+        end
+        out
+      end
+
+      def to_rearrangement(name, type)
+        out = ''
+        if @pattern == '_in_list'
+          out += "#{name}#{param_suffixes[0]} = #{name}#{param_suffixes[0]}.map{|el| \"'\"+el+\"'\"}.join ','"
+        end
+        out
+      end
+    end
+  end
+end

data/lib/specifind/comparators/sq_lite3.rb

@@ -0,0 +1,117 @@
+module Specifind
+
+  module Comparators
+    # Comparator holds the logic for each type of comparator that is use in {MethodBuilder} definition.
+    #
+    # The data are held in the class definition as [identifier (String), number of parameters (int), parameter suffixes (list of String), and sql creators (Procs)].
+    class SQLite3
+      @@comparators = []
+      attr_accessor :pattern, :num_params, :param_suffixes, :values, :sql_proc
+
+      # Getter for comparator list
+      def self.comparators
+        @@comparators
+      end
+
+      # Setter for comparator list
+      def self.comparators=(c)
+        @@comparators = c
+      end
+
+      # list of comparator's patterns
+      def self.patterns
+        a = []
+        comparators.each{|c| a << c.pattern}
+        a
+      end
+
+      # find and return a (new) comparator by it's identifying string
+      def self.find(s)
+        comparators.each{|c| return c.clone if c.pattern == s}
+        nil
+      end
+
+      # From the data listed in the Comparator class definition, Comparator.generate_comparators constructs each type of Comparators
+      # and adds it to Comparator.comparators
+      def self.generate_comparators
+        self.comparators_data.each{|c| c = SQLite3.new :pattern => c[0], :num_params => c[1], :param_suffixes => c[2], :sql_proc => c[3] }
+      end
+
+      def self.comparators_data
+        [
+          ['_in_list',              1, %w(_list),                     Proc.new{|v| "in (#{v[0]})"}],
+          ['_less_than_equals',     1, %w(_val),                      Proc.new{|v| "<= #{v[0]}"}],
+          ['_less_than',            1, %w(_val),                      Proc.new{|v| "< #{v[0]}"}],
+          ['_greater_than_equals',  1, %w(_val),                      Proc.new{|v| ">= #{v[0]}"}],
+          ['_greater_than',         1, %w(_val),                      Proc.new{|v| "> #{v[0]}"}],
+          ['_like',                 1, %w(_val),                      Proc.new{|v| "like #{v[0]}"}],
+          ['_ilike',                1, %w(_val),                      Proc.new{|v| "like #{v[0]}"}],
+          ['_not_equal',            1, %w(_val),                      Proc.new{|v| "!= #{v[0]}"}],
+          ['_between',              2, %w(_bound_one _bound_two),     Proc.new{|v| "between #{v[0]} and #{v[1]}"}],
+          ['_is_not_null',          0, [],                            Proc.new{|v| "is not null"}],
+          ['_is_null',              0, [],                            Proc.new{|v| "is null"}],
+          ['_equals',               1, %w(_val),                      Proc.new{|v| "= #{v[0]}"}]
+        ]
+      end
+
+      def initialize(args)
+        @pattern = args[:pattern]
+        @num_params = args[:num_params]
+        @param_suffixes = @num_params > 0 ? args[:param_suffixes] : []
+        @sql_proc = args[:sql_proc]
+        SQLite3.comparators << self
+      end
+
+      # Creates the values list for this comparator so that when it's build_sql method is called,
+      # the sql building proc will know how to build the appropriate where clause
+      def set_values(property_name, attribute_hash)
+        @values = []
+        param_suffixes.each{|s| @values << attribute_hash["#{property_name}#{s}".to_sym]} if num_params > 0
+      end
+
+      # builds sql (through @sql_proc) for values that corresponds with this type of comparator
+      def to_where(name, remove_quotes = false)
+        #raise 'values for comparator are not defined' if !values
+        response = @sql_proc.call param_suffixes.map{|p| "\#{#{name}#{p}}" }
+        response.delete! "'" if remove_quotes
+        response
+      end
+
+      # builds signature (the parameter definitions for a method) based on the type of suffixes
+      # that are required for this type of Comparator. See {AttributePhrase#to_signature} for further detail
+      def to_signature(name)
+        param_suffixes.map{|p| "#{name}#{p}" }.join(',')
+      end
+
+      # builds hash component (the parameters for the search_by method) based on the type of suffixes
+      # that are required for this type of Comparator. See {AttributePhrase#to_params} for further detail
+      def to_params(name)
+        param_suffixes.map { |p| ":#{name}#{p} => #{name}#{p}" }.join(',')
+      end
+
+      def to_type_test(name, type)
+        out = ""
+        # assert that each variable associated with this comparator is of type passed.
+        # if its not a list
+        if @pattern != '_in_list'
+          param_suffixes.each do |p|
+            out += "#{name}#{p} = Type.assert_#{type}(#{name}#{p})\n"
+          end
+        else # is list - will only have one parameter, which is a list
+          out += "#{name}#{param_suffixes[0]}.each do |v|
+                    v = Type.assert_#{type}(v)
+                  end"
+        end
+        out
+      end
+
+      def to_rearrangement(name, type)
+        out = ''
+        if @pattern == '_in_list'
+          out += "#{name}#{param_suffixes[0]} = #{name}#{param_suffixes[0]}.map{|el| '\"'+el+'\"'}.join ','"
+        end
+        out
+      end
+    end
+  end
+end

data/lib/specifind/comparators.rb

@@ -0,0 +1,20 @@
+module Specifind
+
+  # Comparator holds the logic for each type of comparator that is use in {MethodBuilder} definition.
+  #
+  # The data are held in the class definition as [identifier (String), number of parameters (int), parameter suffixes (list of String), and sql creators (Procs)].
+  module Comparators
+    extend ActiveSupport::Autoload
+
+    autoload :SQLite3
+    autoload :Mysql2
+    autoload :PostgreSQL
+
+    def self.generate_comparators
+      SQLite3.generate_comparators
+      Mysql2.generate_comparators
+      PostgreSQL.generate_comparators
+    end
+
+  end
+end

data/lib/specifind/method_builder.rb

@@ -0,0 +1,144 @@
+
+module Specifind
+
+  class MethodBuilder
+    @matchers = []
+
+    class << self
+      attr_reader :matchers
+
+      def match(model, name)
+        klass = matchers.find { |k| name =~ k.pattern }
+        klass.new(model, name) if klass
+      end
+
+      def parse_to_attributes(s)
+        operator_regexp = Regexp.new Operator.patterns.map{|s| s = "(#{s})"}.join '|'
+        hybrid_list = s.split(operator_regexp)
+        attribute_list = []
+        # it is now split into [field_name (+comparator)] + operator + [field_name (+comparator)] ...
+
+        attribute_list << AttributePhrase.from_string_and_operator(:string => hybrid_list.shift, :operator => hybrid_list.shift) while hybrid_list.length > 0
+        attribute_list
+      end
+
+      def pattern
+        /^#{prefix}_([_a-zA-Z]\w*)#{suffix}$/
+      end
+
+      def prefix
+        raise NotImplementedError
+      end
+
+      def suffix
+        ''
+      end
+    end
+
+    attr_reader :model, :name, :attribute_names, :attributes
+
+    def initialize(model, name)
+      @model           = model
+      @name            = name.to_s
+      match = @name.match(self.class.pattern)
+      @attributes      = MethodBuilder.parse_to_attributes match[1]
+      @attribute_names = @attributes.map{ |a| a.name }
+    end
+
+    def merge_attribute_types(columns)
+      @attributes.each do |a|
+        columns.each do |c|
+          if a.name == c[:name]
+            a.type = c[:type]
+          end
+        end
+      end
+    end
+
+    def valid?
+      attribute_names.all? { |name| model.columns_hash[name] || model.reflect_on_aggregation(name.to_sym) }
+    end
+
+    def define
+      assertions = ""
+      @attributes.each do |a|
+        assertions += a.to_assertion
+      end
+      rearrangements = ""
+      @attributes.each do |a|
+        rearrangements += a.to_rearrangement
+      end
+      model.class_eval <<-CODE, __FILE__, __LINE__ + 1
+        def self.#{name}(#{signature})
+          #{assertions}
+          #{rearrangements}
+          #{body}
+        end
+      CODE
+    end
+
+    def body
+      raise NotImplementedError
+    end
+  end
+
+  module Finder
+    # Extended in activerecord-deprecated_finders
+    def body
+      result
+    end
+
+    # Extended in activerecord-deprecated_finders
+    def result
+      s = "#{model.name}"
+      @attributes.each do |a|
+        s += "#{a.to_where}"
+      end
+      s
+    end
+
+    # Extended in activerecord-deprecated_finders
+    def signature
+      attributes.map{|a| a.to_signature }.delete_if{|s| s == nil}.join(', ')
+    end
+
+    def attributes_hash
+      "{" + attribute_names.map { |name| ":#{name} => #{name}" }.join(',') + "}"
+    end
+
+    def finder
+      raise NotImplementedError
+    end
+  end
+
+  class FindBy < MethodBuilder
+    MethodBuilder.matchers << self
+    include Finder
+
+    def self.prefix
+      "find_by"
+    end
+
+    def finder
+      "find_by"
+    end
+  end
+
+  class FindByBang < MethodBuilder
+    MethodBuilder.matchers << self
+    include Finder
+
+    def self.prefix
+      "find_by"
+    end
+
+    def self.suffix
+      "!"
+    end
+
+    def finder
+      "find_by!"
+    end
+  end
+
+end

data/lib/specifind/operator.rb

@@ -0,0 +1,41 @@
+module Specifind
+
+    # Operator holds the logic for each type of operator that is use in {MethodBuilder} definition.
+  #
+  # The data are held in the class definition as a list of identifying Strings.
+  class Operator
+    @@operators_data = %w(_and_)
+    @@operators = []
+    attr_accessor :pattern
+
+    # list of operator objects
+    def self.operators
+      @@operators
+    end
+
+    # set list of operator objects
+    def self.operators=(o)
+      @@operators = o
+    end
+
+    # list of operator objects' patterns
+    def self.patterns
+      a = []
+      @@operators.each{|c| a << c.pattern}
+      a
+    end
+
+    # find an operator object based on identifying string
+    def self.find(s)
+      @@operators.each{|o| return o if o.pattern == s}
+      nil
+    end
+
+    def initialize(args)
+      @pattern = args[:pattern]
+      Operator.operators << self
+    end
+
+    @@operators_data.each{|o| o = Operator.new pattern: o}
+  end
+end

data/lib/specifind/type.rb

@@ -0,0 +1,38 @@
+module Specifind
+  class Type
+
+    def self.data
+      [
+        { :type => 'binary', :allowed_classes => [String] },
+        { :type => 'boolean', :allowed_classes => [TrueClass, FalseClass] },
+        { :type => 'date', :allowed_classes => [Date, DateTime] },
+        { :type => 'decimal', :allowed_classes => [Float, Fixnum] },
+        { :type => 'float', :allowed_classes => [Float] },
+        { :type => 'integer', :allowed_classes => [Fixnum] },
+        { :type => 'string', :allowed_classes => [String] },
+        { :type => 'text', :allowed_classes => [String] },
+        { :type => 'time', :allowed_classes => [Time] },
+        { :type => 'timestamp', :allowed_classes => [Date, DateTime] }
+      ]
+    end
+
+    def self.generate_methods
+      self.data.each do |h|
+        names = h[:allowed_classes].map{|c| c.name}.join ' or '
+        types = h[:allowed_classes].map{|c| "val.kind_of? #{c.name}"}.join ' or '
+        class_eval <<-CODE, __FILE__, __LINE__ + 1
+          def self.assert_#{h[:type]}(val)
+            raise "Dynamic finder required #{names}, \#{val.class} provided" unless #{types}
+            escape_values(val)
+          end
+        CODE
+      end
+    end
+
+    def self.escape_values(val)
+      c = ActiveRecord::Base.connection
+      c.quote(val)
+    end
+
+  end
+end

data/lib/specifind/version.rb

@@ -0,0 +1,3 @@
+module Specifind
+  VERSION = "0.1.0"
+end

data/lib/specifind.rb

@@ -0,0 +1,49 @@
+#require 'active_record'
+
+module Specifind
+  extend ActiveSupport::Concern
+  extend ActiveSupport::Autoload
+
+  autoload :MethodBuilder
+  autoload :Comparators
+  autoload :Operator
+  autoload :AttributePhrase
+  autoload :Type
+
+  included do
+    Specifind::Comparators.generate_comparators
+    Type.generate_methods
+  end
+
+  module ClassMethods
+
+    def method_missing(name, *arguments, &block)
+      unless Specifind.comparator
+        active_record_adapter = ActiveRecord::Base.connection.class.name.split(':').last.gsub /Adapter/, ''
+        comparator = "Specifind::Comparators::#{active_record_adapter}".constantize
+        Specifind.comparator = "Specifind::Comparators::#{active_record_adapter}".constantize
+      end
+      
+      match = MethodBuilder.match(self, name)
+      if match && match.valid?
+        types = self.columns.map{|c| {:name => c.name, :type => c.type}}
+        match.merge_attribute_types types
+        match.define
+        send(name, *arguments, &block)
+      else
+        super
+      end
+    end
+  end
+
+  def self.comparator=(val)
+    @comparator = val
+  end
+
+  def self.comparator
+    @comparator
+  end
+
+end
+
+ActiveRecord::Base.send(:include, Specifind)

data/spec/config.yml

@@ -0,0 +1,21 @@
+test:
+  adapter: mysql2
+  database: specifind_test
+  username: mlahey
+  password: karma559
+  encoding: utf8
+
+test_sqlite:
+  adapter: sqlite3
+  database: spec/spec.sqlite3
+
+test_mysql:
+  adapter: mysql2
+  database: specifind_test
+  username: root
+  encoding: utf8
+  
+test_postgres:
+  adapter: postgresql
+  database: specifind_test
+  username: postgres

data/spec/spec_helper.rb

@@ -0,0 +1,11 @@
+require 'active_record'
+
+cnf = YAML::load_file(File.join(File.dirname(File.expand_path(__FILE__)), 'config.yml'))
+config_block = ENV['TEST_CONFIG'] || 'test'
+cnf = cnf[config_block]
+
+ActiveRecord::Base.establish_connection(cnf)
+
+RSpec.configure do |config|
+  config.order = "random"
+end

data/spec/specifind_spec.rb

@@ -0,0 +1,120 @@
+require 'spec_helper'
+require 'active_record'
+
+# ActiveRecord::Base.establish_connection(
+#        :adapter   => 'sqlite3',
+#        :database  => 'spec/spec.sqlite3'
+#     )
+
+require 'specifind'
+
+class Person < ActiveRecord::Base
+  attr_accessible :birthday, :name, :male
+end
+
+describe Person do
+  before(:all) do
+
+    ActiveRecord::Migration.class_eval do
+      create_table :people do |t|
+          t.integer  :age
+          t.date :birthday
+          t.string :name
+          t.boolean :male
+       end
+    end
+
+    Person.create :name => 'Erin', :birthday => Date.new(1981, 5, 16), :male => false
+    Person.create :name => 'Aaron', :birthday => Date.new(1956, 8, 6), :male => true
+    Person.create :name => 'Niki', :birthday => Date.new(1992, 3, 29), :male => false
+    Person.create :name => 'Nick', :birthday => Date.new(1974, 11, 1), :male => true
+    Person.create :name => 'Dani', :birthday => Date.new(1987, 4, 9), :male => false
+    Person.create :name => 'Dan', :birthday => Date.new(2001, 1, 17), :male => true
+    Person.create :name => 'xxyxx', :birthday => nil, :male => false
+
+  end
+
+  after :all do
+    ActiveRecord::Migration.class_eval do
+      drop_table :people
+    end
+  end
+
+  describe "Specifind Model" do
+    it "finds instances with in_list comparator" do
+      Person.find_by_name_in_list(['Erin', 'Aaron', 'Niki']).length.should == 3
+    end
+
+    it "finds instances with less_than comparator" do
+      list = Person.find_by_birthday_less_than(Date.new(1957,1,1))
+      list[0].name.should == 'Aaron'
+    end
+
+    it "finds instances with less_than_equals comparator" do
+      list = Person.find_by_birthday_less_than_equals(Date.new(1974, 11, 1))
+      list.length.should == 2
+    end
+
+    it "finds instances with greater_than comparator" do
+      list = Person.find_by_birthday_greater_than(Date.new(1992,3,29))
+      list[0].name.should == 'Dan'
+    end
+
+    it "finds instances with greater_than_equals comparator" do
+      list = Person.find_by_birthday_greater_than_equals(Date.new(1992,3,29))
+      list.length.should == 2
+    end
+
+    it "finds instances with like comparator" do
+      list = Person.find_by_name_like '%n%'
+      if ActiveRecord::Base.connection.class.name == "ActiveRecord::ConnectionAdapters::SQLite3Adapter"
+        list.length.should == 6 # sqlite3 uses case insensitive for like. no magic way to make case sensitive
+      else
+        list.length.should == 4 # Erin, Aaron, Dani, Dan
+      end
+    end
+
+    it "finds instances with ilike comparator" do
+      list = Person.find_by_name_ilike '%N%'
+      list.length.should == 6 # Erin, Aaron, Niki, Nick, Dani, Dan
+    end
+
+    it "finds instances with not_equal comparator" do
+      list = Person.find_by_name_not_equal 'Dan'
+      list.length.should == 6
+      list.each do |p|
+        p.name.should_not == 'Dan'
+      end
+    end
+
+    it "finds instances with between comparator" do
+      list = Person.find_by_birthday_between Date.new(2000, 1, 1), Date.new(2002, 1, 1)
+      list.length.should == 1
+      list[0].name.should == 'Dan'
+    end
+
+    it "finds instances with is_not_null comparator" do
+      list = Person.find_by_birthday_is_not_null
+      list.length.should == 6
+    end
+
+    it "finds instances with is_null comparator" do
+      list = Person.find_by_birthday_is_null
+      list.length.should == 1
+      list[0].name.should == 'xxyxx'
+    end
+
+    it "finds instances with equals comparator" do
+      list = Person.find_by_male false
+      list.length.should == 4
+    end
+
+    it "works" do
+    end
+    it "verifies the type of objects passed in" do
+      expect {Person.find_by_age_equals 'max'}.to raise_error
+      expect {Person.find_by_birthday 'max'}.to raise_error
+      expect {Person.find_by_name_like 16}.to raise_error
+    end
+  end
+end

metadata

@@ -0,0 +1,104 @@
+--- !ruby/object:Gem::Specification
+name: specifind
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Max Lahey
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-04-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.2.9
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.2.9
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Specifind offers advanced ActiveRecord dynamic find_by_* methods that
+  include comparators (like the grails ORM). Coupled with some solid SQL injection
+  mitigation through strict verification of type and string escaping, your find methods
+  will be much more readable. If an object of the wrong type (based on the type of
+  the corresponding column of the db) is passed into a finder, it will raise an exception.
+  Ruby 1.9.2 and above are supported
+email:
+- maxwellslahey@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/specifind/attribute_phrase.rb
+- lib/specifind/comparators/mysql2.rb
+- lib/specifind/comparators/postgre_sql.rb
+- lib/specifind/comparators/sq_lite3.rb
+- lib/specifind/comparators.rb
+- lib/specifind/method_builder.rb
+- lib/specifind/operator.rb
+- lib/specifind/type.rb
+- lib/specifind/version.rb
+- lib/specifind.rb
+- MIT-LICENSE
+- Rakefile
+- README.md
+- spec/config.yml
+- spec/spec.sqlite3
+- spec/spec_helper.rb
+- spec/specifind_spec.rb
+homepage: http://maxwells.github.io
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Readble & Advanced ActiveRecord dynamic methods
+test_files:
+- spec/config.yml
+- spec/spec.sqlite3
+- spec/spec_helper.rb
+- spec/specifind_spec.rb
+has_rdoc: