rats 0.1.0

data/lib/rats/data/meridian.rb

@@ -0,0 +1,43 @@
+module Rats
+  class Meridian < Data
+    
+    VALID_MERIDIANS = (4..6)
+    
+    def self.padding_width; 1; end
+    def self.padding_value; " "; end
+    
+    def self.transform(value)
+      return unless value
+      value = value.to_s.upcase.reverse.chomp('W').reverse
+      value.to_i > 0 ? value.to_i : nil
+    end
+    
+    def valid?
+      VALID_MERIDIANS.include?(self.value.to_i)
+    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

@@ -0,0 +1,67 @@
+module Rats
+  class Quarter < Data
+    
+    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
+    
+    def self.transform(value)
+      value.to_s.upcase if value
+    end
+    
+    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

@@ -0,0 +1,59 @@
+module Rats
+  class Range < Data
+    
+    VALID_RANGES = (1..30)
+    
+    def self.padding_width; 2; end
+    def self.padding_value; "0"; end
+    
+    def self.transform(value)
+      return unless value
+      value.to_i > 0 ? value.to_i : nil
+    end
+    
+    # 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.
+    #
+    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

@@ -0,0 +1,134 @@
+module Rats
+  class Section < Data
+    
+    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
+    
+    def self.transform(value)
+      return unless value
+      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

@@ -0,0 +1,27 @@
+module Rats
+  class Township < Data
+    
+    VALID_TOWNSHIPS = (1..126)
+    
+    def self.padding_width; 3; end
+    def self.padding_value; "0"; end
+    
+    def self.transform(value)
+      return unless value
+      value.to_i > 0 ? value.to_i : nil
+    end
+    
+    # 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.
+    #
+    def valid?
+      VALID_TOWNSHIPS.include?(self.value.to_i)
+    end
+    
+    def traverse(direction); raise IllegalTraverse; end
+    alias taverse! traverse
+    
+  end
+end

data/lib/rats/data.rb

@@ -0,0 +1,10 @@
+$:.unshift(File.dirname(__FILE__))
+
+# data
+#
+require 'data/base'
+require 'data/quarter'
+require 'data/section'
+require 'data/township'
+require 'data/range'
+require 'data/meridian'

data/lib/rats.rb

@@ -0,0 +1,23 @@
+$:.unshift(File.dirname(__FILE__))
+
+require 'rats/base'
+require 'rats/data'
+require 'rats/boundaries'
+
+module Rats
+  
+  def self.new(*args)
+    Rats::Base.new(args)
+  end
+  
+  # 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
+  
+end

data/rats.gemspec

@@ -0,0 +1,73 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{rats}
+  s.version = "0.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Mark G"]
+  s.date = %q{2010-03-31}
+  s.description = %q{A ruby class to help with using the Alberta Township System}
+  s.email = %q{rats@attackcorp.com}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+     ".gitignore",
+     "LICENSE",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION",
+     "lib/rats.rb",
+     "lib/rats/base.rb",
+     "lib/rats/boundaries.rb",
+     "lib/rats/data.rb",
+     "lib/rats/data/base.rb",
+     "lib/rats/data/meridian.rb",
+     "lib/rats/data/quarter.rb",
+     "lib/rats/data/range.rb",
+     "lib/rats/data/section.rb",
+     "lib/rats/data/township.rb",
+     "rats.gemspec",
+     "spec/data/data_spec.rb",
+     "spec/data/meridian_spec.rb",
+     "spec/data/quarter_spec.rb",
+     "spec/data/range_spec.rb",
+     "spec/data/section_spec.rb",
+     "spec/data/township_spec.rb",
+     "spec/rats_spec.rb",
+     "spec/spec.opts",
+     "spec/spec_helper.rb"
+  ]
+  s.homepage = %q{http://github.com/attack/rats}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.6}
+  s.summary = %q{A ruby class to help with using the Alberta Township System}
+  s.test_files = [
+    "spec/data/data_spec.rb",
+     "spec/data/meridian_spec.rb",
+     "spec/data/quarter_spec.rb",
+     "spec/data/range_spec.rb",
+     "spec/data/section_spec.rb",
+     "spec/data/township_spec.rb",
+     "spec/rats_spec.rb",
+     "spec/spec_helper.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end
+

data/spec/data/data_spec.rb

@@ -0,0 +1,122 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Rats::Data do
+  
+  it "initializes" do
+    data = Rats::Data.new
+    data.is_a?(Rats::Data).should be_true
+  end
+  
+  describe "attributes" do
+    
+    before(:each) do
+      @data = Rats::Data.new
+    end
+    
+    describe "writing and reading" do
+      
+      it "writes string" do
+        @data.value = "1"
+        @data.value.should == "1"
+      end
+      
+      it "writes integer" do
+        @data.value = 1
+        @data.value.should == 1
+      end
+      
+      it "writes string using alternate" do
+        @data.v = "1"
+        @data.v.should == "1"
+        @data.value.should == "1"
+      end
+      
+      it "writes integer using alternate" do
+        @data.v = 1
+        @data.v.should == 1
+        @data.value.should == 1
+      end
+      
+    end
+    
+  end
+  
+  describe "validation" do
+    
+    it "stubs valid? with true" do
+      data = Rats::Data.new
+      data.valid?.should be_true
+    end
+    
+  end
+  
+  describe "methods" do
+    
+    it "pads the value" do
+      data = Rats::Data.new(1)
+      data.to_p.should == "1"
+      
+      #Rats::Data.should_receive(:padding_width).twice.and_return(3)
+      Rats::Data.expects(:padding_width).twice.returns(3)
+      data.to_p.should == "  1"
+      
+      #Rats::Data.should_receive(:padding_value).and_return("0")
+      Rats::Data.expects(:padding_value).returns("0")
+      data.to_p.should == "001"
+    end
+    
+    it "converts to string" do
+      data = Rats::Data.new(1)
+      data.to_s.should == "1"
+    end
+    
+    it "resets a value" do
+      data = Rats::Data.new(1)
+      data.v.should == 1
+      data.nil!
+      data.v.should be_nil
+    end
+    
+  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

@@ -0,0 +1,100 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Rats::Meridian do
+  
+  it "initializes" do
+    data = Rats::Meridian.new
+    data.is_a?(Rats::Meridian).should be_true
+  end
+  
+  describe "boundaries" do
+    
+    it "allows valid data" do
+      data = Rats::Meridian.new(6)
+      data.valid?.should be_true
+    end
+    
+    it "doesn't allow bad data" do
+      data = Rats::Meridian.new
+      lambda { data.value = 3 }.should raise_error(ArgumentError)
+    end
+    
+  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 = Rats::Meridian.new('4')
+      data.to_p.should == '4'
+    end
+    
+    it "returns the integer" do
+      data = Rats::Meridian.new('4')
+      data.v.should == 4
+    end
+    
+    it "returns a string" do
+      data = Rats::Meridian.new('4')
+      data.to_s.should == 'W4'
+    end
+    
+    it "writes just the integer" do
+      data = Rats::Meridian.new('W4')
+      data.v.should == 4
+    end
+    
+    describe "transforming" do
+      
+      it "accepts integers" do
+        Rats::Meridian.transform(4).should == 4
+      end
+      
+      it "accepts strings" do
+        Rats::Meridian.transform('4').should == 4
+      end
+      
+      it "accepts string prepended W" do
+        Rats::Meridian.transform('W4').should == 4
+      end
+      
+      it "accepts string prepended w" do
+        Rats::Meridian.transform('w4').should == 4
+      end
+      
+      it "doesn't accept other data" do
+        Rats::Meridian.transform('E4').should be_nil
+      end
+      
+    end
+    
+  end
+  
+end