superstore 2.4.3 → 3.0.0

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/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,16 @@
-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
-
-    include Model
+  class Base < ActiveRecord::Base
+    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 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

data/lib/superstore/persistence.rb

@@ -2,140 +2,51 @@ module Superstore
   module Persistence
     extend ActiveSupport::Concern
 
-    included do
-      class_attribute :batch_statements
-    end
-
     module ClassMethods
-      def delete(ids)
-        adapter.delete table_name, ids
-      end
-
-      def delete_all
-        adapter.execute "TRUNCATE #{table_name}"
+      def find_by_id(id)
+        find_by(id: id)
       end
 
-      def insert_record(id, attributes)
-        adapter.insert table_name, id, encode_attributes(attributes)
-      end
+      def _insert_record(attributes)
+        id = attributes.fetch(primary_key)
 
-      def update_record(id, attributes)
-        adapter.update table_name, id, encode_attributes(attributes)
+        adapter.insert table_name, id, serialize_attributes(attributes)
       end
 
-      def batching?
-        adapter.batching?
-      end
+      def _update_record(attributes, constraints)
+        id = constraints.fetch(primary_key)
 
-      def batch(&block)
-        adapter.batch(&block)
+        adapter.update table_name, id, serialize_attributes(attributes)
       end
 
-      def instantiate(id, attributes)
-        allocate.tap do |object|
-          object.instance_variable_set("@id", id) if id
-          object.instance_variable_set("@new_record", false)
-          object.instance_variable_set("@destroyed", false)
-          object.instance_variable_set("@attributes", typecast_persisted_attributes(attributes))
-          object.instance_variable_set("@association_cache", {})
+      def serialize_attributes(attributes)
+        serialized = {}
+        attributes.each do |attr_name, value|
+          next if attr_name == primary_key
+          serialized[attr_name] = attribute_types[attr_name].serialize(value)
         end
-      end
-
-      def encode_attributes(attributes)
-        encoded = {}
-        attributes.each do |column_name, value|
-          if value.nil?
-            encoded[column_name] = nil
-          else
-            encoded[column_name] = attribute_definitions[column_name].type.encode(value)
-          end
-        end
-        encoded
+        serialized
       end
 
       private
 
-        def quote_columns(column_names)
-          column_names.map { |name| "'#{name}'" }
-        end
-
-        def typecast_persisted_attributes(attributes)
-          result = {}
-
-          attributes.each do |key, value|
-            if definition = attribute_definitions[key]
-              result[key] = definition.instantiate(value)
-            end
+        def instantiate_instance_of(klass, attributes, column_types = {}, &block)
+          if attributes[superstore_column].is_a?(String)
+            attributes = JSON.parse(attributes[superstore_column]).merge('id' => attributes['id'])
           end
 
-          result
-        end
-    end
-
-    def new_record?
-      @new_record
-    end
-
-    def destroyed?
-      @destroyed
-    end
-
-    def persisted?
-      !(new_record? || destroyed?)
-    end
-
-    def save(*)
-      create_or_update
-    end
-
-    def destroy
-      self.class.delete(id)
-      @destroyed = true
-    end
-
-    def update_attribute(name, value)
-      name = name.to_s
-      send("#{name}=", value)
-      save(validate: false)
-    end
-
-    def update(attributes)
-      self.attributes = attributes
-      save
-    end
+          if inheritance_column && attribute_types.key?(inheritance_column)
+            klass = find_sti_class(attributes[inheritance_column])
+          end
 
-    alias update_attributes update
+          attributes.each_key { |k, v| attributes.delete(k) unless klass.attribute_types.key?(k) }
 
-    def update!(attributes)
-      self.attributes = attributes
-      save!
-    end
-
-    alias update_attributes! update!
+          super(klass, attributes, column_types, &block)
+        end
 
-    def reload
-      clear_association_cache
-      @attributes = self.class.find(id).instance_variable_get('@attributes')
-      self
+        def adapter
+          @adapter ||= Superstore::Adapters::JsonbAdapter.new
+        end
     end
-
-    private
-
-      def create_or_update
-        new_record? ? create_self : update_self
-      end
-
-      def create_self
-        write :insert_record
-      end
-
-      def update_self
-        write :update_record
-      end
-
-      def write(method)
-        @new_record = false
-        self.class.send(method, id, unapplied_changes)
-      end
   end
 end

data/lib/superstore/railtie.rb

@@ -1,17 +1,9 @@
 module Superstore
   class Railtie < Rails::Railtie
     initializer "superstore.config" do |app|
-      ActiveSupport.on_load :superstore do
-        pathname = Rails.root.join('config', 'superstore.yml')
-        if pathname.exist?
-          config = ERB.new(pathname.read).result
-          config = YAML.load(config)
-
-          if config = config[Rails.env]
-            self.config = config.symbolize_keys!
-          else
-            raise "Missing environment #{Rails.env} in superstore.yml"
-          end
+      ActiveSupport.on_load :active_record do
+        ActiveRecord::Relation.class_eval do
+          include Superstore::Relation::Scrolling
         end
       end
     end

data/lib/superstore/relation/scrolling.rb

@@ -0,0 +1,48 @@
+module Superstore
+  module Relation
+    module Scrolling
+      def scroll_each(options = {})
+        batch_size = options[:batch_size] || 1000
+
+        scroll_results(batch_size) do |attributes|
+          yield klass.instantiate(attributes)
+        end
+      end
+
+      def scroll_in_batches(options = {})
+        batch_size = options[:batch_size] || 1000
+        batch = []
+
+        scroll_each(options) do |record|
+          batch << record
+
+          if batch.size == batch_size
+            yield batch
+            batch = []
+          end
+        end
+
+        yield(batch) if batch.any?
+      end
+
+      private
+      
+      def scroll_results(batch_size)
+        statement   = to_sql
+        cursor_name = "cursor_#{SecureRandom.hex(6)}"
+        fetch_sql   = "FETCH FORWARD #{batch_size} FROM #{cursor_name}"
+
+        connection.transaction do
+          connection.execute "DECLARE #{cursor_name} NO SCROLL CURSOR FOR (#{statement})"
+
+          while (batch = connection.execute(fetch_sql)).any?
+            batch.each do |result|
+              yield result
+            end
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/superstore/types/array_type.rb

@@ -1,12 +1,8 @@
 module Superstore
   module Types
-    class ArrayType < BaseType
-      def decode(val)
-        val unless val.blank?
-      end
-
-      def typecast(value)
-        value.to_a
+    class ArrayType < Base
+      def cast_value(value)
+        Array(value)
       end
     end
   end

data/lib/superstore/types/base.rb

@@ -0,0 +1,9 @@
+module Superstore
+  module Types
+    class Base < ActiveModel::Type::Value
+      def type
+        self.class.name.demodulize.sub(/Type$/, '').underscore
+      end
+    end
+  end
+end

data/lib/superstore/types/boolean_type.rb

@@ -1,20 +1,15 @@
 module Superstore
   module Types
-    class BooleanType < BaseType
+    class BooleanType < Base
       TRUE_VALS = [true, 'true', '1']
-      FALSE_VALS = [false, 'false', '0', '', nil]
-      VALID_VALS = TRUE_VALS + FALSE_VALS
+      FALSE_VALS = [false, 'false', '0']
 
-      def encode(bool)
-        unless VALID_VALS.include?(bool)
-          raise ArgumentError.new("#{bool.inspect} is not a Boolean")
+      def cast_value(value)
+        if TRUE_VALS.include?(value)
+          true
+        elsif FALSE_VALS.include?(value)
+          false
         end
-
-        TRUE_VALS.include?(bool)
-      end
-
-      def decode(str)
-        TRUE_VALS.include?(str)
       end
     end
   end

data/lib/superstore/types/date_range_type.rb

@@ -0,0 +1,7 @@
+module Superstore
+  module Types
+    class DateRangeType < RangeType
+      self.subtype = DateType.new
+    end
+  end
+end

data/lib/superstore/types/date_type.rb

@@ -1,21 +1,18 @@
 module Superstore
   module Types
-    class DateType < BaseType
+    class DateType < Base
       FORMAT = '%Y-%m-%d'
-      REGEX = /\A\d{4}-\d{2}-\d{2}\Z/
 
-      def encode(value)
-        raise ArgumentError.new("#{value.inspect} is not a Date") unless value.kind_of?(Date)
-        value.strftime(FORMAT)
+      def serialize(value)
+        value.strftime(FORMAT) if value
       end
 
-      def decode(str)
-        return nil if str.empty?
-        Date.parse(str)
+      def deserialize(str)
+        Date.strptime(str, FORMAT) if str
       end
 
-      def typecast(value)
-        value.to_date
+      def cast_value(value)
+        value.to_date rescue nil
       end
     end
   end

data/lib/superstore/types/float_type.rb

@@ -1,16 +1,8 @@
 module Superstore
   module Types
-    class FloatType < BaseType
-      def encode(float)
-        float
-      end
-
-      def decode(str)
-        str.to_f unless str.empty?
-      end
-
-      def typecast(value)
-        value.to_f
+    class FloatType < Base
+      def cast_value(value)
+        Float(value) rescue nil
       end
     end
   end

data/lib/superstore/types/geo_point_type.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Superstore
+  module Types
+    class GeoPointType < Base
+      def deserialize(value)
+        {lat: value[:lat] || value['lat'], lon: value[:lon] || value['lon']} if value
+      end
+
+      def cast_value(value)
+        case value
+        when String
+          cast_value value.split(/[,\s]+/)
+        when Array
+          to_float_or_nil(lat: value[0], lon: value[1])
+        when Hash
+          to_float_or_nil(lat: value[:lat] || value['lat'], lon: value[:lon] || value['lon'])
+        end
+      end
+
+      private
+
+      def to_float_or_nil(coords)
+        if coords[:lat] && coords[:lon]
+          coords.transform_values!(&:to_f)
+        end
+      end
+    end
+  end
+end