superstore 2.4.4 → 2.5.0

data/lib/superstore/associations/association_scope.rb

@@ -0,0 +1,20 @@
+module Superstore
+  module Associations
+    class AssociationScope < ActiveRecord::Relation
+      def initialize(klass, association)
+        super(klass)
+        @association = association
+      end
+
+      def exec_queries
+        super.each { |r| @association.set_inverse_instance r }
+      end
+
+      def <<(*records)
+        if loaded?
+          @records = @records + records
+        end
+      end
+    end
+  end
+end

data/lib/superstore/associations/belongs_to.rb

@@ -17,6 +17,8 @@ module Superstore
         end
       end
 
+      def belongs_to?; true; end
+
       private
 
         def get_record
@@ -32,4 +34,4 @@ module Superstore
 
     end
   end
-end
+end

data/lib/superstore/associations/has_many.rb

@@ -19,12 +19,25 @@ module Superstore
         self.target = relation
       end
 
+      def set_inverse_instance(record)
+        return unless reflection.inverse_name
+
+        inverse = record.association(reflection.inverse_name)
+        inverse.target = owner
+      end
+
       private
 
+        def inverse_of
+          return unless reflection.inverse_name
+
+          @inverse_of ||= association_class.reflect_on_association reflection.inverse_name
+        end
+
         def load_collection
-          association_class.where(reflection.foreign_key => owner.try(reflection.primary_key))
+          AssociationScope.new(association_class, self).where("document ->> '#{reflection.foreign_key}' = '#{owner.try(reflection.primary_key)}'")
         end
 
     end
   end
-end
+end

data/lib/superstore/associations/reflection.rb

@@ -18,7 +18,7 @@ module Superstore
         when :has_one
           Superstore::Associations::HasOne
         end
-        
+
       end
 
       def instance_variable_name
@@ -45,12 +45,18 @@ module Superstore
         options[:polymorphic]
       end
 
+      def belongs_to?; false; end
+
       def class_name
         @class_name ||= (options[:class_name] || name.to_s.classify)
       end
 
+      def inverse_name
+        options[:inverse_of]
+      end
+
       private
-      
+
       def derive_foreign_key
         case macro
         when :has_many, :has_one

data/lib/superstore/attribute_assignment.rb

@@ -0,0 +1,7 @@
+module Superstore
+  module AttributeAssignment
+    def _assign_attribute(k, v)
+      public_send("#{k}=", v) if respond_to?("#{k}=")
+    end
+  end
+end

data/lib/superstore/attribute_methods.rb

@@ -1,117 +1,9 @@
 module Superstore
   module AttributeMethods
     extend ActiveSupport::Concern
-    include ActiveModel::AttributeMethods
 
     included do
-      attribute_method_suffix("=")
-
-      # (Alias for the protected read_attribute method).
-      def [](attr_name)
-        read_attribute(attr_name)
-      end
-
-      # Updates the attribute identified by <tt>attr_name</tt> with the specified +value+.
-      # (Alias for the protected write_attribute method).
-      def []=(attr_name, value)
-        write_attribute(attr_name, value)
-      end
-    end
-
-    module ClassMethods
-      def inherited(child_class)
-        child_class.define_attribute_methods
-        super
-      end
-
-      def define_attribute_methods
-        return if attribute_methods_generated?
-        super(attribute_definitions.keys)
-        @attribute_methods_generated = true
-      end
-
-      def attribute_methods_generated?
-        @attribute_methods_generated ||= false
-      end
-
-      def dangerous_attribute_method?(name)
-        false
-      end
-
-      def has_attribute?(attr_name)
-        attribute_definitions.key?(attr_name.to_s)
-      end
-    end
-
-    def write_attribute(name, value)
-      @attributes[name.to_s] = self.class.typecast_attribute(name, value)
-    end
-
-    def read_attribute(name)
-      name = name.to_s unless name.is_a?(String)
-
-      if name == self.class.primary_key
-        send(name)
-      else
-        @attributes[name]
-      end
-    end
-    alias_method :_read_attribute, :read_attribute
-
-    def attribute_present?(attribute)
-      value = _read_attribute(attribute)
-      !value.nil? && !(value.respond_to?(:empty?) && value.empty?)
+      include PrimaryKey
     end
-
-    def has_attribute?(name)
-      @attributes.key?(name.to_s)
-    end
-    alias_method :attribute_exists?, :has_attribute?
-
-    def attributes
-      results = {}
-      @attributes.each_key do |key|
-        results[key] = read_attribute(key)
-      end
-      results
-    end
-
-    def attributes=(attributes)
-      attributes.each do |(name, value)|
-        send("#{name}=", value)
-      end
-    end
-
-    def method_missing(method_id, *args, &block)
-      self.class.define_attribute_methods unless self.class.attribute_methods_generated?
-
-      match = if ActiveRecord.version >= Gem::Version.new('5.0')
-        # Active Record 5.0
-        matched_attribute_method(method_id.to_s)
-      else
-        # Active Record 4.2
-        match_attribute_method?(method_id.to_s)
-      end
-      match ? attribute_missing(match, *args, &block) : super
-    end
-
-    def respond_to?(*args)
-      self.class.define_attribute_methods unless self.class.attribute_methods_generated?
-      super
-    end
-
-    protected
-      def attribute_method?(name)
-        !!attribute_definitions[name.to_s]
-      end
-
-    private
-      def attribute(name)
-        read_attribute(name)
-      end
-
-      def attribute=(name, value)
-        write_attribute(name, value)
-      end
   end
 end

data/lib/superstore/attribute_methods/primary_key.rb

@@ -1,25 +1,34 @@
+# frozen_string_literal: true
+
 module Superstore
   module AttributeMethods
     module PrimaryKey
       extend ActiveSupport::Concern
 
+      included do
+        attribute :id, type: :string
+        include AttributeOverrides
+      end
+
       module ClassMethods
-        PRIMARY_KEY = 'id'
         def primary_key
-          PRIMARY_KEY
+          'id'
         end
       end
 
-      def id
-        @id ||= self.class._generate_key(self)
-      end
-
-      def id=(id)
-        @id = id
-      end
+      module AttributeOverrides
+        def id
+          value = super
+          if value.nil?
+            value = self.class._generate_key(self)
+            @attributes.write_from_user(self.class.primary_key, value)
+          end
+          value
+        end
 
-      def attributes
-        super.update(self.class.primary_key => id)
+        def attributes
+          super.update(self.class.primary_key => id)
+        end
       end
     end
   end

data/lib/superstore/attributes.rb

@@ -0,0 +1,13 @@
+module Superstore
+  module Attributes
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def attribute(name, options)
+        type_name  = "superstore_#{options.fetch(:type)}".to_sym
+
+        super(name, type_name)
+      end
+    end
+  end
+end

data/lib/superstore/base.rb

@@ -1,44 +1,19 @@
-require 'set'
-
 require 'superstore/types'
 
 module Superstore
-  class Base
-
-    extend ActiveModel::Naming
-    include ActiveModel::Conversion
-    extend ActiveSupport::DescendantsTracker
-    include ActiveModel::Serializers::JSON
-    include GlobalID::Identification
-
-    extend ActiveRecord::Delegation::DelegateCache
-    extend ActiveRecord::ConnectionHandling
-    include ActiveRecord::Persistence
-    include ActiveRecord::ModelSchema
-    include ActiveRecord::Inheritance
-    include ActiveRecord::Attributes
-    include ActiveRecord::Associations
-    include ActiveRecord::AutosaveAssociation
-    include ActiveRecord::Reflection
+  class Base < ActiveRecord::Base
 
-    include Model
+    self.connection_specification_name = 'primary'
+    self.abstract_class                = true
     include Core
-    include Connection
-    include Identity
-    include Inspect
     include Persistence
+    include ModelSchema
+    include AttributeAssignment
+    include Attributes
     include AttributeMethods
-    include Validations
-    include AttributeMethods::Dirty
-    include AttributeMethods::PrimaryKey
-    include AttributeMethods::Typecasting
+    include Timestamp
     include Associations
-    include Callbacks
-    include Timestamps
-    include Scoping
-    include Caching
 
+    include Identity
   end
 end
-
-ActiveSupport.run_load_hooks(:superstore, Superstore::Base)

data/lib/superstore/core.rb

@@ -2,76 +2,18 @@ module Superstore
   module Core
     extend ActiveSupport::Concern
 
-    module ClassMethods
-      def inspect
-        if self == Base
-          super
-        else
-          attr_list = attribute_definitions.keys * ', '
-          "#{super}(#{attr_list.truncate(140 * 1.7337)})"
-        end
-      end
+    def inspect
+      inspection = ["#{self.class.primary_key}: #{id.inspect}"]
 
-      def initialize_generated_modules # :nodoc:
-        generated_association_methods
-      end
+      (self.class.attribute_names - [self.class.primary_key]).each do |name|
+        value = send(name)
 
-      def generated_association_methods
-        @generated_association_methods ||= begin
-          mod = const_set(:GeneratedAssociationMethods, Module.new)
-          include mod
-          mod
+        if value.present? || value === false
+          inspection << "#{name}: #{attribute_for_inspect(name)}"
         end
       end
 
-      def arel_table # :nodoc:
-        @arel_table ||= Arel::Table.new(table_name, self)
-      end
-
-      def subclass_from_attributes?(attrs)
-        false
-      end
-    end
-
-    def initialize(attributes=nil)
-      @new_record         = true
-      @destroyed          = false
-      @association_cache  = {}
-
-      @attributes         = {}
-      self.attributes = attributes || {}
-
-      yield self if block_given?
-    end
-
-    def initialize_dup(other)
-      @attributes = other.attributes
-      @attributes['created_at'] = nil
-      @attributes['updated_at'] = nil
-      @attributes.delete(self.class.primary_key)
-      @id = nil
-      @new_record = true
-      @destroyed = false
-      @association_cache = {}
-      super
-    end
-
-    def to_param
-      id
-    end
-
-    def hash
-      id.hash
-    end
-
-    def ==(comparison_object)
-      comparison_object.equal?(self) ||
-        (comparison_object.instance_of?(self.class) &&
-          comparison_object.id == id)
-    end
-
-    def eql?(comparison_object)
-      self == (comparison_object)
+      "#<#{self.class} #{inspection * ', '}>"
     end
   end
 end

data/lib/superstore/model_schema.rb

@@ -0,0 +1,35 @@
+module Superstore
+  module ModelSchema
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :superstore_column, default: 'document'
+    end
+
+    module ClassMethods
+      def attributes_builder # :nodoc:
+        @attributes_builder ||= ActiveModel::AttributeSet::Builder.new(attribute_types, _default_attributes)
+      end
+
+      def load_schema! # :nodoc:
+        @columns_hash = {}
+
+        attributes_to_define_after_schema_loads.each do |name, (type, options)|
+          if type.is_a?(Symbol)
+            type = ActiveRecord::Type.lookup(type, **options.except(:default))
+          end
+
+          define_attribute(name, type, **options.slice(:default))
+        end
+      end
+
+      def attribute_names
+        attribute_types.keys
+      end
+
+      def column_names
+        attribute_names
+      end
+    end
+  end
+end