datastax_rails 1.0.5

data/lib/datastax_rails/validations/uniqueness.rb

@@ -0,0 +1,119 @@
+require 'active_support/core_ext/array/wrap'
+
+module DatastaxRails
+  module Validations
+    class UniquenessValidator < ActiveModel::EachValidator
+      def initialize(options)
+        super
+      end
+      
+      def setup(klass)
+        @klass = klass
+      end
+      
+      def validate_each(record, attribute, value)
+        return true if options[:allow_blank] && value.blank?
+        # XXX: The following will break if/when abstract base classes
+        #      are implemented in datastax_rails (such as STI)
+        finder_class = record.class
+        
+        scope = finder_class.unscoped.where(attribute => value)
+        scope = scope.where_not(:id => record.id) if record.persisted?
+        
+        Array.wrap(options[:scope]).each do |scope_item|
+          scope_value = record.send(scope_item)
+          scope_value = nil if scope_value.blank?
+          scope = scope.where(scope_item => scope_value)
+        end
+
+        if scope.exists?
+          message = options[:message] || 'has already been taken'
+          record.errors.add(attribute, message, options.except(:case_sensitive, :scope).merge(:value => value))
+        end
+      end
+    end
+    
+    module ClassMethods
+      # Validates whether the value of the specified attributes are unique across the system.
+      # Useful for making sure that only one user can be named "davidhh".
+      #
+      #   class Person < DatastaxRails::Base
+      #     validates_uniqueness_of :user_name
+      #   end
+      #
+      # It can also validate whether the value of the specified attributes are unique based on a scope parameter:
+      #
+      #   class Person < DatastaxRails::Base
+      #     validates_uniqueness_of :user_name, :scope => :account_id
+      #   end
+      #
+      # Or even multiple scope parameters. For example, making sure that a teacher can only be on the schedule once
+      # per semester for a particular class.
+      #
+      #   class TeacherSchedule < DatastaxRails::Base
+      #     validates_uniqueness_of :teacher_id, :scope => [:semester_id, :class_id]
+      #   end
+      #
+      # When the record is created, a check is performed to make sure that no record exists in the database
+      # with the given value for the specified attribute (that maps to a column). When the record is updated,
+      # the same check is made but disregarding the record itself.
+      #
+      # Configuration options:
+      # * <tt>:message</tt> - Specifies a custom error message (default is: "has already been taken").
+      # * <tt>:scope</tt> - One or more columns by which to limit the scope of the uniqueness constraint.
+      # * <tt>:allow_nil</tt> - If set to true, skips this validation if the attribute is +nil+ (default is +false+).
+      # * <tt>:allow_blank</tt> - If set to true, skips this validation if the attribute is blank (default is +false+).
+      # * <tt>:if</tt> - Specifies a method, proc or string to call to determine if the validation should
+      #   occur (e.g. <tt>:if => :allow_validation</tt>, or <tt>:if => Proc.new { |user| user.signup_step > 2 }</tt>).
+      #   The method, proc or string should return or evaluate to a true or false value.
+      # * <tt>:unless</tt> - Specifies a method, proc or string to call to determine if the validation should
+      #   not occur (e.g. <tt>:unless => :skip_validation</tt>, or
+      #   <tt>:unless => Proc.new { |user| user.signup_step <= 2 }</tt>). The method, proc or string should
+      #   return or evaluate to a true or false value.
+      #
+      # === Concurrency and integrity
+      #
+      # Using this validation method in conjunction with DatastaxRails::Base#save
+      # does not guarantee the absence of duplicate record insertions, because
+      # uniqueness checks on the application level are inherently prone to race
+      # conditions. For example, suppose that two users try to post a Comment at
+      # the same time, and a Comment's title must be unique. At the database-level,
+      # the actions performed by these users could be interleaved in the following manner:
+      #
+      #               User 1                |                User 2
+      # ------------------------------------+--------------------------------------
+      # # User 1 checks whether there's     |
+      # # already a comment with the title  |
+      # # 'My Post'. This is not the case.  |
+      # SELECT * FROM comments              |
+      # WHERE title = 'My Post'             |
+      #                                     |
+      #                                     | # User 2 does the same thing and also
+      #                                     | # infers that his title is unique.
+      #                                     | SELECT * FROM comments
+      #                                     | WHERE title = 'My Post'
+      #                                     |
+      # # User 1 inserts his comment.       |
+      # INSERT INTO comments                |
+      # (title, content) VALUES             |
+      # ('My Post', 'hi!')                  |
+      #                                     |
+      #                                     | # User 2 does the same thing.
+      #                                     | INSERT INTO comments
+      #                                     | (title, content) VALUES
+      #                                     | ('My Post', 'hello!')
+      #                                     |
+      #                                     | # ^^^^^^
+      #                                     | # Boom! We now have a duplicate
+      #                                     | # title!
+      #
+      # It is left as an exercise of the developer to figure out how to solve
+      # this problem at the application level because there is no way to do
+      # so generically since Cassandra doesn't support UNIQUE indexes.
+      #
+      def validates_uniqueness_of(*attr_names)
+        validates_with UniquenessValidator, _merge_attributes(attr_names)
+      end
+    end
+  end
+end

data/lib/datastax_rails/validations.rb

@@ -0,0 +1,48 @@
+module DatastaxRails
+  class RecordInvalid < StandardError
+    attr_reader :record
+    def initialize(record)
+      @record = record
+      super("Invalid record: #{@record.errors.full_messages.to_sentence}")
+    end
+  end
+  
+  module Validations
+    extend ActiveSupport::Concern
+    include ActiveModel::Validations
+    
+    included do
+      define_model_callbacks :validation
+      define_callbacks :validate, :scope => :name
+    end
+    
+    module ClassMethods
+      def create!(attributes = {})
+        new(attributes).tap do |object|
+          object.save!
+        end
+      end
+    end
+
+    def valid?
+      run_callbacks :validation do
+        super
+      end
+    end
+
+    def save(options={})
+      perform_validations(options) ?  super : false
+    end
+    
+    def save!
+      save || raise(RecordInvalid.new(self))
+    end
+
+    protected
+      def perform_validations(options={})
+        (options[:validate] != false) ? valid? : true
+      end
+  end
+end
+
+require 'datastax_rails/validations/uniqueness'

data/lib/datastax_rails/version.rb

@@ -0,0 +1,3 @@
+module DatastaxRails
+  VERSION = "1.0.5"
+end

data/lib/datastax_rails.rb

@@ -0,0 +1,87 @@
+require 'active_support/all'
+require 'cassandra-cql/1.0'
+
+module DatastaxRails
+  extend ActiveSupport::Autoload
+  
+  autoload :Associations
+  autoload :AttributeMethods
+  autoload :Base
+  autoload :Batches
+  autoload :Callbacks
+  autoload :Collection
+  autoload :Connection
+  autoload :Consistency
+  autoload :Cql
+  autoload :Cursor
+  autoload :Identity
+  autoload :Migrations
+  #autoload :Mocking
+  autoload :Persistence
+  autoload :Reflection
+  autoload :Relation
+  
+  autoload_under 'relation' do
+    autoload :FinderMethods
+    autoload :ModificationMethods
+    autoload :SearchMethods
+    autoload :SpawnMethods
+  end
+  
+  autoload :Schema
+  autoload :Scoping
+  autoload :Serialization
+  autoload :Timestamps
+  autoload :Type
+  autoload :Validations
+  
+  module AttributeMethods
+    extend ActiveSupport::Autoload
+
+    eager_autoload do
+      autoload :Definition
+      autoload :Dirty
+      autoload :Typecasting
+    end
+  end
+
+  module Tasks
+    extend ActiveSupport::Autoload
+    autoload :Keyspace
+    autoload :ColumnFamily
+  end
+
+  module Types
+    extend ActiveSupport::Autoload
+    
+    autoload :BaseType
+    autoload :BinaryType
+    autoload :ArrayType
+    autoload :BooleanType
+    autoload :DateType
+    autoload :FloatType
+    autoload :IntegerType
+    autoload :JsonType
+    autoload :StringType
+    autoload :TextType
+    autoload :TimeType
+    autoload :TimeWithZoneType
+  end
+end
+
+# Fixup the thrift library
+require "thrift"
+module Thrift
+  class BinaryProtocol
+    def write_string(str)
+      write_i32(str.bytesize)
+      trans.write(str)
+    end
+  end
+end
+
+require 'datastax_rails/railtie' if defined?(Rails)
+require 'datastax_rails/errors'
+# require 'solr_no_escape'
+
+ActiveSupport.run_load_hooks(:datastax_rails, DatastaxRails::Base)

data/lib/solr_no_escape.rb

@@ -0,0 +1,28 @@
+require 'sunspot'
+module SolrNoEscape
+  def escape(str)
+    # We are purposely not escaping since we want people to be able to do
+    # advanced queries that otherwise wouldn't work.  Spaces are a special
+    # case due to later URL escaping.
+    str.gsub(/ /,"\\\\ ")
+  end
+end
+
+module Sunspot
+  module Query
+    class FunctionQuery
+      include SolrNoEscape
+    end
+  end
+end
+
+module Sunspot
+  module Query
+    module Restriction
+      class Base
+        include SolrNoEscape
+      end
+    end
+  end
+end
+

data/spec/datastax_rails/associations/belongs_to_association_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+describe DatastaxRails::Base do
+  describe "BelongsTo Association" do
+    
+  end
+end

data/spec/datastax_rails/associations/has_many_association_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe DatastaxRails::Base do
+  describe "HasMany Associations" do
+    it "should destroy all objects with :dependent => :destroy" do
+      p = Person.create(:name => "jason")
+      Car.create(:name => "Jeep", :person_id => p.id)
+      Car.commit_solr
+      p.destroy
+      Car.commit_solr
+      Person.commit_solr
+      Car.count.should == 0
+    end
+    
+    it "should retrieve child records" do
+      p = Person.create(:name => 'jason')
+      c = Car.create(:name => 'Jeep', :person_id => p.id)
+      Car.commit_solr
+      p.cars.should include(c)
+    end
+    
+    it "should retrieve only child records" do
+      p = Person.create(:name => 'jason')
+      c = Car.create(:name => 'Jeep', :person_id => '12345')
+      Car.commit_solr
+      p.cars.should_not include(c)
+    end
+    
+    it "should create records with the proper foreign key" do
+      p = Person.create(:name => 'jason')
+      p.cars.create(:name => 'Jeep')
+      Car.commit_solr
+      Person.commit_solr
+      Car.first.person.should == p
+    end
+  end
+end

data/spec/datastax_rails/associations_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe DatastaxRails::Base do
+  describe "Relations" do
+    describe "belongs_to" do
+      it "should set the id when setting the object" do
+        person = Person.create(:name => "Jason")
+        job = Job.create(:title => "Developer")
+        job.person = person
+        job.person_id.should == person.id
+      end
+      
+      it "should look up the owning model by id" do
+        person = Person.create(:name => "John")
+        job = Job.create(:title => "Developer", :person_id => person.id)
+        Person.commit_solr
+        Job.commit_solr
+        Job.first.person.should == person
+      end
+    end
+  end
+end

data/spec/datastax_rails/attribute_methods_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+class AttributeMethodsTester < DatastaxRails::Base
+  string :test_string
+  string :non_search_string, :searchable => false
+end 
+
+describe DatastaxRails::Base do
+  def tester
+    @tester ||= AttributeMethodsTester.new
+  end
+  
+  describe "attribute methods" do
+    it "should create attribute setter methods" do
+      tester.should respond_to(:test_string=)
+    end
+    
+    it "Should create attribute getter methods" do
+      tester.should respond_to(:test_string)
+    end
+  end
+  
+end

data/spec/datastax_rails/base_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe DatastaxRails::Base do
+  it "should run before_save" do
+    p = Person.new(:name => "Jason")
+    p.save
+    p.nickname.should == "Jason"
+  end
+  
+  it "should run after_save" do
+    p = Person.new(:name => "Jason")
+    p.save!
+    p.instance_variable_get(:@after_save_ran).should == "yup"
+  end
+end

data/spec/datastax_rails/cql/select_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe DatastaxRails::Cql::Select do
+  before(:each) do
+    @model_class = mock("Model Class", :column_family => 'users')
+  end
+  it "should generate valid CQL" do
+    cql = DatastaxRails::Cql::Select.new(@model_class, ["*"])
+    cql.using(DatastaxRails::Cql::Consistency::QUORUM).conditions(:key => '12345').limit(1)
+    cql.to_cql.should == "SELECT * FROM users USING CONSISTENCY QUORUM WHERE key = '12345' LIMIT 1"
+  end
+end

data/spec/datastax_rails/relation/finder_methods_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+
+describe DatastaxRails::Relation do
+  before(:each) do
+    @relation = DatastaxRails::Relation.new(Hobby, "hobbies")
+  end
+  
+  describe "#first" do
+    it "should return the first result if records are already loaded" do
+      a_record = mock_model(Hobby)
+      @relation.stub(:loaded? => true)
+      @relation.instance_variable_set(:@results, [a_record, mock_model(Hobby)])
+      @relation.first.should == a_record
+    end
+    
+    it "should look up the first result if records are not already loaded" do
+      a_record = mock_model(Hobby)
+      @relation.stub(:loaded? => false)
+      mock_relation = mock(DatastaxRails::Relation, :to_a => [a_record])
+      @relation.should_receive(:limit).with(1).and_return(mock_relation)
+      @relation.first.should == a_record
+    end
+  end
+  
+  describe "#first!" do
+    it "should raise RecordNotFound if no record is returned" do
+      lambda { @relation.first! }.should raise_exception(DatastaxRails::RecordNotFound)
+    end
+  end
+  
+  describe "#last" do
+    it "should return the last result if records are already loaded" do
+      a_record = mock_model(Hobby)
+      @relation.stub(:loaded? => true)
+      @relation.instance_variable_set(:@results, [mock_model(Hobby), a_record])
+      @relation.last.should == a_record
+    end
+    
+    it "should look up the last result if records are not already loaded" do
+      a_record = mock_model(Hobby)
+      @relation.stub(:loaded? => false)
+      mock_relation = mock(DatastaxRails::Relation, :to_a => [a_record])
+      @relation.should_receive(:reverse_order).and_return(mock_relation)
+      mock_relation.should_receive(:limit).with(1).and_return(mock_relation)
+      @relation.last.should == a_record
+    end
+  end
+  
+  describe "#last!" do
+    it "should raise RecordNotFound if no record is returned" do
+      lambda { @relation.last! }.should raise_exception(DatastaxRails::RecordNotFound)
+    end
+  end
+end

data/spec/datastax_rails/relation/modification_methods_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe DatastaxRails::Relation do
+  before(:each) do
+    @relation = DatastaxRails::Relation.new(Hobby, "hobbies")
+  end
+  
+  describe "Modification Methods" do
+    describe "#destroy_all" do
+      it "should destroy all matching records" do
+        Hobby.create(:name => "biking", :complexity => 1.0)
+        Hobby.create(:name => "skydiving", :complexity => 4.0)
+        @relation.commit_solr
+        @relation.where(:complexity).greater_than(2.0).destroy_all
+        @relation.commit_solr
+        @relation = DatastaxRails::Relation.new(Hobby, "hobbies")
+        @relation.count.should == 1
+      end
+    end
+    
+    describe "#destroy" do
+      before(:each) do
+        @h1 = Hobby.create(:name => "biking", :complexity => 1.0)
+        @h2 = Hobby.create(:name => "skydiving", :complexity => 4.0)
+        @relation.commit_solr
+      end
+      
+      it "should destroy 1 record by id" do
+        @relation.destroy(@h1.id)
+        @relation.commit_solr
+        @relation.count.should == 1
+      end
+      
+      it "should destroy multiple records by id" do
+        @relation.destroy([@h1.id, @h2.id])
+        @relation.commit_solr
+        @relation.count.should == 0
+      end
+    end
+  end
+end

data/spec/datastax_rails/relation/search_methods_spec.rb

@@ -0,0 +1,117 @@
+require 'spec_helper'
+
+describe DatastaxRails::Relation do
+  before(:each) do
+    @relation = DatastaxRails::Relation.new(Hobby, "hobbies")
+  end
+  
+  describe "#limit" do
+    it "should limit the page size" do
+      "a".upto("l") do |letter|
+        Hobby.create(:name => letter)
+      end
+      Hobby.commit_solr
+      @relation.limit(7).all.size.should == 7
+    end
+  end
+  
+  describe "#page" do
+    it "should get a particular page" do
+      "a".upto("l") do |letter|
+        Hobby.create(:name => letter)
+      end
+      Hobby.commit_solr
+      @relation.per_page(3).page(2).order(:name).all.first.name.should == "d"
+    end
+  end
+  
+  describe "#group" do
+    
+  end
+  
+  describe "#order" do
+    it "should return items in ascending order" do
+      %w[fishing hiking boating jogging swimming chess].each do |word|
+        Hobby.create(:name => word)
+      end
+      @relation.commit_solr
+      @relation.order(:name).collect {|h| h.name}.should == %w[boating chess fishing hiking jogging swimming]
+    end
+    
+    it "should return items in descending order" do
+      %w[fishing hiking boating jogging swimming chess].each do |word|
+        Hobby.create(:name => word)
+      end
+      @relation.commit_solr
+      @relation.order(:name => :desc).collect {|h| h.name}.should == %w[swimming jogging hiking fishing chess boating]
+    end
+  end
+  
+  describe "#where" do
+    it "should return documents where a field is nil (does not exist)" do
+      Hobby.create(:name => 'Swimming')
+      Hobby.create(:name => nil)
+      @relation.commit_solr
+      @relation.where(:name => nil).should_not be_empty
+    end
+    
+    it "should return documents where a value is greater than the given value" do
+      Hobby.create(:name => 'Swimming', :complexity => 1.1)
+      @relation.commit_solr
+      @relation.where(:complexity).greater_than(1.0).should_not be_empty
+    end
+    
+    it "should return documents where a value is less than the given value" do
+      Hobby.create(:name => 'Swimming', :complexity => 1.1)
+      @relation.commit_solr
+      @relation.where(:complexity).less_than(2.0).should_not be_empty
+    end
+    
+    it "should allow arrays to be passed as OR queries" do
+      %w[fishing hiking boating jogging swimming chess].each do |word|
+        Hobby.create(:name => word)
+      end
+      @relation.commit_solr
+      @relation.where(:name => ['boating', 'jogging', 'chess', 'skydiving']).size.should == 3
+    end
+    
+    it "should handle negative numbers without breaking" do
+      Hobby.create(:name => 'jogging', :complexity => -1.2)
+      @relation.commit_solr
+      @relation.where(:complexity).less_than(-1).should_not be_empty
+    end
+    
+    it "should not tokenize where queries on spaces" do
+      Hobby.create(:name => 'horseback riding')
+      @relation.commit_solr
+      @relation.where(:name => 'horseback').should be_empty
+      @relation.where(:name => 'horseback riding').should_not be_empty
+      @relation.where(:name => 'horseback ri*').should_not be_empty
+    end
+    
+    it "should not tokenize where queries on spaces inside arrays" do
+      Hobby.create(:name => 'horseback riding')
+      @relation.commit_solr
+      @relation.where(:name => ['horseback riding', 'some other hobby']).should_not be_empty
+    end
+  end
+  
+  describe "#where_not" do
+    it "should return documents where a field has any value" do
+      Hobby.create(:name => 'Swimming')
+      @relation.commit_solr
+      @relation.where_not(:name => nil).should_not be_empty
+    end
+    
+    it "should return documents where none of the options are present" do
+      Hobby.create(:name => 'Swimming')
+      Hobby.create(:name => 'Biking')
+      @relation.commit_solr
+      @relation.where_not(:name => ['Swimming','Biking']).should be_empty
+    end
+  end
+  
+  describe "#fulltext" do
+    
+  end
+end

data/spec/datastax_rails/relation/spawn_methods_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+describe DatastaxRails::Relation do
+  before(:each) do
+    @relation = DatastaxRails::Relation.new(Hobby, "hobbies")
+  end
+  
+  describe "#merge" do
+    it "should merge two relations" do
+      r1 = @relation.where("name" => "biking")
+      r2 = @relation.order("name" => :desc)
+      r1.merge(r2).should == @relation.where("name" => "biking").order("name" => :desc)
+    end
+    
+    it "should merge where conditions into a single hash" do
+      r1 = @relation.where("name" => "biking")
+      r2 = @relation.where("complexity" => 1.0)
+      r1.merge(r2).where_values.should == [{"name" => "biking", "complexity" => 1.0}]
+    end
+    
+    it "should overwrite conditions on the same attribute" do
+      r1 = @relation.where("name" => "biking")
+      r2 = @relation.where("name" => "swimming")
+      r1.merge(r2).where_values.should == [{"name" => "swimming"}]
+      r2.merge(r1).where_values.should == [{"name" => "biking"}]
+    end
+  end
+end