RubyGems - minilab - Versions diffs - 1.1.0-x86-mswin32-60 - Mend

minilab 1.1.0-x86-mswin32-60

Files changed (492) hide show

data/vendor/behaviors/test/behaviors_test.rb ADDED Viewed

@@ -0,0 +1,50 @@
+require 'test/unit'
+require File.expand_path(File.dirname(__FILE__)) + '/../lib/behaviors'
+require 'stringio'
+loading_developer_test_class_stdout = StringIO.new
+saved_stdout = $stdout.dup
+$stdout = loading_developer_test_class_stdout
+class DeveloperTest
+  extend Behaviors
+  attr_accessor :flunk_msg, :tested_code
+  should "test their code" do
+    @tested_code = true
+  end
+  should "go to meetings"
+end
+$stdout = saved_stdout
+loading_developer_test_class_stdout.rewind
+$loading_developer_test_class_output = loading_developer_test_class_stdout.read
+class BehaviorsTest < Test::Unit::TestCase
+  def setup
+    @target = DeveloperTest.new
+    assert_nil @target.tested_code, "block called too early"
+  end
+  #
+  # TESTS
+  #
+  def test_should_called_with_a_block_defines_a_test
+    assert @target.methods.include?("test_should_test their code"), "Missing test method"
+    @target.send("test_should_test their code")
+    assert @target.tested_code, "block not called"
+  end
+  def test_should_called_without_a_block_does_not_create_a_test_method
+    assert !@target.methods.include?("test_should_go to meetings"), "Should not have method"
+  end
+  def test_should_called_without_a_block_will_give_unimplemented_output_when_class_loads
+    unimplemented_output = "UNIMPLEMENTED CASE: Developer should go to meetings"
+    assert_match /#{unimplemented_output}/, $loading_developer_test_class_output
+  end
+end

data/vendor/behaviors/test/tasks_test/Rakefile ADDED Viewed

@@ -0,0 +1,16 @@
+require 'rake'
+require 'rake/testtask'
+APP_ROOT = File.expand_path(File.dirname(__FILE__))
+load "#{APP_ROOT}/../../tasks/behaviors_tasks.rake"
+cd APP_ROOT
+desc 'Default: run unit tests.'
+task :default => :test
+Rake::TestTask.new(:test) do |t|
+  t.libs << "#{APP_ROOT}/../../lib"
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end

data/vendor/behaviors/test/tasks_test/doc/behaviors.html ADDED Viewed

@@ -0,0 +1,55 @@
+  <html>
+  <head>
+  <style>
+  div.title
+  {
+    width: 600px;
+    font: bold 14pt trebuchet ms;
+  }
+  div.specification
+  {
+    font: bold 12pt trebuchet ms;
+    border: solid 1px black;
+    width: 600px;
+    padding: 5px;
+    margin: 5px;
+  }
+  ul.requirements
+  {
+    font: normal 11pt verdana;
+    padding-left: 0;
+    margin-left: 0;
+    border-bottom: 1px solid gray;
+    width: 600px;
+  }
+  ul.requirements li
+  {
+    list-style: none;
+    margin: 0;
+    padding: 0.25em;
+    border-top: 1px solid gray;
+  }
+  </style>
+  </head>
+  <body>
+  <div class="title">Specifications for tasks_test</div>
+  <div class="specification">
+  User should:
+  <ul class="requirements">
+  <li>be able set user name and age during construction</li>
+  <li>be able to get user name and age</li>
+  <li>be able to ask if a user is an adult</li>
+  </ul>
+  </div>
+  </body>
+  </html>

data/vendor/behaviors/test/tasks_test/lib/user.rb ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ class User
2	+ end

data/vendor/behaviors/test/tasks_test/test/user_test.rb ADDED Viewed

@@ -0,0 +1,17 @@
+require 'test/unit'
+require 'behaviors'
+require 'user'
+class UserTest < Test::Unit::TestCase
+  extend Behaviors
+  def setup
+  end
+  should "be able set user name and age during construction"
+  should "be able to get user name and age"
+  should "be able to ask if a user is an adult"
+  def test_DELETEME
+  end
+end

data/vendor/constructor-1.0.2/History.txt ADDED Viewed

@@ -0,0 +1,11 @@
+== 1.0.2 / 2008-05-07
+  * An error is raised when constructor keys are passed in that already exist in the super class
+== 1.0.1 / 2007-12-21
+* You can now pass a block to your constructor call; it gets executed after all the ivars get assigned.  (This lets you write some initializer code if you need to.)
+== 1.0.0 / 2007-11-18
+* Released!

data/vendor/constructor-1.0.2/Manifest.txt ADDED Viewed

@@ -0,0 +1,6 @@
+History.txt
+Manifest.txt
+README.txt
+Rakefile
+lib/constructor.rb
+specs/constructor_spec.rb

data/vendor/constructor-1.0.2/README.txt ADDED Viewed

@@ -0,0 +1,77 @@
+constructor
+* http://rubyforge.org/projects/atomicobjectrb/
+* http://atomicobjectrb.rubyforge.org/constructor
+== DESCRIPTION:
+Declarative means to define object properties by passing a hash
+to the constructor, which will set the corresponding ivars.
+== FEATURES/PROBLEMS:
+* Declarative constructor definition and ivar initialization
+== SYNOPSIS:
+  require 'constructor'
+  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
+Arguments specified are required by default.  You can disable
+strict argument checking with :strict option.  This means that
+the constructor will not raise an error if you pass more or
+fewer arguments than declared.
+  class Donkey
+    constructor :age, :odor, :strict => false
+  end
+... this allows you to pass either an age or odor key (or neither)
+to the Donkey constructor.
+== REQUIREMENTS:
+* rubygems
+== INSTALL:
+* sudo gem install constructor
+== LICENSE:
+(The MIT License)
+Copyright (c) 2007 Atomic Object
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/vendor/constructor-1.0.2/Rakefile ADDED Viewed

@@ -0,0 +1,33 @@
+require 'rubygems'
+require 'hoe'
+require './lib/constructor.rb'
+require 'spec/rake/spectask'
+desc 'Default: run specs'
+task :default => :spec
+Hoe.new('constructor', CONSTRUCTOR_VERSION) do |p|
+  p.rubyforge_name = 'atomicobjectrb'
+  p.author = 'Atomic Object'
+  p.email = 'dev@atomicobject.com'
+  p.summary = 'Declarative, named constructor arguments.'
+  p.description =  p.paragraphs_of('README.txt', 2).join("\n\n")
+  p.url = p.paragraphs_of('README.txt', 1).first.gsub(/\* /,'').split(/\n/)
+  p.changes = p.paragraphs_of('History.txt', 0..1).join("\n\n")
+end
+desc 'Run constructor specs'
+Spec::Rake::SpecTask.new(:spec) do |t|
+  t.spec_files = FileList['specs/*_spec.rb']
+  t.spec_opts << '-c -f s'
+end
+if File.exists?("../tools/")
+  load "../tools/tasks/homepage.rake"
+  load "../tools/tasks/release_tagging.rake"
+  ReleaseTagging.new do |t|
+    t.package = "constructor"
+    t.version = CONSTRUCTOR_VERSION
+  end
+end

data/vendor/constructor-1.0.2/lib/constructor.rb ADDED Viewed

@@ -0,0 +1,119 @@
+CONSTRUCTOR_VERSION = '1.0.2' #:nodoc:#
+class Class #:nodoc:#
+  def constructor(*attrs, &block)
+    call_block = ''
+    if block_given?
+      @constructor_block = block
+      call_block = 'self.instance_eval(&self.class.constructor_block)'
+    end
+    # 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? ? true : opts[:strict] != false
+    super_args = opts.nil? ? nil : opts[:super]
+    # Incorporate superclass's constructor keys, if our superclass
+    if superclass.constructor_keys
+      similar_keys = superclass.constructor_keys & attrs
+      raise "Base class already has keys #{similar_keys.inspect}" unless similar_keys.empty?
+      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 user supplied super-constructor hints:
+    super_call = ''
+    if super_args
+      list = super_args.map do |a|
+        case a
+        when String
+          %|"#{a}"|
+        when Symbol
+          %|:#{a}|
+        end
+      end
+      super_call  = %|super(#{list.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)
+        #{super_call}
+        #{validation_code}
+        #{assigns}
+        setup if respond_to?(:setup)
+        #{call_block}
+      end
+    }
+    # Remember our constructor keys
+    @_ctor_keys = attrs
+  end
+  # Access the constructor keys for this class
+  def constructor_keys; @_ctor_keys ||=[]; end
+  def constructor_block #:nodoc:#
+    @constructor_block
+  end
+end
+# Fancy validation exception, based on missing and extraneous keys.
+class ConstructorArgumentError < RuntimeError #:nodoc:#
+  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

data/vendor/constructor-1.0.2/specs/constructor_spec.rb ADDED Viewed

@@ -0,0 +1,345 @@
+require File.expand_path(File.dirname(__FILE__) + '/../lib/constructor')
+describe 'standard constructor usage' do
+  it 'allows for object construction using a hash of named arguments' do
+    fuh = TestingClass.new(
+      :foo => 'my foo',
+      :bar => 'my bar',
+      :qux => 'my qux',
+      :why => 'lucky'
+    )
+    fuh.foo.should eql('my foo')
+    fuh.bar.should eql('my bar')
+    fuh.qux.should eql('my qux')
+    fuh.why.should eql('lucky')
+    fuh.to_pretty_pretty.should eql('my foo my bar')
+  end
+  it 'calls setup method if defined' do
+    ralph = Llamma.new :hair => 'red'
+    ralph.hungry.should be_true
+    ralph.hair.should eql('red')
+  end
+end
+describe "constructor's accessor option" do
+  it 'provides accessors for constructor arguments when accessor option is true' do
+    fuh = TestingAutoAccessors.new(
+      :foo => 'my foo',
+      :bar => 'my bar',
+      :qux => 'my qux',
+      :why => 'lucky'
+    )
+    fuh.foo.should eql('my foo')
+    fuh.bar.should eql('my bar')
+    fuh.qux.should eql('my qux')
+    fuh.why.should eql('lucky')
+    fuh.to_pretty_pretty.should eql('my foo my bar')
+  end
+  it 'does not provide accessors for constructor arguments when accessor option is false' do
+    fuh = TestingBlockedAccessors.new :foo => 'my foo', :bar => 'my bar'
+    lambda {fuh.foo}.should raise_error(NoMethodError)
+    lambda {fuh.bar}.should raise_error(NoMethodError)
+    fuh.to_pretty_pretty.should eql('my foo my bar')
+  end
+end
+describe 'using constructor with inheritance' do
+  it 'allows for inheritance of constructor arguments using a non-constructor defined subclass' do
+    fuh = SubclassOfTestingClass.new :foo => 'whu?'
+    fuh.foo.should eql('whu?')
+    fuh.bar.should be_nil
+    fuh.qux.should be_nil
+    fuh.why.should be_nil
+  end
+  it 'allows for standard construction of a non-constructor subclass of a non-strict constuctor superclass' do
+    fuh = SubclassOfTestingClass2.new
+    fuh.foo.should be_nil
+  end
+  it 'runs initialize method of a sublcass' do
+    fuh = SubclassOfTestingClass3.new
+    fuh.my_new_var.should eql('something')
+    fuh.foo.should be_nil
+    fuh.bar.should be_nil
+    fuh.qux.should be_nil
+    fuh.why.should be_nil
+  end
+  it 'passes named constructor args to superclass when subclass calls super' do
+    fuh = SubclassOfTestingClass3.new :foo => 12
+    fuh.my_new_var.should eql('something')
+    fuh.foo.should eql(12)
+    fuh.bar.should be_nil
+    fuh.qux.should be_nil
+    fuh.why.should be_nil
+  end
+  it 'allows for inheritance of constructor arguments using a constructor defined subclass' do
+    s = Sonny.new :car => 'Nissan', :saw => 'Dewalt', :computer => 'Dell'
+    s.computer.should eql('Dell')
+    s.saw.should eql('Dewalt')
+    s.car.should eql('Nissan')
+  end
+  it 'calls the setup method on superclass if subclass does not define a setup method' do
+    baby = Baby.new :cuteness => 'little', :age => 1
+    baby.fat.should eql('much')
+  end
+  it 'calls parent class setup when super is called from subclass setup'  do
+    m = Mama.new :age => 55
+    m.age.should eql(55)
+    m.fat.should eql('much')
+    s = Sissy.new :age => 19, :beauty => 'medium', :fat => 'yeah'
+    s.age.should eql(19)
+    s.beauty.should eql('medium')
+    s.fat.should eql('much')
+    s.friends.should eql('many')
+  end
+  it 'passes arguments given in the super option to the initializer of a non-constructor defined superclass' do
+    tsc = TestingSuperConstructor.new(:far => 'oo', :away => 'kk')
+    tsc.far.should eql('oo')
+    tsc.away.should eql('kk')
+    tsc.a.should eql("once")
+    tsc.b.should eql(:twice)
+  end
+  it 'calls non-constructor defined superclass constructor when the super option is an empty array' do
+    tsc = TestingSuperConstructor2.new(:some => 'thing')
+    tsc.some.should eql('thing')
+    tsc.c.should eql('what a')
+    tsc.d.should eql('day for')
+  end
+  it "raises an error if subclass tries to build a constructor with the keys as its parents" do
+    class1 = constructor_class(Object, :star, :wars)
+    class2 = constructor_class(class1, :space, :balls)
+    lambda { constructor_class(class2, :star, :space, :chewy) }.should raise_error("Base class already has keys [:space, :star]")
+  end
+end
+describe 'stict mode usage' do
+  it 'allows omission of arguments when strict is off' do
+    fuh = TestingClass.new :foo => 'my foo'
+    fuh.foo.should eql('my foo')
+    fuh.bar.should be_nil
+    fuh.qux.should be_nil
+    fuh.why.should be_nil
+  end
+  it 'allows no arguments to a constructor when strict is off' do
+    fuh = TestingClass.new
+    fuh.foo.should be_nil
+    fuh.bar.should be_nil
+    fuh.qux.should be_nil
+    fuh.why.should be_nil
+  end
+  it 'does not interfere with normal object construction' do
+    require 'rexml/document'
+    d = REXML::Document.new '<base/>'
+    d.should_not be_nil
+    d.root.name.should eql('base')
+  end
+  def see_strict_args_in_effect_for(clazz)
+    fuh = clazz.new :foo => 'my foo', :bar => 'my bar'
+    fuh.to_pretty_pretty.should eql('my foo my bar')
+    # Omit foo
+    lambda {
+      TestingStrictArgsDefault.new :bar => 'ok,yeah'
+    }.should raise_error(ConstructorArgumentError, /foo/)
+    # Omit bar
+    lambda {
+      TestingStrictArgsDefault.new :foo => 'ok,yeah'
+    }.should raise_error(ConstructorArgumentError, /bar/)
+  end
+  it 'defaults to strict argument enforcement' do
+    see_strict_args_in_effect_for TestingStrictArgsDefault
+  end
+  it 'enforces strict arguments when strict option is true' do
+    see_strict_args_in_effect_for TestingStrictArgs
+  end
+  it 'does not allow empty constructor arguments when strict option is true' do
+    lambda {TestingStrictArgs.new {}}.should raise_error(ConstructorArgumentError,/foo,bar/)
+    lambda {TestingStrictArgs.new}.should raise_error(ConstructorArgumentError,/foo,bar/)
+    lambda {TestingStrictArgs.new nil}.should raise_error(ConstructorArgumentError,/foo,bar/)
+  end
+  it 'does not allow extraneous arguments when strict option is true' do
+    [ /thing/, /other/ ].each do |rejected_arg|
+      lambda {
+        TestingStrictArgs.new(:foo => 1, :bar => 2, :other => 3, :thing => 4)
+      }.should raise_error(ConstructorArgumentError, rejected_arg)
+    end
+  end
+  it 'allows for setting accessors option while in strict mode' do
+    t2 = TestingStrictArgs2.new :foo => 1, :bar => 2
+    # See that accessors work
+    t2.foo.should eql(1)
+    t2.bar.should eql(2)
+    # See that strictness still applies
+    lambda {TestingStrictArgs2.new :no => 'good'}.should raise_error(ConstructorArgumentError)
+  end
+end
+describe 'catching ConstructorArgumentError' do
+  it 'allows for generic rescuing of constructor argument errors' do
+    begin
+      TestingStrictArgs.new :broken => 'yoobetcha'
+    rescue => bad_news
+      bad_news.should be_kind_of(ConstructorArgumentError)
+    end
+  end
+end
+describe 'block yielding' do
+  it 'executes a specified block after instantiating' do
+    TestingBlockYield.new(:a => false).a.should == true
+  end
+end
+def constructor_class(base, *keys)
+  Class.new(base) do
+    constructor *keys
+  end
+end
+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 Baby < Mama
+  constructor :cuteness
+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
+class TestingBlockYield
+  constructor :a, :accessors => true do
+    @a = true
+  end
+end