torque-postgresql 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d27d24270072d57ca693a53b5fcd29ac72b509e0
-  data.tar.gz: cc63789993cf2817a2857d6cf5c6b8d31c38dabb
+  metadata.gz: c3d142177c865c53b93ad0cb573190bfa6ef2e8a
+  data.tar.gz: a3918f964ab43868da70397ef8c8c43b45f5b10c
 SHA512:
-  metadata.gz: 8b6bd7dc8af51496eecd1c7c7a33f4d3ce8e885e7918668068b8ecf8e7ac9961c1ee4cfe342ecf46c31ccead863b82fe4c3296e523cffd28a5d4ce4c7499be75
-  data.tar.gz: 41141267915f0e8ad1d5b6052cab7cc45c9e2bb37ff4d02fc4e819a4c8cf199ba33ea924884c8732bfd691c354908e330f8390e8836906806bc7e685ce2d7f84
+  metadata.gz: 85930c4a51a9684caf780ae88d5a25b965f3a24c0112a20b3a90216e714a106b9738b56b889598d6e446ab1a75ab6fbc92c69847ee0414edc0d5aaa4c5e93f86
+  data.tar.gz: 08bebcce0d9e68da7c937582d5988d40038738c3c850d26842d3ec04e95c63cd07f2a394ce83a8aee035ddf36253d6bbf619a16ac43ef1e041913cb35dee205d

data/lib/torque/postgresql.rb

@@ -1,3 +1,4 @@
+require 'i18n'
 require 'active_model'
 require 'active_record'
 require 'active_support'
@@ -9,6 +10,7 @@ require 'torque/postgresql/config'
 require 'torque/postgresql/version'
 require 'torque/postgresql/collector'
 
+require 'torque/postgresql/i18n'
 require 'torque/postgresql/adapter'
 require 'torque/postgresql/attributes'
 require 'torque/postgresql/auxiliary_statement'

data/lib/torque/postgresql/adapter/database_statements.rb

@@ -46,7 +46,7 @@ module Torque
             INNER JOIN  pg_type a ON (a.oid = t.typarray)
             LEFT JOIN   pg_catalog.pg_namespace n ON n.oid = t.typnamespace
             WHERE       n.nspname NOT IN ('pg_catalog', 'information_schema')
-            AND     t.typtype IN ( 'c','e' )
+            AND     t.typtype IN ( 'e' )
             #{filter}
             AND     NOT EXISTS(
                       SELECT 1 FROM pg_catalog.pg_type el

data/lib/torque/postgresql/adapter/oid.rb

@@ -1,4 +1,3 @@
-require_relative 'oid/array'
 require_relative 'oid/enum'
 require_relative 'oid/interval'
 

data/lib/torque/postgresql/attributes/builder/enum.rb

@@ -64,13 +64,13 @@ module Torque
             return false
           rescue Interrupt => err
             if !initial
-              raise ArgumentError, <<-MSG.gsub(/^ +| +$|\n/, '')
+              raise ArgumentError, <<-MSG.strip.gsub(/\n +/, ' ')
                 #{subtype.class.name} was not able to generate requested
                 methods because the method #{err} already exists in
                 #{klass.name}.
               MSG
             else
-              warn <<-MSG.gsub(/^ +| +$|\n/, '')
+              warn <<-MSG.strip.gsub(/\n +/, ' ')
                 #{subtype.class.name} was not able to autoload on
                 #{klass.name} because the method #{err} already exists.
               MSG

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

@@ -137,7 +137,7 @@ module Torque
         # Get a translated version of the value
         def text(attr = nil, model = nil)
           keys = i18n_keys(attr, model) << self.underscore.humanize
-          I18n.t(keys.shift, default: keys)
+          ::I18n.translate(keys.shift, default: keys)
         end
 
         # Change the string result for lazy value

data/lib/torque/postgresql/auxiliary_statement.rb

@@ -1,10 +1,9 @@
+require_relative 'auxiliary_statement/settings'
+
 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
         #
@@ -12,8 +11,8 @@ module Torque
         # 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|
+        [:exposed_attributes, :selected_attributes, :query, :join_attributes,
+          :join_type, :requires].each do |attribute|
           define_method(attribute) do
             setup
             instance_variable_get("@#{attribute}")
@@ -27,11 +26,26 @@ module Torque
           base.const_set(const, Class.new(AuxiliaryStatement))
         end
 
+        # Create a new instance of an auxiliary statement
+        def instantiate(statement, base, options = nil)
+          klass = base.auxiliary_statements_list[statement]
+          return klass.new(options) unless klass.nil?
+          raise ArgumentError, <<-MSG.strip
+            There's no '#{statement}' auxiliary statement defined for #{base.class.name}.
+          MSG
+        end
+
+        # Identify if the query set may be used as a relation
+        def relation_query?(obj)
+          !obj.nil? && obj.respond_to?(:ancestors) && \
+            obj.ancestors.include?(ActiveRecord::Base)
+        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?
+          @query = nil
         end
 
         # Get the base class associated to this statement
@@ -39,14 +53,40 @@ module Torque
           self.parent
         end
 
+        # Get the name of the base class
+        def base_name
+          base.name
+        end
+
+        # Get the arel version of the statement table
+        def table
+          @table ||= Arel::Table.new(table_name)
+        end
+
+        # Get the name of the table of the configurated statement
+        def table_name
+          @table_name ||= self.name.demodulize.split('_').first.underscore
+        end
+
         # Get the arel table of the base class
         def base_table
-          base.arel_table
+          @base_table ||= base.arel_table
         end
 
         # Get the arel table of the query
         def query_table
-          query.arel_table
+          @query_table ||= query.arel_table
+        end
+
+        # Project a column on a given table, or use the column table
+        def project(column, arel_table = nil)
+          if column.to_s.include?('.')
+            table_name, column = column.to_s.split('.')
+            arel_table = Arel::Table.new(table_name)
+          end
+
+          arel_table ||= table
+          arel_table[column.to_s]
         end
 
         private
@@ -62,7 +102,7 @@ module Torque
 
           # Setup the class
           def setup!
-            # attributes key
+            # 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
@@ -74,7 +114,7 @@ module Torque
             # fields, then:
             #   attributes 'table.name': :item_name
             #
-            # join_type key
+            # 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
@@ -87,106 +127,193 @@ module Torque
             # It's possible to change the default type of join
             #   join :left, id: :user_id
             #
-            # join key
+            # join key:
             # Changes the type of the join
             #
-            # query key
+            # query key:
             # Save the query command to be performand
-            settings = Settings.new
+            #
+            # requires key:
+            # Indicates dependencies with another statements
+            #
+            # polymorphic key:
+            # Indicates a polymorphic relationship, with will affect the way the
+            # auto join works, by giving a polymorphic connection
+            settings = Settings.new(self)
             @config.call(settings)
 
-            table_name = self.name.demodulize.split('_').first.underscore
             @join_type = settings.join_type || :inner
-            @table = Arel::Table.new(table_name)
+            @requires = Array[settings.requires].flatten.compact
             @query = settings.query
 
+            # Manually set the query table when it's not an relation query
+            @query_table = settings.query_table unless relation_query?(@query)
+
+            # Reset all the used attributes
             @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|
+            # Generate attributes projections
+            attributes_projections(settings.attributes)
+
+            # Generate join projections
+            if settings.join.present?
+              joins_projections(settings.join)
+            elsif relation_query?(@query)
+              check_auto_join(settings.polymorphic)
+            else
+              raise ArgumentError, <<-MSG.strip.gsub(/\n +/, ' ')
+                You must provide the join columns when using '#{query.class.name}'
+                as a query object on #{self.class.name}.
+              MSG
+            end
+          end
+
+          # Iterate the attributes settings
+          # Attributes (left => right)
+          #   left -> query.selected_attributes AS right
+          #   right -> table.exposed_attributes
+          def attributes_projections(list)
+            list.each do |left, right|
               @exposed_attributes << project(right)
               @selected_attributes << project(left, query_table).as(right.to_s)
             end
+          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
+          # Iterate the join settings
+          # Join (left => right)
+          #   left -> base.join_attributes.eq(right)
+          #   right -> table.selected_attributes
+          def joins_projections(list)
+            list.each do |left, right|
+              @selected_attributes << project(right, query_table)
+              @join_attributes << project(left, base_table).eq(project(right))
             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
+          #
+          # First, identify the foreign key column name, then check if it exists
+          # on the query and then create the projections
+          def check_auto_join(polymorphic)
+            foreign_key = (polymorphic.present? ? polymorphic : base_name)
+            foreign_key = foreign_key.to_s.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))
+              joins_projections(base.primary_key => foreign_key)
+              if polymorphic.present?
+                foreign_type = project(foreign_key.gsub(/_id$/, '_type'), query_table)
+                @selected_attributes << foreign_type
+                @join_attributes << foreign_type.eq(base_name)
+              end
             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
 
+      delegate :exposed_attributes, :join_attributes, :selected_attributes, :join_type, :table,
+               :query_table, :base_table, :requires, :project, :relation_query?, to: :class
+
       # Start a new auxiliary statement giving extra options
       def initialize(*args)
-        @options = args.extract_options!
+        options = args.extract_options!
+        uses_key = Torque::PostgreSQL.config.auxiliary_statement.send_arguments_key
+
+        @join = options.fetch(:join, {})
+        @uses = options.fetch(uses_key, [])
+        @select = options.fetch(:select, {})
+        @join_type = options.fetch(:join_type, join_type)
       end
 
       # Get the columns that will be selected for this statement
       def columns
-        self.class.exposed_attributes
+        exposed_attributes + @select.values.map(&method(:project))
       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)
+      def build_arel(arel, base)
+        list = []
+
+        # Process dependencies
+        if requires.present?
+          requires.each do |dependent|
+            next if base.auxiliary_statements.key?(dependent)
+
+            instance = AuxiliaryStatement.instantiate(dependent, base)
+            base.auxiliary_statements[dependent] = instance
+            list << instance.build_arel(arel, base)
+          end
+        end
 
         # Build the join for this statement
-        arel.join(klass.table, arel_join).on(*klass.join_attributes)
+        arel.join(table, arel_join).on(*join_columns)
 
         # Return the subquery for this statement
-        Arel::Nodes::As.new(klass.table, query.send(:build_arel))
+        list << Arel::Nodes::As.new(table, mount_query)
       end
 
       private
 
         # Get the class of the join on arel
         def arel_join
-          case @options.fetch(:join_type, self.class.join_type)
+          case @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/, '')
+            raise ArgumentError, <<-MSG.strip
               The '#{@join_type}' is not implemented as a join type.
             MSG
           end
         end
 
+        # Mount the query base on it's class
+        def mount_query
+          klass = self.class
+          query = klass.query
+          uses = @uses.map(&klass.parent.connection.method(:quote))
+
+          # Call a proc to get the query
+          if query.respond_to?(:call)
+            query = query.call(*uses)
+            uses = []
+          end
+
+          # Prepare the query depending on its type
+          if query.is_a?(String)
+            Arel::Nodes::SqlLiteral.new("(#{query})" % uses)
+          elsif relation_query?(query)
+            query.select(*select_columns).send(:build_arel)
+          else
+            raise ArgumentError, <<-MSG.strip
+              Only String and ActiveRecord::Base objects are accepted as query objects,
+              #{query.class.name} given for #{self.class.name}.
+            MSG
+          end
+        end
+
+        # Mount the list of join attributes with the additional ones
+        def join_columns
+          join_attributes + @join.map do |left, right|
+            if right.is_a?(Symbol)
+              project(left, base_table).eq(project(right))
+            else
+              project(left).eq(right)
+            end
+          end
+        end
+
+        # Mount the list of selected attributes with the additional ones
+        def select_columns
+          selected_attributes + @select.map do |left, right|
+            project(left, query_table).as(right.to_s)
+          end + @join.map do |left, right|
+            column = right.is_a?(Symbol) ? right : left
+            project(column, query_table)
+          end
+        end
+
     end
   end
 end

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

@@ -0,0 +1,48 @@
+module Torque
+  module PostgreSQL
+    class AuxiliaryStatement
+      class Settings < Collector.new(:attributes, :join, :join_type, :query, :requires,
+                                     :polymorphic)
+
+        attr_reader :source
+        alias cte source
+
+        delegate :base, :base_name, :base_table, :table, :table_name, to: :@source
+        delegate :relation_query?, to: Torque::PostgreSQL::AuxiliaryStatement
+
+        def initialize(source)
+          @source = source
+        end
+
+        # Get the arel version of the table set on the query
+        def query_table
+          raise StandardError, 'The query is not defined yet' if query.nil?
+          return query.arel_table if relation_query?(query)
+          @query_table
+        end
+
+        # There are two ways of setting the query:
+        # - A simple relation based on a modle
+        # - A string or a proc that requires the table name as first argument
+        def query(value = nil, command = nil)
+          return @query if value.nil?
+          return @query = value if relation_query?(value)
+
+          valid_type = command.respond_to?(:call) || command.is_a?(String)
+          raise ArgumentError, <<-MSG.strip.gsub(/\n +/, ' ') if command.nil?
+            To use proc or string as query, you need to provide the table name
+            as the first argument
+          MSG
+          raise ArgumentError, <<-MSG.strip.gsub(/\n +/, ' ') unless valid_type
+            Only relation, string and proc are valid object types for query,
+            #{command.inspect} given.
+          MSG
+
+          @query = command
+          @query_table = Arel::Table.new(value)
+        end
+
+      end
+    end
+  end
+end

data/lib/torque/postgresql/config.rb

@@ -46,5 +46,14 @@ module Torque
 
     end
 
+    # Configure auxiliary statement features
+    config.nested(:auxiliary_statement) do |cte|
+
+      # Define the key that is used on auxiliary statements to send extra
+      # arguments to format string or send on a proc
+      cte.send_arguments_key = :uses
+
+    end
+
   end
 end

data/lib/torque/postgresql/i18n.rb

@@ -0,0 +1,17 @@
+module Torque
+  module PostgreSQL
+    module I18n
+
+      # Adds extra suport to localize durations
+      # This is a temporary solution, since 3600.seconds do not translate into
+      # 1 hour
+      def localize(locale, object, format = :default, options = {})
+        return super unless object.is_a?(ActiveSupport::Duration)
+        object.inspect
+      end
+
+    end
+
+    ::I18n::Backend::Base.prepend I18n
+  end
+end

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

@@ -13,21 +13,16 @@ module Torque
         # Like #with, but modifies relation in place.
         def with!(*args)
           options = args.extract_options!
-          self.auxiliary_statements ||= []
+          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)
+            self.auxiliary_statements[table] = instantiate(table, self, options)
           end
+
           self
         end
 
         private
+          delegate :instantiate, to: PostgreSQL::AuxiliaryStatement
 
           # Hook arel build to add the distinct on clause
           def build_arel
@@ -35,12 +30,12 @@ module Torque
 
             if self.auxiliary_statements.present?
               columns = []
-              subqueries = self.auxiliary_statements.map do |klass|
+              subqueries = self.auxiliary_statements.values.map do |klass|
                 columns << klass.columns
-                klass.build_arel(arel)
+                klass.build_arel(arel, self)
               end
 
-              arel.with(subqueries)
+              arel.with(subqueries.flatten)
               if select_values.empty? && columns.any?
                 columns.unshift table[Arel.sql('*')]
                 arel.projections = columns
@@ -53,9 +48,8 @@ module Torque
           # 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}.
+            raise ArgumentError, <<-MSG.strip
+              There's no '#{name}' auxiliary statement defined for #{self.class.name}.
             MSG
           end
 

data/lib/torque/postgresql/version.rb

@@ -1,5 +1,5 @@
 module Torque
   module PostgreSQL
-    VERSION = '0.1.0'
+    VERSION = '0.1.1'
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: torque-postgresql
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Carlos Silva
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-04-12 00:00:00.000000000 Z
+date: 2017-04-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -171,7 +171,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: 1.5.0
 description: Add support to complex resources of PostgreSQL, like data types, user-defined
-  types and CTE with extensions for Arel and ActiveRecord
+  types and auxiliary statements (CTE)
 email:
 - carlinhus.fsilva@gmail.com
 executables: []
@@ -185,7 +185,6 @@ files:
 - lib/torque/postgresql/adapter.rb
 - lib/torque/postgresql/adapter/database_statements.rb
 - lib/torque/postgresql/adapter/oid.rb
-- lib/torque/postgresql/adapter/oid/array.rb
 - lib/torque/postgresql/adapter/oid/enum.rb
 - lib/torque/postgresql/adapter/oid/interval.rb
 - lib/torque/postgresql/adapter/quoting.rb
@@ -199,9 +198,11 @@ files:
 - lib/torque/postgresql/attributes/lazy.rb
 - lib/torque/postgresql/attributes/type_map.rb
 - lib/torque/postgresql/auxiliary_statement.rb
+- lib/torque/postgresql/auxiliary_statement/settings.rb
 - lib/torque/postgresql/base.rb
 - lib/torque/postgresql/collector.rb
 - lib/torque/postgresql/config.rb
+- lib/torque/postgresql/i18n.rb
 - lib/torque/postgresql/migration.rb
 - lib/torque/postgresql/migration/command_recorder.rb
 - lib/torque/postgresql/relation.rb
@@ -221,16 +222,16 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 2.2.2
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.8.11
 requirements: []
 rubyforge_project: 
 rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
-summary: ActiveRecord extension to reach PostgreSQL native resources
+summary: ActiveRecord extension to access PostgreSQL advanced resources
 test_files: []

data/lib/torque/postgresql/adapter/oid/array.rb

@@ -1,19 +0,0 @@
-module Torque
-  module PostgreSQL
-    module Adapter
-      module OID
-        module Array
-
-          def initialize(subtype, delimiter = ',')
-            super
-            @pg_encoder = Coder
-            @pg_decoder = Coder
-          end
-
-        end
-
-        ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Array.prepend Array
-      end
-    end
-  end
-end