datastax_rails 1.2.3 → 2.0.3

data/lib/datastax_rails/identity.rb

@@ -1,64 +0,0 @@
-module DatastaxRails #:nodoc:
-  module Identity
-    extend ActiveSupport::Concern
-    extend ActiveSupport::Autoload
-
-    autoload :Key
-    autoload :AbstractKeyFactory
-    autoload :UUIDKeyFactory
-    autoload :NaturalKeyFactory
-    autoload :HashedNaturalKeyFactory
-    autoload :CustomKeyFactory
-
-    module ClassMethods
-      attr_accessor :key_factory
-      # Indicate what kind of key the model will have: uuid or natural
-      #
-      # @param [:uuid, :natural] name_or_factory the type of key
-      # @param [Hash] options the options you want to pass along to the key factory (like :attributes => :name, for a natural key).
-      # 
-      def key(name_or_factory = :uuid, *options)
-        @key_factory = case name_or_factory
-        when :uuid
-          UUIDKeyFactory.new(*options)
-        when :natural
-          NaturalKeyFactory.new(*options)
-        when :custom
-          CustomKeyFactory.new(*options)
-        else
-          name_or_factory
-        end
-      end
-
-      # The next key for the given object. Delegates the actual work to the factory which may
-      # or may not use the passed in object to generate the key.
-      #
-      # @param [DatastaxRails::Base] object the object for which the key is being generated
-      # @return [String] a key for this object
-      def next_key(object = nil)
-        @key_factory.next_key(object).tap do |key|
-          raise "Keys may not be nil" if key.nil?
-        end
-      end
-
-      # Parses out a key from the given string. Delegates the actual work to the factory.
-      # Return type varies depending on what type of key is used.
-      #
-      # @param [String] string a string representing a primary key
-      # @return an object representing the same key
-      def parse_key(string)
-        @key_factory.parse(string)
-      end
-    end
-
-    def id
-      key.to_s
-    end
-
-    # TODO test this
-    def id=(key)
-      self.key = self.class.parse_key(key)
-      id
-    end
-  end
-end

data/lib/datastax_rails/identity/abstract_key_factory.rb

@@ -1,29 +0,0 @@
-module DatastaxRails
-  module Identity
-    # Key factories need to support 3 operations
-    class AbstractKeyFactory
-      attr_accessor :key_columns
-      # Next key takes an object and returns the key object it should use.
-      # object will be ignored with synthetic keys but could be useful with natural ones
-      #
-      # @abstract
-      # @param  [DatastaxRails::Base] object the object that needs a new key
-      # @return [DatastaxRails::Identity::Key] the key
-      #
-      def next_key(object)
-        raise NotImplementedError, "#{self.class.name}#next_key isn't implemented."
-      end
-
-      # Parse should create a new key object from the 'to_param' format
-      #
-      # @abstract
-      # @param  [String] string the result of calling key.to_param
-      # @return [DatastaxRails::Identity::Key] the parsed key
-      #
-      def parse(string)
-        raise NotImplementedError, "#{self.class.name}#parse isn't implemented."
-      end
-    end
-  end
-end
-

data/lib/datastax_rails/identity/custom_key_factory.rb

@@ -1,37 +0,0 @@
-module DatastaxRails
-  module Identity
-    class CustomKeyFactory < AbstractKeyFactory
-      class CustomKey
-        attr_reader :value
-
-        def initialize(value)
-          @value = value
-        end
-
-        def to_s
-          value
-        end
-
-        def ==(other)
-          other.to_s == value
-        end
-      end
-
-      attr_reader :method
-
-      def initialize(options)
-        @method = options[:method]
-        @key_columns = Array.wrap(options[:column])
-      end
-
-      def next_key(object)
-        CustomKey.new(object.send(@method))
-      end
-
-      def parse(value)
-        value
-      end
-    end
-  end
-end
-

data/lib/datastax_rails/identity/hashed_natural_key_factory.rb

@@ -1,10 +0,0 @@
-require 'digest/sha1'
-module DatastaxRails
-  module Identity
-    class HashedNaturalKeyFactory < NaturalKeyFactory
-      def next_key(object)
-        NaturalKey.new(Digest::SHA1.hexdigest(attributes.map { |a| object.attributes[a.to_s] }.join(separator)))
-      end
-    end
-  end
-end

data/lib/datastax_rails/identity/natural_key_factory.rb

@@ -1,39 +0,0 @@
-module DatastaxRails
-  module Identity
-    class NaturalKeyFactory < AbstractKeyFactory
-      class NaturalKey
-        attr_reader :value
-
-        delegate :size, :bytesize, :to => :value
-        def initialize(value)
-          @value = value
-        end
-
-        def to_s
-          value
-        end
-
-        def ==(other)
-          other.to_s == to_s
-        end
-      end
-
-      attr_reader :attributes, :separator
-
-      def initialize(options)
-        @attributes = [*options[:attributes]]
-        @separator  = options[:separator] || "-"
-        @key_columns = options[:column].blank? ? @attributes.dup : Array.wrap(options[:column])
-      end
-
-      def next_key(object)
-        NaturalKey.new(attributes.map { |a| object.attributes[a.to_s] }.join(separator))
-      end
-
-      def parse(paramized_key)
-        NaturalKey.new(paramized_key)
-      end
-    end
-  end
-end
-

data/lib/datastax_rails/identity/uuid_key_factory.rb

@@ -1,27 +0,0 @@
-module DatastaxRails
-  module Identity
-    # Key factories need to support 3 operations
-    class UUIDKeyFactory < AbstractKeyFactory
-      class UUID < SimpleUUID::UUID
-        def to_s
-          to_guid
-        end
-      end
-      
-      def initialize(options = {})
-        @key_columns = options[:column].blank? ? ['key'] : Array.wrap(options[:column])
-      end
-    
-      def next_key(object)
-        UUID.new
-      end
-      
-      def parse(string)
-        UUID.new(string) if string
-      rescue
-        nil
-      end
-    end
-  end
-end
-

data/lib/datastax_rails/type.rb

@@ -1,16 +0,0 @@
-module DatastaxRails
-  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/datastax_rails/types.rb

@@ -1,9 +0,0 @@
-DatastaxRails::Type.register(:array,          DatastaxRails::Types::ArrayType)
-DatastaxRails::Type.register(:binary,         DatastaxRails::Types::BinaryType)
-DatastaxRails::Type.register(:boolean,        DatastaxRails::Types::BooleanType)
-DatastaxRails::Type.register(:date,           DatastaxRails::Types::DateType)
-DatastaxRails::Type.register(:float,          DatastaxRails::Types::FloatType)
-DatastaxRails::Type.register(:integer,        DatastaxRails::Types::IntegerType)
-DatastaxRails::Type.register(:time,           DatastaxRails::Types::TimeType)
-DatastaxRails::Type.register(:string,         DatastaxRails::Types::StringType)
-DatastaxRails::Type.register(:text,           DatastaxRails::Types::TextType)

data/lib/datastax_rails/types/array_type.rb

@@ -1,86 +0,0 @@
-module DatastaxRails
-  module Types
-    # ArrayType is used for storing arrays in Datastax Enterprise.
-    # They are indexed into SOLR as discrete values so that you can do something like this:
-    #
-    #   Post.where(:tags => 'Technology')
-    #
-    # That would give you all the posts that have Technology somewhere in the tags array. 
-    class ArrayType < BaseType
-      DEFAULTS = {:solr_type => 'array', :indexed => :solr, :stored => true, :multi_valued => false, :sortable => false, :tokenized => true, :fulltext => true, :cassandra_type => 'text'}
-      
-      # An extension to normal arrays that allow for tracking of dirty values.  This is
-      # used by ActiveModel's change tracking framework.
-      class DirtyArray < Array
-        attr_accessor :record, :name, :options
-        def initialize(record, name, array, options)
-          @record   = record
-          @name     = name.to_s
-          @options  = options
-
-          super(array)
-          setify!
-        end
-
-        def <<(obj)
-          modifying do
-            super
-            setify!
-          end
-        end
-
-        def delete(obj)
-          modifying do
-            super
-          end
-        end
-
-        private
-          def setify!
-            if options[:unique]
-              compact!
-              uniq!
-              begin sort! rescue ArgumentError end
-            end
-          end
-
-          def modifying
-            unless record.changed_attributes.include?(name)
-              original = dup
-            end
-
-            result = yield
-
-            if !record.changed_attributes.key?(name) && original != self
-              record.changed_attributes[name] = original
-            end
-
-            record.send("#{name}=", self)
-
-            result
-          end
-      end
-
-      def default
-        []
-      end
-
-      def encode(array)
-        raise ArgumentError.new("#{self} requires an Array") unless array.kind_of?(Array)
-        ar = Array(array)
-        ar.uniq! if options[:unique]
-        ar.join("$$$$")
-      end
-
-      def decode(str)
-        return [] if str.blank?
-        #                                         Temporary fix
-        str.is_a?(Array) ? str.flatten : str.gsub(/&&&&/,'$$$$').split(/\$\$\$\$/).reject{|a|a.blank?} 
-      end
-
-      def wrap(record, name, value)
-        DirtyArray.new(record, name, value, options)
-      end
-    end
-  end
-end

data/lib/datastax_rails/types/base_type.rb

@@ -1,42 +0,0 @@
-module DatastaxRails
-  module Types
-    # All of the DSR type classes inherit from here.  It sets up some default options and doesn basic conversion
-    # to strings.  Subclasses can override these methods as needed.
-    #
-    # NOTE: All subclasses MUST declare a +DEFAULTS+ constant that specifies the indexing defaults.  Defaults may of
-    # course be overridden when the attribute is declared.
-    class BaseType
-      attr_accessor :options
-      # Default initializer.  Sets the indexing options based on the DEFAULTS
-      def initialize(options = {})
-        @options = self.class::DEFAULTS.merge(options)
-      end
-
-      def default
-        if options.has_key?(:default)
-          options[:default].duplicable? ? options[:default].dup : options[:default]
-        end
-      end
-      
-      def encode(value, format = :solr)
-        value.to_s
-      end
-
-      def decode(str)
-        str
-      end
-
-      def wrap(record, name, value)
-        value
-      end
-      
-      def type
-        self.class.name.sub(/^DatastaxRails::Types::/,'').sub(/Type$/,'').underscore.to_sym
-      end
-      
-      def full_solr_range
-        '[\"\" TO *]'
-      end
-    end
-  end
-end

data/lib/datastax_rails/types/binary_type.rb

@@ -1,19 +0,0 @@
-module DatastaxRails
-  module Types
-    class BinaryType < BaseType
-      DEFAULTS = {:solr_type => false, :indexed => false, :stored => false, :multi_valued => false, :sortable => false, :tokenized => false, :fulltext => false, :cassandra_type => 'blob'}
-      def encode(str)
-        raise ArgumentError.new("#{self} requires a String") unless str.kind_of?(String)
-        Base64.encode64(str)
-      end
-      
-      def decode(str)
-        Base64.decode64(str)
-      end
-
-      def wrap(record, name, value)
-        (value.frozen? ? value.dup : value)
-      end
-    end
-  end
-end

data/lib/datastax_rails/types/boolean_type.rb

@@ -1,22 +0,0 @@
-module DatastaxRails
-  module Types
-    class BooleanType < BaseType
-      DEFAULTS = {:solr_type => 'boolean', :indexed => :solr, :stored => true, :multi_valued => false, :sortable => true, :tokenized => false, :fulltext => false, :cassandra_type => 'boolean'}
-      TRUE_VALS = [true, 'true', '1', 'Y']
-      FALSE_VALS = [false, 'false', '0', '', 'N', nil, 'null']
-      VALID_VALS = TRUE_VALS + FALSE_VALS
-      
-      def encode(bool)
-        unless VALID_VALS.include?(bool)
-          raise ArgumentError.new("#{self} requires a boolean")
-        end
-        TRUE_VALS.include?(bool) ? '1' : '0'
-      end
-
-      def decode(str)
-        raise ArgumentError.new("Cannot convert #{str} into a boolean") unless VALID_VALS.include?(str)
-        TRUE_VALS.include?(str)
-      end
-    end
-  end
-end

data/lib/datastax_rails/types/date_type.rb

@@ -1,23 +0,0 @@
-module DatastaxRails
-  module Types
-    class DateType < BaseType
-      DEFAULTS = {:solr_type => 'date', :indexed => :solr, :stored => true, :multi_valued => false, :sortable => true, :tokenized => false, :fulltext => false, :cassandra_type => 'timestamp'}
-      FORMAT = '%Y-%m-%dT%H:%M:%SZ'
-
-      def encode(value)
-        return unless value
-        raise ArgumentError.new("#{self} requires a Date") unless value.kind_of?(Date) || value.kind_of?(Time)
-        value.to_date.strftime(FORMAT)
-      end
-
-      def decode(str)
-        return str if str.kind_of?(Date)
-        Date.parse(str) rescue nil
-      end
-      
-      def full_solr_range
-        '[* TO *]'
-      end
-    end
-  end
-end