Changeset 288

Timestamp:

09/30/08 15:00:29 (7 weeks ago)

Author:

ged

Message:

• Updated build system
• Finished converting statistic tests to specs.

Location:

trunk

Files:

• Rakefile (modified) (1 diff)
• Rakefile.local (modified) (1 prop)
• lib/fm/composedobject.rb (modified) (2 diffs)
• lib/fm/periodicobject/element.rb (modified) (2 diffs)
• lib/fm/statistic.rb (modified) (4 diffs)
• spec/fm/periodicobject/element_spec.rb (modified) (1 diff)
• spec/fm/statistic.tests.rb (deleted)
• spec/fm/statistic_spec.rb (modified) (1 diff)

trunk/Rakefile

@@ -270 +270 @@
 ### Task: cruise (Cruisecontrol task)
 desc "Cruisecontrol build"
-task :cruise => [:clean, :spec, :package] do |task|
+task :cruise => [:clean, 'spec:quiet', :package] do |task|
     raise "Artifacts dir not set." if ARTIFACTS_DIR.to_s.empty?
     artifact_dir = ARTIFACTS_DIR.cleanpath

trunk/lib/fm/composedobject.rb

@@ -87 +87 @@
                 define_method( devel ) { self.statistic.developmental }
                 define_method( "#{devel}=" ) {|arg|
-                    check_type( arg, FaerieMUD::DevelopmentalObject )
                     self.statistic.developmental = arg
                 }
@@ -121 +120 @@
             # just use Hydrogen.
             element = args.delete( :statistic ) || 1
-            @statistic = FaerieMUD::Statistic.new(
-                self.class.statistic_names[0],
-                self.class.statistic_names[1],
-                element )
+            devel, linear = self.class.statistic_names
+            @statistic = FaerieMUD::Statistic.new( element, devel, linear )
 
             super

trunk/lib/fm/periodicobject/element.rb

@@ -228 +228 @@
     ### atomic number or element name +elem+.
     def self::fetch( elem=1 )
+        elem ||= 1
         FaerieMUD::Logger[ self ].debug "Fetching element %p" % [ elem ]
 
         # Allow elem to be an Element object for implementations of element=
         # mutators.
-        return elem if elem.is_a?( self )
+        if elem.is_a?( self )
+            FaerieMUD::Logger[ self ].debug "self-referential fetch"
+            return elem
+        end
 
         # Attempt to convert names or chemical symbols to atomic numbers.
@@ -240 +244 @@
                 raise ArgumentError, "No such element '#{name}'"
         end
+
+        FaerieMUD::Logger[ self ].debug "...<%s(%s):%d>" % [ NAMES[elem], SYMBOLS[elem], elem ]
 
         super( elem,

trunk/lib/fm/statistic.rb

@@ -67 +67 @@
     DEFAULT_LINEAR_NAME = "linear"
 
+
     #############################################################
     ### I N S T A N C E   M E T H O D S
@@ -72 +73 @@
 
     ### Create a new Statistic object with the specified +devel_name+,
-    ### +linear_name+ and +element+. The +devel_name+ and +linear_name+ arguments
-    ### are the name of the developmental and linear aspects of the statistic,
-    ### respectively, and must be Strings or objects which respond to #to_s. The
-    ### +element+ argument is the primary aspect of the statistic, and can be
-    ### any valid argument to PeriodicObject's constructor.
-    def initialize( element=:H, devel_name=DEFAULT_DEVEL_NAME, linear_name=DEFAULT_LINEAR_NAME, options={} )
-        @devel_name = devel_name || DEFAULT_DEVEL_NAME
-        @linear_name = linear_name || DEFAULT_LINEAR_NAME
-        @developmental = FaerieMUD::DevelopmentalObject::new
+    ### +linear_name+ and +element+. The +element+ argument is the primary
+    ### aspect of the statistic, and can be
+    ### any valid argument to PeriodicObject's constructor. The +devel_name+ and
+    ### +linear_name+ arguments are the name of the developmental and linear
+    ### aspects of the statistic,
+    ### respectively, and must be Strings or objects which respond to #to_s. 
+    def initialize( element=:Li, devel_name=DEFAULT_DEVEL_NAME, linear_name=DEFAULT_LINEAR_NAME, options={} )
+        @developmental     = FaerieMUD::DevelopmentalObject.new( element )
+        @devel_name        = devel_name ? devel_name.to_s : DEFAULT_DEVEL_NAME
+        @linear_name       = linear_name ? linear_name.to_s : DEFAULT_LINEAR_NAME
         @linear_adjustment = 0
 
@@ -118 +120 @@
     end
 
+
+    ### Return a copy of the receiver with its linear aspect decremented by +value+.
+    def -( value )
+        copy = self.dup
+        copy.linear -= value
+        return copy
+    end
+    
+    
+    ### Subtract +value+ from the linear aspect of the statistic.
+    ### :TODO: Decrement the developmental aspect once the linear is zero.
+    def decrement( value )
+        self.linear -= value
+    end
+    
+    
+    ### Return a copy of the receiver with its linear aspect incremented by +value+.
+    def +( value )
+        copy = self.dup
+        copy.linear += value
+        return copy
+    end
+    
+
+    ### Add +value+ to the linear aspect of the statistic, with bounds-checking.
+    def increment( value )
+        self.linear += value
+        return self
+    end
+    
 
     ### Return the linear aspect of the statistic (an Integer)
@@ -162 +194 @@
     def to_s
         "<%s/%s: %d/%d>" % [
-            self.devel_name.capitalize,
-            self.linear_name.capitalize,
+            self.devel_name.to_s.capitalize,
+            self.linear_name.to_s.capitalize,
             self.developmental.to_i,
             self.linear,

trunk/spec/fm/periodicobject/element_spec.rb

@@ -76 +76 @@
     it "raises an appropriate exception for other invalid values" do
         lambda {
-            FaerieMUD::PeriodicObject::Element.fetch( nil )
+            FaerieMUD::PeriodicObject::Element.fetch( Object )
         }.should raise_error( ArgumentError, /no such element/i )
     end

trunk/spec/fm/statistic_spec.rb

@@ -23 +23 @@
 
 describe FaerieMUD::Statistic do
+    include FaerieMUD::SpecHelpers,
+            FaerieMUD::TestConstants
 
+    before( :all ) do
+        setup_logging( :crit )
+    end
+    
+    after( :all ) do
+        reset_logging()
+    end
+
+    
     it "can be instantiated with no arguments" do
         stat = FaerieMUD::Statistic.new
+        stat.developmental.element.should == FaerieMUD::PeriodicObject::Element.fetch( :Lithium )
         stat.devel_name.should == 'developmental'
+        stat.linear_name.should == 'linear'
     end
 
+    it "can be instantiated with an element name" do
+        stat = FaerieMUD::Statistic.new( 'Magnesium' )
+        stat.developmental.element.should == FaerieMUD::PeriodicObject::Element.fetch( :Mg )
+        stat.devel_name.should == 'developmental'
+        stat.linear_name.should == 'linear'
+    end
+    
+    it "can be instantiated with an atomic number" do
+        stat = FaerieMUD::Statistic.new( 28 )
+        stat.developmental.element.should == FaerieMUD::PeriodicObject::Element.fetch( :Ni )
+        stat.devel_name.should == 'developmental'
+        stat.linear_name.should == 'linear'
+    end
+    
+
+    it "can be instantiated with an element symbol" do
+        stat = FaerieMUD::Statistic.new( :Ac )
+        stat.developmental.element.should == FaerieMUD::PeriodicObject::Element.fetch( :Actinium )
+        stat.devel_name.should == 'developmental'
+        stat.linear_name.should == 'linear'
+    end
+    
+
     it "can be instantiated with a development name as a String" do
-        stat = FaerieMUD::Statistic.new( 'test1' )
+        stat = FaerieMUD::Statistic.new( :n, 'test1' )
+        stat.developmental.element.should == FaerieMUD::PeriodicObject::Element.fetch( :N )
         stat.devel_name.should == 'test1'
+        stat.linear_name.should == 'linear'
     end
     
     it "can be instantiated with a development name as a Symbol" do
-        stat = FaerieMUD::Statistic.new( :test1 )
+        stat = FaerieMUD::Statistic.new( :N, :test1 )
+        stat.developmental.element.should == FaerieMUD::PeriodicObject::Element.fetch( :N )
         stat.devel_name.should == 'test1'
+        stat.linear_name.should == 'linear'
     end
 
     it "can be instantiated with a development name and a linear name as a String" do
-        FaerieMUD::Statistic.new( 'test1', 'test2' )
+        stat = FaerieMUD::Statistic.new( :Nitrogen, 'test1', 'test2' )
+        stat.developmental.element.should == FaerieMUD::PeriodicObject::Element.fetch( :N )
+        stat.devel_name.should == 'test1'
+        stat.linear_name.should == 'test2'
     end
     
     it "can be instantiated with a development name and a linear name as a Symbol" do
-        FaerieMUD::Statistic.new( 'test1', :test2 )
+        stat = FaerieMUD::Statistic.new( 17, 'test1', :test2 )
+        stat.developmental.element.should == FaerieMUD::PeriodicObject::Element.fetch( :Chlorine )
+        stat.devel_name.should == 'test1'
+        stat.linear_name.should == 'test2'
     end
 
-    it "can be instantiated with both names and an element name" do
-        FaerieMUD::Statistic.new( 'test1', 'test2', 'Nitrogen' )
-    end
     
-    it "can be instantiated with both names and an element symbol" do
-        FaerieMUD::Statistic.new( 'test1', 'test2', 'Nitrogen' )
-    end
-    
-    it "can be instantiated with both names and a numeric element"
-
-    it "provides a reasonable default for an unspecified development name"
-    it "provides a reasonable default for an unspecified linear name"
-    it "provides a reasonable default for an unspecified linear name"
-    
+    describe "instance" do
+        before( :each ) do
+            @stat = FaerieMUD::Statistic.new( :Se, 'vitality', 'energy' )
+        end
 
 
-    # Argument sets to test the constructor with, along with what the result
-    # should be.
-    ArgSets = {
-        # Valid args: { :devel_name, :linear_name, :element }
-        []                              => FaerieMUD::Statistic,
-        ["test1"]                       => FaerieMUD::Statistic,
-        [:test1]                        => FaerieMUD::Statistic,
-        [nil, "test2"]                  => FaerieMUD::Statistic,
-        [nil, :test2]                   => FaerieMUD::Statistic,
-        ["test1", "test2", nil]         => FaerieMUD::Statistic,
-        ["test1", "test2"]              => FaerieMUD::Statistic,
-        [:test1, :test2]                => FaerieMUD::Statistic,
-        ["test1", "test2", :Yb]         => FaerieMUD::Statistic,
-        [nil, nil, :Yb]                 => FaerieMUD::Statistic,
-        ["test1", "test2", :Lithium]    => FaerieMUD::Statistic,
-        ["test1", "test2", "Mg"]        => FaerieMUD::Statistic,
-        ["test1", "test2", :boron]      => FaerieMUD::Statistic,
-        ["test1", "test2", "es"]        => FaerieMUD::Statistic,
-        ["test1", "test2", 71 ]         => FaerieMUD::Statistic,
-
-        # Invalid arg lists
-        ["test1", "test2", :foo]        => ArgumentError,
-        ["test1", "test2", false]       => TypeError,
+        it "doesn't allow its linear value to fall below 0" do
+            @stat.linear = -10
+            @stat.linear.should == 0
+        end
         
-    }
-
-    Interface = [
-        :devel_name,
-        :devel_name=,
-        :linear_name,
-        :linear_name=,
-        :element,
-        :element=,
-        :developmental,
-        :linear_adjustment,
-        :linear,
-        :linear=,
-        :average,
-        :to_s,
-    ]       
-
-    # The arguments to be used for the testing statistic
-    TestArgSet = {:devel_name => "test1", :linear_name => "test2", :element => 22}
-
-
-    #################################################################
-    ### E X A M P L E S
-    #################################################################
-
-    ### Instance test
-    def test_00_Instance
-        rval = nil
-        printTestHeader "Statistic: Instantiation"
-
-        assert_instance_of Class, FaerieMUD::Statistic
-
-        # Test various valid argument configurations
-        ArgSets.each {|arglist, result|
-            args = {}
-            args[:devel_name] = arglist[0] unless arglist[0].nil?
-            args[:linear_name] = arglist[1] unless arglist[1].nil?
-            args[:element] = arglist[2] unless arglist[2].nil?
-
-            description = "for args = %s, result = %s" %
-                [ args.inspect, result.inspect ]
-                
-            if result < Exception
-                assert_raises( result, description ) {
-                    FaerieMUD::Statistic::new( args )
-                }
-            else
-                elem = FaerieMUD::PeriodicObject::Element::fetch( args[:element] || 1 )
-                assert_nothing_raised( description ) {
-                    rval = FaerieMUD::Statistic::new( args )
-                }
-                assert_instance_of FaerieMUD::Statistic, rval
-                
-            end
-        }
-
-        self.class.addSetupBlock {
-            @stat = FaerieMUD::Statistic::new( TestArgSet )
-        }
-        self.class.addTeardownBlock {
-            @stat = nil
-        }
-    end
-
-
-    ### Test the statistic's interface
-    def test_10_interface
-        rval = nil
-        printTestHeader "Statistic: Interface"
-
-        Interface.each do |meth|
-            assert_respond_to @stat, meth
-            if /=/ =~ meth.to_s
-                assert_raises( ArgumentError, "#{meth}" ) { @stat.send(meth) }
-            else
-                assert_nothing_raised( "#{meth}" ) { rval = @stat.send(meth) }
-            end
+        
+        it "doesn't allow its linear value to exceed its developmental aspect" do
+            @stat.linear = 60
+            @stat.linear.should == 34
         end
-    end
-
-
-    ### Test the developmental part
-    def test_20_developmental
-        rval = nil
-        printTestHeader "Statistic: Developmental Aspect"
-
-        assert_nothing_raised { rval = @stat.developmental }
-        assert_instance_of FaerieMUD::DevelopmentalObject, rval
-    end
-
-
-    ### Test linear part
-    def test_25_linear
-        rval = nil
-        printTestHeader "Statistic: Linear Aspect"
-
-        # The linear value should be the same as the initial developmental value
-        assert_nothing_raised { rval = @stat.linear }
-        assert_equal TestArgSet[:element], rval, "initial linear value"
-
-        # Subtract increasing values, making sure the offset stuff is working
-        # correctly.
-        [ 0, 1, 4, 12 ].inject {|total, val|
-            assert_nothing_raised {
-                @stat.linear -= val
-                rval = @stat.linear
-            }
-            assert_equal TestArgSet[:element] - total - val, rval,
-                "linear value after subtracting #{val} (#{total} total)"
-            total + val
-        }
-
-        # Try subtracting something that would make it negative. It should be
-        # zero.
-        assert_nothing_raised {
-            @stat.linear -= TestArgSet[:element] * 2
-            rval = @stat.linear
-        }
-        assert_equal 0, rval,
-            "linear value after subtracting #{TestArgSet[:element] * 2}"
-
-
-        # Try adding a number that would make it exceed the developmental
-        # value. It should max out at what it started at.
-        assert_nothing_raised {
-            @stat.linear += TestArgSet[:element] * 2
-            rval = @stat.linear
-        }
-        assert_equal TestArgSet[:element], rval,
-            "linear value after incrementing out-of-bounds"
-    end 
-
-
-    ### Test duplication
-    def test_30_Duplication
-        rval = nil
-
-        assert_nothing_raised { rval = @stat.clone }
-        assert_instance_of FaerieMUD::Statistic, rval
-        assert_not_same @stat, rval
-        assert_same @stat.developmental.element,
-            rval.developmental.element,
-            "Elements of the statistic should be identical"
+        
+        
+        it "allows its linear value to be decremented" do
+            @stat.decrement( 40 )
+            @stat.linear.should == 0
+        end
+        
+        it "allows its linear value to be incremented" do
+            @stat.linear = 0
+            @stat.increment( 20 )
+            @stat.linear.should == 20
+        end
+        
     end