couchrest 0.35 → 0.36

data/lib/couchrest/more/typecast.rb

@@ -0,0 +1,180 @@
+require 'time'
+require 'bigdecimal'
+require 'bigdecimal/util'
+require File.join(File.dirname(__FILE__), '..', 'more', 'property')
+
+class Time                       
+  # returns a local time value much faster than Time.parse
+  def self.mktime_with_offset(string)
+    string =~ /(\d{4})[\-|\/](\d{2})[\-|\/](\d{2})[T|\s](\d{2}):(\d{2}):(\d{2})([\+|\s|\-])*(\d{2}):?(\d{2})/
+    # $1 = year
+    # $2 = month
+    # $3 = day
+    # $4 = hours
+    # $5 = minutes
+    # $6 = seconds
+    # $7 = time zone direction
+    # $8 = tz difference
+    # utc time with wrong TZ info: 
+    time = mktime($1, RFC2822_MONTH_NAME[$2.to_i - 1], $3, $4, $5, $6, $7)
+    tz_difference = ("#{$7 == '-' ? '+' : '-'}#{$8}".to_i * 3600)
+    time + tz_difference + zone_offset(time.zone) 
+  end 
+end
+
+module CouchRest
+  module More
+    module Typecast
+
+      def typecast_value(value, klass, init_method)
+        return nil if value.nil?
+
+        if value.instance_of?(klass) || klass.to_s == 'Object'
+          value 
+        elsif ['String', 'TrueClass', 'Integer', 'Float', 'BigDecimal', 'DateTime', 'Time', 'Date', 'Class'].include?(klass.to_s)
+          send('typecast_to_'+klass.to_s.downcase, value)
+        else
+          # Allow the init_method to be defined as a Proc for advanced conversion
+          init_method.is_a?(Proc) ? init_method.call(value) : klass.send(init_method, value)
+        end
+      end
+
+      protected
+
+        # Typecast a value to an Integer
+        def typecast_to_integer(value)
+          value.kind_of?(Integer) ? value : typecast_to_numeric(value, :to_i)
+        end
+
+        # Typecast a value to a String
+        def typecast_to_string(value)
+          value.to_s
+        end
+
+        # Typecast a value to a true or false
+        def typecast_to_trueclass(value)
+          if value.kind_of?(Integer)
+            return true  if value == 1
+            return false if value == 0
+          elsif value.respond_to?(:to_s)
+            return true  if %w[ true  1 t ].include?(value.to_s.downcase)
+            return false if %w[ false 0 f ].include?(value.to_s.downcase)
+          end
+          value
+        end
+
+        # Typecast a value to a BigDecimal
+        def typecast_to_bigdecimal(value)
+          return value if value.kind_of?(BigDecimal)
+
+          if value.kind_of?(Integer)
+            value.to_s.to_d
+          else
+            typecast_to_numeric(value, :to_d)
+          end
+        end
+
+        # Typecast a value to a Float
+        def typecast_to_float(value)
+          return value if value.kind_of?(Float)
+          typecast_to_numeric(value, :to_f)
+        end
+
+        # Match numeric string
+        def typecast_to_numeric(value, method)
+          if value.respond_to?(:to_str)
+            if value.to_str =~ /\A(-?(?:0|[1-9]\d*)(?:\.\d+)?|(?:\.\d+))\z/
+              $1.send(method)
+            else
+              value
+            end
+          elsif value.respond_to?(method)
+            value.send(method)
+          else
+            value
+          end
+        end
+
+        # Typecasts an arbitrary value to a DateTime.
+        # Handles both Hashes and DateTime instances.
+        def typecast_to_datetime(value)
+          return value if value.kind_of?(DateTime)
+
+          if value.is_a?(Hash)
+            typecast_hash_to_datetime(value)
+          else
+            DateTime.parse(value.to_s)
+          end
+        rescue ArgumentError
+          value
+        end
+
+        # Typecasts an arbitrary value to a Date
+        # Handles both Hashes and Date instances.
+        def typecast_to_date(value)
+          return value if value.kind_of?(Date)
+
+          if value.is_a?(Hash)
+            typecast_hash_to_date(value)
+          else
+            Date.parse(value.to_s)
+          end
+        rescue ArgumentError
+          value
+        end
+
+        # Typecasts an arbitrary value to a Time
+        # Handles both Hashes and Time instances.
+        def typecast_to_time(value)
+          return value if value.kind_of?(Time)
+
+          if value.is_a?(Hash)
+            typecast_hash_to_time(value)
+          else
+            Time.mktime_with_offset(value.to_s)
+          end
+        rescue ArgumentError
+          value
+        rescue TypeError
+          value
+        end
+
+        # Creates a DateTime instance from a Hash with keys :year, :month, :day,
+        # :hour, :min, :sec
+        def typecast_hash_to_datetime(value)
+          DateTime.new(*extract_time(value))
+        end
+
+        # Creates a Date instance from a Hash with keys :year, :month, :day
+        def typecast_hash_to_date(value)
+          Date.new(*extract_time(value)[0, 3])
+        end
+
+        # Creates a Time instance from a Hash with keys :year, :month, :day,
+        # :hour, :min, :sec
+        def typecast_hash_to_time(value)
+          Time.local(*extract_time(value))
+        end
+
+        # Extracts the given args from the hash. If a value does not exist, it
+        # uses the value of Time.now.
+        def extract_time(value)
+          now  = Time.now
+
+          [:year, :month, :day, :hour, :min, :sec].map do |segment|
+            typecast_to_numeric(value.fetch(segment, now.send(segment)), :to_i)
+          end
+        end
+
+        # Typecast a value to a Class
+        def typecast_to_class(value)
+          return value if value.kind_of?(Class)
+          ::CouchRest.constantize(value.to_s)
+        rescue NameError
+          value
+        end
+
+    end
+  end
+end
+

data/lib/couchrest/validation/validators/required_field_validator.rb

@@ -37,7 +37,7 @@ module CouchRest
 
       def call(target)
         value = target.validation_property_value(field_name)
-        property = target.validation_property(field_name)
+        property = target.validation_property(field_name.to_s)
         return true if present?(value, property)
 
         error_message = @options[:message] || default_error(property)
@@ -66,7 +66,7 @@ module CouchRest
       # Returns false for other property types.
       # Returns false for non-properties.
       def boolean_type?(property)
-        property ? property.type == TrueClass : false
+        property ? property.type == 'Boolean' : false
       end
 
     end # class RequiredFieldValidator

data/spec/couchrest/core/couchrest_spec.rb

@@ -46,137 +46,74 @@ describe CouchRest do
     it "should parse just a dbname" do
       db = CouchRest.parse "my-db"
       db[:database].should == "my-db"
-      db[:host].should == "127.0.0.1:5984"
+      db[:host].should == "http://127.0.0.1:5984"
     end
     it "should parse a host and db" do
       db = CouchRest.parse "127.0.0.1/my-db"
       db[:database].should == "my-db"
-      db[:host].should == "127.0.0.1"
-    end
-    it "should parse a host and db with http" do
-      db = CouchRest.parse "https://127.0.0.1/my-db"
-      db[:database].should == "my-db"
-      db[:host].should == "127.0.0.1"
-    end
-    it "should parse a host with a port and db" do
-      db = CouchRest.parse "127.0.0.1:5555/my-db"
-      db[:database].should == "my-db"
-      db[:host].should == "127.0.0.1:5555"
-    end
-    it "should parse a host with a port and db with http" do
-      db = CouchRest.parse "http://127.0.0.1:5555/my-db"
-      db[:database].should == "my-db"
-      db[:host].should == "127.0.0.1:5555"
-    end
-    it "should parse a host with a port and db with https" do
-      db = CouchRest.parse "https://127.0.0.1:5555/my-db"
-      db[:database].should == "my-db"
-      db[:host].should == "127.0.0.1:5555"
-    end
-    it "should parse just a host" do
-      db = CouchRest.parse "http://127.0.0.1:5555/"
-      db[:database].should be_nil
-      db[:host].should == "127.0.0.1:5555"
-    end
-    it "should parse just a host with https" do
-      db = CouchRest.parse "https://127.0.0.1:5555/"
-      db[:database].should be_nil
-      db[:host].should == "127.0.0.1:5555"
-    end
-    it "should parse just a host no slash" do
-      db = CouchRest.parse "http://127.0.0.1:5555"
-      db[:host].should == "127.0.0.1:5555"
-      db[:database].should be_nil
-    end
-    it "should parse just a host no slash and https" do
-      db = CouchRest.parse "https://127.0.0.1:5555"
-      db[:host].should == "127.0.0.1:5555"
-      db[:database].should be_nil
-    end
-    it "should get docid" do
-      db = CouchRest.parse "127.0.0.1:5555/my-db/my-doc"
-      db[:database].should == "my-db"
-      db[:host].should == "127.0.0.1:5555"
-      db[:doc].should == "my-doc"
-    end
-    it "should get docid with http" do
-      db = CouchRest.parse "http://127.0.0.1:5555/my-db/my-doc"
-      db[:database].should == "my-db"
-      db[:host].should == "127.0.0.1:5555"
-      db[:doc].should == "my-doc"
-    end
-    it "should get docid with https" do
-      db = CouchRest.parse "https://127.0.0.1:5555/my-db/my-doc"
-      db[:database].should == "my-db"
-      db[:host].should == "127.0.0.1:5555"
-      db[:doc].should == "my-doc"
-    end
-    it "should parse a host and db" do
-      db = CouchRest.parse "127.0.0.1/my-db"
-      db[:database].should == "my-db"
-      db[:host].should == "127.0.0.1"
+      db[:host].should == "http://127.0.0.1"
     end
     it "should parse a host and db with http" do
       db = CouchRest.parse "http://127.0.0.1/my-db"
       db[:database].should == "my-db"
-      db[:host].should == "127.0.0.1"
+      db[:host].should == "http://127.0.0.1"
     end
     it "should parse a host and db with https" do
       db = CouchRest.parse "https://127.0.0.1/my-db"
       db[:database].should == "my-db"
-      db[:host].should == "127.0.0.1"
+      db[:host].should == "https://127.0.0.1"
     end
     it "should parse a host with a port and db" do
       db = CouchRest.parse "127.0.0.1:5555/my-db"
       db[:database].should == "my-db"
-      db[:host].should == "127.0.0.1:5555"
+      db[:host].should == "http://127.0.0.1:5555"
     end
     it "should parse a host with a port and db with http" do
       db = CouchRest.parse "http://127.0.0.1:5555/my-db"
       db[:database].should == "my-db"
-      db[:host].should == "127.0.0.1:5555"
+      db[:host].should == "http://127.0.0.1:5555"
     end
     it "should parse a host with a port and db with https" do
-      db = CouchRest.parse "http://127.0.0.1:5555/my-db"
+      db = CouchRest.parse "https://127.0.0.1:5555/my-db"
       db[:database].should == "my-db"
-      db[:host].should == "127.0.0.1:5555"
+      db[:host].should == "https://127.0.0.1:5555"
     end
     it "should parse just a host" do
       db = CouchRest.parse "http://127.0.0.1:5555/"
       db[:database].should be_nil
-      db[:host].should == "127.0.0.1:5555"
+      db[:host].should == "http://127.0.0.1:5555"
     end
     it "should parse just a host with https" do
       db = CouchRest.parse "https://127.0.0.1:5555/"
       db[:database].should be_nil
-      db[:host].should == "127.0.0.1:5555"
+      db[:host].should == "https://127.0.0.1:5555"
     end
     it "should parse just a host no slash" do
       db = CouchRest.parse "http://127.0.0.1:5555"
-      db[:host].should == "127.0.0.1:5555"
+      db[:host].should == "http://127.0.0.1:5555"
       db[:database].should be_nil
     end
     it "should parse just a host no slash and https" do
       db = CouchRest.parse "https://127.0.0.1:5555"
-      db[:host].should == "127.0.0.1:5555"
+      db[:host].should == "https://127.0.0.1:5555"
       db[:database].should be_nil
     end
     it "should get docid" do
       db = CouchRest.parse "127.0.0.1:5555/my-db/my-doc"
       db[:database].should == "my-db"
-      db[:host].should == "127.0.0.1:5555"
+      db[:host].should == "http://127.0.0.1:5555"
       db[:doc].should == "my-doc"
     end
     it "should get docid with http" do
       db = CouchRest.parse "http://127.0.0.1:5555/my-db/my-doc"
       db[:database].should == "my-db"
-      db[:host].should == "127.0.0.1:5555"
+      db[:host].should == "http://127.0.0.1:5555"
       db[:doc].should == "my-doc"
     end
     it "should get docid with https" do
       db = CouchRest.parse "https://127.0.0.1:5555/my-db/my-doc"
       db[:database].should == "my-db"
-      db[:host].should == "127.0.0.1:5555"
+      db[:host].should == "https://127.0.0.1:5555"
       db[:doc].should == "my-doc"
     end
   end
@@ -185,7 +122,7 @@ describe CouchRest do
     it "should be possible without an explicit CouchRest instantiation" do
       db = CouchRest.database "http://127.0.0.1:5984/couchrest-test"
       db.should be_an_instance_of(CouchRest::Database)
-      db.host.should == "127.0.0.1:5984"
+      db.host.should == "http://127.0.0.1:5984"
     end
     # TODO add https support (need test environment...)
     # it "should work with https" # do

data/spec/couchrest/core/database_spec.rb

@@ -703,12 +703,12 @@ describe CouchRest::Database do
     end
   end
   
-  describe "replicating a database" do
+  describe "simply replicating a database" do
     before do
       @db.save_doc({'_id' => 'test_doc', 'some-value' => 'foo'})
-      @other_db = @cr.database 'couchrest-test-replication'
+      @other_db = @cr.database REPLICATIONDB
       @other_db.delete! rescue nil
-      @other_db = @cr.create_db 'couchrest-test-replication'
+      @other_db = @cr.create_db REPLICATIONDB
     end
 
     describe "via pulling" do
@@ -733,6 +733,53 @@ describe CouchRest::Database do
       end
     end
   end
+    
+  describe "continuously replicating a database" do
+    before do
+      @db.save_doc({'_id' => 'test_doc', 'some-value' => 'foo'})
+      @other_db = @cr.database REPLICATIONDB
+      @other_db.delete! rescue nil
+      @other_db = @cr.create_db REPLICATIONDB
+    end
+
+    describe "via pulling" do
+      before do
+        @other_db.replicate_from @db, true
+      end
+      
+      it "contains the document from the original database" do
+        sleep(1) # Allow some time to replicate
+        doc = @other_db.get('test_doc')
+        doc['some-value'].should == 'foo'
+      end
+      
+      it "contains documents saved after replication initiated" do
+        @db.save_doc({'_id' => 'test_doc_after', 'some-value' => 'bar'})
+        sleep(1) # Allow some time to replicate
+        doc = @other_db.get('test_doc_after')
+        doc['some-value'].should == 'bar'
+      end
+    end
+    
+    describe "via pushing" do
+      before do
+        @db.replicate_to @other_db, true
+      end
+      
+      it "copies the document to the other database" do
+        sleep(1) # Allow some time to replicate
+        doc = @other_db.get('test_doc')
+        doc['some-value'].should == 'foo'
+      end
+      
+      it "copies documents saved after replication initiated" do
+        @db.save_doc({'_id' => 'test_doc_after', 'some-value' => 'bar'})
+        sleep(1) # Allow some time to replicate
+        doc = @other_db.get('test_doc_after')
+        doc['some-value'].should == 'bar'
+      end
+    end
+  end
 
   describe "creating a database" do
     before(:each) do
@@ -769,5 +816,25 @@ describe CouchRest::Database do
     
   end
 
+  describe "searching a database" do
+    before(:each) do
+      search_function = { 'defaults' => {'store' => 'no', 'index' => 'analyzed_no_norms'},
+          'index' => "function(doc) { ret = new Document(); ret.add(doc['name'], {'field':'name'}); ret.add(doc['age'], {'field':'age'}); return ret; }" }
+      @db.save_doc({'_id' => '_design/search', 'fulltext' => {'people' => search_function}})
+      @db.save_doc({'_id' => 'john', 'name' => 'John', 'age' => '31'})
+      @db.save_doc({'_id' => 'jack', 'name' => 'Jack', 'age' => '32'})
+      @db.save_doc({'_id' => 'dave', 'name' => 'Dave', 'age' => '33'})
+    end
+
+    it "should be able to search a database using couchdb-lucene" do
+      if couchdb_lucene_available?
+        result = @db.search('search/people', :q => 'name:J*')
+        doc_ids = result['rows'].collect{ |row| row['id'] }
+        doc_ids.size.should == 2
+        doc_ids.should include('john')
+        doc_ids.should include('jack')
+      end
+    end
+  end
 
 end