superstore 2.4.4 → 2.5.0

data/lib/superstore/caching.rb

@@ -1,13 +0,0 @@
-module Superstore
-  module Caching
-    extend ActiveSupport::Concern
-
-    def cache_key
-      if new_record?
-        "#{self.class.model_name.cache_key}/new"
-      else
-        "#{self.class.model_name.cache_key}/#{id}-#{updated_at.utc.to_s(:nsec)}"
-      end
-    end
-  end
-end

data/lib/superstore/callbacks.rb

@@ -1,29 +0,0 @@
-module Superstore
-  module Callbacks
-    extend ActiveSupport::Concern
-
-    included do
-      extend ActiveModel::Callbacks
-      include ActiveModel::Validations::Callbacks
-
-      define_model_callbacks :save, :create, :update, :destroy
-    end
-
-    def destroy #:nodoc:
-      run_callbacks(:destroy) { super }
-    end
-
-    private
-      def write(*args) #:nodoc:
-        run_callbacks(:save) { super }
-      end
-
-      def create_self #:nodoc:
-        run_callbacks(:create) { super }
-      end
-
-      def update_self(*) #:nodoc:
-        run_callbacks(:update) { super }
-      end
-  end
-end

data/lib/superstore/connection.rb

@@ -1,24 +0,0 @@
-module Superstore
-  module Connection
-    extend ActiveSupport::Concern
-
-    module ClassMethods
-      def adapter
-        @adapter ||= adapter_class.new(config)
-      end
-
-      def adapter_class
-        case config[:adapter]
-        when nil, 'jsonb'
-          Superstore::Adapters::JsonbAdapter
-        else
-          raise "Unknown adapter #{config[:adapter]}"
-        end
-      end
-
-      def connection
-        adapter.connection
-      end
-    end
-  end
-end

data/lib/superstore/errors.rb

@@ -1,10 +0,0 @@
-module Superstore
-  class CasssandraObjectError < StandardError
-  end
-
-  class RecordNotSaved < CasssandraObjectError
-  end
-
-  class RecordNotFound < CasssandraObjectError
-  end
-end

data/lib/superstore/inspect.rb

@@ -1,25 +0,0 @@
-module Superstore
-  module Inspect
-    def inspect
-      inspection = ["#{self.class.primary_key}: #{id.inspect}"]
-
-      @attributes.each do |attribute, value|
-        if value.present?
-          inspection << "#{attribute}: #{attribute_for_inspect(value)}"
-        end
-      end
-
-      "#<#{self.class} #{inspection * ', '}>"
-    end
-
-    def attribute_for_inspect(value)
-      if value.is_a?(String) && value.length > 50
-        "#{value[0..50]}...".inspect
-      elsif value.is_a?(Date) || value.is_a?(Time)
-        %("#{value.to_s(:db)}")
-      else
-        value.inspect
-      end
-    end
-  end
-end

data/lib/superstore/model.rb

@@ -1,38 +0,0 @@
-module Superstore
-  module Model
-    extend ActiveSupport::Concern
-
-    included do
-      class_attribute :symbolized_config
-      self.symbolized_config = {}
-    end
-
-    module ClassMethods
-      def base_class
-        class_of_active_record_descendant(self)
-      end
-
-      def config=(config)
-        self.symbolized_config = config.deep_symbolize_keys
-      end
-
-      def config
-        symbolized_config
-      end
-
-      private
-
-      # Returns the class descending directly from ActiveRecord::Base or an
-      # abstract class, if any, in the inheritance hierarchy.
-      def class_of_active_record_descendant(klass)
-        if klass == Base || klass.superclass == Base
-          klass
-        elsif klass.superclass.nil?
-          raise "#{name} doesn't belong in a hierarchy descending from Superstore"
-        else
-          class_of_active_record_descendant(klass.superclass)
-        end
-      end
-    end
-  end
-end

data/lib/superstore/schema.rb

@@ -1,20 +0,0 @@
-module Superstore
-  class Schema
-    class << self
-      def create_table(table_name, options = {})
-        adapter.create_table table_name, options
-      end
-
-      def drop_table(table_name)
-        adapter.drop_table table_name
-      end
-
-      private
-
-        def adapter
-          Superstore::Base.adapter
-        end
-
-    end
-  end
-end

data/lib/superstore/scope.rb

@@ -1,73 +0,0 @@
-require 'superstore/scope/batches'
-require 'superstore/scope/finder_methods'
-require 'superstore/scope/query_methods'
-
-module Superstore
-  class Scope
-    include Batches, FinderMethods, QueryMethods
-
-    attr_accessor :klass
-    attr_accessor :limit_value, :select_values, :where_values, :id_values, :order_values
-
-    def initialize(klass)
-      @klass = klass
-
-      @limit_value    = nil
-      @select_values  = []
-      @where_values   = []
-      @order_values   = []
-      @id_values      = []
-
-      reset
-    end
-
-    def initialize_copy(other)
-      @limit_value    = @limit_value.dup if @limit_value
-      @select_values  = @select_values.dup
-      @where_values   = @where_values.dup
-      @order_values   = @order_values.dup
-      @id_values      = @id_values.dup
-      reset
-    end
-
-    def reset
-      @records = nil
-      @loaded = false
-    end
-
-    private
-
-      def scoping
-        previous, klass.current_scope = klass.current_scope, self
-        yield
-      ensure
-        klass.current_scope = previous
-      end
-
-      def method_missing(method_name, *args, &block)
-        if klass.respond_to?(method_name)
-          scoping { klass.send(method_name, *args, &block) }
-        elsif Array.method_defined?(method_name)
-          to_a.send(method_name, *args, &block)
-        else
-          super
-        end
-      end
-
-      def to_a
-        unless @loaded
-          @records = select_records
-          @loaded  = true
-        end
-        @records
-      end
-
-      def select_records
-        results = []
-        klass.adapter.select(self) do |key, attributes|
-          results << klass.instantiate(key, attributes)
-        end
-        results
-      end
-  end
-end

data/lib/superstore/scope/batches.rb

@@ -1,27 +0,0 @@
-module Superstore
-  module Batches
-    def find_each(options = {})
-      batch_size = options[:batch_size] || 1000
-
-      klass.adapter.scroll(self, batch_size) do |key, attributes|
-        yield klass.instantiate(key, attributes)
-      end
-    end
-
-    def find_in_batches(options = {})
-      batch_size = options[:batch_size] || 1000
-      batch = []
-
-      find_each(options) do |record|
-        batch << record
-
-        if batch.size == batch_size
-          yield batch
-          batch = []
-        end
-      end
-
-      yield(batch) if batch.any?
-    end
-  end
-end

data/lib/superstore/scope/finder_methods.rb

@@ -1,51 +0,0 @@
-module Superstore
-  module FinderMethods
-    def find(ids)
-      if ids.is_a?(Array)
-        find_some(ids)
-      else
-        find_one(ids)
-      end
-    end
-
-    def find_by_id(ids)
-      find(ids)
-    rescue Superstore::RecordNotFound
-      nil
-    end
-
-    def all
-      clone
-    end
-
-    def first
-      limit(1).to_a.first
-    end
-
-    def to_ids
-      klass.adapter.to_ids self
-    end
-
-    private
-
-      def find_one(id)
-        if id.blank?
-          raise Superstore::RecordNotFound, "Couldn't find #{self.name} with key #{id.inspect}"
-        elsif record = where_ids(id).first
-          record
-        else
-          raise Superstore::RecordNotFound
-        end
-      end
-
-      def find_some(ids)
-        ids = ids.flatten
-        ids.compact!
-        return [] if ids.empty?
-
-        ids = ids.map(&:to_s).uniq
-
-        where_ids(ids).to_a
-      end
-  end
-end

data/lib/superstore/scope/query_methods.rb

@@ -1,52 +0,0 @@
-module Superstore
-  module QueryMethods
-    def select!(*values)
-      self.select_values += values.flatten
-      self
-    end
-
-    def select(*values, &block)
-      if block_given?
-        to_a.select(&block)
-      else
-        clone.select!(*values)
-      end
-    end
-
-    def where!(*values)
-      self.where_values += values.flatten
-      self
-    end
-
-    def where(*values)
-      clone.where! values
-    end
-
-    def where_ids!(*ids)
-      self.id_values += ids.flatten
-      self
-    end
-
-    def where_ids(*ids)
-      clone.where_ids! ids
-    end
-
-    def limit!(value)
-      self.limit_value = value
-      self
-    end
-
-    def limit(value)
-      clone.limit! value
-    end
-
-    def order!(*values)
-      self.order_values = values.flatten
-      self
-    end
-
-    def order(*values)
-      clone.order! values
-    end
-  end
-end

data/lib/superstore/scoping.rb

@@ -1,30 +0,0 @@
-module Superstore
-  module Scoping
-    extend ActiveSupport::Concern
-
-    included do
-      singleton_class.class_eval do
-        delegate :find, :find_by_id, :first, :all, :to_ids, to: :scope
-        delegate :find_each, :find_in_batches, to: :scope
-        delegate :select, :where, :where_ids, to: :scope
-      end
-
-      class_attribute :default_scopes, instance_writer: false, instance_predicate: false
-      self.default_scopes = []
-    end
-
-    module ClassMethods
-      def scope
-        self.current_scope ||= Scope.new(self)
-      end
-
-      def current_scope
-        Thread.current["#{self}_current_scope"]
-      end
-
-      def current_scope=(new_scope)
-        Thread.current["#{self}_current_scope"] = new_scope
-      end
-    end
-  end
-end

data/lib/superstore/timestamps.rb

@@ -1,19 +0,0 @@
-module Superstore
-  module Timestamps
-    extend ActiveSupport::Concern
-
-    included do
-      attribute :created_at, type: :time
-      attribute :updated_at, type: :time
-
-      before_create do
-        self.created_at ||= Time.current
-        self.updated_at ||= Time.current
-      end
-
-      before_update if: :changed? do
-        self.updated_at = Time.current unless self.changed_attributes.key?("updated_at")
-      end
-    end
-  end
-end

data/lib/superstore/type.rb

@@ -1,16 +0,0 @@
-module Superstore
-  class Type
-    cattr_accessor :attribute_types
-    self.attribute_types = {}.with_indifferent_access
-
-    class << self
-      def register(name, type)
-        attribute_types[name] = type
-      end
-
-      def get_type_class(name)
-        attribute_types[name]
-      end
-    end
-  end
-end