record_filter 0.9.12

data/config/roodi.yml

@@ -0,0 +1,14 @@
+AssignmentInConditionalCheck:    { }
+CaseMissingElseCheck:            { }
+ClassLineCountCheck:             { line_count: 300 }
+ClassNameCheck:                  { pattern: !ruby/regexp /^[A-Z][a-zA-Z0-9]*$/ }
+CyclomaticComplexityBlockCheck:  { complexity: 4 }
+CyclomaticComplexityMethodCheck: { complexity: 8 }
+EmptyRescueBodyCheck:            { }
+ForLoopCheck:                    { }
+MethodLineCountCheck:            { line_count: 20 }
+MethodNameCheck:                 { pattern: !ruby/regexp /^[_a-z<>=\[\]|+-\/\*`]+[_a-z0-9_<>=~@\[\]]*[=!\?]?$/ }
+ModuleLineCountCheck:            { line_count: 300 }
+ModuleNameCheck:                 { pattern: !ruby/regexp /^[A-Z][a-zA-Z0-9]*$/ }
+ParameterNumberCheck:            { parameter_count: 5 }
+

data/lib/record_filter/active_record.rb

@@ -0,0 +1,108 @@
+module RecordFilter
+  # The ActiveRecordExtension module is mixed in to ActiveRecord::Base to form the
+  # top-level API for interacting with record_filter. It adds public methods for
+  # executing ad-hoc filters as well as for creating and querying named filters.
+  # See RecordFilter::ActiveRecordExtension::ClassMethods for more detail on the
+  # API.
+  module ActiveRecordExtension
+    module ClassMethods
+
+      # Create a filter on the fly to find a set of results that matches the given criteria.
+      # This method, which can be called on any ActiveRecord::Base subclass, accepts a block
+      # that defines the contents of the filter and returns a Filter object that contains a list
+      # of the objects resulting from the query. See the documentation for RecordFilter::DSL
+      # for more information on how to specify the filter.
+      #
+      # ==== Parameters
+      # block<Proc>::
+      #   A block that specifies the contents of the filter.
+      #
+      # ==== Returns
+      # Filter:: 
+      #   The Filter object resulting from the query, which can be treated as an array of the results.
+      #
+      # ==== Example
+      #   Blog.filter do
+      #     having(:posts).with(:name, nil)
+      #   end
+      #
+      # @public
+      def filter(&block)
+        Filter.new(self, nil, &block)
+      end
+
+      # Create a new named filter, which defines a function on the callee class that provides easy
+      # access to the query defined by the filter. Any number of named filters can be created on a
+      # class, and they can also be chained to create complex queries out of simple building blocks.
+      # In addition, named filters can accept any number of arguments in order to allow customization
+      # of their behavior when used. For more details on how to specify the contents of named filters,
+      # see the documentation for RecordFilter::DSL.
+      #
+      #   Post.named_filter(:without_permalink) do
+      #     with(:permalink, nil)
+      #   end
+      #
+      #   Post.named_filter(:created_after) do |time|
+      #     with(:created_at).gt(time)
+      #   end
+      #
+      #   Post.without_permalink                             # :conditions => ['permalink IS NULL']
+      #   Post.created_after(3.hours.ago)                    # :conditions => ['created_at > ?', 3.hours.ago]
+      #   Post.without_permalink.created_after(3.hours.ago)  # :conditions => ['permalink IS NULL AND created_at > ?', 3.hours.ago]
+      #
+      # ==== Raises
+      # InvalidFilterNameException::
+      #   There is already a named filter with the given name on this class or one of its superclasses.
+      #
+      # ==== Returns
+      # nil
+      #
+      # @public
+      def named_filter(name, &block)
+        name = name.to_sym
+        if named_filters.include?(name)
+          raise InvalidFilterNameException.new("A named filter with the name #{name} already exists on the class #{self.name}.")
+        end
+        local_named_filters << name
+        DSL::DSLFactory::get_subclass(self).module_eval do
+          define_method(name, &block)
+        end
+
+        (class << self; self; end).instance_eval do
+          define_method(name) do |*args|
+            Filter.new(self, name, *args)
+          end
+        end
+        nil
+      end
+
+      # Retreive a list of named filters that apply to a specific class, including ones
+      # that were defined in its superclasses.
+      #
+      # ==== Returns
+      # Array:: A list of the names of the named filters, as symbols. 
+      #
+      # @public
+      def named_filters
+        result = local_named_filters.dup
+        result.concat(superclass.named_filters) if (superclass && superclass.respond_to?(:named_filters))
+        result
+      end
+
+      protected
+      
+      def local_named_filters # :nodoc:
+        @local_named_filters ||= []
+      end
+    end
+
+    module AssociationInstanceMethods
+      def filter(&block)
+        Filter.new(self, @finder_sql, &block)
+      end
+    end
+  end
+end
+
+ActiveRecord::Base.send(:extend, RecordFilter::ActiveRecordExtension::ClassMethods)
+ActiveRecord::Associations::AssociationCollection.send(:include, RecordFilter::ActiveRecordExtension::AssociationInstanceMethods)

data/lib/record_filter/column_parser.rb

@@ -0,0 +1,14 @@
+module RecordFilter
+  module ColumnParser # :nodoc: all
+
+    protected
+
+    def parse_column_in_table(column, table)
+      while column.is_a?(Hash)
+        table = table.find_join!(column.keys[0]).right_table
+        column = column.values[0]
+      end
+      [column, table]
+    end
+  end
+end

data/lib/record_filter/conjunctions.rb

@@ -0,0 +1,169 @@
+module RecordFilter
+  module Conjunctions # :nodoc: all
+    class Base
+      attr_reader :table_name, :limit, :offset, :distinct
+
+      def self.create_from(dsl_conjunction, table)
+        result = case dsl_conjunction.type
+          when :any_of then AnyOf.new(table)
+          when :all_of then AllOf.new(table)
+          when :none_of then NoneOf.new(table)
+          when :not_all_of then NotAllOf.new(table)
+          else raise InvalidFilterException.new("An invalid conjunction type of #{dsl_conjunction.type} was used.")
+        end
+
+        dsl_conjunction.steps.each do |step|
+          case step
+          when DSL::Restriction 
+            handle_restriction_step(step, result, table, true)
+          when DSL::Conjunction 
+            result.add_conjunction(create_from(step, table)) 
+          when DSL::Join
+            join = result.add_join_on_association(step.association, step.join_type, step.aliaz)
+            result.add_conjunction(create_from(step.conjunction, join.right_table))
+          when DSL::ClassJoin
+            join = result.add_join_on_class(
+              step.join_class, step.join_type, step.table_alias, step.conditions)
+            result.add_conjunction(create_from(step.conjunction, join.right_table))
+          when DSL::Limit
+            result.add_limit_and_offset(step.limit, step.offset)
+          when DSL::Order
+            result.add_order(step.column, step.direction)
+          when DSL::GroupBy
+            result.add_group_by(step.column)
+          when DSL::NamedFilter
+            result.add_named_filter(step.name, step.args)
+          else raise InvalidFilterException.new('And invalid filter step was provided.')
+          end
+        end
+        result.set_distinct(dsl_conjunction.distinct)
+        result
+      end
+
+      def initialize(table, restrictions = nil, joins = nil)
+        @table = table
+        @table_name = table.table_alias
+        @restrictions = restrictions || []
+        @joins = joins || []
+        @distinct = false
+      end
+
+      def add_restriction(column_name, operator, value, options={})
+        check_column_exists!(column_name)
+        restriction = RestrictionFactory.build(operator, "#{@table_name}.#{column_name}", value, options)
+        self << restriction
+      end
+
+      def add_conjunction(conjunction)
+        self << conjunction
+        conjunction
+      end
+
+      def add_join_on_association(association_name, join_type, aliaz)
+        table = @table
+        while association_name.is_a?(Hash)
+          table = table.join_association(association_name.keys[0], { :join_type => join_type }).right_table
+          association_name = association_name.values[0]
+        end
+        table.join_association(association_name, :join_type => join_type, :alias => aliaz)
+      end
+      
+      def add_join_on_class(join_class, join_type, table_alias, conditions)
+        @table.join_class(join_class, join_type, table_alias, conditions)
+      end
+
+      def add_order(column_name, direction)
+        @table.order_column(column_name, direction)
+      end
+
+      def add_group_by(column_name)
+        @table.group_by_column(column_name)
+      end
+
+      def add_limit_and_offset(limit, offset)
+        @limit, @offset = limit, offset
+      end
+
+      def set_distinct(value)
+        @distinct = value
+      end
+
+      def add_named_filter(name, args)
+        unless @table.model_class.named_filters.include?(name.to_sym)
+          raise NamedFilterNotFoundException.new("The named filter #{name} was not found in #{@table.model_class}")
+        end
+        query = Query.new(@table.model_class, name, *args)
+        self << self.class.create_from(query.dsl_conjunction, @table)
+      end
+
+      def <<(restriction)
+        @restrictions << restriction
+      end
+
+      def to_conditions
+        result = begin
+          if @restrictions.empty?
+            nil
+          elsif @restrictions.length == 1
+            @restrictions.first.to_conditions
+          else
+            @restrictions.map do |restriction|
+              conditions = restriction.to_conditions
+              if conditions
+                conditions[0] = "(#{conditions[0]})"
+                conditions
+              else
+                nil
+              end
+            end.compact.inject do |conditions, new_conditions|
+              conditions.first << " #{conjunctor} #{new_conditions.shift}"
+              conditions.concat(new_conditions)
+              conditions
+            end
+          end
+        end
+        result[0] = "NOT (#{result[0]})" if (negated && !result.nil? && !result[0].nil?)
+        result
+      end
+
+      protected
+
+      def check_column_exists!(column_name)
+        if (!@table.has_column(column_name))
+          raise ColumnNotFoundException.new("The column #{column_name} was not found in #{@table.table_name}.")
+        end
+      end
+
+      def self.handle_restriction_step(step, conjunction, table, follow_conjunctions=true)
+        if ((cr = step.conjuncted_restriction) && follow_conjunctions)
+          restriction_conjunction = create_from(DSL::Conjunction.new(nil, step.conjuncted_restriction_type), table)
+          handle_restriction_step(step, restriction_conjunction, table, false)
+          handle_restriction_step(cr, restriction_conjunction, table, true)
+          conjunction.add_conjunction(restriction_conjunction)
+        else
+          conjunction.add_restriction(step.column, step.operator, step.value, :negated => step.negated)
+        end
+      end
+    end
+
+    class AnyOf < Base
+      def conjunctor; 'OR'; end
+      def negated; false; end
+    end
+
+    class AllOf < Base
+      def conjunctor; 'AND'; end
+      def negated; false; end
+    end
+
+    class NoneOf < Base
+      def conjunctor; 'OR'; end
+      def negated; true; end
+    end
+
+    class NotAllOf < Base
+      def conjunctor; 'AND'; end
+      def negated; true; end
+    end
+  end
+end

data/lib/record_filter/dsl/class_join.rb

@@ -0,0 +1,16 @@
+module RecordFilter
+  module DSL
+    class ClassJoin # :nodoc: all
+      attr_reader :join_class, :join_type, :table_alias, :conjunction
+
+      def initialize(join_class, join_type, table_alias, conjunction, join_conditions)
+        @join_class, @join_type, @table_alias, @conjunction, @join_conditions = 
+          join_class, join_type, table_alias, conjunction, join_conditions
+      end
+
+      def conditions
+        @join_conditions ? @join_conditions.map { |c| c.condition } : nil
+      end
+    end
+  end
+end

data/lib/record_filter/dsl/conjunction.rb

@@ -0,0 +1,57 @@
+module RecordFilter
+  module DSL
+    class Conjunction # :nodoc: all
+
+      attr_reader :type, :steps, :distinct
+
+      def initialize(model_class, type=:all_of)
+        @model_class, @type, @steps, @distinct = model_class, type, [], false
+      end
+
+      def add_restriction(column, value)
+        @steps << (restriction = Restriction.new(column, value))
+        restriction 
+      end
+
+      def add_conjunction(type, &block)
+        dsl = ConjunctionDSL.new(@model_class, Conjunction.new(@model_class, type))
+        dsl.instance_eval(&block) if block
+        @steps << dsl.conjunction
+      end
+
+      def add_join(association, join_type, aliaz, &block)
+        dsl = ConjunctionDSL.new(@model_class, Conjunction.new(@model_class, :all_of))
+        dsl.instance_eval(&block) if block
+        @steps << Join.new(association, join_type, dsl.conjunction, aliaz)
+        dsl
+      end
+
+      def add_class_join(clazz, join_type, table_alias, &block)
+        dsl = JoinDSL.new(@model_class, Conjunction.new(@model_class, :all_of))
+        dsl.instance_eval(&block) if block
+        @steps << ClassJoin.new(clazz, join_type, table_alias, dsl.conjunction, dsl.conditions)
+        dsl
+      end
+
+      def add_limit(limit, offset)
+        @steps << Limit.new(limit, offset)
+      end
+
+      def add_order(column, direction)
+        @steps << Order.new(column, direction)
+      end
+
+      def add_group_by(column)
+        @steps << GroupBy.new(column)
+      end
+
+      def set_distinct
+        @distinct = true
+      end
+
+      def add_named_filter(method, *args)
+        @steps << NamedFilter.new(method, *args)
+      end
+    end
+  end
+end