samlown-couchrest 0.35

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

@@ -0,0 +1,109 @@
+# Extracted from dm-validations 0.9.10
+#
+# Copyright (c) 2007 Guy van den Berg
+# 
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+# 
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+# 
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+module CouchRest
+  module Validation
+
+    ##
+    #
+    # @author Guy van den Berg
+    # @since  0.9
+    class NumericValidator < GenericValidator
+
+      def initialize(field_name, options={})
+        super
+        @field_name, @options = field_name, options
+        @options[:integer_only] = false unless @options.has_key?(:integer_only)
+      end
+
+      def call(target)
+        value = target.send(field_name)
+        return true if @options[:allow_nil] && value.nil?
+
+        value = (defined?(BigDecimal) && value.kind_of?(BigDecimal)) ? value.to_s('F') : value.to_s
+
+        error_message = @options[:message]
+        precision     = @options[:precision]
+        scale         = @options[:scale]
+
+        if @options[:integer_only]
+          return true if value =~ /\A[+-]?\d+\z/
+          error_message ||= ValidationErrors.default_error_message(:not_an_integer, field_name)
+        else
+          # FIXME: if precision and scale are not specified, can we assume that it is an integer?
+          #        probably not, as floating point numbers don't have hard
+          #        defined scale. the scale floats with the length of the
+          #        integral and precision. Ie. if precision = 10 and integral
+          #        portion of the number is 9834 (4 digits), the max scale will
+          #        be 6 (10 - 4). But if the integral length is 1, max scale
+          #        will be (10 - 1) = 9, so 1.234567890.
+          if precision && scale
+            #handles both Float when it has scale specified and BigDecimal
+            if precision > scale && scale > 0
+              return true if value =~ /\A[+-]?(?:\d{1,#{precision - scale}}|\d{0,#{precision - scale}}\.\d{1,#{scale}})\z/
+            elsif precision > scale && scale == 0
+              return true if value =~ /\A[+-]?(?:\d{1,#{precision}}(?:\.0)?)\z/
+            elsif precision == scale
+              return true if value =~ /\A[+-]?(?:0(?:\.\d{1,#{scale}})?)\z/
+            else
+              raise ArgumentError, "Invalid precision #{precision.inspect} and scale #{scale.inspect} for #{field_name} (value: #{value.inspect} #{value.class})"
+            end
+          elsif precision && scale.nil?
+            # for floats, if scale is not set
+
+            #total number of digits is less or equal precision
+            return true if value.gsub(/[^\d]/, '').length <= precision
+
+            #number of digits before decimal == precision, and the number is x.0. same as scale = 0
+            return true if value =~ /\A[+-]?(?:\d{1,#{precision}}(?:\.0)?)\z/
+          else
+            return true if value =~ /\A[+-]?(?:\d+|\d*\.\d+)\z/
+          end
+          error_message ||= ValidationErrors.default_error_message(:not_a_number, field_name)
+        end
+
+        add_error(target, error_message, field_name)
+
+        # TODO: check the gt, gte, lt, lte, and eq options
+
+        return false
+      end
+    end # class NumericValidator
+
+    module ValidatesIsNumber
+
+      # Validate whether a field is numeric
+      #
+      def validates_numericality_of(*fields)
+        opts = opts_from_validator_args(fields)
+        add_validator_to_context(opts, fields, CouchRest::Validation::NumericValidator)
+      end
+      
+      def validates_is_number(*fields)
+        warn "[DEPRECATION] `validates_is_number` is deprecated.  Please use `validates_numericality_of` instead."
+        validates_numericality_of(*fields)
+      end
+
+    end # module ValidatesIsNumber
+  end # module Validation
+end # module CouchRest

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

@@ -0,0 +1,114 @@
+# Extracted from dm-validations 0.9.10
+#
+# Copyright (c) 2007 Guy van den Berg
+# 
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+# 
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+# 
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+module CouchRest
+  module Validation
+
+    ##
+    #
+    # @author Guy van den Berg
+    # @since  0.9
+    class RequiredFieldValidator < GenericValidator
+
+      def initialize(field_name, options={})
+        super
+        @field_name, @options = field_name, options
+      end
+
+      def call(target)
+        value = target.validation_property_value(field_name)
+        property = target.validation_property(field_name.to_s)
+        return true if present?(value, property)
+
+        error_message = @options[:message] || default_error(property)
+        add_error(target, error_message, field_name)
+
+        false
+      end
+
+      protected
+
+      # Boolean property types are considered present if non-nil.
+      # Other property types are considered present if non-blank.
+      # Non-properties are considered present if non-blank.
+      def present?(value, property)
+        boolean_type?(property) ? !value.nil? : !value.blank?
+      end
+
+      def default_error(property)
+        actual = boolean_type?(property) ? :nil : :blank
+        ValidationErrors.default_error_message(actual, field_name)
+      end
+
+      # Is +property+ a boolean property?
+      #
+      # Returns true for Boolean, ParanoidBoolean, TrueClass, etc. properties.
+      # Returns false for other property types.
+      # Returns false for non-properties.
+      def boolean_type?(property)
+        property ? property.type == 'Boolean' : false
+      end
+
+    end # class RequiredFieldValidator
+
+    module ValidatesPresent
+
+      ##
+      # Validates that the specified attribute is present.
+      #
+      # For most property types "being present" is the same as being "not
+      # blank" as determined by the attribute's #blank? method. However, in
+      # the case of Boolean, "being present" means not nil; i.e. true or
+      # false.
+      #
+      # @note
+      #   dm-core's support lib adds the blank? method to many classes,
+      # @see lib/dm-core/support/blank.rb (dm-core) for more information.
+      #
+      # @example [Usage]
+      #
+      #   class Page
+      #
+      #     property :required_attribute, String
+      #     property :another_required, String
+      #     property :yet_again, String
+      #
+      #     validates_presence_of :required_attribute
+      #     validates_presence_of :another_required, :yet_again
+      #
+      #     # a call to valid? will return false unless
+      #     # all three attributes are !blank?
+      #   end
+      def validates_presence_of(*fields)
+        opts = opts_from_validator_args(fields)
+        add_validator_to_context(opts, fields, CouchRest::Validation::RequiredFieldValidator)
+      end
+      
+      def validates_present(*fields)
+        warn "[DEPRECATION] `validates_present` is deprecated.  Please use `validates_presence_of` instead."
+        validates_presence_of(*fields)
+      end
+
+    end # module ValidatesPresent
+  end # module Validation
+end # module CouchRest

data/lib/couchrest.rb

@@ -0,0 +1,162 @@
+# Copyright 2008 J. Chris Anderson
+# 
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+# 
+#        http://www.apache.org/licenses/LICENSE-2.0
+# 
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+
+require 'rubygems'
+begin
+  require 'json'
+rescue LoadError
+  raise "You need install and require your own json compatible library since couchrest rest couldn't load the json/json_pure gem" unless Kernel.const_defined?("JSON")
+end
+require 'rest_client'
+
+$:.unshift File.dirname(__FILE__) unless
+  $:.include?(File.dirname(__FILE__)) ||
+  $:.include?(File.expand_path(File.dirname(__FILE__)))
+    
+require 'couchrest/monkeypatches'
+
+# = CouchDB, close to the metal
+module CouchRest
+  VERSION    = '0.35' unless self.const_defined?("VERSION")
+  
+  autoload :Server,       'couchrest/core/server'
+  autoload :Database,     'couchrest/core/database'
+  autoload :Response,     'couchrest/core/response'
+  autoload :Document,     'couchrest/core/document'
+  autoload :Design,       'couchrest/core/design'
+  autoload :View,         'couchrest/core/view'
+  autoload :Model,        'couchrest/core/model'
+  autoload :Pager,        'couchrest/helper/pager'
+  autoload :FileManager,  'couchrest/helper/file_manager'
+  autoload :Streamer,     'couchrest/helper/streamer'
+  autoload :Upgrade,      'couchrest/helper/upgrade'
+  
+  autoload :ExtendedDocument,     'couchrest/more/extended_document'
+  autoload :CastedModel,          'couchrest/more/casted_model'
+  
+  require File.join(File.dirname(__FILE__), 'couchrest', 'core', 'rest_api')
+  require File.join(File.dirname(__FILE__), 'couchrest', 'core', 'http_abstraction')
+  require File.join(File.dirname(__FILE__), 'couchrest', 'mixins')
+  require File.join(File.dirname(__FILE__), 'couchrest', 'support', 'rails') if defined?(Rails)
+
+  # we extend CouchRest with the RestAPI module which gives us acess to
+  # the get, post, put, delete and copy
+  CouchRest.extend(::RestAPI)
+  
+  # The CouchRest module methods handle the basic JSON serialization 
+  # and deserialization, as well as query parameters. The module also includes
+  # some helpers for tasks like instantiating a new Database or Server instance.
+  class << self
+
+    # extracted from Extlib
+    #
+    # Constantize tries to find a declared constant with the name specified
+    # in the string. It raises a NameError when the name is not in CamelCase
+    # or is not initialized.
+    #
+    # @example
+    # "Module".constantize #=> Module
+    # "Class".constantize #=> Class
+    def constantize(camel_cased_word)
+      unless /\A(?:::)?([A-Z]\w*(?:::[A-Z]\w*)*)\z/ =~ camel_cased_word
+        raise NameError, "#{camel_cased_word.inspect} is not a valid constant name!"
+      end
+
+      Object.module_eval("::#{$1}", __FILE__, __LINE__)
+    end
+    
+    # extracted from Extlib
+    #    
+    # Capitalizes the first word and turns underscores into spaces and strips _id.
+    # Like titleize, this is meant for creating pretty output.
+    #
+    # @example
+    #   "employee_salary" #=> "Employee salary"
+    #   "author_id" #=> "Author"
+    def humanize(lower_case_and_underscored_word)
+      lower_case_and_underscored_word.to_s.gsub(/_id$/, "").gsub(/_/, " ").capitalize
+    end
+    
+    # todo, make this parse the url and instantiate a Server or Database instance
+    # depending on the specificity.
+    def new(*opts)
+      Server.new(*opts)
+    end
+    
+    def parse url
+      case url
+      when /^(https?:\/\/)(.*)\/(.*)\/(.*)/
+        scheme = $1
+        host = $2
+        db = $3
+        docid = $4
+      when /^(https?:\/\/)(.*)\/(.*)/
+        scheme = $1
+        host = $2
+        db = $3
+      when /^(https?:\/\/)(.*)/
+        scheme = $1
+        host = $2
+      when /(.*)\/(.*)\/(.*)/
+        host = $1
+        db = $2
+        docid = $3
+      when /(.*)\/(.*)/
+        host = $1
+        db = $2
+      else
+        db = url
+      end
+
+      db = nil if db && db.empty?
+      
+      {
+        :host => (scheme || "http://") + (host || "127.0.0.1:5984"),
+        :database => db,
+        :doc => docid
+      }
+    end
+
+    # set proxy to use
+    def proxy url
+      HttpAbstraction.proxy = url
+    end
+
+    # ensure that a database exists
+    # creates it if it isn't already there
+    # returns it after it's been created
+    def database! url
+      parsed = parse url
+      cr = CouchRest.new(parsed[:host])
+      cr.database!(parsed[:database])
+    end
+  
+    def database url
+      parsed = parse url
+      cr = CouchRest.new(parsed[:host])
+      cr.database(parsed[:database])
+    end
+    
+    def paramify_url url, params = {}
+      if params && !params.empty?
+        query = params.collect do |k,v|
+          v = v.to_json if %w{key startkey endkey}.include?(k.to_s)
+          "#{k}=#{CGI.escape(v.to_s)}"
+        end.join("&")
+        url = "#{url}?#{query}"
+      end
+      url
+    end
+  end # class << self
+end

data/spec/couchrest/core/couchrest_spec.rb

@@ -0,0 +1,184 @@
+require File.expand_path("../../../spec_helper", __FILE__)
+
+describe CouchRest do
+
+  before(:each) do
+    @cr = CouchRest.new(COUCHHOST)
+    begin
+      @db = @cr.database(TESTDB)
+      @db.delete! rescue nil      
+    end
+  end
+
+  after(:each) do
+    begin
+      @db.delete! rescue nil
+    end
+  end
+
+  describe "getting info" do
+    it "should list databases" do
+      @cr.databases.should be_an_instance_of(Array)
+    end
+    it "should get info" do
+      @cr.info["couchdb"].should == "Welcome"
+      @cr.info.class.should == Hash   
+    end
+  end
+  
+  it "should restart" do
+    @cr.restart!
+  end
+
+  it "should provide one-time access to uuids" do
+    @cr.next_uuid.should_not be_nil
+  end
+
+  describe "initializing a database" do
+    it "should return a db" do
+      db = @cr.database(TESTDB)
+      db.should be_an_instance_of(CouchRest::Database)
+      db.host.should == @cr.uri
+    end
+  end
+
+  describe "parsing urls" do
+    it "should parse just a dbname" do
+      db = CouchRest.parse "my-db"
+      db[:database].should == "my-db"
+      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 == "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 == "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 == "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 == "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 == "http://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 == "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 == "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 == "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 == "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 == "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 == "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 == "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 == "https://127.0.0.1:5555"
+      db[:doc].should == "my-doc"
+    end
+  end
+
+  describe "easy initializing a database adapter" 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 == "http://127.0.0.1:5984"
+    end
+    # TODO add https support (need test environment...)
+    # it "should work with https" # do
+    #      db = CouchRest.database "https://127.0.0.1:5984/couchrest-test"
+    #      db.host.should == "https://127.0.0.1:5984"
+    #    end
+    it "should not create the database automatically" do
+      db = CouchRest.database "http://127.0.0.1:5984/couchrest-test"
+      lambda{db.info}.should raise_error(RestClient::ResourceNotFound)      
+    end
+  end
+
+  describe "ensuring the db exists" do
+    it "should be super easy" do
+      db = CouchRest.database! "http://127.0.0.1:5984/couchrest-test-2"
+      db.name.should == 'couchrest-test-2'
+      db.info["db_name"].should == 'couchrest-test-2'
+    end
+  end
+
+  describe "successfully creating a database" do
+    it "should start without a database" do
+      @cr.databases.should_not include(TESTDB)
+    end
+    it "should return the created database" do
+      db = @cr.create_db(TESTDB)
+      db.should be_an_instance_of(CouchRest::Database)
+    end
+    it "should create the database" do
+      db = @cr.create_db(TESTDB)
+      @cr.databases.should include(TESTDB)
+    end
+  end
+
+  describe "failing to create a database because the name is taken" do
+    before(:each) do
+      db = @cr.create_db(TESTDB)
+    end
+    it "should start with the test database" do
+      @cr.databases.should include(TESTDB)
+    end
+    it "should PUT the database and raise an error" do
+      lambda{
+        @cr.create_db(TESTDB)
+      }.should raise_error(RestClient::Request::RequestFailed)
+    end
+  end
+
+  describe "using a proxy for RestClient connections" do
+    it "should set proxy url for RestClient" do
+      CouchRest.proxy 'http://localhost:8888/'
+      proxy_uri = URI.parse(HttpAbstraction.proxy)
+      proxy_uri.host.should eql( 'localhost' )
+      proxy_uri.port.should eql( 8888 )
+      CouchRest.proxy nil
+    end
+  end
+
+end