facets 1.1.0 → 1.2.0

data/lib/facets/more/methodprobe.rb

@@ -0,0 +1,215 @@
+#--
+# Method Probe
+#
+# Copyright (c) 2004,2005 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.
+#
+#
+# ===========================================================================
+# Revision History ::
+# ---------------------------------------------------------------------------
+#  5.7.21  Trans   * Changed name from DuckHunter to Method::Probe.
+# ===========================================================================
+#++
+
+#:title: Method Probe
+#
+# Method::Probe (aka DuckHunter) is a decoy object which is dropped into
+# methods which records the calls made against it --hence a method probe.
+# Of course, it is not perfect --an inescapable matter it seems for any
+# internal probe. There are a couple of issues related to conditionals.
+# Since the method test for a certain condition against the decoy, how
+# is the decoy to respond? Thus ceratin paths in the code may never get
+# exceuted and thus go unmapped. If Ruby had better conditional reflection
+# (i.e. if 'if', 'case', 'unless', 'when', etc. were true methods) then
+# this could be fixed by making the Probe reentrant, mapping out variant
+# true/false/nil replies. The likely insurmountable problem though is the
+# Halting problem. A probe can cause some methods to complete execution.
+# It's pretty rare, but it can happen and little can be done about it (I think).
+#
+# Note, the alternative to this kind of probe is a program that examines, rather
+# then executes, the code. This would circumvent the above problems, but run
+# into difficulties with dynamic evals. It would also be more complicated,
+# but might prove a better means in the future.
+#
+# This script is provided for experimetnal purposes. Please inform the author
+# if you find ways to improve it or put to an interesting use.
+#
+# == Synopsis
+#
+#   require 'methodprobe'
+#
+#   def amethod(x)
+#     x + 1
+#   end
+#
+#   p method(:amethod).signiture
+#   p method(:amethod).signiture(:class)
+#   p method(:amethod).signiture(:pretty)
+#
+# produces
+#
+#   [["+"]]
+#   [{"+"=>[["Fixnum"]]}]
+#   [["+( Fixnum )"]]
+#
+# == Authors(s)
+#
+# * Thomas Sawyer
+#
+
+class Method
+
+  class Probe
+
+    def Probe.duckcall
+      begin
+        yield
+      rescue TypeError => e
+        self.send(e.message)
+        retry
+      end
+    end
+
+    attr_reader :ducks, :decoys
+
+    def initialize
+      @ducks, @decoys = {}, {}
+    end
+
+    def initialize_copy(from)
+      initialize
+    end
+
+    def method_missing(aSym, *args)
+      aSymStr = aSym.to_s
+
+      # This will happen the first time
+      @ducks[aSymStr] ||= [] #unless @ducks[aSymStr]
+      @ducks[aSymStr] << args.collect { |a| "#{a.class}" }
+
+      decoy = self.dup
+
+      @decoys[aSymStr] ||= [] #unless @decoys[aSymStr]
+      @decoys[aSymStr] << decoy
+
+      # build proxy?
+      #begin
+      #  d = <<-HERE
+      #    def self.#{aSymStr}(*args)
+      #      # This will happen the subsequent times
+      #      @ducks["#{aSymStr}"] << args.collect { |a| #{'"#{a.class}"'} }
+      #      @ducks["#{aSymStr}"].uniq!
+      #      decoy = self.dup
+      #      @decoys["#{aSymStr}"] = [] unless @decoys["#{aSymStr}"]
+      #      @decoys["#{aSymStr}"] << decoy
+      #      decoy
+      #    end
+      #  HERE
+      #  instance_eval d
+      #rescue SyntaxError
+      #  puts "This error may be avoidable by returning the failing duck type as the error message."
+      #  raise
+      #end
+
+      decoy
+    end
+
+  end #class Probe
+
+
+  # Outputs migration information.
+  def migration
+    parameters = []; argc = self.arity
+    if argc > 0
+      argc.times { parameters << Probe.new }
+      Probe.duckcall { self.call(*parameters) }
+    elsif argc < 0
+      raise "(NYI) method takes unlimited arguments"
+    end
+    return parameters
+  end
+  private :migration
+
+
+  # Outputs signiture information.
+  def signature(detail=nil)
+    ds = []
+    case detail
+    when :complete, :all, :full
+      ds = migration
+    when :class, :with_class
+      migration.each { |dh| ds << dh.ducks }
+    when :pp, :pretty, :prettyprint, :pretty_print
+      migration.each do |dh|
+        responders = []
+        dh.ducks.each do |responder, argss|
+          argss.each { |args| responders << "#{responder}( #{args.join(',')} )" }
+        end
+        ds << responders
+      end
+    else
+      migration.each { |dh| ds << dh.ducks.keys }
+    end
+    return ds
+  end
+
+end #class Method
+
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+
+=begin testing
+
+  require 'test/unit'
+
+  # " I am a Duck Hunter ! "
+
+  class TC_MethodProbe < Test::Unit::TestCase
+
+    # fixture
+    def amethod(x)
+      x + 1
+    end
+
+    def test_signiture_default
+      assert_nothing_raised {
+        method(:amethod).signature
+      }
+    end
+
+    def test_signiture_with_class
+      assert_nothing_raised {
+        method(:amethod).signature(:class)
+      }
+    end
+
+    def test_signiture_pp
+      assert_nothing_raised {
+        method(:amethod).signature(:pp)
+      }
+    end
+
+    def test_signiture_all
+      assert_nothing_raised {
+        method(:amethod).signature(:complete)
+      }
+    end
+
+  end
+
+=end

data/lib/facets/more/mock.rb

@@ -0,0 +1,233 @@
+#--
+# Mock
+#
+# Copyright (c) 2005 Thomas Sawyer, Michael Granger and 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.
+#
+#
+# ==========================================================================
+# Revision History ::
+# --------------------------------------------------------------------------
+#  0.5.8.24  trans  Created, based-off of George's initial Mock idea, and
+#                   largely influence by Michael Granger's Test::Unit::Mock.
+# ==========================================================================
+#
+#++
+
+require 'ostruct'
+
+#:title: Mock
+#
+# A straightfoward mocking facility. Typically used in test cases.
+# The Mock class offers a few constructors for quickly building
+# mockups.
+#
+#   mock - Returns a static reponse.
+#   echo - Returns the arguments passed-in.
+#   spin - Returns a rotation of responses.
+#   keys - Returns an index of responses.
+#
+# Mock classes can be built from sratch or partially framed
+# against other classes.
+#
+# === Usage
+#
+#   class ContextMock < Mock
+#     mock :response_headers, {}
+#     spin :host_url, ['http://www.nitrohq.com','http://www.rubyforge.com']
+#   end
+#
+#   ctx = ContextMock.new
+#   ctx.response_headers['location'] = url
+#   ctx.host_url   #=> "http://www.nitrohq.com"
+#   ctx.host_url   #=> "http://www.rubyforge.com"
+#
+# Or
+#
+#   class ContextMock < Mock(Context)
+#     ...
+#   end
+#
+
+class Mock < OpenStruct
+
+  # include these?
+  #include Test::Unit::Assertions
+
+  # Certain methods are not mocked:
+  #   inspect       (tricky)
+  #   class         (delegated)
+  #   kind_of?      (delegated)
+  #   is_a?         (delegated)
+  #   instance_of?  (delegated)
+  #   method        (works as-is)
+  #   send          (works as-is)
+  #   respond_to?   (works as-is)
+  #   hash          (no way to mock)
+  #
+  #   __id__, __call__, etc. (not meant to be mocked, ever!)
+  #
+
+  UnmockedMethods = %r{^(
+    |inspect
+    |kind_of\?|is_a\?|instance_of\?|class
+    |method|send|respond_to\?
+    |hash
+    |__
+  )}x
+
+  class << self
+
+    attr :mocked_class
+
+    def mocks
+      self.methods(false)
+    end
+
+    # Mock a static repsonse.
+    def mock( sym, val )
+      define_method( sym ) { |*args| val }
+    end
+
+    # Responds with input.
+    def echo( sym )
+      define_method( sym ) { |*args| args }
+    end
+
+    # Reponds with a rotation of reponses.
+    def spin( sym, arr )
+      define_method( sym ) { |*args| arr.push(arr.shift) ; arr[-1] }
+    end
+
+    # Responds according to a mapping of input parameters.
+    def keys( sym, hsh )
+      define_method( sym ) { |*args| hsh[args] }
+    end
+
+  end
+
+  # Delegate methods: #class, instance_of?, kind_of?, and is_a?
+
+  alias :__class :class
+
+  def class # :nodoc:
+    return __class.mocked_class
+  end
+
+  def instance_of?( klass ) # :nodoc:
+    self.class == klass
+  end
+
+  def kind_of?( klass ) # :nodoc:
+    self.class <= klass
+  end
+
+  alias_method :is_a?, :kind_of?
+
+end
+
+
+# Factory method for creating semi-functional mock objects given the
+# class which is to be mocked. It looks like a constant for purposes
+# of syntactic sugar.
+def Mock( realclass )
+
+  mockclass = Class.new( Mock )
+
+  mockclass.instance_eval do @mocked_class = realclass end
+
+  # Provide an accessor to class instance var that holds the class
+  # object we're faking
+  class << mockclass
+    # The actual class being mocked
+    attr_reader :mocked_class
+
+    # Propagate the mocked class ivar to derivatives so it can be
+    # called like:
+    #   class MockFoo < Mock( RealClass )
+    def inherited( subclass )
+      mc = self.mockedClass
+      subclass.instance_eval do @mocked_class = mc end
+    end
+  end
+
+  # Build method definitions for all the mocked class's instance
+  # methods, as well as those given to it by its superclasses, since
+  # we're not really inheriting from it.
+  imethods = realclass.instance_methods(true).collect do |name|
+    next if name =~ ::Mock::UnmockedMethods
+
+    # Figure out the argument list
+    arity = realclass.instance_method( name ).arity
+    optargs = false
+
+    if arity < 0
+      optargs = true
+      arity = (arity+1).abs
+    end
+
+    args = []
+    arity.times do |n| args << "arg#{n+1}" end
+    args << "*optargs" if optargs
+
+    # Build a method definition. Some methods need special
+    # declarations.
+    argsj = args.join(',')
+    case name.intern
+    when :initialize
+      "def initialize(#{argsj}) ; super ; end"
+    else
+      "def #{name}(#{argsj}) ; self.send(#{name},#{argsj}) ; end"
+      #"def %s( %s ) ; self.__mockRegisterCall(%s) ; end" %
+      #  [ name, argstr, [":#{name}", *args].join(',') ]
+    end
+  end
+
+  # Now add the instance methods to the mockclass class
+  mockclass.class_eval imethods.join( "\n" )
+
+  return mockclass
+end
+
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+
+# TODO
+
+=begin #test
+
+  class MyMock < Mock
+    mock :m, 10
+    echo :e
+    spin :s, [1,2,3]
+    keys :i, { [:foo] => 'Hello', [:boo] => 'Frog' }
+
+    def a(k) k+1 end
+  end
+
+  my = MyMock.new
+
+  p my.m
+  p my.e('hi')
+  p my.s
+  p my.s
+  p my.s
+  p my.i(:foo)
+  p my.i(:boo)
+  p my.a(1)
+
+=end

data/lib/facets/more/multipliers.rb

@@ -0,0 +1,192 @@
+#--
+# multipliers.rb
+#
+# Copyright (c) 2005 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.
+#
+# ==========================================================================
+# Revision History ::
+# --------------------------------------------------------------------------
+#  2005.08.10  trans   * Created, inspired by Rich Kilmer's bytes.rb.
+# ==========================================================================
+#++
+
+#:title: Multipliers
+#
+# Adds methods to Numeric to make working with
+# magnitudes (kilo, mega, giga, milli, micro, etc.)
+# as well as bits and bytes easier.
+#
+#   1.kilo               #=> 1000
+#   1.milli              #=> 0.001
+#   1.kibi               #=> 1024
+#
+# To display a value in a certain denomination, simply 
+# perform the inverse operation by placing the 
+# multiplier called on unit (1) in the denominator.
+#
+#   1000 / 1.kilo        #=> 1
+#   1024 / 1.kibi        #=> 1
+#
+
+class Numeric
+
+  # SI Multipliers
+
+  def deka  ; self * 10 ; end
+  def hecto ; self * 100 ; end
+  def kilo  ; self * 1000 ; end
+  def mega  ; self * 1000000 ; end
+  def giga  ; self * 1000000000 ; end
+  def tera  ; self * 1000000000000 ; end
+  def peta  ; self * 1000000000000000 ; end
+  def exa   ; self * 1000000000000000000 ; end
+
+  # SI Fractional
+
+  def deci  ; self.to_f / 10 ; end
+  def centi ; self.to_f / 100 ; end
+  def milli ; self.to_f / 1000 ; end
+  def micro ; self.to_f / 1000000 ; end
+  def nano  ; self.to_f / 1000000000 ; end
+  def pico  ; self.to_f / 1000000000000 ; end
+  def femto ; self.to_f / 1000000000000000 ; end
+  def atto  ; self.to_f / 1000000000000000000 ; end
+
+  # SI Binary
+
+  def kibi ; self * 1024 ; end
+  def mebi ; self * 1024**2 ; end
+  def gibi ; self * 1024**3 ; end
+  def tebi ; self * 1024**4 ; end
+  def pebi ; self * 1024**5 ; end
+  def exbi ; self * 1024**6 ; end
+
+  # Bits and Bytes
+ 
+  def bit   ; self ; end
+  def bits  ; self ; end
+  def byte  ; self * 8 ; end
+  def bytes ; self * 8 ; end
+
+end
+
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+
+=begin testing
+
+  require 'test/unit'
+
+  class TC_Multipliers < Test::Unit::TestCase
+
+    def test_deka
+      assert_equal( 10, 1.deka )
+    end
+
+    def test_hecto
+      assert_equal( 100, 1.hecto )
+    end
+
+    def test_kilo
+      assert_equal( 1000, 1.kilo )
+    end
+
+    def test_mega
+      assert_equal( 1000000, 1.mega )
+    end
+
+    def test_giga
+      assert_equal( 1000000000, 1.giga )
+    end
+
+    def test_tera
+      assert_equal( 1000000000000, 1.tera )
+    end
+
+    def test_peta
+      assert_equal( 1000000000000000, 1.peta )
+    end
+
+    def test_exa
+      assert_equal( 1000000000000000000, 1.exa )
+    end
+
+    # Fractional
+
+    def test_deci
+      assert_equal( 0.1, 1.deci )
+    end
+
+    def test_centi
+      assert_equal( 0.01, 1.centi )
+    end
+
+    def test_milli
+      assert_equal( 0.001, 1.milli )
+    end
+
+    def test_milli
+      assert_equal( 0.000001, 1.micro )
+    end
+
+    def test_nano
+      assert_equal( 0.000000001, 1.nano )
+    end
+
+    def test_pico
+      assert_equal( 0.000000000001, 1.pico )
+    end
+
+    def test_femto
+      assert_equal( 0.000000000000001, 1.femto )
+    end
+
+    def test_atto
+      assert_equal( 0.000000000000000001, 1.atto )
+    end
+
+    # SI Binary
+
+    def test_kibi
+      assert_equal( 1024, 1.kibi )
+    end
+
+    def test_mebi
+      assert_equal( 1024**2, 1.mebi )
+    end
+
+    def test_gibi
+      assert_equal( 1024**3, 1.gibi )
+    end
+
+    def test_tebi
+      assert_equal( 1024**4, 1.tebi )
+    end
+
+    def test_pebi
+      assert_equal( 1024**5, 1.pebi )
+    end
+
+    def test_exbi
+      assert_equal( 1024**6, 1.exbi )
+    end
+
+  end
+
+=end
+