torque-postgresql 0.1.7 → 0.2.1

data/lib/torque/postgresql/relation.rb

@@ -1,13 +1,21 @@
-
 require_relative 'relation/distinct_on'
 require_relative 'relation/auxiliary_statement'
+require_relative 'relation/inheritance'
+
+require_relative 'relation/merger'
 
 module Torque
   module PostgreSQL
     module Relation
+      extend ActiveSupport::Concern
 
       include DistinctOn
       include AuxiliaryStatement
+      include Inheritance
+
+      SINGLE_VALUE_METHODS = [:itself_only]
+      MULTI_VALUE_METHODS = [:distinct_on, :auxiliary_statements, :cast_records]
+      VALUE_METHODS = SINGLE_VALUE_METHODS + MULTI_VALUE_METHODS
 
       # Resolve column definition up to second value.
       # For example, based on Post model:
@@ -23,7 +31,7 @@ module Torque
       def resolve_column(list, base = false)
         base = resolve_base_table(base)
 
-        list.map do |item|
+        Array.wrap(list).map do |item|
           case item
           when String
             ::Arel::Nodes::SqlLiteral.new(klass.send(:sanitize_sql, item.to_s))
@@ -55,8 +63,65 @@ module Torque
         end
       end
 
+      private
+
+        # Compatibility method with 5.0
+        unless ActiveRecord::Relation.method_defined?(:get_value)
+          def get_value(name)
+            @values[name] || ActiveRecord::QueryMethods::FROZEN_EMPTY_ARRAY
+          end
+        end
+
+        # Compatibility method with 5.0
+        unless ActiveRecord::Relation.method_defined?(:set_value)
+          def set_value(name, value)
+            assert_mutability!
+            @values[name] = value
+          end
+        end
+
+      module ClassMethods
+        # Easy and storable way to access the name used to get the record table
+        # name when using inheritance tables
+        def _record_class_attribute
+          @@record_class ||= Torque::PostgreSQL.config
+            .inheritance.record_class_column_name.to_sym
+        end
+
+        # Easy and storable way to access the name used to get the indicater of
+        # auto casting inherited records
+        def _auto_cast_attribute
+          @@auto_cast ||= Torque::PostgreSQL.config
+            .inheritance.auto_cast_column_name.to_sym
+        end
+      end
     end
 
+    # Include the methos here provided and then change the constants to ensure
+    # the operation of ActiveRecord Relation
     ActiveRecord::Relation.include Relation
+
+    warn_level = $VERBOSE
+    $VERBOSE = nil
+
+    ActiveRecord::Relation::SINGLE_VALUE_METHODS  += Relation::SINGLE_VALUE_METHODS
+    ActiveRecord::Relation::MULTI_VALUE_METHODS   += Relation::MULTI_VALUE_METHODS
+    ActiveRecord::Relation::VALUE_METHODS         += Relation::VALUE_METHODS
+    ActiveRecord::QueryMethods::VALID_UNSCOPING_VALUES += [:cast_records, :itself_only,
+      :distinct_on, :auxiliary_statements]
+
+    if ActiveRecord::QueryMethods.const_defined?('DEFAULT_VALUES')
+      Relation::SINGLE_VALUE_METHODS.each do |value|
+        ActiveRecord::QueryMethods::DEFAULT_VALUES[value] = nil \
+          if ActiveRecord::QueryMethods::DEFAULT_VALUES[value].nil?
+      end
+
+      Relation::MULTI_VALUE_METHODS.each do |value|
+        ActiveRecord::QueryMethods::DEFAULT_VALUES[value] ||= \
+          ActiveRecord::QueryMethods::FROZEN_EMPTY_ARRAY
+      end
+    end
+
+    $VERBOSE = warn_level
   end
 end

data/lib/torque/postgresql/schema_cache.rb

@@ -0,0 +1,192 @@
+module Torque
+  module PostgreSQL
+    # :TODO: Create the +add+ to load inheritance info
+    module SchemaCache
+
+      def initialize(*) # :nodoc:
+        super
+
+        @data_sources_model_names = {}
+        @inheritance_dependencies = {}
+        @inheritance_associations = {}
+        @cached_data_sources_size = 0
+      end
+
+      def initialize_dup(*) # :nodoc:
+        super
+        @data_sources_model_names = @data_sources_model_names.dup
+        @inheritance_dependencies = @inheritance_dependencies.dup
+        @inheritance_associations = @inheritance_associations.dup
+        @cached_data_sources_size = @cached_data_sources_size.dup
+      end
+
+      def clear! # :nodoc:
+        super
+        @data_sources_model_names.clear
+        @inheritance_dependencies.clear
+        @inheritance_associations.clear
+        @cached_data_sources_size = nil
+      end
+
+      def size # :nodoc:
+        super + [
+          @data_sources_model_names,
+          @inheritance_dependencies,
+          @inheritance_associations,
+        ].map(&:size).inject(:+)
+      end
+
+      def clear_data_source_cache!(name) # :nodoc:
+        super
+        @data_sources_model_names.delete name
+        @inheritance_dependencies.delete name
+        @inheritance_associations.delete name
+        @inheritance_cache -= 1
+      end
+
+      def marshal_dump # :nodoc:
+        super + [
+          @inheritance_cache,
+          @inheritance_dependencies,
+          @inheritance_associations,
+          @data_sources_model_names,
+        ]
+      end
+
+      def marshal_load(array) # :nodoc:
+        @data_sources_model_names = array.pop
+        @inheritance_associations = array.pop
+        @inheritance_dependencies = array.pop
+        @inheritance_cache = array.pop
+        super
+      end
+
+      # A way to manually add models name so it doesn't need the lookup method
+      def add_model_name(table_name, model)
+        return unless data_source_exists?(table_name) && model.is_a?(Class)
+        @data_sources_model_names[table_name] = model
+      end
+
+      # Get all the tables that the given one inherits from
+      def dependencies(table_name)
+        reload_inheritance_data!
+        @inheritance_dependencies[table_name]
+      end
+
+      # Get the list of all tables that are associated (direct or indirect
+      # inheritance) with the provided one
+      def associations(table_name)
+        reload_inheritance_data!
+        @inheritance_associations[table_name]
+      end
+
+      # Try to find a model based on a given table
+      def lookup_model(table_name, scopred_class = '')
+        scopred_class = scopred_class.name if scopred_class.is_a?(Class)
+        return @data_sources_model_names[table_name] \
+          if @data_sources_model_names.key?(table_name)
+
+        # Get all the possible scopes
+        scopes = scopred_class.scan(/(?:::)?[A-Z][a-z]+/)
+        scopes.unshift('Object::')
+
+        # Consider the maximum namespaced possible model name
+        max_name = table_name.tr('_', '/').camelize.split(/(::)/)
+        max_name[-1] = max_name[-1].singularize
+
+        # Test all the possible names against all the possible scopes
+        until scopes.size == 0
+          scope = scopes.join.safe_constantize
+          model = find_model(max_name, table_name, scope) unless scope.nil?
+          return @data_sources_model_names[table_name] = model unless model.nil?
+          scopes.pop
+        end
+
+        nil
+      end
+
+      private
+
+        # Find a model by a given max namespaced class name thath matches the
+        # given table name
+        def find_model(max_name, table_name, scope = Object)
+          pieces = max_name.is_a?(Array) ? max_name : max_name.split(/(::)/)
+          ns_places = (1..(max_name.size - 1)).step(2).to_a
+
+          # Generate all possible combinarions
+          conditions = []
+          range = Torque::PostgreSQL.config.inheritance.inverse_lookup \
+            ? 0.upto(ns_places.size) \
+            : ns_places.size.downto(0)
+          range.each do |size|
+            conditions.concat(ns_places.combination(size).to_a)
+          end
+
+          # Now iterate over
+          while (condition = conditions.shift)
+            ns_places.each{ |i| pieces[i] = condition.include?(i) ? '::' : '' }
+            next unless scope.const_defined?(pieces.join)
+
+            # Check if the class match the table name
+            klass = scope.const_get(pieces.join)
+            return klass if klass < ::ActiveRecord::Base && klass.table_name == table_name
+          end
+        end
+
+        # Generates the cache key for inheitance information
+        def inheritance_cache_key
+          @data_sources.keys.sort.join(',')
+        end
+
+        # Reload information about tables inheritance and dependencies, uses a
+        # cache to not perform additional checkes
+        def reload_inheritance_data!
+          cache_key = inheritance_cache_key
+
+          return unless @inheritance_cache != cache_key
+          @inheritance_cache = cache_key
+
+          @inheritance_dependencies = connection.inherited_tables.freeze
+          @inheritance_associations = generate_associations.freeze
+        end
+
+        # Calculates the inverted dependency (association), where even indirect
+        # inheritance comes up in the list
+        def generate_associations
+          result = Hash.new{ |h, k| h[k] = [] }
+          masters = @inheritance_dependencies.values.flatten.uniq
+
+          # Add direct associations
+          masters.map do |master|
+            @inheritance_dependencies.each do |(dependent, associations)|
+              result[master] << dependent if associations.include?(master)
+            end
+          end
+
+          # Add indirect associations
+          result.each do |master, children|
+            children.each do |child|
+              children.concat(result[child]).uniq! if result.key?(child)
+            end
+          end
+
+          # Remove the default proc that would create new entries
+          result.default_proc = nil
+          result
+        end
+
+        # Use this method to also load any irregular model name. This is smart
+        # enought to only load the sources present on this instance
+        def prepare_data_sources
+          super
+          @data_sources_model_names = Torque::PostgreSQL.config
+            .irregular_models.slice(*@data_sources.keys).map do |table_name, model_name|
+            [table_name, model_name.constantize]
+          end.to_h
+        end
+
+    end
+
+    ActiveRecord::ConnectionAdapters::SchemaCache.prepend SchemaCache
+  end
+end

data/lib/torque/postgresql/schema_dumper.rb

@@ -2,13 +2,60 @@ module Torque
   module PostgreSQL
     module SchemaDumper
 
-      def extensions(stream)
+      def dump(stream) # :nodoc:
+        @connection.dump_mode!
+        super
+
+        @connection.dump_mode!
+        stream
+      end
+
+      def extensions(stream) # :nodoc:
         super
         user_defined_types(stream)
       end
 
       private
 
+        def tables(stream) # :nodoc:
+          inherited_tables = @connection.inherited_tables
+          sorted_tables = @connection.data_sources.sort - @connection.views
+
+          stream.puts "  # These are the common tables managed"
+          (sorted_tables - inherited_tables.keys).each do |table_name|
+            table(table_name, stream) unless ignored?(table_name)
+          end
+
+          if inherited_tables.present?
+            stream.puts "  # These are tables that has inheritance"
+            inherited_tables.each do |table_name, inherits|
+              unless ignored?(table_name)
+                sub_stream = StringIO.new
+                table(table_name, sub_stream)
+
+                # Add the inherits setting
+                sub_stream.rewind
+                inherits.map!(&:to_sym)
+                inherits = inherits.first if inherits.size === 1
+                inherits = ", inherits: #{inherits.inspect} do |t|"
+                table_dump = sub_stream.read.gsub(/ do \|t\|$/, inherits)
+
+                # Ensure bodyless definitions
+                table_dump.gsub!(/do \|t\|\n  end/, '')
+                stream.print table_dump
+              end
+            end
+          end
+
+          # dump foreign keys at the end to make sure all dependent tables exist.
+          if @connection.supports_foreign_keys?
+            sorted_tables.each do |tbl|
+              foreign_keys(tbl, stream) unless ignored?(tbl)
+            end
+          end
+        end
+
+        # Dump user defined types like enum
         def user_defined_types(stream)
           types = @connection.user_defined_types
           return unless types.any?
@@ -25,6 +72,7 @@ module Torque
           stream.puts
         end
 
+        # Dump enum custom type
         def enum(name, stream)
           values = @connection.enum_values(name).map { |v| "\"#{v}\"" }
           stream.puts "  create_enum \"#{name}\", [#{values.join(', ')}], force: :cascade"

data/lib/torque/postgresql/version.rb

@@ -1,5 +1,5 @@
 module Torque
   module PostgreSQL
-    VERSION = '0.1.7'
+    VERSION = '0.2.1'
   end
 end

data/lib/torque/postgresql.rb

@@ -1,4 +1,5 @@
 require 'i18n'
+require 'ostruct'
 require 'active_model'
 require 'active_record'
 require 'active_support'
@@ -11,15 +12,16 @@ require 'torque/postgresql/version'
 require 'torque/postgresql/collector'
 
 require 'torque/postgresql/i18n'
+require 'torque/postgresql/arel'
 require 'torque/postgresql/adapter'
 require 'torque/postgresql/attributes'
 require 'torque/postgresql/auxiliary_statement'
 require 'torque/postgresql/base'
+require 'torque/postgresql/inheritance'
+require 'torque/postgresql/coder'
 require 'torque/postgresql/migration'
 require 'torque/postgresql/relation'
+require 'torque/postgresql/schema_cache'
 require 'torque/postgresql/schema_dumper'
 
-gdep = Gem::Dependency.new('arel', '~> 9.0.0')
-unless gdep.matching_specs.sort_by(&:version).last
-  require 'torque/postgresql/arel/visitors'
-end
+require 'torque/postgresql/railtie' if defined?(Rails)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: torque-postgresql
 version: !ruby/object:Gem::Version
-  version: 0.1.7
+  version: 0.2.1
 platform: ruby
 authors:
 - Carlos Silva
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-03-23 00:00:00.000000000 Z
+date: 2018-08-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -37,9 +37,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0.18'
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '1.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -47,9 +44,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0.18'
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '1.0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -179,6 +173,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - MIT-LICENSE
+- README.rdoc
 - Rakefile
 - lib/torque-postgresql.rb
 - lib/torque/postgresql.rb
@@ -188,9 +183,14 @@ files:
 - lib/torque/postgresql/adapter/oid/enum.rb
 - lib/torque/postgresql/adapter/oid/interval.rb
 - lib/torque/postgresql/adapter/quoting.rb
+- lib/torque/postgresql/adapter/schema_creation.rb
 - lib/torque/postgresql/adapter/schema_definitions.rb
 - lib/torque/postgresql/adapter/schema_dumper.rb
 - lib/torque/postgresql/adapter/schema_statements.rb
+- lib/torque/postgresql/arel.rb
+- lib/torque/postgresql/arel/join_source.rb
+- lib/torque/postgresql/arel/select_manager.rb
+- lib/torque/postgresql/arel/using.rb
 - lib/torque/postgresql/arel/visitors.rb
 - lib/torque/postgresql/attributes.rb
 - lib/torque/postgresql/attributes/builder.rb
@@ -201,14 +201,20 @@ files:
 - lib/torque/postgresql/auxiliary_statement.rb
 - lib/torque/postgresql/auxiliary_statement/settings.rb
 - lib/torque/postgresql/base.rb
+- lib/torque/postgresql/coder.rb
 - lib/torque/postgresql/collector.rb
 - lib/torque/postgresql/config.rb
 - lib/torque/postgresql/i18n.rb
+- lib/torque/postgresql/inheritance.rb
 - lib/torque/postgresql/migration.rb
 - lib/torque/postgresql/migration/command_recorder.rb
+- lib/torque/postgresql/railtie.rb
 - lib/torque/postgresql/relation.rb
 - lib/torque/postgresql/relation/auxiliary_statement.rb
 - lib/torque/postgresql/relation/distinct_on.rb
+- lib/torque/postgresql/relation/inheritance.rb
+- lib/torque/postgresql/relation/merger.rb
+- lib/torque/postgresql/schema_cache.rb
 - lib/torque/postgresql/schema_dumper.rb
 - lib/torque/postgresql/version.rb
 homepage: https://github.com/crashtech/torque-postgresql