datamapper-dm-core 0.9.11 → 0.10.0

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

data/lib/dm-core/migrations/destructive_migrations.rb

@@ -1,17 +0,0 @@
-# TODO: move to dm-more/dm-migrations
-
-module DataMapper
-  module DestructiveMigrations
-    def self.included(model)
-      DestructiveMigrator.models << model
-    end
-  end # module DestructiveMigrations
-
-  class DestructiveMigrator < Migrator
-    def self.migrate(repository_name)
-      models.each do |model|
-        model.auto_migrate!
-      end
-    end
-  end # class DestructiveMigrator
-end # module DataMapper

data/lib/dm-core/migrator.rb

@@ -1,29 +0,0 @@
-# TODO: move to dm-more/dm-migrations
-
-module DataMapper
-  class Migrator
-    def self.subclasses
-      @@subclasses ||= []
-    end
-
-    def self.subclasses=(obj)
-      @@subclasses = obj
-    end
-
-    def self.inherited(klass)
-      subclasses << klass
-
-      class << klass
-        def models
-          @models ||= []
-        end
-      end
-    end
-
-    def self.migrate(repository_name)
-      subclasses.collect do |migrator|
-        migrator.migrate(repository_name)
-      end.flatten
-    end
-  end # class Migrator
-end # module DataMapper

data/lib/dm-core/scope.rb

@@ -1,58 +0,0 @@
-module DataMapper
-  module Scope
-    Model.append_extensions self
-
-    # @api private
-    def default_scope(repository_name = nil)
-      repository_name = self.default_repository_name if repository_name == :default || repository_name.nil?
-      @default_scope ||= {}
-      @default_scope[repository_name] ||= {}
-    end
-
-    # @api private
-    def query
-      scope_stack.last
-    end
-
-    protected
-
-    # @api semipublic
-    def with_scope(query)
-      # merge the current scope with the passed in query
-      with_exclusive_scope(self.query ? self.query.merge(query) : query) {|*block_args| yield(*block_args) }
-    end
-
-    # @api semipublic
-    def with_exclusive_scope(query)
-      query = DataMapper::Query.new(repository, self, query) if query.kind_of?(Hash)
-
-      scope_stack << query
-
-      begin
-        return yield(query)
-      ensure
-        scope_stack.pop
-      end
-    end
-
-    private
-
-    # @api private
-    def merge_with_default_scope(query)
-      DataMapper::Query.new(query.repository, query.model, default_scope_for_query(query)).update(query)
-    end
-
-    # @api private
-    def scope_stack
-      scope_stack_for = Thread.current[:dm_scope_stack] ||= {}
-      scope_stack_for[self] ||= []
-    end
-
-    # @api private
-    def default_scope_for_query(query)
-      repository_name = query.repository.name
-      default_repository_name = query.model.default_repository_name
-      self.default_scope(default_repository_name).merge(self.default_scope(repository_name))
-    end
-  end # module Scope
-end # module DataMapper

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

@@ -1,13 +0,0 @@
-class Array
-
-  ##
-  # atm it assumes self is an array of [key,value]-arrays
-  # this is just a better way to make hashes than Hash[*array.flatten]
-  # since you cannot flatten only one level in ruby 1.8.6
-  #
-  def to_hash
-    h = {}
-    self.each{ |k,v| h[k] = v }
-    h
-  end
-end # class Symbol

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

@@ -1,8 +0,0 @@
-module DataMapper
-  module Assertions
-    def assert_kind_of(name, value, *klasses)
-      klasses.each { |k| return if value.kind_of?(k) }
-      raise ArgumentError, "+#{name}+ should be #{klasses.map { |k| k.name } * ' or '}, but was #{value.class.name}", caller(2)
-    end
-  end
-end # module DataMapper

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

@@ -1,23 +0,0 @@
-#Some useful errors types
-module DataMapper
-  class ValidationError < StandardError; end
-
-  class ObjectNotFoundError < StandardError; end
-
-  class MaterializationError < StandardError; end
-
-  class RepositoryNotSetupError < StandardError; end
-
-  class IncompleteResourceError < StandardError; end
-
-  class PersistenceError < StandardError; end
-
-  class PluginNotFoundError < StandardError; end
-end # module DataMapper
-
-class StandardError
-  # Displays the specific error message and the backtrace associated with it.
-  def display
-    "#{message}\n\t#{backtrace.join("\n\t")}"
-  end
-end # class StandardError

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

@@ -1,11 +0,0 @@
-module Kernel
-  # Delegates to DataMapper::repository.
-  # Will not overwrite if a method of the same name is pre-defined.
-  def repository(*args)
-    if block_given?
-      DataMapper.repository(*args) { |*block_args| yield(*block_args) }
-    else
-      DataMapper.repository(*args)
-    end
-  end
-end # module Kernel

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

@@ -1,41 +0,0 @@
-class Symbol
-  def gt
-    DataMapper::Query::Operator.new(self, :gt)
-  end
-
-  def gte
-    DataMapper::Query::Operator.new(self, :gte)
-  end
-
-  def lt
-    DataMapper::Query::Operator.new(self, :lt)
-  end
-
-  def lte
-    DataMapper::Query::Operator.new(self, :lte)
-  end
-
-  def not
-    DataMapper::Query::Operator.new(self, :not)
-  end
-
-  def eql
-    DataMapper::Query::Operator.new(self, :eql)
-  end
-
-  def like
-    DataMapper::Query::Operator.new(self, :like)
-  end
-
-  def in
-    DataMapper::Query::Operator.new(self, :in)
-  end
-
-  def asc
-    DataMapper::Query::Operator.new(self, :asc)
-  end
-
-  def desc
-    DataMapper::Query::Operator.new(self, :desc)
-  end
-end # class Symbol

data/lib/dm-core/support.rb

@@ -1,7 +0,0 @@
-dir = Pathname(__FILE__).dirname.expand_path / 'support'
-
-require dir / 'array'
-require dir / 'assertions'
-require dir / 'errors'
-require dir / 'kernel'
-require dir / 'symbol'

data/lib/dm-core/type_map.rb

@@ -1,80 +0,0 @@
-# TODO: move to dm-more/dm-migrations
-
-module DataMapper
-  class TypeMap
-
-    attr_accessor :parent, :chains
-
-    def initialize(parent = nil, &blk)
-      @parent, @chains = parent, {}
-
-      blk.call(self) unless blk.nil?
-    end
-
-    def map(type)
-      @chains[type] ||= TypeChain.new
-    end
-
-    def lookup(type)
-      if type_mapped?(type)
-        lookup_from_map(type)
-      else
-        lookup_by_type(type)
-      end
-    end
-
-    def lookup_from_map(type)
-      lookup_from_parent(type).merge(map(type).translate)
-    end
-
-    def lookup_from_parent(type)
-      if !@parent.nil? && @parent.type_mapped?(type)
-        @parent[type]
-      else
-        {}
-      end
-    end
-
-    # @raise <DataMapper::TypeMap::Error> if the type is not a default primitive or has a type map entry.
-    def lookup_by_type(type)
-      raise DataMapper::TypeMap::Error.new(type) unless type.respond_to?(:primitive) && !type.primitive.nil?
-
-      lookup(type.primitive).merge(Type::PROPERTY_OPTIONS.inject({}) {|h, k| h[k] = type.send(k); h})
-    end
-
-    alias [] lookup
-
-    def type_mapped?(type)
-      @chains.has_key?(type) || (@parent.nil? ? false : @parent.type_mapped?(type))
-    end
-
-    class TypeChain
-      attr_accessor :primitive, :attributes
-
-      def initialize
-        @attributes = {}
-      end
-
-      def to(primitive)
-        @primitive = primitive
-        self
-      end
-
-      def with(attributes)
-        raise "method 'with' expects a hash" unless attributes.kind_of?(Hash)
-        @attributes.merge!(attributes)
-        self
-      end
-
-      def translate
-        @attributes.merge((@primitive.nil? ? {} : {:primitive => @primitive}))
-      end
-    end # class TypeChain
-
-    class Error < StandardError
-      def initialize(type)
-        super("Type #{type} must have a default primitive or type map entry")
-      end
-    end
-  end # class TypeMap
-end # module DataMapper

data/lib/dm-core/types.rb

@@ -1,19 +0,0 @@
-dir = Pathname(__FILE__).dirname.expand_path / 'types'
-
-require dir / 'boolean'
-require dir / 'discriminator'
-require dir / 'text'
-require dir / 'paranoid_datetime'
-require dir / 'paranoid_boolean'
-require dir / 'object'
-require dir / 'serial'
-
-unless defined?(DM)
-  DM = DataMapper::Types
-end
-
-module DataMapper
-  module Resource
-    include Types
-  end # module Resource
-end # module DataMapper

data/script/all

@@ -1,4 +0,0 @@
-#!/usr/bin/env sh
-ADAPTER=sqlite3  rake spec
-ADAPTER=mysql    rake spec
-ADAPTER=postgres rake spec