rats 0.1.1 → 0.2.0

data/README.rdoc

@@ -2,7 +2,8 @@
 
 a.k.a. Ruby Alberta Township System
 
-A ruby class to help with using the Alberta Township System
+A ruby class to help with using the Alberta Township System.  This class will allow
+you to create and represent townships, sections and quarter sections.
 
 You may find it amusing that Alberta was Rat-free ... until now.
 
@@ -96,32 +97,6 @@ For example, NE 1-2-3 W4 and 40300201NE are both recognized and parsed.
 Included is string creation that can create common representations of the
 location.
 
-=== Traversing
-
-NOTE: This is experimental and can probably be improved and made more exact.
-See 'Assumptions' to see where possible errors may exist.
-
-In this case, traverse means go North, South, East or West of a given location
-and know what the new location is.
-
-Within a Township you can traverse any direction from:
-- quarter to quarter
-- quarter to section
-- section to section
-
-When leaving a Township, you can only traverse West and East from:
-- quarter to quarter
-- quarter to section
-- quarter to township
-- section to section
-- section to township
-- township to township
-
-NOTE: The limitation in traversing from one Township to another is
-due to correction lines and the nature that Townships due no run vertical
-from North to South.  It might be possible to include a way to allow this
-but I do not currently need it.
-
 = Usage
 
 # parse a location
@@ -137,11 +112,6 @@ quarter_section.township
 quarter_section.range
 quarter_section.meridian
 
-# traverse
-new_quarter_section = quarter_section.left
-new_quarter_section = quarter_section.left.down
-new_section = quarter_section.left(:section)
-
 = Information
 
 == links
@@ -151,47 +121,26 @@ http://en.wikipedia.org/wiki/Alberta_Township_System
 == Road Map
 
 Future:
-- correct assumption #3 (see below)
+- either correct the assumption that all quarters are valid in a valid
+  section, or remove validation completely (re: all or none)
 - add support for Saskatchewan (no timeline, need to find data)
 - address bugs, if any
 
 Except for the above, once this gem is finalized, I do not see future
-development happening unless the North-South Township traversing needs
-to be addressed or I want to add ATS to other-system conversions
+development happening unless I want to add ATS to other-system conversions
 (ie: latitude/longitude).  Nothing else is planned.
 
 Currently this point has not been reached and this gem is still in development.
 
 == Assumptions
 
-I make 3 key assumptions.
-
-The only assumptions made are in respects to traversing.  I do assume that
-(#1) traversing within a township, that all sections and quarter sections are
-perfectly aligned.  If this is not correct, it must be pretty close, and
-is close enough for my purpose.
-
-(#2) I also assume that all townships are perfectly aligned from East to West.
-
-UPDATE: Based on some GPS data I have access to, the range line (x-axis)
-doesn't seem to run perfectly straight from East-to-West, but actually drops
-a bit South as you go West.  I still assume that quarters/sections/townships
-are aligned East-to-West, or rather Right-to-Left, they just follow this pattern
-of dropping a bit South as you go West.  What this means is that the functions
-I use to traverse locations are a bit of a lie.  The function .east() and .west()
-imply that you are traversing East and West, when they are actually slightly askew,
-and could be called .east_and_ever_so_slightly_south() and
-.west_and_ever_so_slightly_north() ... but I will leave them named as is.
-
-(#3) Lastly, I assume that within every valid section, all four quarters are valid.
-This has been confirmed to be incorrect.  I have recently found a way to get this
-data but it will take some time to collect it.  I will remove this assumption in a
-future version.
+As currently written, I assume that within every valid section, all four quarters
+are valid. I know this to be incorrect.
 
 == Environment
 
 This gem was created using:
-- ruby 1.9.1-p378
+- ruby 1.9.1-p378, 1.9.2-head
 - rspec 1.3.0
 - rake 0.8.7
 

data/VERSION

@@ -1 +1 @@
-0.1.1
+0.2.0

data/lib/rats/base.rb

@@ -113,84 +113,6 @@ module Rats
       end
     end
     
-    def up(level=nil); self.traverse(:up, level); end
-    def down(level=nil); self.traverse(:down, level); end
-    def left(level=nil); self.traverse(:left, level); end
-    def right(level=nil); self.traverse(:right, level); end
-    alias north up
-    alias south down
-    alias west left
-    alias east right
-    
-    # this just walks from location to location in the given direction until
-    # it finds the next valid location.
-    #
-    def traverse(direction, level=nil)
-      return unless direction
-      
-      new_location = self.dup
-      # change the scope of the traverse
-      # eg. allow quarter section to traverse to a section
-      #
-      case level
-      when :section
-        # we are traversing by section, remove quarter
-        new_location.q.nil!
-      when :township
-        # we are traversing by section, remove quarter & section
-        new_location.q.nil!
-        new_location.s.nil!
-      end
-
-      the_scope = new_location.scope
-      begin
-        case the_scope
-        when :quarter
-          new_location._traverse_quarter(direction)
-        when :section
-          new_location._traverse_section(direction)
-        when :township
-          new_location._traverse_range(direction)
-        end
-      end until new_location.valid?
-      new_location
-    end
-     
-    def _traverse_quarter(direction)
-      begin
-        self.q = self.q.send(direction)
-      rescue OutOfSection
-        self.q = self.q.send(direction.to_s + '!')
-        self._traverse_section(direction)
-      end
-    end
-  
-    def _traverse_section(direction)
-      begin
-        self.s = self.s.send(direction)
-      rescue OutOfTownship
-        self.s = self.s.send(direction.to_s + '!')
-        self._traverse_range(direction)
-      end
-    end
-  
-    def _traverse_range(direction)
-      begin
-        self.r = self.r.send(direction)
-      rescue OutOfMeridian
-        self.r = self.r.send(direction.to_s + '!')
-        self._traverse_meridian(direction)
-      end
-    end
-  
-    def _traverse_meridian(direction)
-      begin
-        self.m = self.m.send(direction)
-      rescue
-        raise OutOfAlberta
-      end
-    end
-    
     def to_a
       [self.quarter, self.section, self.township, self.range, self.meridian].compact
     end

data/lib/rats/data/base.rb

@@ -43,32 +43,6 @@ module Rats
       return nil unless @value
       self.value.to_s.rjust(self.class.padding_width,self.class.padding_value)
     end
-  
-    #
-    # TRAVERSING
-    #
-    # - it is expected that a specfic data sub-class will define this
-    #
-    
-    def up; traverse(:up); end
-    def up!; traverse!(:up); end
-    alias north up
-    alias north! up!
-    
-    def right; traverse(:right); end
-    def right!; traverse!(:right); end
-    alias east right
-    alias east! right!
-    
-    def down; traverse(:down); end
-    def down!; traverse!(:down); end
-    alias south down
-    alias south! down!
-    
-    def left; traverse(:left); end
-    def left!; traverse!(:left); end
-    alias west left
-    alias west! left!
     
     #
     # VALIDATION
@@ -79,11 +53,6 @@ module Rats
     def valid?
       true
     end
-    
-    private
-    
-    def traverse(direction); raise NotImplementedError; end
-    def traverse!(direction); raise NotImplementedError; end
   
   end
 end

data/lib/rats/data/meridian.rb

@@ -17,27 +17,6 @@ module Rats
     end
     
     def to_s; "W" + self.value.to_s; end
-    
-    private
-    
-    # as a meridian, we can only safely traverse within alberta
-    
-    def traverse(direction)
-      raise ArgumentError unless self.v
-      new_value = case direction.downcase.to_sym
-      when :up
-        raise IllegalTraverse
-      when :right
-        self.v.to_i > VALID_MERIDIANS.min ? self.v.to_i - 1 : nil
-      when :down
-        raise IllegalTraverse
-      when :left
-        self.v.to_i < VALID_MERIDIANS.max ? self.v.to_i + 1 : nil
-      end
-      raise Rats::OutOfAlberta if new_value.nil?
-      Rats::Meridian.new(new_value)
-    end
-    alias traverse! traverse
 
   end
 end

data/lib/rats/data/quarter.rb

@@ -3,20 +3,6 @@ module Rats
     
     VALID_QUARTERS = [:ne, :nw, :se, :sw]
     
-    # order: up, right, down, left
-    UNBOUNDED_QUARTER_MATRIX = {
-      :se => [:ne, :sw, :ne, :sw],
-      :sw => [:nw, :se, :nw, :se],
-      :nw => [:sw, :ne, :sw, :ne],
-      :ne => [:se, :nw, :se, :nw]
-    }
-    BOUNDED_QUARTER_MATRIX = {
-      :se => [:ne, nil, nil, :sw],
-      :sw => [:nw, :se, nil, nil],
-      :nw => [nil, :ne, :sw, nil],
-      :ne => [nil, nil, :se, :nw]
-    }
-    
     def self.padding_width; 2; end
     def self.padding_value; " "; end
     
@@ -27,41 +13,6 @@ module Rats
     def valid?
       VALID_QUARTERS.include?(self.value.to_s.downcase.to_sym)
     end
-
-    private
-    
-    # as a quarter, we can only safely traverse within a section
-    
-    def traverse(direction)
-      raise ArgumentError unless self.v
-      new_value = case direction.downcase.to_sym
-      when :up
-        BOUNDED_QUARTER_MATRIX[self.v.to_s.downcase.to_sym][0]
-      when :right
-        BOUNDED_QUARTER_MATRIX[self.v.to_s.downcase.to_sym][1]
-      when :down
-        BOUNDED_QUARTER_MATRIX[self.v.to_s.downcase.to_sym][2]
-      when :left
-        BOUNDED_QUARTER_MATRIX[self.v.to_s.downcase.to_sym][3]
-      end
-      raise Rats::OutOfSection if new_value.nil?
-      Rats::Quarter.new(new_value)
-    end
-    
-    def traverse!(direction)
-      raise ArgumentError unless self.v
-      new_value = case direction.downcase.to_sym
-      when :up
-        UNBOUNDED_QUARTER_MATRIX[self.v.to_s.downcase.to_sym][0]
-      when :right
-        UNBOUNDED_QUARTER_MATRIX[self.v.to_s.downcase.to_sym][1]
-      when :down
-        UNBOUNDED_QUARTER_MATRIX[self.v.to_s.downcase.to_sym][2]
-      when :left
-        UNBOUNDED_QUARTER_MATRIX[self.v.to_s.downcase.to_sym][3]
-      end
-      Rats::Quarter.new(new_value)
-    end
     
   end
 end

data/lib/rats/data/range.rb

@@ -14,46 +14,11 @@ module Rats
     # NOTE: this does not take into consideration that some ranges do not
     # exist for some meridians and township (y-axis) values ... but we
     # would need to know those values, and that is outside the scope
-    # of the Range class.  The Base class will handle these cases.
+    # of the Range class.
     #
     def valid?
       VALID_RANGES.include?(self.value.to_i)
     end
     
-    private
-    
-    # as a range, we can only safely traverse within a meridian
-    
-    def traverse(direction)
-      raise ArgumentError unless self.v
-      new_value = case direction.downcase.to_sym
-      when :up
-        raise IllegalTraverse
-      when :right
-        self.v.to_i > VALID_RANGES.min ? self.v.to_i - 1 : nil
-      when :down
-        raise IllegalTraverse
-      when :left
-        self.v.to_i < VALID_RANGES.max ? self.v.to_i + 1 : nil
-      end
-      raise Rats::OutOfMeridian if new_value.nil?
-      Rats::Range.new(new_value)
-    end
-    
-    def traverse!(direction)
-      raise ArgumentError unless self.v
-      new_value = case direction.downcase.to_sym
-      when :up
-        raise IllegalTraverse
-      when :right
-        self.v.to_i > VALID_RANGES.min ? self.v.to_i - 1 : VALID_RANGES.max
-      when :down
-        raise IllegalTraverse
-      when :left
-        self.v.to_i < VALID_RANGES.max ? self.v.to_i + 1 : VALID_RANGES.min
-      end
-      Rats::Range.new(new_value)
-    end
-    
   end
 end

data/lib/rats/data/section.rb

@@ -3,84 +3,6 @@ module Rats
     
     VALID_SECTIONS = (1..36)
     
-    UNBOUNDED_SECTION_MATRIX = {
-      1 => [12, 6, nil, 2],
-      2 => [11, 1, nil, 3],
-      3 => [10, 2, nil, 4],
-      4 => [9, 3, nil, 5],
-      5 => [8, 4, nil, 6],
-      6 => [7, 5, nil, 1],
-      7 => [18, 8, 6, 12],
-      8 => [17, 9, 5, 7],
-      9 => [16, 10, 4, 8],
-      10 => [15, 11, 3, 9],
-      11 => [14, 12, 2, 10],
-      12 => [13, 7, 1, 11],
-      13 => [24, 18, 12, 14],
-      14 => [23, 13, 11, 15],
-      15 => [22, 14, 10, 16],
-      16 => [21, 15, 9, 17],
-      17 => [20, 16, 8, 18],
-      18 => [19, 17, 7, 13],
-      19 => [30, 20, 18, 24],
-      20 => [29, 21, 17, 19],
-      21 => [28, 22, 16, 20],
-      22 => [27, 23, 15, 21],
-      23 => [26, 24, 14, 22],
-      24 => [25, 19, 13, 23],
-      25 => [36, 30, 24, 26],
-      26 => [35, 25, 23, 27],
-      27 => [34, 26, 22, 28],
-      28 => [33, 27, 21, 29],
-      29 => [32, 28, 20, 30],
-      30 => [31, 29, 19, 25],
-      31 => [nil, 32, 30, 36],
-      32 => [nil, 33, 29, 31],
-      33 => [nil, 34, 28, 32],
-      34 => [nil, 35, 27, 33],
-      35 => [nil, 36, 26, 34],
-      36 => [nil, 31, 25, 35],
-    }
-    
-    BOUNDED_SECTION_MATRIX = {
-      1 => [12, nil, nil, 2],
-      2 => [11, 1, nil, 3],
-      3 => [10, 2, nil, 4],
-      4 => [9, 3, nil, 5],
-      5 => [8, 4, nil, 6],
-      6 => [7, 5, nil, nil],
-      7 => [18, 8, 6, nil],
-      8 => [17, 9, 5, 7],
-      9 => [16, 10, 4, 8],
-      10 => [15, 11, 3, 9],
-      11 => [14, 12, 2, 10],
-      12 => [13, nil, 1, 11],
-      13 => [24, nil, 12, 14],
-      14 => [23, 13, 11, 15],
-      15 => [22, 14, 10, 16],
-      16 => [21, 15, 9, 17],
-      17 => [20, 16, 8, 18],
-      18 => [19, 17, 7, nil],
-      19 => [30, 20, 18, nil],
-      20 => [29, 21, 17, 19],
-      21 => [28, 22, 16, 20],
-      22 => [27, 23, 15, 21],
-      23 => [26, 24, 14, 22],
-      24 => [25, nil, 13, 23],
-      25 => [36, nil, 24, 26],
-      26 => [35, 25, 23, 27],
-      27 => [34, 26, 22, 28],
-      28 => [33, 27, 21, 29],
-      29 => [32, 28, 20, 30],
-      30 => [31, 29, 19, nil],
-      31 => [nil, 32, 30, nil],
-      32 => [nil, 33, 29, 31],
-      33 => [nil, 34, 28, 32],
-      34 => [nil, 35, 27, 33],
-      35 => [nil, 36, 26, 34],
-      36 => [nil, nil, 25, 35],
-    }
-    
     def self.padding_width; 2; end
     def self.padding_value; "0"; end
     
@@ -89,46 +11,9 @@ module Rats
       value.to_i > 0 ? value.to_i : nil
     end
     
-    
     def valid?
       VALID_SECTIONS.include?(self.value.to_i)
     end
-    
-    private
-    
-    # as a section, we can only safely traverse within a township
-    
-    def traverse(direction)
-      raise ArgumentError unless self.v
-      new_value = case direction.downcase.to_sym
-      when :up
-        BOUNDED_SECTION_MATRIX[self.v.to_i][0]
-      when :right
-        BOUNDED_SECTION_MATRIX[self.v.to_i][1]
-      when :down
-        BOUNDED_SECTION_MATRIX[self.v.to_i][2]
-      when :left
-        BOUNDED_SECTION_MATRIX[self.v.to_i][3]
-      end
-      raise Rats::OutOfTownship if new_value.nil?
-      Rats::Section.new(new_value)
-    end
-    
-    def traverse!(direction)
-      raise ArgumentError unless self.v
-      new_value = case direction.downcase.to_sym
-      when :up
-        UNBOUNDED_SECTION_MATRIX[self.v.to_i][0]
-      when :right
-        UNBOUNDED_SECTION_MATRIX[self.v.to_i][1]
-      when :down
-        UNBOUNDED_SECTION_MATRIX[self.v.to_i][2]
-      when :left
-        UNBOUNDED_SECTION_MATRIX[self.v.to_i][3]
-      end
-      raise Rats::IllegalTraverse if new_value.nil?
-      Rats::Section.new(new_value)
-    end
    
   end
 end

data/lib/rats/data/township.rb

@@ -14,14 +14,11 @@ module Rats
     # NOTE: this does not take into consideration that some townships do not
     # exist for some meridians and ranges (x-axis) values ... but we
     # would need to know those values, and that is outside the scope
-    # of the Township class.  The Base class will handle these cases.
+    # of the Township class.
     #
     def valid?
       VALID_TOWNSHIPS.include?(self.value.to_i)
     end
     
-    def traverse(direction); raise IllegalTraverse; end
-    alias taverse! traverse
-    
   end
 end

data/lib/rats.rb

@@ -13,11 +13,9 @@ module Rats
   # custom errors
   #
   class OutOfBounds < StandardError; end
-  class OutOfSection < OutOfBounds; end
-  class OutOfTownship < OutOfBounds; end
-  class OutOfMeridian < OutOfBounds; end
-  class OutOfAlberta < OutOfBounds; end
-  
-  class IllegalTraverse < StandardError; end
-  
+  #class OutOfSection < OutOfBounds; end
+  #class OutOfTownship < OutOfBounds; end
+  #class OutOfMeridian < OutOfBounds; end
+  #class OutOfAlberta < OutOfBounds; end
+    
 end

data/rats.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{rats}
-  s.version = "0.1.1"
+  s.version = "0.2.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Mark G"]
-  s.date = %q{2010-04-02}
+  s.date = %q{2010-04-13}
   s.description = %q{A ruby class to help with using the Alberta Township System}
   s.email = %q{rats@attackcorp.com}
   s.extra_rdoc_files = [

data/spec/data/data_spec.rb

@@ -79,44 +79,4 @@ describe Rats::Data do
     
   end
   
-  describe "traversing" do
-    
-    before(:each) do
-      @data = Rats::Data.new
-    end
-    
-    it "stubs left" do
-      lambda { @data.left }.should raise_error(NotImplementedError)
-    end
-    
-    it "stubs west" do
-      lambda { @data.west }.should raise_error(NotImplementedError)
-    end
-    
-    it "stubs right" do
-      lambda { @data.right }.should raise_error(NotImplementedError)
-    end
-    
-    it "stubs east" do
-      lambda { @data.east }.should raise_error(NotImplementedError)
-    end
-    
-    it "stubs up" do
-      lambda { @data.up }.should raise_error(NotImplementedError)
-    end
-    
-    it "stubs north" do
-      lambda { @data.north }.should raise_error(NotImplementedError)
-    end
-    
-    it "stubs down" do
-      lambda { @data.down }.should raise_error(NotImplementedError)
-    end
-    
-    it "stubs south" do
-      lambda { @data.south }.should raise_error(NotImplementedError)
-    end
-    
-  end
-  
 end

data/spec/data/meridian_spec.rb

@@ -21,34 +21,6 @@ describe Rats::Meridian do
     
   end
   
-  describe "traversing" do
-    
-    describe "correctly" do
-      
-      it "moves up" do
-        data = Rats::Meridian.new("5")
-        lambda { data.up }.should raise_error(Rats::IllegalTraverse)
-      end
-      
-      it "moves right" do
-        data = Rats::Meridian.new("5")
-        data.right.v.should == 4
-      end
-      
-      it "moves down" do
-        data = Rats::Meridian.new("5")
-        lambda { data.up }.should raise_error(Rats::IllegalTraverse)
-      end
-      
-      it "moves left" do
-        data = Rats::Meridian.new("5")
-        data.left.v.should == 6
-      end
-      
-    end
-
-  end
-  
   describe "read/write" do
     
     it "returns a padded value" do

data/spec/data/quarter_spec.rb

@@ -21,56 +21,4 @@ describe Rats::Quarter do
     
   end
   
-  describe "traversing" do
-    
-    describe "correctly" do
-      
-      it "moves up" do
-        data = Rats::Quarter.new("SE")
-        data.up.v.should == "NE"
-      end
-      
-      it "moves right" do
-        data = Rats::Quarter.new("NW")
-        data.right.v.should == "NE"
-      end
-      
-      it "moves down" do
-        data = Rats::Quarter.new("NW")
-        data.down.v.should == "SW"
-      end
-      
-      it "moves left" do
-        data = Rats::Quarter.new("NE")
-        data.left.v.should == "NW"
-      end
-      
-    end
-    
-    describe "out of bounds" do
-      
-      it "moves up" do
-        data = Rats::Quarter.new("NE")
-        lambda { data.up }.should raise_error(Rats::OutOfBounds)
-      end
-      
-      it "moves right" do
-        data = Rats::Quarter.new("NE")
-        lambda { data.right }.should raise_error(Rats::OutOfBounds)
-      end
-      
-      it "moves down" do
-        data = Rats::Quarter.new("SE")
-        lambda { data.down }.should raise_error(Rats::OutOfBounds)
-      end
-      
-      it "moves left" do
-        data = Rats::Quarter.new("NW")
-        lambda { data.left }.should raise_error(Rats::OutOfBounds)
-      end
-      
-    end
-    
-  end
-  
 end

data/spec/data/range_spec.rb

@@ -21,34 +21,6 @@ describe Rats::Range do
     
   end
   
-  describe "traversing" do
-    
-    describe "correctly" do
-      
-      it "moves up" do
-        data = Rats::Range.new("5")
-        lambda { data.up }.should raise_error(Rats::IllegalTraverse)
-      end
-      
-      it "moves right" do
-        data = Rats::Range.new("5")
-        data.right.v.should == 4
-      end
-      
-      it "moves down" do
-        data = Rats::Range.new("5")
-        lambda { data.up }.should raise_error(Rats::IllegalTraverse)
-      end
-      
-      it "moves left" do
-        data = Rats::Range.new("5")
-        data.left.v.should == 6
-      end
-      
-    end
-
-  end
-  
   describe "read/write" do
     
     it "returns a padded value" do

data/spec/data/section_spec.rb

@@ -21,58 +21,6 @@ describe Rats::Section do
     
   end
   
-  describe "traversing" do
-    
-    describe "correctly" do
-      
-      it "moves up" do
-        data = Rats::Section.new("6")
-        data.up.v.should == 7
-      end
-      
-      it "moves right" do
-        data = Rats::Section.new("6")
-        data.right.v.should == 5
-      end
-      
-      it "moves down" do
-        data = Rats::Section.new("7")
-        data.down.v.should == 6
-      end
-      
-      it "moves left" do
-        data = Rats::Section.new("1")
-        data.left.v.should == 2
-      end
-      
-    end
-    
-    describe "out of bounds" do
-      
-      it "moves up" do
-        data = Rats::Section.new("36")
-        lambda { data.up }.should raise_error(Rats::OutOfBounds)
-      end
-      
-      it "moves right" do
-        data = Rats::Section.new("1")
-        lambda { data.right }.should raise_error(Rats::OutOfBounds)
-      end
-      
-      it "moves down" do
-        data = Rats::Section.new("1")
-        lambda { data.down }.should raise_error(Rats::OutOfBounds)
-      end
-      
-      it "moves left" do
-        data = Rats::Section.new("6")
-        lambda { data.left }.should raise_error(Rats::OutOfBounds)
-      end
-      
-    end
-
-  end
-  
   describe "read/write" do
     
     it "returns a padded value" do

data/spec/data/township_spec.rb

@@ -21,34 +21,6 @@ describe Rats::Township do
     
   end
   
-  describe "traversing" do
-    
-    describe "correctly" do
-      
-      it "moves up" do
-        data = Rats::Township.new("5")
-        lambda { data.up }.should raise_error(Rats::IllegalTraverse)
-      end
-      
-      it "moves right" do
-        data = Rats::Township.new("5")
-        lambda { data.up }.should raise_error(Rats::IllegalTraverse)
-      end
-      
-      it "moves down" do
-        data = Rats::Township.new("5")
-        lambda { data.up }.should raise_error(Rats::IllegalTraverse)
-      end
-      
-      it "moves left" do
-        data = Rats::Township.new("5")
-        lambda { data.up }.should raise_error(Rats::IllegalTraverse)
-      end
-      
-    end
-
-  end
-  
   describe "read/write" do
     
     it "returns a padded value" do

data/spec/rats_spec.rb

@@ -236,362 +236,6 @@ describe "Rats" do
     
   end
   
-  describe "taversing" do
-    
-    describe "from quarter to quarter" do
-    
-      describe "within a township" do
-    
-        describe "within a section" do
-      
-          it "knows what is up (north)" do
-            land = Rats.new("SE 1-2-3 W4")
-            land.up.location.should == "NE 1-2-3 W4"
-          end
-      
-          it "knows what is down (south)" do
-            land = Rats.new("NE 1-2-3 W4")
-            land.down.location.should == "SE 1-2-3 W4"
-          end
-      
-          it "knows what is left (west)" do
-            land = Rats.new("SE 1-2-3 W4")
-            land.left.location.should == "SW 1-2-3 W4"
-          end
-      
-          it "knows what is right (east)" do
-            land = Rats.new("SW 1-2-3 W4")
-            land.right.location.should == "SE 1-2-3 W4"
-          end
-      
-        end
-    
-        describe "outside a section" do
-        
-          it "knows what is up (north)" do
-            land = Rats.new("NE 1-2-3 W4")
-            land.up.location.should == "SE 12-2-3 W4"
-          end
-
-          it "knows what is down (south)" do
-            land = Rats.new("SE 12-2-3 W4")
-            land.down.location.should == "NE 1-2-3 W4"
-          end
-
-          it "knows what is left (west)" do
-            land = Rats.new("SW 1-2-3 W4")
-            land.left.location.should == "SE 2-2-3 W4"
-          end
-
-          it "knows what is right (east)" do
-            land = Rats.new("NE 2-2-3 W4")
-            land.right.location.should == "NW 1-2-3 W4"
-          end
-        
-        end
-        
-      end
-      
-      describe "outside a township (which implies outside a section)" do
-
-        # townships do not line up North to South, so you can't know
-        # what township/section/quarter is above another when you
-        # leave a township
-
-        it "knows it can't go up (north)" do
-          land = Rats.new("NE 36-2-3 W4")
-          lambda { land.up }.should raise_error(IllegalTraverse)
-        end
-
-        it "knows it can't go down (south)" do
-          land = Rats.new("SE 1-2-3 W4")
-          lambda { land.down }.should raise_error(IllegalTraverse)
-        end
-
-        it "knows what is left (west)" do
-          land = Rats.new("SW 6-2-3 W4")
-          land.left.location.should == "SE 1-2-4 W4"
-        end
-
-        it "knows what is right (east)" do
-          land = Rats.new("NE 1-2-3 W4")
-          land.right.location.should == "NW 6-2-2 W4"
-        end
-
-      end
-      
-      describe "outside a meridian (which implies outside a section and township)" do
-
-        # NOTE: you cannot leave a meridian by going North or South
-
-        it "knows what is left (west)" do
-          land = Rats.new("SW 6-2-30 W4")
-          land.left.location.should == "SE 1-2-1 W5"
-        end
-
-        it "knows what is right (east)" do
-          land = Rats.new("NE 1-2-1 W5")
-          land.right.location.should == "NW 6-2-30 W4"
-        end
-
-      end
-      
-      describe "with complicated gaps in valid quarter sections" do
-        
-        # this is the ultimate test(s).  Can we traverse to the next quarter
-        # when the normal rules do not apply for what is next?
-        
-        def skip(q,s,t,m)
-          skips = (q + s*2 + t*6*2 + m*30*6*2) || 0
-          skips -= 1 unless skips == 0
-          answers = ([false]*skips + [true]).to_a
-        
-          Rats::Base.any_instance.stubs(:valid?).returns(*answers)
-        end
-        
-        it "should skip sections going left (west)" do 
-          skip(1,0,0,0)
-          
-          land = Rats.new("NE 1-1-2 W4")
-          new_land = land.left
-          new_land.location.should == "NW 1-1-2 W4"
-        end
-        
-        it "should skip sections going left (west)" do 
-          skip(0,1,0,0)
-          
-          land = Rats.new("NW 1-1-2 W4")
-          new_land = land.left
-          new_land.location.should == "NW 2-1-2 W4"
-        end
-        
-        it "should skip sections going left (west)" do 
-          skip(0,0,1,0)
-          
-          land = Rats.new("NW 1-1-2 W4")
-          new_land = land.left
-          new_land.location.should == "NW 1-1-3 W4"
-        end
-        
-        it "should skip sections going left (west)" do 
-          skip(0,0,0,1)
-          
-          land = Rats.new("NW 1-1-2 W4")
-          new_land = land.left
-          new_land.location.should == "NW 1-1-2 W5"
-        end
-        
-      end
-      
-    end
-    
-    describe "from section to section" do
-    
-      describe "within a township" do
-      
-        it "knows what is up (north)" do
-          land = Rats.new("1-2-3 W4")
-          land.up.location.should == "12-2-3 W4"
-        end
-      
-        it "knows what is down (south)" do
-          land = Rats.new("7-2-3 W4")
-          land.down.location.should == "6-2-3 W4"
-        end
-      
-        it "knows what is left (west)" do
-          land = Rats.new("12-2-3 W4")
-          land.left.location.should == "11-2-3 W4"
-        end
-      
-        it "knows what is right (east)" do
-          land = Rats.new("6-2-3 W4")
-          land.right.location.should == "5-2-3 W4"
-        end
-      
-      end
-    
-      describe "outside a township" do
-        
-        # townships do not line up North to South, so you can't know
-        # what township/section/quarter is above another when you
-        # leave a township
-      
-        it "knows it can't go up (north)" do
-          land = Rats.new("35-2-3 W4")
-          lambda { land.up }.should raise_error(IllegalTraverse)
-        end
-
-        it "knows it can't go down (south)" do
-          land = Rats.new("1-2-3 W4")
-          lambda { land.down }.should raise_error(IllegalTraverse)
-        end
-
-        it "knows what is left (west)" do
-          land = Rats.new("6-2-3 W4")
-          land.left.location.should == "1-2-4 W4"
-        end
-
-        it "knows what is right (east)" do
-          land = Rats.new("1-2-3 W4")
-          land.right.location.should == "6-2-2 W4"
-        end
-        
-      end
-      
-    end
-    
-    describe "from township to township" do
-      
-      describe "within a meridian" do
-              
-        it "knows it can't go up (north)" do
-          land = Rats.new("2-3 W4")
-          lambda { land.up }.should raise_error(IllegalTraverse)
-        end
-        
-        it "knows it can't go down (south)" do
-          land = Rats.new("2-3 W4")
-          lambda { land.down }.should raise_error(IllegalTraverse)
-        end
-      
-        it "knows what is left (west)" do
-          land = Rats.new("2-3 W4")
-          land.left.location.should == "2-4 W4"
-        end
-
-        it "knows what is right (east)" do
-          land = Rats.new("2-3 W4")
-          land.right.location.should == "2-2 W4"
-        end
-
-      end
-      
-    end
-    
-    describe "from quarter to section" do
-      
-      describe "within a township" do
-
-        it "knows what is up (north)" do
-          land = Rats.new("SE 1-2-3 W4")
-          land.up(:section).location.should == "12-2-3 W4"
-        end
-
-        it "knows what is down (south)" do
-          land = Rats.new("NE 7-2-3 W4")
-          land.down(:section).location.should == "6-2-3 W4"
-        end
-
-        it "knows what is left (west)" do
-          land = Rats.new("NE 12-2-3 W4")
-          land.left(:section).location.should == "11-2-3 W4"
-        end
-
-        it "knows what is right (east)" do
-          land = Rats.new("NW 6-2-3 W4")
-          land.right(:section).location.should == "5-2-3 W4"
-        end
-
-      end
-
-      describe "outside a township" do
-      
-        # townships do not line up North to South, so you can't know
-        # what township/section/quarter is above another when you
-        # leave a township
-      
-        it "knows it can't go up (north)" do
-          land = Rats.new("SE 35-2-3 W4")
-          lambda { land.up(:section) }.should raise_error(IllegalTraverse)
-        end
-      
-        it "knows it can't go down (south)" do
-          land = Rats.new("NE 1-2-3 W4")
-          lambda { land.down(:section) }.should raise_error(IllegalTraverse)
-        end
-      
-        it "knows what is left (west)" do
-          land = Rats.new("NE 6-2-3 W4")
-          land.left(:section).location.should == "1-2-4 W4"
-        end
-      
-        it "knows what is right (east)" do
-          land = Rats.new("NW 1-2-3 W4")
-          land.right(:section).location.should == "6-2-2 W4"
-        end
-      
-      end
-      
-    end
-    
-    describe "from quarter to township" do
-      
-      describe "within a meridian" do
-              
-        it "knows it can't go up (north)" do
-          land = Rats.new("NE 1-2-3 W4")
-          lambda { land.up(:township) }.should raise_error(IllegalTraverse)
-        end
-        
-        it "knows it can't go down (south)" do
-          land = Rats.new("NE 1-2-3 W4")
-          lambda { land.down(:township) }.should raise_error(IllegalTraverse)
-        end
-      
-        it "knows what is left (west)" do
-          land = Rats.new("NE 1-2-3 W4")
-          land.left(:township).location.should == "2-4 W4"
-        end
-
-        it "knows what is right (east)" do
-          land = Rats.new("NE 1-2-3 W4")
-          land.right(:township).location.should == "2-2 W4"
-        end
-
-      end
-      
-    end
-    
-    describe "from section to township" do
-      
-      describe "within a meridian" do
-              
-        it "knows it can't go up (north)" do
-          land = Rats.new("1-2-3 W4")
-          lambda { land.up(:township) }.should raise_error(IllegalTraverse)
-        end
-        
-        it "knows it can't go down (south)" do
-          land = Rats.new("1-2-3 W4")
-          lambda { land.down(:township) }.should raise_error(IllegalTraverse)
-        end
-      
-        it "knows what is left (west)" do
-          land = Rats.new("1-2-3 W4")
-          land.left(:township).location.should == "2-4 W4"
-        end
-
-        it "knows what is right (east)" do
-          land = Rats.new("1-2-3 W4")
-          land.right(:township).location.should == "2-2 W4"
-        end
-
-      end
-      
-    end
-    
-    describe "chaining" do
-      
-      it "allows chaining of traversing" do
-        land = Rats.new("NE 1-2-3 W4")
-        land.up.down.left.right.location.should == "NE 1-2-3 W4"
-      end
-      
-    end
-    
-  end
-  
   describe "formatting" do
     
     describe ":long" do

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 1
-  - 1
-  version: 0.1.1
+  - 2
+  - 0
+  version: 0.2.0
 platform: ruby
 authors: 
 - Mark G
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-04-02 00:00:00 -04:00
+date: 2010-04-13 00:00:00 -04:00
 default_executable: 
 dependencies: []