superstore 1.0.0

data/lib/superstore/attribute_methods/typecasting.rb

@@ -0,0 +1,59 @@
+module Superstore
+  module AttributeMethods
+    module Typecasting
+      extend ActiveSupport::Concern
+
+      included do
+        class_attribute :attribute_definitions
+        self.attribute_definitions = {}
+
+        %w(array boolean date float integer json string time).each do |type|
+          instance_eval <<-EOV, __FILE__, __LINE__ + 1
+            def #{type}(*args)
+              options = args.extract_options!
+              args.each do |name|
+                attribute(name, options.merge(:type => :#{type}))
+              end
+            end
+          EOV
+        end
+      end
+
+      module ClassMethods
+        def inherited(child)
+          super
+          child.attribute_definitions = attribute_definitions.dup
+        end
+
+        #
+        # attribute :name, type: :string
+        # attribute :ammo, type: Ammo, coder: AmmoCodec
+        #
+        def attribute(name, options)
+          type  = options[:type]
+          coder = options[:coder]
+
+          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)
+        end
+
+        def typecast_attribute(record, name, value)
+          if attribute_definition = attribute_definitions[name.to_s]
+            attribute_definition.instantiate(record, value)
+          else
+            raise NoMethodError, "Unknown attribute #{name.inspect}"
+          end
+        end
+
+        def coder_for(attribute)
+          attribute_definitions[attribute.to_s].coder
+        end
+      end
+    end
+  end
+end

data/lib/superstore/attribute_methods.rb

@@ -0,0 +1,96 @@
+module Superstore
+  module AttributeMethods
+    extend ActiveSupport::Concern
+    include ActiveModel::AttributeMethods
+
+    included do
+      if ActiveModel::VERSION::STRING < '3.2'
+        attribute_method_suffix("", "=")
+      else
+        attribute_method_suffix("=")
+      end
+
+      # (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
+    end
+
+    def write_attribute(name, value)
+      @attributes[name.to_s] = self.class.typecast_attribute(self, name, value)
+    end
+
+    def read_attribute(name)
+      @attributes[name.to_s]
+    end
+
+    def attribute_exists?(name)
+      @attributes.key?(name.to_s)
+    end
+
+    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)
+      if !self.class.attribute_methods_generated?
+        self.class.define_attribute_methods
+        send(method_id, *args, &block)
+      else
+        super
+      end
+    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/base.rb

@@ -0,0 +1,33 @@
+require 'set'
+
+require 'superstore/log_subscriber'
+require 'superstore/types'
+
+module Superstore
+  class Base
+
+    extend ActiveModel::Naming
+    include ActiveModel::Conversion
+    extend ActiveSupport::DescendantsTracker
+    include ActiveModel::Serializers::JSON
+
+    include Connection
+    include Identity
+    include Inspect
+    include Persistence
+    include AttributeMethods
+    include Validations
+    include AttributeMethods::Dirty
+    include AttributeMethods::PrimaryKey
+    include AttributeMethods::Typecasting
+    include BelongsTo
+    include Callbacks
+    include Timestamps
+    include Scoping
+    include Core
+    extend  Model
+
+  end
+end
+
+ActiveSupport.run_load_hooks(:superstore, Superstore::Base)

data/lib/superstore/belongs_to/association.rb

@@ -0,0 +1,48 @@
+module Superstore
+  module BelongsTo
+    class Association
+      attr_reader :owner, :reflection
+      attr_accessor :record_variable
+      delegate :options, to: :reflection
+
+      def initialize(owner, reflection)
+        @owner = owner
+        @reflection = reflection
+      end
+
+      def reader
+        unless loaded?
+          if record_id = owner.send(reflection.foreign_key).presence
+            self.record_variable = association_class.find_by_id(record_id)
+          else
+            self.record_variable = nil
+          end
+          @loaded = true
+        end
+
+        record_variable
+      end
+
+      def writer(record)
+        self.record_variable = record
+        @loaded = true
+        owner.send("#{reflection.foreign_key}=", record.try(:id))
+        if reflection.polymorphic?
+          owner.send("#{reflection.polymorphic_column}=", record.class.name)
+        end
+      end
+
+      def association_class
+        association_class_name.constantize
+      end
+
+      def association_class_name
+        reflection.polymorphic? ? owner.send(reflection.polymorphic_column) : reflection.class_name
+      end
+
+      def loaded?
+        @loaded
+      end
+    end
+  end
+end

data/lib/superstore/belongs_to/builder.rb

@@ -0,0 +1,40 @@
+module Superstore
+  module BelongsTo
+    class Builder
+      def self.build(model, name, options)
+        new(model, name, options).build
+      end
+
+      attr_reader :model, :name, :options
+      def initialize(model, name, options)
+        @model, @name, @options = model, name, options
+      end
+
+      def build
+        define_writer
+        define_reader
+
+        reflection = Superstore::BelongsTo::Reflection.new(model, name, options)
+        model.belongs_to_reflections = model.belongs_to_reflections.merge(name => reflection)
+      end
+
+      def mixin
+        model.generated_belongs_to_methods
+      end
+
+      def define_writer
+        name = self.name
+        mixin.redefine_method("#{name}=") do |records|
+          belongs_to_association(name).writer(records)
+        end
+      end
+
+      def define_reader
+        name = self.name
+        mixin.redefine_method(name) do
+          belongs_to_association(name).reader
+        end
+      end
+    end
+  end
+end

data/lib/superstore/belongs_to/reflection.rb

@@ -0,0 +1,30 @@
+module Superstore
+  module BelongsTo
+    class Reflection
+      attr_reader :model, :name, :options
+      def initialize(model, name, options)
+        @model, @name, @options = model, name, options
+      end
+
+      def instance_variable_name
+        "@#{name}"
+      end
+
+      def foreign_key
+        "#{name}_id"
+      end
+
+      def polymorphic_column
+        "#{name}_type"
+      end
+
+      def polymorphic?
+        options[:polymorphic]
+      end
+
+      def class_name
+        options[:class_name] || name.to_s.camelize
+      end
+    end
+  end
+end

data/lib/superstore/belongs_to.rb

@@ -0,0 +1,63 @@
+module Superstore
+  module BelongsTo
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :belongs_to_reflections
+      self.belongs_to_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::BelongsTo::Builder.build(self, name, options)
+      end
+
+      def generated_belongs_to_methods
+        @generated_belongs_to_methods ||= begin
+          mod = const_set(:GeneratedBelongsToMethods, 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 belongs_to_association(name)
+      association = belongs_to_instance_get(name)
+
+      if association.nil?
+        association = Superstore::BelongsTo::Association.new(self, belongs_to_reflections[name])
+        belongs_to_instance_set(name, association)
+      end
+
+      association
+    end
+
+    private
+      def clear_belongs_to_cache
+        belongs_to_cache.clear if persisted?
+      end
+
+      def belongs_to_cache
+        @belongs_to_cache ||= {}
+      end
+
+      def belongs_to_instance_get(name)
+        belongs_to_cache[name.to_sym]
+      end
+
+      def belongs_to_instance_set(name, association)
+        belongs_to_cache[name.to_sym] = association
+      end
+  end
+end

data/lib/superstore/callbacks.rb

@@ -0,0 +1,29 @@
+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 #:nodoc:
+        run_callbacks(:create) { super }
+      end
+
+      def update(*) #:nodoc:
+        run_callbacks(:update) { super }
+      end
+  end
+end

data/lib/superstore/cassandra_schema/statements.rb

@@ -0,0 +1,52 @@
+module Superstore
+  module Statements
+    DEFAULT_CREATE_KEYSPACE = {
+      'strategy_class' => 'SimpleStrategy',
+      'strategy_options:replication_factor' => 1
+    }
+
+    def create_keyspace(keyspace, options = nil)
+      stmt = "CREATE KEYSPACE #{keyspace}"
+
+      options ||= DEFAULT_CREATE_KEYSPACE
+
+      system_execute adapter.statement_with_options(stmt, options)
+    end
+
+    def drop_keyspace(keyspace)
+      system_execute "DROP KEYSPACE #{keyspace}"
+    end
+
+    def create_column_family(column_family, options = {})
+      create_table column_family, options
+    end
+
+    def alter_column_family(column_family, instruction, options = {})
+      stmt = "ALTER TABLE #{column_family} #{instruction}"
+      keyspace_execute adapter.statement_with_options(stmt, options)
+    end
+
+    def drop_column_family(column_family)
+      drop_table column_family
+    end
+
+    def add_index(column_family, column, index_name = nil)
+      stmt = "CREATE INDEX #{index_name.nil? ? '' : index_name} ON #{column_family} (#{column})"
+      keyspace_execute stmt
+    end
+
+    # If the index was not given a name during creation, the index name is <columnfamily_name>_<column_name>_idx.
+    def drop_index(index_name)
+      keyspace_execute "DROP INDEX #{index_name}"
+    end
+
+
+    def keyspace_execute(cql)
+      adapter.schema_execute cql, Superstore::Base.config[:keyspace]
+    end
+
+    def system_execute(cql)
+      adapter.schema_execute cql, 'system'
+    end
+  end
+end

data/lib/superstore/cassandra_schema/tasks.rb

@@ -0,0 +1,47 @@
+module Superstore
+  module Tasks
+    def dump(io)
+      table_names.each do |column_family|
+        io.puts run_command("DESCRIBE COLUMNFAMILY #{column_family}")
+        io.puts
+      end
+    end
+
+    def load(io)
+      current_cql = ''
+
+      io.each_line do |line|
+        next if line.blank?
+
+        current_cql << line.rstrip
+
+        if current_cql =~ /;$/
+          keyspace_execute current_cql
+          current_cql = ''
+        end
+      end
+    end
+
+    def table_names
+      run_command('DESCRIBE COLUMNFAMILIES').split.sort
+    end
+
+    private
+
+      def run_command(command)
+        `echo "#{command};" | #{cqlsh} -2 -k #{keyspace} #{server}`.sub(/^(.*)$/, '').strip
+      end
+
+      def cqlsh
+        ENV['CQLSH'] || 'cqlsh'
+      end
+
+      def keyspace
+        Superstore::Base.config[:keyspace]
+      end
+
+      def server
+        Superstore::Base.adapter.servers.first.gsub(/:.*/, '')
+      end
+  end
+end

data/lib/superstore/cassandra_schema.rb

@@ -0,0 +1,9 @@
+require 'superstore/cassandra_schema/statements'
+require 'superstore/cassandra_schema/tasks'
+
+module Superstore
+  class CassandraSchema < Schema
+    extend Superstore::Statements
+    extend Superstore::Tasks
+  end
+end

data/lib/superstore/connection.rb

@@ -0,0 +1,39 @@
+module CassandraCQL
+  class Statement
+    def self.sanitize(statement, bind_vars=[])
+      return statement if bind_vars.empty?
+
+      bind_vars = bind_vars.dup
+      expected_bind_vars = statement.count("?")
+
+      raise Error::InvalidBindVariable, "Wrong number of bound variables (statement expected #{expected_bind_vars}, was #{bind_vars.size})" if expected_bind_vars != bind_vars.size
+
+      statement.gsub(/\?/) do
+        quote(cast_to_cql(bind_vars.shift))
+      end
+    end
+  end
+end
+
+module Superstore
+  module Connection
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def adapter
+        @@adapter ||= adapter_class.new(config)
+      end
+
+      def adapter_class
+        case config[:adapter]
+        when 'hstore'
+          Superstore::Adapters::HstoreAdapter
+        when nil, 'cassandra'
+          Superstore::Adapters::CassandraAdapter
+        else
+          raise "Unknown adapter #{config[:adapter]}"
+        end
+      end
+    end
+  end
+end

data/lib/superstore/core.rb

@@ -0,0 +1,59 @@
+module Superstore
+  module Core
+    extend ActiveSupport::Concern
+
+    def initialize(attributes=nil)
+      @new_record = true
+      @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
+
+    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
+      super
+    end
+
+    def to_param
+      id
+    end
+
+    def hash
+      id.hash
+    end
+
+    module ClassMethods
+      def inspect
+        if self == Base
+          super
+        else
+          attr_list = @attributes.map do |col, definition| "#{col}: #{definition.type}" end * ', '
+          "#{super}(#{attr_list.truncate(140 * 1.7337)})"
+        end
+      end
+    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)
+    end
+  end
+end

data/lib/superstore/errors.rb

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

data/lib/superstore/identity.rb

@@ -0,0 +1,26 @@
+require 'securerandom'
+
+module Superstore
+  module Identity
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :key_generator
+
+      key do
+        SecureRandom.uuid.tr('-','')
+      end
+    end
+
+    module ClassMethods
+      # Define a key generator. Default is UUID.
+      def key(&block)
+        self.key_generator = block
+      end
+
+      def _generate_key(object)
+        object.instance_eval(&key_generator)
+      end
+    end
+  end
+end

data/lib/superstore/inspect.rb

@@ -0,0 +1,25 @@
+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