superstore 1.2.0 → 2.0.0

data/lib/superstore/associations.rb

@@ -0,0 +1,72 @@
+module Superstore
+  module Associations
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :association_reflections
+      self.association_reflections = {}
+    end
+
+    module ClassMethods
+      # === Options
+      # [:class_name]
+      #   Use if the class cannot be inferred from the association
+      # [:polymorphic]
+      #   Specify if the association is polymorphic
+      # Example:
+      #   class Driver < Superstore::Base
+      #   end
+      #   class Truck < Superstore::Base
+      #   end
+      def belongs_to(name, options = {})
+        Superstore::Associations::Builder::BelongsTo.build(self, name, options)
+      end
+
+      def has_many(name, options = {})
+        Superstore::Associations::Builder::HasMany.build(self, name, options)
+      end
+
+      def has_one(name, options = {})
+        Superstore::Associations::Builder::HasOne.build(self, name, options)
+      end
+
+      def generated_association_methods
+        @generated_association_methods ||= begin
+          mod = const_set(:GeneratedAssociationMethods, Module.new)
+          include mod
+          mod
+        end
+      end
+    end
+
+    # Returns the belongs_to instance for the given name, instantiating it if it doesn't already exist
+    def association(name)
+      instance = association_instance_get(name)
+
+      if instance.nil?
+        reflection = association_reflections[name]
+        instance = reflection.association_class.new(self, reflection)
+        association_instance_set(name, instance)
+      end
+
+      instance
+    end
+
+    private
+      def clear_associations_cache
+        associations_cache.clear if persisted?
+      end
+
+      def associations_cache
+        @associations_cache ||= {}
+      end
+
+      def association_instance_get(name)
+        associations_cache[name.to_sym]
+      end
+
+      def association_instance_set(name, association)
+        associations_cache[name.to_sym] = association
+      end
+  end
+end

data/lib/superstore/attribute_methods/definition.rb

@@ -1,21 +1,16 @@
 module Superstore
   module AttributeMethods
     class Definition
-      attr_reader :name, :coder
-      def initialize(name, coder, options)
-        @name   = name.to_s
-        @coder  = coder.new(options)
-      end
-
-      def default
-        coder.default
+      attr_reader :name, :type
+      def initialize(model, name, type_class, options)
+        @name = name.to_s
+        @type = type_class.new(model, options)
       end
 
       def instantiate(value)
-        value = value.nil? ? coder.default : value
         return if value.nil?
 
-        value.kind_of?(String) ? coder.decode(value) : coder.typecast(value)
+        value.kind_of?(String) ? type.decode(value) : type.typecast(value)
       end
     end
   end

data/lib/superstore/attribute_methods/dirty.rb

@@ -27,13 +27,23 @@ module Superstore
         result
       end
 
+      def old_attribute_value(attr)
+        if attribute_changed?(attr)
+          changed_attributes[attr]
+        else
+          read_attribute attr
+        end
+      end
+
       def write_attribute(name, value)
         name = name.to_s
-        old = read_attribute(name)
+        old = old_attribute_value(name)
 
         super
 
-        unless attribute_changed?(name) || old == read_attribute(name)
+        if old == read_attribute(name)
+          changed_attributes.delete(name)
+        else
           changed_attributes[name] = old
         end
       end

data/lib/superstore/attribute_methods/typecasting.rb

@@ -27,19 +27,13 @@ module Superstore
 
         #
         # attribute :name, type: :string
-        # attribute :ammo, type: Ammo, coder: AmmoCodec
+        # attribute :ammo, type: :integer
         #
         def attribute(name, options)
-          type  = options[:type]
-          coder = options[:coder]
+          type_name  = options[:type]
+          type_class = Superstore::Type.get_type_class(type_name) || (raise "Unknown type #{type_name}")
 
-          if type.is_a?(Symbol)
-            coder = Superstore::Type.get_coder(type) || (raise "Unknown type #{type}")
-          elsif coder.nil?
-            raise "Must supply a :coder for #{name}"
-          end
-
-          attribute_definitions[name.to_s] = AttributeMethods::Definition.new(name, coder, options)
+          attribute_definitions[name.to_s] = AttributeMethods::Definition.new(self, name, type_class, options)
         end
 
         def typecast_attribute(name, value)
@@ -50,8 +44,8 @@ module Superstore
           end
         end
 
-        def coder_for(attribute)
-          attribute_definitions[attribute.to_s].coder
+        def type_for(attribute)
+          attribute_definitions[attribute.to_s].type
         end
       end
     end

data/lib/superstore/base.rb

@@ -1,6 +1,5 @@
 require 'set'
 
-require 'superstore/log_subscriber'
 require 'superstore/types'
 
 module Superstore
@@ -12,6 +11,8 @@ module Superstore
     include ActiveModel::Serializers::JSON
     include GlobalID::Identification
 
+    include Model
+    include Core
     include Connection
     include Identity
     include Inspect
@@ -21,13 +22,11 @@ module Superstore
     include AttributeMethods::Dirty
     include AttributeMethods::PrimaryKey
     include AttributeMethods::Typecasting
-    include BelongsTo
+    include Associations
     include Callbacks
     include Timestamps
     include Scoping
-    include Core
     include Caching
-    extend  Model
 
   end
 end

data/lib/superstore/connection.rb

@@ -4,15 +4,13 @@ module Superstore
 
     module ClassMethods
       def adapter
-        @@adapter ||= adapter_class.new(config)
+        @adapter ||= adapter_class.new(config)
       end
 
       def adapter_class
         case config[:adapter]
-        when 'hstore'
-          Superstore::Adapters::HstoreAdapter
-        when nil, 'cassandra'
-          Superstore::Adapters::CassandraAdapter
+        when nil, 'jsonb'
+          Superstore::Adapters::JsonbAdapter
         else
           raise "Unknown adapter #{config[:adapter]}"
         end

data/lib/superstore/core.rb

@@ -7,11 +7,6 @@ module Superstore
       @destroyed = false
       @attributes = {}
       self.attributes = attributes || {}
-      attribute_definitions.each_value do |definition|
-        unless definition.default.nil? || attribute_exists?(definition.name)
-          @attributes[definition.name] = definition.default
-        end
-      end
 
       yield self if block_given?
     end

data/lib/superstore/model.rb

@@ -1,46 +1,45 @@
 module Superstore
   module Model
-    def table_name=(table_name)
-      @table_name = table_name
-    end
+    extend ActiveSupport::Concern
 
-    def table_name
-      @table_name ||= base_class.name.pluralize
+    included do
+      class_attribute :symbolized_config
+      self.symbolized_config = {}
     end
 
-    def column_family
-      ActiveSupport::Deprecation.warn '`column_family` is deprecated & will be removed in superstore 2.0. Use `table_name` instead.'
-      table_name
-    end
+    module ClassMethods
+      def table_name=(table_name)
+        @table_name = table_name
+      end
 
-    def column_family=(table_name)
-      ActiveSupport::Deprecation.warn '`column_family=` is deprecated & will be removed in superstore 2.0. Use `table_name=` instead.'
-      self.table_name = table_name
-    end
+      def table_name
+        @table_name ||= base_class.model_name.plural
+      end
 
-    def base_class
-      class_of_active_record_descendant(self)
-    end
+      def base_class
+        class_of_active_record_descendant(self)
+      end
 
-    def config=(config)
-      @@config = config.deep_symbolize_keys
-    end
+      def config=(config)
+        self.symbolized_config = config.deep_symbolize_keys
+      end
 
-    def config
-      @@config
-    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)
+      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

data/lib/superstore/persistence.rb

@@ -7,7 +7,7 @@ module Superstore
     end
 
     module ClassMethods
-      def remove(ids)
+      def delete(ids)
         adapter.delete table_name, ids
       end
 
@@ -52,7 +52,7 @@ module Superstore
           if value.nil?
             encoded[column_name] = nil
           else
-            encoded[column_name] = attribute_definitions[column_name].coder.encode(value)
+            encoded[column_name] = attribute_definitions[column_name].type.encode(value)
           end
         end
         encoded
@@ -73,12 +73,6 @@ module Superstore
             end
           end
 
-          attribute_definitions.each_value do |definition|
-            unless definition.default.nil? || result.has_key?(definition.name)
-              result[definition.name] = definition.default
-            end
-          end
-
           result
         end
     end
@@ -100,7 +94,7 @@ module Superstore
     end
 
     def destroy
-      self.class.remove(id)
+      self.class.delete(id)
       @destroyed = true
     end
 
@@ -133,7 +127,7 @@ module Superstore
     end
 
     def reload
-      clear_belongs_to_cache
+      clear_associations_cache
       @attributes = self.class.find(id).instance_variable_get('@attributes')
       self
     end

data/lib/superstore/railtie.rb

@@ -1,19 +1,9 @@
 module Superstore
   class Railtie < Rails::Railtie
-    rake_tasks do
-      load 'superstore/tasks/ks.rake'
-    end
-
     initializer "superstore.config" do |app|
       ActiveSupport.on_load :superstore do
-        pathnames = [Rails.root.join('config', 'cassandra.yml'), Rails.root.join('config', 'superstore.yml')]
-        if pathname = pathnames.detect(&:exist?)
-          if pathname.basename.to_s == 'cassandra.yml'
-            warn "***********************"
-            warn "config/cassandra.yml is deprecated. Use config/superstore.yml"
-            warn "***********************"
-          end
-
+        pathname = Rails.root.join('config', 'superstore.yml')
+        if pathname.exist?
           config = ERB.new(pathname.read).result
           config = YAML.load(config)
 
@@ -25,13 +15,5 @@ module Superstore
         end
       end
     end
-
-    # Expose database runtime to controller for logging.
-    initializer "superstore.log_runtime" do |app|
-      require "superstore/railties/controller_runtime"
-      ActiveSupport.on_load(:action_controller) do
-        include Superstore::Railties::ControllerRuntime
-      end
-    end
   end
 end

data/lib/superstore/scope/batches.rb

@@ -1,32 +1,27 @@
 module Superstore
-  class Scope
-    module Batches
-      def find_each(options = {})
-        find_in_batches(options) do |records|
-          records.each { |record| yield record }
-        end
-      end
-
-      def find_in_batches(options = {})
-        batch_size = options.delete(:batch_size) || 1000
-        start_key = nil
+  module Batches
+    def find_each(options = {})
+      batch_size = options[:batch_size] || 1000
 
-        scope = limit(batch_size + 1).order(:id)
-        records = scope.to_a
+      klass.adapter.scroll(self, batch_size) do |key, attributes|
+        yield klass.instantiate(key, attributes)
+      end
+    end
 
-        while records.any?
-          if records.size > batch_size
-            next_record = records.pop
-          else
-             next_record = nil
-          end
+    def find_in_batches(options = {})
+      batch_size = options[:batch_size] || 1000
+      batch = []
 
-          yield records
-          break if next_record.nil?
+      find_each(options) do |record|
+        batch << record
 
-          records = scope.where("#{adapter.primary_key_column} >= '#{next_record.id}'").to_a
+        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,48 +1,46 @@
 module Superstore
-  class Scope
-    module FinderMethods
-      def find(ids)
-        if ids.is_a?(Array)
-          find_some(ids)
-        else
-          find_one(ids)
-        end
+  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 find_by_id(ids)
+      find(ids)
+    rescue Superstore::RecordNotFound
+      nil
+    end
 
-      def all
-        to_a
-      end
+    def all
+      clone
+    end
 
-      def first
-        limit(1).to_a.first
-      end
+    def first
+      limit(1).to_a.first
+    end
 
-      private
+    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
+      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
-          return [] if ids.empty?
+      def find_some(ids)
+        ids = ids.flatten
+        return [] if ids.empty?
 
-          ids = ids.compact.map(&:to_s).uniq
+        ids = ids.compact.map(&:to_s).uniq
 
-          where_ids(ids).to_a
-        end
-    end
+        where_ids(ids).to_a
+      end
   end
 end

data/lib/superstore/scope/query_methods.rb

@@ -1,58 +1,52 @@
 module Superstore
-  class Scope
-    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
+  module QueryMethods
+    def select!(*values)
+      self.select_values += values.flatten
+      self
+    end
 
-      def where!(*values)
-        self.where_values += values.flatten
-        self
+    def select(*values, &block)
+      if block_given?
+        to_a.select(&block)
+      else
+        clone.select! *values
       end
+    end
 
-      def where(*values)
-        clone.where! values
-      end
+    def where!(*values)
+      self.where_values += values.flatten
+      self
+    end
 
-      def where_ids!(*ids)
-        self.id_values += ids.flatten
-        self
-      end
+    def where(*values)
+      clone.where! values
+    end
 
-      def where_ids(*ids)
-        clone.where_ids! ids
-      end
+    def where_ids!(*ids)
+      self.id_values += ids.flatten
+      self
+    end
 
-      def limit!(value)
-        self.limit_value = value
-        self
-      end
+    def where_ids(*ids)
+      clone.where_ids! ids
+    end
 
-      def limit(value)
-        clone.limit! value
-      end
+    def limit!(value)
+      self.limit_value = value
+      self
+    end
 
-      def order!(*values)
-        self.order_values = values.flatten
-        self
-      end
+    def limit(value)
+      clone.limit! value
+    end
 
-      def order(*values)
-        clone.order! values
-      end
+    def order!(*values)
+      self.order_values = values.flatten
+      self
+    end
 
-      def to_a
-        select_records
-      end
+    def order(*values)
+      clone.order! values
     end
   end
 end

data/lib/superstore/scope.rb

@@ -17,6 +17,22 @@ module Superstore
       @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
@@ -38,6 +54,14 @@ module Superstore
         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|

data/lib/superstore/type.rb

@@ -4,11 +4,11 @@ module Superstore
     self.attribute_types = {}.with_indifferent_access
 
     class << self
-      def register(name, coder)
-        attribute_types[name] = coder
+      def register(name, type)
+        attribute_types[name] = type
       end
 
-      def get_coder(name)
+      def get_type_class(name)
         attribute_types[name]
       end
     end