simple_master 1.0.0

data/lib/simple_master/master/column.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+module SimpleMaster
+  class Master
+    class Column
+      attr_reader :name
+      attr_reader :options
+      attr_accessor :group_key
+
+      def self.column_type
+        klass_name = name.split("::").last
+        type_name = klass_name.delete_suffix('Column')
+        return :column if type_name.empty?
+
+        type_name.underscore.to_sym
+      end
+
+      def self.inherited(subclass)
+        type = subclass.column_type
+        Column.register(type, subclass)
+      end
+
+      def self.column_types
+        @column_types ||= {}
+      end
+
+      def self.register(type, klass)
+        if column_types.key?(type)
+          fail "#{klass}: Column type #{type} is defined at #{column_types[type]}."
+        end
+
+        column_types[type] = klass
+      end
+
+      register(:column, self)
+
+      def initialize(name, options)
+        @name = name
+        @group_key = !!options[:group_key]
+        @options = options
+      end
+
+      def init(master_class, for_test = false)
+        master_class.simple_master_module.attr_reader name
+
+        master_class.simple_master_module.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          def #{name}=(value)
+            #{code_for_conversion}
+            #{code_for_dirty_check if for_test}
+            @#{name} = value
+          end
+
+          def #{name}_value_for_sql
+            value = #{code_for_sql_value}
+            return "NULL" if value.nil?
+            return "'" + value.gsub(/'/, "''").gsub("\\\\", '\\&\\&') + "'" if value.is_a?(String)
+            value
+          end
+
+          # For inspecting raw DB/CSV values when checking CSV diffs
+          def #{name}_value_for_csv
+            #{code_for_sql_value}
+          end
+        RUBY
+
+        globalize(master_class) if options[:globalize]
+
+        if options[:db_column_name]
+          master_class.simple_master_module.alias_method :"#{options[:db_column_name]}=", :"#{name}="
+        end
+      end
+
+      def db_column_name
+        options[:db_column_name] || name
+      end
+
+      private
+
+      def code_for_conversion
+      end
+
+      def globalize(master_class)
+        fail "#{master_class}.#{name}: group key can not be globalized." if options[:group_key]
+
+        mod = Module.new
+        mod.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          def #{name}
+            return super if @_globalized_#{name}.nil?
+            @_globalized_#{name}.fetch(I18n.locale) { super }
+          end
+
+          attr_reader :_globalized_#{name}
+
+          def _globalized_#{name}=(hash_or_json)
+            hash = hash_or_json.is_a?(String) ? JSON.parse(hash_or_json, symbolize_names: true) : hash_or_json
+            @_globalized_#{name} = hash&.transform_values { |value|
+              #{code_for_conversion}
+              value
+            }
+          end
+
+          def _globalized_#{name}_set(locale, value)
+            @_globalized_#{name} ||= {}
+            #{code_for_conversion}
+            @_globalized_#{name}[locale] = value
+          end
+        RUBY
+
+        master_class.simple_master_module.prepend(mod)
+      end
+
+      def code_for_dirty_check
+        <<-RUBY
+          dirty! unless @#{name} == value
+        RUBY
+      end
+
+      def code_for_sql_value
+        <<-RUBY
+          self.#{name}
+        RUBY
+      end
+    end
+  end
+end
+
+require "simple_master/master/column/id_column"
+require "simple_master/master/column/integer_column"
+require "simple_master/master/column/float_column"
+require "simple_master/master/column/string_column"
+require "simple_master/master/column/symbol_column"
+require "simple_master/master/column/boolean_column"
+require "simple_master/master/column/json_column"
+require "simple_master/master/column/time_column"
+require "simple_master/master/column/enum_column"
+require "simple_master/master/column/bitmask_column"
+require "simple_master/master/column/sti_type_column"
+require "simple_master/master/column/polymorphic_type_column"

data/lib/simple_master/master/dsl.rb

@@ -0,0 +1,239 @@
+# frozen_string_literal: true
+
+module SimpleMaster
+  class Master
+    # Items declared at class-definition time are grouped inside this module
+    module Dsl
+      TYPES_BY_OPTIONS = {
+        polymorphic_type: Column::PolymorphicTypeColumn,
+        sti: Column::StiTypeColumn,
+        enum: Column::EnumColumn,
+        bitmask: Column::BitmaskColumn,
+      }.freeze
+
+      def def_column(column_name, options = {})
+        column = column_type(column_name, options).new(column_name, options)
+        columns << column
+
+        if options[:sti]
+          class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            def self.sti_base_class
+              #{name}
+            end
+
+            def self.sti_column
+              :#{column_name}
+            end
+          RUBY
+        end
+      end
+
+      def has_one(name, options = EMPTY_HASH)
+        ass = Association::HasOneAssociation.new(self, name, options)
+        has_one_associations << ass
+      end
+
+      def has_many(name, options = {})
+        ass =
+          if options[:through]
+            Association::HasManyThroughAssociation.new(self, name, options)
+          else
+            Association::HasManyAssociation.new(self, name, options)
+          end
+
+        has_many_associations << ass
+      end
+
+      def belongs_to(name, options = EMPTY_HASH)
+        ass =
+          if options[:polymorphic]
+            Association::BelongsToPolymorphicAssociation.new(self, name, options)
+          else
+            Association::BelongsToAssociation.new(self, name, options)
+          end
+
+        belongs_to_associations << ass
+      end
+
+      def group_key(column_name)
+        proc {
+          update_column_info(column_name) do |column|
+            column.group_key = true
+
+            column
+          end
+        }.tap { dsl_initializers << _1 }
+      end
+
+      def enum(*args)
+        if args.length == 1
+          options = args.first
+          proc {
+            options.each do |name, enums|
+              update_column_info(name) do |column|
+                Column::EnumColumn.new(name, column.options.merge(enum: enums))
+              end
+            end
+          }.tap { dsl_initializers << _1 }
+        elsif args.length >= 2
+          name = args.shift
+          enums = args.shift
+          options = args.shift || {}
+
+          proc {
+            update_column_info(name) do |column|
+              Column::EnumColumn.new(name, column.options.merge(options.merge(enum: enums)))
+            end
+          }.tap { dsl_initializers << _1 }
+        else
+          fail
+        end
+      end
+
+      def bitmask(name, options = Association)
+        proc {
+          update_column_info(name) do |column|
+            Column::BitmaskColumn.new(name, column.options.merge(bitmask: options[:as]))
+          end
+        }.tap { dsl_initializers << _1 }
+      end
+
+      def globalize(column_name)
+        proc {
+          update_column_info(column_name) do |column|
+            column.options[:globalize] = true
+            column
+          end
+        }.tap { dsl_initializers << _1 }
+      end
+
+      # * Cache generated at load time and stored in the dataset.
+      #
+      #     cache_class_method method_name_symbol
+      #
+      # * Can also be declared using the return value of a def:
+      #
+      #     cache_class_method def self.method_name
+      #       ...
+      #     end
+      #
+      # * Pass a block to generate the cache from the block instead of an existing method.
+      #
+      #     cache_class_method method_name_symbol { ... }
+      #
+      # * Defines class methods; multiple caches can be generated by passing several args.
+      #
+      #     cache_class_method(:cache1, :cache2) {
+      #       ...
+      #       [cache1, cache2]
+      #     }
+      def cache_class_method(*args, &block)
+        @class_method_cache_info ||= []
+        if block_given?
+          @class_method_cache_info << [args, block]
+        else
+          args.each do |arg|
+            method_name = :"_class_cache_#{arg}"
+            @class_method_cache_info << [[arg], method_name]
+            singleton_class.alias_method method_name, arg
+          end
+        end
+
+        args.each do |arg|
+          define_singleton_method(arg) do
+            class_method_cache[arg]
+          end
+        end
+      end
+
+      alias def_custom_cache cache_class_method
+
+      # Access the method once after the record is loaded
+      def tap_instance_method(method_name)
+        @instance_methods_need_tap ||= []
+        @instance_methods_need_tap << method_name
+      end
+
+      # * Cache generated at load time and stored in an instance variable.
+      #   Lightweight, but must not reference the dataset, so use with care.
+      #   Intended for caches derived from record attributes.
+      #
+      #     cache_attribute method_name_symbol
+      #
+      # * Can also be declared using the return value of a def:
+      #
+      #     cache_attribute def method_name
+      #       ...
+      #     end
+      #
+      # * Passing a block generates the cache from the block.
+      # cache_attribute method_name { ... }
+      def cache_attribute(method_name, &)
+        calc_method_name = :"_attribute_cache_#{method_name}"
+
+        if block_given?
+          define_method(calc_method_name, &)
+        else
+          alias_method calc_method_name, method_name
+        end
+
+        class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          def #{method_name}
+            return @#{method_name} if defined? @#{method_name}
+
+            @#{method_name} = #{calc_method_name}
+          end
+        RUBY
+
+        tap_instance_method method_name
+      end
+
+      # * Cache generated at load time and stored in the dataset.
+      #   Heavier than cache_attribute because it uses the dataset.
+      #
+      #     cache_method method_name_symbol
+      #
+      # * Can also be declared using the return value of a def:
+      #
+      #     cache_method def method_name
+      #       ...
+      #     end
+      #
+      # * Passing a block generates the cache from the block.
+      #
+      #     cache_method method_name_symbol { ... }
+      def cache_method(method_name, &)
+        calc_method_name = :"_method_cache_#{method_name}"
+        if block_given?
+          define_method(calc_method_name, &)
+        else
+          alias_method calc_method_name, method_name
+        end
+
+        class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          def #{method_name}
+            self.class.method_cache[:#{method_name}].fetch(self) {
+              self.class.method_cache[:#{method_name}][self] = #{calc_method_name}
+            }
+          end
+        RUBY
+
+        tap_instance_method method_name
+      end
+
+      private
+
+      def column_type(column_name, options)
+        return Column::IdColumn if column_name == :id
+
+        TYPES_BY_OPTIONS.each do |option_key, type|
+          return type if options[option_key]
+        end
+
+        return Column unless options[:type]
+
+        Column.column_types.fetch(options[:type]) { fail "Undefined column type: #{options[:type]}" }
+      end
+    end
+  end
+end

data/lib/simple_master/master/editable.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+module SimpleMaster
+  class Master
+    # Provide save! helpers for test data
+    module Editable
+      extend ActiveSupport::Concern
+
+      class_methods do
+        def create(...)
+          new(...).save
+        end
+
+        def create!(...)
+          new(...).save!
+        end
+      end
+      def dirty!
+        @dirty = true
+      end
+
+      def new_record?
+        id.nil? || self.class.id_hash[id] != self
+      end
+
+      def has_changes_to_save?
+        !@dirty.nil?
+      end
+
+      def record_to_save
+        # Assumes type_not_match? has already been checked
+        return nil if type.nil?
+        return @record_to_save if @record_to_save && @record_to_save.type == type
+
+        @record_to_save = type.constantize.new
+      end
+
+      def type_not_match?
+        self.class.sti_class? && type != self.class.to_s
+      end
+
+      # Use a generator that avoids ID collisions across classes
+      @@generated_id = 0 # rubocop:disable Style/ClassVars
+      def generate_id
+        loop do
+          @@generated_id += 1 # rubocop:disable Style/ClassVars
+          break unless self.class.base_class.id_hash.key?(@@generated_id)
+        end
+        @@generated_id
+      end
+
+      # FOR TEST
+      def save(**_options)
+        save!
+      end
+
+      def save!(**_options)
+        return if @saving
+        @saving = true
+        if id.nil?
+          self.id = generate_id
+        end
+
+        # Save belongs_to.
+        association_records = belongs_to_store.dup
+        association_records.each do |association_name, record|
+          next unless record
+
+          unless send(:"_#{association_name}_target_save?")
+            belongs_to_store.delete(association_name)
+            next
+          end
+
+          record.save
+          send(:"#{association_name}=", record)
+          belongs_to_store.delete(association_name) if record.is_a?(SimpleMaster::Master)
+        end
+
+        if @dirty
+          # Update this table
+          if type_not_match?
+            # If data would be created on the parent class, discard that instance and save separately
+            record_to_save&.update!(attributes)
+          else
+            if new_record?
+              id_updated = true
+              current_and_super_classes_each { |klass| klass.master_storage.update(id, self) }
+              SimpleMaster.logger.debug { "[SimpleMaster] Created: #{self.class}##{id}" }
+            else
+              current_and_super_classes_each { |klass| klass.master_storage.record_updated }
+              SimpleMaster.logger.debug { "[SimpleMaster] Updated: #{self.class}##{id}" }
+            end
+          end
+          @dirty = false
+        end
+
+        # save has_many
+        association_records = has_many_store.dup
+
+        association_records.each do |association_name, records|
+          association = (self.class.all_has_many_associations | self.class.all_has_one_associations).find { |ass| ass.name == association_name }
+          records.each do |record|
+            if id_updated
+              record.send(:"#{association.foreign_key}=", send(association.primary_key))
+            end
+            record.save
+          end
+          has_many_store.delete(association_name) if association.target_class < Master
+        end
+
+        @saving = false
+
+        self
+      end
+
+      def current_and_super_classes_each
+        klass = self.class
+        yield klass
+
+        loop do
+          klass = klass.superclass
+          break unless klass < Master
+          next if klass.abstract_class?
+
+          yield klass
+        end
+      end
+
+      def update(attributes)
+        update!(attributes)
+        true
+      end
+
+      def update!(attributes)
+        attributes.each do |key, value|
+          send :"#{key}=", value
+        end
+        save!
+      end
+
+      def destroy
+        destroy!
+        true
+      end
+
+      def destroy!
+        fail "Destroy is not allowed"
+      end
+
+      # NOTE: no freezing
+      def freeze
+      end
+    end
+  end
+end

data/lib/simple_master/master/filterable.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module SimpleMaster
+  class Master
+    # Lookup helper methods
+    module Filterable
+      def find(id)
+        id_hash.fetch(id)
+      end
+
+      def find_by_id(id)
+        id_hash[id]
+      end
+
+      def find_by_ids(ids)
+        id_hash.values_at(*ids).compact
+      end
+
+      def find_by_ids!(ids)
+        id_hash.fetch_values(*ids)
+      end
+
+      def find_by(key, value)
+        all_by(key, value).first
+      end
+
+      def all_by(key, value)
+        grouped_hash.fetch(key).fetch(value) { EMPTY_ARRAY }
+      end
+
+      def all_by!(key, value)
+        grouped_hash.fetch(key).fetch(value)
+      end
+
+      def all_in(key, values)
+        # NOTE: Avoid Array#flatten because it is slow here
+        grouped_hash.fetch(key).fetch_values(*values) { EMPTY_ARRAY }.flat_map(&:itself).freeze
+      end
+
+      def exists?(key)
+        id_hash.key?(key)
+      end
+
+      delegate :pluck, :map, :first, :last, :each, :select, to: :all
+    end
+  end
+end

data/lib/simple_master/master/queryable.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module SimpleMaster
+  class Master
+    # Query in database
+    module Queryable
+      def query_select_all
+        connection.select_all("SELECT * from #{table_name}")
+      end
+
+      def query_upsert_records(records, batch_size: 10000)
+        insert_queries(records, true, batch_size: batch_size).each do |sql|
+          connection.execute(sql)
+        end
+      end
+
+      def insert_queries(records, on_duplicate_key_update = false, batch_size: 10000)
+        return [] if records.empty?
+
+        column_names = all_columns.map(&:name)
+        db_column_names = all_columns.map(&:db_column_name)
+        sql_columns = db_column_names.map { "`#{_1}`" }.join(", ").then { "(#{_1})" }
+
+        sql_column_methods = column_names.map { |column_name| :"#{column_name}_value_for_sql" }
+        current_time = "'#{Time.now.utc.strftime('%Y-%m-%d %H:%M:%S')}'"
+
+        if on_duplicate_key_update
+          sql_update = db_column_names.filter_map { |column_name| "`#{column_name}` = new.#{column_name}" if column_name != :created_at }.join(", ")
+          on_duplicate_key_update_sql = " AS new ON DUPLICATE KEY UPDATE #{sql_update}"
+        else
+          on_duplicate_key_update_sql = ""
+        end
+
+        records.each_slice(batch_size).map { |sliced_records|
+          values_sql =
+            sliced_records.map { |record|
+              sql_column_methods
+                .zip(column_names)
+                .map { |method_name, column_name|
+                  if [:updated_at, :created_at].include?(column_name)
+                    current_time
+                  else
+                    record.send(method_name)
+                  end
+              }.join(", ").then { "(#{_1})" }
+            }.join(", \n")
+
+          "INSERT INTO `#{table_name}` \n#{sql_columns} VALUES \n#{values_sql}#{on_duplicate_key_update_sql};\n"
+        }
+      end
+
+      def sqlite_insert_query(records)
+        insert_queries(records, false).join("\n").gsub("\\\\", "\\")
+      end
+
+      def query_delete_all
+        connection.execute(delete_all_query)
+      end
+
+      def delete_all_query
+        "DELETE FROM #{table_name};"
+      end
+
+      def table_available?
+        connection.table_exists? table_name
+      rescue
+        false
+      end
+
+      def connection
+        ::ActiveRecord::Base.connection
+      end
+    end
+  end
+end

data/lib/simple_master/master/storable.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module SimpleMaster
+  class Master
+    module Storable
+      def master_storage(dataset = $current_dataset)
+        dataset.table(self)
+      end
+
+      delegate :all, :all=, :id_hash, :id_hash=, :grouped_hash, :grouped_hash=, :class_method_cache, :class_method_cache=, :method_cache, to: :master_storage
+      delegate :update_id_hash, :update_grouped_hash, :update_class_method_cache, :tap_instance_methods, :freeze_all, to: :master_storage
+    end
+
+    module SubClassStorable
+      def master_storage(dataset = $current_dataset)
+        dataset.table(sti_base_class).sub_table(self)
+      end
+    end
+  end
+end