clearly-query 0.3.1.pre

data/bin/yard

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+#
+# This file was generated by Bundler.
+#
+# The application 'yard' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+require 'pathname'
+ENV['BUNDLE_GEMFILE'] ||= File.expand_path('../../Gemfile',
+  Pathname.new(__FILE__).realpath)
+
+require 'rubygems'
+require 'bundler/setup'
+
+load Gem.bin_path('yard', 'yard')

data/clearly-query.gemspec

@@ -0,0 +1,33 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'clearly/query/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'clearly-query'
+  spec.version       = Clearly::Query::VERSION
+  spec.authors       = ['@cofiem']
+  spec.email         = ['cofiem@gmail.com']
+  spec.summary       = %q{A library for constructing an sql query from a hash.}
+  spec.description   = %q{A library for constructing an sql query from a hash. Uses a strict, yet flexible specification.}
+  spec.homepage      = 'https://github.com/cofiem/clearly-query'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_runtime_dependency 'arel', '~> 6'
+  spec.add_runtime_dependency 'activesupport', '~> 4'
+  spec.add_runtime_dependency 'activerecord', '~> 4'
+
+  spec.add_development_dependency 'bundler', '~> 1'
+  spec.add_development_dependency 'rake', '~> 10'
+  spec.add_development_dependency 'guard-rspec', '~> 4'
+  spec.add_development_dependency 'guard-yard', '~> 2'
+  spec.add_development_dependency 'simplecov', '~> 0'
+  spec.add_development_dependency 'sqlite3', '~> 1'
+  spec.add_development_dependency 'zonebie', '~> 0'
+  spec.add_development_dependency 'database_cleaner', '~> 1'
+end

data/lib/clearly/query.rb

@@ -0,0 +1,22 @@
+require 'active_support/all'
+
+require 'clearly/query/version'
+
+require 'clearly/query/errors'
+require 'clearly/query/helper'
+require 'clearly/query/validate'
+require 'clearly/query/cleaner'
+
+require 'clearly/query/compose/core'
+require 'clearly/query/compose/subset'
+require 'clearly/query/compose/comparison'
+require 'clearly/query/compose/range'
+require 'clearly/query/compose/special'
+require 'clearly/query/compose/custom'
+require 'clearly/query/compose/conditions'
+
+require 'clearly/query/composer'
+require 'clearly/query/definition'
+require 'clearly/query/graph'
+
+

data/lib/clearly/query/cleaner.rb

@@ -0,0 +1,63 @@
+module Clearly
+  module Query
+
+    # Cleans a filter hash so it is ready to be built using the Composer.
+    class Cleaner
+
+      # Create a cleaner for a filter hash.
+      # @return [Clearly::Query::Cleaner]
+      def initialize
+        self
+      end
+
+      # Get the cleaned filter hash.
+      # @param [Hash] hash
+      # @return [Hash]
+      def do(hash)
+        clean(hash)
+      end
+
+      private
+
+      # Clean an object.
+      # @param [Object] value
+      # @return [Object]
+      def clean(value)
+        if value.is_a?(Hash)
+          clean_hash(value)
+        elsif value.is_a?(Array)
+          clean_array(value)
+        else
+          value
+        end
+      end
+
+      # Clean a hash.
+      # @param [Hash] hash
+      # @return [Hash] Cleaned hash
+      def clean_hash(hash)
+        cleaned_hash = Hash.new
+        hash.each do |key, value|
+          new_key = clean_value(key)
+          cleaned_hash[new_key] = clean(value)
+        end
+        cleaned_hash
+      end
+
+      # Clean an array.
+      # @param [Array] array
+      # @return [Array]
+      def clean_array(array)
+        array.map { |item| clean(item) }
+      end
+
+      # Convert to a snake case symbol
+      # @param [Object] value
+      # @return [Symbol]
+      def clean_value(value)
+        value.to_s.underscore.to_sym
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,102 @@
+module Clearly
+  module Query
+
+  # Arel helper methods used by Composer and Definition
+  module Compose
+
+    # Provides comparisons for composing queries.
+    module Comparison
+      include Clearly::Query::Validate
+
+      private
+
+      # Create equals condition.
+      # @param [Arel::Nodes::Node] node
+      # @param [Object] value
+      # @return [Arel::Nodes::Node] condition
+      def compose_eq_node(node, value)
+        validate_node_or_attribute(node)
+        node.eq(value)
+      end
+
+      # Create not equals condition.
+      # @param [Arel::Nodes::Node] node
+      # @param [Object] value
+      # @return [Arel::Nodes::Node] condition
+      def compose_not_eq_node(node, value)
+        validate_node_or_attribute(node)
+        node.not_eq(value)
+      end
+
+      # Create less than condition.
+      # @param [Arel::Nodes::Node] node
+      # @param [Object] value
+      # @return [Arel::Nodes::Node] condition
+      def compose_lt_node(node, value)
+        validate_node_or_attribute(node)
+        node.lt(value)
+      end
+
+      # Create not less than condition.
+      # @param [Arel::Nodes::Node, Arel::Attributes::Attribute, String] node
+      # @param [Object] value
+      # @return [Arel::Nodes::Node] condition
+      def compose_not_lt_node(node, value)
+        compose_gteq_node(node, value)
+      end
+
+      # Create greater than condition.
+      # @param [Arel::Nodes::Node, Arel::Attributes::Attribute, String] node
+      # @param [Object] value
+      # @return [Arel::Nodes::Node] condition
+      def compose_gt_node(node, value)
+        validate_node_or_attribute(node)
+        node.gt(value)
+      end
+
+      # Create not greater than condition.
+      # @param [Arel::Nodes::Node, Arel::Attributes::Attribute, String] node
+      # @param [Object] value
+      # @return [Arel::Nodes::Node] condition
+      def compose_not_gt_node(node, value)
+        compose_lteq_node(node, value)
+      end
+
+      # Create less than or equal condition.
+      # @param [Arel::Nodes::Node, Arel::Attributes::Attribute, String] node
+      # @param [Object] value
+      # @return [Arel::Nodes::Node] condition
+      def compose_lteq_node(node, value)
+        validate_node_or_attribute(node)
+        node.lteq(value)
+      end
+
+      # Create not less than or equal condition.
+      # @param [Arel::Nodes::Node, Arel::Attributes::Attribute, String] node
+      # @param [Object] value
+      # @return [Arel::Nodes::Node] condition
+      def compose_not_lteq_node(node, value)
+        compose_gt_node(node, value)
+      end
+
+      # Create greater than or equal condition.
+      # @param [Arel::Nodes::Node, Arel::Attributes::Attribute, String] node
+      # @param [Object] value
+      # @return [Arel::Nodes::Node] condition
+      def compose_gteq_node(node, value)
+        validate_node_or_attribute(node)
+        node.gteq(value)
+      end
+
+      # Create not greater than or equal condition.
+      # @param [Arel::Nodes::Node, Arel::Attributes::Attribute, String] node
+      # @param [Object] value
+      # @return [Arel::Nodes::Node] condition
+      def compose_not_gteq_node(node, value)
+        compose_lt_node(node, value)
+      end
+
+    end
+  end
+end
+end

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

@@ -0,0 +1,215 @@
+module Clearly
+  module Query
+    module Compose
+
+      # Methods for building conditions.
+      module Conditions
+        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
+
+        # Logical query operators
+        OPERATORS_LOGICAL = [:and, :or, :not]
+
+        # Comparison query operators
+        OPERATORS_COMPARISON = [
+            :eq, :equal,
+            :not_eq, :not_equal,
+            :lt, :less_than,
+            :not_lt, :not_less_than,
+            :gt, :greater_than,
+            :not_gt, :not_greater_than,
+            :lteq, :less_than_or_equal,
+            :not_lteq, :not_less_than_or_equal,
+            :gteq, :greater_than_or_equal,
+            :not_gteq, :not_greater_than_or_equal]
+
+        # range query operators
+        OPERATORS_RANGE = [
+            :range, :in_range,
+            :not_range, :not_in_range]
+
+        # Subset query operators
+        OPERATORS_SUBSET = [
+            :in, :is_in,
+            :not_in, :is_not_in,
+            :contains, :contain,
+            :not_contains, :not_contain, :does_not_contain,
+            :starts_with, :start_with,
+            :not_starts_with, :not_start_with, :does_not_start_with,
+            :ends_with, :end_with,
+            :not_ends_with, :not_end_with, :does_not_end_with]
+
+        # Regex query operators
+        OPERATORS_REGEX = [
+            :regex, :regex_match, :matches,
+            :not_regex, :not_regex_match, :does_not_match, :not_match]
+
+        # Special query operators (null)
+        OPERATORS_SPECIAL = [:null, :is_null]
+
+        # All query operators except logical operators
+        # All query operators except logical operators
+        OPERATORS =
+            OPERATORS_COMPARISON +
+                OPERATORS_RANGE +
+                OPERATORS_SUBSET +
+                OPERATORS_REGEX +
+                OPERATORS_SPECIAL
+
+        # Add conditions to a query.
+        # @param [ActiveRecord::Relation] query
+        # @param [Array<Arel::Nodes::Node>, Arel::Nodes::Node] conditions
+        # @return [ActiveRecord::Relation] the modified query
+        def condition_apply(query, conditions)
+          conditions = [conditions].flatten
+          validate_not_blank(conditions)
+          validate_array(conditions)
+
+          conditions.each do |condition|
+            validate_condition(condition)
+            query = query.where(condition)
+          end
+
+          query
+        end
+
+        # Combine multiple conditions.
+        # @param [Symbol] combiner
+        # @param [Arel::Nodes::Node, Array<Arel::Nodes::Node>] conditions
+        # @return [Arel::Nodes::Node] condition
+        def condition_combine(combiner, *conditions)
+          conditions = [conditions].flatten
+          validate_not_blank(conditions)
+          validate_array(conditions)
+          validate_condition(conditions[0])
+          validate_array_items(conditions)
+
+          combined_conditions = nil
+          conditions.each do |condition|
+            combined_conditions = condition_combine_new(combiner, combined_conditions, condition)
+          end
+          combined_conditions
+        end
+
+        # Combine multiple conditions with a new condition.
+        # @param [Symbol] combiner
+        # @param [Arel::Nodes::Node, Array<Arel::Nodes::Node>] conditions
+        # @param [Arel::Nodes::Node] new_condition
+        # @return [Arel::Nodes::Node] condition
+        def condition_combine_new(combiner, conditions, new_condition)
+          case combiner
+            when :and
+              conditions.nil? ? new_condition : compose_and(conditions, new_condition)
+            when :or
+             conditions.nil? ? new_condition : compose_or(conditions, new_condition)
+            when :not
+              not_condition = compose_not(new_condition)
+              conditions.nil? ? not_condition : compose_and(conditions, not_condition)
+            else
+              fail Clearly::Query::QueryArgumentError.new("unrecognised logical operator '#{combiner}'")
+          end
+        end
+
+
+        # Build a condition.
+        # @param [Symbol] operator
+        # @param [Arel::Table] table
+        # @param [Symbol] column_name
+        # @param [Array<symbol>] valid_fields
+        # @param [Object] value
+        # @return [Arel::Nodes::Node] condition
+        def condition_components(operator, table, column_name, valid_fields, value)
+          validate_table_column(table, column_name, valid_fields)
+          condition_node(operator, table[column_name], value)
+        end
+
+        # Build a condition.
+        # @param [Symbol] operator
+        # @param [Arel::Nodes::Node, Arel::Attributes::Attribute, String] node
+        # @param [Object] value
+        # @return [Arel::Nodes::Node] condition
+        def condition_node(operator, node, value)
+          new_condition = condition_node_comparison(operator, node, value)
+          new_condition = condition_node_subset(operator, node, value) if new_condition.nil?
+          new_condition = compose_null_node(node, value) if new_condition.nil? && [:null, :is_null].include?(operator)
+
+          fail Clearly::Query::QueryArgumentError.new("unrecognised operator '#{operator}'") if new_condition.nil?
+          new_condition
+        end
+
+        # Build a comparison condition.
+        # @param [Symbol] operator
+        # @param [Arel::Nodes::Node, Arel::Attributes::Attribute, String] node
+        # @param [Object] value
+        # @return [Arel::Nodes::Node] condition
+        def condition_node_comparison(operator, node, value)
+          case operator
+            when :eq, :equal
+              compose_eq_node(node, value)
+            when :not_eq, :not_equal
+              compose_not_eq_node(node, value)
+            when :lt, :less_than
+              compose_lt_node(node, value)
+            when :not_lt, :not_less_than
+              compose_not_lt_node(node, value)
+            when :gt, :greater_than
+              compose_gt_node(node, value)
+            when :not_gt, :not_greater_than
+              compose_not_gt_node(node, value)
+            when :lteq, :less_than_or_equal
+              compose_lteq_node(node, value)
+            when :not_lteq, :not_less_than_or_equal
+              compose_not_lteq_node(node, value)
+            when :gteq, :greater_than_or_equal
+              compose_gteq_node(node, value)
+            when :not_gteq, :not_greater_than_or_equal
+              compose_not_gteq_node(node, value)
+            else
+              nil
+          end
+        end
+
+        # Build a range or subset condition.
+        # @param [Symbol] operator
+        # @param [Arel::Nodes::Node, Arel::Attributes::Attribute, String] node
+        # @param [Object] value
+        # @return [Arel::Nodes::Node] condition
+        def condition_node_subset(operator, node, value)
+          case operator
+            when :range, :in_range
+              compose_range_node(node, value)
+            when :not_range, :not_in_range
+              compose_not_range_node(node, value)
+            when :in, :is_in
+              compose_in_node(node, value)
+            when :not_in, :is_not_in
+              compose_not_in_node(node, value)
+            when :contains, :contain
+              compose_contains_node(node, value)
+            when :not_contains, :not_contain, :does_not_contain
+              compose_not_contains_node(node, value)
+            when :starts_with, :start_with
+              compose_starts_with_node(node, value)
+            when :not_starts_with, :not_start_with, :does_not_start_with
+              compose_not_starts_with_node(node, value)
+            when :ends_with, :end_with
+              compose_ends_with_node(node, value)
+            when :not_ends_with, :not_end_with, :does_not_end_with
+              compose_not_ends_with_node(node, value)
+            when :regex, :regex_match, :matches
+              compose_regex_node(node, value)
+            when :not_regex, :not_regex_match, :does_not_match, :not_match
+              compose_not_regex_node(node, value)
+            else
+              nil
+          end
+        end
+
+      end
+    end
+  end
+end