couchrest_model 2.0.0.beta2 → 2.0.0

data/lib/couchrest/model/designs.rb

@@ -22,18 +22,37 @@ module CouchRest
 
       module ClassMethods
 
-        # Add views and other design document features
-        # to the current model.
-        def design(prefix = nil, &block)
+        # Define a Design Document associated with the current model.
+        #
+        # This class method supports several cool features that make it much
+        # easier to define design documents.
+        #
+        # Adding a prefix allows you to associate multiple design documents with the same
+        # model. This is useful if you'd like to split your designs into seperate
+        # use cases; one for regular search functions and a second for stats for example.
+        # 
+        #    # Create a design doc with id _design/Cats
+        #    design do
+        #      view :by_name
+        #    end
+        #
+        #    # Create a design doc with id _design/Cats_stats
+        #    design :stats do
+        #      view :by_age, :reduce => :stats
+        #    end
+        #
+        #
+        def design(*args, &block)
+          opts = prepare_design_options(*args)
 
           # Store ourselves a copy of this design spec incase any other model inherits.
-          (@_design_blocks ||= [ ]) << {:args => [prefix], :block => block}
+          (@_design_blocks ||= [ ]) << {:args => args, :block => block}
 
-          mapper = DesignMapper.new(self, prefix)
+          mapper = DesignMapper.new(self, opts[:prefix])
           mapper.instance_eval(&block) if block_given?
 
           # Create an 'all' view if no prefix and one has not been defined already
-          mapper.view(:all) if prefix.nil? and !mapper.design_doc.has_view?(:all)
+          mapper.view(:all) if opts[:prefix].nil? and !mapper.design_doc.has_view?(:all)
         end
 
         def inherited(model)
@@ -68,76 +87,24 @@ module CouchRest
           @_design_docs ||= []
         end
 
-      end
-
-      # Map method calls defined in a design block to actions
-      # in the Design Document.
-      class DesignMapper
-
-        # Basic mapper attributes
-        attr_accessor :model, :method, :prefix
-
-        # Temporary variable storing the design doc
-        attr_accessor :design_doc
-
-        def initialize(model, prefix = nil)
-          self.model  = model
-          self.prefix = prefix
-          self.method = Design.method_name(prefix)
-
-          create_model_design_doc_reader
-          self.design_doc = model.send(method) || assign_model_design_doc
-        end
-
-        def disable_auto_update
-          design_doc.auto_update = false
-        end
-
-        def enable_auto_update
-          design_doc.auto_update = true
-        end
-
-        # Add the specified view to the design doc the definition was made in
-        # and create quick access methods in the model.
-        def view(name, opts = {})
-          design_doc.create_view(name, opts)
-        end
-
-        # Really simple design function that allows a filter
-        # to be added. Filters are simple functions used when listening
-        # to the _changes feed.
-        #
-        # No methods are created here, the design is simply updated.
-        # See the CouchDB API for more information on how to use this.
-        def filter(name, function)
-          design_doc.create_filter(name, function)
-        end
-
-        # Convenience wrapper to access model's type key option.
-        def model_type_key
-          model.model_type_key
-        end
-
-        protected
+        private
 
-        # Create accessor in model and assign a new design doc.
-        # New design doc is returned ready to use.
-        def create_model_design_doc_reader
-          model.instance_eval "def #{method}; @#{method}; end"
+        def prepare_design_options(*args)
+          options = {}
+          if !args.first.is_a?(Hash)
+            options[:prefix] = args.shift
+          end
+          options.merge(args.last) unless args.empty?
+          prepare_source_paths(options)
+          options
         end
 
-        def assign_model_design_doc
-          doc = Design.new(model, prefix)
-          model.instance_variable_set("@#{method}", doc)
-          model.design_docs << doc
-
-          # Set defaults
-          doc.auto_update = model.auto_update_design_doc
-
-          doc
+        def prepare_source_paths(options)
+          
         end
 
       end
+
     end
   end
 end

data/lib/couchrest/model/persistence.rb

@@ -8,8 +8,8 @@ module CouchRest
       # be returned.
       def create(options = {})
         return false unless perform_validations(options)
-        _run_create_callbacks do
-          _run_save_callbacks do
+        run_callbacks :create do
+          run_callbacks :save do
             set_unique_id if new? && self.respond_to?(:set_unique_id)
             result = database.save_doc(self)
             ret = (result["ok"] == true) ? self : false
@@ -32,8 +32,8 @@ module CouchRest
         raise "Calling #{self.class.name}#update on document that has not been created!" if new?
         return false unless perform_validations(options)
         return true if !self.disable_dirty && !self.changed?
-        _run_update_callbacks do
-          _run_save_callbacks do
+        run_callbacks :update do
+          run_callbacks :save do
             result = database.save_doc(self)
             ret = result["ok"] == true
             @changed_attributes.clear if ret && @changed_attributes
@@ -56,7 +56,7 @@ module CouchRest
 
       # Deletes the document from the database. Runs the :destroy callbacks.
       def destroy
-        _run_destroy_callbacks do
+        run_callbacks :destroy do
           result = database.delete_doc(self)
           if result['ok']
             @_destroyed = true

data/lib/couchrest/model/properties.rb

@@ -205,26 +205,15 @@ module CouchRest
 
           # This is not a thread safe operation, if you have to set new properties at runtime
           # make sure a mutex is used.
-          def define_property(name, options={}, &block)
-            # check if this property is going to casted
-            type = options.delete(:type) || options.delete(:cast_as)
-            if block_given?
-              type = Class.new do
-                include Embeddable
-              end
-              if block.arity == 1 # Traditional, with options
-                type.class_eval { yield type }
-              else
-                type.instance_exec(&block)
-              end
-              type = [type] # inject as an array
-            end
-            property = Property.new(name, type, options)
+          def define_property(name, options = {}, &block)
+            property = Property.new(name, options, &block)
             create_property_getter(property)
             create_property_setter(property) unless property.read_only == true
-            if property.type_class.respond_to?(:validates_casted_model)
+
+            if property.type.respond_to?(:validates_casted_model)
               validates_casted_model property.name
             end
+
             properties << property
             properties_by_name[property.to_s] = property
             property

data/lib/couchrest/model/property.rb

@@ -4,26 +4,29 @@ module CouchRest::Model
 
     include ::CouchRest::Model::Typecast
 
-    attr_reader :name, :type, :type_class, :read_only, :alias, :default, :casted, :init_method, :options, :allow_blank
+    attr_reader :name, :type, :array, :read_only, :alias, :default, :casted, :init_method, :options, :allow_blank
 
     # Attribute to define.
     # All Properties are assumed casted unless the type is nil.
-    def initialize(name, type = nil, options = {})
+    def initialize(name, options = {}, &block)
       @name = name.to_s
-      @casted = true
-      parse_type(type)
       parse_options(options)
+      parse_type(options, &block)
       self
     end
 
     def to_s
       name
     end
+    
+    def to_sym
+      @_sym_name ||= name.to_sym
+    end
 
     # Cast the provided value using the properties details.
     def cast(parent, value)
       return value unless casted
-      if type.is_a?(Array)
+      if array
         if value.nil?
           value = []
         elsif [Hash, HashWithIndifferentAccess].include?(value.class)
@@ -68,12 +71,12 @@ module CouchRest::Model
     # used. If a proc is defined for the init method, it will be used instead of 
     # a normal call to the class.
     def build(*args)
-      raise StandardError, "Cannot build property without a class" if @type_class.nil?
+      raise StandardError, "Cannot build property without a class" if @type.nil?
 
       if @init_method.is_a?(Proc)
         @init_method.call(*args)
       else
-        @type_class.send(@init_method, *args)
+        @type.send(@init_method, *args)
       end
     end
 
@@ -93,21 +96,23 @@ module CouchRest::Model
         value
       end
 
-      def parse_type(type)
-        if type.nil?
+      def parse_type(options, &block)
+        set_type_from_block(&block) if block_given?
+        if @type.nil?
           @casted = false
-          @type = nil
-          @type_class = nil
         else
-          base = type.is_a?(Array) ? type.first : type
-          base = Object if base.nil?
-          raise "Defining a property type as a #{type.class.name.humanize} is not supported in CouchRest Model!" if base.class != Class
-          @type_class = base
-          @type = type
+          @casted = true
+          if @type.is_a?(Array)
+            @type  = @type.first || Object
+            @array = true
+          end
+          raise "Defining a property type as a #{@type.class.name.humanize} is not supported in CouchRest Model!" if @type.class != Class
         end
       end
 
       def parse_options(options)
+        @type               = options.delete(:type) || options.delete(:cast_as)
+        @array              = !!options.delete(:array)
         @validation_format  = options.delete(:format)      if options[:format]
         @read_only          = options.delete(:read_only)   if options[:read_only]
         @alias              = options.delete(:alias)       if options[:alias]
@@ -116,5 +121,18 @@ module CouchRest::Model
         @allow_blank        = options[:allow_blank].nil? ? true : options.delete(:allow_blank)
         @options            = options
       end
+
+
+      def set_type_from_block(&block)
+        @type = Class.new do
+          include Embeddable
+        end
+        if block.arity == 1 # Traditional, with options
+          @type.class_eval(&block)
+        else
+          @type.instance_eval(&block)
+        end
+      end
+
   end
 end

data/lib/couchrest/model/translation.rb

@@ -0,0 +1,22 @@
+module CouchRest
+  module Model
+    module Translation
+      include ActiveModel::Translation
+
+      def lookup_ancestors #:nodoc:
+        klass = self
+        classes = [klass]
+        return classes if klass == CouchRest::Model::Base
+
+        while klass.superclass != CouchRest::Model::Base
+          classes << klass = klass.superclass
+        end
+        classes
+      end
+
+      def i18n_scope
+        :couchrest
+      end
+    end
+  end
+end

data/lib/couchrest/model/typecast.rb

@@ -4,17 +4,17 @@ module CouchRest
 
       def typecast_value(parent, property, value)
         return nil if value.nil?
-        klass = property.type_class
-        if value.instance_of?(klass) || klass == Object
-          if klass == Time && !value.utc?
+        type = property.type
+        if value.instance_of?(type) || type == Object
+          if type == Time && !value.utc?
             value.utc # Ensure Time is always in UTC
           else
             value
           end
-        elsif klass.respond_to?(:couchrest_typecast)
-          klass.couchrest_typecast(parent, property, value)
-        elsif [String, TrueClass, Integer, Float, BigDecimal, DateTime, Time, Date, Class].include?(klass)
-          send('typecast_to_'+klass.to_s.downcase, value)
+        elsif type.respond_to?(:couchrest_typecast)
+          type.couchrest_typecast(parent, property, value)
+        elsif [String, Symbol, TrueClass, Integer, Float, BigDecimal, DateTime, Time, Date, Class].include?(type)
+          send('typecast_to_'+type.to_s.downcase, value)
         else
           property.build(value)
         end
@@ -27,30 +27,9 @@ module CouchRest
           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)
-          if value.kind_of?(Integer)
-            value.to_s.to_d
-          else
-            typecast_to_numeric(value, :to_d)
-          end
+          typecast_to_numeric(value, :to_d)
         end
 
         # Typecast a value to a Float
@@ -58,21 +37,50 @@ module CouchRest
           typecast_to_numeric(value, :to_f)
         end
 
-        # Match numeric string
+        # Convert some kind of object to a number that of the type
+        # provided.
+        #
+        # When a string is provided, It'll attempt to filter out
+        # region specific details such as commas instead of points
+        # for decimal places, text units, and anything else that is
+        # not a number and a human could make out.
+        #
+        # Esentially, the aim is to provide some kind of sanitary
+        # conversion from values in incoming http forms.
+        #
+        # If what we get makes no sense at all, nil it.
         def typecast_to_numeric(value, method)
-          if value.respond_to?(:to_str)
-            if value.strip.gsub(/,/, '.').gsub(/\.(?!\d*\Z)/, '').to_str =~ /\A(-?(?:0|[1-9]\d*)(?:\.\d+)?|(?:\.\d+))\z/
-              $1.send(method)
-            else
-              value
-            end
+          if value.is_a?(String)
+            value = value.strip.gsub(/,/, '.').gsub(/[^\d\-\.]/, '').gsub(/\.(?!\d*\Z)/, '')
+            value.empty? ? nil : value.send(method)
           elsif value.respond_to?(method)
             value.send(method)
           else
-            value
+            nil
           end
         end
 
+        # Typecast a value to a String
+        def typecast_to_string(value)
+          value.to_s
+        end
+
+        def typecast_to_symbol(value)
+          value.to_sym
+        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
+          nil
+        end
+
         # Typecasts an arbitrary value to a DateTime.
         # Handles both Hashes and DateTime instances.
         # This is slow!! Use Time instead.
@@ -83,7 +91,7 @@ module CouchRest
             DateTime.parse(value.to_s)
           end
         rescue ArgumentError
-          value
+          nil
         end
 
         # Typecasts an arbitrary value to a Date
@@ -100,21 +108,24 @@ module CouchRest
             Date.parse(value)
           end
         rescue ArgumentError
-          value
+          nil
         end
 
         # Typecasts an arbitrary value to a Time
         # Handles both Hashes and Time instances.
         def typecast_to_time(value)
-          if value.is_a?(Hash)
+          case value
+          when Float # JSON oj already parses Time, FTW.
+            Time.at(value).utc
+          when Hash
             typecast_hash_to_time(value)
           else
             Time.parse_iso8601(value.to_s)
           end
         rescue ArgumentError
-          value
+          nil
         rescue TypeError
-          value
+          nil
         end
 
         # Creates a DateTime instance from a Hash with keys :year, :month, :day,
@@ -147,7 +158,7 @@ module CouchRest
         def typecast_to_class(value)
           value.to_s.constantize
         rescue NameError
-          value
+          nil
         end
 
     end

data/lib/couchrest/model/utils/migrate.rb

@@ -0,0 +1,106 @@
+module CouchRest
+  module Model
+    module Utils
+
+      # Handle CouchDB Design Document migrations.
+      #
+      # Actual migrations are handled by the Design document, this serves as a utility
+      # to find all the CouchRest Model submodels and perform the migration on them.
+      #
+      # Also contains some more advanced support for handling proxied models.
+      #
+      # Examples of usage:
+      #
+      #    # Ensure all models have been loaded (only Rails)
+      #    CouchRest::Model::Utils::Migrate.load_all_models
+      #
+      #    # Migrate all regular models (not proxied)
+      #    CouchRest::Model::Utils::Migrate.all_models
+      #
+      #    # Migrate all models and submodels of proxies
+      #    CouchRest::Model::Utils::Migrate.all_models_and_proxies
+      #
+      # Typically however you'd want to run these methods from the rake tasks:
+      #
+      #    $ rake couchrest:migrate_with_proxies
+      #
+      # NOTE: This is an experimental feature that is not yet properly tested.
+      #
+      module Migrate
+        extend self
+
+        # Make an attempt at loading all the files in this Rails application's
+        # models directory.
+        def load_all_models
+          # Make a reasonable effort to load all models
+          return unless defined?(Rails)
+          Dir[Rails.root + 'app/models/**/*.rb'].each do |path|
+            require path
+          end
+        end
+
+        # Go through each class that inherits from CouchRest::Model::Base and
+        # attempt to migrate the design documents.
+        def all_models
+          callbacks = migrate_each_model(find_models)
+          cleanup(callbacks)
+        end
+
+        def all_models_and_proxies
+          callbacks = migrate_each_model(find_models)
+          callbacks += migrate_each_proxying_model(find_proxying_models)
+          cleanup(callbacks)
+        end
+
+        protected
+
+        def find_models
+          CouchRest::Model::Base.subclasses.reject{|m| m.proxy_owner_method.present?}
+        end
+
+        def find_proxying_models
+          CouchRest::Model::Base.subclasses.reject{|m| m.proxy_database_method.blank?}
+        end
+
+        def migrate_each_model(models, db = nil)
+          callbacks = [ ]
+          models.each do |model|
+            model.design_docs.each do |design|
+              callbacks << migrate_design(model, design, db)
+            end
+          end
+          callbacks
+        end
+
+        def migrate_each_proxying_model(models)
+          callbacks = [ ]
+          models.each do |model|
+            submodels = model.proxied_model_names.map{|n| n.constantize}
+            model.all.each do |base|
+              puts "Finding proxied models for #{model}: \"#{base.send(model.proxy_database_method)}\""
+              callbacks += migrate_each_model(submodels, base.proxy_database)
+            end
+          end
+          callbacks
+        end
+
+        def migrate_design(model, design, db = nil)
+          print "Migrating #{model.to_s}##{design.method_name}... "
+          callback = design.migrate(db) do |result|
+            puts "#{result.to_s.gsub(/_/, ' ')}"
+          end
+          # Return the callback hash if there is one
+          callback ? {:design => design, :proc => callback, :db => db || model.database} : nil
+        end
+
+        def cleanup(methods)
+          methods.compact.each do |cb|
+            name = "/#{cb[:db].name}/#{cb[:design]['_id']}"
+            puts "Activating new design: #{name}"
+            cb[:proc].call
+          end
+        end
+      end
+    end
+  end
+end

data/lib/couchrest_model.rb

@@ -24,6 +24,7 @@ require 'couchrest'
 
 require 'couchrest/model'
 require 'couchrest/model/errors'
+require 'couchrest/model/translation'
 require "couchrest/model/persistence"
 require "couchrest/model/typecast"
 require "couchrest/model/casted_by"
@@ -41,8 +42,9 @@ require "couchrest/model/proxyable"
 require "couchrest/model/associations"
 require "couchrest/model/configuration"
 require "couchrest/model/connection"
+require "couchrest/model/design"
 require "couchrest/model/designs"
-require "couchrest/model/designs/design"
+require "couchrest/model/designs/design_mapper"
 require "couchrest/model/designs/view"
 
 # Monkey patches applied to couchrest
@@ -57,7 +59,7 @@ require "couchrest/model/embeddable"
 require "couchrest/model/base"
 
 # Design Migration support
-require "couchrest/model/migrate.rb"
+require "couchrest/model/utils/migrate.rb"
 
 # Add rails support *after* everything has loaded
 if defined?(Rails)

data/lib/tasks/migrations.rake

@@ -1,20 +1,20 @@
 #
 # CouchRest Migration Rake Tasks
 #
-# Use at own risk! These are not tested yet!
+# See the CouchRest::Model::Utils::Migrate class for more details.
 #
 namespace :couchrest do
 
   desc "Migrate all the design docs found in each model"
   task :migrate => :environment do
-    CouchRest::Model::Migrate.load_all_models
-    CouchRest::Model::Migrate.all_models
+    CouchRest::Model::Utils::Migrate.load_all_models
+    CouchRest::Model::Utils::Migrate.all_models
   end
 
   desc "Migrate all the design docs "
   task :migrate_with_proxies => :environment do
-    CouchRest::Model::Migrate.load_all_models
-    CouchRest::Model::Migrate.all_models_and_proxies
+    CouchRest::Model::Utils::Migrate.load_all_models
+    CouchRest::Model::Utils::Migrate.all_models_and_proxies
   end
 
 

data/spec/fixtures/models/course.rb

@@ -21,6 +21,7 @@ class Course < CouchRest::Model::Base
   property :klass, :type => Class
   property :currency, String, :default => 'EUR'
   property :price, Money
+  property :symbol, Symbol
 
   design do
     view :by_title

data/spec/fixtures/models/designs.rb

@@ -0,0 +1,22 @@
+
+class DesignModel < CouchRest::Model::Base
+  use_database DB
+  property :name
+end
+
+class DesignsModel < CouchRest::Model::Base
+  use_database DB
+  property :name
+end
+
+
+class DesignsNoAutoUpdate < CouchRest::Model::Base
+  use_database DB
+  property :title, String
+  design do
+    disable_auto_update
+    view :by_title_fail, :by => ['title']
+    view :by_title, :reduce => true
+  end
+end
+

data/spec/spec_helper.rb

@@ -5,6 +5,7 @@ require "bundler/setup"
 require "rubygems"
 require "rspec"
 
+#require 'oj'
 require 'couchrest_model'
 
 unless defined?(FIXTURE_PATH)