datamapper 0.3.2 → 0.9.3

data/lib/data_mapper/support/object.rb

@@ -1,54 +0,0 @@
-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,96 +0,0 @@
-require 'rexml/document'
-
-begin
-  require 'faster_csv'
-rescue LoadError
-  nil
-end
-
-begin
-  require 'json/ext'
-rescue LoadError
-  require 'json/pure'
-end
-
-module DataMapper
-  module Support
-    module Serialization
-      
-      def to_yaml(opts = {})
-        
-        YAML::quick_emit( object_id, opts ) do |out|
-          out.map(nil, to_yaml_style ) do |map|
-            database_context.table(self).columns.each do |column|
-              lazy_load!(column.name) if column.lazy?
-              value = get_value_for_column(column)
-              map.add(column.to_s, value.is_a?(Class) ? value.to_s : value)
-            end
-            (self.instance_variable_get("@yaml_added") || []).each do |k,v|
-              map.add(k.to_s, v)
-            end
-          end
-        end
-        
-      end
-      
-      def to_xml
-        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(xml_element_name)
-        
-        key_attribute = root.attributes << REXML::Attribute.new(table.key.to_s, key)
-        
-        # Single-quoted attributes are ugly. :p
-        # NOTE: I don't want to break existing REXML specs for everyone, so I'm
-        # overwriting REXML::Attribute#to_string just for this instance.
-        def key_attribute.to_string
-          %Q[#@expanded_name="#{to_s().gsub(/"/, '&quot;')}"] 
-        end
-        
-        table.columns.each do |column|
-          next if column.key?
-          value = get_value_for_column(column)
-          node = root.add_element(column.to_s)
-          node << REXML::Text.new(value.to_s) unless value.nil?
-        end
-        
-        doc
-      end
-      
-      def to_json(*a)
-        table = database_context.table(self.class)
-        
-        result = '{ '
-        
-        result << table.columns.map do |column|
-          "#{column.name.to_json}: #{get_value_for_column(column).to_json(*a)}"
-        end.join(', ')
-        
-        result << ' }'
-        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
-
-    end
-  end # module Support
-end # module DataMapper

data/lib/data_mapper/support/silence.rb

@@ -1,10 +0,0 @@
-module Kernel
-  def silence_warnings 
-     old_verbose, $VERBOSE = $VERBOSE, nil 
-     begin 
-       yield 
-     ensure 
-       $VERBOSE = old_verbose 
-     end 
-  end
-end

data/lib/data_mapper/support/string.rb

@@ -1,72 +0,0 @@
-module DataMapper
-  module Support
-    module String
-      
-      # I set the constant on the String itself to avoid inheritance chain lookups.
-      def self.included(base)
-        base.extend(ClassMethods)
-      end
-      
-      module ClassMethods
-        # Overwrite this method to provide your own translations.
-        def translate(value)
-          translations[value] || value
-        end
-        
-        def translations
-          @translations || @translations = {}
-        end
-      end
-      
-      def ensure_starts_with(part)
-        [0,1] == part ? self : (part + self)
-      end
-  
-      def ensure_ends_with(part)
-        [-1,1] == part ? self : (self + part)
-      end
-  
-      def ensure_wrapped_with(a, b = nil)
-        ensure_starts_with(a).ensure_ends_with(b || a)
-      end
-      
-      # Matches any whitespace (including newline) and replaces with a single space
-      # EXAMPLE:
-      #   <<QUERY.compress_lines
-      #     SELECT name
-      #     FROM users
-      #   QUERY
-      #   => "SELECT name FROM users"
-      def compress_lines(spaced = true)
-        split($/).map { |line| line.strip }.join(spaced ? ' ' : '')
-      end
-      
-      # Useful for heredocs - removes whitespace margin.
-      def margin(indicator = nil)
-        lines = self.dup.split($/)
-        
-        min_margin = 0
-        lines.each do |line|
-          if line =~ /^(\s+)/ && (min_margin == 0 || $1.size < min_margin)
-            min_margin = $1.size
-          end
-        end
-        lines.map { |line| line.sub(/^\s{#{min_margin}}/, '') }.join($/)
-      end
-      
-      # Formats String for easy translation. Replaces an arbitrary number of 
-      # values using numeric identifier replacement.
-      # 
-      #   "%s %s %s" % %w(one two three) #=> "one two three"
-      #   "%3$s %2$s %1$s" % %w(one two three) #=> "three two one"
-      def t(*values)
-        self.class::translate(self) % values
-      end
-      
-    end # module String
-  end # module Support
-end # module DataMapper
-
-class String #:nodoc:
-  include DataMapper::Support::String  
-end

data/lib/data_mapper/support/struct.rb

@@ -1,7 +0,0 @@
-class Struct
-  def attributes
-    h = {}
-    each_pair { |k,v| h[k] = v }
-    h
-  end
-end

data/lib/data_mapper/support/symbol.rb

@@ -1,82 +0,0 @@
-module DataMapper
-  module Support
-    
-    # Extends 
-    module Symbol
-      
-      class Operator
-      
-        attr_reader :value, :type, :options
-      
-        def initialize(value, type, options = nil)
-          @value, @type, @options = value, type, options
-        end
-    
-        def to_sym
-          @value
-        end
-      end
-    
-      def gt
-        Operator.new(self, :gt)
-      end
-  
-      def gte
-        Operator.new(self, :gte)
-      end
-  
-      def lt
-        Operator.new(self, :lt)
-      end
-  
-      def lte
-        Operator.new(self, :lte)
-      end
-  
-      def not
-        Operator.new(self, :not)
-      end
-  
-      def eql
-        Operator.new(self, :eql)
-      end
-  
-      def like
-        Operator.new(self, :like)
-      end
-  
-      def in
-        Operator.new(self, :in)
-      end
-
-      def to_proc
-        lambda { |value| value.send(self) }
-      end
-      
-      # Calculations:
-  
-      def count
-        Operator.new(self, :count)
-      end
-  
-      def max
-        Operator.new(self, :max)
-      end
-  
-      def avg
-        Operator.new(self, :avg)
-      end
-      
-      alias average avg
-  
-      def min
-        Operator.new(self, :min)
-      end
-      
-    end # module Symbol
-  end # module Support
-end # module DataMapper
-
-class Symbol #:nodoc:
-  include DataMapper::Support::Symbol
-end

data/lib/data_mapper/support/typed_set.rb

@@ -1,65 +0,0 @@
-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
-  def <=>(other)
-    name <=> other.name
-  end
-end

data/lib/data_mapper/types/base.rb

@@ -1,44 +0,0 @@
-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

@@ -1,34 +0,0 @@
-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