Ironic Wolf

describe Point do
  before :each do
    @p = Point.new
  end
 
  it "should have a property x" do
    @p.should respond_to(:x)
  end
 
  it "should have a property y" do
    @p.should respond_to(:y)
  end
 
  it "should have default x value of 0" do
    @p.x.should == 0
  end
 
  it "should have default y value of 0" do
    @p.y.should == 0
  end
 
  it "should have a setter for x" do
    @p.x = 1313
    @p.x.should == 1313
  end
 
  it "should have setter for y" do
    @p.y = 1313
    @p.y.should == 1313
  end
 
  it "should only accept numeric values for initialization" do
    lambda { Point.new('1', '2') }.should raise_error
  end
 
  it "should only accept numeric values for x" do
    lambda { @p.x = "String" }.should raise_error
  end
 
  it "should only accept numeric values for y" do
    lambda { @p.y = "String" }.should raise_error
  end
 
  it "should being able to compare ==" do
    p2 = Point.new
    @p.should == p2
    p2.x = 1313
    @p.should_not == p2
    @p.should_not == "Test"
  end
 
  it "should be castable to an array" do
    @p.should respond_to(:to_a)
    @p.to_a.should == [0,0]
  end
 
  it "should be castable to an hash" do
    @p.should respond_to(:to_hash)
    @p.to_hash.should == {:x => 0, :y => 0}
  end
 
  it "should be castable to Point" do
    @p.should respond_to(:to_point)
    @p.to_point.should == @p
  end
 
  it "an array of two elements should be castable to Point" do
    p = [0,0].to_point
    p.should == @p
  end
 
  it "an array contain more than 2 elements raise error" do
    lambda { p = [1,2,3].to_point }.should raise_error
  end
 
  it "a hash containing ( :x => value, :y =>value ) should be castable to Point" do
    p = {:x => 0, :y => 0}.to_point
    p.should == @p
  end
 
  it "a hash to_point should raise if the keys x and y are not found" do
    lambda { p = {}.to_point }.should raise_error
  end
end

module Inox
 
  # Representation of a Point, defined as Object for the ability to 
  # handle it in a good OO manner and furthur extention and
  # modification.
  # 
  # Struct is the base class of Point and as such Point inherits 
  # the already powerful methods of Struct. 
  #
  # The assignment checks for Numeric kind of values 
  # to prevent errors. 
  class Point <  Struct.new(:x, :y)
 
    # added type check to enforce Numeric values
    def initialize(*args)
      super(*(args.empty? ? [0,0] : args))
      unless self.x.kind_of? Numeric and self.y.kind_of? Numeric
        self.x = 0
        self.y = 0
        raise "#{args} not a two Numeric values"
      end
    end
 
    # added type check to enforce Numeric values    
    def x=(value)
      raise "#{num} not a Numeric value" unless value.kind_of? Numeric
      super(value)
    end
 
    # added type check to enforce Numeric values
    def y=(value)
      raise "#{num} not a Numeric value" unless value.kind_of? Numeric
      super(value)
    end
 
    def to_hash
      {:x => self.x, :y => self.y}
    end
 
    def to_point
      self
    end
  end
end
 
# Extending the ability of Array to handle
# extra Inox types
class Array
 
  # Cast an Array holding two Numerics to an instance of the class Point
  #
  # [1,3].to_point  ==  Point.new(1,3)
  def to_point
    raise "Cannot convert #{self} to Point" unless length == 2
    Inox::Point.new(self[0], self[1])
  end
end
 
# Extending the ability of the Hash class to handle
# extra Inox types
class Hash
 
  # Cast a Hash containing two keys [:x, :y] with Numeric values
  # to an instance of the class Point
  #
  # {:x => 1, y => 3}.to_point  == Point.new(1,3)
  #
  # Extra keys in the hash doesn't interfer
  def to_point
    raise "Cannot find keys 'x' and 'y'" unless key?(:x) and key?(:y) 
    Inox::Point.new(self[:x], self[:y])
  end
end