sangaku 0.5.4

data/.rvmrc

@@ -0,0 +1 @@
+rvm use 1.9.3@sangaku --create

data/Gemfile

@@ -0,0 +1,22 @@
+source :rubygems
+
+group :development do
+  gem "awesome_print"
+end
+
+group :test do
+  gem "rake"
+  gem "rspec"
+  gem "yard"
+  gem "debugger"
+end
+
+group :document do
+  gem "rdoc"
+  gem "redcarpet"
+end
+
+group :gemify do
+  gem "jeweler"
+end
+

data/Gemfile.lock

@@ -0,0 +1,46 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    awesome_print (1.1.0)
+    columnize (0.3.6)
+    debugger (1.3.3)
+      columnize (>= 0.3.1)
+      debugger-linecache (~> 1.1.1)
+      debugger-ruby_core_source (~> 1.2.0)
+    debugger-linecache (1.1.2)
+      debugger-ruby_core_source (>= 1.1.1)
+    debugger-ruby_core_source (1.2.0)
+    diff-lcs (1.2.1)
+    git (1.2.5)
+    jeweler (1.8.4)
+      bundler (~> 1.0)
+      git (>= 1.2.5)
+      rake
+      rdoc
+    json (1.7.7)
+    rake (10.0.3)
+    rdoc (4.0.0)
+      json (~> 1.4)
+    redcarpet (2.2.2)
+    rspec (2.13.0)
+      rspec-core (~> 2.13.0)
+      rspec-expectations (~> 2.13.0)
+      rspec-mocks (~> 2.13.0)
+    rspec-core (2.13.0)
+    rspec-expectations (2.13.0)
+      diff-lcs (>= 1.1.3, < 2.0)
+    rspec-mocks (2.13.0)
+    yard (0.8.5.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  awesome_print
+  debugger
+  jeweler
+  rake
+  rdoc
+  redcarpet
+  rspec
+  yard

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2013 Agworld Pty. Ltd.
+
+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/README.md

@@ -0,0 +1,45 @@
+Sangaku
+=======
+
+Sangaku is a geometry gem for Ruby.
+
+[![Build Status](https://secure.travis-ci.org/agworld/sangaku.png)](http://travis-ci.org/#!/agworld/sangaku)
+[![Dependency Status](https://gemnasium.com/agworld/sangaku.png)](https://gemnasium.com/agworld/sangaku)
+
+Getting Started
+---------------
+
+Simply `sudo gem install sangaku` and then `require 'sangaku'` in your code.
+
+Example Usage
+-------------
+
+```ruby
+data = [[10, 10], [10, 20], [20, 10]]
+polygon = Sangaku::Polygon.new(*data)
+polygon.close!
+aabb = polygon.aabb
+puts aabb.mid
+```
+
+This code prints the following:
+
+```
+(15.0, 15.0)
+```
+
+Contributing to Sangaku
+-----------------------
+
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet.
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it.
+* Fork the project.
+* Start a feature/bugfix branch.
+* Commit and push until you are happy with your contribution.
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+Copyright
+---------
+
+Copyright (c) 2013 Agworld Pty. Ltd. See LICENSE.txt for further details.

data/Rakefile

@@ -0,0 +1,42 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "sangaku"
+  gem.homepage = "https://github.com/agworld/sangaku"
+  gem.license = "MIT"
+  gem.summary = "Sangaku is a geometry gem for Ruby."
+  gem.description = "Sangaku contains classes for Point, Line, Polygon, AABB and so on in 2D. It can find the 'pole of inaccessibility' for a polygon. And it can simply the boundary of a polygon to minimise points while retaining detail. It works well with Gosu."
+  gem.email = "jason.hutchens@agworld.com.au"
+  gem.authors = ["Jason Hutchens"]
+  # dependencies defined in Gemfile
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+end
+
+RSpec::Core::RakeTask.new(:rcov) do |spec|
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = false
+end
+
+task :default => :spec
+
+require 'yard'
+YARD::Rake::YardocTask.new

data/VERSION

@@ -0,0 +1 @@
+0.5.4

data/lib/sangaku.rb

@@ -0,0 +1,7 @@
+require 'sangaku/point'
+require 'sangaku/line'
+require 'sangaku/polygon'
+require 'sangaku/aabb'
+require 'sangaku/grid'
+require 'sangaku/star'
+require 'sangaku/errors'

data/lib/sangaku/aabb.rb

@@ -0,0 +1,53 @@
+module Sangaku
+
+  class AABB
+
+    def initialize(*points)
+      points = Point::convert(points)
+      xs = points.map { |p| p.x }
+      ys = points.map { |p| p.y }
+      @line = Line.new([xs.min || 0, ys.min || 0], [xs.max || 0, ys.max || 0])
+    end
+
+    def min; @line.p1; end
+    def max; @line.p2; end
+    def mid; @line.mid; end
+
+    def w; @line.w; end
+    def h; @line.h; end
+
+    def centre!(point = [0, 0])
+      point = Point.new(*point) if point.is_a?(Array)
+      @line -= (@line.mid - point)
+    end
+
+    def square!
+      mid = @line.mid
+      ds = 0.5 * [w, h].max
+      @line.p1.x = mid.x - ds
+      @line.p1.y = mid.y - ds
+      @line.p2.x = mid.x + ds
+      @line.p2.y = mid.y + ds
+    end
+
+    def *(scale)
+      mid = @line.mid
+      dx = 0.5 * w * scale
+      dy = 0.5 * h * scale
+      AABB.new([mid.x - dx, mid.y - dy], [mid.x + dx, mid.y + dy])
+    end
+
+    def to_grid(count = 5)
+      raise if count < 2
+      xs = (min.x..max.x).step(w/(count-1).to_f)
+      ys = (min.y..max.y).step(h/(count-1).to_f)
+      Grid.new(xs.to_a, ys.to_a)
+    end
+
+    def to_a; @line.to_a; end
+    def to_s; @line.to_s; end
+    alias_method :inspect, :to_s
+
+  end
+
+end

data/lib/sangaku/errors.rb

@@ -0,0 +1,9 @@
+module Sangaku
+  module Errors
+    class OpenPolygonError < StandardError
+      def initialize
+        super "Expected poly to be closed."
+      end
+    end
+  end
+end

data/lib/sangaku/grid.rb

@@ -0,0 +1,51 @@
+module Sangaku
+
+  class Grid
+
+    def initialize(xs, ys)
+      @xs, @ys = xs, ys
+    end
+
+    def get_stars(poly)
+      raise Errors::OpenPolygonError.new unless poly.closed?
+      stars = []
+
+      @xs.each do |x|
+        ys = poly.select(x, nil).map { |line| line.get_y(x) }
+        next if ys.length % 2 != 0
+        stars += ys.sort.each_slice(2).map do |s|
+          height = s.reduce(:-).abs
+          y = 0.5 * s.reduce(:+)
+          xs = poly.select(nil, y).map { |line| line.get_x(y) }
+          xs.sort!
+          s = xs.zip(xs.rotate).find { |a, b| x.between?(a, b) }
+          # TODO: de-hack
+          next unless s
+          width = 2 * [(x-s[0]).abs, (x-s[1]).abs].min
+          Star.new([x, y], [width, height])
+        end
+      end
+
+      @ys.each do |y|
+        xs = poly.select(nil, y).map { |line| line.get_x(y) }
+        next if xs.length % 2 != 0
+        stars += xs.sort.each_slice(2).map do |s|
+          width = s.reduce(:-).abs
+          x = 0.5 * s.reduce(:+)
+          ys = poly.select(x, nil).map { |line| line.get_y(x) }
+          ys.sort!
+          s = ys.zip(ys.rotate).find { |a, b| y.between?(a, b) }
+          # TODO: de-hack
+          next unless s
+          height = 2 * [(y-s[0]).abs, (y-s[1]).abs].min
+          Star.new([x, y], [width, height])
+        end
+      end
+
+      #TODO: de-hack
+      stars.reject{|s| s.nil?}
+    end
+
+  end
+
+end

data/lib/sangaku/line.rb

@@ -0,0 +1,77 @@
+module Sangaku
+
+  class Line
+
+    def initialize(p1, p2)
+      @coords = Point::convert([p1, p2])
+    end
+
+    def p1; @coords[0]; end
+    def p1=(val); @coords[0] = val; end
+    def p2; @coords[1]; end
+    def p2=(val); @coords[1] = val; end
+
+    def w
+      (p2.x - p1.x).abs
+    end
+    def h
+      (p2.y - p1.y).abs
+    end
+
+    def length
+      Math.sqrt(vx ** 2 + vy ** 2)
+    end
+
+    def vx
+      p2.x - p1.x
+    end
+
+    def vy
+      p2.y - p1.y
+    end
+
+    def get_x(y)
+      ratio = p1.y != p2.y ? (y-p1.y)/(p2.y-p1.y).to_f : 0.5
+      p1.x + ratio * (p2.x-p1.x)
+    end
+    def get_y(x)
+      ratio = p1.x != p2.x ? (x-p1.x)/(p2.x-p1.x).to_f : 0.5
+      p1.y + ratio * (p2.y-p1.y)
+    end
+
+    def +(point)
+      Line.new(p1 + point, p2 + point)
+    end
+    def -(point)
+      Line.new(p1 - point, p2 - point)
+    end
+
+    def mid
+      (p1 + p2) * 0.5
+    end
+
+    def dot(other)
+      (self.vx * other.vx + self.vy * other.vy)/(self.length * other.length)
+    end
+
+    def cross(other)
+      self.vx * other.vy - self.vy * other.vx
+    end
+
+    def contain?(x = nil, y = nil)
+      (x.nil? || x.between?(*[p1.x, p2.x].sort)) &&
+      (y.nil? || y.between?(*[p1.y, p2.y].sort))
+    end
+
+    def to_a
+      [@p1.to_a, @p2.to_a]
+    end
+
+    def to_s
+      "#{p1}->#{p2}"
+    end
+    alias_method :inspect, :to_s
+
+  end
+
+end

data/lib/sangaku/point.rb

@@ -0,0 +1,49 @@
+module Sangaku
+
+  class Point
+
+    def initialize(x, y)
+      @coord = [x, y]
+    end
+
+    def self.convert(points)
+      points.map { |p| Point.new(*p) }
+    end
+
+    def x; @coord[0]; end
+    def x=(val); @coord[0]=val; end
+    def y; @coord[1]; end
+    def y=(val); @coord[1]=val; end
+
+    alias_method :w, :x
+    alias_method :w=, :x=
+    alias_method :h, :y
+    alias_method :h=, :y=
+
+    def +(other)
+      Point.new(self.x + other.x, self.y + other.y)
+    end
+
+    def -(other)
+      Point.new(self.x - other.x, self.y - other.y)
+    end
+
+    def *(scale)
+      Point.new(self.x * scale,  self.y * scale)
+    end
+
+    def /(scale)
+      Point.new(self.x / scale,  self.y / scale)
+    end
+
+    def dist(other)
+      Math.sqrt((self.x - other.x) ** 2 + (self.y - other.y) ** 2 )
+    end
+
+    def to_a; @coord; end
+    def to_s; "(#{@coord.join(', ')})"; end
+    alias_method :inspect, :to_s
+
+  end
+
+end

data/lib/sangaku/polygon.rb

@@ -0,0 +1,75 @@
+module Sangaku
+
+  class Polygon
+
+    def initialize(*points)
+      @points = Point::convert(points)
+      @lines = nil
+      @closed = false
+      @aabb = nil
+    end
+
+    def closed?
+      @closed
+    end
+
+    def close!
+      return if @closed
+      @closed = true
+      @lines = nil
+      @aabb = nil
+    end
+
+    def clear!
+      @points.clear
+      @closed = false
+      @lines = nil
+      @aabb = nil
+    end
+
+    def length
+      @points.length
+    end
+
+    def points
+      @points
+    end
+
+    def lines
+      @lines ||= _points_to_lines
+    end
+
+    def aabb
+      @aabb ||= AABB.new(*@points)
+    end
+
+    def <<(p)
+      @lines = nil
+      @points << Point.new(*p)
+    end
+
+    def select(x = nil, y = nil)
+      lines.select { |line| line.contain?(x, y) }
+    end
+
+    def to_a
+      @points.map { |p| p.to_a }
+    end
+
+    def to_s
+      @points.join('->')
+    end
+    alias_method :inspect, :to_s
+
+    private
+
+    def _points_to_lines
+      return [] if @points.length < 2
+      retval = @points.zip(@points.rotate).map { |p1, p2| Line.new(p1, p2) }
+      retval = retval[0...-1] unless @closed
+      retval
+    end
+
+  end
+
+end

data/lib/sangaku/star.rb

@@ -0,0 +1,25 @@
+module Sangaku
+
+  class Star
+
+    include Comparable
+
+    def initialize(center, size)
+      @center, @size = Point.new(*center), Point.new(*size)
+    end
+
+    def center
+      @center
+    end
+
+    def fitness
+      @fitness ||= (@size.w * @size.h)/(1+0.1*(@size.w-@size.h).abs)
+    end
+
+    def <=>(other)
+      other.fitness <=> fitness
+    end
+
+  end
+
+end

data/sangaku.gemspec

@@ -0,0 +1,62 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = "sangaku"
+  s.version = "0.5.4"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Jason Hutchens"]
+  s.date = "2013-03-15"
+  s.description = "Sangaku contains classes for Point, Line, Polygon, AABB and so on in 2D. It can find the 'pole of inaccessibility' for a polygon. And it can simply the boundary of a polygon to minimise points while retaining detail. It works well with Gosu."
+  s.email = "jason.hutchens@agworld.com.au"
+  s.extra_rdoc_files = [
+    "LICENSE.txt",
+    "README.md"
+  ]
+  s.files = [
+    ".rvmrc",
+    "Gemfile",
+    "Gemfile.lock",
+    "LICENSE.txt",
+    "README.md",
+    "Rakefile",
+    "VERSION",
+    "lib/sangaku.rb",
+    "lib/sangaku/aabb.rb",
+    "lib/sangaku/errors.rb",
+    "lib/sangaku/grid.rb",
+    "lib/sangaku/line.rb",
+    "lib/sangaku/point.rb",
+    "lib/sangaku/polygon.rb",
+    "lib/sangaku/star.rb",
+    "sangaku.gemspec",
+    "spec/aabb_spec.rb",
+    "spec/grid_spec.rb",
+    "spec/line_spec.rb",
+    "spec/point_spec.rb",
+    "spec/polygon_spec.rb",
+    "spec/spec_helper.rb",
+    "spec/star_spec.rb"
+  ]
+  s.homepage = "https://github.com/agworld/sangaku"
+  s.licenses = ["MIT"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = "1.8.24"
+  s.summary = "Sangaku is a geometry gem for Ruby."
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<awesome_print>, [">= 0"])
+    else
+      s.add_dependency(%q<awesome_print>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<awesome_print>, [">= 0"])
+  end
+end
+

data/spec/aabb_spec.rb

@@ -0,0 +1,28 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+module Sangaku
+
+  describe AABB do
+
+    it "should just work" do
+      aabb = AABB.new([1, 5], [3, 1], [5, -3])
+      aabb.min.to_s.should eq("(1, -3)")
+      aabb.max.to_s.should eq("(5, 5)")
+      aabb.mid.to_s.should eq("(3.0, 1.0)")
+      aabb.w.should eq(4)
+      aabb.h.should eq(8)
+      aabb.centre!
+      aabb.mid.to_s.should eq("(0.0, 0.0)")
+      aabb.w.should eq(4)
+      aabb.h.should eq(8)
+      aabb *= 0.5
+      aabb.to_s.should eq("(-1.0, -2.0)->(1.0, 2.0)")
+      aabb.square!
+      aabb.mid.to_s.should eq("(0.0, 0.0)")
+      aabb.w.should eq(4)
+      aabb.w.should eq(4)
+    end
+
+  end
+
+end

data/spec/grid_spec.rb

@@ -0,0 +1,30 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+module Sangaku
+
+  describe Grid do
+
+    context "#get_stars" do
+
+      it "should fail gracefully for an open poly" do
+        xs = [1,4,7]
+        ys = [1,3,5]
+        grid = Grid.new(xs,ys)
+        poly = Polygon.new([1,1],[4,4],[7,2])
+        expect { grid.get_stars(poly) }.to raise_error(Errors::OpenPolygonError)
+      end
+
+      it "should work for a poly that folds back on itself" do
+        xs = [1,2,3,4,5]
+        ys = [1,2,3,4,5]
+        grid = Grid.new(xs,ys)
+        poly = Polygon.new([1,1],[1,4],[1,3],[2,2],[4,1])
+        poly.close!
+        grid.get_stars(poly)
+      end
+
+    end
+
+  end
+
+end

data/spec/line_spec.rb

@@ -0,0 +1,60 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+module Sangaku
+
+  describe Line do
+
+    it 'should have a width and height' do
+      line = Line.new([10, 20], [15, 10])
+      line.w.should eq(5)
+      line.h.should eq(10)
+      line.to_s.should eq("(10, 20)->(15, 10)")
+    end
+
+    it 'should be possible to test boundary' do
+      line = Line.new([10, 20], [15, 10])
+      line.contain?.should eq(true)
+      line.contain?(9).should eq(false)
+      line.contain?(12).should eq(true)
+      line.contain?(16).should eq(false)
+      line.contain?(nil, 15).should eq(true)
+      line.contain?(12, 15).should eq(true)
+    end
+
+    it 'should be possible to do dot products yo' do
+      line1 = Line.new([10, 10], [20, 20])
+      line2 = Line.new([30, 30], [50, 50])
+      line3 = Line.new([20, 20], [40, 0])
+      line4 = Line.new([30, 30], [40, 30])
+      line1.dot(line2).should be_within(1e-6).of(1)
+      line2.dot(line1).should be_within(1e-6).of(1)
+      line1.dot(line3).should be_within(1e-6).of(0)
+      line3.dot(line2).should be_within(1e-6).of(0)
+      line4.dot(line2).should be_within(1e-6).of(0.5*Math.sqrt(2.0))
+    end
+
+    context "#get_x" do
+      it "should return half point for lines running along the same x" do
+        line = Line.new([5,1], [9,1])
+        line.get_x(Point.new(3,1)).should eq(7)
+        line.get_x(1).should eq(7)
+      end
+      it "should return the point itself for lines that are a point" do
+        line = Line.new([5,1], [5,1])
+        line.get_x(Point.new(1,1)).should eq(5)
+      end
+    end
+
+    context "#get_y" do
+      it "should return half point for lines running along the same y" do
+        line = Line.new([1,5], [1,9])
+        line.get_y(Point.new(1,3)).should eq(7)
+        line.get_y(1).should eq(7)
+      end
+      it "should return the point itself for lines that are a point" do
+        line = Line.new([1,5], [1,5])
+        line.get_y(Point.new(1,1)).should eq(5)
+      end
+    end
+  end
+end

data/spec/point_spec.rb

@@ -0,0 +1,37 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+def test_splat(a, b)
+  a + b
+end
+
+module Sangaku
+
+  describe Point do
+
+    it "should be useful" do
+      point = Point.new(100, 200)
+      point.x.should eq(100)
+      point.y.should eq(200)
+      test_splat(*point).should eq(300)
+      point.x = 20
+      point.y = 30
+      point.to_s.should eq("(20, 30)")
+    end
+
+    it "should be possible to measure separation" do
+      p1 = Point.new(10, 20)
+      p2 = Point.new(15, 10)
+      delta = p2-p1
+      delta.w.should eq(5)
+      delta.h.should eq(-10)
+    end
+
+    it "should be possible to measure distance" do
+      p1 = Point.new(10, 13)
+      p2 = Point.new(14, 10)
+      p1.dist(p2).should eq(5)
+    end
+
+  end
+
+end

data/spec/polygon_spec.rb

@@ -0,0 +1,39 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+module Sangaku
+
+  describe Polygon do
+
+    it "should just work" do
+      poly = Polygon.new([1, 2], [3, 4], [5, 6])
+      lines = poly.lines
+      lines.length.should eq(2)
+      poly.close!
+      lines = poly.lines
+      lines.length.should eq(3)
+      lines[0].to_s.should eq("(1, 2)->(3, 4)")
+      lines[1].to_s.should eq("(3, 4)->(5, 6)")
+      lines[2].to_s.should eq("(5, 6)->(1, 2)")
+      poly << [7, 8]
+      poly.to_s.should eq("(1, 2)->(3, 4)->(5, 6)->(7, 8)")
+    end
+
+    it "should be possible to select lines" do
+      poly = Polygon.new([1, 2], [3, 4], [5, 6], [7, 8])
+      poly.close!
+      lines = poly.select(2)
+      lines.length.should eq(2)
+      lines[0].to_s.should eq("(1, 2)->(3, 4)")
+      lines[1].to_s.should eq("(7, 8)->(1, 2)")
+    end
+
+    it "should be possible to get the bounding box" do
+      poly = Polygon.new([1, 7], [3, 4], [5, 6], [8, 2])
+      aabb = poly.aabb
+      aabb.min.to_s.should eq("(1, 2)")
+      aabb.max.to_s.should eq("(8, 7)")
+    end
+
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,14 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'rspec'
+require 'sangaku'
+require 'debugger'
+
+
+# Requires supporting files with custom matchers and macros, etc,
+# in ./support/ and its subdirectories.
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+
+RSpec.configure do |config|
+
+end

data/spec/star_spec.rb

@@ -0,0 +1,9 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+module Sangaku
+
+  describe Star do
+
+  end
+
+end

metadata

@@ -0,0 +1,92 @@
+--- !ruby/object:Gem::Specification
+name: sangaku
+version: !ruby/object:Gem::Version
+  version: 0.5.4
+  prerelease: 
+platform: ruby
+authors:
+- Jason Hutchens
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-03-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: awesome_print
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Sangaku contains classes for Point, Line, Polygon, AABB and so on in
+  2D. It can find the 'pole of inaccessibility' for a polygon. And it can simply the
+  boundary of a polygon to minimise points while retaining detail. It works well with
+  Gosu.
+email: jason.hutchens@agworld.com.au
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE.txt
+- README.md
+files:
+- .rvmrc
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- VERSION
+- lib/sangaku.rb
+- lib/sangaku/aabb.rb
+- lib/sangaku/errors.rb
+- lib/sangaku/grid.rb
+- lib/sangaku/line.rb
+- lib/sangaku/point.rb
+- lib/sangaku/polygon.rb
+- lib/sangaku/star.rb
+- sangaku.gemspec
+- spec/aabb_spec.rb
+- spec/grid_spec.rb
+- spec/line_spec.rb
+- spec/point_spec.rb
+- spec/polygon_spec.rb
+- spec/spec_helper.rb
+- spec/star_spec.rb
+homepage: https://github.com/agworld/sangaku
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -2726484618989348966
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Sangaku is a geometry gem for Ruby.
+test_files: []