datamapper 0.2.5 → 0.3.0

data/lib/data_mapper/support/object.rb

@@ -0,0 +1,54 @@
+module DataMapper
+  module Support
+    module Object
+      
+      def self.included(base)
+        
+        nested_constants = Hash.new do |h,k|
+          klass = Object
+          k.split('::').each do |c|
+            klass = klass.const_get(c)
+          end
+          h[k] = klass
+        end
+        
+        base.instance_variable_set("@nested_constants", nested_constants)
+        base.send(:include, ClassMethods)
+      end
+      
+      module ClassMethods
+        def recursive_const_get(nested_name)
+          @nested_constants[nested_name]
+        end
+      end
+    end
+  end
+end
+
+class Object #:nodoc:
+  include DataMapper::Support::Object
+end
+
+# require 'benchmark'
+# 
+# N = 1_000_000
+# 
+# puts Benchmark.measure {
+#   N.times { Object.recursive_const_get('DataMapper::Support::Object') }
+# }
+# 
+# puts Benchmark.measure {
+#   N.times {
+#     klass = Object
+#     'DataMapper::Support::Object'.split('::').each do |c|
+#       klass = klass.const_get(c)
+#     end
+#     klass  
+#   }
+# }
+# 
+# __END__
+# >>> object.rb
+# 
+#   0.910000   0.000000   0.910000 (  0.916914)
+#   6.140000   0.010000   6.150000 (  6.151984)

data/lib/data_mapper/support/serialization.rb

@@ -1,5 +1,11 @@
 require 'rexml/document'
 
+begin
+  require 'faster_csv'
+rescue LoadError
+  nil
+end
+
 begin
   require 'json/ext'
 rescue LoadError
@@ -31,11 +37,16 @@ module DataMapper
         to_xml_document.to_s
       end
       
+      def xml_element_name ## overloadable
+        Inflector.underscore(self.class.name)
+      end
+      
       def to_xml_document
         doc = REXML::Document.new
         
         table = database_context.table(self.class)
-        root = doc.add_element(Inflector.underscore(self.class.name))
+        # root = doc.add_element(Inflector.underscore(self.class.name))
+        root = doc.add_element(xml_element_name)
         
         key_attribute = root.attributes << REXML::Attribute.new(table.key.to_s, key)
         
@@ -69,6 +80,13 @@ module DataMapper
         result
       end
       
+      def to_csv(writer = "")
+        FasterCSV.generate(writer) do |csv|
+          csv << database_context.table(self.class).columns.map { |column| get_value_for_column(column) }
+        end
+        return writer
+      end
+      
       def get_value_for_column(column)
         send(column.type == :boolean ? column.name.to_s.ensure_ends_with('?') : column.name)
       end

data/lib/data_mapper/support/string.rb

@@ -41,26 +41,17 @@ module DataMapper
         split($/).map { |line| line.strip }.join(spaced ? ' ' : '')
       end
       
+      # Useful for heredocs - removes whitespace margin.
       def margin(indicator = nil)
-        target = dup
-        lines = target.split($/)
+        lines = self.dup.split($/)
         
-        if indicator.nil?
-          min_margin = nil
-          lines.each do |line|
-            if line =~ /(\s+)/ && (min_margin.nil? || $1.size < min_margin)
-              min_margin = $1.size
-            end
+        min_margin = 0
+        lines.each do |line|
+          if line =~ /^(\s+)/ && (min_margin == 0 || $1.size < min_margin)
+            min_margin = $1.size
           end
-
-          lines.map do |line|
-            line.sub(/^\s{#{min_margin}}/, '')
-          end.join($/)
-        else
-          lines.map do |line|
-            line.sub(/^.*?#{"\\" + indicator}/, '')
-          end.join($/)
         end
+        lines.map { |line| line.sub(/^\s{#{min_margin}}/, '') }.join($/)
       end
       
       # Formats String for easy translation. Replaces an arbitrary number of 

data/lib/data_mapper/support/symbol.rb

@@ -48,23 +48,11 @@ module DataMapper
       def in
         Operator.new(self, :in)
       end
-  
-      def select(klass = nil)    
-        Operator.new(self, :select, { :class => klass })
-      end
-  
-      def to_s
-        @string_form || (@string_form = id2name.freeze)
-      end
-  
+
       def to_proc
-       lambda { |value| value.send(self) }
+        lambda { |value| value.send(self) }
       end
       
-      def as_instance_variable_name
-        @instance_variable_name_form || (@instance_variable_name_form = "@#{id2name}".freeze)
-      end
-  
       # Calculations:
   
       def count
@@ -91,4 +79,4 @@ end # module DataMapper
 
 class Symbol #:nodoc:
   include DataMapper::Support::Symbol
-end
+end

data/lib/data_mapper/support/typed_set.rb

@@ -0,0 +1,68 @@
+require 'set'
+
+module DataMapper
+  module Support
+    class TypedSet
+      
+      include ::Enumerable
+      
+      def initialize(*types)
+        @types = types
+        @set = SortedSet.new
+      end
+      
+      def <<(item)
+        raise ArgumentError.new("#{item.inspect} must be a kind of: #{@types.inspect}") unless @types.any? { |type| type === item }
+        @set << item
+        return self
+      end
+      
+      def concat(values)
+        [*values].each { |item| self << item }
+        self
+      end
+      
+      def inspect
+        "#<DataMapper::Support::TypedSet#{@types.inspect}: {#{entries.inspect[1...-1]}}>"
+      end
+      
+      def each
+        @set.each { |item| yield(item) }
+      end
+      
+      def delete?(item)
+        @set.delete?(item)
+      end
+      
+      def size
+        @set.size
+      end
+      alias length size
+      
+      def empty?
+        @set.empty?
+      end
+      alias blank? empty?
+      
+      def clear
+        @set.clear
+      end
+      
+      def +(other)
+        x = self.class.new(*@types)
+        each { |entry| x << entry }
+        other.each { |entry| x << entry } unless other.blank?
+        return x
+      end
+    end
+  end
+end
+
+class Class
+  
+  include Comparable
+  
+  def <=>(other)
+    name <=> other.name
+  end
+end

data/lib/data_mapper/types/base.rb

@@ -0,0 +1,44 @@
+require 'data_mapper/validations/number_validator'
+require 'data_mapper/validations/string_validator'
+
+module DataMapper
+  module Types
+    TYPE_MAP = {}
+
+    module Base
+      module ClassMethods
+        def context(ctx)
+          contexts(ctx)
+        end
+
+        def contexts(*ctxs)
+          @contexts || @contexts = %w{__all__} << ctxs.map { |c| c.to_s }
+        end
+      end
+
+      def self.included(klass)
+        klass.extend(ClassMethods)
+      end
+
+      def do_validations
+        raise NotImplementedError.new
+      end
+
+      def valid?(context = "__all__")
+        @errors = []
+
+        if self.class.contexts.include?(context.to_s) 
+          do_validations
+
+          @errors.empty?
+        else 
+          true
+        end
+      end
+
+      def errors
+        @errors || @errors = []
+      end
+    end
+  end
+end

data/lib/data_mapper/types/string.rb

@@ -0,0 +1,34 @@
+require 'data_mapper/types/base'
+
+module DataMapper
+  module Types
+    class String < ::String
+      include Types::Base
+
+      TYPE_MAP[:string] = self
+      TYPE_MAP[::String] = self
+
+      def self.length
+        length_validator
+      end
+
+      def self.matches(regexp)
+        match_validator.matches(regexp)
+      end 
+
+      def self.length_validator
+        @length_validator ||
+          @length_validator = Validations::NumberValidator.new
+      end
+
+      def self.match_validator
+        @match_validator || @match_validator = Validations::StringValidator.new
+      end
+
+      def do_validations
+        errors.concat(self.class.length_validator.errors_for(length))
+        errors.concat(self.class.match_validator.errors_for(self))
+      end
+    end
+  end
+end

data/lib/data_mapper/validations/number_validator.rb

@@ -0,0 +1,40 @@
+require 'data_mapper/validations/validator'
+
+module DataMapper 
+  module Validations 
+    class NumberValidator < Validator
+      def <(max)
+        @max_excl = max
+      end
+
+      def <=(max)
+        @max_incl = max
+      end
+
+      def >(min)
+        @min_excl = min
+      end
+
+      def >=(min)
+        @min_incl = min
+      end
+
+      def between(range)
+        @range = range
+      end
+
+      def errors_for(target)
+        errors = []
+        error = nil
+
+        errors << Validator::Error.new(@max_excl, target) if @max_excl && target >= @max_excl
+        errors << Validator::Error.new(@max_incl, target) if @max_incl && target > @max_incl
+        errors << Validator::Error.new(@min_excl, target) if @min_excl && target <= @min_excl
+        errors << Validator::Error.new(@min_incl, target) if @min_incl && target < @min_incl
+        errors << Validator::Error.new(@range, target) if @range && ! @range.include?(target)
+
+        errors
+      end
+    end
+  end
+end

data/lib/data_mapper/validations/string_validator.rb

@@ -0,0 +1,20 @@
+require 'data_mapper/validations/validator'
+
+module DataMapper 
+  module Validations 
+    class StringValidator < Validator
+      def matches(regexp)
+        @regexp = regexp
+      end
+
+      def errors_for(target)
+        errors = []
+
+        errors << Validator::Error.new(@regexp, target) if @regexp && @regexp.match(target)
+
+        errors
+      end
+    end
+  end
+end
+

data/lib/data_mapper/validations/validator.rb

@@ -0,0 +1,13 @@
+module DataMapper 
+  module Validations 
+    class Validator
+      Error = Struct.new(:expected, :got)
+
+      def errors_for(target)
+        raise NotImplementedError.new
+      end
+    end
+  end
+end
+
+

data/performance.rb

@@ -35,7 +35,7 @@ DataMapper::Database.setup(configuration_options)
 class DMAnimal < DataMapper::Base #:nodoc:
   set_table_name 'animals'
   property :name, :string
-  property :notes, :string
+  property :notes, :text
 end
 
 class DMPerson < DataMapper::Base #:nodoc:
@@ -71,6 +71,7 @@ end
 
 class Zoo < DataMapper::Base #:nodoc:
   property :name, :string
+  property :notes, :text
   has_many :exhibits
 end
 
@@ -100,6 +101,18 @@ Benchmark::send(ENV['BM'] || :bmbm, 40) do |x|
     N.times { ARAnimal.find(1).name }
   end
   
+  x.report('ActiveRecord:id:raw_result-set') do
+    connection = ARAnimal.connection
+    
+    N.times do
+      result = connection.execute("SELECT name FROM animals WHERE id = 1")
+      result.each do |row|
+        nil
+      end
+      result.free if result.respond_to?(:free)
+    end
+  end
+  
   x.report('DataMapper:id') do
     N.times { DMAnimal[1].name }
   end
@@ -109,6 +122,18 @@ Benchmark::send(ENV['BM'] || :bmbm, 40) do |x|
       N.times { DMAnimal[1].name }
     end
   end
+    
+  x.report('DataMapper:id:raw-result-set') do
+    database.adapter.connection do |db|
+      N.times do
+        command = db.create_command("SELECT name FROM animals WHERE id = 1")
+
+        command.execute_reader do |reader|          
+          reader.each { reader.current_row }
+        end
+      end
+    end
+  end
   
   x.report('ActiveRecord:all') do
     N.times { ARZoo.find(:all).each { |a| a.name } }

data/profile_data_mapper.rb

@@ -15,7 +15,7 @@ end
 
 profile do
   1000.times do
-    database.query("SELECT * FROM zoos")
+    Zoo.all.each { |zoo| zoo.name; zoo.exhibits.entries }
   end
 end