mack-facets 0.8.1 → 0.8.2

data/lib/gems/facets-2.4.5/lib/lore/facets/getoptlong.rb

@@ -0,0 +1,71 @@
+# = GetoptLong
+#
+# Ruby's standard GetoptLong class with an added DSL.
+#
+#   opts = GetoptLong.new do
+#     reqs '--expect', '-x'
+#     flag '--help', '-h'
+#   end
+#
+#   opts.each { |opt, arg|
+#     ...
+#   }
+#
+# == Authors
+#
+# * Thomas Sawuer
+#
+# == Copying
+#
+# Copyright (c) 2007 Thomas Sawyer
+#
+# Ruby License
+#
+# This module is free software. You may use, modify, and/or redistribute this
+# software under the same terms as Ruby.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE.
+
+require 'getoptlong'
+
+class GetoptLong
+
+  alias :init :initialize
+
+  def initialize(*arguments, &block)
+    if block_given?
+      raise ArgumentError unless arguments.empty?
+      arguments = DSL.new(&block).arguments
+    end
+    init(*arguments)
+  end
+
+  # DSL-mode parser.
+
+  class DSL
+    attr :arguments
+
+    def initialize(&block)
+      @arguments = []
+      instance_eval(&block)
+    end
+
+    def flag(*opts)
+      @arguments << (opts << GetoptLong::NO_ARGUMENT)
+    end
+
+    def required(*opts)
+      @arguments << (opts <<  GetoptLong::REQUIRED_ARGUMENT)
+    end
+    alias :reqs :required
+
+    def optional(*opts)
+      @arguments << (opts << GetoptLong::OPTIONAL_ARGUMENT)
+    end
+    alias :opts :optional
+  end
+
+end
+

data/lib/gems/facets-2.4.5/lib/lore/facets/logger.rb

@@ -0,0 +1,291 @@
+# = Logger
+#
+# Extended variation of Ruby's standard Logger library.
+#
+#   log = Logger.new
+#
+#   log.setup_format do |severity, timestamp, progname, msg|
+#     Logger::SIMPLE_FORMAT % [severity, msg]
+#   end
+#
+# == Conventions
+#
+# When using debug level logger messages always append 'if $DBG'
+# at the end. This hack is needed because Ruby does not support
+# lazy evaluation (lisp macros).
+#
+# == Authors
+#
+# * George Moschovitis
+# * TransLogarithim
+#
+# == Copying
+#
+# Copyright (c) 2005 George Moschovitis
+#
+# Ruby License
+#
+# This module is free software. You may use, modify, and/or redistribute this
+# software under the same terms as Ruby.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE.
+
+require "logger"
+require "time"
+require "facets/ansicode"
+
+# = Logger
+#
+# Extended variation of Ruby's standard Logger library.
+# Mainly for compatibility purposes (with what?)
+#
+#   log = Logger.new
+#
+#   log.setup_format do |severity, timestamp, progname, msg|
+#     Logger::SIMPLE_FORMAT % [severity, msg]
+#   end
+#
+# When using debug level logger messages always append 'if $DBG'
+# at the end. This hack is needed because Ruby does not support
+# lazy evaluation (lisp macros).
+#
+# TODO: What's all this about then?
+
+class Logger
+
+  # Some available logging formats.
+  SIMPLE_FORMAT = "%5s: %s\n"
+  DETAILED_FORMAT = "%s %5s: %s\n"
+
+  # Why these names ?
+  alias_method :devel, :debug
+  alias_method :fine, :debug
+
+  def ansicolor=(on)
+    unless is_a?(Ansicolor)
+      class << self
+        include Ansicolor
+      end
+    end
+    @logdev.ansicolor = on
+  end
+
+# NOTE: trace is deprecated b/c binding of caller is no longer possible.
+=begin
+  # Prints a trace message to DEBUGLOG (at debug level).
+  # Useful for emitting the value of variables, etc.  Use
+  # like this:
+  #
+  #   x = y = 5
+  #   trace 'x'        # -> 'x = 5'
+  #   trace 'x ** y'   # -> 'x ** y = 3125'
+  #
+  # If you have a more complicated value, like an array of
+  # hashes, then you'll probably want to use an alternative
+  # output format.  For instance:
+  #
+  #   trace 'value', :yaml
+  #
+  # Valid output format values (the _style_ parameter) are:
+  #
+  #   :p :inspect
+  #   :pp                     (pretty-print, using 'pp' library)
+  #   :s :to_s
+  #   :y :yaml :to_yaml       (using the 'yaml' library')
+  #
+  # The default is <tt>:p</tt>.
+  #
+  # CREDITS:
+  #
+  # This code comes straight from the dev-utils Gem.
+  # Author: Gavin Sinclair <gsinclair@soyabean.com.au>
+
+  def trace(expr, style=:p)
+    unless expr.respond_to? :to_str
+      warn "trace: Can't evaluate the given value: #{caller.first}"
+    else
+      raise "FACETS: binding/or_caller is no longer possible"
+      require "facets/core/binding/self/of_caller"
+
+      Binding.of_caller do |b|
+        value = b.eval(expr.to_str)
+        formatter = TRACE_STYLES[style] || :inspect
+        case formatter
+        when :pp then require 'pp'
+        when :y, :yaml, :to_yaml then require 'yaml'
+        end
+        value_s = value.send(formatter)
+        message = "#{expr} = #{value_s}"
+        lines = message.split(/\n/)
+        indent = "   "
+        debug(lines.shift)
+        lines.each do |line|
+          debug(indent + line)
+        end
+      end
+    end
+  end
+
+  TRACE_STYLES = {}  # :nodoc:
+  TRACE_STYLES.update(
+    :pp => :pp_s, :s => :to_s, :p => :inspect,
+    :y => :to_yaml, :yaml => :to_yaml,
+    :inspect => :inspect, :to_yaml => :to_yaml
+  )
+=end
+
+  # Dictate the way in which this logger should format the
+  # messages it displays. This method requires a block. The
+  # block should return formatted strings given severity,
+  # timestamp, msg, progname.
+  #
+  # === Example
+  #
+  # logger = Logger.new
+  # logger.setup_format do |severity, timestamp, msg, progname|
+  #   "#{progname}@#{timestamp} - #{severity}::#{msg}"
+  # end
+
+  def setup_format(&format_proc)
+    raise "Formating block needed" unless format_proc
+    @format_proc = format_proc
+  end
+
+  def format_procedure
+    @format_proc
+  end
+
+private
+
+  attr_accessor :format_proc
+
+  alias_method :format_message_without_proc, :format_message # :nodoc:
+
+  def format_message(*args) # :nodoc:
+    @format_proc ? @format_proc.call(*args) : format_message_without_proc(*args)
+  end
+
+  class LogDevice
+    attr_writer :ansicolor
+
+    def ansicolor?
+      @ansicolor
+    end
+  end
+
+  # For adding ansicolor output.
+
+  module Ansicolor
+
+    def info(str)
+      return unless info?
+      @logdev.ansicolor? ? info_with_color{ super } : super
+    end
+
+    def warn(str)
+      return unless warn?
+      @logdev.ansicolor? ? warn_with_color{ super } : super
+    end
+
+    def debug(str)
+      return unless debug?
+      @logdev.ansicolor? ? debug_with_color{ super } : super
+    end
+
+    def error(str)
+      return unless error?
+      @logdev.ansicolor? ? error_with_color{ super } : super
+    end
+
+    def fatal(str)
+      return unless error?
+      @logdev.ansicolor? ? fatal_with_color{ super } : super
+    end
+
+    def info_with_color #:yield:
+      self << ANSICode.green
+      yield
+      self << ANSICode.clear
+    end
+
+    def warn_with_color #:yield:
+      self << ANSICode.cyan
+      yield
+      self << ANSICode.clear
+    end
+
+    def error_with_color #:yield:
+      self << ANSICode.red
+      yield
+      self << ANSICode.clear
+    end
+
+    def debug_with_color #:yield:
+      self << ANSICode.yellow
+      yield
+      self << ANSICode.clear
+    end
+
+    def fatal_with_color #:yield:
+      self << ANSICode.bold + ANSICode.red
+      yield
+      self << ANSICode.clear
+    end
+
+  end
+
+end
+
+# OLD WAY TO ADD COLOR
+=begin
+module Console
+
+  class  Logger < ::Logger
+
+    attr_accessor :style
+
+    def style
+      @style ||= Style.new
+    end
+
+    def info(str)
+      return if level > Logger::INFO
+      self << style.info(str)
+      super
+      self << ANSICode.clear
+    end
+
+    def warn(str)
+      self << style.warn(str)
+      super
+      self << ANSICode.clear
+    end
+
+    def error(str)
+      return if level > Logger::ERROR
+      self << style.error(str)
+      super
+      self << ANSICode.clear
+    end
+
+    def debug(str)
+      self << style.debug(str)
+      super
+      self << ANSICode.clear
+    end
+
+    # Logger Style
+
+    class Style
+      def info(str)  ; ANSICode.green ; end
+      def warn(str)  ; ANSICode.cyan ; end
+      def error(str) ; ANSICode.bold + ANSICode.red ; end
+      def debug(str) ; '' ; end
+    end
+
+  end
+end
+=end
+

data/lib/gems/facets-2.4.5/lib/lore/facets/ostruct.rb

@@ -0,0 +1,238 @@
+# = OpenStruct
+#
+# Ruby's standard OpenStruct with a few extensions added-in.
+#
+# == Auhtors
+#
+# * Thomas Sawyer
+#
+# == Copying
+#
+# Copyright (c) 2005 Thomas Sawyer, George Moschovitis
+#
+# Ruby License
+#
+# This module is free software. You may use, modify, and/or redistribute this
+# software under the same terms as Ruby.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE.
+#
+# == History
+#
+# * 2006-11-04 trans  Deprecate #instance in favor of #instance_delegate.
+# * 2007-04-15 trans  Filled out with actual methods, used "ostruct_" for some accessors.
+
+require 'ostruct'
+
+class OpenStruct
+
+  # Allows the initialization of an OpenStruct with a setter block:
+  #
+  #   person = OpenStruct.new do |o|
+  #     o.name    = 'John Smith'
+  #     o.gender  = :M
+  #     o.age     = 71
+  #   end 
+  #
+  # You can still provide a hash for initialization purposes, and even combine
+  # the two approaches if you wish.
+  #
+  #   person = OpenStruct.new(:name => 'John Smith', :age => 31) do |p|
+  #     p.gender = :M 
+  #   end
+  #
+  # Alternatively you can provide a default block:
+  #
+  #   stuff = OpenStruct.new{ |o,k| o[k] = [] }
+  #   stuff.place << :a
+  #   stuff.place << :b
+  #   stuff.place #=> [:a, :b]
+  #
+  # A setter block versus a defualt block is determined by the arity of
+  # the block. You can not provide both at the same time.
+  #
+  #   CREDIT Noah Gibbs
+  #   CREDIT Gavin Sinclair
+  #   CREDIT 7rans
+  #
+  def initialize(hash=nil, &block)
+    if block && block.arity==2
+      @table = Hash.new(&block)
+    else
+      @table = {}
+    end
+    if hash
+      for k,v in hash
+        @table[k.to_sym] = v
+        new_ostruct_member(k)
+      end
+    end
+    if block && block.arity==1
+      yield self
+    end
+  end
+
+  #
+  def each(&blk)
+    @table.each(&blk)
+  end
+
+  #
+  def to_h
+    @table.dup
+  end
+
+  # Access a value in the OpenStruct by key, like a Hash.
+  # This increases OpenStruct's "duckiness".
+  #
+  #   o = OpenStruct.new
+  #   o.t = 4
+  #   o['t']  #=> 4
+  #
+  def [](key)
+    key = key.to_sym unless key.is_a?(Symbol)
+    @table[key]
+  end
+
+  # Set a value in the OpenStruct by key, like a Hash.
+  #
+  #   o = OpenStruct.new
+  #   o['t'] = 4
+  #   o.t  #=> 4
+  #
+  def []=(key,val)
+    raise TypeError, "can't modify frozen #{self.class}", caller(1) if self.frozen?
+    key = key.to_sym unless key.is_a?(Symbol)
+    @table[key]=val
+  end
+
+  # CREDIT Robert J. Berger <rberger AT ibd.com>
+  # Thanks for reporting issues that this method resolved.
+
+  # Provides access to an OpenStruct's inner table.
+  #
+  #   o = OpenStruct.new
+  #   o.a = 1
+  #   o.b = 2
+  #   o.instance_delegate.each { |k, v| puts "#{k} #{v}" }
+  #
+  # produces
+  #
+  #   a 1
+  #   b 2
+  #
+  #
+  def instance_delegate
+    @table
+  end
+  alias ostruct_delegate instance_delegate
+
+  # Insert/update hash data on the fly.
+  #
+  #   o = OpenStruct.new
+  #   o.ostruct_update { :a => 2 }
+  #   o.a  #=> 2
+  #
+  def ostruct_update(other)
+    #other = other.to_hash  #to_h ?
+    for k,v in other
+      @table[k.to_sym] = v
+    end
+    self
+  end
+
+  # Merge hash data creating a new OpenStruct object.
+  #
+  #   o = OpenStruct.new
+  #   o.ostruct_merge { :a => 2 }
+  #   o.a  #=> 2
+  #
+  def ostruct_merge(other)
+    o = dup
+    o.ostruct_update(other)
+    o
+  end
+
+  ##
+  # TO BE DEPRECATED
+  # Must consider that accessing instance_delegate instead can be dangerous.
+  # Might we us a Functor to ensure the table keys are always symbols?
+  ##
+
+  # Insert/update hash data on the fly.
+  #
+  #   o = OpenStruct.new
+  #   o.ostruct_update { :a => 2 }
+  #   o.a  #=> 2
+  #
+  def __update__(other)
+    #other = other.to_hash #to_h?
+    for k,v in other
+      @table[k.to_sym] = v
+    end
+    self
+  end
+
+  # Merge hash data creating a new OpenStruct object.
+  #
+  #   o = OpenStruct.new
+  #   o.ostruct_merge { :a => 2 }
+  #   o.a  #=> 2
+  #
+  def __merge__(other)
+    o = dup
+    o.__update__(other)
+    o
+  end
+end
+
+
+class Hash
+
+  # Turns a hash into a generic object using an OpenStruct.
+  #
+  #   o = { 'a' => 1 }.to_ostruct
+  #   o.a  #=> 1
+  #
+  def to_ostruct
+    OpenStruct.new(self)
+  end
+
+  # CREDIT Alison Rowland
+  # CREDIT Jamie Macey
+  # CREDIT Mat Schaffer
+
+  #--
+  # Special thanks to Alison Rowland, Jamie Macey and Mat Schaffer
+  # for inspiring recursive improvements.
+  #++
+
+  # Like to_ostruct but recusively objectifies all hash elements as well.
+  #
+  #     o = { 'a' => { 'b' => 1 } }.to_ostruct_recurse
+  #     o.a.b  #=> 1
+  #
+  # The +exclude+ parameter is used internally to prevent infinite
+  # recursion and is not intended to be utilized by the end-user.
+  # But for more advance use, if there is a particular subhash you
+  # would like to prevent from being converted to an OpoenStruct
+  # then include it in the +exclude+ hash referencing itself. Eg.
+  #
+  #     h = { 'a' => { 'b' => 1 } }
+  #     o = h.to_ostruct_recurse( { h['a'] => h['a'] } )
+  #     o.a['b']  #=> 1
+  #
+  def to_ostruct_recurse(exclude={})
+    return exclude[self] if exclude.key?( self )
+    o = exclude[self] = OpenStruct.new
+    h = self.dup
+    each_pair do |k,v|
+      h[k] = v.to_ostruct_recurse( exclude ) if v.respond_to?(:to_ostruct_recurse)
+    end
+    o.__update__(h)
+  end
+
+end
+