dm-core 0.9.11 → 0.10.0

data/lib/dm-core/associations/relationship_chain.rb

@@ -1,81 +0,0 @@
-module DataMapper
-  module Associations
-    class RelationshipChain < Relationship
-      OPTIONS = [
-        :repository_name, :near_relationship_name, :remote_relationship_name,
-        :child_model, :parent_model, :parent_key, :child_key,
-        :min, :max
-      ]
-
-      undef_method :get_parent
-      undef_method :attach_parent
-
-      # @api private
-      def child_model
-        near_relationship.child_model
-      end
-
-      # @api private
-      def get_children(parent, options = {}, finder = :all, *args)
-        query = @query.merge(options).merge(child_key.to_query(parent_key.get(parent)))
-
-        query[:links]  = links
-        query[:unique] = true
-
-        with_repository(parent) do
-          results = grandchild_model.send(finder, *(args << query))
-          # FIXME: remove the need for the uniq.freeze
-          finder == :all ? (@mutable ? results : results.freeze) : results
-        end
-      end
-
-      private
-
-      # @api private
-      def initialize(options)
-        if (missing_options = OPTIONS - [ :min, :max ] - options.keys ).any?
-          raise ArgumentError, "The options #{missing_options * ', '} are required", caller
-        end
-
-        @repository_name          = options.fetch(:repository_name)
-        @near_relationship_name   = options.fetch(:near_relationship_name)
-        @remote_relationship_name = options.fetch(:remote_relationship_name)
-        @child_model              = options.fetch(:child_model)
-        @parent_model             = options.fetch(:parent_model)
-        @parent_properties        = options.fetch(:parent_key)
-        @child_properties         = options.fetch(:child_key)
-        @mutable                  = options.delete(:mutable) || false
-
-        @name        = near_relationship.name
-        @query       = options.reject{ |key,val| OPTIONS.include?(key) }
-        @extra_links = []
-        @options     = options
-      end
-
-      # @api private
-      def near_relationship
-        parent_model.relationships[@near_relationship_name]
-      end
-
-      # @api private
-      def links
-        if remote_relationship.kind_of?(RelationshipChain)
-          remote_relationship.send(:links) + [ remote_relationship.send(:near_relationship) ]
-        else
-          [ remote_relationship ]
-        end
-      end
-
-      # @api private
-      def remote_relationship
-        near_relationship.child_model.relationships[@remote_relationship_name] ||
-          near_relationship.child_model.relationships[@remote_relationship_name.to_s.singularize.to_sym]
-      end
-
-      # @api private
-      def grandchild_model
-        Class === @child_model ? @child_model : (Class === @parent_model ? @parent_model.find_const(@child_model) : Object.find_const(@child_model))
-      end
-    end # class Relationship
-  end # module Associations
-end # module DataMapper

data/lib/dm-core/auto_migrations.rb

@@ -1,105 +0,0 @@
-# TODO: move to dm-more/dm-migrations
-
-module DataMapper
-  class AutoMigrator
-    ##
-    # Destructively automigrates the data-store to match the model.
-    # First migrates all models down and then up.
-    # REPEAT: THIS IS DESTRUCTIVE
-    #
-    # @param Symbol repository_name the repository to be migrated
-    def self.auto_migrate(repository_name = nil, *descendants)
-      auto_migrate_down(repository_name, *descendants)
-      auto_migrate_up(repository_name, *descendants)
-    end
-
-    ##
-    # Destructively automigrates the data-store down
-    # REPEAT: THIS IS DESTRUCTIVE
-    #
-    # @param Symbol repository_name the repository to be migrated
-    # @calls DataMapper::Resource#auto_migrate_down!
-    # @api private
-    def self.auto_migrate_down(repository_name = nil, *descendants)
-      descendants = DataMapper::Resource.descendants.to_a if descendants.empty?
-      descendants.reverse.each do |model|
-        model.auto_migrate_down!(repository_name)
-      end
-    end
-
-    ##
-    # Automigrates the data-store up
-    #
-    # @param Symbol repository_name the repository to be migrated
-    # @calls DataMapper::Resource#auto_migrate_up!
-    # @api private
-    def self.auto_migrate_up(repository_name = nil, *descendants)
-      descendants = DataMapper::Resource.descendants.to_a if descendants.empty?
-      descendants.each do |model|
-        model.auto_migrate_up!(repository_name)
-      end
-    end
-
-    ##
-    # Safely migrates the data-store to match the model
-    # preserving data already in the data-store
-    #
-    # @param Symbol repository_name the repository to be migrated
-    # @calls DataMapper::Resource#auto_upgrade!
-    def self.auto_upgrade(repository_name = nil)
-      DataMapper::Resource.descendants.each do |model|
-        model.auto_upgrade!(repository_name)
-      end
-    end
-  end # class AutoMigrator
-
-  module AutoMigrations
-    ##
-    # Destructively automigrates the data-store to match the model
-    # REPEAT: THIS IS DESTRUCTIVE
-    #
-    # @param Symbol repository_name the repository to be migrated
-    def auto_migrate!(repository_name = self.repository_name)
-      auto_migrate_down!(repository_name)
-      auto_migrate_up!(repository_name)
-    end
-
-    ##
-    # Destructively migrates the data-store down, which basically
-    # deletes all the models.
-    # REPEAT: THIS IS DESTRUCTIVE
-    #
-    # @param Symbol repository_name the repository to be migrated
-    # @api private
-    def auto_migrate_down!(repository_name = self.repository_name)
-      # repository_name ||= default_repository_name
-      repository(repository_name) do |r|
-        r.adapter.destroy_model_storage(r, self.base_model)
-      end
-    end
-
-    ##
-    # Auto migrates the data-store to match the model
-    #
-    # @param Symbol repository_name the repository to be migrated
-    # @api private
-    def auto_migrate_up!(repository_name = self.repository_name)
-      repository(repository_name) do |r|
-        r.adapter.create_model_storage(r, self.base_model)
-      end
-    end
-
-    ##
-    # Safely migrates the data-store to match the model
-    # preserving data already in the data-store
-    #
-    # @param Symbol repository_name the repository to be migrated
-    def auto_upgrade!(repository_name = self.repository_name)
-      repository(repository_name) do |r|
-        r.adapter.upgrade_model_storage(r, self)
-      end
-    end
-
-    Model.send(:include, self)
-  end # module AutoMigrations
-end # module DataMapper

data/lib/dm-core/dependency_queue.rb

@@ -1,32 +0,0 @@
-module DataMapper
-  ##
-  #
-  # DataMapper's DependencyQueue is used to store callbacks for classes which
-  # may or may not be loaded already.
-  #
-  class DependencyQueue
-    def initialize
-      @dependencies = {}
-    end
-
-    def add(class_name, &callback)
-      @dependencies[class_name] ||= []
-      @dependencies[class_name] << callback
-      resolve!
-    end
-
-    def resolve!
-      @dependencies.each do |class_name, callbacks|
-        begin
-          klass = Object.find_const(class_name)
-          callbacks.each do |callback|
-            callback.call(klass)
-          end
-          callbacks.clear
-        rescue NameError
-        end
-      end
-    end
-
-  end # class DependencyQueue
-end # module DataMapper

data/lib/dm-core/hook.rb

@@ -1,11 +0,0 @@
-module DataMapper
-  module Hook
-    def self.included(model)
-      model.class_eval <<-EOS, __FILE__, __LINE__
-        include Extlib::Hook
-        register_instance_hooks :save, :create, :update, :destroy
-      EOS
-    end
-  end
-  DataMapper::Resource.append_inclusions Hook
-end # module DataMapper

data/lib/dm-core/is.rb

@@ -1,16 +0,0 @@
-module DataMapper
-  module Is
-
-    def is(plugin, *pars, &block)
-      generator_method = "is_#{plugin}".to_sym
-
-      if self.respond_to?(generator_method)
-        self.send(generator_method, *pars, &block)
-      else
-        raise PluginNotFoundError, "could not find plugin named #{plugin}"
-      end
-    end
-
-    Model.send(:include, self)
-  end # module Is
-end # module DataMapper

data/lib/dm-core/logger.rb

@@ -1,232 +0,0 @@
-require "time" # httpdate
-# ==== Public DataMapper Logger API
-#
-# Logger taken from Merb :)
-#
-# To replace an existing logger with a new one:
-#   DataMapper.logger.set_log(log{String, IO},level{Symbol, String})
-#
-# Available logging levels are:
-#   :off, :fatal, :error, :warn, :info, :debug
-#
-# Logging via:
-#   DataMapper.logger.fatal(message<String>)
-#   DataMapper.logger.error(message<String>)
-#   DataMapper.logger.warn(message<String>)
-#   DataMapper.logger.info(message<String>)
-#   DataMapper.logger.debug(message<String>)
-#
-# Flush the buffer to
-#   DataMapper.logger.flush
-#
-# Remove the current log object
-#   DataMapper.logger.close
-#
-# ==== Private DataMapper Logger API
-#
-# To initialize the logger you create a new object, proxies to set_log.
-#   DataMapper::Logger.new(log{String, IO}, level{Symbol, String})
-#
-# Logger will not create the file until something is actually logged
-# This avoids file creation on DataMapper init when it creates the
-# default logger.
-module DataMapper
-
-  class << self #:nodoc:
-    attr_accessor :logger
-  end
-
-  class Logger
-
-    attr_accessor :aio
-    attr_accessor :delimiter
-    attr_reader   :level
-    attr_reader   :buffer
-    attr_reader   :log
-
-    # @note
-    #   Ruby (standard) logger levels:
-    #     off:   absolutely nothing
-    #     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
-    #
-    #   DataMapper::Logger::LEVELS[:off, :fatal, :error, :warn, :info, :debug]
-    LEVELS =
-    {
-      :off   => 99999,
-      :fatal => 7,
-      :error => 6,
-      :warn  => 4,
-      :info  => 3,
-      :debug => 0
-    }
-
-    def level=(new_level)
-      @level = LEVELS[new_level.to_sym]
-      reset_methods(:close)
-    end
-
-    private
-
-    # The idea here is that instead of performing an 'if' conditional check on
-    # each logging we do it once when the log object is setup
-    def set_write_method
-      @log.instance_eval do
-
-        # Determine if asynchronous IO can be used
-        def aio?
-          @aio = !RUBY_PLATFORM.match(/java|mswin/) &&
-          !(@log == STDOUT) &&
-          @log.respond_to?(:write_nonblock)
-        end
-
-        # Define the write method based on if aio an be used
-        undef write_method if defined? write_method
-        if aio?
-          alias :write_method :write_nonblock
-        else
-          alias :write_method :write
-        end
-      end
-    end
-
-    def initialize_log(log)
-      close if @log # be sure that we don't leave open files laying around.
-      @log = log || "log/dm.log"
-    end
-
-    def reset_methods(o_or_c)
-      if o_or_c == :open
-        alias internal_push push_opened
-      elsif o_or_c == :close
-        alias internal_push push_closed
-      end
-    end
-
-    def push_opened(string)
-      message = Time.now.httpdate
-      message << delimiter
-      message << string
-      message << "\n" unless message[-1] == ?\n
-      @buffer << message
-      flush # Force a flush for now until we figure out where we want to use the buffering.
-    end
-
-    def push_closed(string)
-      unless @log.respond_to?(:write)
-        log = Pathname(@log)
-        log.dirname.mkpath
-        @log = log.open('a')
-        @log.sync = true
-      end
-      set_write_method
-      reset_methods(:open)
-      push(string)
-    end
-
-    alias internal_push push_closed
-
-    def prep_msg(message, level)
-      level << delimiter << message
-    end
-
-    public
-
-    # To initialize the logger you create a new object, proxies to set_log.
-    #   DataMapper::Logger.new(log{String, IO},level{Symbol, String})
-    #
-    # @param log<IO,String>        either an IO object or a name of a logfile.
-    # @param log_level<String>     the message string to be logged
-    # @param delimiter<String>     delimiter to use between message sections
-    # @param log_creation<Boolean> log that the file is being created
-    def initialize(*args)
-      set_log(*args)
-    end
-
-    # To replace an existing logger with a new one:
-    #   DataMapper.logger.set_log(log{String, IO},level{Symbol, String})
-    #
-    # @param log<IO,String>        either an IO object or a name of a logfile.
-    # @param log_level<Symbol>     a symbol representing the log level from
-    #   {:off, :fatal, :error, :warn, :info, :debug}
-    # @param delimiter<String>     delimiter to use between message sections
-    # @param log_creation<Boolean> log that the file is being created
-    def set_log(log, log_level = :off, delimiter = " ~ ", log_creation = false)
-      delimiter    ||= " ~ "
-
-      if log_level && LEVELS[log_level.to_sym]
-        self.level = log_level.to_sym
-      else
-        self.level = :debug
-      end
-
-      @buffer    = []
-      @delimiter = delimiter
-
-      initialize_log(log)
-
-      DataMapper.logger = self
-
-      self.info("Logfile created") if log_creation
-    end
-
-    # Flush the entire buffer to the log object.
-    #   DataMapper.logger.flush
-    #
-    def flush
-      return unless @buffer.size > 0
-      @log.write_method(@buffer.slice!(0..-1).join)
-    end
-
-    # Close and remove the current log object.
-    #   DataMapper.logger.close
-    #
-    def close
-      flush
-      @log.close if @log.respond_to?(:close)
-      @log = nil
-    end
-
-    # Appends a string and log level to logger's buffer.
-
-    # @note
-    #   Note that the string is discarded if the string's log level less than the
-    #   logger's log level.
-    # @note
-    #   Note that if the logger is aio capable then the logger will use
-    #   non-blocking asynchronous writes.
-    #
-    # @param level<Fixnum>  the logging level as an integer
-    # @param string<String> the message string to be logged
-    def push(string)
-      internal_push(string)
-    end
-    alias << push
-
-    # Generate the following logging methods for DataMapper.logger as described
-    # in the API:
-    #  :fatal, :error, :warn, :info, :debug
-    #  :off only gets a off? method
-    LEVELS.each_pair do |name, number|
-      unless name.to_s == 'off'
-        class_eval <<-EOS, __FILE__, __LINE__
-          # DOC
-          def #{name}(message)
-            self.<<( prep_msg(message, "#{name}") ) if #{name}?
-          end
-        EOS
-      end
-
-      class_eval <<-EOS, __FILE__, __LINE__
-        # DOC
-        def #{name}?
-          #{number} >= level
-        end
-      EOS
-    end
-
-  end # class Logger
-end # module DataMapper