datastax_rails 1.0.5

data/lib/datastax_rails/schema/migrator.rb

@@ -0,0 +1,212 @@
+module DatastaxRails
+  module Schema
+
+    class Migrator
+
+      def self.migrate(migrations_path, target_version = nil)
+        case
+        when target_version.nil?
+          up(migrations_path, target_version)
+        when current_version == 0 && target_version == 0
+        when current_version > target_version
+          down(migrations_path, target_version)
+        else
+          up(migrations_path, target_version)
+        end
+      end
+
+      def self.rollback(migrations_path, steps = 1)
+        move(:down, migrations_path, steps)
+      end
+
+      def self.forward(migrations_path, steps = 1)
+        move(:up, migrations_path, steps)
+      end
+
+      def self.up(migrations_path, target_version = nil)
+        new(:up, migrations_path, target_version).migrate
+      end
+
+      def self.down(migrations_path, target_version = nil)
+        new(:down, migrations_path, target_version).migrate
+      end
+
+      def self.run(direction, migrations_path, target_version)
+        new(direction, migrations_path, target_version).run
+      end
+
+      def self.migrations_path
+        'ks/migrate'
+      end
+
+      def self.schema_migrations_column_family
+        :schema_migrations
+      end
+
+      def self.column_family_tasks
+        cas = DatastaxRails::Base.connection
+        Tasks::ColumnFamily.new(cas.keyspace)
+      end
+
+      def self.get_all_versions
+        cas = DatastaxRails::Base.connection
+        cas.get(schema_migrations_column_family, 'all').map {|(name, _value)| name.to_i}.sort
+      end
+
+      def self.current_version
+        sm_cf = schema_migrations_column_family
+        if column_family_tasks.exists?(sm_cf)
+          get_all_versions.max || 0
+        else
+          0
+        end
+      end
+
+      private
+
+      def self.move(direction, migrations_path, steps)
+        migrator = self.new(direction, migrations_path)
+        start_index = migrator.migrations.index(migrator.current_migration)
+
+        if start_index
+          finish = migrator.migrations[start_index + steps]
+          version = finish ? finish.version : 0
+          send(direction, migrations_path, version)
+        end
+      end
+
+      public
+
+      def initialize(direction, migrations_path, target_version = nil)
+        sm_cf = self.class.schema_migrations_column_family
+
+        unless column_family_tasks.exists?(sm_cf)
+          column_family_tasks.create(sm_cf) do |cf|
+            cf.comparator_type = 'LongType'
+          end
+        end
+
+        @direction, @migrations_path, @target_version = direction, migrations_path, target_version
+      end
+
+      def current_version
+        migrated.last || 0
+      end
+
+      def current_migration
+        migrations.detect { |m| m.version == current_version }
+      end
+
+      def run
+        target = migrations.detect { |m| m.version == @target_version }
+        raise UnknownMigrationVersionError.new(@target_version) if target.nil?
+        unless (up? && migrated.include?(target.version.to_i)) || (down? && !migrated.include?(target.version.to_i))
+          target.migrate(@direction)
+          record_version_state_after_migrating(target)
+        end
+      end
+
+      def migrate
+        current = migrations.detect { |m| m.version == current_version }
+        target = migrations.detect { |m| m.version == @target_version }
+
+        if target.nil? && !@target_version.nil? && @target_version > 0
+          raise UnknownMigrationVersionError.new(@target_version)
+        end
+
+        start = up? ? 0 : (migrations.index(current) || 0)
+        finish = migrations.index(target) || migrations.size - 1
+        runnable = migrations[start..finish]
+
+        # skip the last migration if we're headed down, but not ALL the way down
+        runnable.pop if down? && !target.nil?
+
+        runnable.each do |migration|
+          #puts "Migrating to #{migration.name} (#{migration.version})"
+
+          # On our way up, we skip migrating the ones we've already migrated
+          next if up? && migrated.include?(migration.version.to_i)
+
+          # On our way down, we skip reverting the ones we've never migrated
+          if down? && !migrated.include?(migration.version.to_i)
+            migration.announce 'never migrated, skipping'; migration.write
+            next
+          end
+
+          migration.migrate(@direction)
+          record_version_state_after_migrating(migration)
+        end
+      end
+
+      def migrations
+        @migrations ||= begin
+                          files = Dir["#{@migrations_path}/[0-9]*_*.rb"]
+
+                          migrations = files.inject([]) do |klasses, file|
+                            version, name = file.scan(/([0-9]+)_([_a-z0-9]*).rb/).first
+
+                            raise IllegalMigrationNameError.new(file) unless version
+                            version = version.to_i
+
+                            if klasses.detect { |m| m.version == version }
+                              raise DuplicateMigrationVersionError.new(version)
+                            end
+
+                            if klasses.detect { |m| m.name == name.camelize }
+                              raise DuplicateMigrationNameError.new(name.camelize)
+                            end
+
+                            migration = MigrationProxy.new
+                            migration.name     = name.camelize
+                            migration.version  = version
+                            migration.filename = file
+                            klasses << migration
+                          end
+
+                          migrations = migrations.sort_by { |m| m.version }
+                          down? ? migrations.reverse : migrations
+                        end
+      end
+
+      def pending_migrations
+        already_migrated = migrated
+        migrations.reject { |m| already_migrated.include?(m.version.to_i) }
+      end
+
+      def migrated
+        @migrated_versions ||= self.class.get_all_versions
+      end
+
+      private
+
+      def column_family_tasks
+        Tasks::ColumnFamily.new(connection.keyspace)
+      end
+
+      def connection
+        DatastaxRails::Base.connection
+      end
+
+      def record_version_state_after_migrating(migration)
+        sm_cf = self.class.schema_migrations_column_family
+
+        @migrated_versions ||= []
+        if down?
+          @migrated_versions.delete(migration.version)
+          connection.remove sm_cf, 'all', migration.version
+        else
+          @migrated_versions.push(migration.version).sort!
+          connection.insert sm_cf, 'all', { migration.version => migration.name }
+        end
+      end
+
+      def up?
+        @direction == :up
+      end
+
+      def down?
+        @direction == :down
+      end
+    end
+  end
+end

data/lib/datastax_rails/schema.rb

@@ -0,0 +1,37 @@
+module DatastaxRails
+  module Schema
+    extend ActiveSupport::Autoload
+
+    class IrreversibleMigration < StandardError
+    end
+
+    class DuplicateMigrationVersionError < StandardError#:nodoc:
+      def initialize(version)
+        super("Multiple migrations have the version number #{version}")
+      end
+    end
+
+    class DuplicateMigrationNameError < StandardError#:nodoc:
+      def initialize(name)
+        super("Multiple migrations have the name #{name}")
+      end
+    end
+
+    class UnknownMigrationVersionError < StandardError #:nodoc:
+      def initialize(version)
+        super("No migration with version number #{version}")
+      end
+    end
+
+    class IllegalMigrationNameError < StandardError#:nodoc:
+      def initialize(name)
+        super("Illegal name for migration file: #{name}\n\t(only lower case letters, numbers, and '_' allowed)")
+      end
+    end
+
+    autoload :Migrator
+    autoload :Migration
+    autoload :MigrationProxy
+
+  end
+end

data/lib/datastax_rails/scoping.rb

@@ -0,0 +1,394 @@
+module DatastaxRails
+  module Scoping
+    extend ActiveSupport::Concern
+    
+    module ClassMethods
+      def scoped(options = nil)
+        if options
+          scoped.apply_finder_options(options)
+        else
+          if current_scope
+            current_scope.clone
+          else
+            relation.clone.tap do |scope|
+              scope.default_scoped = true
+            end
+          end
+        end
+      end
+      
+      # Adds a class method for retrieving and querying objects. A \scope represents a narrowing of a SOLR query,
+      # such as <tt>where(:color => :red).order(:size)</tt>.
+      #
+      #   class Shirt < DatastaxRails::Base
+      #     scope :red, where(:color => 'red')
+      #     scope :dry_clean_only, where(:dry_clean => true)
+      #   end
+      #
+      # The above calls to <tt>scope</tt> define class methods Shirt.red and Shirt.dry_clean_only. Shirt.red,
+      # in effect, represents the query <tt>Shirt.where(:color => 'red')</tt>.
+      #
+      # Note that this is simply 'syntactic sugar' for defining an actual class method:
+      #
+      #   class Shirt < ActiveRecord::Base
+      #     def self.red
+      #       where(:color => 'red')
+      #     end
+      #   end
+      #
+      # Unlike <tt>Shirt.find(...)</tt>, however, the object returned by Shirt.red is not an Array; it
+      # resembles the association object constructed by a <tt>has_many</tt> declaration. For instance,
+      # you can invoke <tt>Shirt.red.first</tt>, <tt>Shirt.red.count</tt>, <tt>Shirt.red.where(:size => 'small')</tt>.
+      # Also, just as with the association objects, named \scopes act like an Array, implementing Enumerable;
+      # <tt>Shirt.red.each(&block)</tt>, <tt>Shirt.red.first</tt>, and <tt>Shirt.red.inject(memo, &block)</tt>
+      # all behave as if Shirt.red really was an Array.
+      #
+      # These named \scopes are composable. For instance, <tt>Shirt.red.dry_clean_only</tt> will produce
+      # all shirts that are both red and dry clean only.
+      # Nested finds and calculations also work with these compositions: <tt>Shirt.red.dry_clean_only.count</tt>
+      # returns the number of garments for which these criteria obtain. Similarly with
+      # <tt>Shirt.red.dry_clean_only.average(:thread_count)</tt>.
+      #
+      # All \scopes are available as class methods on the DatastaxRails::Base descendant upon which
+      # the \scopes were defined. But they are also available to <tt>has_many</tt> associations. If,
+      #
+      #   class Person < DatastaxRails::Base
+      #     has_many :shirts
+      #   end
+      #
+      # then <tt>elton.shirts.red.dry_clean_only</tt> will return all of Elton's red, dry clean
+      # only shirts.
+      #
+      # Named \scopes can also be procedural:
+      #
+      #   class Shirt < DatastaxRails::Base
+      #     scope :colored, lambda { |color| where(:color => color) }
+      #   end
+      #
+      # In this example, <tt>Shirt.colored('puce')</tt> finds all puce shirts.
+      #
+      # Note that scopes defined with \scope will be evaluated when they are defined, rather than
+      # when they are used. For example, the following would be incorrect:
+      #
+      #   class Post < DatastaxRails::Base
+      #     scope :recent, where('published_at >= ?', Time.current - 1.week)
+      #   end
+      #
+      # The example above would be 'frozen' to the <tt>Time.current</tt> value when the <tt>Post</tt>
+      # class was defined, and so the resultant SOLR query would always be the same. The correct
+      # way to do this would be via a lambda, which will re-evaluate the scope each time
+      # it is called:
+      #
+      #   class Post < DatastaxRails::Base
+      #     scope :recent, lambda { where('published_at >= ?', Time.current - 1.week) }
+      #   end
+      #
+      # Named \scopes can also have extensions, just as with <tt>has_many</tt> declarations:
+      #
+      #   class Shirt < DatastaxRails::Base
+      #     scope :red, where(:color => 'red') do
+      #       def dom_id
+      #         'red_shirts'
+      #       end
+      #     end
+      #   end
+      #
+      # Scopes can also be used while creating/building a record.
+      #
+      #   class Article < DatastaxRails::Base
+      #     scope :published, where(:published => true)
+      #   end
+      #
+      #   Article.published.new.published # => true
+      #   Article.published.create.published # => true
+      #
+      # Class methods on your model are automatically available
+      # on scopes. Assuming the following setup:
+      #
+      #   class Article < DatastaxRails::Base
+      #     scope :published, where(:published => true)
+      #     scope :featured, where(:featured => true)
+      #
+      #     def self.latest_article
+      #       order('published_at desc').first
+      #     end
+      #
+      #     def self.titles
+      #       map(&:title)
+      #     end
+      #   end
+      #
+      # We are able to call the methods like this:
+      #
+      #   Article.published.featured.latest_article
+      #   Article.featured.titles
+      def scope(name, scope_options = {})
+        name = name.to_sym
+        valid_scope_name?(name)
+        extension = Module.new(&Proc.new) if block_given?
+
+        scope_proc = lambda do |*args|
+          options = scope_options.respond_to?(:call) ? scope_options.call(*args) : scope_options
+          options = scoped.apply_finder_options(options) if options.is_a?(Hash)
+
+          relation = scoped.merge(options)
+
+          extension ? relation.extending(extension) : relation
+        end
+
+        singleton_class.send(:redefine_method, name, &scope_proc)
+      end
+      
+      # Returns a scope for this class without taking into account the default_scope.
+        #
+        #   class Post < DatastaxRails::Base
+        #     def self.default_scope
+        #       where :published => true
+        #     end
+        #   end
+        #
+        #   Post.all # Finds posts where +published+ is +true+
+        #   Post.unscoped.all # Finds all posts regardless of +published+'s truthiness
+        #
+        # This method also accepts a block meaning that all queries inside the block will
+        # not use the default_scope:
+        #
+        #   Post.unscoped {
+        #     Post.limit(10) # Finds the first 10 posts
+        #   }
+        #
+        # It is recommended to use block form of unscoped because chaining unscoped with <tt>scope</tt>
+        # does not work. Assuming that <tt>published</tt> is a <tt>scope</tt> following two statements are same.
+        #
+        #   Post.unscoped.published
+        #   Post.published
+        def unscoped #:nodoc:
+          block_given? ? relation.scoping { yield } : relation
+        end
+        
+        def before_remove_const #:nodoc:
+          self.current_scope = nil
+        end
+        
+        # with_scope lets you apply options to inner block incrementally. It takes a hash and the keys must be
+        # <tt>:find</tt> or <tt>:create</tt>. <tt>:find</tt> parameter is <tt>Relation</tt> while
+        # <tt>:create</tt> parameters are an attributes hash.
+        #
+        #   class Article < DatastaxRails::Base
+        #     def self.create_with_scope
+        #       with_scope(:find => where(:blog_id => 1), :create => { :blog_id => 1 }) do
+        #         find(1) # => WHERE blog_id = 1 AND id = 1
+        #         a = create(1)
+        #         a.blog_id # => 1
+        #       end
+        #     end
+        #   end
+        #
+        # In nested scopings, all previous parameters are overwritten by the innermost rule, with the exception of
+        # <tt>where</tt> which is merged.
+        #
+        # You can ignore any previous scopings by using the <tt>with_exclusive_scope</tt> method.
+        #
+        #   class Article < DatastaxRails::Base
+        #     def self.find_with_exclusive_scope
+        #       with_scope(:find => where(:blog_id => 1).limit(1)) do
+        #         with_exclusive_scope(:find => limit(10)) do
+        #           all # => SELECT * from articles LIMIT 10
+        #         end
+        #       end
+        #     end
+        #   end
+        #
+        # *Note*: the +:find+ scope also has effect on update and deletion methods, like +update_all+ and +delete_all+.
+        def with_scope(scope = {}, action = :merge, &block)
+          # If another DatastaxRails class has been passed in, get its current scope
+          scope = scope.current_scope if !scope.is_a?(Relation) && scope.respond_to?(:current_scope)
+
+          previous_scope = self.current_scope
+
+          if scope.is_a?(Hash)
+            # Dup first and second level of hash (method and params).
+            scope = scope.dup
+            scope.each do |method, params|
+              scope[method] = params.dup unless params == true
+            end
+
+            scope.assert_valid_keys([ :find, :create ])
+            relation = construct_finder_relation(scope[:find] || {})
+            relation.default_scoped = true unless action == :overwrite
+
+            if previous_scope && previous_scope.create_with_value && scope[:create]
+              scope_for_create = if action == :merge
+                previous_scope.create_with_value.merge(scope[:create])
+              else
+                scope[:create]
+              end
+
+              relation = relation.create_with(scope_for_create)
+            else
+              scope_for_create = scope[:create]
+              scope_for_create ||= previous_scope.create_with_value if previous_scope
+              relation = relation.create_with(scope_for_create) if scope_for_create
+            end
+
+            scope = relation
+          end
+
+          scope = previous_scope.merge(scope) if previous_scope && action == :merge
+
+          self.current_scope = scope
+          begin
+            yield
+          ensure
+            self.current_scope = previous_scope
+          end
+        end
+        
+        # Works like with_scope, but discards any nested properties.
+        def with_exclusive_scope(method_scoping = {}, &block)
+          if method_scoping.values.any? { |e| e.is_a?(DatastaxRails::Relation) }
+            raise ArgumentError, <<-MSG
+New finder API can not be used with_exclusive_scope. You can either call unscoped to get an anonymous scope not bound to the default_scope:
+
+User.unscoped.where(:active => true)
+
+Or call unscoped with a block:
+
+User.unscoped do
+User.where(:active => true).all
+end
+
+MSG
+          end
+          with_scope(method_scoping, :overwrite, &block)
+        end
+        
+        # Use this macro in your model to set a default scope for all operations on
+        # the model.
+        #
+        #   class Article < DatastaxRails::Base
+        #     default_scope where(:published => true)
+        #   end
+        #
+        #   Article.all # => all articles where published = true
+        #
+        # The <tt>default_scope</tt> is also applied while creating/building a record. It is not
+        # applied while updating a record.
+        #
+        #   Article.new.published # => true
+        #   Article.create.published # => true
+        #
+        # You can also use <tt>default_scope</tt> with a block, in order to have it lazily evaluated:
+        #
+        #   class Article < DatastaxRails::Base
+        #     default_scope { where(:published_at => Time.now - 1.week) }
+        #   end
+        #
+        # (You can also pass any object which responds to <tt>call</tt> to the <tt>default_scope</tt>
+        # macro, and it will be called when building the default scope.)
+        #
+        # If you use multiple <tt>default_scope</tt> declarations in your model then they will
+        # be merged together:
+        #
+        #   class Article < DatastaxRails::Base
+        #     default_scope where(:published => true)
+        #     default_scope where(:rating => 'G')
+        #   end
+        #
+        # Article.all # => all articles where published = true AND rating = 'G'
+        #
+        # This is also the case with inheritance and module includes where the parent or module
+        # defines a <tt>default_scope</tt> and the child or including class defines a second one.
+        #
+        # If you need to do more complex things with a default scope, you can alternatively
+        # define it as a class method:
+        #
+        #   class Article < DatastaxRails::Base
+        #     def self.default_scope
+        #       # Should return a scope, you can call 'super' here etc.
+        #     end
+        #   end
+        def default_scope(scope = {})
+          scope = Proc.new if block_given?
+          self.default_scopes = default_scopes + [scope]
+        end
+
+        def build_default_scope #:nodoc:
+          if method(:default_scope).owner != Base.singleton_class
+            evaluate_default_scope { default_scope }
+          elsif default_scopes.any?
+            evaluate_default_scope do
+              default_scopes.inject(relation) do |default_scope, scope|
+                if scope.is_a?(Hash)
+                  default_scope.apply_finder_options(scope)
+                elsif !scope.is_a?(Relation) && scope.respond_to?(:call)
+                  default_scope.merge(scope.call)
+                else
+                  default_scope.merge(scope)
+                end
+              end
+            end
+          end
+        end
+
+        def ignore_default_scope? #:nodoc:
+          Thread.current["#{self}_ignore_default_scope"]
+        end
+
+        def ignore_default_scope=(ignore) #:nodoc:
+          Thread.current["#{self}_ignore_default_scope"] = ignore
+        end
+
+        # The ignore_default_scope flag is used to prevent an infinite recursion situation where
+        # a default scope references a scope which has a default scope which references a scope...
+        def evaluate_default_scope
+          return if ignore_default_scope?
+
+          begin
+            self.ignore_default_scope = true
+            yield
+          ensure
+            self.ignore_default_scope = false
+          end
+        end
+      
+      # Collects attributes from scopes that should be applied when creating
+      # an SO instance for the particular class this is called on.
+      def scope_attributes # :nodoc:
+        if current_scope
+          current_scope.scope_for_create
+        else
+          relation.clone.tap do |scope|
+            scope.default_scoped = true
+          end
+        end
+      end
+
+      # Are there default attributes associated with this scope?
+      def scope_attributes? # :nodoc:
+        current_scope || default_scopes.any?
+      end
+      
+      protected
+      
+        def current_scope #:nodoc:
+          Thread.current["#{self}_current_scope"]
+        end
+  
+        def current_scope=(scope) #:nodoc:
+          Thread.current["#{self}_current_scope"] = scope
+        end
+      
+        def apply_default_scope
+          
+        end
+      
+        def valid_scope_name?(name)
+          if respond_to?(name, true)
+            logger.warn "Creating scope :#{name}. " \
+                        "Overwriting existing method #{self.name}.#{name}."
+          end
+        end
+    end
+  end
+end

data/lib/datastax_rails/serialization.rb

@@ -0,0 +1,6 @@
+module DatastaxRails
+  module Serialization
+    extend ActiveSupport::Concern
+    include ActiveModel::Serializers::JSON
+  end
+end