active_house 0.4.0 → 0.5.0

data/lib/active_house/version.rb

@@ -1,3 +1,3 @@
 module ActiveHouse
-  VERSION = '0.4.0'.freeze
+  VERSION = '0.5.0'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: active_house
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Denis Talakevich
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-08-02 00:00:00.000000000 Z
+date: 2019-08-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel
@@ -52,6 +52,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 0.1.10
+- !ruby/object:Gem::Dependency
+  name: plain_model
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -113,31 +127,29 @@ files:
 - bin/console
 - bin/setup
 - lib/active_house.rb
-- lib/active_house/array_joinable.rb
-- lib/active_house/chainable.rb
-- lib/active_house/collectable.rb
 - lib/active_house/configuration.rb
-- lib/active_house/connecting.rb
 - lib/active_house/connection.rb
-- lib/active_house/connection_error.rb
-- lib/active_house/error.rb
-- lib/active_house/fromable.rb
-- lib/active_house/groupable.rb
-- lib/active_house/havingable.rb
-- lib/active_house/limitable.rb
-- lib/active_house/logger.rb
+- lib/active_house/exceptions.rb
+- lib/active_house/logging.rb
 - lib/active_house/model.rb
-- lib/active_house/modeling.rb
-- lib/active_house/orderable.rb
+- lib/active_house/modeling/attributes.rb
+- lib/active_house/modeling/connection.rb
+- lib/active_house/modeling/query.rb
+- lib/active_house/modeling/scope.rb
 - lib/active_house/prepared_statement.rb
-- lib/active_house/query.rb
-- lib/active_house/querying.rb
-- lib/active_house/scopeable.rb
-- lib/active_house/scoping.rb
-- lib/active_house/selectable.rb
-- lib/active_house/unionable.rb
+- lib/active_house/query_builder.rb
+- lib/active_house/querying/array_join.rb
+- lib/active_house/querying/collect.rb
+- lib/active_house/querying/from.rb
+- lib/active_house/querying/group_by.rb
+- lib/active_house/querying/having.rb
+- lib/active_house/querying/limit.rb
+- lib/active_house/querying/order_by.rb
+- lib/active_house/querying/scope.rb
+- lib/active_house/querying/select.rb
+- lib/active_house/querying/union.rb
+- lib/active_house/querying/where.rb
 - lib/active_house/version.rb
-- lib/active_house/whereable.rb
 homepage: https://github.com/senid231/active_house
 licenses:
 - MIT

data/lib/active_house/array_joinable.rb

@@ -1,31 +0,0 @@
-module ActiveHouse
-  module ArrayJoinable
-    extend ActiveSupport::Concern
-
-    included do
-      private
-
-      def build_array_join_query_part
-        "ARRAY JOIN #{@array_joins.join(', ')}" unless @array_joins.empty?
-      end
-    end
-
-    def initialize(*)
-      @array_joins = []
-      super
-    end
-
-    def array_join(*fields)
-      raise ArgumentError, 'wrong number of arguments' if fields.empty?
-      formatted_fields = fields.map do |field|
-        if field.is_a?(Symbol) && model_class._attribute_opts.key?(field)
-          opts = model_class._attribute_opts.fetch(field)
-          opts.key?(:select) ? "#{opts[:select]} AS #{field}" : field.to_s
-        else
-          field.to_s
-        end
-      end
-      chain_query array_joins: (@array_joins + formatted_fields).uniq
-    end
-  end
-end

data/lib/active_house/chainable.rb

@@ -1,151 +0,0 @@
-require_relative 'selectable'
-require_relative 'fromable'
-require_relative 'whereable'
-require_relative 'orderable'
-require_relative 'groupable'
-require_relative 'limitable'
-require_relative 'havingable'
-require_relative 'unionable'
-require_relative 'array_joinable'
-require 'active_support/concern'
-
-module ActiveHouse
-  module Chainable
-    extend ActiveSupport::Concern
-
-    include ActiveHouse::Selectable
-    include ActiveHouse::Fromable
-    include ActiveHouse::Whereable
-    include ActiveHouse::Orderable
-    include ActiveHouse::Groupable
-    include ActiveHouse::Havingable
-    include ActiveHouse::Limitable
-    include ActiveHouse::Unionable
-    include ActiveHouse::ArrayJoinable
-
-    included do
-      protected
-
-      def data
-        chain_methods.values.map { |var| [var, instance_variable_get(:"@#{var}")] }.to_h
-      end
-
-      def data=(other_data)
-        chain_methods.values.each do |var|
-          value = other_data.fetch(var)
-          instance_variable_set(:"@#{var}", value.nil? ? nil : value.dup)
-        end
-      end
-
-      def query_parts
-        [
-            build_select_query_part,
-            build_from_query_part,
-            build_array_join_query_part,
-            build_where_query_part,
-            build_group_by_query_part,
-            build_having_query_part,
-            build_order_by_query_part,
-            build_limit_query_part,
-            build_union_query_part
-        ]
-      end
-
-      def build_query
-        query_parts.reject(&:nil?).join("\n")
-      end
-
-      private
-
-      # By default each chain method (select, where, group_by) returns new instance of query
-      # but in some cases we need to modify and return existing query object
-      # (for example when we apply default_scope on query initialize).
-      # For this you need just to wrap code that appends chain methods with #with_current_query.
-      # Example:
-      #
-      #   scope1 = SomeModel.all # object id #1
-      #   scope2 = scope1.where(id: 3) # object id #2
-      #   scope3 = scope2.send(:with_current_query) { scope2.where(success: true) } # object id #2
-      #
-      def with_current_query
-        @_with_current_query = true
-        yield
-      ensure
-        @_with_current_query = false
-      end
-
-      def chain_query(options = {})
-        options.assert_valid_keys(*chain_methods.values)
-        if @_with_current_query
-          self.data = data.merge(options)
-          self
-        else
-          new_instance = self.class.new(model_class)
-          new_instance.data = data.merge(options)
-          new_instance
-        end
-      end
-    end
-
-    def initialize(*)
-      @_with_current_query = false
-      super
-    end
-
-    # key - chain method name
-    # value - instance variable name that which store values
-    def chain_methods
-      {
-          select: :fields,
-          where: :conditions,
-          group_by: :grouping,
-          order_by: :ordering,
-          limit: :limit,
-          having: :having,
-          union: :unions,
-          from: :subquery,
-          array_join: :array_joins
-      }
-    end
-
-    # key - instance variable name that which store values
-    # value - default value for the variable
-    def chain_defaults
-      {
-          fields: [],
-          conditions: [],
-          grouping: [],
-          ordering: [],
-          limit: { offset: nil, limit: nil },
-          having: [],
-          union: {},
-          subquery: nil,
-          array_joins: []
-      }
-    end
-
-    def except(*values)
-      raise ArgumentError, 'wrong number of arguments' if values.empty?
-      not_allowed = values - chain_methods.keys
-      unless not_allowed.empty?
-        raise ArgumentError, "Values #{not_allowed} are not allowed, allowed only #{chain_methods.keys}."
-      end
-
-      new_data = {}
-      chain_methods.each do |meth, var|
-        new_data[var] = chain_defaults[var].dup if values.include?(meth)
-      end
-      chain_query(new_data)
-    end
-
-    def to_query
-      build_query
-    end
-
-    def dup
-      chain_query
-    end
-
-    alias clone dup
-  end
-end

data/lib/active_house/collectable.rb

@@ -1,44 +0,0 @@
-require 'active_support/concern'
-require 'active_support/core_ext/string/filters'
-require 'active_support/core_ext/module/delegation'
-
-module ActiveHouse
-  module Collectable
-    extend ActiveSupport::Concern
-
-    def initialize(*)
-      @collection = nil
-      super
-    end
-
-    def to_a
-      collection
-    end
-
-    def reset
-      @collection = nil
-    end
-
-    def loaded?
-      !@collection.nil?
-    end
-
-    def to_hashes
-      connection.select_rows(to_query.squish)
-    end
-
-    def collection
-      @collection ||= fetch_collection
-    end
-
-    def fetch_collection
-      to_hashes.map { |row| model_class.load!(row) }
-    end
-
-    included do
-      private :collection, :fetch_collection
-      delegate :each, :size, :count, :map, :collect, :detect, :filter, :reject, :inject, :reduce, :all?, :any?,
-               to: :to_a
-    end
-  end
-end

data/lib/active_house/connecting.rb

@@ -1,36 +0,0 @@
-require_relative 'connection'
-require_relative 'configuration'
-require 'active_support/core_ext/class/attribute'
-require 'active_support/concern'
-
-module ActiveHouse
-  module Connecting
-    extend ActiveSupport::Concern
-
-    included do
-      class_attribute :_connection_class, instance_accessor: false
-      class_attribute :_connection, instance_accessor: false
-      self._connection_class = ActiveHouse::Connection
-    end
-
-    class_methods do
-      def ensure_connection
-        establish_connection if _connection.nil?
-      end
-
-      def establish_connection(name_or_config = nil)
-        config = if name_or_config.is_a?(Hash)
-                   name_or_config.symbolize_keys
-                 else
-                   ActiveHouse.configuration.connection_config_for(name_or_config)
-                 end
-        self._connection = _connection_class.new(config)
-      end
-
-      def connection
-        ensure_connection
-        _connection
-      end
-    end
-  end
-end

data/lib/active_house/connection_error.rb

@@ -1,6 +0,0 @@
-require_relative 'error'
-
-module ActiveHouse
-  class ConnectionError < Error
-  end
-end

data/lib/active_house/error.rb

@@ -1,4 +0,0 @@
-module ActiveHouse
-  class Error < ::StandardError
-  end
-end

data/lib/active_house/fromable.rb

@@ -1,29 +0,0 @@
-module ActiveHouse
-  module Fromable
-    extend ActiveSupport::Concern
-
-    included do
-      private
-
-      def from_subquery
-        return model_class._table_name if @subquery.nil?
-        query = @subquery.is_a?(ActiveHouse::Query) ? @subquery.to_query : @subquery
-        "( #{query} )"
-      end
-
-      def build_from_query_part
-        "FROM #{from_subquery}"
-      end
-    end
-
-    def initialize(*)
-      @subquery = nil
-      super
-    end
-
-    def from(table_or_subquery)
-      raise ArgumentError, '' if !table_or_subquery.is_a?(ActiveHouse::Query) && !table_or_subquery.is_a?(String)
-      chain_query subquery: table_or_subquery.dup
-    end
-  end
-end

data/lib/active_house/groupable.rb

@@ -1,23 +0,0 @@
-module ActiveHouse
-  module Groupable
-    extend ActiveSupport::Concern
-
-    included do
-      private
-
-      def build_group_by_query_part
-        "GROUP BY #{@grouping.join(', ')}" unless @grouping.empty?
-      end
-    end
-
-    def initialize(*)
-      @grouping = []
-      super
-    end
-
-    def group_by(*fields)
-      raise ArgumentError, 'wrong number of arguments' if fields.empty?
-      chain_query grouping: (@grouping + fields.map(&:to_s)).uniq
-    end
-  end
-end

data/lib/active_house/havingable.rb

@@ -1,50 +0,0 @@
-require_relative 'prepared_statement'
-require 'active_support/core_ext/array/wrap'
-
-module ActiveHouse
-  module Havingable
-    extend ActiveSupport::Concern
-
-    included do
-      private
-
-      def format_having(*conditions)
-        raise ArgumentError, 'wrong number of arguments' if conditions.empty?
-        return ActiveHouse::PreparedStatement.prepare_sql(*conditions) if conditions.size > 1
-        condition = conditions.first
-        if condition.is_a?(Hash)
-          condition.map do |field, value|
-            "#{field} #{sign_for_having(value)} #{ActiveHouse::PreparedStatement.format_value(value)}"
-          end
-        else
-          condition.to_s
-        end
-      end
-
-      def sign_for_having(value)
-        if value.is_a?(Array)
-          'IN'
-        elsif value.nil?
-          'IS'
-        else
-          '='
-        end
-      end
-
-      def build_having_query_part
-        "HAVING\n" + @having.join(" AND\n") unless @having.empty?
-      end
-    end
-
-    def initialize(*)
-      @having = []
-      super
-    end
-
-    def having(*conditions)
-      raise ArgumentError, 'wrong number of arguments' if conditions.empty?
-      formatted_conditions = Array.wrap(format_having(*conditions))
-      chain_query having: (@having + formatted_conditions).uniq
-    end
-  end
-end