clearly-query 0.3.1.pre

data/lib/clearly/query/compose/core.rb

@@ -0,0 +1,75 @@
+module Clearly
+  module Query
+    module Compose
+
+      # Provides 'and', and 'or' for composing queries.
+      module Core
+        include Clearly::Query::Validate
+
+        private
+
+        # Get the ActiveRecord::Relation that represents zero records.
+        # @param [ActiveRecord::Base] model
+        # @return [ActiveRecord::Relation] query that will get zero records
+        def relation_none(model)
+          validate_model(model)
+          model.none
+        end
+
+        # Get the ActiveRecord::Relation that represents all records.
+        # @param [ActiveRecord::Base] model
+        # @return [ActiveRecord::Relation] query that will get all records
+        def relation_all(model)
+          validate_model(model)
+          model.all
+        end
+
+        # Get the Arel::Table for this model.
+        # @param [ActiveRecord::Base] model
+        # @return [Arel::Table] arel table
+        def relation_table(model)
+          validate_model(model)
+          model.arel_table
+        end
+
+        # Join conditions using or.
+        # @param [Arel::Nodes::Node] first_condition
+        # @param [Arel::Nodes::Node] second_condition
+        # @return [Arel::Nodes::Node] condition
+        def compose_or(first_condition, second_condition)
+          validate_condition(first_condition)
+          validate_condition(second_condition)
+          first_condition.or(second_condition)
+        end
+
+        # Join conditions using and.
+        # @param [Arel::Nodes::Node] first_condition
+        # @param [Arel::Nodes::Node] second_condition
+        # @param [Array<Arel::Nodes::Node>] conditions
+        # @return [Arel::Nodes::Node] condition
+        def compose_and(first_condition, second_condition, *conditions)
+          validate_condition(first_condition)
+          validate_condition(second_condition)
+          combined = first_condition.and(second_condition)
+
+          unless conditions.blank?
+            conditions.each do |condition|
+              combined = combined.and(condition)
+            end
+          end
+
+          combined
+        end
+
+        # Join conditions using not.
+        # @param [Arel::Nodes::Node] condition
+        # @return [Arel::Nodes::Node] condition
+        def compose_not(condition)
+          validate_condition(condition)
+          condition.not
+        end
+
+      end
+    end
+  end
+end

data/lib/clearly/query/compose/custom.rb

@@ -0,0 +1,268 @@
+module Clearly
+  module Query
+    module Compose
+
+      # Public class for creating custom queries.
+      class Custom
+        include Clearly::Query::Compose::Comparison
+        include Clearly::Query::Compose::Core
+        include Clearly::Query::Compose::Range
+        include Clearly::Query::Compose::Subset
+        include Clearly::Query::Compose::Special
+        include Clearly::Query::Validate
+
+        # Create equals condition.
+        # @param [Arel::Table] table
+        # @param [Symbol] column_name
+        # @param [Array<Symbol>] allowed
+        # @param [Object] value
+        # @return [Arel::Nodes::Node] condition
+        def compose_eq(table, column_name, allowed, value)
+          validate_table_column(table, column_name, allowed)
+          compose_eq_node(table[column_name], value)
+        end
+
+        # Create not equals condition.
+        # @param [Arel::Table] table
+        # @param [Symbol] column_name
+        # @param [Array<Symbol>] allowed
+        # @param [Object] value
+        # @return [Arel::Nodes::Node] condition
+        def compose_not_eq(table, column_name, allowed, value)
+          validate_table_column(table, column_name, allowed)
+          compose_not_eq_node(table[column_name], value)
+        end
+
+        # Create less than condition.
+        # @param [Arel::Table] table
+        # @param [Symbol] column_name
+        # @param [Array<Symbol>] allowed
+        # @param [Object] value
+        # @return [Arel::Nodes::Node] condition
+        def compose_lt(table, column_name, allowed, value)
+          validate_table_column(table, column_name, allowed)
+          compose_lt_node(table[column_name], value)
+        end
+
+        # Create not less than condition.
+        # @param [Arel::Table] table
+        # @param [Symbol] column_name
+        # @param [Array<Symbol>] allowed
+        # @param [Object] value
+        # @return [Arel::Nodes::Node] condition
+        def compose_not_lt(table, column_name, allowed, value)
+          compose_gteq(table, column_name, allowed, value)
+        end
+
+        # Create greater than condition.
+        # @param [Arel::Table] table
+        # @param [Symbol] column_name
+        # @param [Array<Symbol>] allowed
+        # @param [Object] value
+        # @return [Arel::Nodes::Node] condition
+        def compose_gt(table, column_name, allowed, value)
+          validate_table_column(table, column_name, allowed)
+          compose_gt_node(table[column_name], value)
+        end
+
+        # Create not greater than condition.
+        # @param [Arel::Table] table
+        # @param [Symbol] column_name
+        # @param [Array<Symbol>] allowed
+        # @param [Object] value
+        # @return [Arel::Nodes::Node] condition
+        def compose_not_gt(table, column_name, allowed, value)
+          compose_lteq(table, column_name, allowed, value)
+        end
+
+        # Create less than or equal condition.
+        # @param [Arel::Table] table
+        # @param [Symbol] column_name
+        # @param [Array<Symbol>] allowed
+        # @param [Object] value
+        # @return [Arel::Nodes::Node] condition
+        def compose_lteq(table, column_name, allowed, value)
+          validate_table_column(table, column_name, allowed)
+          compose_lteq_node(table[column_name], value)
+        end
+
+        # Create not less than or equal condition.
+        # @param [Arel::Table] table
+        # @param [Symbol] column_name
+        # @param [Array<Symbol>] allowed
+        # @param [Object] value
+        # @return [Arel::Nodes::Node] condition
+        def compose_not_lteq(table, column_name, allowed, value)
+          compose_gt(table, column_name, allowed, value)
+        end
+
+        # Create greater than or equal condition.
+        # @param [Arel::Table] table
+        # @param [Symbol] column_name
+        # @param [Array<Symbol>] allowed
+        # @param [Object] value
+        # @return [Arel::Nodes::Node] condition
+        def compose_gteq(table, column_name, allowed, value)
+          validate_table_column(table, column_name, allowed)
+          compose_gteq_node(table[column_name], value)
+        end
+
+        # Create not greater than or equal condition.
+        # @param [Arel::Table] table
+        # @param [Symbol] column_name
+        # @param [Array<Symbol>] allowed
+        # @param [Object] value
+        # @return [Arel::Nodes::Node] condition
+        def compose_not_gteq(table, column_name, allowed, value)
+          compose_lt(table, column_name, allowed, value)
+        end
+
+        # Create contains condition.
+        # @param [Arel::Table] table
+        # @param [Symbol] column_name
+        # @param [Array<Symbol>] allowed
+        # @param [Object] value
+        # @return [Arel::Nodes::Node] condition
+        def compose_contains(table, column_name, allowed, value)
+          validate_table_column(table, column_name, allowed)
+          compose_contains_node(table[column_name], value)
+        end
+
+        # Create not contains condition.
+        # @param [Arel::Table] table
+        # @param [Symbol] column_name
+        # @param [Array<Symbol>] allowed
+        # @param [Object] value
+        # @return [Arel::Nodes::Node] condition
+        def compose_not_contains(table, column_name, allowed, value)
+          validate_table_column(table, column_name, allowed)
+          compose_not_contains_node(table[column_name], value)
+        end
+
+        # Create starts_with condition.
+        # @param [Arel::Table] table
+        # @param [Symbol] column_name
+        # @param [Array<Symbol>] allowed
+        # @param [Object] value
+        # @return [Arel::Nodes::Node] condition
+        def compose_starts_with(table, column_name, allowed, value)
+          validate_table_column(table, column_name, allowed)
+          compose_starts_with_node(table[column_name], value)
+        end
+
+        # Create not starts_with condition.
+        # @param [Arel::Table] table
+        # @param [Symbol] column_name
+        # @param [Array<Symbol>] allowed
+        # @param [Object] value
+        # @return [Arel::Nodes::Node] condition
+        def compose_not_starts_with(table, column_name, allowed, value)
+          validate_table_column(table, column_name, allowed)
+          compose_not_starts_with_node(table[column_name], value)
+        end
+
+        # Create ends_with condition.
+        # @param [Arel::Table] table
+        # @param [Symbol] column_name
+        # @param [Array<Symbol>] allowed
+        # @param [Object] value
+        # @return [Arel::Nodes::Node] condition
+        def compose_ends_with(table, column_name, allowed, value)
+          validate_table_column(table, column_name, allowed)
+          compose_ends_with_node(table[column_name], value)
+        end
+
+        # Create not ends_with condition.
+        # @param [Arel::Table] table
+        # @param [Symbol] column_name
+        # @param [Array<Symbol>] allowed
+        # @param [Object] value
+        # @return [Arel::Nodes::Node] condition
+        def compose_not_ends_with(table, column_name, allowed, value)
+          validate_table_column(table, column_name, allowed)
+          compose_not_ends_with_node(table[column_name], value)
+        end
+
+        # Create IN condition.
+        # @param [Arel::Table] table
+        # @param [Symbol] column_name
+        # @param [Array<Symbol>] allowed
+        # @param [Array] values
+        # @return [Arel::Nodes::Node] condition
+        def compose_in(table, column_name, allowed, values)
+          validate_table_column(table, column_name, allowed)
+          compose_in_node(table[column_name], values)
+        end
+
+        # Create NOT IN condition.
+        # @param [Arel::Table] table
+        # @param [Symbol] column_name
+        # @param [Array<Symbol>] allowed
+        # @param [Array] values
+        # @return [Arel::Nodes::Node] condition
+        def compose_not_in(table, column_name, allowed, values)
+          validate_table_column(table, column_name, allowed)
+          compose_not_in_node(table[column_name], values)
+        end
+
+        # Create regular expression condition.
+        # @param [Arel::Table] table
+        # @param [Symbol] column_name
+        # @param [Array<Symbol>] allowed
+        # @param [Object] value
+        # @return [Arel::Nodes::Node] condition
+        def compose_regex(table, column_name, allowed, value)
+          validate_table_column(table, column_name, allowed)
+          compose_regex_node(table[column_name], value)
+        end
+
+        # Create negated regular expression condition.
+        # Not available just now, maybe in Arel 6?
+        # @param [Arel::Table] table
+        # @param [Symbol] column_name
+        # @param [Array<Symbol>] allowed
+        # @param [Object] value
+        # @return [Arel::Nodes::Node] condition
+        def compose_not_regex(table, column_name, allowed, value)
+          validate_table_column(table, column_name, allowed)
+          compose_not_regex_node(table[column_name], value)
+        end
+
+        # Create null comparison.
+        # @param [Arel::Table] table
+        # @param [Symbol] column_name
+        # @param [Array<Symbol>] allowed
+        # @param [Boolean] value
+        # @return [Arel::Nodes::Node] condition
+        def compose_null(table, column_name, allowed, value)
+          validate_table_column(table, column_name, allowed)
+          validate_boolean(value)
+          compose_null_node(table[column_name], value)
+        end
+
+        # Create IN condition using from (inclusive) and to (exclusive).
+        # @param [Arel::Table] table
+        # @param [Symbol] column_name
+        # @param [Array<Symbol>] allowed
+        # @param [Object] value
+        # @return [Arel::Nodes::Node] condition
+        def compose_range(table, column_name, allowed, value)
+          validate_table_column(table, column_name, allowed)
+          compose_range_node(table[column_name], value)
+        end
+
+        # Create NOT IN condition using from (inclusive) and to (exclusive).
+        # @param [Arel::Table] table
+        # @param [Symbol] column_name
+        # @param [Array<Symbol>] allowed
+        # @param [Object] value
+        # @return [Arel::Nodes::Node] condition
+        def compose_not_range(table, column_name, allowed, value)
+          validate_table_column(table, column_name, allowed)
+          compose_not_range_node(table[column_name], value)
+        end
+
+      end
+    end
+  end
+end

data/lib/clearly/query/compose/range.rb

@@ -0,0 +1,114 @@
+module Clearly
+  module Query
+    module Compose
+
+      # Methods for composing range queries.
+      module Range
+        include Clearly::Query::Validate
+
+        # Parse an interval.
+        # @param [String] value
+        # @return [Array<String>] captures
+        def parse_interval(value)
+          range_regex = /(\[|\()(.*),(.*)(\)|\])/i
+          matches = value.match(range_regex)
+          fail Clearly::Query::QueryArgumentError.new(
+                   "range string must be in the form (|[.*,.*]|), got '#{value}'") unless matches
+
+          captures = matches.captures
+          {
+              start_include: captures[0] == '[',
+              start_value: captures[1],
+              end_value: captures[2],
+              end_include: captures[3] == ']'
+          }
+        end
+
+        # Validate a range.
+        # @param [Hash] hash
+        # @return [Hash]
+        def parse_range(hash)
+          unless hash.is_a?(Hash)
+            fail Clearly::Query::QueryArgumentError.new(
+                     "range filter must be {'from': 'value', 'to': 'value'} " +
+                         "or {'interval': '(|[.*,.*]|)'} got '#{hash}'", {hash: hash})
+
+          end
+
+          from = hash[:from]
+          to = hash[:to]
+          interval = hash[:interval]
+
+          if !from.blank? && !to.blank? && !interval.blank?
+            fail Clearly::Query::QueryArgumentError.new(
+                     "range filter must use either ('from' and 'to') or ('interval'), not both", {hash: hash})
+          elsif from.blank? && !to.blank?
+            fail Clearly::Query::QueryArgumentError.new(
+                     "range filter missing 'from'", {hash: hash})
+          elsif !from.blank? && to.blank?
+            fail Clearly::Query::QueryArgumentError.new(
+                     "range filter missing 'to'", {hash: hash})
+          elsif !from.blank? && !to.blank?
+            parse_interval("[#{from},#{to})")
+          elsif !interval.blank?
+            parse_interval(interval)
+          else
+            fail Clearly::Query::QueryArgumentError.new(
+                     "range filter did not contain ('from' and 'to') or ('interval'), got '#{hash}'", {hash: hash})
+          end
+        end
+
+        private
+
+        # Create IN condition using from (inclusive) and to (exclusive).
+        # @param [Arel::Nodes::Node, Arel::Attributes::Attribute, String] node
+        # @param [Object] value
+        # @return [Arel::Nodes::Node] condition
+        def compose_range_node(node, value)
+          validate_node_or_attribute(node)
+          range_info = parse_range(value)
+
+          # build using gt, lt, gteq, lteq
+          if range_info[:start_include]
+            start_condition = node.gteq(range_info[:start_value])
+          else
+            start_condition = node.gt(range_info[:start_value])
+          end
+
+          if range_info[:end_include]
+            end_condition = node.lteq(range_info[:end_value])
+          else
+            end_condition = node.lt(range_info[:end_value])
+          end
+
+          start_condition.and(end_condition)
+        end
+
+        # Create NOT IN condition using from (inclusive) and to (exclusive).
+        # @param [Arel::Nodes::Node, Arel::Attributes::Attribute, String] node
+        # @param [Object] value
+        # @return [Arel::Nodes::Node] condition
+        def compose_not_range_node(node, value)
+          validate_node_or_attribute(node)
+          range_info = parse_range(value)
+
+          # build using gt, lt, gteq, lteq
+          if range_info[:start_include]
+            start_condition = node.lt(range_info[:start_value])
+          else
+            start_condition = node.lteq(range_info[:start_value])
+          end
+
+          if range_info[:end_include]
+            end_condition = node.gt(range_info[:end_value])
+          else
+            end_condition = node.gteq(range_info[:end_value])
+          end
+
+          start_condition.or(end_condition)
+        end
+
+      end
+    end
+  end
+end