caruby-core 1.5.5 → 2.1.1

data/lib/caruby/util/domain_extent.rb

@@ -1,46 +0,0 @@
-require 'caruby/util/collection'
-require 'caruby/util/validation'
-
-# A DomainExtent contains class-specific key => object associations.
-# The objects are created on demand and accessed by the get method.
-#
-# @example
-#   DomainExtent.new { |klass, key| key.to_s + klass.name }.get(String, 'a') #=> aString
-class DomainExtent < LazyHash
-  # Creates a new DomainExtent. The block passed to the constructor
-  # is a factory to create an object on demand, with arguments
-  # the target class and the target key. The default block is empty.
-  def initialize
-    return initialize {} unless block_given?
-    super { |klass| LazyHash.new { |key| yield klass, key } }
-  end
-
-  # Sets the factory used to create an instance of the specified class.
-  # The factory is called to create a new instance when a get operation
-  # does not yet have a key => instance association.
-  #
-  # The factory accepts a single argument, the instance key, e.g.
-  #   set_factory(MyClass) { |key| MyClass.new(key) }
-  def set_factory(klass, &factory)
-    # the current instances, if any
-    instances = fetch(klass) if has_key?(klass)
-    # make the key => instance class extent map
-    # the instance creation factory is
-    class_extent = LazyHash.new { |key| yield key }
-    # copy existing instances if necessary
-    class_extent.merge!(instances) if instances
-    # add the class => class extent association
-    self[klass] = class_extent
-  end
-
-  # Returns the domain instance of the given class for the given key.
-  # If there is nois no entry for key and the factory is set for the class,
-  # then a new object is created on demand.
-  def get(klass, key)
-    raise RuntimeError.new("Invalid target class: #{klass}") unless klass.is_a?(Class)
-    raise RuntimeError.new("Missing target key value") if key.nil?
-    # the class extent hash is created on demand if necessary.
-    # the instance is created on demand if there is a factory for the class.
-    self[klass][key]
-  end
-end

data/lib/caruby/util/file_separator.rb

@@ -1,65 +0,0 @@
-require 'caruby/util/class'
-
-class File
-  [:gets, :readline, :readlines].each do |attr|
-    # Overrides the standard method to infer a line separator from the input
-    # if the separator argument is the default.
-    redefine_method(attr) do |original|
-      lambda do |*params|
-        sep = params.first || default_line_separator
-        send(original, sep)
-      end
-    end
-
-    # Overrides the standard {#each} method to infer a line separator from the input
-    # if the separator argument is not given.
-    def each(separator=nil)
-      while (line = gets(separator)) do
-        yield line
-      end
-    end
-  end
-
-  private
-
-  # Returns the default line separator. The logic is borrowed from the FasterCVS gem.
-  def default_line_separator
-    @def_line_sep ||= infer_line_separator
-  end
-
-  def infer_line_separator
-    type_line_separator or content_line_separator or $/
-  end
-
-  def type_line_separator
-    if [ARGF, STDIN, STDOUT, STDERR].include?(self) or
-      (defined?(Zlib) and self.class == Zlib::GzipWriter) then
-      return $/
-    end
-  end
-
-  def content_line_separator
-    begin
-      saved_pos = pos  # remember where we were
-      # read a chunk until a separator is discovered
-      sep = discover_line_separator
-      # tricky seek() clone to work around GzipReader's lack of seek()
-      rewind
-      # reset back to the remembered position
-      chunks, residual = saved_pos.divmod(1024)
-      chunks.times { read(1024) }
-      read(residual)
-    rescue IOError  # stream not opened for reading
-    end
-    sep
-  end
-
-  def discover_line_separator
-    # read a chunk until a separator is discovered
-    while (sample = read(1024)) do
-      sample += read(1) if sample[-1, 1] == "\r" and not eof?
-      # try to find a standard separator
-      return $& if sample =~ /\r\n?|\n/
-    end
-  end
-end

data/lib/caruby/util/inflector.rb

@@ -1,27 +0,0 @@
-require 'caruby/active_support/inflector'
-
-class String
-  # @param [Numeric] quantity the amount qualifier
-  # @return this String qualified by a plural if the quantity is not 1
-  # @example
-  #   "rose".quantify(3) #=> "roses"
-  #   "rose".quantify(1 #=> "rose"
-  def quantify(quantity)
-    raise ArgumentError.new("Missing quantity argument") if quantity.nil?
-    "#{quantity} #{quantity == 1 ? self : pluralize}"
-  end
-  
-  # @return this String with the first letter capitalized and other letters preserved.
-  # @example
-  #   "rosesAreRed".capitalize_first #=> "RosesAreRed"
-  def capitalize_first
-    sub(/(?:^)(.)/) { $1.upcase }
-  end
-  
-  # @return this String with the first letter decapitalized and other letters preserved.
-  # @example
-  #   "RosesAreRed".decapitalize #=> "rosesAreRed"
-  def decapitalize
-    sub(/(?:^)(.)/) { $1.downcase }
-  end
-end

data/lib/caruby/util/log.rb

@@ -1,95 +0,0 @@
-require 'logger'
-require 'singleton'
-require 'ftools'
-require 'caruby/util/collection'
-
-# @return [CaRuby::Logger] the global logger
-def logger
-  CaRuby::Log.instance.logger
-end
-
-module CaRuby
-  # Extends the standard Logger to format multi-line messages on separate lines.
-  class MultilineLogger < Logger
-    # @see Logger#initialize
-    def initialize(*args)
-      super
-    end
-  
-    private
-  
-    # Writes msg to the log device. Each line in msg is formatted separately.
-    #
-    # @param (see Logger#format_message)
-    # @return (see Logger#format_message)
-    def format_message(severity, datetime, progname, msg)
-      if String === msg then
-        msg.inject('') { |s, line| s << super(severity, datetime, progname, line.chomp) }
-      else
-        super
-      end
-    end
-  end
-  
-  # Wraps a standard global Logger.
-  class Log
-    include Singleton
-    
-    # Opens the log.
-    #
-    # @param [String, IO, nil] file_or_dev the log file or device (default STDOUT)
-    # @param [Hash, nil] the Logger::LogDevice options
-    # @return [Logger] the logger
-    def open(file_or_dev=nil, options=nil)
-      dev = file_or_dev || default_log_file
-      return @logger if same_file?(dev, @dev)
-      # close the previous log file, if necessary
-      @logger.close if @logger
-      if String === dev then File.makedirs(File.dirname(dev)) end
-      # default is 4-file rotation @ 16MB each
-      shift_age = Options.get(:shift_age, options, 4)
-      shift_size = Options.get(:shift_size, options, 16 * 1048576)
-      @logger = MultilineLogger.new(dev, shift_age, shift_size)
-      @logger.level = Options.get(:debug, options, ENV['DEBUG'] == 'true') ? Logger::DEBUG : Logger::INFO
-      @logger.info('============================================')
-      @logger.info('Logging started.')
-      @dev = dev
-      @logger
-    end
-  
-    def close
-      @logger.close
-      @logger = nil
-    end
-  
-    # Returns the logger.
-    def logger
-      @logger ||= open
-    end
-    
-    # @return [String, nil] the log file, or nil if the log was opened on an IO rather
-    #   than a String
-    def file
-      @dev if String === @dev
-    end
-    
-    private
-    
-    def same_file?(f1, f2)
-      f1 == f2 or (String === f2 and String === f1 and File.expand_path(f1) == File.expand_path(f2))
-    end
-    
-    def default_log_file
-      log_ndx = ARGV.index("--log") || ARGV.index("-l")
-      if log_ndx then
-        ARGV[log_ndx + 1]
-      elsif ENV.has_key?("LOG") then
-        ENV["LOG"]
-      elsif defined?(DEF_LOG_FILE)
-        DEF_LOG_FILE
-      else
-        'log/caruby.log'
-      end
-    end
-  end
-end

data/lib/caruby/util/math.rb

@@ -1,12 +0,0 @@
-# Extends the Numeric class with max and min methods. 
-class Numeric
-  # Returns the minimum of this Numeric and the other Numerics.
-  def min(*others)
-    others.inject(self) { |min, other| other < min ? other : min }
-  end
-
-  # Returns the minimum of this Numeric and the other Numerics.
-  def max(*others)
-    others.inject(self) { |max, other| other > max ? other : max }
-  end
-end

data/lib/caruby/util/merge.rb

@@ -1,59 +0,0 @@
-require 'caruby/util/options'
-require 'caruby/util/collection'
-
-class Hash
-  # Returns a new hash which merges the other hash with this hash.
-  #
-  # Supported options include the following:
-  # * :deep - merge values which match on the key.
-  # If the :deep option is set, and a key matches both this hash and the other hash
-  # on hash values, then the other hash's value is recursively merged into this Hash's
-  # value using the non-destructive {#merge} method with the deep option set.
-  # If a block is given to this method, then the block is passed to the value merge.
-  #
-  # @example
-  #   {:a => [1], :b => [2]}.merge({:b => [3]}, :deep) #=> {:a => [1], :b => [2, 3]}
-  #   {:a => {:b => [1]}}.merge({:a => {:b => [2]}, :c => 3}, :deep) #=> {:a => {:b => [1, 2]}, :c => 3}
-  def merge(other, options=nil, &block)
-    dup.merge!(other, options, &block)
-  end
-
-  alias :base__merge! :merge!
-  private :base__merge!
-
-  # Merges the other hash into this hash and returns this modified hash.
-  #
-  # @see #merge the options and block description
-  def merge!(other, options=nil, &block)
-    # use the standard Hash merge unless the :deep option is set
-    return base__merge!(other, &block) unless Options.get(:deep, options)
-    # merge the other entries:
-    # if the hash value is a hash, then call merge on that hash value.
-    # otherwise, if the hash value understands merge, then call that method.
-    # otherwise, if there is a block, then call the block.
-    # otherwise, set the the hash value to the other value.
-    base__merge!(other) do |key, oldval, newval|
-      if Hash === oldval then
-        oldval.merge(newval, options, &block)
-      elsif oldval.respond_to?(:merge)
-        oldval.merge(newval, &block)
-      elsif block_given? then
-        yield(key, oldval, newval)
-      else
-        newval
-      end
-    end
-  end
-end
-
-class Array
-  # Adds the elements in the other Enumerable which are not already included in this Array.
-  # Returns this modified Array.
-  def merge(other)
-    # incompatible merge argument is allowed but ignored
-    self unless Enumerable === other
-    # concatenate the members of other not in self
-    unique = other.to_a - self
-    concat(unique)
-  end
-end

data/lib/caruby/util/module.rb

@@ -1,18 +0,0 @@
-class Module
-  # Returns the class or module with the given name defined in this module.
-  # The name can qualified by parent modules, e.g. +MyApp::Person+.
-  # If name cannot be resolved as a Module, then this method returns nil.
-  #
-  # @param [String] the class name
-  # @return [Module, nil] the class or module defined in this module, or nil if none 
-  def module_with_name(name)
-    name.split('::').inject(self) { |parent, part| parent.const_get(part) } rescue nil
-  end
-  
-  # @example
-  #   A::B.parent_module #=> A
-  # @return [Module] this module's definition context
-  def parent_module
-    Kernel.module_with_name(name.split('::')[0..-2].join('::'))
-  end
-end

data/lib/caruby/util/options.rb

@@ -1,97 +0,0 @@
-require 'caruby/util/collection'
-require 'caruby/util/validation'
-require 'caruby/util/merge'
-
-# Options is a utility class to support method options.
-class Options
-  # Returns the value of option in options as follows:
-  # * If options is a hash which contains the option key, then this method returns
-  #   the option value. A non-collection options[option] value is wrapped as a singleton
-  #   collection to conform to a collection default type, as shown in the example below.
-  # * If options equals the option symbol, then this method returns +true+.
-  # * If options is an Array of symbols which includes the given option, then this method
-  #   returns +true+.
-  # * Otherwise, this method returns the default.
-  #
-  # If default is nil and a block is given to this method, then the default is determined
-  # by calling the block with no arguments. The block can also be used to raise a missing
-  # option exception, e.g.:
-  #   Options.get(:userid, options) { raise RuntimeError.new("Missing required option: userid") }
-  #
-  # @example
-  #   Options.get(:create, {:create => true}) #=> true
-  #   Options.get(:create, :create) #=> true
-  #   Options.get(:create, [:create, :compress]) #=> true
-  #   Options.get(:create, nil) #=> nil
-  #   Options.get(:create, nil, :false) #=> false
-  #   Options.get(:create, nil, :true) #=> true
-  #   Options.get(:values, nil, []) #=> []
-  #   Options.get(:values, {:values => :a}, []) #=> [:a]
-  def self.get(option, options, default=nil, &block)
-    return default(default, &block) if options.nil?
-    case options
-      when Hash then
-        value = options[option]
-        if String === value then value.strip! end
-        value.nil_or_empty? ? default(default, &block) : value
-      when Enumerable then
-        options.include?(option) ? true : default(default, &block)
-      when Symbol then
-        option == options ? true : default(default, &block)
-      else
-        raise ArgumentError.new("Options argument type is not supported; expected Hash or Symbol, found: #{options.class}")
-    end
-  end
-
-  # Returns the given argument list as a hash, determined as follows:
-  # * If the sole argument member is a hash, then that hash is the options.
-  # * An argument list of option symbols followed by zero, one or more non-option parameters is composed as the option hash.
-  # * An empty argument list is a new empty option hash.
-  #
-  # @example
-  #   Options.to_hash() #=> {}
-  #   Options.to_hash(nil) #=> {}
-  #   Options.to_hash(:a => 1) #=> {:a => 1}
-  #   Options.to_hash(:a) #=> {:a => true}
-  #   Options.to_hash(:a, 1, :b, 2) #=> {:a => 1, :b => 2}
-  #   Options.to_hash(:a, 1, :b, :c, 2, 3) #=> {:a => 1, :b => true, :c => [2, 3]}
-  # @param [Array] args the option list
-  # @return [Hash] the option hash
-  def self.to_hash(*args)
-    unless Enumerable === args then
-      raise ArgumentError.new("Expected Enumerable, found #{args.class.qp}")
-    end
-    oargs = {}
-    opt = args.first
-    return oargs if opt.nil?
-    return opt if oargs.empty? and Hash === opt
-    unless Symbol === opt then
-      raise ArgumentError.new("Expected Symbol as first argument, found #{args.first.class.qp}")
-    end
-    args.inject(nil) do |list, item|
-      Symbol === item ? oargs[item] = Array.new : list << item
-    end
-    # convert the value list to true, a single value or leave as an array
-    oargs.transform do |list|
-      case list.size
-        when 0 then true
-        when 1 then list.first
-        else list
-      end
-    end.to_hash
-  end
-
-  # @param [Hash, Symbol, nil] opts the options to validate
-  # @raise [ValidationError] if the given options are not in the given allowable choices
-  def self.validate(options, choices)
-    to_hash(options).each_key do |opt|
-      raise ValidationError.new("Option is not supported: #{opt}") unless choices.include?(opt)
-    end
-  end
-
-  private
-
-  def self.default(value)
-    value.nil? && block_given? ? yield : value
-  end
-end

data/lib/caruby/util/partial_order.rb

@@ -1,35 +0,0 @@
-# A PartialOrder is a Comparable which restricted scope. Classes wich include PartialOrder
-# are required to implement the <=> operator with the following semantics:
-# *  _a_ <=> _b_ returns -1, 0, or 1 if a and b are comparable, nil otherwise
-# A PartialOrder thus relaxes comparison symmetry, e.g.
-#   a < b
-# does not imply
-#   b >= a.
-# Example:
-#   module Queued
-#     attr_reader :queue
-#     def <=>(other)
-#       queue.index(self) <=> queue.index(other) if queue.equal?(other.queue)
-#     end
-#   end
-#   q1 = [a, b] # a, b are Queued
-#   q2 = [c] # c is a Queued
-#   a < b #=> true
-#   b < c #=> nil
-module PartialOrder
-  include Comparable
-  
-  Comparable.instance_methods(false).each do |m|
-    define_method(m.to_sym) do |other|
-       self <=> other ? super : nil
-    end
-  end
-  
-  # @return [Boolean] true if other is an instance of this object's class and other == self,
-  #   false otherwise
-  def eql?(other)
-    self.class === other and super
-  end
-
-  alias :== :eql?
-end