simple_master 1.0.0

data/lib/simple_master/master/association/has_many_through_association.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module SimpleMaster
+  class Master
+    class Association
+      class HasManyThroughAssociation < self
+        def foreign_key
+          @foreign_key ||= (options[:foreign_key] || ActiveSupport::Inflector.foreign_key(defined_at.to_s)).to_sym
+        end
+
+        def through
+          @through ||= options[:through]
+        end
+
+        def through_association
+          @through_association ||=
+            begin
+              through_association = defined_at.all_has_many_associations.find { |ass| ass.name == through }
+
+              if through_association.nil?
+                fail "Association '#{through}' not found in has_many_associations. Use 'delegate' instead."
+              end
+
+              through_association
+            end
+        end
+
+        delegate :target_class, to: :through_association
+
+        def source
+          @source ||= options[:source] || ActiveSupport::Inflector.singularize(name)
+        end
+
+        def primary_key
+          @primary_key ||= options[:primary_key] || :id
+        end
+
+        def init(master_class)
+          # check
+          through_association
+
+          master_class.simple_master_module.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            def #{name}
+              Array.wrap(#{through}).flat_map { |ass| ass.#{source} }.compact
+            end
+          RUBY
+        end
+
+        def init_for_test(master_class)
+          master_class.simple_master_module.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            def #{name}=(values)
+              self.#{through} = values.map { |value|
+                #{through_association.target_class}.new.tap do |through|
+                  through.#{source} = value
+                  #{"through.#{through_association.inverse_of} = self" if through_association.try(:inverse_of)}
+                end
+              }
+            end
+          RUBY
+        end
+      end
+    end
+  end
+end

data/lib/simple_master/master/association/has_one_association.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module SimpleMaster
+  class Master
+    class Association
+      class HasOneAssociation < self
+        def foreign_key
+          @foreign_key ||= (options[:foreign_key] || ActiveSupport::Inflector.foreign_key(defined_at.to_s)).to_sym
+        end
+
+        def inverse_of
+          @inverse_of ||= options[:inverse_of] || ActiveSupport::Inflector.underscore(defined_at.to_s)
+        end
+
+        def primary_key
+          @primary_key ||= options[:primary_key] || defined_at.primary_key || :id
+        end
+
+        def init(master_class)
+          master_class.simple_master_module.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            if #{target_class} < SimpleMaster::Master
+              def #{name}
+                #{target_class}.find_by(:#{foreign_key}, #{primary_key})
+              end
+            else
+              def #{name}
+                # Store in an Array so nil values still hit the cache
+                values = (has_many_store[:#{name}] ||= [#{target_class}.simple_master_connection.find_by_#{foreign_key}(#{primary_key})])
+                values.first
+              end
+            end
+          RUBY
+        end
+
+        def init_for_test(master_class)
+          master_class.simple_master_module.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            if #{target_class} < SimpleMaster::Master
+              def #{name}
+                (has_many_store[:#{name}] || #{target_class}.all_by(:#{foreign_key}, #{primary_key})).first
+              end
+            else
+              def #{name}
+                # Store in an Array so nil values still hit the cache
+                values = (has_many_store[:#{name}] ||= [#{target_class}.simple_master_connection.find_by_#{foreign_key}(#{primary_key})])
+                values.first
+              end
+            end
+
+            def #{name}=(value)
+              has_many_store[:#{name}] = [value]
+            end
+          RUBY
+        end
+      end
+    end
+  end
+end

data/lib/simple_master/master/association.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module SimpleMaster
+  class Master
+    class Association
+      autoload :BelongsToAssociation, "simple_master/master/association/belongs_to_association"
+      autoload :BelongsToPolymorphicAssociation, "simple_master/master/association/belongs_to_polymorphic_association"
+      autoload :HasManyAssociation, "simple_master/master/association/has_many_association"
+      autoload :HasManyThroughAssociation, "simple_master/master/association/has_many_through_association"
+      autoload :HasOneAssociation, "simple_master/master/association/has_one_association"
+
+      attr_reader :name
+      attr_reader :defined_at
+      attr_reader :options
+
+      def initialize(master_class, name, options)
+        @name = name
+        @defined_at = master_class
+        @options = options
+      end
+
+      # Execute after definition phase.
+      def target_class
+        @target_class ||= find_class(defined_at, options[:class_name] || ActiveSupport::Inflector.classify(name))
+      end
+
+      def is_active_record?
+        target_class < ::ActiveRecord::Base
+      end
+
+      def init(master_class)
+      end
+
+      def init_for_test(master_class)
+      end
+
+      private
+
+      def find_class(current, class_name)
+        loop do
+          return current.const_get(class_name, false)
+        rescue NameError => e
+          raise e if current == current.module_parent
+
+          current = current.module_parent
+        end
+      end
+    end
+  end
+end

data/lib/simple_master/master/column/bitmask_column.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module SimpleMaster
+  class Master
+    class Column
+      class BitmaskColumn < self
+        attr_reader :name
+        attr_reader :bitmask
+        attr_reader :const_name
+
+        def initialize(name, options)
+          @bitmask = options[:bitmask]
+          @const_name = "BITMASK_FOR_#{name.upcase}"
+
+          super
+        end
+
+        def init(master_class, for_test = false)
+          super
+
+          master_class.simple_master_module.const_set(const_name, bitmask) unless master_class.const_defined?(const_name)
+
+          master_class.simple_master_module.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            def #{name}
+              return EMPTY_ARRAY if @#{name}.nil?
+              #{const_name}.filter_map.with_index {
+                _1 if (1 << _2) & @#{name} != 0
+              }
+            end
+
+            def #{name}_value
+              @#{name}
+            end
+
+            def #{name}_value=(value)
+              #{code_for_dirty_check if for_test}
+              @#{name} = value&.to_i
+            end
+          RUBY
+        end
+
+        private
+
+        def code_for_conversion
+          <<-RUBY
+            value = cache_object(:#{name}, value) { |value|
+              value = [value] if value.is_a?(Symbol)
+
+              if value.is_a?(Array)
+                bits = 0
+                value.each do |day|
+                  bits |= 1 << #{const_name}.index(day)
+                end
+                bits
+              else
+                value&.to_i
+              end
+            }
+          RUBY
+        end
+
+        def code_for_sql_value
+          <<-RUBY
+            @#{name}
+          RUBY
+        end
+
+        def globalize
+          fail NotImplementedError
+        end
+      end
+    end
+  end
+end

data/lib/simple_master/master/column/boolean_column.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module SimpleMaster
+  class Master
+    class Column
+      class BooleanColumn < self
+        def init(master_class, for_test = false)
+          super
+
+          master_class.simple_master_module.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            def #{name}?
+              !!#{name}
+            end
+          RUBY
+        end
+
+        private
+
+        def code_for_conversion
+          <<-RUBY
+            value = cache_object(:#{name}, value) { |value|
+              if value.is_a?(Integer)
+                value != 0
+              elsif value.is_a?(String)
+                value.downcase == "true" || value == "1"
+              elsif value.nil?
+                value
+              else
+                !!value
+              end
+            }
+          RUBY
+        end
+
+        def code_for_sql_value
+          <<-RUBY
+            # Convert to 0/1 for systems that do not support true/false
+            case #{name}
+            when true
+              1
+            when false
+              0
+            else
+              nil
+            end
+          RUBY
+        end
+      end
+    end
+  end
+end

data/lib/simple_master/master/column/enum_column.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module SimpleMaster
+  class Master
+    class Column
+      class EnumColumn < self
+        attr_reader :name
+        attr_reader :enum
+        attr_reader :const_name
+        attr_reader :prefix
+        attr_reader :suffix
+
+        def initialize(name, options)
+          @enum = options[:enum]
+          @const_name = "ENUM_FOR_#{name.upcase}"
+          @prefix = "#{options[:prefix] == true ? name : options[:prefix]}_" if options[:prefix]
+          @suffix = "_#{options[:suffix] == true ? name : options[:suffix]}" if options[:suffix]
+
+          super
+        end
+
+        def init(master_class, for_test = false)
+          super
+
+          master_class.simple_master_module.const_set(const_name, enum.freeze) unless master_class.const_defined?(const_name)
+
+          master_class.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            def self.#{name.to_s.pluralize}
+              #{const_name}
+            end
+          RUBY
+
+          master_class.simple_master_module.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            def #{name}_to_enum(value)
+              case value
+              when Integer
+                return #{const_name}.key(value)
+              when String
+                sym = value.to_sym
+                return sym if #{const_name}.key?(sym)
+
+                int_val = Integer(value, exception: false)
+                if int_val
+                  result = #{const_name}.key(int_val)
+                  return result if result
+                end
+
+                fail "Unsupported type \#{value.inspect}."
+              when Symbol, NilClass
+                return value
+              else
+                fail "Unsupported type \#{value.inspect}."
+              end
+            end
+
+            def #{name.to_s.pluralize}
+              #{const_name}
+            end
+
+            def #{name}_before_type_cast
+              #{const_name}[#{name}]
+            end
+          RUBY
+
+          enum.each_key do |enum_name|
+            # Skip generating helpers for names that start with a digit
+            next if enum_name.match?(/\A\d/) && prefix.nil?
+            master_class.simple_master_module.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+                def #{prefix}#{enum_name}#{suffix}?
+                  #{name} == :#{enum_name}
+                end
+            RUBY
+          end
+        end
+
+        private
+
+        def code_for_conversion
+          <<-RUBY
+            value = cache_object(:#{name}, value) { #{name}_to_enum(_1) }
+          RUBY
+        end
+
+        def code_for_sql_value
+          <<-RUBY
+            #{name}_before_type_cast
+          RUBY
+        end
+
+        def globalize
+          fail NotImplementedError
+        end
+      end
+    end
+  end
+end

data/lib/simple_master/master/column/float_column.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module SimpleMaster
+  class Master
+    class Column
+      class FloatColumn < self
+        private
+
+        def code_for_conversion
+          <<-RUBY
+            if value.is_a?(String) && value.strip.empty?
+              value = nil
+            else
+              value = value&.to_f
+            end
+          RUBY
+        end
+      end
+    end
+  end
+end

data/lib/simple_master/master/column/id_column.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module SimpleMaster
+  class Master
+    class Column
+      class IdColumn < self
+        private
+
+        def code_for_conversion
+          <<-RUBY
+            value = value&.to_i
+          RUBY
+        end
+
+        def code_for_dirty_check
+          <<-RUBY
+            unless @#{name} == value
+              dirty!
+              # IDs require updating @id_hash when changed
+              self.class.id_hash.delete(@#{name}) if @#{name}
+            end
+          RUBY
+        end
+
+        def globalize
+          fail NotImplementedError
+        end
+      end
+    end
+  end
+end

data/lib/simple_master/master/column/integer_column.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module SimpleMaster
+  class Master
+    class Column
+      class IntegerColumn < self
+        private
+
+        def code_for_conversion
+          <<-RUBY
+            if value.is_a?(String) && value.strip.empty?
+              value = nil
+            else
+              value = value&.to_i
+            end
+          RUBY
+        end
+      end
+    end
+  end
+end

data/lib/simple_master/master/column/json_column.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module SimpleMaster
+  class Master
+    class Column
+      class JsonColumn < self
+        private
+
+        def code_for_conversion
+          <<-RUBY
+            value = cache_object(:#{name}, value) { |value|
+              value = JSON.parse(value, symbolize_names: #{!!options[:symbolize_names]}) if value.is_a?(String)
+              value
+            }
+          RUBY
+        end
+
+        def code_for_sql_value
+          <<-RUBY
+            # Use JSON.generate because to_json adds unnecessary escaping
+            #{name}&.then { JSON.generate(_1) }
+          RUBY
+        end
+      end
+    end
+  end
+end

data/lib/simple_master/master/column/polymorphic_type_column.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module SimpleMaster
+  class Master
+    class Column
+      class PolymorphicTypeColumn < self
+        def init(master_class, for_test = false)
+          super
+
+          master_class.simple_master_module.attr_reader :"#{name}_class"
+          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
+              @#{name}_class = value&.then { ActiveSupport::Inflector.constantize(_1) }
+            end
+
+            def #{name}_class=(klass)
+              #{"dirty! unless @#{name}_class == klass" if for_test}
+              @#{name} = klass.to_s
+              @#{name}_class = klass
+            end
+          RUBY
+        end
+
+        private
+
+        def code_for_conversion
+          <<-RUBY
+            value = nil if value == ""
+            value = cache_object(:#{name}, value) { _1&.to_s }
+          RUBY
+        end
+
+        def globalize
+          fail NotImplementedError
+        end
+      end
+    end
+  end
+end

data/lib/simple_master/master/column/sti_type_column.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module SimpleMaster
+  class Master
+    class Column
+      class StiTypeColumn < self
+        private
+
+        def code_for_conversion
+          <<-RUBY
+            value = cache_object(:#{name}, value) { _1&.to_s }
+          RUBY
+        end
+
+        def globalize
+          fail NotImplementedError
+        end
+      end
+    end
+  end
+end

data/lib/simple_master/master/column/string_column.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module SimpleMaster
+  class Master
+    class Column
+      class StringColumn < self
+        private
+
+        def code_for_conversion
+          <<-RUBY
+            value = cache_object(:#{name}, value) { _1&.to_s }
+          RUBY
+        end
+      end
+    end
+  end
+end

data/lib/simple_master/master/column/symbol_column.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module SimpleMaster
+  class Master
+    class Column
+      class SymbolColumn < self
+        private
+
+        def code_for_conversion
+          <<-RUBY
+            value = value&.to_s&.to_sym
+          RUBY
+        end
+
+        def code_for_sql_value
+          <<-RUBY
+            #{name}&.to_s
+          RUBY
+        end
+      end
+    end
+  end
+end

data/lib/simple_master/master/column/time_column.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module SimpleMaster
+  class Master
+    class Column
+      class TimeColumn < self
+        private
+
+        def code_for_conversion
+          <<-RUBY
+            value = cache_object(:#{name}, value) { |value|
+              if value.is_a?(String)
+                #{"value = value.sub(/\A\d{4}-\d\d-\d\d(?:T|\s)|/, \"2000-01-01 \")" if options[:db_type] == :time}
+                time_hash = ::Date._parse(value)
+                zone = time_hash[:offset] || "UTC"
+                value = Time.new(*time_hash.values_at(:year, :mon, :mday, :hour, :min, :sec), zone)
+              end
+              value = value.floor if value && value.subsec != 0
+              value
+            }
+          RUBY
+        end
+
+        def code_for_sql_value
+          if options[:db_type] == :time
+            <<-RUBY
+              #{name}&.getutc&.strftime('%H:%M:%S')
+            RUBY
+          else
+            <<-RUBY
+              #{name}&.getutc&.strftime('%Y-%m-%d %H:%M:%S')
+            RUBY
+          end
+        end
+      end
+    end
+  end
+end