superstore 1.0.0

data/lib/superstore/log_subscriber.rb

@@ -0,0 +1,44 @@
+module Superstore
+  class LogSubscriber < ActiveSupport::LogSubscriber
+    def self.runtime=(value)
+      Thread.current["cassandra_object_request_runtime"] = value
+    end
+
+    def self.runtime
+      Thread.current["cassandra_object_request_runtime"] ||= 0
+    end
+
+    def self.reset_runtime
+      rt, self.runtime = runtime, 0
+      rt
+    end
+
+    def initialize
+      super
+      @odd_or_even = false
+    end
+
+    def cql(event)
+      self.class.runtime += event.duration
+
+      payload = event.payload
+      name = '%s (%.1fms)' % [payload[:name], event.duration]
+      cql = payload[:cql].squeeze(' ')
+
+      if odd?
+        name = color(name, CYAN, true)
+        cql  = color(cql, nil, true)
+      else
+        name = color(name, MAGENTA, true)
+      end
+
+      debug "  #{name}  #{cql}"
+    end
+
+    def odd?
+      @odd_or_even = !@odd_or_even
+    end
+  end
+end
+
+Superstore::LogSubscriber.attach_to :cassandra_object

data/lib/superstore/model.rb

@@ -0,0 +1,37 @@
+module Superstore
+  module Model
+    def column_family=(column_family)
+      @column_family = column_family
+    end
+
+    def column_family
+      @column_family ||= base_class.name.pluralize
+    end
+
+    def base_class
+      class_of_active_record_descendant(self)
+    end
+
+    def config=(config)
+      @@config = config.deep_symbolize_keys
+    end
+
+    def config
+      @@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

data/lib/superstore/persistence.rb

@@ -0,0 +1,153 @@
+module Superstore
+  module Persistence
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :batch_statements
+    end
+
+    module ClassMethods
+      def remove(ids)
+        adapter.delete column_family, ids
+      end
+
+      def delete_all
+        adapter.execute "TRUNCATE #{column_family}"
+      end
+
+      def create(attributes = {}, &block)
+        new(attributes, &block).tap do |object|
+          object.save
+        end
+      end
+
+      def insert_record(id, attributes)
+        adapter.insert column_family, id, encode_attributes(attributes)
+      end
+
+      def update_record(id, attributes)
+        adapter.update column_family, id, encode_attributes(attributes)
+      end
+
+      def batching?
+        adapter.batching?
+      end
+
+      def batch(&block)
+        adapter.batch(&block)
+      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(object, attributes))
+        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].coder.encode(value)
+          end
+        end
+        encoded
+      end
+
+      private
+
+        def quote_columns(column_names)
+          column_names.map { |name| "'#{name}'" }
+        end
+
+        def typecast_persisted_attributes(object, attributes)
+          attributes.each do |key, value|
+            if definition = attribute_definitions[key]
+              attributes[key] = definition.instantiate(object, value)
+            else
+              attributes.delete(key)
+            end
+          end
+
+          attribute_definitions.each_value do |definition|
+            unless definition.default.nil? || attributes.has_key?(definition.name)
+              attributes[definition.name] = definition.default
+            end
+          end
+
+          attributes
+        end
+    end
+
+    def new_record?
+      @new_record
+    end
+
+    def destroyed?
+      @destroyed
+    end
+
+    def persisted?
+      !(new_record? || destroyed?)
+    end
+
+    def save(*)
+      new_record? ? create : update
+    end
+
+    def destroy
+      self.class.remove(id)
+      @destroyed = true
+    end
+
+    def update_attribute(name, value)
+      name = name.to_s
+      send("#{name}=", value)
+      save(validate: false)
+    end
+
+    def update_attributes(attributes)
+      self.attributes = attributes
+      save
+    end
+
+    def update_attributes!(attributes)
+      self.attributes = attributes
+      save!
+    end
+
+    def becomes(klass)
+      became = klass.new
+      became.instance_variable_set("@attributes", @attributes)
+      became.instance_variable_set("@new_record", new_record?)
+      became.instance_variable_set("@destroyed", destroyed?)
+      became
+    end
+
+    def reload
+      clear_belongs_to_cache
+      @attributes = self.class.find(id).instance_variable_get('@attributes')
+      self
+    end
+
+    private
+
+      def create
+        @new_record = false
+        write :insert_record
+      end
+
+      def update
+        write :update_record
+      end
+
+      def write(method)
+        changed_attributes = Hash[changed.map { |attr| [attr, read_attribute(attr)] }]
+        self.class.send(method, id, changed_attributes)
+      end
+  end
+end

data/lib/superstore/railtie.rb

@@ -0,0 +1,30 @@
+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
+        pathname = Rails.root.join('config', 'superstore.yml')
+        if pathname.exist?
+          config = YAML.load(pathname.read)
+
+          if config = config[Rails.env]
+            self.config = config.symbolize_keys!
+          else
+            raise "Missing environment #{Rails.env} in superstore.yml"
+          end
+        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/railties/controller_runtime.rb

@@ -0,0 +1,45 @@
+require 'active_support/core_ext/module/attr_internal'
+require 'superstore/log_subscriber'
+
+module Superstore
+  module Railties # :nodoc:
+    module ControllerRuntime #:nodoc:
+      extend ActiveSupport::Concern
+
+      module ClassMethods # :nodoc:
+        def log_process_action(payload)
+          messages, cassandra_object_runtime = super, payload[:cassandra_object_runtime]
+          if cassandra_object_runtime.to_i > 0
+            messages << ("Superstore: %.1fms" % cassandra_object_runtime.to_f)
+          end
+          messages
+        end
+      end
+
+      #private
+
+        attr_internal :cassandra_object_runtime
+
+        def process_action(action, *args)
+          # We also need to reset the runtime before each action
+          # because of queries in middleware or in cases we are streaming
+          # and it won't be cleaned up by the method below.
+          Superstore::LogSubscriber.reset_runtime
+          super
+        end
+
+        def cleanup_view_runtime
+          runtime_before_render = Superstore::LogSubscriber.reset_runtime
+          runtime = super
+          runtime_after_render = Superstore::LogSubscriber.reset_runtime
+          self.cassandra_object_runtime = runtime_before_render + runtime_after_render
+          runtime - runtime_after_render
+        end
+
+        def append_info_to_payload(payload)
+          super
+          payload[:cassandra_object_runtime] = (cassandra_object_runtime || 0) + Superstore::LogSubscriber.reset_runtime
+        end
+    end
+  end
+end

data/lib/superstore/schema.rb

@@ -0,0 +1,20 @@
+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/batches.rb

@@ -0,0 +1,32 @@
+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
+
+        scope = limit(batch_size + 1)
+        records = scope.to_a
+
+        while records.any?
+          if records.size > batch_size
+            next_record = records.pop
+          else
+             next_record = nil
+          end
+
+          yield records
+          break if next_record.nil?
+
+          records = scope.where("#{adapter.primary_key_column} >= '#{next_record.id}'").to_a
+        end
+      end
+    end
+  end
+end

data/lib/superstore/scope/finder_methods.rb

@@ -0,0 +1,48 @@
+module Superstore
+  class Scope
+    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
+        to_a
+      end
+
+      def first
+        limit(1).to_a.first
+      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
+          return [] if ids.empty?
+
+          ids = ids.compact.map(&:to_s).uniq
+
+          where_ids(ids).to_a
+        end
+    end
+  end
+end

data/lib/superstore/scope/query_methods.rb

@@ -0,0 +1,49 @@
+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
+
+      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 to_a
+        select_records
+      end
+    end
+  end
+end

data/lib/superstore/scope.rb

@@ -0,0 +1,49 @@
+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
+
+    def initialize(klass)
+      @klass = klass
+
+      @limit_value    = nil
+      @select_values  = []
+      @where_values   = []
+      @id_values      = []
+    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 select_records
+        results = []
+        klass.adapter.select(self) do |key, attributes|
+          results << klass.instantiate(key, attributes)
+        end
+        results.compact!
+        results
+      end
+  end
+end

data/lib/superstore/scoping.rb

@@ -0,0 +1,27 @@
+module Superstore
+  module Scoping
+    extend ActiveSupport::Concern
+
+    included do
+      singleton_class.class_eval do
+        delegate :find, :find_by_id, :first, :all, to: :scope
+        delegate :find_each, :find_in_batches, to: :scope
+        delegate :select, :where, :where_ids, to: :scope
+      end
+    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/tasks/ks.rake

@@ -0,0 +1,54 @@
+ks_namespace = namespace :ks do
+  desc 'Create the keyspace in config/superstore.yml for the current environment'
+  task create: :environment do
+    begin
+      Superstore::CassandraSchema.create_keyspace Superstore::Base.config[:keyspace], Superstore::Base.config[:keyspace_options]
+    rescue Exception => e
+      if e.message =~ /conflicts/
+        p "Keyspace #{Superstore::Base.config[:keyspace]} already exists"
+      else
+        raise e
+      end
+    end
+  end
+
+  task drop: :environment do
+    begin
+      Superstore::CassandraSchema.drop_keyspace Superstore::Base.config[:keyspace]
+    rescue Exception => e
+      if e.message =~ /non existing keyspace/
+        p "Keyspace #{Superstore::Base.config[:keyspace]} does not exist"
+      else
+        raise e
+      end
+    end
+  end
+
+  task reset: [:drop, :setup]
+
+  task setup: [:create, :_load]
+
+  namespace :structure do
+    task dump: :environment do
+      filename = ENV['SCHEMA'] || "#{Rails.root}/ks/structure.cql"
+      File.open(filename, "w:utf-8") do |file|
+        Superstore::CassandraSchema.dump(file)
+      end
+    end
+
+    task load: :environment do
+      filename = ENV['SCHEMA'] || "#{Rails.root}/ks/structure.cql"
+      File.open(filename) do |file|
+        Superstore::CassandraSchema.load(file)
+      end
+    end
+  end
+
+  task :_dump do
+    ks_namespace["structure:dump"].invoke
+  end
+
+  task :_load do
+    ks_namespace["structure:load"].invoke
+  end
+end

data/lib/superstore/timestamps.rb

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

data/lib/superstore/type.rb

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

data/lib/superstore/types/array_type.rb

@@ -0,0 +1,20 @@
+module Superstore
+  module Types
+    class ArrayType < BaseType
+      def encode(array)
+        raise ArgumentError.new("#{array.inspect} is not an Array") unless array.kind_of?(Array)
+        array.to_a.to_json
+      end
+
+      def decode(str)
+        return nil if str.blank?
+
+        ActiveSupport::JSON.decode(str)
+      end
+
+      def typecast(value)
+        value.to_a
+      end
+    end
+  end
+end

data/lib/superstore/types/base_type.rb

@@ -0,0 +1,26 @@
+module Superstore
+  module Types
+    class BaseType
+      attr_accessor :options
+      def initialize(options = {})
+        @options = options
+      end
+
+      def default
+        options[:default].duplicable? ? options[:default].dup : options[:default]
+      end
+
+      def encode(value)
+        value.to_s
+      end
+
+      def decode(str)
+        str
+      end
+
+      def typecast(value)
+        value
+      end
+    end
+  end
+end

data/lib/superstore/types/boolean_type.rb

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