active_house 0.4.0 → 0.5.0

data/lib/active_house/limitable.rb

@@ -1,27 +0,0 @@
-module ActiveHouse
-  module Limitable
-    extend ActiveSupport::Concern
-
-    included do
-      private
-
-      def build_limit_query_part
-        return if @limit[:limit].nil?
-        if @limit[:offset]
-          "LIMIT #{@limit[:limit]}, #{@limit[:offset]}"
-        else
-          "LIMIT #{@limit[:limit]}"
-        end
-      end
-    end
-
-    def initialize(*)
-      @limit = { offset: nil, limit: nil }
-      super
-    end
-
-    def limit(limit_value, offset_value = nil)
-      chain_query limit: { offset: offset_value || @limit[:offset], limit: limit_value }
-    end
-  end
-end

data/lib/active_house/modeling.rb

@@ -1,100 +0,0 @@
-require 'active_support/concern'
-
-module ActiveHouse
-  module Modeling
-    extend ActiveSupport::Concern
-
-    included do
-      class_attribute :_attribute_opts, instance_writer: false
-      self._attribute_opts = {}
-
-      private
-
-      def parse_attribute_method_name(method_name)
-        name, is_setter = method_name.to_s.match(/\A(.+)?(=)?\z/).captures
-        name = name.to_sym
-        is_setter = !is_setter.nil?
-        [name, is_setter]
-      end
-
-      def attribute_method?(name, is_setter, *args)
-        (_attribute_opts.key?(name) || @_attributes.key?(name)) && (is_setter ? args.size == 1 : true)
-      end
-
-      def get_attribute(name)
-        @_attributes[name]
-      end
-
-      def set_attribute(name, value)
-        opts = _attribute_opts.fetch(name, {})
-        value = opts[:cast].call(value) if opts[:cast]
-        @_attributes[name] = value
-      end
-    end
-
-    class_methods do
-      def attribute(name, options = {})
-        name = name.to_sym
-        self._attribute_opts = _attribute_opts.merge(name => options)
-        define_method(name) do
-          get_attribute(name)
-        end
-        define_method("#{name}=") do |value|
-          set_attribute(name, value)
-        end
-      end
-
-      def attributes(*names)
-        options = names.extract_options!
-        names.each { |name| attribute(name, options.dup) }
-      end
-
-      def load!(params)
-        new.tap do |model|
-          params.each { |name, value| model[name] = value }
-        end
-      end
-    end
-
-    def initialize(params = {})
-      @_attributes = {}
-      assign_attributes(params) unless params.nil?
-    end
-
-    def as_json(*_args)
-      to_h
-    end
-
-    def to_h
-      @_attributes.dup
-    end
-
-    def [](key)
-      get_attribute(key.to_sym)
-    end
-
-    def []=(key, value)
-      set_attribute(key.to_sym, value)
-    end
-
-    def assign_attributes(params)
-      params.each do |key, val|
-        public_send("#{key}=", val)
-      end
-    end
-
-    def respond_to_missing?(method_name, *args)
-      name, is_setter = parse_attribute_method_name(method_name)
-      attribute_method?(name, is_setter, *args)
-    end
-
-    def method_missing(method_name, *args, &block)
-      name, is_setter = parse_attribute_method_name(method_name)
-      if attribute_method?(name, is_setter, *args)
-        is_setter ? set_attribute(name, args.first) : get_attribute(name)
-      else
-        super
-      end
-    end
-  end
-end

data/lib/active_house/orderable.rb

@@ -1,45 +0,0 @@
-require 'active_support/core_ext/object/try'
-
-module ActiveHouse
-  module Orderable
-    extend ActiveSupport::Concern
-
-    included do
-      private
-
-      def build_order_by_query_part
-        "ORDER BY #{@ordering.join(', ')}" unless @ordering.empty?
-      end
-    end
-
-    def initialize(*)
-      @ordering = []
-      super
-    end
-
-    def order_by(*clauses)
-      raise ArgumentError, 'wrong number of arguments' if clauses.empty?
-      formatter_clauses = clauses.map do |clause|
-        if clause.is_a?(String)
-          clause
-        elsif clause.is_a?(Symbol)
-          clause.to_s
-        elsif clause.is_a?(Hash)
-          if clause.keys.one?
-            direction = clause.values.first
-            raise ArgumentError, 'direction must be asc or desc' unless [:asc, :desc].include?(direction.try!(:to_sym))
-            "#{clause.keys.first} #{direction.to_s.upcase}"
-          else
-            clause.assert_valid_keys(:field, :direction, :collate)
-            [
-                clause.fetch(:field),
-                clause[:direction].try!(:to_s).try!(:upcase),
-                clause.key?(:collate) ? "COLLATE '#{clause[:collate]}'" : nil
-            ].reject(&:nil?).join(' ')
-          end
-        end
-      end
-      chain_query ordering: (@ordering + formatter_clauses).uniq
-    end
-  end
-end

data/lib/active_house/query.rb

@@ -1,22 +0,0 @@
-require_relative 'chainable'
-require_relative 'scopeable'
-require_relative 'collectable'
-
-module ActiveHouse
-  class Query
-    attr_reader :model_class
-
-    def initialize(model_class = ActiveHouse::Model)
-      @model_class = model_class
-      super()
-    end
-
-    def connection
-      model_class.connection
-    end
-
-    include ActiveHouse::Chainable
-    include ActiveHouse::Collectable
-    include ActiveHouse::Scopeable
-  end
-end

data/lib/active_house/querying.rb

@@ -1,21 +0,0 @@
-require 'active_support/concern'
-require 'active_support/core_ext/module/delegation'
-
-module ActiveHouse
-  module Querying
-    extend ActiveSupport::Concern
-
-    included do
-      class_attribute :_query_class, instance_accessor: false
-      self._query_class = ActiveHouse::Query
-    end
-
-    class_methods do
-      delegate :to_a, :select, :where, :group_by, :limit, :order_by, :having, :from, to: :all
-
-      def all
-        _query_class.new(self)
-      end
-    end
-  end
-end

data/lib/active_house/scopeable.rb

@@ -1,42 +0,0 @@
-require 'active_support/concern'
-
-module ActiveHouse
-  module Scopeable
-    extend ActiveSupport::Concern
-
-    included do
-      private
-
-      def apply_scope(name, *args)
-        scope = model_class._scopes.fetch(name.to_sym)
-        instance_exec(*args, &scope)
-      end
-
-      def scope?(name)
-        model_class._scopes.key?(name.to_sym)
-      end
-
-      def apply_default_scope
-        return if model_class._default_scope.nil?
-        apply_scope(model_class._default_scope)
-      end
-    end
-
-    def initialize(*)
-      super
-      with_current_query { apply_default_scope }
-    end
-
-    def respond_to_missing?(method_name, *_args)
-      scope?(method_name) || super
-    end
-
-    def method_missing(method_name, *args, &_block)
-      if scope?(method_name)
-        apply_scope(method_name, *args)
-      else
-        super
-      end
-    end
-  end
-end

data/lib/active_house/scoping.rb

@@ -1,37 +0,0 @@
-require 'active_support/concern'
-
-module ActiveHouse
-  module Scoping
-    extend ActiveSupport::Concern
-
-    included do
-      class_attribute :_default_scope, instance_accessor: false
-      class_attribute :_scopes, instance_accessor: false
-      self._scopes = {}
-    end
-
-    class_methods do
-      def default_scope(name)
-        self._default_scope = name.to_sym
-      end
-
-      def scope(name, block)
-        self._scopes = _scopes.merge(name.to_sym => block)
-      end
-
-      def respond_to_missing?(method_name, *_args)
-        _scopes.key?(method_name.to_sym)
-      end
-
-      def method_missing(method_name, *args, &_block)
-        method_name = method_name.to_sym
-        if _scopes.key?(method_name)
-          scope = _scopes.fetch(method_name)
-          all.instance_exec(*args, &scope)
-        else
-          super
-        end
-      end
-    end
-  end
-end

data/lib/active_house/selectable.rb

@@ -1,35 +0,0 @@
-module ActiveHouse
-  module Selectable
-    extend ActiveSupport::Concern
-
-    included do
-      private
-
-      def build_select_query_part
-        if !@fields.empty?
-          "SELECT\n#{@fields.join(",\n")}"
-        else
-          'SELECT *'
-        end
-      end
-    end
-
-    def initialize(*)
-      @fields = []
-      super
-    end
-
-    def select(*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 fields: (@fields + formatted_fields).uniq
-    end
-  end
-end

data/lib/active_house/unionable.rb

@@ -1,43 +0,0 @@
-module ActiveHouse
-  module Unionable
-    extend ActiveSupport::Concern
-
-    included do
-      private
-
-      def build_union_query_part
-        "UNION ALL\n#{@unions.values.map(&:to_query).join("\n")}" unless @unions.values.empty?
-      end
-    end
-
-    def initialize(*)
-      @unions = {}
-      super
-    end
-
-    def union(name, query)
-      query = query.all if query.is_a?(ActiveHouse::Model)
-      raise ArgumentError, 'argument must be model or query object' unless query.is_a?(ActiveHouse::Query)
-      new_unions = @unions.map { |n, q| [n, q.dup] }.to_h
-      new_unions[name] = query.dup
-      chain_query unions: new_unions
-    end
-
-    def update_union(name)
-      raise ArgumentError, "can't find union by name #{name}" unless @unions.key?(name)
-      new_union = yield union_for(name)
-      union(name, new_union)
-    end
-
-    def union_for(name)
-      raise ArgumentError, "can't find union by name #{name}" unless @unions.key?(name)
-      @unions[name].dup
-    end
-
-    def except_union(name)
-      new_unions = @unions.map { |n, q| [n, q.dup] }.to_h
-      new_unions.delete(name)
-      chain_query unions: new_unions
-    end
-  end
-end

data/lib/active_house/whereable.rb

@@ -1,57 +0,0 @@
-require_relative 'prepared_statement'
-require 'active_support/core_ext/array/wrap'
-
-module ActiveHouse
-  module Whereable
-    extend ActiveSupport::Concern
-
-    included do
-      private
-
-      def format_condition(*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_condition(value)} #{ActiveHouse::PreparedStatement.format_value(value)}"
-          end
-        else
-          condition.to_s
-        end
-      end
-
-      def sign_for_condition(value)
-        if value.is_a?(Array)
-          'IN'
-        elsif value.nil?
-          'IS'
-        else
-          '='
-        end
-      end
-
-      def build_where_query_part
-        "WHERE\n" + @conditions.join(" AND\n") unless @conditions.empty?
-      end
-    end
-
-    def initialize(*)
-      @conditions = []
-      super
-    end
-
-    def where(*conditions)
-      raise ArgumentError, 'wrong number of arguments' if conditions.empty?
-      formatted_conditions = Array.wrap(format_condition(*conditions))
-      chain_query conditions: (@conditions + formatted_conditions).uniq
-    end
-
-    def where_not(*conditions)
-      raise ArgumentError, 'wrong number of arguments' if conditions.empty?
-      formatted_conditions = Array.wrap(format_condition(*conditions))
-      negative_condition = "NOT (#{formatted_conditions.join(' AND ')})"
-      chain_query conditions: (@conditions + [negative_condition]).uniq
-    end
-  end
-end