minilab 1.0.0-mswin32

data/vendor/constructor/test/constructor_test.rb

@@ -0,0 +1,366 @@
+require File.dirname(__FILE__) + '/helper'
+require 'behaviors'
+require 'constructor'
+
+class ConstructorTest < Test::Unit::TestCase
+  extend Behaviors
+  
+  class TestingClass
+    attr_accessor :foo, :bar, :why, :qux
+    constructor :foo, :bar, :why, :qux, :strict => false
+
+    def to_pretty_pretty
+      "#{@foo} #{@bar}"
+    end
+
+  end
+
+  class Mama
+    attr_accessor :fat, :age
+    constructor :age, :strict => false
+    def setup
+      @fat = "much"
+    end
+  end
+
+  class Sissy < Mama
+    attr_accessor :friends, :beauty
+    constructor :beauty, :strict => false
+    def setup
+      super #IMPORTANT!
+      @friends = "many"
+    end
+  end
+
+  class TestingStrictArgsDefault
+    constructor :foo, :bar
+    def to_pretty_pretty
+      "#{@foo} #{@bar}"
+    end
+  end
+
+  class TestingStrictArgs
+    constructor :foo, :bar, :strict => true
+    def to_pretty_pretty
+      "#{@foo} #{@bar}"
+    end
+  end
+
+  class TestingStrictArgs2
+    constructor :foo, :bar, :accessors => true
+  end
+
+  class SubclassOfTestingClass < TestingClass
+  end
+
+  class SubclassOfTestingClass2 < TestingClass
+    def initialize; end
+  end
+
+  class SubclassOfTestingClass3 < TestingClass
+    attr_reader :my_new_var
+    def initialize(hash = nil)
+      super
+      @my_new_var = "something"
+    end
+  end
+
+  class TestingAutoAccessors
+    constructor :foo, :bar, :why, :qux, :accessors => true, :strict => false
+    def to_pretty_pretty
+      "#{@foo} #{@bar}"
+    end
+  end
+
+  class TestingSuperConstructorBase
+    attr_reader :a, :b
+    def initialize(a,b)
+      @a = a
+      @b = b
+    end
+  end
+
+  class TestingSuperConstructor < TestingSuperConstructorBase
+    constructor :far, :away, :accessors => true, :super => ["once", :twice], :strict => false
+  end
+
+  class TestingSuperConstructorBase2
+    attr_reader :c, :d
+    def initialize
+      @c = 'what a'
+      @d = 'day for'
+    end
+  end
+  
+  class TestingSuperConstructor2 < TestingSuperConstructorBase2
+    constructor :some, :accessors => true, :super => [], :strict => false
+  end
+
+  class TestingBlockedAccessors
+    constructor :foo, :bar, :accessors => false
+    def to_pretty_pretty
+      "#{@foo} #{@bar}"
+    end
+  end
+
+  class Papa
+    constructor :car, :saw
+  end
+
+  class Sonny < Papa
+    constructor :computer, :accessors => true
+  end
+
+  class Llamma
+    attr_accessor :hungry, :hair
+    constructor :hair
+    def setup
+      @hungry = true
+    end
+  end
+  
+  #
+  # TESTS
+  #
+
+  should "construct an object using a hash of named constructor arguments" do
+    fuh = TestingClass.new( 
+      :foo => 'my foo',
+      :bar => 'my bar',
+      :qux => 'my qux',
+      :why => 'lucky'
+    )
+
+    assert_equal 'my foo', fuh.foo
+    assert_equal 'my bar', fuh.bar
+    assert_equal 'my qux', fuh.qux
+    assert_equal 'lucky', fuh.why
+    assert_equal 'my foo my bar', fuh.to_pretty_pretty
+  end
+
+  should "allow omission of arguments when strict is off" do
+    fuh = TestingClass.new( :foo => 'my foo' )
+    assert_equal 'my foo', fuh.foo
+    assert_nil fuh.bar
+    assert_nil fuh.qux
+    assert_nil fuh.why
+  end
+
+  should "allow no arguments to a constructor when strict is off" do
+    fuh = TestingClass.new
+    assert_nil fuh.foo
+    assert_nil fuh.bar
+    assert_nil fuh.qux
+    assert_nil fuh.why
+  end
+
+  should  "that objects that do not use constructor work normally" do
+    require 'rexml/document'
+    d = REXML::Document.new("<base/>")
+    assert_not_nil d, 'nil document'
+    assert_equal "base", d.root.name
+  end
+
+ should "inherit constructor arguments" do
+    fuh = SubclassOfTestingClass.new(:foo => 'whu?')
+    assert_equal "whu?", fuh.foo
+    assert_nil fuh.bar
+    assert_nil fuh.qux
+    assert_nil fuh.why
+  end
+
+  should "still be able to use a standard constructor in a subclass" do
+    fuh = SubclassOfTestingClass2.new 
+    assert_nil fuh.foo
+  end
+
+  should "call subclass constructor" do
+    fuh = SubclassOfTestingClass3.new
+    assert_equal "something", fuh.my_new_var
+  end
+  
+  should "be able to use named constructor args when a subclass defines a constructor and calls super" do
+    fuh = SubclassOfTestingClass3.new(:foo => 12)
+    assert_equal "something", fuh.my_new_var
+    assert_equal 12, fuh.foo
+  end
+
+  should "provide accessors for constructor arguments when the accessor option is used" do
+    fuh = TestingAutoAccessors.new( 
+      :foo => 'my foo',
+      :bar => 'my bar',
+      :qux => 'my qux',
+      :why => 'lucky'
+    )
+    assert_equal 'my foo', fuh.foo
+    assert_equal 'my bar', fuh.bar
+    assert_equal 'my qux', fuh.qux
+    assert_equal 'lucky', fuh.why
+    assert_equal 'my foo my bar', fuh.to_pretty_pretty
+  end
+
+  should "not provide accessors for constructor arguments when the accessor option is false" do
+    fuh = TestingBlockedAccessors.new( 
+      :foo => 'my foo',
+      :bar => 'my bar'
+    )
+    [:foo, :bar].each do |accessor_name|
+      assert_raise NoMethodError  do
+        fuh.send accessor_name
+      end
+    end
+    assert_equal 'my foo my bar', fuh.to_pretty_pretty
+  end
+
+  should "inherit constructor arguments" do
+    s = Sonny.new(:car => "Nissan", :saw => "Dewalt", :computer => "Dell")
+    assert_equal "Dell", s.computer
+    assert_equal "Dewalt", s.saw
+    assert_equal "Nissan", s.car
+  end
+
+  should "call setup method if defined" do
+    ralph = Llamma.new(:hair => "red")
+    assert ralph.hungry
+    assert_equal "red", ralph.hair
+  end
+
+  class Baby < Mama
+    constructor :cuteness
+  end
+
+  should "call setup on superclass if subclass does not define a setup method" do
+    baby = Baby.new(:cuteness => 'little', :age => 1)
+    assert_equal "much", baby.fat
+  end
+  
+  should "let parent class setup affect subclass setup" do
+    m = Mama.new(:age => 55)
+    assert_equal 55, m.age
+    assert_equal "much", m.fat
+    
+    s = Sissy.new(:age => 19, :beauty => "medium")
+    assert_equal 19, s.age
+    assert_equal "medium", s.beauty
+    assert_equal "much", s.fat
+    assert_equal "many", s.friends
+  end
+  
+  should "default to strict argument enforcement" do
+    fuh = TestingStrictArgsDefault.new( 
+      :foo => 'my foo',
+      :bar => 'my bar')
+    assert_equal 'my foo my bar', fuh.to_pretty_pretty
+
+    # Omit foo
+    err = assert_raise ConstructorArgumentError do
+      TestingStrictArgsDefault.new :bar => 'ok,yeah'
+    end
+    assert_match(/foo/, err.message)  
+
+    # Omit bar
+    err = assert_raise ConstructorArgumentError do
+      TestingStrictArgsDefault.new :foo => 'ok,yeah'
+    end
+    assert_match(/bar/, err.message)  
+  end
+
+  should "enforce strict arguments when the strict option is true" do
+    fuh = TestingStrictArgs.new( 
+      :foo => 'my foo',
+      :bar => 'my bar')
+    assert_equal 'my foo my bar', fuh.to_pretty_pretty
+
+    # Omit foo
+    err = assert_raise ConstructorArgumentError do
+      TestingStrictArgs.new :bar => 'ok,yeah'
+    end
+    assert_match(/foo/, err.message)  
+
+    # Omit bar
+    err = assert_raise ConstructorArgumentError do
+      TestingStrictArgs.new :foo => 'ok,yeah'
+    end
+    assert_match(/bar/, err.message)  
+  end
+
+  
+  should "not allow an empty construction when using strict arguments" do
+    # Omit foo and bar
+    err = assert_raise ConstructorArgumentError do
+      TestingStrictArgs.new {}
+    end
+    assert_match(/bar/, err.message)  
+    assert_match(/foo/, err.message)  
+
+    # Nil 
+    err = assert_raise ConstructorArgumentError do
+      TestingStrictArgs.new 
+    end
+    assert_match(/bar/, err.message)  
+    assert_match(/foo/, err.message)  
+
+    # Nil explicitly
+    err = assert_raise ConstructorArgumentError do
+      TestingStrictArgs.new nil
+    end
+    assert_match(/bar/, err.message)  
+    assert_match(/foo/, err.message)  
+  end
+
+  should "not allow extraneous arguments in strict mode" do
+    err = assert_raise ConstructorArgumentError do
+      TestingStrictArgs.new(:foo => 1, :bar => 2, :other => 3, :thing => 4)
+    end
+    assert_match(/other/, err.message)  
+    assert_match(/thing/, err.message)  
+
+  end
+ 
+  should "raise an exception mentioning missing or extra arguments in strict mode" do
+    err = assert_raise ConstructorArgumentError do
+      TestingStrictArgs.new(:other => 3, :thing => 4)
+    end
+    assert_match(/foo/, err.message)  
+    assert_match(/bar/, err.message)  
+    assert_match(/thing/, err.message)  
+    assert_match(/thing/, err.message)  
+  end
+
+
+  should "provide accessors for constructor arguments in strict mode" do
+    t2 = TestingStrictArgs2.new(:foo => 1, :bar => 2)
+    # See that accessors work
+    assert_equal 1, t2.foo
+    assert_equal 2, t2.bar
+
+    # See that strictness still applies
+    err = assert_raise ConstructorArgumentError do
+      TestingStrictArgs2.new(:no => 'good')
+    end
+  end
+
+  should "allow generic rescue of constructor argument catching" do
+    begin
+      TestingStrictArgs.new(:broken => 'yoobetcha')
+    rescue => oops  
+      assert oops.kind_of?(ConstructorArgumentError)
+    end
+  end
+
+  should "pass arguments given in the super option to the initializer of a parent class" do
+    tsc = TestingSuperConstructor.new(:far => 'oo', :away => 'kk')
+    assert_equal 'oo', tsc.far
+    assert_equal 'kk', tsc.away
+    assert_equal "once", tsc.a
+    assert_equal :twice, tsc.b
+  end
+
+  should "call a super constructor when the super option is an empty array" do
+    tsc = TestingSuperConstructor2.new(:some => 'thing')
+    assert_equal 'thing', tsc.some
+    assert_equal 'what a', tsc.c
+    assert_equal 'day for', tsc.d
+  end
+  
+end

data/vendor/constructor/test/helper.rb

@@ -0,0 +1,3 @@
+require File.expand_path(File.dirname(__FILE__) + "/../config/environment")
+require 'test/unit'
+

data/vendor/diy/README

@@ -0,0 +1,26 @@
+Tue Oct 25 01:48:45 EDT 2005
+crosby
+
+DIY - Dependency Injection with YAML
+
+Constructor-based dependency injection container using YAML input.
+
+Currently, all objects that get components put into them must have a
+constructor that gets a hash with symbols as keys.
+Best used with constructor.rb
+
+Auto-naming and auto-library support is done.
+
+TEST
+  rake
+  ...or ruby test/diy_context_test.rb
+
+INSTALL
+  Just grab src/diy_context.rb and put it somewhere.
+  You might want lib/constructor.rb too, but best get it from svn/devtools/ruby/constructor, its official home.
+
+DOC
+  Read SVN log
+  Read diy_context_test.rb
+  See test/files/dog/simple.yml for sample.
+  "rdoc src/"

data/vendor/diy/Rakefile

@@ -0,0 +1,18 @@
+require 'rake'
+require 'rake/testtask'
+
+def header(s)
+  puts "---\n\n#{s}\n\n---\n"
+end
+
+
+task :default => [ :testall ]
+
+desc "Run the unit tests in test/unit"
+Rake::TestTask.new("testall") { |t|
+  header(t.name)
+  t.libs << "test"
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+}
+

data/vendor/diy/lib/constructor.rb

@@ -0,0 +1,114 @@
+class Class
+	#
+	# Declarative means to define object properties by passing a hash 
+	# to the constructor, which will set the corresponding ivars.
+	# Eg,
+	#  class Horse
+	#    constructor :name, :breed, :weight
+	#  end
+	#  Horse.new :name => 'Ed', :breed => 'Mustang', :weight => 342
+	#
+	# By default the ivars do not get accessors defined.
+	# But you can get them auto-made if you want:
+	#  class Horse
+	#    constructor :name, :breed, :weight, :accessors => true
+	#  end
+	#  ...
+	#  puts my_horse.weight
+	# 
+	# You can enforce strict argument checking with :strict option.
+	# This means that the constructor will raise an error if you pass
+	# more or fewer arguments than declared.
+	# Eg,
+	#  class Donkey
+	#    constructor :age, :odor, :strict => true
+	#  end
+	# ... this forces you to pass both an age and odor key to the Donkey constructor.
+	#
+	def constructor(*attrs)
+		# Look for embedded options in the listing:
+		opts = attrs.find { |a| a.kind_of?(Hash) and attrs.delete(a) } 
+		do_acc = opts.nil? ? false : opts[:accessors] == true
+		require_args = opts.nil? ? false : opts[:strict] == true
+
+		# Incorporate superclass's constructor keys
+		if superclass.constructor_keys
+			attrs = [attrs,superclass.constructor_keys].flatten
+		end
+		# Generate ivar assigner code lines
+		assigns = ''
+		attrs.each do |k|
+			assigns += "@#{k.to_s} = args[:#{k.to_s}]\n"
+		end 
+
+		# If accessors option is on, declare accessors for the attributes:
+		if do_acc
+			self.class_eval "attr_accessor " + attrs.map {|x| ":#{x.to_s}"}.join(',')
+		end
+
+		# If strict is on, define the constructor argument validator method,
+		# and setup the initializer to invoke the validator method.
+		# Otherwise, insert lax code into the initializer.
+		validation_code = "return if args.nil?"
+		if require_args
+			self.class_eval do 
+			  def _validate_constructor_args(args)
+					# First, make sure we've got args of some kind
+					unless args and args.keys and args.keys.size > 0 
+						raise ConstructorArgumentError.new(self.class.constructor_keys)
+					end
+					# Scan for missing keys in the argument hash
+					a_keys = args.keys
+					missing = []
+					self.class.constructor_keys.each do |ck|
+						unless a_keys.member?(ck)
+							missing << ck
+						end
+						a_keys.delete(ck) # Delete inbound keys as we address them
+					end
+					if missing.size > 0 || a_keys.size > 0
+						raise ConstructorArgumentError.new(missing,a_keys)
+					end
+				end
+			end
+			# Setup the code to insert into the initializer:
+			validation_code = "_validate_constructor_args args "
+		end
+
+		# Generate the initializer code
+		self.class_eval %{
+			def initialize(args=nil)
+				#{validation_code}
+				#{assigns}
+				setup if respond_to?(:setup)
+			end
+		}
+
+		# Remember our constructor keys
+		@_ctor_keys = attrs
+	end
+
+	# Access the constructor keys for this class
+	def constructor_keys; @_ctor_keys; end
+end
+
+# Fancy validation exception, based on missing and extraneous keys.
+class ConstructorArgumentError < RuntimeError
+	def initialize(missing,rejected=[])
+		err_msg = ''
+		if missing.size > 0
+			err_msg = "Missing constructor args [#{missing.join(',')}]"
+		end
+		if rejected.size > 0
+			# Some inbound keys were not addressed earlier; this means they're unwanted
+			if err_msg
+				err_msg << "; " # Appending to earlier message about missing items
+			else
+				err_msg = ''
+			end
+			# Enumerate the rejected key names
+			err_msg << "Rejected constructor args [#{rejected.join(',')}]"
+		end
+		super err_msg
+	end
+end