datamapper 0.2.3 → 0.2.4

data/lib/data_mapper/embedded_value.rb

@@ -1,27 +1,67 @@
 module DataMapper
   
   class EmbeddedValue
+    EMBEDDED_PROPERTIES = []
     
     def initialize(instance)
       @instance = instance
+      @container_prefix = ''
+
+      # force lazy load on access to any lazy-loaded embed property
+      @instance.lazy_load!(*self.class::EMBEDDED_PROPERTIES) # if @container_lazy
+    end
+
+    def self.inherited(base)
+      base.const_set('EMBEDDED_PROPERTIES', [])
     end
     
+    # add an embedded property
     def self.property(name, type, options = {})
-      mapping = database.schema[containing_class].add_column(name, type, options)
-      define_property_getter(name, mapping)
-      define_property_setter(name, mapping)
+      # set lazy option on the mapping if defined in the embed block
+      options[:lazy] ||= @container_lazy
+
+      visibility_options = [:public, :protected, :private]
+      reader_visibility = options[:reader] || options[:accessor] || @container_reader_visibility
+      writer_visibility = options[:writer] || options[:accessor] || @container_writer_visibility
+      writer_visibility = :protected if options[:protected]
+      writer_visibility = :private if options[:private]
+
+      raise(ArgumentError.new, "property visibility must be :public, :protected, or :private") unless visibility_options.include?(reader_visibility) && visibility_options.include?(writer_visibility)
+
+      mapping = database.schema[containing_class].add_column("#{@container_prefix}#{name}", type, options)
+
+      self::EMBEDDED_PROPERTIES << "#{@container_prefix}#{name}"
+      define_property_getter(name, mapping, reader_visibility)
+      define_property_setter(name, mapping, writer_visibility)
     end
     
-    def self.define_property_getter(name, mapping)
+    # define embedded property getters
+    def self.define_property_getter(name, mapping, visibility = :public)
+      # add convenience method on non-embedded base for #update_attributes
+      self.containing_class.property_getter(mapping, visibility)
+
+      # add the method on the embedded class
       class_eval <<-EOS
+        #{visibility.to_s}
         def #{name}
           @instance.instance_variable_get(#{mapping.instance_variable_name.inspect})
         end
       EOS
+
+      # add a shortcut boolean? method if applicable (ex: activated?)
+      if mapping.type == :boolean
+        class_eval("alias #{name}? #{name}")
+      end
     end
     
-    def self.define_property_setter(name, mapping)
+    # define embedded property setters
+    def self.define_property_setter(name, mapping, visibility = :public)
+      # add convenience method on non-embedded base for #update_attributes
+      self.containing_class.property_setter(mapping, visibility)
+
+      # add the method on the embedded class
       class_eval <<-EOS
+        #{visibility.to_s}
         def #{name.to_s.sub(/\?$/, '')}=(value)
           @instance.instance_variable_set(#{mapping.instance_variable_name.inspect}, value)
         end
@@ -36,21 +76,25 @@ module DataMapper
       end
     end
     
-    def self.define(container, class_or_name, &block)
-       embedded_class, embedded_class_name, accessor_name = nil
+    def self.define(container, name, options, &block)
+      embedded_class, embedded_class_name, accessor_name = nil
 
-      if class_or_name.kind_of?(Class)
-        embedded_class = class_or_name
-        embedded_class_name = class_or_name.name.split('::').last
-        accessor_name = Inflector.underscore(embedded_class_name)
-      else
-        accessor_name = class_or_name.to_s
-        embedded_class_name = Inflector.camelize(accessor_name)
-        embedded_class = Class.new(EmbeddedValue)
-        container.const_set(embedded_class_name, embedded_class) unless container.const_defined?(embedded_class_name)
+      accessor_name = name.to_s
+      embedded_class_name = Inflector.camelize(accessor_name)
+      embedded_class = Class.new(EmbeddedValue)
+      container.const_set(embedded_class_name, embedded_class) unless container.const_defined?(embedded_class_name)
+
+      if options[:prefix]
+        container_prefix = options[:prefix].kind_of?(String) ? options[:prefix] : "#{accessor_name}_"
+        embedded_class.instance_variable_set('@container_prefix', container_prefix)
       end
 
       embedded_class.instance_variable_set('@containing_class', container)
+
+      embedded_class.instance_variable_set('@container_lazy', !!options[:lazy])
+      embedded_class.instance_variable_set('@container_reader_visibility', options[:reader] || options[:accessor] || :public)
+      embedded_class.instance_variable_set('@container_writer_visibility', options[:writer] || options[:accessor] || :public)
+
       embedded_class.class_eval(&block) if block_given?
 
       container.class_eval <<-EOS
@@ -62,4 +106,4 @@ module DataMapper
     
   end
   
-end # module DataMapper
+end # module DataMapper

data/lib/data_mapper/property.rb

@@ -0,0 +1,4 @@
+module DataMapper
+  class Property
+  end
+end

data/lib/data_mapper/support/active_record_impersonation.rb

@@ -8,11 +8,13 @@ module DataMapper
       end
       
       def save
-        session.save(self)
+        database_context.save(self)
       end
       
       def reload!
-        session.first(self.class, key, :select => original_values.keys, :reload => true)
+        database_context.first(self.class, key, :select => original_values.keys, :reload => true)
+        self.loaded_associations.each { |association| association.reload! }
+        self
       end
       
       def reload
@@ -20,12 +22,12 @@ module DataMapper
       end
       
       def destroy!
-        session.destroy(self)
+        database_context.destroy(self)
       end
       
       module ClassMethods
         
-        def find_or_create(search_attributes, create_attributes = nil)
+        def find_or_create(search_attributes, create_attributes = {})
           first(search_attributes) || create(search_attributes.merge(create_attributes))
         end
         
@@ -70,8 +72,14 @@ module DataMapper
           instance.save
           instance
         end
+        
+        def create!(attributes)
+          instance = self.new(attributes)
+          raise InvalidRecord.new(instance) unless instance.save
+          instance
+        end
       end
     end
     
   end
-end
+end

data/lib/data_mapper/support/errors.rb

@@ -0,0 +1,5 @@
+module DataMapper
+  
+  class InvalidRecord < StandardError; end
+  
+end

data/lib/data_mapper/support/serialization.rb

@@ -14,7 +14,7 @@ module DataMapper
         
         YAML::quick_emit( object_id, opts ) do |out|
           out.map(nil, to_yaml_style ) do |map|
-            session.table(self).columns.each do |column|
+            database_context.table(self).columns.each do |column|
               lazy_load!(column.name) if column.lazy?
               value = instance_variable_get(column.instance_variable_name)
               map.add(column.to_s, value.is_a?(Class) ? value.to_s : value)
@@ -28,9 +28,13 @@ module DataMapper
       end
       
       def to_xml
+        to_xml_document.to_s
+      end
+      
+      def to_xml_document
         doc = REXML::Document.new
         
-        table = session.table(self.class)
+        table = database_context.table(self.class)
         root = doc.add_element(Inflector.underscore(self.class.name))
         
         key_attribute = root.attributes << REXML::Attribute.new(table.key.to_s, key)
@@ -49,11 +53,11 @@ module DataMapper
           node << REXML::Text.new(copy_frozen_value(value).to_s) unless value.nil?
         end
         
-        doc.to_s
+        doc
       end
       
       def to_json(*a)
-        table = session.table(self.class)
+        table = database_context.table(self.class)
         
         result = '{ '
         

data/lib/data_mapper/validatable_extensions/errors.rb

@@ -0,0 +1,12 @@
+module Validatable
+  class Errors
+    def on(attribute)
+      raw(attribute)
+    end
+  
+    def full_messages
+      errors.values.flatten.compact
+    end
+
+  end
+end

data/lib/data_mapper/validatable_extensions/macros.rb

@@ -0,0 +1,7 @@
+module Validatable
+  module Macros
+    def validates_uniqueness_of(*args)
+      add_validations(args, ValidatesUniquenessOf)
+    end
+  end
+end

data/lib/data_mapper/validatable_extensions/validatable_instance_methods.rb

@@ -0,0 +1,62 @@
+# = Validations
+# DataMapper uses the 'Validatable' gem to validate models.
+# 
+# Example:
+#   class Person < DataMapper::Base
+#     property :name, :string
+#     property :email, :string
+#     property :password, :string
+#
+#     validates_presence_of :name, :email
+#     validates_length_of :password, :minimum => 6, :on => :create
+#     validates_format_of :email, :with => :email_address, :message => 'Please provide a valid email address.'
+#   end
+#
+#   p = Person.new
+#   p.valid? #=> false
+#   p.errors.full_messages #=> ["Email must not be blank", "Please provide a valid email address.", "Name must not be blank"]
+#
+#   p.save #=> false
+#   p.errors.full_messages #=> ["Password must be more than 5 characters long", "Email must not be blank", 
+#                                  "Please provide a valid email address.", "Name must not be blank"]
+#   
+#
+
+module Validatable
+  alias_method :valid_in_all_cases?, :valid? #:nodoc:
+
+  # Returns true if no errors were added otherwise false. Only executes validations that have no :groups option specified
+  def valid?(event = :validate)
+    validate_recursively(event, Set.new)
+  end
+  
+  #TODO should callbacks really affect the flow? shouldn't validations themselves do that?
+  def validate_recursively(event, cleared) #:nodoc:
+    return true if cleared.include?(self)
+    cleared << self
+    
+    self.class.callbacks.execute(:before_validation, self)
+
+    # Validatable clears the errors list when running valid_for_some_group?, so we save general errors
+    # and then merge them back in after we've validated for events
+    generally_valid = valid_for_group?(nil)
+    general_errors = self.errors.errors.dup
+    
+    if respond_to?(:"valid_for_#{event}?")
+      valid_for_events = send(:"valid_for_#{event}?")
+      self.errors.errors.merge!(general_errors) {|key, val1, val2| val1+val2 }
+      return false unless generally_valid && valid_for_events
+    end
+    
+    return false unless generally_valid
+    
+    if self.respond_to?(:loaded_associations)
+      return false unless self.loaded_associations.all? do |association|
+        association.validate_recursively(event, cleared)
+      end
+    end
+    
+    self.class.callbacks.execute(:after_validation, self)
+    return true
+  end
+end

data/lib/data_mapper/validatable_extensions/validation_base.rb

@@ -0,0 +1,18 @@
+module Validatable
+  class ValidationBase
+    alias_method :old_init, :initialize
+  
+    DEFAULT_EVENTS = [:validate, :create, :save, :update]
+
+    def initialize(klass, attribute, options={})
+      events = [options.delete(:on)].flatten.compact + [options.delete(:event)].flatten.compact
+      raise ArgumentError.new("Events must be one of #{DEFAULT_EVENTS.inspect}") unless (events & DEFAULT_EVENTS).size == events.size
+      options[:groups] ||= events unless events.empty? ### <- Danger will robinson
+      old_init(klass, attribute, options)
+    end
+  
+    def humanized_attribute
+      @humanized_attribute ||= Inflector.humanize(self.attribute.to_s)
+    end
+  end
+end

data/lib/data_mapper/validatable_extensions/validations/formats/email.rb

@@ -0,0 +1,43 @@
+module Validatable
+  module Helpers #:nodoc:
+    module Formats #:nodoc:
+      
+      # Allows you to validate fields as email addresses
+      #   validates_format_of :email_field, :with => :email_address
+
+      module Email
+          
+          def self.included(base)
+            base::FORMATS.merge!( :email_address => [ EmailAddress, 
+                                  lambda { |attribute| lambda { "%s is not a valid email address".t(self.send(attribute)) } }] )
+          end
+          
+          EmailAddress = begin
+            alpha = "a-zA-Z"
+            digit = "0-9"
+            atext = "[#{alpha}#{digit}\!\#\$\%\&\'\*+\/\=\?\^\_\`\{\|\}\~\-]"
+            dot_atom_text = "#{atext}+([.]#{atext}*)*"
+            dot_atom = "#{dot_atom_text}"
+            qtext = '[^\\x0d\\x22\\x5c\\x80-\\xff]'
+            text = "[\\x01-\\x09\\x11\\x12\\x14-\\x7f]"
+            quoted_pair = "(\\x5c#{text})"
+            qcontent = "(?:#{qtext}|#{quoted_pair})"
+            quoted_string = "[\"]#{qcontent}+[\"]"
+            atom = "#{atext}+"
+            word = "(?:#{atom}|#{quoted_string})"
+            obs_local_part = "#{word}([.]#{word})*"
+            local_part = "(?:#{dot_atom}|#{quoted_string}|#{obs_local_part})"
+            no_ws_ctl = "\\x01-\\x08\\x11\\x12\\x14-\\x1f\\x7f"    
+            dtext = "[#{no_ws_ctl}\\x21-\\x5a\\x5e-\\x7e]"
+            dcontent = "(?:#{dtext}|#{quoted_pair})"
+            domain_literal = "\\[#{dcontent}+\\]"
+            obs_domain = "#{atom}([.]#{atom})*"
+            domain = "(?:#{dot_atom}|#{domain_literal}|#{obs_domain})"
+            addr_spec = "#{local_part}\@#{domain}"
+            pattern = /^#{addr_spec}$/
+          end
+          
+      end
+    end
+  end
+end

data/lib/data_mapper/validatable_extensions/validations/validates_acceptance_of.rb

@@ -0,0 +1,7 @@
+module Validatable
+  class ValidatesAcceptanceOf < ValidationBase
+    def message(instance)
+      super || '%s must be accepted'.t(humanized_attribute)
+    end
+  end
+end

data/lib/data_mapper/validatable_extensions/validations/validates_confirmation_of.rb

@@ -0,0 +1,7 @@
+module Validatable
+  class ValidatesConfirmationOf < ValidationBase
+    def message(instance)
+      super || "%s does not match the confirmation".t(humanized_attribute)
+    end
+  end
+end

data/lib/data_mapper/validatable_extensions/validations/validates_each.rb

@@ -0,0 +1,7 @@
+module Validatable
+  class ValidatesEach < ValidationBase
+    def message(instance)
+      super || '%s is invalid'.t(humanized_attribute)
+    end
+  end
+end

data/lib/data_mapper/validatable_extensions/validations/validates_format_of.rb

@@ -0,0 +1,28 @@
+require File.dirname(__FILE__) + '/formats/email.rb'
+
+module Validatable
+  
+  class ValidatesFormatOf < ValidationBase
+    FORMATS = {}
+    
+    include Validatable::Helpers::Formats::Email
+
+    def initialize(klass, attribute, options={})
+      super
+      if with.is_a? Symbol
+        self.with = if FORMATS[with].is_a? Array
+          @message = (FORMATS[with][1].respond_to?(:call) ? FORMATS[with][1].call(attribute) : FORMATS[with][1]) unless @message
+          FORMATS[with][0]
+        else
+          FORMATS[with]
+        end
+      end
+    end
+    
+    def message(instance)
+      super || '%s is invalid'.t(humanized_attribute)
+    end
+
+  end
+
+end

data/lib/data_mapper/validatable_extensions/validations/validates_length_of.rb

@@ -0,0 +1,15 @@
+module Validatable
+  class ValidatesLengthOf < ValidationBase
+     def message(instance)
+       super || unless minimum.nil?
+         '%s must be more than %d characters long'.t(humanized_attribute, minimum-1)
+       else unless maximum.nil?
+         '%s must be less than %d characters long'.t(humanized_attribute, maximum+1)
+       else unless is.nil?
+         '%s must be %d characters long'.t(humanized_attribute, is)
+       else unless within.nil?
+         '%s must be between %d and %d characters long'.t(humanized_attribute, within.first, within.last)
+       end;end;end;end
+     end
+   end
+ end

data/lib/data_mapper/validatable_extensions/validations/validates_numericality_of.rb

@@ -0,0 +1,7 @@
+module Validatable
+  class ValidatesNumericalityOf < ValidationBase
+    def message(instance)
+      super || '%s must be a number'.t(humanized_attribute)
+    end
+  end
+end

data/lib/data_mapper/validatable_extensions/validations/validates_presence_of.rb

@@ -0,0 +1,7 @@
+module Validatable
+  class ValidatesPresenceOf < ValidationBase
+    def message(instance)
+      super || "%s must not be blank".t(humanized_attribute)
+    end
+  end
+end

data/lib/data_mapper/validatable_extensions/validations/validates_true_for.rb

@@ -0,0 +1,7 @@
+module Validatable
+  class ValidatesTrueFor < ValidationBase
+    def message(instance)
+      super || '%s must be true'.t(humanized_attribute)
+    end
+  end
+end

data/lib/data_mapper/validatable_extensions/validations/validates_uniqueness_of.rb

@@ -0,0 +1,33 @@
+module Validatable
+  class ValidatesUniquenessOf < ValidationBase
+    option :scope, :allow_nil, :case_sensitive
+
+    def message(instance)
+      super || '%s has already been taken'.t(humanized_attribute)
+    end
+    
+    def case_sensitive?
+      case_sensitive
+    end
+    
+    def valid?(instance)
+      value = instance.send(self.attribute)
+      return true if allow_nil && value.nil?
+      
+      finder_options = if case_sensitive?
+        { self.attribute => value }
+      else
+        { self.attribute.like => value }
+      end
+      
+      if scope
+        scope_value = instance.send(scope)
+        finder_options.merge! scope => scope_value
+      end
+      
+      finder_options.merge!({ instance.database_context.table(instance.class).key.name.not => instance.key }) unless instance.new_record?
+      instance.database_context.first(instance.class, finder_options).nil?
+    end  
+  end
+  
+end

data/lib/data_mapper/validations.rb

@@ -0,0 +1,20 @@
+Dir[File.dirname(__FILE__) + "/validatable_extensions/**/*.rb"].each do |path|
+  require path
+end
+
+#--
+# TODO:
+#   implement alias_option method for all validations (so we can set :with == :as)
+#   make validations orthogonal with allow_nil default to true
+#
+module DataMapper
+  module Validations
+      
+    def self.included(base) #:nodoc:
+      base.class_eval do
+        include Validatable
+      end
+    end
+    
+  end
+end

data/lib/data_mapper.rb

@@ -20,57 +20,62 @@ require 'rubygems'
 require 'yaml'
 require 'set'
 require 'fastthread'
+require 'validatable'
 require 'data_mapper/support/blank'
 require 'data_mapper/support/enumerable'
 require 'data_mapper/support/symbol'
 require 'data_mapper/support/string'
 require 'data_mapper/support/silence'
 require 'data_mapper/support/inflector'
+require 'data_mapper/support/errors'
 require 'data_mapper/database'
 require 'data_mapper/base'
 
-# This block of code is for compatibility with Ruby On Rails' or Merb's database.yml
-# file, allowing you to simply require the data_mapper.rb in your
-# Rails application's environment.rb to configure the DataMapper.
-unless defined?(DM_APP_ROOT)
-  application_root, application_environment = *if defined?(MERB_ROOT)
-    [MERB_ROOT, MERB_ENV]
-  elsif defined?(RAILS_ROOT)
-    [RAILS_ROOT, RAILS_ENV]
-  end
+begin
+  # This block of code is for compatibility with Ruby On Rails' or Merb's database.yml
+  # file, allowing you to simply require the data_mapper.rb in your
+  # Rails application's environment.rb to configure the DataMapper.
+  unless defined?(DM_APP_ROOT)
+    application_root, application_environment = *if defined?(RAILS_ROOT)
+      [RAILS_ROOT, RAILS_ENV]
+    end
   
-  DM_APP_ROOT = application_root || Dir::pwd
+    DM_APP_ROOT = application_root || Dir::pwd
   
-  if application_root && File.exists?(application_root + '/config/database.yml')
+    if application_root && File.exists?(application_root + '/config/database.yml')
 
-    database_configurations = YAML::load_file(application_root + '/config/database.yml')
-    current_database_config = database_configurations[application_environment] || database_configurations[application_environment.to_sym]
+      database_configurations = YAML::load_file(application_root + '/config/database.yml')
+      current_database_config = database_configurations[application_environment] || database_configurations[application_environment.to_sym]
     
-    config = lambda { |key| current_database_config[key.to_s] || current_database_config[key] }
+      config = lambda { |key| current_database_config[key.to_s] || current_database_config[key] }
     
-    default_database_config = {
-      :adapter  => config[:adapter],
-      :host     => config[:host],
-      :database => config[:database],
-      :username => config[:username],
-      :password => config[:password]
-    }
+      default_database_config = {
+        :adapter  => config[:adapter],
+        :host     => config[:host],
+        :database => config[:database],
+        :username => config[:username],
+        :password => config[:password],
+        :socket => config[:socket]
+      }
   
-    DataMapper::Database.setup(default_database_config)
+      DataMapper::Database.setup(default_database_config)
     
-  elsif application_root && FileTest.directory?(application_root + '/config')
+    elsif application_root && FileTest.directory?(application_root + '/config')
     
-    %w(development testing production).map do |environment|
-      <<-EOS.margin
-        #{environment}:
-          adapter: mysql
-          username: root
-          password:
-          host: localhost
-          database: #{File.dirname(DM_APP_ROOT).split('/').last}_#{environment}
-      EOS
-    end
+      %w(development testing production).map do |environment|
+        <<-EOS.margin
+          #{environment}:
+            adapter: mysql
+            username: root
+            password:
+            host: localhost
+            database: #{File.dirname(DM_APP_ROOT).split('/').last}_#{environment}
+        EOS
+      end
     
-    #File::open(application_root + '/config/database.yml')
+      #File::open(application_root + '/config/database.yml')
+    end
   end
+rescue Exception
+  warn "Could not connect to database specified by database.yml."
 end