dm-core 0.10.2 → 1.0.0.rc1

data/lib/dm-core/support/local_object_space.rb

@@ -0,0 +1,12 @@
+module DataMapper
+  module LocalObjectSpace
+    def self.extended(klass)
+      (class << klass; self; end).send :attr_accessor, :hook_scopes
+      klass.hook_scopes = []
+    end
+
+    def object_by_id(object_id)
+      self.hook_scopes.detect { |object| object.object_id == object_id }
+    end
+  end
+end

data/lib/dm-core/support/logger.rb

@@ -1,13 +1,200 @@
+require "time" # httpdate
+# ==== Public Extlib Logger API
+#
+# To replace an existing logger with a new one:
+#  Extlib::Logger.set_log(log{String, IO},level{Symbol, String})
+#
+# Available logging levels are
+#   Extlib::Logger::{ Fatal, Error, Warn, Info, Debug }
+#
+# Logging via:
+#   Extlib.logger.fatal(message<String>,&block)
+#   Extlib.logger.error(message<String>,&block)
+#   Extlib.logger.warn(message<String>,&block)
+#   Extlib.logger.info(message<String>,&block)
+#   Extlib.logger.debug(message<String>,&block)
+#
+# Logging with autoflush:
+#   Extlib.logger.fatal!(message<String>,&block)
+#   Extlib.logger.error!(message<String>,&block)
+#   Extlib.logger.warn!(message<String>,&block)
+#   Extlib.logger.info!(message<String>,&block)
+#   Extlib.logger.debug!(message<String>,&block)
+#
+# Flush the buffer to
+#   Extlib.logger.flush
+#
+# Remove the current log object
+#   Extlib.logger.close
+#
+# ==== Private Extlib Logger API
+#
+# To initialize the logger you create a new object, proxies to set_log.
+#   Extlib::Logger.new(log{String, IO},level{Symbol, String})
 module DataMapper
-  class << self #:nodoc:
+
+  class << self
     attr_accessor :logger
   end
 
-  class Logger < Extlib::Logger
-    def initialize(*)
-      super
+  class Logger
+
+    attr_accessor :level
+    attr_accessor :delimiter
+    attr_accessor :auto_flush
+    attr_reader   :buffer
+    attr_reader   :log
+    attr_reader   :init_args
+
+    # ==== Notes
+    # Ruby (standard) logger levels:
+    # :fatal:: An unhandleable error that results in a program crash
+    # :error:: A handleable error condition
+    # :warn:: A warning
+    # :info:: generic (useful) information about system operation
+    # :debug:: low-level information for developers
+    Levels =
+    {
+      :fatal => 7,
+      :error => 6,
+      :warn  => 4,
+      :info  => 3,
+      :debug => 0
+    }
+
+    private
+
+    # Readies a log for writing.
+    #
+    # ==== Parameters
+    # log<IO, String>:: Either an IO object or a name of a logfile.
+    def initialize_log(log)
+      close if @log # be sure that we don't leave open files laying around.
+
+      if log.respond_to?(:write)
+        @log = log
+      elsif File.exist?(log)
+        @log = open(log, (File::WRONLY | File::APPEND))
+        @log.sync = true
+      else
+        FileUtils.mkdir_p(File.dirname(log)) unless File.directory?(File.dirname(log))
+        @log = open(log, (File::WRONLY | File::APPEND | File::CREAT))
+        @log.sync = true
+        @log.write("#{Time.now.httpdate} #{delimiter} info #{delimiter} Logfile created\n")
+      end
+    end
+
+    public
+
+    # To initialize the logger you create a new object, proxies to set_log.
+    #
+    # ==== Parameters
+    # *args:: Arguments to create the log from. See set_logs for specifics.
+    def initialize(*args)
+      @init_args = args
+      set_log(*args)
       self.auto_flush = true
       DataMapper.logger = self
     end
-  end # class Logger
-end # module DataMapper
+
+    # Replaces an existing logger with a new one.
+    #
+    # ==== Parameters
+    # log<IO, String>:: Either an IO object or a name of a logfile.
+    # log_level<~to_sym>::
+    #   The log level from, e.g. :fatal or :info. Defaults to :error in the
+    #   production environment and :debug otherwise.
+    # delimiter<String>::
+    #   Delimiter to use between message sections. Defaults to " ~ ".
+    # auto_flush<Boolean>::
+    #   Whether the log should automatically flush after new messages are
+    #   added. Defaults to false.
+    def set_log(log, log_level = nil, delimiter = " ~ ", auto_flush = false)
+      if log_level && Levels[log_level.to_sym]
+        @level = Levels[log_level.to_sym]
+      else
+        @level = Levels[:debug]
+      end
+      @buffer     = []
+      @delimiter  = delimiter
+      @auto_flush = auto_flush
+
+      initialize_log(log)
+    end
+
+    # Flush the entire buffer to the log object.
+    def flush
+      return unless @buffer.size > 0
+      @log.write(@buffer.slice!(0..-1).join)
+    end
+
+    # Close and remove the current log object.
+    def close
+      flush
+      @log.close if @log.respond_to?(:close) && !@log.tty?
+      @log = nil
+    end
+
+    # Appends a message to the log. The methods yield to an optional block and
+    # the output of this block will be appended to the message.
+    #
+    # ==== Parameters
+    # string<String>:: The message to be logged. Defaults to nil.
+    #
+    # ==== Returns
+    # String:: The resulting message added to the log file.
+    def <<(string = nil)
+      message = ""
+      message << delimiter
+      message << string if string
+      message << "\n" unless message[-1] == ?\n
+      @buffer << message
+      flush if @auto_flush
+
+      message
+    end
+    alias :push :<<
+
+    # Generate the logging methods for Extlib.logger for each log level.
+    Levels.each_pair do |name, number|
+      class_eval <<-LEVELMETHODS, __FILE__, __LINE__
+
+      # Appends a message to the log if the log level is at least as high as
+      # the log level of the logger.
+      #
+      # ==== Parameters
+      # string<String>:: The message to be logged. Defaults to nil.
+      #
+      # ==== Returns
+      # self:: The logger object for chaining.
+      def #{name}(message = nil)
+        self << message if #{number} >= level
+        self
+      end
+
+      # Appends a message to the log if the log level is at least as high as
+      # the log level of the logger. The bang! version of the method also auto
+      # flushes the log buffer to disk.
+      #
+      # ==== Parameters
+      # string<String>:: The message to be logged. Defaults to nil.
+      #
+      # ==== Returns
+      # self:: The logger object for chaining.
+      def #{name}!(message = nil)
+        self << message if #{number} >= level
+        flush if #{number} >= level
+        self
+      end
+
+      # ==== Returns
+      # Boolean:: True if this level will be logged by this logger.
+      def #{name}?
+        #{number} >= level
+      end
+      LEVELMETHODS
+    end
+
+  end
+
+end

data/lib/dm-core/support/naming_conventions.rb

@@ -28,25 +28,25 @@ module DataMapper
 
       module UnderscoredAndPluralized
         def self.call(name)
-          Extlib::Inflection.pluralize(Extlib::Inflection.underscore(name)).gsub('/', '_')
+          ActiveSupport::Inflector.pluralize(ActiveSupport::Inflector.underscore(name)).gsub('/', '_')
         end
       end # module UnderscoredAndPluralized
 
       module UnderscoredAndPluralizedWithoutModule
         def self.call(name)
-          Extlib::Inflection.pluralize(Extlib::Inflection.underscore(Extlib::Inflection.demodulize(name)))
+          ActiveSupport::Inflector.pluralize(ActiveSupport::Inflector.underscore(ActiveSupport::Inflector.demodulize(name)))
         end
       end # module UnderscoredAndPluralizedWithoutModule
 
       module Underscored
         def self.call(name)
-          Extlib::Inflection.underscore(name)
+          ActiveSupport::Inflector.underscore(name)
         end
       end # module Underscored
 
       module Yaml
         def self.call(name)
-          "#{Extlib::Inflection.pluralize(Extlib::Inflection.underscore(name))}.yaml"
+          "#{ActiveSupport::Inflector.pluralize(ActiveSupport::Inflector.underscore(name))}.yaml"
         end
       end # module Yaml
 
@@ -56,25 +56,25 @@ module DataMapper
 
       module UnderscoredAndPluralized
         def self.call(property)
-          Extlib::Inflection.pluralize(Extlib::Inflection.underscore(property.name.to_s)).gsub('/', '_')
+          ActiveSupport::Inflector.pluralize(ActiveSupport::Inflector.underscore(property.name.to_s)).gsub('/', '_')
         end
       end # module UnderscoredAndPluralized
 
       module UnderscoredAndPluralizedWithoutModule
         def self.call(property)
-          Extlib::Inflection.pluralize(Extlib::Inflection.underscore(Extlib::Inflection.demodulize(property.name.to_s)))
+          ActiveSupport::Inflector.pluralize(ActiveSupport::Inflector.underscore(ActiveSupport::Inflector.demodulize(property.name.to_s)))
         end
       end # module UnderscoredAndPluralizedWithoutModule
 
       module Underscored
         def self.call(property)
-          Extlib::Inflection.underscore(property.name.to_s)
+          ActiveSupport::Inflector.underscore(property.name.to_s)
         end
       end # module Underscored
 
       module Yaml
         def self.call(property)
-          "#{Extlib::Inflection.pluralize(Extlib::Inflection.underscore(property.name.to_s))}.yaml"
+          "#{ActiveSupport::Inflector.pluralize(ActiveSupport::Inflector.underscore(property.name.to_s))}.yaml"
         end
       end # module Yaml
 

data/lib/dm-core/support/subject.rb

@@ -0,0 +1,33 @@
+module DataMapper
+  module Subject
+    # Returns a default value of the subject for given resource
+    #
+    # When default value is a callable object, it is called with resource
+    # and subject passed as arguments.
+    #
+    # @param [Resource] resource
+    #   the model instance for which the default is to be set
+    #
+    # @return [Object]
+    #   the default value of this subject for +resource+
+    #
+    # @api semipublic
+    def default_for(resource)
+      if @default.respond_to?(:call)
+        @default.call(resource, self)
+      else
+        @default.try_dup
+      end
+    end
+
+    # Returns true if the subject has a default value
+    #
+    # @return [Boolean]
+    #   true if the subject has a default value
+    #
+    # @api semipublic
+    def default?
+      @options.key?(:default)
+    end
+  end
+end

data/lib/dm-core/type.rb

@@ -83,6 +83,10 @@ module DataMapper
   #     JSON = Json
   #   end # module Types
   # end # module DataMapper
+
+  # TODO: this is only for the backward compatibility in case someone's subclassing from one of the deprecated types
+  module Types; end
+
   class Type
     # Until cooperation of Property and Type does not change, each must
     # have a separate list of options, because plugins (ex.: dm-validations)

data/lib/dm-core/types/boolean.rb

@@ -1,3 +1,5 @@
+require 'dm-core/type'
+
 module DataMapper
   module Types
     class Boolean < Type

data/lib/dm-core/types/decimal.rb

@@ -0,0 +1,9 @@
+require 'dm-core/type'
+
+module DataMapper
+  module Types
+    class Decimal < Type
+      primitive BigDecimal
+    end # class Decimal
+  end # module Types
+end # module DataMapper

data/lib/dm-core/types/discriminator.rb

@@ -1,3 +1,5 @@
+require 'dm-core/type'
+
 module DataMapper
   module Types
     class Discriminator < Type

data/lib/dm-core/types/object.rb

@@ -1,3 +1,6 @@
+require 'dm-core/type'
+require 'dm-core/types/text'
+
 module DataMapper
   module Types
     class Object < Type

data/lib/dm-core/types/serial.rb

@@ -1,3 +1,5 @@
+require 'dm-core/type'
+
 module DataMapper
   module Types
     class Serial < Type

data/lib/dm-core/types/text.rb

@@ -1,3 +1,5 @@
+require 'dm-core/type'
+
 module DataMapper
   module Types
     class Text < Type

data/lib/dm-core/version.rb

@@ -1,3 +1,3 @@
 module DataMapper
-  VERSION = '0.10.2'.freeze
+  VERSION = '1.0.0.rc1'.freeze
 end

data/spec/public/associations/many_to_many/read_multiple_join_spec.rb

@@ -0,0 +1,67 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', 'spec_helper'))
+
+describe 'Many to Many Associations read across multiple join associations' do
+  before :all do
+    class ::User
+      include DataMapper::Resource
+
+      property :id, Serial
+
+      has n, :sales
+      has n, :sale_items, :through => :sales
+      has n, :items,      :through => :sale_items
+    end
+
+    class ::Sale
+      include DataMapper::Resource
+
+      property :id, Serial
+
+      belongs_to :user
+      has n, :sale_items
+      has n, :items, :through => :sale_items
+    end
+
+    class ::SaleItem
+      include DataMapper::Resource
+
+      property :id, Serial
+
+      belongs_to :sale
+      belongs_to :item
+    end
+
+    class ::Item
+      include DataMapper::Resource
+
+      property :id, Serial
+
+      has n, :sale_items
+    end
+  end
+
+  supported_by :all do
+    before :all do
+      @user = User.create
+      @sale = @user.sales.create
+
+      5.times { @sale.items.create }
+    end
+
+    before :all do
+      @no_join = defined?(DataMapper::Adapters::InMemoryAdapter) && @adapter.kind_of?(DataMapper::Adapters::InMemoryAdapter) ||
+                 defined?(DataMapper::Adapters::YamlAdapter)     && @adapter.kind_of?(DataMapper::Adapters::YamlAdapter)
+
+      @skip = @no_join
+    end
+
+    before do
+      pending if @skip
+    end
+
+    it 'should return all the created entries' do
+      @user.items.to_a.should == Item.all.to_a
+      @sale.items.to_a.should == Item.all.to_a
+    end
+  end
+end