inquery 0.0.1

data/lib/inquery.rb

@@ -0,0 +1,10 @@
+module Inquery
+end
+
+require 'schemacop'
+
+require 'inquery/exceptions'
+require 'inquery/mixins/schema_validation'
+require 'inquery/mixins/relation_validation'
+require 'inquery/query'
+require 'inquery/query/chainable'

data/lib/inquery/exceptions.rb

@@ -0,0 +1,7 @@
+module Inquery
+  module Exceptions
+    class Base < StandardError; end
+    class UnknownCallSignature < Base; end
+    class InvalidRelation < Base; end
+  end
+end

data/lib/inquery/mixins/relation_validation.rb

@@ -0,0 +1,100 @@
+module Inquery
+  module Mixins
+    module RelationValidation
+      extend ActiveSupport::Concern
+
+      OPTIONS_SCHEMA = {
+        hash: {
+          class: { type: String, null: true, required: false },
+          fields: { type: :integer, null: true, required: false },
+          default_select: { type: :symbol, null: true, required: false },
+          default: { type: [Proc, FalseClass], null: true, required: false }
+        }
+      }
+
+      DEFAULT_OPTIONS = {
+        # Allows to restrict the class (attribute `klass`) of the relation. Use
+        # `nil` to not perform any checks. The `class` attribute will also be
+        # taken to infer a default if no relation is given and you didn't
+        # specify any `default`.
+        class: nil,
+
+        # This allows to specify a default relation that will be taken if no
+        # relation is given. This must be specified as a Proc returning the
+        # relation. Set this to `false` for no default. If this is set to `nil`,
+        # it will try to infer the default from the option `class` (if given).
+        default: nil,
+
+        # Allows to restrict the number of fields / values the relation must
+        # select. This is particularly useful if you're using the query as a
+        # subquery and need it to return exactly one field. Use `nil` to not
+        # perform any checks.
+        fields: nil,
+
+        # If this is set to a symbol, the relation does not have any select
+        # fields specified (`select_values` is empty) and `fields` is > 0, it
+        # will automatically select the given field. Use `nil` to disable this
+        # behavior.
+        default_select: :id
+      }
+
+      included do
+        class_attribute :_relation_options
+      end
+
+      module ClassMethods
+        # Allows to configure the parameters of the relation this query operates
+        # on. See {OPTIONS_SCHEMA} for documentation of the options hash.
+        def relation(options = {})
+          Schemacop.validate!(OPTIONS_SCHEMA, options)
+          self._relation_options = options
+        end
+      end
+
+      # Validates (and possibly alters) the given relation according to the
+      # options specified at class level using the `relation` method.
+      def validate_relation!(relation)
+        options = DEFAULT_OPTIONS.dup
+        options.merge!(self.class._relation_options.dup) if self.class._relation_options
+
+        relation_class = options[:class].try(:constantize)
+
+        # ---------------------------------------------------------------
+        # Validate presence
+        # ---------------------------------------------------------------
+        if relation.nil?
+          if options[:default]
+            relation = options[:default].call
+          elsif options[:default].nil? && relation_class
+            relation = relation_class.all
+          else
+            fail Inquery::Exceptions::InvalidRelation, 'A relation must be given for this query.'
+          end
+        end
+
+        # ---------------------------------------------------------------
+        # Validate class
+        # ---------------------------------------------------------------
+        if relation_class && relation_class != relation.klass
+          fail Inquery::Exceptions::InvalidRelation, "Unexpected relation class '#{relation.klass}' for this query, expected a '#{relation_class}'."
+        end
+
+        # ---------------------------------------------------------------
+        # Validate selected fields
+        # ---------------------------------------------------------------
+        fields_count = relation.select_values.size
+
+        if fields_count == 0 && options[:default_select] && options[:fields] && options[:fields] > 0
+          relation = relation.select(options[:default_select])
+          fields_count = 1
+        end
+
+        if !options[:fields].nil? && fields_count != options[:fields]
+          fail Inquery::Exceptions::InvalidRelation, "Expected given relation to select #{options[:fields]} field(s) but got #{fields_count}."
+        end
+
+        return relation
+      end
+    end
+  end
+end

data/lib/inquery/mixins/schema_validation.rb

@@ -0,0 +1,27 @@
+module Inquery
+  module Mixins
+    module SchemaValidation
+      extend ActiveSupport::Concern
+
+      included do
+        class_attribute :_schema
+        self._schema = nil
+      end
+
+      module ClassMethods
+        def schema(schema)
+          fail 'Schema must be a hash.' unless schema.is_a?(Hash)
+
+          unless schema[:type]
+            schema = {
+              type: :hash,
+              hash: schema
+            }
+          end
+
+          self._schema = schema
+        end
+      end
+    end
+  end
+end

data/lib/inquery/query.rb

@@ -0,0 +1,50 @@
+module Inquery
+  class Query
+    include Mixins::SchemaValidation
+
+    attr_reader :params
+
+    # Instantiates the query class using the given arguments
+    # and runs `call` and `process` on it.
+    def self.run(*args)
+      new(*args).run
+    end
+
+    # Instantiates the query class using the given arguments
+    # and runs `call` on it.
+    def self.call(*args)
+      new(*args).call
+    end
+
+    # Instantiates the query class and validates the given params hash (if there
+    # was a validation schema specified).
+    def initialize(params = {})
+      @params = params
+
+      if self.class._schema
+        Schemacop.validate!(self.class._schema, @params)
+      end
+    end
+
+    # Runs both `call` and `process`.
+    def run
+      process(call)
+    end
+
+    # Override this method to perform the actual query.
+    def call
+      fail NotImplementedError
+    end
+
+    # Override this method to perform an optional result postprocessing.
+    def process(results)
+      results
+    end
+
+    # Returns a copy of the query's params, wrapped in an OpenStruct object for
+    # easyer access.
+    def osparams
+      @osparams ||= OpenStruct.new(params)
+    end
+  end
+end

data/lib/inquery/query/chainable.rb

@@ -0,0 +1,53 @@
+module Inquery
+  class Query::Chainable < Query
+    include Inquery::Mixins::RelationValidation
+
+    # Allows using this class as an AR scope.
+    def self.call(*args)
+      return new(*args).call
+    end
+
+    def call(*args)
+      fail args.inspect
+    end
+
+    attr_reader :relation
+
+    def initialize(*args)
+      relation, params = parse_init_args(*args)
+      @relation = validate_relation!(relation)
+      super(params)
+    end
+
+    private
+
+    def parse_init_args(*args)
+      # new(relation)
+      if (args[0].is_a?(ActiveRecord::Relation) || args[0].class < ActiveRecord::Base) && args[1].nil?
+        relation = args[0]
+        params = {}
+
+      # new(params)
+      elsif args[0].is_a?(Hash) && args[1].nil?
+        relation = nil
+        params = args[0]
+
+      # new(relation, params)
+      elsif (args[0].is_a?(ActiveRecord::Relation) || args[0].class < ActiveRecord::Base) && args[1].is_a?(Hash)
+        relation = args[0]
+        params = args[1]
+
+      # new()
+      elsif args.empty?
+        relation = nil
+        params = {}
+
+      # Unknown
+      else
+        fail Inquery::Exceptions::UnknownCallSignature, "Unknown call signature for the query constructor: #{args.collect(&:class)}."
+      end
+
+      return relation, params
+    end
+  end
+end

data/test/db/models.rb

@@ -0,0 +1,20 @@
+require 'queries/group/fetch_green'
+require 'queries/group/fetch_red'
+
+class GroupsUser < ActiveRecord::Base
+  belongs_to :group
+  belongs_to :user
+end
+
+class User < ActiveRecord::Base
+  has_many :groups_users
+  has_many :groups, through: :groups_users
+end
+
+class Group < ActiveRecord::Base
+  has_many :groups_users
+  has_many :users, through: :groups_users
+
+  scope :red, Queries::Group::FetchRed
+  scope :green, Queries::Group::FetchGreen
+end

data/test/db/schema.rb

@@ -0,0 +1,20 @@
+ActiveRecord::Schema.define do
+  self.verbose = false
+
+  create_table :groups, force: true do |t|
+    t.string :name
+    t.string :color
+    t.timestamps
+  end
+
+  create_table :users, force: true do |t|
+    t.string :name
+    t.timestamps
+  end
+
+  create_table :groups_users, force: true do |t|
+    t.integer :group_id
+    t.integer :user_id
+    t.timestamps
+  end
+end

data/test/inquery/query/chainable_test.rb

@@ -0,0 +1,67 @@
+require 'test_helper'
+
+require 'queries/user/fetch_in_group_rel'
+require 'queries/group/filter_with_color'
+
+module Inquery
+  class Query
+    class ChainableTest < Minitest::Unit::TestCase
+      include TestHelper
+
+      def setup
+        self.class.setup_db
+        self.class.setup_base_data
+      end
+
+      def test_fetch_users_in_group_rels
+        result = Queries::User::FetchInGroupRel.run(Group.where('ID IN (1, 2)'))
+        assert_equal User.find([1, 2, 3]), result.to_a
+      end
+
+      def test_fetch_users_in_group_rels_with_select
+        # Fetch all groups user 1 is in
+        group_ids_rel = GroupsUser.where(user_id: 1).select(:group_id)
+
+        # Fetch all users that are in these groups
+        result = Queries::User::FetchInGroupRel.run(group_ids_rel)
+        assert_equal User.find([1, 2, 3]), result.to_a
+      end
+
+      def test_fetch_red_groups
+        result = Queries::Group::FetchRed.run
+        assert_equal Group.find([1]), result.to_a
+      end
+
+      def test_fetch_red_groups_via_scope
+        result = Group.red
+        assert_equal Group.find([1]), result.to_a
+      end
+
+      def test_fetch_green_groups_via_scope
+        result = Group.green
+        assert_equal Group.find([2, 3]), result.to_a
+      end
+
+      def test_fetch_green_groups_via_scope_with_where
+        # Where before
+        result = Group.where('id > 2').green
+        assert_equal Group.find([3]), result.to_a
+
+        # Where after
+        result = Group.green.where('id > 2')
+        assert_equal Group.find([3]), result.to_a
+      end
+
+      def test_fetch_green_groups_with_where
+        # With default scope
+        result = Queries::Group::FetchGreen.run(Group.where('id > 2'))
+        assert_equal Group.find([3]), result.to_a
+      end
+
+      def test_filter_with_color
+        result = Queries::Group::FilterWithColor.run(Group.where('id > 2'), color: 'green')
+        assert_equal Group.find([3]), result.to_a
+      end
+    end
+  end
+end

data/test/inquery/query_test.rb

@@ -0,0 +1,47 @@
+require 'test_helper'
+require 'queries/user/fetch_all'
+require 'queries/user/fetch_in_group'
+require 'queries/group/fetch_as_json'
+
+module Inquery
+  class QueryTest < Minitest::Unit::TestCase
+    include TestHelper
+
+    def setup
+      self.class.setup_db
+      self.class.setup_base_data
+    end
+
+    def test_fetch_all_users
+      result = Queries::User::FetchAll.run
+      assert_equal User.find([1, 2, 3]), result
+    end
+
+    def test_fetch_users_in_group
+      result = Queries::User::FetchInGroup.run(group_id: 1)
+      assert_equal User.find([1, 2]), result.to_a
+
+      result = Queries::User::FetchInGroup.run(group_id: 2)
+      assert_equal User.find([1, 3]), result.to_a
+
+      result = Queries::User::FetchInGroup.run(group_id: 3)
+      assert_equal User.find([2]), result.to_a
+    end
+
+    def test_fetch_users_in_group_with_invalid_schema
+      assert_raises Schemacop::Exceptions::Validation do
+        Queries::User::FetchInGroup.run
+      end
+    end
+
+    def test_fetch_groups_as_json
+      result = Queries::Group::FetchAsJson.call
+      assert_equal Group.all, result
+    end
+
+    def test_fetch_groups_as_json_with_process
+      result = Queries::Group::FetchAsJson.run
+      assert_equal Group.all.to_json, result
+    end
+  end
+end

data/test/queries/group/fetch_as_json.rb

@@ -0,0 +1,13 @@
+module Queries
+  module Group
+    class FetchAsJson < Inquery::Query
+      def call
+        ::Group.all
+      end
+
+      def process(result)
+        result.to_json
+      end
+    end
+  end
+end

data/test/queries/group/fetch_green.rb

@@ -0,0 +1,11 @@
+module Queries
+  module Group
+    class FetchGreen < Inquery::Query::Chainable
+      relation class: 'Group'
+
+      def call
+        relation.where(color: 'green')
+      end
+    end
+  end
+end

data/test/queries/group/fetch_red.rb

@@ -0,0 +1,11 @@
+module Queries
+  module Group
+    class FetchRed < Inquery::Query::Chainable
+      relation class: 'Group'
+
+      def call
+        relation.where(color: 'red')
+      end
+    end
+  end
+end