torque-postgresql 0.1.0

data/lib/torque/postgresql/attributes/type_map.rb

@@ -0,0 +1,46 @@
+module Torque
+  module PostgreSQL
+    module Attributes
+      module TypeMap
+
+        class << self
+
+          # Reader of the list of tyes
+          def types
+            @types ||= {}
+          end
+
+          # Register a type that can be processed by a given block
+          def register_type(key, &block)
+            raise_type_defined(key) if present?(key)
+            types[key] = block
+          end
+
+          # Search for a type match and process it if any
+          def lookup(key, klass, *args)
+            return unless present?(key)
+            klass.instance_exec(key, *args, &types[key.class])
+          rescue LocalJumpError
+            # There's a bug or misbehavior that blocks being called through
+            # instance_exec don't accept neither return nor break
+            return false
+          end
+
+          # Check if the given type class is registered
+          def present?(key)
+            types.key?(key.class)
+          end
+
+          # Message when trying to define multiple types
+          def raise_type_defined(key)
+            raise ArgumentError, <<-MSG.strip
+              Type #{key} is already defined here: #{types[key].source_location.join(':')}
+            MSG
+          end
+
+        end
+
+      end
+    end
+  end
+end

data/lib/torque/postgresql/attributes.rb

@@ -0,0 +1,32 @@
+
+require_relative 'attributes/type_map'
+require_relative 'attributes/lazy'
+
+require_relative 'attributes/builder'
+
+require_relative 'attributes/enum'
+
+module Torque
+  module PostgreSQL
+    module Attributes
+      extend ActiveSupport::Concern
+
+      included do
+        class_attribute :enum_save_on_bang, instance_accessor: true
+        self.enum_save_on_bang = Torque::PostgreSQL.config.enum.save_on_bang
+      end
+
+      module ClassMethods
+        private
+
+          def define_attribute_method(attribute)
+            type = attribute_types[attribute]
+            super unless TypeMap.lookup(type, self, attribute, true)
+          end
+
+      end
+    end
+
+    ActiveRecord::Base.include Attributes
+  end
+end

data/lib/torque/postgresql/auxiliary_statement.rb

@@ -0,0 +1,192 @@
+module Torque
+  module PostgreSQL
+    class AuxiliaryStatement
+
+      # The settings collector class
+      Settings = Collector.new(:attributes, :join, :join_type, :query)
+
+      class << self
+        # These attributes require that the class is setup
+        #
+        # The attributes separation means
+        # exposed_attributes -> Will be projected to the main query
+        # selected_attributes -> Will be selected on the configurated query
+        # join_attributes -> Will be used to join the the queries
+        [:exposed_attributes, :selected_attributes, :join_attributes, :table, :query,
+          :join_type].each do |attribute|
+          define_method(attribute) do
+            setup
+            instance_variable_get("@#{attribute}")
+          end
+        end
+
+        # Find or create the class that will handle statement
+        def lookup(name, base)
+          const = name.to_s.camelize << '_' << self.name.demodulize
+          return base.const_get(const) if base.const_defined?(const)
+          base.const_set(const, Class.new(AuxiliaryStatement))
+        end
+
+        # Set a configuration block, if the class is already set up, just clean
+        # the query and wait it to be setup again
+        def configurator(block)
+          @config = block
+          @query = nil if setup?
+        end
+
+        # Get the base class associated to this statement
+        def base
+          self.parent
+        end
+
+        # Get the arel table of the base class
+        def base_table
+          base.arel_table
+        end
+
+        # Get the arel table of the query
+        def query_table
+          query.arel_table
+        end
+
+        private
+          # Just setup the class if it's not setup
+          def setup
+            setup! unless setup?
+          end
+
+          # Check if the class is setup
+          def setup?
+            defined?(@query) && @query
+          end
+
+          # Setup the class
+          def setup!
+            # attributes key
+            # Provides a map of attributes to be exposed to the main query.
+            #
+            # For instace, if the statement query has an 'id' column that you
+            # want it to be accessed on the main query as 'item_id',
+            # you can use:
+            #   attributes id: :item_id
+            #
+            # If its statement has more tables, and you want to expose those
+            # fields, then:
+            #   attributes 'table.name': :item_name
+            #
+            # join_type key
+            # Changes the type of the join and set the constraints
+            #
+            # The left side of the hash is the source table column, the right
+            # side is the statement table column, now it's only accepting '='
+            # constraints
+            #   join id: :user_id
+            #   join id: :'user.id'
+            #   join 'post.id': :'user.last_post_id'
+            #
+            # It's possible to change the default type of join
+            #   join :left, id: :user_id
+            #
+            # join key
+            # Changes the type of the join
+            #
+            # query key
+            # Save the query command to be performand
+            settings = Settings.new
+            @config.call(settings)
+
+            table_name = self.name.demodulize.split('_').first.underscore
+            @join_type = settings.join_type || :inner
+            @table = Arel::Table.new(table_name)
+            @query = settings.query
+
+            @selected_attributes = []
+            @exposed_attributes = []
+            @join_attributes = []
+
+            # Iterate the attributes settings
+            # Attributes (left => right)
+            #   left -> query.selected_attributes AS right
+            #   right -> table.exposed_attributes
+            settings.attributes.each do |left, right|
+              @exposed_attributes << project(right)
+              @selected_attributes << project(left, query_table).as(right.to_s)
+            end
+
+            # Iterate the join settings
+            # Join (left => right)
+            #   left -> base.join_attributes.eq(right)
+            #   right -> table.selected_attributes
+            if settings.join.nil?
+              check_auto_join
+            else
+              settings.join.each do |left, right|
+                @selected_attributes << project(right, query_table)
+                @join_attributes << project(left, base_table).eq(project(right))
+              end
+            end
+          end
+
+          # Check if it's possible to identify the connection between the main
+          # query and the statement query
+          def check_auto_join
+            foreign_key = base.name.foreign_key
+            if query.columns_hash.key?(foreign_key)
+              primary_key = project(base.primary_key, base_table)
+              @selected_attributes << project(foreign_key, query_table)
+              @join_attributes << primary_key.eq(project(foreign_key))
+            end
+          end
+
+          # Project a column on a given table, or use the column table
+          def project(column, table = @table)
+            if column.to_s.include?('.')
+              table, column = column.split('.')
+              table = Arel::Table.new(table)
+            end
+
+            table[column]
+          end
+      end
+
+      # Start a new auxiliary statement giving extra options
+      def initialize(*args)
+        @options = args.extract_options!
+      end
+
+      # Get the columns that will be selected for this statement
+      def columns
+        self.class.exposed_attributes
+      end
+
+      # Build the statement on the given arel and return the WITH statement
+      def build_arel(arel)
+        klass = self.class
+        query = klass.query.select(*klass.selected_attributes)
+
+        # Build the join for this statement
+        arel.join(klass.table, arel_join).on(*klass.join_attributes)
+
+        # Return the subquery for this statement
+        Arel::Nodes::As.new(klass.table, query.send(:build_arel))
+      end
+
+      private
+
+        # Get the class of the join on arel
+        def arel_join
+          case @options.fetch(:join_type, self.class.join_type)
+          when :inner then Arel::Nodes::InnerJoin
+          when :left then Arel::Nodes::OuterJoin
+          when :right then Arel::Nodes::RightOuterJoin
+          when :full then Arel::Nodes::FullOuterJoin
+          else
+            raise ArgumentError, <<-MSG.gsub(/^ +| +$|\n/, '')
+              The '#{@join_type}' is not implemented as a join type.
+            MSG
+          end
+        end
+
+    end
+  end
+end

data/lib/torque/postgresql/base.rb

@@ -0,0 +1,28 @@
+module Torque
+  module PostgreSQL
+    module Base
+      extend ActiveSupport::Concern
+
+      included do
+        class_attribute :auxiliary_statements_list, instance_accessor: true
+        self.auxiliary_statements_list = {}
+      end
+
+      module ClassMethods
+        delegate :distinct_on, :with, to: :all
+
+        protected
+
+          # Creates a new auxiliary statement (CTE) under the base class
+          def auxiliary_statement(table, &block)
+            klass = AuxiliaryStatement.lookup(table, self)
+            auxiliary_statements_list[table.to_sym] = klass
+            klass.configurator(block)
+          end
+          alias cte auxiliary_statement
+      end
+    end
+
+    ActiveRecord::Base.include Base
+  end
+end

data/lib/torque/postgresql/collector.rb

@@ -0,0 +1,31 @@
+module Torque
+  module PostgreSQL
+    module Collector
+
+      def self.new(*args)
+        klass = Class.new
+
+        args.flatten!
+        args.compact!
+
+        klass.module_eval do
+          args.each do |attribute|
+            define_method attribute do |*args|
+              if args.empty?
+                instance_variable_get("@#{attribute}")
+              elsif args.size > 1
+                instance_variable_set("@#{attribute}", args)
+              else
+                instance_variable_set("@#{attribute}", args.first)
+              end
+            end
+            alias_method "#{attribute}=", attribute
+          end
+        end
+
+        klass
+      end
+
+    end
+  end
+end

data/lib/torque/postgresql/config.rb

@@ -0,0 +1,50 @@
+module Torque
+  module PostgreSQL
+    include ActiveSupport::Configurable
+
+    # Allow nested configurations
+    config.define_singleton_method(:nested) do |name, &block|
+      klass = Class.new(ActiveSupport::Configurable::Configuration).new
+      block.call(klass) if block
+      send("#{name}=", klass)
+    end
+
+    # Configure ENUM features
+    config.nested(:enum) do |enum|
+
+      # Indicates if the enum features on ActiveRecord::Base should be initiated
+      # automatically or not
+      enum.initializer = false
+
+      # The name of the method to be used on any ActiveRecord::Base to
+      # initialize model-based enum features
+      enum.base_method = :enum
+
+      # Indicates if bang methods like 'disabled!' should update the record on
+      # database or not
+      enum.save_on_bang = true
+
+      # Specify the namespace of each enum type of value
+      enum.namespace = ::Object.const_set('Enum', Module.new)
+
+      # Specify the scopes for I18n translations
+      enum.i18n_scopes = [
+        'activerecord.attributes.%{model}.%{attr}.%{value}',
+        'activerecord.attributes.%{attr}.%{value}',
+        'activerecord.enums.%{type}.%{value}',
+        'enum.%{type}.%{value}',
+        'enum.%{value}'
+      ]
+
+      # Specify the scopes for I18n translations but with type only
+      enum.i18n_type_scopes = Enumerator.new do |yielder|
+        enum.i18n_scopes.each do |key|
+          next if key.include?('%{model}') || key.include?('%{attr}')
+          yielder << key
+        end
+      end
+
+    end
+
+  end
+end

data/lib/torque/postgresql/migration/command_recorder.rb

@@ -0,0 +1,31 @@
+module Torque
+  module PostgreSQL
+    module Migration
+      module CommandRecorder
+
+        # Records the rename operation for types.
+        def rename_type(*args, &block)
+          record(:rename_type, args, &block)
+        end
+
+        # Inverts the type name.
+        def invert_rename_type(args)
+          [:rename_type, args.reverse]
+        end
+
+        # Records the creation of the enum to be reverted.
+        def create_enum(*args, &block)
+          record(:create_enum, args, &block)
+        end
+
+        # Inverts the creation of the enum.
+        def invert_create_enum(args)
+          [:drop_type, [args.first]]
+        end
+
+      end
+
+      ActiveRecord::Migration::CommandRecorder.include CommandRecorder
+    end
+  end
+end

data/lib/torque/postgresql/migration.rb

@@ -0,0 +1 @@
+require_relative 'migration/command_recorder'

data/lib/torque/postgresql/relation/auxiliary_statement.rb

@@ -0,0 +1,65 @@
+module Torque
+  module PostgreSQL
+    module Relation
+      module AuxiliaryStatement
+
+        attr_accessor :auxiliary_statements
+
+        # Set use of an auxiliary statement already configurated on the model
+        def with(*args)
+          spawn.with!(*args)
+        end
+
+        # Like #with, but modifies relation in place.
+        def with!(*args)
+          options = args.extract_options!
+          self.auxiliary_statements ||= []
+          args.each do |table|
+            unless self.auxiliary_statements_list.key?(table)
+              raise ArgumentError, <<-MSG.gsub(/^ +| +$|\n/, '')
+                There's no '#{table}' auxiliary statement defined for #{self.class.name}.
+              MSG
+            end
+
+            klass = self.auxiliary_statements_list[table]
+            self.auxiliary_statements << klass.new(options)
+          end
+          self
+        end
+
+        private
+
+          # Hook arel build to add the distinct on clause
+          def build_arel
+            arel = super
+
+            if self.auxiliary_statements.present?
+              columns = []
+              subqueries = self.auxiliary_statements.map do |klass|
+                columns << klass.columns
+                klass.build_arel(arel)
+              end
+
+              arel.with(subqueries)
+              if select_values.empty? && columns.any?
+                columns.unshift table[Arel.sql('*')]
+                arel.projections = columns
+              end
+            end
+
+            arel
+          end
+
+          # Throw an error showing that an auxiliary statement of the given
+          # table name isn't defined
+          def auxiliary_statement_error(name)
+            raise ArgumentError, <<-MSG.gsub(/^ +| +$|\n/, '')
+              There's no '#{name}' auxiliary statement defined for
+              #{self.class.name}.
+            MSG
+          end
+
+      end
+    end
+  end
+end