code0-zero_track 0.0.0 → 0.0.2

data/lib/code0/zero_track/injectors/active_record_schema_migrations.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Code0
+  module ZeroTrack
+    module Injectors
+      class ActiveRecordSchemaMigrations
+        def self.inject!
+          # Patch to write version information as empty files under the db/schema_migrations directory
+          # This is intended to reduce potential for merge conflicts in db/structure.sql
+          ActiveSupport.on_load(:active_record_postgresqladapter) do
+            prepend Database::PostgresqlAdapter::DumpSchemaVersionsMixin
+          end
+          # Patch to load version information from empty files under the db/schema_migrations directory
+          ActiveRecord::Tasks::PostgreSQLDatabaseTasks
+            .prepend Database::PostgresqlDatabaseTasks::LoadSchemaVersionsMixin
+        end
+      end
+    end
+  end
+end

data/lib/code0/zero_track/injectors/active_record_timestamps.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Code0
+  module ZeroTrack
+    module Injectors
+      class ActiveRecordTimestamps
+        def self.inject!
+          ActiveSupport.on_load(:active_record_postgresqladapter) do
+            self::NATIVE_DATABASE_TYPES[:datetime_with_timezone] = { name: 'timestamptz' }
+          end
+
+          ActiveSupport.on_load(:active_record) do
+            ActiveRecord::Base.time_zone_aware_types += [:datetime_with_timezone]
+          end
+
+          ActiveRecord::ConnectionAdapters::ColumnMethods.include ZeroTrack::Database::ColumnMethods::Timestamps
+        end
+      end
+    end
+  end
+end

data/lib/code0/zero_track/loggable.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Code0
+  module ZeroTrack
+    module Loggable
+      extend ActiveSupport::Concern
+
+      class_methods do
+        def logger
+          Logger.new(Rails.logger, name || '<Anonymous>')
+        end
+      end
+
+      def logger
+        Logger.new(Rails.logger, self.class.name || '<Anonymous>')
+      end
+
+      class Logger
+        def initialize(log, clazz)
+          @log = log
+          @clazz = clazz
+        end
+
+        delegate :debug?, :info?, :warn?, :error?, :fatal?, :formatter, :level, to: :@log
+
+        def with_context(&block)
+          Code0::ZeroTrack::Context.with_context(class: @clazz, &block)
+        end
+
+        def debug(message)
+          with_context { @log.debug(message) }
+        end
+
+        def error(message)
+          with_context { @log.error(message) }
+        end
+
+        def warn(message)
+          with_context { @log.warn(message) }
+        end
+
+        def info(message)
+          with_context { @log.info(message) }
+        end
+      end
+    end
+  end
+end

data/lib/code0/zero_track/logs/json_formatter.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Code0
+  module ZeroTrack
+    module Logs
+      class JsonFormatter < ::Logger::Formatter
+        def call(severity, datetime, _progname, message)
+          JSON.generate(data(severity, datetime, message)) << "\n"
+        end
+
+        def data(severity, datetime, message)
+          data = {}
+          data[:severity] = severity
+          data[:time] = datetime.utc.iso8601(3)
+
+          case message
+          when String
+            data[:message] = chomp message
+          when Hash
+            data.merge!(message)
+          end
+
+          data.merge!(Code0::ZeroTrack::Context.current.to_h)
+        end
+
+        def chomp(message)
+          message.chomp! until message.chomp == message
+
+          message.strip
+        end
+
+        class Tagged < JsonFormatter
+          include ActiveSupport::TaggedLogging::Formatter
+
+          def tagged(*_args)
+            yield self # Ignore tags, they break the json layout as they are prepended to the log line
+          end
+        end
+      end
+    end
+  end
+end

data/lib/code0/zero_track/memoize.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Code0
+  module ZeroTrack
+    module Memoize
+      def memoize(name, reset_on_change: nil)
+        unless reset_on_change.nil?
+          reset_trigger = reset_on_change.call
+          reset_memoize = memoize("#{name}_reset_on_change") { reset_trigger }
+
+          if reset_trigger != reset_memoize
+            clear_memoize(name)
+            clear_memoize("#{name}_reset_on_change")
+          end
+        end
+
+        if memoized?(name)
+          instance_variable_get(ivar(name))
+        else
+          instance_variable_set(ivar(name), yield)
+        end
+      end
+
+      def memoized?(name)
+        instance_variable_defined?(ivar(name))
+      end
+
+      def clear_memoize(name)
+        clear_memoize!(name) if memoized?(name)
+      end
+
+      def clear_memoize!(name)
+        remove_instance_variable(ivar(name))
+      end
+
+      private
+
+      def ivar(name)
+        case name
+        when Symbol
+          name.to_s.prepend('@').to_sym
+        when String
+          :"@#{name}"
+        else
+          raise ArgumentError, "Invalid type of '#{name}'"
+        end
+      end
+    end
+  end
+end

data/lib/code0/zero_track/railtie.rb

@@ -3,6 +3,21 @@
 module Code0
   module ZeroTrack
     class Railtie < ::Rails::Railtie
+      config.zero_track = ActiveSupport::OrderedOptions.new
+      config.zero_track.active_record = ActiveSupport::OrderedOptions.new
+      config.zero_track.active_record.timestamps = false
+      config.zero_track.active_record.schema_migrations = false
+      config.zero_track.active_record.schema_cleaner = false
+
+      rake_tasks do
+        path = File.expand_path(__dir__)
+        Dir.glob("#{path}/../../tasks/**/*.rake").each { |f| load f }
+      end
+
+      config.after_initialize do
+        Injectors::ActiveRecordTimestamps.inject! if config.zero_track.active_record.timestamps
+        Injectors::ActiveRecordSchemaMigrations.inject! if config.zero_track.active_record.schema_migrations
+      end
     end
   end
 end

data/lib/code0/zero_track/version.rb

@@ -2,6 +2,6 @@
 
 module Code0
   module ZeroTrack
-    VERSION = '0.0.0'
+    VERSION = '0.0.2'
   end
 end

data/lib/code0/zero_track.rb

@@ -1,10 +1,18 @@
 # frozen_string_literal: true
 
-require 'code0/zero_track/version'
-require 'code0/zero_track/railtie'
+require 'rails/railtie'
+
+require 'zeitwerk'
+loader = Zeitwerk::Loader.new
+loader.tag = File.basename(__FILE__, '.rb')
+loader.inflector = Zeitwerk::GemInflector.new(__FILE__)
+loader.push_dir(File.expand_path(File.join(__dir__, '..')))
+loader.setup
 
 module Code0
   module ZeroTrack
     # Your code goes here...
   end
 end
+
+Code0::ZeroTrack::Railtie # eager load the railtie

data/lib/rubocop/code0/zero_track/file_helpers.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Code0
+    module ZeroTrack
+      module FileHelpers
+        def dirname(node)
+          File.dirname(filepath(node))
+        end
+
+        def basename(node)
+          File.basename(filepath(node))
+        end
+
+        def filepath(node)
+          node.location.expression.source_buffer.name
+        end
+
+        def in_migration?(node)
+          dirname(node).end_with?('db/migrate')
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/code0/zero_track/logs/rails_logger.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Code0
+      module ZeroTrack
+        module Logs
+          # Cop that checks if 'timestamps' method is called with timezone information.
+          class RailsLogger < RuboCop::Cop::Base
+            MSG = 'Do not use `Rails.logger` directly, include `Code0::ZeroTrack::Loggable` instead'
+            LOG_METHODS = %i[debug error fatal info warn].freeze
+            LOG_METHODS_PATTERN = LOG_METHODS.map(&:inspect).join(' ').freeze
+
+            def_node_matcher :rails_logger_log?, <<~PATTERN
+              (send
+                (send (const nil? :Rails) :logger)
+                {#{LOG_METHODS_PATTERN}} ...
+              )
+            PATTERN
+
+            def on_send(node)
+              return unless rails_logger_log?(node)
+
+              add_offense(node)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/code0/zero_track/migration/create_table_with_timestamps.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require_relative '../../../../code0/zero_track/file_helpers'
+
+module RuboCop
+  module Cop
+    module Code0
+      module ZeroTrack
+        module Migration
+          class CreateTableWithTimestamps < RuboCop::Cop::Base
+            include RuboCop::Code0::ZeroTrack::FileHelpers
+
+            MSG = 'Add timestamps when creating a new table.'
+            RESTRICT_ON_SEND = %i[create_table].freeze
+
+            def_node_matcher :create_table_with_timestamps_proc?, <<~PATTERN
+              (send nil? :create_table (sym _) ... (block-pass (sym :timestamps_with_timezone)))
+            PATTERN
+
+            def_node_search :timestamps_included?, <<~PATTERN
+              (send _var :timestamps_with_timezone ...)
+            PATTERN
+
+            def_node_search :created_at_included?, <<~PATTERN
+              (send _var :datetime_with_timezone
+                {(sym :created_at)(str "created_at")}
+                ...)
+            PATTERN
+
+            def_node_search :updated_at_included?, <<~PATTERN
+              (send _var :datetime_with_timezone
+                {(sym :updated_at)(str "updated_at")}
+                ...)
+            PATTERN
+
+            def_node_matcher :create_table_with_block?, <<~PATTERN
+              (block
+                (send nil? :create_table ...)
+                (args (arg _var)+)
+                _)
+            PATTERN
+
+            def on_send(node)
+              return unless in_migration?(node)
+              return unless node.command?(:create_table)
+
+              parent = node.parent
+
+              if create_table_with_block?(parent)
+                add_offense(parent) if parent.body.nil? || !time_columns_included?(parent.body)
+              elsif create_table_with_timestamps_proc?(node)
+                # nothing to do
+              else
+                add_offense(node)
+              end
+            end
+
+            private
+
+            def time_columns_included?(node)
+              timestamps_included?(node) || created_at_and_updated_at_included?(node)
+            end
+
+            def created_at_and_updated_at_included?(node)
+              created_at_included?(node) && updated_at_included?(node)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/code0/zero_track/migration/datetime.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require_relative '../../../../code0/zero_track/file_helpers'
+
+module RuboCop
+  module Cop
+    module Code0
+      module ZeroTrack
+        module Migration
+          # Cop that checks if datetime data type is added with timezone information.
+          class Datetime < RuboCop::Cop::Base
+            include RuboCop::Code0::ZeroTrack::FileHelpers
+            extend AutoCorrector
+
+            MSG = 'Do not use the `%s` data type, use `datetime_with_timezone` instead'
+
+            # Check methods in table creation.
+            def on_def(node)
+              return unless in_migration?(node)
+
+              node.each_descendant(:send) do |send_node|
+                method_name = send_node.children[1]
+
+                next unless %i[datetime timestamp].include?(method_name)
+
+                add_offense(send_node.loc.selector, message: format(MSG, method_name)) do |corrector|
+                  corrector.replace(send_node.loc.selector, 'datetime_with_timezone')
+                end
+              end
+            end
+
+            # Check methods.
+            def on_send(node)
+              return unless in_migration?(node)
+
+              node.each_descendant do |descendant|
+                next unless descendant.type == :sym
+
+                last_argument = descendant.children.last
+
+                next unless %i[datetime timestamp].include?(last_argument)
+
+                add_offense(descendant, message: format(MSG, last_argument)) do |corrector|
+                  corrector.replace(descendant, ':datetime_with_timezone')
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/code0/zero_track/migration/timestamps.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require_relative '../../../../code0/zero_track/file_helpers'
+
+module RuboCop
+  module Cop
+    module Code0
+      module ZeroTrack
+        module Migration
+          # Cop that checks if 'timestamps' method is called with timezone information.
+          class Timestamps < RuboCop::Cop::Base
+            include RuboCop::Code0::ZeroTrack::FileHelpers
+            extend AutoCorrector
+
+            MSG = 'Do not use `timestamps`, use `timestamps_with_timezone` instead'
+
+            # Check methods in table creation.
+            def on_def(node)
+              return unless in_migration?(node)
+
+              node.each_descendant(:send) do |send_node|
+                next unless method_name(send_node) == :timestamps
+
+                add_offense(send_node.loc.selector) do |corrector|
+                  corrector.replace(send_node.loc.selector, 'timestamps_with_timezone')
+                end
+              end
+            end
+
+            def method_name(node)
+              node.children[1]
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/code0/zero_track/migration/versioned_class.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require_relative '../../../../code0/zero_track/file_helpers'
+
+module RuboCop
+  module Cop
+    module Code0
+      module ZeroTrack
+        module Migration
+          class VersionedClass < RuboCop::Cop::Base
+            include RuboCop::Code0::ZeroTrack::FileHelpers
+            extend AutoCorrector
+
+            MIGRATION_CLASS = 'Code0::ZeroTrack::Database::Migration'
+
+            # rubocop:disable Layout/LineLength
+            MSG_WRONG_BASE_CLASS = "Don't use `%<base_class>s`. Use `#{MIGRATION_CLASS}` instead.".freeze
+            MSG_WRONG_VERSION = "Don't use version `%<current_version>s` of `#{MIGRATION_CLASS}`. Use version `%<allowed_version>s` instead.".freeze
+            # rubocop:enable Layout/LineLength
+
+            def on_class(node)
+              return unless in_migration?(node)
+
+              return on_zerotrack_migration(node) if zerotrack_migration?(node)
+
+              add_offense(
+                node.parent_class,
+                message: format(MSG_WRONG_BASE_CLASS, base_class: superclass(node))
+              ) do |corrector|
+                corrector.replace(node.parent_class, "#{MIGRATION_CLASS}[#{find_allowed_versions(node).last}]")
+              end
+            end
+
+            private
+
+            def on_zerotrack_migration(node)
+              return if cop_config['AllowedVersions'].nil? # allow all versions if nothing configured
+              return if correct_migration_version?(node)
+
+              current_version = get_migration_version(node)
+              allowed_version = find_allowed_versions(node).last
+
+              version_node = get_migration_version_node(node)
+
+              add_offense(
+                version_node,
+                message: format(MSG_WRONG_VERSION, current_version: current_version, allowed_version: allowed_version)
+              ) do |corrector|
+                corrector.replace(version_node, find_allowed_versions(node).last.to_s)
+              end
+            end
+
+            def zerotrack_migration?(node)
+              superclass(node) == MIGRATION_CLASS
+            end
+
+            def superclass(class_node)
+              _, *others = class_node.descendants
+
+              others.find { |node| node.const_type? && node.const_name != 'Types' }&.const_name
+            end
+
+            def correct_migration_version?(node)
+              find_allowed_versions(node).include?(get_migration_version(node))
+            end
+
+            def get_migration_version_node(node)
+              node.parent_class.arguments[0]
+            end
+
+            def get_migration_version(node)
+              get_migration_version_node(node).value
+            end
+
+            def find_allowed_versions(node)
+              migration_version = basename(node).split('_').first.to_i
+              allowed_versions.select do |range, _|
+                range.include?(migration_version)
+              end.values
+            end
+
+            def allowed_versions
+              cop_config['AllowedVersions'].transform_keys do |range|
+                range_ints = range.split('..').map(&:to_i)
+                range_ints[0]..range_ints[1]
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/zero_track.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+# rubocop:disable Lint/RedundantDirGlobSort
+Dir[File.join(__dir__, 'cop', '**', '*.rb')].sort.each { |file| require file }
+# rubocop:enable Lint/RedundantDirGlobSort

data/lib/tasks/code0/zero_track_tasks.rake

@@ -1,6 +1,35 @@
 # frozen_string_literal: true
 
-# desc "Explaining what the task does"
-# task :code0_zero_track do
-#   # Task goes here
-# end
+namespace :code0 do
+  namespace :zero_track do
+    namespace :db do
+      desc 'This adjusts and cleans db/structure.sql - it runs after db:schema:dump'
+      task clean_structure_sql: :environment do |task_name|
+        # Allow this task to be called multiple times, as happens when running db:migrate:redo
+        Rake::Task[task_name].reenable
+
+        next unless Rails.application.config.zero_track.active_record.schema_cleaner
+
+        ActiveRecord::Base.configurations
+                          .configs_for(env_name: ActiveRecord::Tasks::DatabaseTasks.env)
+                          .each do |db_config|
+          structure_file = ActiveRecord::Tasks::DatabaseTasks.schema_dump_path(db_config)
+
+          schema = File.read(structure_file)
+
+          File.open(structure_file, 'wb+') do |io|
+            Code0::ZeroTrack::Database::SchemaCleaner.new(schema).clean(io)
+          end
+        end
+      end
+
+      # Inform Rake that custom tasks should be run every time rake db:schema:dump is run
+      Rake::Task['db:schema:dump'].enhance do
+        Rake::Task['code0:zero_track:db:clean_structure_sql'].invoke
+      end
+      Rake::Task['db:prepare'].enhance do
+        Rake::Task['code0:zero_track:db:clean_structure_sql'].invoke
+      end
+    end
+  end
+end