superstore 1.2.0 → 2.0.0

data/lib/superstore/adapters/hstore_adapter.rb

@@ -1,170 +0,0 @@
-gem 'pg'
-require 'pg'
-
-module Superstore
-  module Adapters
-    class HstoreAdapter < AbstractAdapter
-      class QueryBuilder
-        def initialize(adapter, scope)
-          @adapter  = adapter
-          @scope    = scope
-        end
-
-        def to_query
-          [
-            "SELECT #{select_string} FROM #{@scope.klass.table_name}",
-            where_string,
-            order_string,
-            limit_string
-          ].delete_if(&:blank?) * ' '
-        end
-
-        def select_string
-          if @scope.select_values.any?
-            "id, slice(attribute_store, #{@adapter.fields_to_postgres_array(@scope.select_values)}) as attribute_store"
-          else
-            '*'
-          end
-        end
-
-        def where_string
-          wheres = @scope.where_values.dup
-          if @scope.id_values.any?
-            wheres << @adapter.create_ids_where_clause(@scope.id_values)
-          end
-
-          if wheres.any?
-            "WHERE #{wheres * ' AND '}"
-          end
-        end
-
-        def order_string
-          if @scope.order_values.any?
-            orders = @scope.order_values.join(', ')
-            "ORDER BY #{orders}"
-          elsif @scope.id_values.many?
-            id_orders = @scope.id_values.map { |id| "ID=#{@adapter.quote(id)} DESC" }.join(',')
-            "ORDER BY #{id_orders}"
-          end
-        end
-
-        def limit_string
-          if @scope.limit_value
-            "LIMIT #{@scope.limit_value}"
-          end
-        end
-      end
-
-      def primary_key_column
-        'id'
-      end
-
-      def connection
-        # conf = {:adapter=>"postgresql", :encoding=>"unicode", :database=>"axle_place_test", :pool=>5, :username=>"postgres"}
-        # @connection ||= ActiveRecord::Base.postgresql_connection(conf)
-        ActiveRecord::Base.connection
-      end
-
-      def execute(statement)
-        ActiveSupport::Notifications.instrument("cql.cassandra_object", cql: statement) do
-          connection.execute statement
-        end
-      end
-
-      def select(scope)
-        statement = QueryBuilder.new(self, scope).to_query
-
-        connection.execute(statement).each do |attributes|
-          yield attributes[primary_key_column], hstore_to_attributes(attributes['attribute_store'])
-        end
-      end
-
-      def insert(table, id, attributes)
-        not_nil_attributes = attributes.reject { |key, value| value.nil? }
-        statement = "INSERT INTO #{table} (#{primary_key_column}, attribute_store) VALUES (#{quote(id)}, #{attributes_to_hstore(not_nil_attributes)})"
-        execute_batchable statement
-      end
-
-      def update(table, id, attributes)
-        return if attributes.empty?
-
-        not_nil_attributes = attributes.reject { |key, value| value.nil? }
-        nil_attributes = attributes.select { |key, value| value.nil? }
-
-        if not_nil_attributes.any? && nil_attributes.any?
-          value_update = "(attribute_store - #{fields_to_postgres_array(nil_attributes.keys)}) || #{attributes_to_hstore(not_nil_attributes)}"
-        elsif not_nil_attributes.any?
-          value_update = "attribute_store || #{attributes_to_hstore(not_nil_attributes)}"
-        elsif nil_attributes.any?
-          value_update = "attribute_store - #{fields_to_postgres_array(nil_attributes.keys)}"
-        end
-
-        statement = "UPDATE #{table} SET attribute_store = #{value_update} WHERE #{primary_key_column} = #{quote(id)}"
-        execute_batchable statement
-      end
-
-      def delete(table, ids)
-        statement = "DELETE FROM #{table} WHERE #{create_ids_where_clause(ids)}"
-
-        execute_batchable statement
-      end
-
-      def execute_batch(statements)
-        stmt = [
-          "BEGIN",
-          statements * ";\n",
-          'COMMIT'
-        ] * ";\n"
-
-        execute stmt
-      end
-
-      def create_table(table_name, options = {})
-        connection.execute 'CREATE EXTENSION IF NOT EXISTS hstore'
-        ActiveRecord::Migration.create_table table_name, id: false do |t|
-          t.string :id, null: false
-          t.hstore :attribute_store, null: false
-        end
-        connection.execute "ALTER TABLE \"#{table_name}\" ADD CONSTRAINT #{table_name}_pkey PRIMARY KEY (id)"
-      end
-
-      def drop_table(table_name)
-        ActiveRecord::Migration.drop_table table_name
-      end
-
-      def create_ids_where_clause(ids)
-        ids = ids.first if ids.is_a?(Array) && ids.one?
-
-        if ids.is_a?(Array)
-          id_list = ids.map { |id| quote(id) }.join(',')
-          "#{primary_key_column} IN (#{id_list})"
-        else
-          "#{primary_key_column} = #{quote(ids)}"
-        end
-      end
-
-      def quote(value)
-        connection.quote(value)
-      end
-
-      def fields_to_postgres_array(fields)
-        quoted_fields = fields.map { |field| "'#{field}'" }.join(',')
-        "ARRAY[#{quoted_fields}]"
-      end
-
-      private
-
-        def hstore_type
-          @hstore_type ||= ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Hstore.new
-        end
-
-        def attributes_to_hstore(attributes)
-          quote hstore_type.type_cast_for_database(attributes)
-        end
-
-        def hstore_to_attributes(string)
-          hstore_type.type_cast_from_database(string)
-        end
-    end
-  end
-end

data/lib/superstore/belongs_to/association.rb

@@ -1,65 +0,0 @@
-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?
-          check_appropriate_primary_key!
-          self.record_variable = get_record
-          @loaded = true
-        end
-
-        record_variable
-      end
-
-      def writer(record)
-        check_appropriate_primary_key!
-        self.record_variable = record
-        @loaded = true
-        owner.send("#{reflection.foreign_key}=", record.try(reflection.primary_key))
-        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
-
-      private
-
-      def get_record
-        record_id = owner.send(reflection.foreign_key).presence
-        return unless record_id
-
-        if reflection.default_primary_key?
-          association_class.find_by_id(record_id)
-        else
-          association_class.find_by(reflection.primary_key => record_id)
-        end
-      end
-
-      def check_appropriate_primary_key!
-        if !reflection.default_primary_key? && !(association_class <= ActiveRecord::Base)
-          raise ArgumentError, "Association must inherit from ActiveRecord::Base to use custom primary key"
-        end
-      end
-    end
-  end
-end

data/lib/superstore/belongs_to/builder.rb

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

@@ -1,38 +0,0 @@
-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
-        options[:foreign_key] || "#{name}_id"
-      end
-
-      def primary_key
-        options[:primary_key] || "id"
-      end
-
-      def default_primary_key?
-        primary_key == "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

@@ -1,63 +0,0 @@
-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/cassandra_schema/statements.rb

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

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

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

@@ -1,44 +0,0 @@
-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/railties/controller_runtime.rb

@@ -1,45 +0,0 @@
-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/tasks/ks.rake

@@ -1,59 +0,0 @@
-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
-
-  desc 'Remove the keyspace in config/superstore.yml for the current environment'
-  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
-
-  desc 'Alias for ks:drop and ks:setup'
-  task reset: [:drop, :setup]
-
-  desc 'Alias for ks:create and ks:structure:load'
-  task setup: [:create, :_load]
-
-  namespace :structure do
-    desc 'Serialize the current structure for the keyspace in config/superstore.yml to the SCHEMA environment variable (defaults to "$RAILS_ROOT/ks/structure.cql")'
-    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
-
-    desc 'Load the structure for the keyspace in config/superstore.yml from the SCHEMA environment variable (defaults to "$RAILS_ROOT/ks/structure.cql")'
-    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/test/support/cassandra.rb

@@ -1,46 +0,0 @@
-Bundler.require :cassandra
-
-Superstore::Base.config = {
-  keyspace: 'superstore_test',
-  servers: '127.0.0.1:9160',
-  consistency: 'QUORUM',
-  thrift: {
-    timeout: 5
-  }
-}
-
-begin
-  Superstore::CassandraSchema.drop_keyspace 'superstore_test'
-rescue Exception => e
-end
-
-sleep 1
-Superstore::CassandraSchema.create_keyspace 'superstore_test'
-Superstore::CassandraSchema.create_column_family 'Issues'
-Superstore::CassandraSchema.alter_column_family 'Issues', "ADD title varchar"
-Superstore::CassandraSchema.add_index 'Issues', 'title', "issues_title_idx"
-
-Superstore::Base.class_eval do
-  class_attribute :created_records
-  self.created_records = []
-
-  after_create do
-    created_records << self
-  end
-
-  def self.delete_after_test
-    # created_records.reject(&:destroyed?).each(&:destroy)
-    Issue.delete_all
-    created_records.clear
-  end
-end
-
-module ActiveSupport
-  class TestCase
-    teardown do
-      if Superstore::Base.created_records.any?
-        Superstore::Base.delete_after_test
-      end
-    end
-  end
-end