caruby-core 1.5.5 → 2.1.1

data/lib/caruby/util/pretty_print.rb

@@ -1,204 +0,0 @@
-require 'set'
-require 'date'
-require 'pp'
-require 'stringio'
-require 'caruby/util/options'
-require 'caruby/util/collection'
-require 'caruby/util/inflector'
-
-class PrettyPrint
-  # The standard +prettyprint+ gem SingleLine is adjusted to add an output accessor and an optional output argument to {#initialize}.
-  class SingleLine
-    # @return [String] the print target
-    attr_reader :output
-
-    alias :base__initialize :initialize
-    private :base__initialize
-
-    # Overrides the standard SingleLine initializer to supply an output parameter default.
-    def initialize(output='', maxwidth=nil, newline=nil)
-      base__initialize(output, maxwidth, newline)
-    end
-  end
-end
-
-# A PrintWrapper prints arguments by calling a printer proc.
-class PrintWrapper < Proc
-  # Creates a new PrintWrapper on the given arguments.
-  def initialize(*args)
-    super()
-    @args = args
-  end
-
-  # @param args this wrapper's print block parameters
-  # @return [PrintWrapper] self
-  def wrap(*args)
-    @args = args
-    self
-  end
-
-  # Calls this PrintWrapper's print procedure on the arguments set in the initializer.
-  def to_s
-    @args.empty? ? 'nil' : call(*@args)
-  end
-
-  alias :inspect :to_s
-end
-
-class Object
-  # @return [String] this object's class demodulized name and object id
-  def print_class_and_id
-    "#{self.class.qp}@#{object_id}"
-  end
-
-  # qp, an abbreviation for quick-print, calls {#print_class_and_id} in this base implementation.
-  alias :qp :print_class_and_id
-
-  # Formats this object with the standard {PrettyPrint}.
-  #
-  # @param [Hash, Symbol, nil] opts the print options
-  # @option opts [Boolean] :single_line print the output on a single line
-  # @return [String] the formatted print result
-  def pp_s(opts=nil)
-    s = StringIO.new
-    if Options.get(:single_line, opts) then
-      PP.singleline_pp(self, s)
-    else
-      PP.pp(self, s)
-    end
-    s.rewind
-    s.read.chomp
-  end
-end
-
-class Numeric
-  # Alias #{Object#qp} to {#to_s} in this primitive class.
-  alias :qp :to_s
-end
-
-class String
-  # Alias #{Object#qp} to {#to_s} in this primitive class.
-  alias :qp :to_s
-end
-
-class TrueClass
-  # Alias #{Object#qp} to {#to_s} in this primitive class.
-  alias :qp :to_s
-end
-
-class FalseClass
-  # Alias #{Object#qp} to {#to_s} in this primitive class.
-  alias :qp :to_s
-end
-
-class NilClass
-  # Alias #{Object#qp} to {#to_s} in this primitive class.
-  alias :qp :inspect
-end
-
-class Symbol
-  # Alias #{Object#qp} to {#to_s} in this primitive class.
-  alias :qp :inspect
-end
-
-class Module
-  # @return [String ] the demodulized name
-  def qp
-    name[/\w+$/]
-  end
-end
-
-module Enumerable
-  # Prints this Enumerable with a filter that calls qp on each item.
-  # Non-collection Enumerable classes override this method to delegate to {Object#qp}.
-  #
-  # Unlike {Object#qp}, this implementation accepts the {Object#pp_s} options.
-  # The options are used to format this Enumerable, but are not propagated to the
-  # enumerated items.
-  #
-  # @param (see Object#pp_s)
-  # @return [String] the formatted result
-  def qp(opts=nil)
-    wrap { |item| item.qp }.pp_s(opts)
-  end
-
-  # If a transformer block is given to this method, then the block is applied to each
-  # enumerated item before pretty-printing the result.
-  #
-  # @param (see Object#pp_s)
-  # @yield [item] transforms the item to print
-  # @yieldparam item the item to print
-  # @return (see Oblect#pp_s)
-  def pp_s(opts=nil)
-    # delegate to Object if no block
-    return super unless block_given?
-    # make a print wrapper
-    wrapper = PrintWrapper.new { |item| yield item }
-    # print using the wrapper on each item
-    wrap { |item| wrapper.wrap(item) }.pp_s(opts)
-  end
-
-  # Pretty-prints the content within brackets, as is done by the Array pretty printer.
-  def pretty_print(q)
-    q.group(1, '[', ']') {
-      q.seplist(self) { |v|
-        q.pp v
-      }
-    }
-  end
-
-  # Pretty-prints the cycle within brackets, as is done by the Array pretty printer.
-  def pretty_print_cycle(q)
-    q.text(empty? ? '[]' : '[...]')
-  end
-end
-
-module Hashable
-  # qp, short for quick-print, prints this Hashable with a filter that calls qp on each key and value.
-  #
-  # @return [String] the quick-print result
-  def qp
-    qph = {}
-    each { |k, v| qph[k.qp] = v.qp }
-    qph.pp_s
-  end
-
-  def pretty_print(q)
-    Hash === self ? q.pp_hash(self) : q.pp_hash(to_hash)
-  end
-
-  def pretty_print_cycle(q)
-    q.text(empty? ? '{}' : '{...}')
-  end
-end
-
-class String
-  # Pretty-prints this String using the Object pretty_print rather than Enumerable pretty_print.
-  def pretty_print(q)
-    q.text self
-  end
-end
-
-class DateTime
-  # @return [String] the formatted +strftime+
-  def pretty_print(q)
-    q.text(strftime)
-  end
-  
-  # qp, an abbreviation for quick-print, is an alias for {#to_s} in this primitive class.
-  alias :qp :to_s
-end
-
-class Set
-  # Formats this set using {Enumerable#pretty_print}.
-  def pretty_print(q)
-    # mark this object as visited; this fragment is inferred from pp.rb and is necessary to detect a cycle
-    Thread.current[:__inspect_key__] << __id__
-    to_a.pretty_print(q)
-  end
-
-  # The pp.rb default pretty printing method for general objects that are detected as part of a cycle.
-  def pretty_print_cycle(q)
-    to_a.pretty_print_cycle(q)
-  end
-end

data/lib/caruby/util/stopwatch.rb

@@ -1,74 +0,0 @@
-require 'benchmark'
-
-# Stopwatch is a simple execution time accumulator.
-class Stopwatch
-  # Time accumulates elapsed real time and total CPU time.
-  class Time
-    # @return [Benchmark::Tms] the Tms wrapped by this Time
-    attr_reader :tms
-
-    # @param [Benchmark::Tms, nil] the starting time (default is now)
-    def initialize(tms=nil)
-      @tms = tms || Benchmark::Tms.new
-    end
-
-    # @return [Numeric] the cumulative elapsed real clock time
-    def elapsed
-      @tms.real
-    end
-
-    #  @return [Numeric] the cumulative CPU total time
-    def cpu
-      @tms.total
-    end
-
-    # Adds the time to execute the given block to this time.
-    #
-    #  @return [Numeric] the split execution Time
-    def split(&block)
-      stms = Benchmark.measure(&block)
-      @tms += stms
-      Time.new(stms)
-    end
-
-    # Sets this benchmark timer to zero.
-    def reset
-      @tms = Benchmark::Tms.new
-    end
-  end
-  
-  # Executes the given block
-  #
-  # @return [Numeric] the execution Time
-  def self.measure(&block)
-    new.run(&block)
-  end
-
-  # Creates a new idle Stopwatch.
-  def initialize
-    @time = Time.new
-  end
-
-  # Executes the given block. Accumulates the execution time in this Stopwatch. 
-  #
-  #  @return [Numeric] the execution run Time
-  def run(&block)
-    @time.split(&block)
-  end
-
-  # @return [Numeric] the cumulative elapsed real clock time spent in {#run} executions
-  def elapsed
-    @time.elapsed
-  end
-
-  # @return [Numeric] the cumulative CPU total time spent in {#run} executions for the
-  #  current process and its children
-  def cpu
-    @time.cpu
-  end
-
-  # Resets this Stopwatch's cumulative time to zero.
-  def reset
-    @time.reset
-  end
-end

data/lib/caruby/util/topological_sync_enumerator.rb

@@ -1,62 +0,0 @@
-require 'caruby/util/collection'
-
-# A TopologicalSyncEnumerator iterates over (target, source) pairs with the target matched
-# to the source with a matcher block. Child targets are matched to child sources based on
-# a topological order reference method. The iteration is performed in depth-first order.
-class TopologicalSyncEnumerator
-  include Enumerable
-
-  # @param targets the objects to synch to
-  # @param sources the objects to synch from
-  # @param [Symbol] method the topological order reference method
-  # @yield (see #each)
-  def initialize(targets, sources, method, &matcher)
-    @tgts = targets
-    @srcs = sources
-    @mthd = method
-    @matcher = matcher || lambda { |tgt, srcs| srcs.first }
-  end
-
-  # Calls the given block on each matching target and source in depth-first order.
-  #
-  # @yield [target, source] the objects to synchronize
-  # @return [Hash] the matching target => source hash
-  def each
-    # the parent hashes for targets and sources
-    pt = @tgts.to_compact_hash { |tgt| tgt.send(@mthd) }
-    ps = @srcs.to_compact_hash { |src| src.send(@mthd) }
-
-    # the child hashes
-    ct = LazyHash.new { Array.new }
-    cs = LazyHash.new { Array.new }
-
-    # collect the chidren and roots
-    rt = @tgts.reject { |tgt| p = pt[tgt]; ct[p] << tgt if p }
-    rs = @srcs.reject { |src| p = ps[src]; cs[p] << src if p }
-
-    # the match hash
-    matches = {}
-    # match recursively
-    each_match_recursive(rt, rs, ct, cs) do |tgt, src|
-      yield(tgt, src)
-      matches[tgt] = src
-    end
-
-    matches
-  end
-
-  private
-
-  def each_match_recursive(targets, sources, ct, cs, &block)
-    # copy the sources
-    srcs = sources.dup
-    # match each target, removing the matched source for the
-    # next iteration
-    targets.each do |tgt|
-      src = @matcher.call(tgt, srcs) || next
-      yield(tgt, src)
-      srcs.delete(src)
-      each_match_recursive(ct[tgt], cs[src], ct, cs, &block)
-    end
-  end
-end

data/lib/caruby/util/transitive_closure.rb

@@ -1,55 +0,0 @@
-require 'caruby/util/visitor'
-
-class Object
-  # Returns the transitive closure over a method or block. This method returns an array partially ordered
-  # by the children method or block, i.e. each node occurs before all other nodes referenced directly or
-  # indirectly by the children.
-  #
-  # If a method symbol or name is provided, then that method is called. Otherwise, the block is called.
-  # In either case, the call is expected to return an object or Enumerable of objects which also respond
-  # to the method or block.
-  #
-  # @param [Symbol, nil] method the child reference, or nil if a block is given
-  # @yield [node] the parent node's children
-  # @yieldparam node the parent node
-  # @example
-  #   class Node
-  #     attr_reader :parent, :children
-  #     def initialize(name, parent=nil)
-  #       super()
-  #       @name = name
-  #       @parent = parent
-  #       @children = []
-  #       parent.children << self if parent
-  #     end
-  #
-  #     def to_s;
-  #   end
-  #   a = Node.new('a'); b = Node.new('b', a), c = Node.new('c', a); d = Node.new('d', c)
-  #   a.transitive_closure { |node| node.children }.to_a.join(", ") #=> a, b, c, d
-  #   a.transitive_closure(:children).to_a.join(", ") #=> a, b, c, d
-  def transitive_closure(method=nil)
-    raise ArgumentError.new("Missing both a method argument and a block") if method.nil? and not block_given?
-    # If there is a method argument, then the transitive closure is based on that method.
-    # Otherwise, visit the closure in reverse depth-first order.
-    if method then
-      transitive_closure() { |node| node.send(method) }
-    else
-      CaRuby::Visitor.new(:depth_first) { |node| yield node }.to_enum(self).to_a.reverse
-    end
-  end
-end
-
-module Enumerable
-  # Returns the transitive closure over all items in this Enumerable.
-  #
-  # @see Object#transitive_closure
-  def transitive_closure(method=nil)
-    # delegate to Object if there is a method argument
-    return super(method) if method
-    # this Enumerable's children are this Enumerable's contents
-    closure = super() { |node| node.equal?(self) ? self : yield(node) }
-    # remove this collection from the closure
-    closure[1..-1]
-  end
-end

data/lib/caruby/util/tree.rb

@@ -1,48 +0,0 @@
-# A Tree consists of a root node and subtree children.
-# A Tree can be decorated with an optional value.
-class Tree
-  attr_reader :root, :children
-
-  attr_accessor :value
-
-  # Creates a Trie with the given root node.
-  def initialize(root=nil)
-   @root = root
-   @children = []
- end
-
-  # Adds a subtree rooted at the given node as a child of this tree.
-  def <<(node)
-    @children << self.class.new(node)
-    self
-  end
-
-  # Returns the subtree at the given node path.
-  def subtree(*path)
-    return self if path.empty?
-    first = path.shift
-    tree = @children.detect { |child| child.root == first }
-    tree.subtree(*path) if tree
-  end
-
-  alias :[] :subtree
-
-  # Creates the given node path if it does not yet exist.
-  # Returns the subtree at the path.
-  def fill(*path)
-    return self if path.empty?
-    first = path.shift
-    tree = subtree(first)
-    if tree.nil? then
-      self << first
-      tree = @children.last
-    end
-    tree.fill(*path)
-  end
-
-  def to_s
-    root_s = @root.nil? || Symbol === root ? root.inspect : root.to_s
-    return "[#{root_s}]" if @children.empty?
-    "[#{root_s} -> #{@children.join(', ')}]"
-  end
-end