brick 0.1.0 → 1.0.2

data/lib/brick/frameworks/rails/engine.rb

@@ -0,0 +1,211 @@
+# frozen_string_literal: true
+
+module Brick
+  module Rails
+    # See http://guides.rubyonrails.org/engines.html
+    class Engine < ::Rails::Engine
+      # paths['app/models'] << 'lib/brick/frameworks/active_record/models'
+      config.brick = ActiveSupport::OrderedOptions.new
+      initializer 'brick.initialisation' do |app|
+        Brick.enable_models = app.config.brick.fetch(:enable_models, true)
+        Brick.enable_controllers = app.config.brick.fetch(:enable_controllers, true)
+
+        # ====================================
+        # Dynamically create generic templates
+        # ====================================
+        if (Brick.enable_views = app.config.brick.fetch(:enable_views, true))
+          ActionView::LookupContext.class_exec do
+            alias :_brick_template_exists? :template_exists?
+            def template_exists?(*args, **options)
+              unless (is_template_exists = _brick_template_exists?(*args, **options))
+                # Need to return true if we can fill in the blanks for a missing one
+                # args will be something like:  ["index", ["categories"]]
+                model = args[1].map(&:camelize).join('::').singularize.constantize
+                if (
+                     is_template_exists = model && (
+                       ['index', 'show'].include?(args.first) || # Everything has index and show
+                       # Only CRU stuff has create / update / destroy
+                       (!model.is_view? && ['new', 'create', 'edit', 'update', 'destroy'].include?(args.first))
+                     )
+                   )
+                  instance_variable_set(:@_brick_model, model)
+                end
+              end
+              is_template_exists
+            end
+
+            alias :_brick_find_template :find_template
+            def find_template(*args, **options)
+              if @_brick_model
+                model_name = @_brick_model.name
+                pk = @_brick_model.primary_key
+                obj_name = model_name.underscore
+                table_name = model_name.pluralize.underscore
+                # This gets has_many as well as has_many :through
+                # %%% weed out ones that don't have an available model to reference
+                bts, hms = @_brick_model.reflect_on_all_associations.each_with_object([{}, {}]) do |a, s|
+                  case a.macro
+                  when :belongs_to
+                    # Build #brick_descrip if needed
+                    unless a.klass.instance_methods(false).include?(:brick_descrip)
+                      descrip_col = (a.klass.columns.map(&:name) - a.klass._brick_get_fks -
+                                    (::Brick.config.metadata_columns || []) -
+                                    [a.klass.primary_key]).first&.to_sym
+                      if descrip_col
+                        a.klass.define_method :brick_descrip do
+                          send(descrip_col)
+                        end
+                      end
+                    end
+
+                    s.first[a.foreign_key] = [a.name, a.klass]
+                  when :has_many
+                    s.last[a.name] = a
+                  end
+                  s
+                end
+                # Weed out has_manys that go to an associative table
+                hms.select { |k, v| v.options[:through] }.each { |_k, hmt| hms.delete(hmt.options[:through]) }
+                show_obj_blurb = "<td><%= link_to \"#\{#{obj_name}.class.name\} ##\{#{obj_name}.id\}\", #{obj_name} %></td>\n"
+                hms_headers = hms.each_with_object(+'') { |hm, s| s << "<th>HM #{hm.first}</th>\n" }
+                hms_columns = hms.each_with_object(+'') do |hm, s|
+                  s << "<td>
+  <%= link_to \"#\{#{obj_name}.#{hm.first}.count\} #{hm.first}\", #{hm.last.klass.name.underscore.pluralize}_path({ #{hm.last.foreign_key}: #{obj_name}.#{pk} }) %>
+</td>\n"
+                end
+
+                inline = case args.first
+                when 'index'
+                  "<p style=\"color: green\"><%= notice %></p>
+
+<h1>#{model_name.pluralize}</h1>
+<% if @_brick_params&.present? %><h3>where <%= @_brick_params.each_with_object([]) { |v, s| s << \"#\{v.first\} = #\{v.last.inspect\}\" }.join(', ') %></h3><% end %>
+
+<table id=\"#{table_name}\">
+  <tr>
+  <% is_first = true; is_need_id_col = nil
+     bts = { #{bts.each_with_object([]) { |v, s| s << "#{v.first.inspect} => [#{v.last.first.inspect}, #{v.last.last.name}, #{v.last.last.primary_key.inspect}]"}.join(', ')} }
+     @#{table_name}.columns.map(&:name).each do |col| %>
+    <% next if col == '#{pk}' || ::Brick.config.metadata_columns.include?(col) %>
+    <th>
+    <% if bt = bts[col]
+        if is_first
+          is_first = false
+          is_need_id_col = true %>
+          </th><th>
+        <% end %>
+      BT <%= bt[1].name %>
+    <% else
+        is_first = false %>
+      <%= col %>
+    <% end %>
+    </th>
+  <% end %>
+  <% if is_first # STILL haven't been able to write a first non-key / non-metadata column?
+    is_first = false
+    is_need_id_col = true %>
+    <td></td>
+  <% end %>
+#{hms_headers}
+  </tr>
+
+  <% @#{table_name}.each do |#{obj_name}| %>
+  <tr>
+    <% if is_need_id_col %>
+      <td>#{show_obj_blurb}</td>
+    <% end %>
+    <% is_first = true; #{obj_name}.attributes.each do |k, val| %>
+      <% next if k == '#{pk}' || ::Brick.config.metadata_columns.include?(k) %>
+      <% if (bt = bts[k]) %>
+        <td>
+        <%= obj = bt[1].find_by(bt.last => val); link_to obj.brick_descrip, obj %>
+      <% elsif is_first %>
+        <td>
+        <%= is_first = false; link_to val, #{obj_name} %>
+      <% else %>
+        <td>
+        <%= val %>
+      <% end %>
+      </td>
+    <% end %>
+#{hms_columns}
+    <!-- td>X</td -->
+  </tr>
+  <% end %>
+</table>
+
+<%= link_to \"New #{obj_name}\", new_#{obj_name}_path %>
+"
+                  # "<%= @#{@_brick_model.name.underscore.pluralize}.inspect %>"
+                when 'show'
+                  "<%= @#{@_brick_model.name.underscore}.inspect %>"
+                end
+puts inline
+                # As if it were an inline template (see #determine_template in actionview-5.2.6.2/lib/action_view/renderer/template_renderer.rb)
+                keys = options.has_key?(:locals) ? options[:locals].keys : []
+                handler = ActionView::Template.handler_for_extension(options[:type] || 'erb')
+                ActionView::Template.new(inline, "auto-generated #{args.first} template", handler, locals: keys)
+              else
+                _brick_find_template(*args, **options)
+              end
+            end
+          end
+        end
+
+        if (::Brick.enable_routes = app.config.brick.fetch(:enable_routes, true))
+          ActionDispatch::Routing::RouteSet.class_exec do
+            alias _brick_finalize_routeset! finalize!
+            def finalize!(*args, **options)
+              unless @finalized
+                existing_controllers = routes.each_with_object({}) { |r, s| c = r.defaults[:controller]; s[c] = nil if c }
+                ::Rails.application.routes.append do
+                  # %%% TODO: If no auto-controllers then enumerate the controllers folder in order to build matching routes
+                  # If auto-controllers and auto-models are both enabled then this makes sense:
+                  relations = (::Brick.instance_variable_get(:@relations) || {})[ActiveRecord::Base.connection_pool.object_id] || {}
+                  relations.each do |k, v|
+                    unless existing_controllers.key?(controller_name = k.underscore.pluralize)
+                      options = {}
+                      options[:only] = [:index, :show] if v.key?(:isView)
+                      send(:resources, controller_name.to_sym, **options)
+                    end
+                  end
+                end
+              end
+              _brick_finalize_routeset!(*args, **options)
+            end
+          end
+        end
+
+        # Do not consider database views when auto-creating models
+        ::Brick.skip_database_views = app.config.brick.fetch(:skip_database_views, false)
+
+        # Specific database tables and views to omit when auto-creating models
+        ::Brick.exclude_tables = app.config.brick.fetch(:exclude_tables, [])
+
+        # Columns to treat as being metadata for purposes of identifying associative tables for has_many :through
+        ::Brick.metadata_columns = app.config.brick.fetch(:metadata_columns, ['created_at', 'updated_at', 'deleted_at'])
+
+        # Additional references (virtual foreign keys)
+        if (ars = (::Brick.additional_references = app.config.brick.fetch(:additional_references, nil)))
+          ars = ars.call if ars.is_a?(Proc)
+          ars = ars.to_a unless ars.is_a?(Array)
+          ars = [ars] unless ars.empty? || ars.first.is_a?(Array)
+          ars.each do |fk|
+            ::Brick._add_bt_and_hm(fk[0..2])
+          end
+        end
+
+        # Find associative tables that can be set up for has_many :through
+        ::Brick.relations.each do |_key, tbl|
+          tbl_cols = tbl[:cols].keys
+          fks = tbl[:fks].each_with_object({}) { |fk, s| s[fk.last[:fk]] = fk.last[:inverse_table] if fk.last[:is_bt]; s }
+          # Aside from the primary key and the metadata columns created_at, updated_at, and deleted_at, if this table only has
+          # foreign keys then it can act as an associative table and thus be used with has_many :through.
+          if fks.length > 1 && (tbl_cols - fks.keys - (::Brick.config.metadata_columns || []) - tbl[:pkey].values.first).length.zero?
+            fks.each { |fk| tbl[:hmt_fks][fk.first] = fk.last }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/brick/frameworks/rails.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+# require 'brick/frameworks/rails/controller'
+require 'brick/frameworks/rails/engine'

data/lib/brick/frameworks/rspec.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require 'rspec/core'
+require 'rspec/matchers'
+# require 'brick/frameworks/rspec/helpers'
+
+RSpec.configure do |config|
+  # config.include ::Brick::RSpec::Helpers::InstanceMethods
+  # config.extend ::Brick::RSpec::Helpers::ClassMethods
+
+  # config.before(:each) do
+  #   ::Brick.enable_routes = false
+  # end
+
+  # config.before(:each, df_importing: true) do
+  #   ::Brick.enable_routes = true
+  # end
+end

data/lib/brick/serializers/json.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Brick
+  module Serializers
+    # An alternate serializer for, e.g. `versions.object`.
+    module JSON
+      extend self # makes all instance methods become module methods as well
+
+      def load(string)
+        ActiveSupport::JSON.decode string
+      end
+
+      def dump(object)
+        ActiveSupport::JSON.encode object
+      end
+
+      # Returns a SQL LIKE condition to be used to match the given field and
+      # value in the serialized object.
+      def where_object_condition(arel_field, field, value)
+        # Convert to JSON to handle strings and nulls correctly.
+        json_value = value.to_json
+
+        # If the value is a number, we need to ensure that we find the next
+        # character too, which is either `,` or `}`, to ensure that searching
+        # for the value 12 doesn't yield false positives when the value is
+        # 123.
+        if value.is_a? Numeric
+          arel_field.matches("%\"#{field}\":#{json_value},%")
+                    .or(arel_field.matches("%\"#{field}\":#{json_value}}%"))
+        else
+          arel_field.matches("%\"#{field}\":#{json_value}%")
+        end
+      end
+    end
+  end
+end

data/lib/brick/serializers/yaml.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'yaml'
+
+module Brick
+  module Serializers
+    # The default serializer for, e.g. `versions.object`.
+    module YAML
+      extend self # makes all instance methods become module methods as well
+
+      def load(string)
+        ::YAML.safe_load string
+      end
+
+      def dump(object)
+        ::YAML.dump object
+      end
+
+      # Returns a SQL LIKE condition to be used to match the given field and
+      # value in the serialized object.
+      def where_object_condition(arel_field, field, value)
+        arel_field.matches("%\n#{field}: #{value}\n%")
+      end
+    end
+  end
+end

data/lib/brick/util.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+# :nodoc:
+module Brick
+  module Util
+    # ===================================
+    # Epic require patch
+    def self._patch_require(module_filename, folder_matcher, search_text, replacement_text, autoload_symbol = nil, is_bundler = false)
+      mod_name_parts = module_filename.split('.')
+      extension = case mod_name_parts.last
+                  when 'rb', 'so', 'o'
+                    module_filename = mod_name_parts[0..-2].join('.')
+                    ".#{mod_name_parts.last}"
+                  else
+                    '.rb'
+                  end
+
+      if autoload_symbol
+        unless Object.const_defined?('ActiveSupport::Dependencies')
+          require 'active_support'
+          require 'active_support/dependencies'
+        end
+        alp = ActiveSupport::Dependencies.autoload_paths
+        custom_require_dir = ::Brick::Util._custom_require_dir
+        # Create any missing folder structure leading up to this file
+        module_filename.split('/')[0..-2].inject(custom_require_dir) do |s, part|
+          new_part = File.join(s, part)
+          Dir.mkdir(new_part) unless Dir.exist?(new_part)
+          new_part
+        end
+        if ::Brick::Util._write_patched(folder_matcher, module_filename, extension, custom_require_dir, nil, search_text, replacement_text) &&
+           !alp.include?(custom_require_dir)
+          alp.unshift(custom_require_dir)
+        end
+      elsif is_bundler
+        puts "Bundler hack"
+        require 'pry-byebug'
+        binding.pry
+        x = 5
+        # bin_path
+        # puts Bundler.require.inspect
+      else
+        unless (require_overrides = ::Brick::Util.instance_variable_get(:@_require_overrides))
+          ::Brick::Util.instance_variable_set(:@_require_overrides, (require_overrides = {}))
+
+          # Patch "require" itself so that when it specifically sees "active_support/values/time_zone" then
+          # a copy is taken of the original, an attempt is made to find the line with a circular error, that
+          # single line is patched, and then an updated version is written to a temporary folder which is
+          # then required in place of the original.
+
+          Kernel.module_exec do
+            # class << self
+            alias_method :orig_require, :require
+            # end
+            # To be most faithful to Ruby's normal behaviour, this should look like a public singleton
+            define_method(:require) do |name|
+              puts name if name.to_s.include?('cucu')
+              if (require_override = ::Brick::Util.instance_variable_get(:@_require_overrides)[name])
+                extension, folder_matcher, search_text, replacement_text, autoload_symbol = require_override
+                patched_filename = "/patched_#{name.tr('/', '_')}#{extension}"
+                if $LOADED_FEATURES.find { |f| f.end_with?(patched_filename) }
+                  false
+                else
+                  is_replaced = false
+                  if (replacement_path = ::Brick::Util._write_patched(folder_matcher, name, extension, ::Brick::Util._custom_require_dir, patched_filename, search_text, replacement_text))
+                    is_replaced = Kernel.send(:orig_require, replacement_path)
+                  elsif replacement_path.nil?
+                    puts "Couldn't find #{name} to require it!"
+                  end
+                  is_replaced
+                end
+              else
+                Kernel.send(:orig_require, name)
+              end
+            end
+          end
+        end
+        require_overrides[module_filename] = [extension, folder_matcher, search_text, replacement_text, autoload_symbol]
+      end
+    end
+
+    def self._custom_require_dir
+      unless (custom_require_dir = ::Brick::Util.instance_variable_get(:@_custom_require_dir))
+        ::Brick::Util.instance_variable_set(:@_custom_require_dir, (custom_require_dir = Dir.mktmpdir))
+        # So normal Ruby require will now pick this one up
+        $LOAD_PATH.unshift(custom_require_dir)
+        # When Ruby is exiting, remove this temporary directory
+        at_exit do
+          FileUtils.rm_rf(::Brick::Util.instance_variable_get(:@_custom_require_dir))
+        end
+      end
+      custom_require_dir
+    end
+
+    # Returns the full path to the replaced filename, or
+    # false if the file already exists, and nil if it was unable to write anything.
+    def self._write_patched(folder_matcher, name, extension, dir, patched_filename, search_text, replacement_text)
+      # See if our replacement file might already exist for some reason
+      name = +"/#{name}" unless name.start_with?('/')
+      name << extension unless name.end_with?(extension)
+      puts (replacement_path = "#{dir}#{patched_filename || name}")
+      return false if File.exist?(replacement_path)
+
+      # Dredge up the original .rb file, doctor it, and then require it instead
+      num_written = nil
+      orig_path = nil
+      orig_as = nil
+      # Using Ruby's approach to find files to require
+      $LOAD_PATH.each do |path|
+        orig_path = "#{path}#{name}"
+        break if path.include?(folder_matcher) && (orig_as = File.open(orig_path))
+      end
+      puts [folder_matcher, name].inspect
+      if (orig_text = orig_as&.read)
+        File.open(replacement_path, 'w') do |replacement|
+          num_written = replacement.write(orig_text.gsub(search_text, replacement_text))
+        end
+        orig_as.close
+      end
+      (num_written&.> 0) ? replacement_path : nil
+    end
+  end
+end

data/lib/brick/version_number.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+# :nodoc:
+module Brick
+  module VERSION
+    MAJOR = 1
+    MINOR = 0
+    TINY = 2
+
+    # PRE is nil unless it's a pre-release (beta, RC, etc.)
+    PRE = nil
+
+    STRING = [MAJOR, MINOR, TINY, PRE].compact.join('.').freeze
+
+    def self.to_s
+      STRING
+    end
+  end
+end