superstore 2.4.4 → 2.5.0

data/lib/superstore/persistence.rb

@@ -2,140 +2,56 @@ 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", {})
-        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)
+      if Rails.version >= '6.0'
+        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
-        end
-        encoded
-      end
 
-      private
-
-        def quote_columns(column_names)
-          column_names.map { |name| "'#{name}'" }
+          super(klass, attributes, column_types, &block)
         end
-
-        def typecast_persisted_attributes(attributes)
-          result = {}
-
-          attributes.each do |key, value|
-            if definition = attribute_definitions[key]
-              result[key] = definition.instantiate(value)
-            end
+        private :instantiate_instance_of
+      else
+        def instantiate(attributes, column_types = {}, &block)
+          if attributes[superstore_column].is_a?(String)
+            attributes = JSON.parse(attributes[superstore_column]).merge('id' => attributes['id'])
           end
 
-          result
+          super(attributes, column_types, &block)
         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
-
-    alias update_attributes update
-
-    def update!(attributes)
-      self.attributes = attributes
-      save!
-    end
-
-    alias update_attributes! update!
-
-    def reload
-      clear_association_cache
-      @attributes = self.class.find(id).instance_variable_get('@attributes')
-      self
-    end
-
-    private
-
-      def create_or_update
-        new_record? ? create_self : update_self
       end
 
-      def create_self
-        write :insert_record
+      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
+        serialized
       end
 
-      def update_self
-        write :update_record
-      end
+      private
 
-      def write(method)
-        @new_record = false
-        self.class.send(method, id, unapplied_changes)
-      end
+        def adapter
+          @adapter ||= Superstore::Adapters::JsonbAdapter.new
+        end
+    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/timestamp.rb

@@ -0,0 +1,13 @@
+module Superstore
+  module Timestamp
+    extend ActiveSupport::Concern
+
+    class_methods do
+      def inherited(child)
+        super
+        child.attribute :created_at, type: :time
+        child.attribute :updated_at, type: :time
+      end
+    end
+  end
+end

data/lib/superstore/types.rb

@@ -1,9 +1,11 @@
-Superstore::Type.register(:array,          Superstore::Types::ArrayType)
-Superstore::Type.register(:boolean,        Superstore::Types::BooleanType)
-Superstore::Type.register(:date,           Superstore::Types::DateType)
-Superstore::Type.register(:float,          Superstore::Types::FloatType)
-Superstore::Type.register(:geo_point,      Superstore::Types::JsonType)
-Superstore::Type.register(:integer,        Superstore::Types::IntegerType)
-Superstore::Type.register(:json,           Superstore::Types::JsonType)
-Superstore::Type.register(:time,           Superstore::Types::TimeType)
-Superstore::Type.register(:string,         Superstore::Types::StringType)
+ActiveRecord::Type.register(:superstore_array,          Superstore::Types::ArrayType)
+ActiveRecord::Type.register(:superstore_boolean,        Superstore::Types::BooleanType)
+ActiveRecord::Type.register(:superstore_date,           Superstore::Types::DateType)
+ActiveRecord::Type.register(:superstore_date_range,     Superstore::Types::DateRangeType)
+ActiveRecord::Type.register(:superstore_float,          Superstore::Types::FloatType)
+ActiveRecord::Type.register(:superstore_geo_point,      Superstore::Types::GeoPointType)
+ActiveRecord::Type.register(:superstore_integer,        Superstore::Types::IntegerType)
+ActiveRecord::Type.register(:superstore_integer_range,  Superstore::Types::IntegerRangeType)
+ActiveRecord::Type.register(:superstore_json,           Superstore::Types::JsonType)
+ActiveRecord::Type.register(:superstore_time,           Superstore::Types::TimeType)
+ActiveRecord::Type.register(:superstore_string,         Superstore::Types::StringType)

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 < ActiveModel::Type::Value
+      def cast_value(value)
+        Array(value)
       end
     end
   end

data/lib/superstore/types/boolean_type.rb

@@ -1,20 +1,15 @@
 module Superstore
   module Types
-    class BooleanType < BaseType
+    class BooleanType < ActiveModel::Type::Value
       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 < ActiveModel::Type::Value
       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 < ActiveModel::Type::Value
+      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 < ActiveModel::Type::Value
+      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

data/lib/superstore/types/integer_range_type.rb

@@ -0,0 +1,19 @@
+module Superstore
+  module Types
+    class IntegerRangeType < RangeType
+      self.subtype = IntegerType.new
+
+      def serialize_for_open_ended(value)
+        value.abs == Float::INFINITY ? nil : super
+      end
+
+      def convert_min(method, value)
+        value.nil? ? -Float::INFINITY : super
+      end
+
+      def convert_max(method, value)
+        value.nil? ? Float::INFINITY : super
+      end
+    end
+  end
+end

data/lib/superstore/types/integer_type.rb

@@ -1,19 +1,13 @@
 module Superstore
   module Types
-    class IntegerType < BaseType
-      REGEX = /\A[-+]?\d+\Z/
-      def encode(int)
-        raise ArgumentError.new("#{int.inspect} is not an Integer.") unless int.kind_of?(Integer)
-
-        int
-      end
-
-      def decode(str)
-        str.to_i unless str.empty?
-      end
-
-      def typecast(value)
-        value.to_i
+    class IntegerType < ActiveModel::Type::Value
+      def cast_value(value)
+        if value.is_a?(String)
+          Integer(value, 10)
+        else
+          Integer(value)
+        end
+      rescue
       end
     end
   end