brick 0.1.0 → 1.0.2

data/lib/brick.rb

@@ -0,0 +1,528 @@
+# frozen_string_literal: true
+
+require 'active_record/version'
+
+# ActiveRecord before 4.0 didn't have #version
+unless ActiveRecord.respond_to?(:version)
+  module ActiveRecord
+    def self.version
+      ::Gem::Version.new(ActiveRecord::VERSION::STRING)
+    end
+  end
+end
+
+# In ActiveSupport older than 5.0, the duplicable? test tries to new up a BigDecimal,
+# and Ruby 2.6 and later deprecates #new.  This removes the warning from BigDecimal.
+require 'bigdecimal'
+if (ruby_version = ::Gem::Version.new(RUBY_VERSION)) >= ::Gem::Version.new('2.6') &&
+   ActiveRecord.version < ::Gem::Version.new('5.0')
+  def BigDecimal.new(*args, **kwargs)
+    BigDecimal(*args, **kwargs)
+  end
+end
+
+# Allow ActiveRecord 4.0 and 4.1 to work with newer Ruby (>= 2.4) by avoiding a "stack level too deep"
+# error when ActiveSupport tries to smarten up Numeric by messing with Fixnum and Bignum at the end of:
+# activesupport-4.0.13/lib/active_support/core_ext/numeric/conversions.rb
+if ActiveRecord.version < ::Gem::Version.new('4.2') &&
+   ActiveRecord.version > ::Gem::Version.new('3.2') &&
+   Object.const_defined?('Integer') && Integer.superclass.name == 'Numeric'
+  class OurFixnum < Integer; end
+  Numeric.const_set('Fixnum', OurFixnum)
+  class OurBignum < Integer; end
+  Numeric.const_set('Bignum', OurBignum)
+end
+
+# Allow ActiveRecord < 3.2 to run with newer versions of Psych gem
+if BigDecimal.respond_to?(:yaml_tag) && !BigDecimal.respond_to?(:yaml_as)
+  class BigDecimal
+    class <<self
+      alias yaml_as yaml_tag
+    end
+  end
+end
+
+require 'brick/util'
+
+# Allow ActiveRecord < 3.2 to work with Ruby 2.7 and later
+if ActiveRecord.version < ::Gem::Version.new('3.2') &&
+   ruby_version >= ::Gem::Version.new('2.7')
+  # Remove circular reference for "now"
+  ::Brick::Util._patch_require(
+    'active_support/values/time_zone.rb', '/activesupport',
+    '  def parse(str, now=now)',
+    '  def parse(str, now=now())'
+  )
+  # Remove circular reference for "reflection" for ActiveRecord 3.1
+  if ActiveRecord.version >= ::Gem::Version.new('3.1')
+    ::Brick::Util._patch_require(
+      'active_record/associations/has_many_association.rb', '/activerecord',
+      'reflection = reflection)',
+      'reflection = reflection())',
+      :HasManyAssociation # Make sure the path for this guy is available to be autoloaded
+    )
+  end
+end
+
+# puts ::Brick::Util._patch_require(
+#     'cucumber/cli/options.rb', '/cucumber/cli/options', # /cli/options
+#     '  def extract_environment_variables',
+#     "  def extract_environment_variables\n
+#     puts 'Patch test!'"
+#   ).inspect
+
+# An ActiveRecord extension that uses INFORMATION_SCHEMA views to reflect on all
+# tables and views in the database (just once at the time the database connection
+# is first established), and then automatically creates models, controllers, views,
+# and routes based on those available relations.
+require 'brick/config'
+require 'brick/frameworks/rails'
+module Brick
+  class << self
+    # All tables and views (what Postgres calls "relations" including column and foreign key info)
+    def relations
+      connections = Brick.instance_variable_get(:@relations) ||
+        Brick.instance_variable_set(:@relations, (connections = {}))
+      # Key our list of relations for this connection off of the connection pool's object_id
+      (connections[ActiveRecord::Base.connection_pool.object_id] ||= Hash.new { |h, k| h[k] = Hash.new { |h, k| h[k] = {} } })
+    end
+
+    # Switches Brick auto-models on or off, for all threads
+    # @api public
+    def enable_models=(value)
+      Brick.config.enable_models = value
+    end
+
+    # Returns `true` if Brick models are on, `false` otherwise. This affects all
+    # threads. Enabled by default.
+    # @api public
+    def enable_models?
+      !!Brick.config.enable_models
+    end
+
+    # Switches Brick auto-controllers on or off, for all threads
+    # @api public
+    def enable_controllers=(value)
+      Brick.config.enable_controllers = value
+    end
+
+    # Returns `true` if Brick controllers are on, `false` otherwise. This affects all
+    # threads. Enabled by default.
+    # @api public
+    def enable_controllers?
+      !!Brick.config.enable_controllers
+    end
+
+    # Switches Brick auto-views on or off, for all threads
+    # @api public
+    def enable_views=(value)
+      Brick.config.enable_views = value
+    end
+
+    # Returns `true` if Brick views are on, `false` otherwise. This affects all
+    # threads. Enabled by default.
+    # @api public
+    def enable_views?
+      !!Brick.config.enable_views
+    end
+
+    # Switches Brick auto-routes on or off, for all threads
+    # @api public
+    def enable_routes=(value)
+      Brick.config.enable_routes = value
+    end
+
+    # Returns `true` if Brick routes are on, `false` otherwise. This affects all
+    # threads. Enabled by default.
+    # @api public
+    def enable_routes?
+      !!Brick.config.enable_routes
+    end
+
+    # @api public
+    def skip_database_views=(value)
+      Brick.config.skip_database_views = value
+    end
+
+    # @api public
+    def exclude_tables=(value)
+      Brick.config.exclude_tables = value
+    end
+
+    # @api public
+    def metadata_columns=(value)
+      Brick.config.metadata_columns = value
+    end
+
+    # Additional table associations to use (Think of these as virtual foreign keys perhaps)
+    # @api public
+    def additional_references=(value)
+      Brick.config.additional_references = value
+    end
+
+
+    # Returns Brick's `::Gem::Version`, convenient for comparisons. This is
+    # recommended over `::Brick::VERSION::STRING`.
+    #
+    # @api public
+    def gem_version
+      ::Gem::Version.new(VERSION::STRING)
+    end
+
+    # Set the Brick serializer. This setting affects all threads.
+    # @api public
+    def serializer=(value)
+      Brick.config.serializer = value
+    end
+
+    # Get the Brick serializer used by all threads.
+    # @api public
+    def serializer
+      Brick.config.serializer
+    end
+
+    # Returns Brick's global configuration object, a singleton. These
+    # settings affect all threads.
+    # @api private
+    def config
+      @config ||= Brick::Config.instance
+      yield @config if block_given?
+      @config
+    end
+    alias configure config
+
+    def version
+      VERSION::STRING
+    end
+  end
+end
+
+require 'brick/extensions'
+require 'brick/version_number'
+# require 'brick/serializers/json'
+# require 'brick/serializers/yaml'
+
+require 'active_record'
+# Major compatibility fixes for ActiveRecord < 4.2
+# ================================================
+ActiveSupport.on_load(:active_record) do
+  # rubocop:disable Lint/ConstantDefinitionInBlock
+  module ActiveRecord
+    class Base
+      unless respond_to?(:execute_sql)
+        class << self
+          def execute_sql(sql, *param_array)
+            param_array = param_array.first if param_array.length == 1 && param_array.first.is_a?(Array)
+            connection.execute(send(:sanitize_sql_array, [sql] + param_array))
+          end
+        end
+      end
+    end
+
+    # Rails < 4.0 cannot do #find_by, #find_or_create_by, or do #pluck on multiple columns, so here are the patches:
+    if version < ::Gem::Version.new('4.0')
+      # Normally find_by is in FinderMethods, which older AR doesn't have
+      module Calculations
+        def find_by(*args)
+          where(*args).limit(1).to_a.first
+        end
+
+        def find_or_create_by(attributes, &block)
+          find_by(attributes) || create(attributes, &block)
+        end
+
+        def pluck(*column_names)
+          column_names.map! do |column_name|
+            if column_name.is_a?(Symbol) && self.column_names.include?(column_name.to_s)
+              "#{connection.quote_table_name(table_name)}.#{connection.quote_column_name(column_name)}"
+            else
+              column_name
+            end
+          end
+
+          # Same as:  if has_include?(column_names.first)
+          if eager_loading? || (includes_values.present? && (column_names.first || references_eager_loaded_tables?))
+            construct_relation_for_association_calculations.pluck(*column_names)
+          else
+            relation = clone # spawn
+            relation.select_values = column_names
+            result = if klass.connection.class.name.end_with?('::PostgreSQLAdapter')
+                       rslt = klass.connection.execute(relation.arel.to_sql)
+                       rslt.type_map =
+                         @type_map ||= proc do
+                           # This aliasing avoids the warning:
+                           # "no type cast defined for type "numeric" with oid 1700. Please cast this type
+                           # explicitly to TEXT to be safe for future changes."
+                           PG::BasicTypeRegistry.alias_type(0, 'numeric', 'text') # oid 1700
+                           PG::BasicTypeRegistry.alias_type(0, 'time', 'text') # oid 1083
+                           PG::BasicTypeMapForResults.new(klass.connection.raw_connection)
+                         end.call
+                       rslt.to_a
+                     elsif respond_to?(:bind_values)
+                       klass.connection.select_all(relation.arel, nil, bind_values)
+                     else
+                       klass.connection.select_all(relation.arel.to_sql, nil)
+                     end
+            if result.empty?
+              []
+            else
+              columns = result.first.keys.map do |key|
+                # rubocop:disable Style/SingleLineMethods Naming/MethodParameterName
+                klass.columns_hash.fetch(key) do
+                  Class.new { def type_cast(v); v; end }.new
+                end
+                # rubocop:enable Style/SingleLineMethods Naming/MethodParameterName
+              end
+
+              result = result.map do |attributes|
+                values = klass.initialize_attributes(attributes).values
+
+                columns.zip(values).map do |column, value|
+                  column.type_cast(value)
+                end
+              end
+              columns.one? ? result.map!(&:first) : result
+            end
+          end
+        end
+      end
+
+      unless Base.is_a?(Calculations)
+        class Base
+          class << self
+            delegate :pluck, :find_by, :find_or_create_by, to: :scoped
+          end
+        end
+      end
+
+      # ActiveRecord < 3.2 doesn't have initialize_attributes, used by .pluck()
+      unless AttributeMethods.const_defined?('Serialization')
+        class Base
+          class << self
+            def initialize_attributes(attributes, options = {}) #:nodoc:
+              serialized = (options.delete(:serialized) { true }) ? :serialized : :unserialized
+              # super(attributes, options)
+
+              serialized_attributes.each do |key, coder|
+                attributes[key] = Attribute.new(coder, attributes[key], serialized) if attributes.key?(key)
+              end
+
+              attributes
+            end
+          end
+        end
+      end
+
+      # This only gets added for ActiveRecord < 3.2
+      module Reflection
+        unless AssociationReflection.instance_methods.include?(:foreign_key)
+          class AssociationReflection < MacroReflection
+            alias foreign_key association_foreign_key
+          end
+        end
+      end
+
+      # ActiveRecord 3.1 and 3.2 didn't try to bring in &block for the .extending() convenience thing
+      # that smartens up scopes, and Ruby 2.7 complained loudly about just doing the magical "Proc.new"
+      # that historically would just capture the incoming block.
+      module QueryMethods
+        unless instance_method(:extending).parameters.include?([:block, :block])
+          # These first two lines used to be:
+          # def extending(*modules)
+          #   modules << Module.new(&Proc.new) if block_given?
+
+          def extending(*modules, &block)
+            modules << Module.new(&block) if block_given?
+
+            return self if modules.empty?
+
+            relation = clone
+            relation.send(:apply_modules, modules.flatten)
+            relation
+          end
+        end
+      end
+
+      # Same kind of thing for ActiveRecord::Scoping::Default#default_scope
+      module Scoping
+        module Default
+          module ClassMethods
+            if instance_methods.include?(:default_scope) &&
+               !instance_method(:default_scope).parameters.include?([:block, :block])
+              # Fix for AR 3.2-5.1
+              def default_scope(scope = nil, &block)
+                scope = block if block_given?
+
+                if scope.is_a?(Relation) || !scope.respond_to?(:call)
+                  raise ArgumentError,
+                        'Support for calling #default_scope without a block is removed. For example instead ' \
+                        "of `default_scope where(color: 'red')`, please use " \
+                        "`default_scope { where(color: 'red') }`. (Alternatively you can just redefine " \
+                        'self.default_scope.)'
+                end
+
+                self.default_scopes += [scope]
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+  # rubocop:enable Lint/ConstantDefinitionInBlock
+
+  # Rails < 4.2 is not innately compatible with Ruby 2.4 and later, and comes up with:
+  # "TypeError: Cannot visit Integer" unless we patch like this:
+  if ruby_version >= ::Gem::Version.new('2.4') &&
+     Arel::Visitors.const_defined?('DepthFirst') &&
+     !Arel::Visitors::DepthFirst.private_instance_methods.include?(:visit_Integer)
+    module Arel
+      module Visitors
+        class DepthFirst < Visitor
+          alias visit_Integer terminal
+        end
+
+        class Dot < Visitor
+          alias visit_Integer visit_String
+        end
+
+        class ToSql < Visitor
+        private
+
+          # ActiveRecord before v3.2 uses Arel < 3.x, which does not have Arel#literal.
+          unless private_instance_methods.include?(:literal)
+            def literal(obj)
+              obj
+            end
+          end
+          alias visit_Integer literal
+        end
+      end
+    end
+  end
+
+  unless DateTime.instance_methods.include?(:nsec)
+    class DateTime < Date
+      def nsec
+        (sec_fraction * 1_000_000_000).to_i
+      end
+    end
+  end
+
+  # First part of arel_table_type stuff:
+  # ------------------------------------
+  # (more found below)
+  # was:  ActiveRecord.version >= ::Gem::Version.new('3.2') &&
+  if ActiveRecord.version < ::Gem::Version.new('5.0')
+    # Used by Util#_arel_table_type
+    module ActiveRecord
+      class Base
+        def self.arel_table
+          @arel_table ||= Arel::Table.new(table_name, arel_engine).tap do |x|
+            x.instance_variable_set(:@_arel_table_type, self)
+          end
+        end
+      end
+    end
+  end
+
+  include ::Brick::Extensions
+
+  unless ::Brick::Extensions::IS_AMOEBA
+    # Add amoeba-compatible support
+    module ActiveRecord
+      class Base
+        def self.amoeba(*args)
+          puts "Amoeba called from #{name} with #{args.inspect}"
+        end
+      end
+    end
+  end
+end
+
+# Do this earlier because stuff here gets mixed into JoinDependency::JoinAssociation and AssociationScope
+if ActiveRecord.version < ::Gem::Version.new('5.0') && Object.const_defined?('PG::Connection')
+  # Avoid pg gem deprecation warning:  "You should use PG::Connection, PG::Result, and PG::Error instead"
+  PGconn = PG::Connection
+  PGresult = PG::Result
+  PGError = PG::Error
+end
+
+# More arel_table_type stuff:
+# ---------------------------
+if ActiveRecord.version < ::Gem::Version.new('5.2')
+  # Specifically for AR 3.1 and 3.2 to avoid:  "undefined method `delegate' for ActiveRecord::Reflection::ThroughReflection:Class"
+  require 'active_support/core_ext/module/delegation' if ActiveRecord.version < ::Gem::Version.new('4.0')
+  # Used by Util#_arel_table_type
+  # rubocop:disable Style/CommentedKeyword
+  module ActiveRecord
+    module Reflection
+      # AR < 4.0 doesn't know about join_table and derive_join_table
+      unless AssociationReflection.instance_methods.include?(:join_table)
+        class AssociationReflection < MacroReflection
+          def join_table
+            @join_table ||= options[:join_table] || derive_join_table
+          end
+
+        private
+
+          def derive_join_table
+            [active_record.table_name, klass.table_name].sort.join("\0").gsub(/^(.*[._])(.+)\0\1(.+)/, '\1\2_\3').gsub("\0", '_')
+          end
+        end
+      end
+    end
+
+    module Associations
+      # Specific to AR 4.2 - 5.1:
+      if Associations.const_defined?('JoinDependency') && JoinDependency.private_instance_methods.include?(:table_aliases_for)
+        class JoinDependency
+        private
+
+          if ActiveRecord.version < ::Gem::Version.new('5.1') # 4.2 or 5.0
+            def table_aliases_for(parent, node)
+              node.reflection.chain.map do |reflection|
+                alias_tracker.aliased_table_for(
+                  reflection.table_name,
+                  table_alias_for(reflection, parent, reflection != node.reflection)
+                ).tap do |x|
+                  # %%% Specific only to Rails 4.2 (and maybe 4.1?)
+                  x = x.left if x.is_a?(Arel::Nodes::TableAlias)
+                  y = reflection.chain.find { |c| c.table_name == x.name }
+                  x.instance_variable_set(:@_arel_table_type, y.klass)
+                end
+              end
+            end
+          end
+        end
+      elsif Associations.const_defined?('JoinHelper') && JoinHelper.private_instance_methods.include?(:construct_tables)
+        module JoinHelper
+        private
+
+          # AR > 3.0 and < 4.2 (%%% maybe only < 4.1?) uses construct_tables like this:
+          def construct_tables
+            tables = []
+            chain.each do |reflection|
+              tables << alias_tracker.aliased_table_for(
+                table_name_for(reflection),
+                table_alias_for(reflection, reflection != self.reflection)
+              ).tap do |x|
+                x = x.left if x.is_a?(Arel::Nodes::TableAlias)
+                x.instance_variable_set(:@_arel_table_type, reflection.chain.find { |c| c.table_name == x.name }.klass)
+              end
+
+              next unless reflection.source_macro == :has_and_belongs_to_many
+
+              tables << alias_tracker.aliased_table_for(
+                (reflection.source_reflection || reflection).join_table,
+                table_alias_for(reflection, true)
+              )
+            end
+            tables
+          end
+        end
+      end
+    end
+  end # module ActiveRecord
+  # rubocop:enable Style/CommentedKeyword
+end

data/lib/generators/brick/USAGE

@@ -0,0 +1,2 @@
+Description:
+  Modifies an existing model so that it includes an IMPORT_TEMPLATE.

data/lib/generators/brick/install_generator.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+require 'rails/generators'
+# require 'rails/generators/active_record'
+
+module Brick
+  class InstallGenerator < ::Rails::Generators::Base
+    # include ::Rails::Generators::Migration
+
+    source_root File.expand_path('templates', __dir__)
+    class_option(
+      :with_changes,
+      type: :boolean,
+      default: false,
+      desc: 'Store changeset (diff) with each version'
+    )
+
+    desc 'Generates an initializer file for configuring Brick'
+
+    def create_initializer_file
+      unless File.exists?(filename = 'config/initializers/brick.rb')
+        create_file filename, "# frozen_string_literal: true
+
+# # Settings for the Brick gem
+# # (By default this auto-creates models, controllers, views, and routes on-the-fly.)
+
+# # Normally these all start out as being enabled, but can be selectively disabled:
+# Brick.enable_routes = false
+# Brick.enable_models = false
+# Brick.enable_controllers = false
+# Brick.enable_views = false
+
+# # By default models are auto-created from database views, and set to be read-only.  This can be skipped.
+# Brick.skip_database_views = true
+
+# # Any tables or views you'd like to skip when auto-creating models
+# Brick.exclude_tables = ['custom_metadata', 'version_info']
+
+# # Additional table references which are used to create has_many / belongs_to associations inside auto-created
+# # models.  (You can consider these to be \"virtual foreign keys\" if you wish)...  You only have to add these
+# # in cases where your database for some reason does not have foreign key constraints defined.  Sometimes for
+# # performance reasons or just out of sheer laziness these might be missing.
+# # Each of these virtual foreign keys is defined as an array having three values:
+# #   foreign table name / foreign key column / primary table name.
+# # (We boldly expect that the primary key identified by ActiveRecord on the primary table will be accurate,
+# # usually this is \"id\" but there are some good smarts that are used in case some other column has been set
+# # to be the primary key.
+# Brick.additional_references = [['orders', 'customer_id', 'customer'],
+#                                ['customer', 'region_id', 'regions']]
+
+# # We normally don't consider the timestamp columns \"created_at\", \"updated_at\", and \"deleted_at\" to count when
+# # finding tables which can serve as associative tables in an N:M association.  That is, ones that can be a
+# # part of a has_many :through association.  If you want to use different exclusion columns than our defaults
+# # then this setting resets that list.  For instance, here is the override for the Sakila sample database:
+# Brick.metadata_columns = ['last_updated']
+
+# # If a default route is not supplied, Brick attempts to find the most \"central\" table and wires up the default
+# # route to go to the :index action for what would be a controller for that table.  You can specify any controller
+# # name and action you wish in order to override this and have that be the default route when none other has been
+# # specified in routes.rb or elsewhere.  (Or just use an empty string in order to disable this behaviour.)
+# Brick.default_route_fallback = 'customers' # This defaults to \"customers/index\"
+# Brick.default_route_fallback = 'orders/outstanding' # Example of a non-RESTful route
+# Brick.default_route_fallback = '' # Omits setting a default route in the absence of any other
+"
+      end
+    end
+
+    # def create_migration_file
+    #   add_brick_migration('create_versions')
+    #   add_brick_migration('add_object_changes_to_versions') if options.with_changes?
+    # end
+
+    # def self.next_migration_number(dirname)
+    #   ::ActiveRecord::Generators::Base.next_migration_number(dirname)
+    # end
+
+  protected
+
+    # def add_brick_migration(template)
+    #   migration_dir = File.expand_path('db/migrate')
+    #   if self.class.migration_exists?(migration_dir, template)
+    #     ::Kernel.warn "Migration already exists: #{template}"
+    #   else
+    #     migration_template(
+    #       "#{template}.rb.erb",
+    #       "db/migrate/#{template}.rb",
+    #       item_type_options: item_type_options,
+    #       migration_version: migration_version,
+    #       versions_table_options: versions_table_options
+    #     )
+    #   end
+    # end
+
+  private
+
+    # # MySQL 5.6 utf8mb4 limit is 191 chars for keys used in indexes.
+    # def item_type_options
+    #   opt = { null: false }
+    #   opt[:limit] = 191 if mysql?
+    #   ", #{opt}"
+    # end
+
+    # def migration_version
+    #   return unless (major = ActiveRecord::VERSION::MAJOR) >= 5
+
+    #   "[#{major}.#{ActiveRecord::VERSION::MINOR}]"
+    # end
+
+    # # Class names of MySQL adapters.
+    # # - `MysqlAdapter` - Used by gems: `mysql`, `activerecord-jdbcmysql-adapter`.
+    # # - `Mysql2Adapter` - Used by `mysql2` gem.
+    # def mysql?
+    #   [
+    #     'ActiveRecord::ConnectionAdapters::MysqlAdapter',
+    #     'ActiveRecord::ConnectionAdapters::Mysql2Adapter'
+    #   ].freeze.include?(ActiveRecord::Base.connection.class.name)
+    # end
+
+    # # Even modern versions of MySQL still use `latin1` as the default character
+    # # encoding. Many users are not aware of this, and run into trouble when they
+    # # try to use Brick in apps that otherwise tend to use UTF-8. Postgres, by
+    # # comparison, uses UTF-8 except in the unusual case where the OS is configured
+    # # with a custom locale.
+    # #
+    # # - https://dev.mysql.com/doc/refman/5.7/en/charset-applications.html
+    # # - http://www.postgresql.org/docs/9.4/static/multibyte.html
+    # #
+    # # Furthermore, MySQL's original implementation of UTF-8 was flawed, and had
+    # # to be fixed later by introducing a new charset, `utf8mb4`.
+    # #
+    # # - https://mathiasbynens.be/notes/mysql-utf8mb4
+    # # - https://dev.mysql.com/doc/refman/5.5/en/charset-unicode-utf8mb4.html
+    # #
+    # def versions_table_options
+    #   if mysql?
+    #     ', { options: "ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci" }'
+    #   else
+    #     ''
+    #   end
+    # end
+  end
+end