hexagonly 0.1.0

data/spec/lib/hexagonly/hexagon_spec.rb

@@ -0,0 +1,208 @@
+require 'spec_helper'
+
+describe Hexagonly::Hexagon do
+  
+  describe "#hex_corners" do
+
+    context "if hex_center or hex_size have not been defined" do
+      subject { Hexagonly::Hexagon.new(nil, nil) }
+      it { expect { subject.hex_corners }.to raise_error Exception }
+    end
+
+    context "if hex_center and hex_size have been defined" do
+      subject { Hexagonly::Hexagon.new(Hexagonly::Point.new(5, 6), 2.1) }
+      let(:corners) do 
+        [
+          [7.1, 6.0], 
+          [6.050000000000001, 7.818653347947321], 
+          [3.95, 7.818653347947321], 
+          [2.9, 6.0], 
+          [3.9499999999999993, 4.18134665205268], 
+          [6.049999999999999, 4.181346652052678]
+        ]
+      end
+      it { subject.hex_corners.size == 5 }
+      it { (subject.hex_corners.map{ |p| [p.x_coord, p.y_coord] } - corners).should == [] }
+    end
+
+  end
+
+  describe "#loosely_contains?" do
+
+    context "if hex_center or hex_size have not been defined" do
+      subject { Hexagonly::Hexagon.new(nil, nil) }
+      it { expect { subject.loosely_contains?(Hexagonly::Point.new(1, 1)) }.to raise_error Exception }
+    end
+
+    context "if hex_center and hex_size have been defined" do
+      subject { Hexagonly::Hexagon.new(Hexagonly::Point.new(5, 6), 2.1) }
+      # Outside the bounding box
+      it { subject.loosely_contains?(Hexagonly::Point.new(5, 8)).should == false }
+      it { subject.loosely_contains?(Hexagonly::Point.new(5, 4)).should == false }
+      it { subject.loosely_contains?(Hexagonly::Point.new(2, 6)).should == false }
+      it { subject.loosely_contains?(Hexagonly::Point.new(8, 6)).should == false }
+      # Inside the bounding box but outside the hexagon
+      it { subject.loosely_contains?(Hexagonly::Point.new(3.3, 7)).should == true }
+      it { subject.loosely_contains?(Hexagonly::Point.new(6.7, 5)).should == true }
+      # Inside the hexagon
+      it { subject.loosely_contains?(Hexagonly::Point.new(5.1, 6.2)).should == true }
+      it { subject.loosely_contains?(Hexagonly::Point.new(4.2, 5.3)).should == true }
+      it { subject.loosely_contains?(Hexagonly::Point.new(5.0, 6.0)).should == true }
+    end
+
+  end
+
+  describe "#contains?" do
+
+    context "if hex_center or hex_size have not been defined" do
+      subject { Hexagonly::Hexagon.new(nil, nil) }
+      it { expect { subject.contains?(Hexagonly::Point.new(1, 1)) }.to raise_error Exception }
+    end
+
+    context "if hex_center and hex_size have been defined" do
+      subject { Hexagonly::Hexagon.new(Hexagonly::Point.new(5, 6), 2.1) }
+      # Outside the bounding box
+      it { subject.contains?(Hexagonly::Point.new(5, 8)).should == false }
+      it { subject.contains?(Hexagonly::Point.new(5, 4)).should == false }
+      it { subject.contains?(Hexagonly::Point.new(2, 6)).should == false }
+      it { subject.contains?(Hexagonly::Point.new(8, 6)).should == false }
+      # Inside the bounding box but outside the hexagon
+      it { subject.contains?(Hexagonly::Point.new(3.3, 7)).should == false }
+      it { subject.contains?(Hexagonly::Point.new(6.7, 5)).should == false }
+      # Inside the hexagon
+      it { subject.contains?(Hexagonly::Point.new(5.1, 6.2)).should == true }
+      it { subject.contains?(Hexagonly::Point.new(4.2, 5.3)).should == true }
+      it { subject.contains?(Hexagonly::Point.new(5.0, 6.0)).should == true }
+    end
+
+  end
+
+  describe "#grab" do
+
+    context "when none of the points belong to the hexagon" do
+      let(:rejected_points) { [[5, 8], [5, 4], [2, 6], [8, 6], [3.3, 7], [6.7, 5]].map{ |x, y| Hexagonly::Point.new(x, y) } }
+      subject do
+        hex = Hexagonly::Hexagon.new(Hexagonly::Point.new(5, 6), 2.1)
+        hex.grab(rejected_points)
+        hex
+      end
+      it { subject.collected_points.class.should == Array }
+      it { subject.collected_points.size.should == 0 }
+      it { subject.rejected_points.class.should == Array }
+      it { subject.rejected_points.should == rejected_points }
+    end
+
+    context "when some of the points belong to the hexagon" do
+      let(:accepted_points) { [[5.1, 6.2], [4.2, 5.3], [5.0, 6.0]].map{ |x, y| Hexagonly::Point.new(x, y) } }
+      let(:rejected_points) { [[5, 8], [5, 4], [2, 6], [8, 6], [3.3, 7], [6.7, 5]].map{ |x, y| Hexagonly::Point.new(x, y) } }
+      subject do
+        hex = Hexagonly::Hexagon.new(Hexagonly::Point.new(5, 6), 2.1)
+        hex.grab(accepted_points + rejected_points)
+        hex
+      end
+      it { subject.collected_points.class.should == Array }
+      it { subject.collected_points.should == accepted_points }
+      it { subject.rejected_points.class.should == Array }
+      it { subject.rejected_points.should == rejected_points }
+    end
+
+    context "when all of the points belong to the hexagon" do
+      let(:accepted_points) { [[5.1, 6.2], [4.2, 5.3], [5.0, 6.0]].map{ |x, y| Hexagonly::Point.new(x, y) } }
+      subject do
+        hex = Hexagonly::Hexagon.new(Hexagonly::Point.new(5, 6), 2.1)
+        hex.grab(accepted_points)
+        hex
+      end
+      it { subject.collected_points.class.should == Array }
+      it { subject.collected_points.should == accepted_points }
+      it { subject.rejected_points.class.should == Array }
+      it { subject.rejected_points.size.should == 0 }
+    end
+
+  end
+
+  describe ".pack" do
+
+    context "when using default classes and point grabbing" do
+      let(:points) { 100.times.map{ build(:point) } }
+      let(:hex_size) { 0.15 }
+      let(:params) { { :grab_points => true } }
+      subject { Hexagonly::Hexagon.pack(points, hex_size, params) }
+      it { subject.class.should == Array }
+      it { subject.each{ |hex| hex.collected_points.each{ |p| hex.contains?(p).should == true } } } 
+      it { subject.inject([]){ |arr, hex| arr += hex.collected_points }.size.should == points.size }
+    end
+
+    context "when using default classes, point grabbing and rejecting empty" do
+      let(:points) { 100.times.map{ build(:point) } }
+      let(:hex_size) { 0.15 }
+      let(:params) { { :grab_points => true, :reject_empty => true } }
+      subject { Hexagonly::Hexagon.pack(points, hex_size, params) }
+      it { subject.class.should == Array }
+      it { subject.inject([]){ |arr, hex| arr += hex.collected_points }.size.should == points.size }
+      it { subject.each{ |hex| hex.collected_points.should_not be_empty} }
+    end
+
+    context "when using custom classes" do
+      before(:all) do
+        class CustomPoint
+          include Hexagonly::Point::Methods
+          x_y_coord_methods :a, :b
+
+          attr_accessor :a, :b
+          def initialize(*args); set_coords(*args) if args.size == 2; end
+        end
+
+        class CustomHexagon
+          include Hexagonly::Hexagon::Methods
+
+          def initialize(*args); setup_hex(center, size) if args.size == 2; end
+        end
+      end
+      let(:custom_boundries) { [[22, 46], [24, 48]].map{ |x, y| CustomPoint.new(x, y) } }
+      let(:hex_size) { 0.15 }
+      let(:params) { { :hexagon_class => CustomHexagon, :point_class => CustomPoint } }
+      subject{ Hexagonly::Hexagon.pack(custom_boundries, hex_size, params) }
+      it { subject.inject(0){ |sum, hex| sum += custom_boundries.inject(0){ |subsum, p| hex.contains?(p) ? subsum += 1 : subsum } }.should == custom_boundries.size }
+      it { subject.each{ |hex| hex.class.should == CustomHexagon } }
+      it { subject.each{ |hex| hex.hex_center.class.should == CustomPoint } }
+    end
+
+    context "when using custom classes with mixed points and point grabbing" do
+      before(:all) do
+        class Cheese
+          include Hexagonly::Point::Methods
+          x_y_coord_methods :a, :b
+
+          attr_accessor :a, :b
+          def initialize(*args); set_coords(*args) if args.size == 2; end
+        end
+
+        class Salami
+          include Hexagonly::Point::Methods
+          x_y_coord_methods :a, :b
+
+          attr_accessor :a, :b
+          def initialize(*args); set_coords(*args) if args.size == 2; end
+        end
+
+        class Pizza
+          include Hexagonly::Hexagon::Methods
+
+          def initialize(*args); setup_hex(center, size) if args.size == 2; end
+        end
+      end
+      let(:points) { 100.times.map{ [Cheese, Salami].sample.new(generate(:x), generate(:y)) } }
+      let(:hex_size) { 0.15 }
+      let(:params) { { :hexagon_class => Pizza, :grab_points => true } }
+      subject{ Hexagonly::Hexagon.pack(points, hex_size, params) }
+      it { subject.class.should == Array }
+      it { subject.each{ |hex| hex.class.should == Pizza } }
+      it { subject.each{ |hex| hex.collected_points.each{ |p| hex.contains?(p).should == true } } } 
+      it { subject.inject([]){ |arr, hex| arr += hex.collected_points }.size.should == points.size }
+      it { subject.each{ |hex| hex.collected_points.each{ |p| [Cheese, Salami].should include(p.class) } } }
+    end
+
+  end
+
+end

data/spec/lib/hexagonly/point_spec.rb

@@ -0,0 +1,71 @@
+require 'spec_helper'
+
+describe Hexagonly::Point do
+  
+  describe "#x_coord and #y_coord" do
+    
+    context "when .set_coord_names WAS NOT used" do
+
+      context "if #x and #y are not defined" do
+        before(:all) do
+          class TestPoint
+            include Hexagonly::Point::Methods
+          end
+        end
+
+        subject { TestPoint.new }
+        it { expect {subject.x_coord}.to raise_error(NoMethodError) }
+        it { expect {subject.y_coord}.to raise_error(NoMethodError) }
+      end
+
+      context "if #x and #y are defined" do
+        before(:all) do
+          class TestPoint
+            include Hexagonly::Point::Methods
+            attr_accessor :x, :y
+            def initialize(x, y); @x, @y = x, y; end
+          end
+        end
+
+        subject { TestPoint.new(1, 2) }
+        it { subject.x_coord.should == 1 }
+        it { subject.y_coord.should == 2 }
+      end
+
+    end
+
+    context "when .set_coord_names WAS used" do
+
+      context "if given coordinate methods are not defined" do
+        before(:all) do
+          class TestPoint
+            include Hexagonly::Point::Methods
+            x_y_coord_methods :a, :b
+          end
+        end
+
+        subject { TestPoint.new(1, 2) }
+        it { expect {subject.x_coord}.to raise_error(NoMethodError) }
+        it { expect {subject.y_coord}.to raise_error(NoMethodError) }
+      end
+
+      context "if given coordinate methods are defined" do
+        before(:all) do
+          class TestPoint
+            include Hexagonly::Point::Methods
+            x_y_coord_methods :a, :b
+            attr_accessor :a, :b
+            def initialize(a, b); @a, @b = a, b; end
+          end
+        end
+
+        subject { TestPoint.new(1, 2) }
+        it { subject.x_coord.should == 1 }
+        it { subject.y_coord.should == 2 }
+      end
+      
+    end
+
+  end
+
+end

data/spec/lib/hexagonly/polygon_spec.rb

@@ -0,0 +1,96 @@
+require 'spec_helper'
+
+describe Hexagonly::Polygon do
+
+  describe "#poly_points" do
+
+    context "when .poly_points_method WAS NOT used" do
+
+      context "if #poly_points is not defined" do
+        before(:all) do
+          class TestPolyWithoutPolyPoints
+            include Hexagonly::Polygon::Methods
+          end
+        end
+
+        subject { TestPolyWithoutPolyPoints.new }
+        it { expect { subject.poly_points }.to raise_error(NoMethodError) }
+      end
+      
+      context "if #poly_points is defined" do
+        before(:all) do
+          class TestPolyWithPolyPoints
+            include Hexagonly::Polygon::Methods
+            attr_reader :poly_points
+            def initialize(points); @poly_points = points; end
+          end
+        end
+
+        let(:points) { 5.times.map{ build(:point) } }
+        subject { TestPolyWithPolyPoints.new(points).poly_points }
+        it { subject.class.should == Array }
+        it { should == points }
+      end
+
+    end
+
+    context  "when .poly_points_method WAS used" do
+
+      context "if given method is defined" do
+        before(:all) do
+          class TestPolyWithCustomMethod
+            include Hexagonly::Polygon::Methods
+            poly_points_method :custom_poly_points
+            attr_reader :custom_poly_points
+            def initialize(points); @custom_poly_points = points; end
+          end
+        end
+
+        let(:points) { 5.times.map{ build(:point) } }
+        subject { TestPolyWithCustomMethod.new(points) }
+        it { subject.poly_points.class.should == Array }
+        it { subject.poly_points.should == points }
+      end
+
+    end
+
+  end
+
+  describe "#contains?" do
+
+    context "when the polygon has less than 3 points" do
+      let(:points) { 2.times.map( build(:point)) }
+      it { expect { Hexagonly::Polygon.new(nil).contains?(Hexagonly::Point.new(1, 2)) }.to raise_error Exception }
+      it { expect { Hexagonly::Polygon.new(points).contains?(Hexagonly::Point.new(1, 2)) }.to raise_error Exception }
+    end
+
+    context "when the polygon has 3 or more points and a simple poly was given" do
+      # See Wolfram Alpha: (4, 4)(5, 6)(3, 8)(8, 8)(7, 4) polygon
+      let(:simple_poly_points) { [[4, 4], [5, 6], [3, 8], [8, 8], [7, 4]].map{ |p| Hexagonly::Point.new(p[0], p[1]) } }
+      subject { Hexagonly::Polygon.new(simple_poly_points) }
+      it { subject.contains?(Hexagonly::Point.new(4, 6)).should == false }
+      it { subject.contains?(Hexagonly::Point.new(6, 6)).should == true }
+      it { subject.contains?(Hexagonly::Point.new(3, 3)).should == false }
+      it { subject.contains?(Hexagonly::Point.new(6, 7.99)).should == true }
+      it { subject.contains?(Hexagonly::Point.new(8, 6)).should == false }
+      it { subject.contains?(Hexagonly::Point.new(-6, -6)).should == false }
+    end
+
+    context "when the polygon has 3 or more points and a messed up poly was given" do
+      # See Wolfram Alpha: (4, 6)(8, 7)(7, 3)(5, 9)(8, 9)(4.2, 2)(5, 4) polygon
+      let(:messed_up_poly_points) { [[4, 6], [8, 7], [7, 3], [5, 9], [8, 9], [4.2, 2], [5, 4]].map{ |p| Hexagonly::Point.new(p[0], p[1]) } }
+      subject { Hexagonly::Polygon.new(messed_up_poly_points) }
+      it { subject.contains?(Hexagonly::Point.new(8, 6)).should == false }
+      it { subject.contains?(Hexagonly::Point.new(4, 4)).should == false }
+      it { subject.contains?(Hexagonly::Point.new(4.3, 7)).should == false }
+      it { subject.contains?(Hexagonly::Point.new(7, 8)).should == true }
+      it { subject.contains?(Hexagonly::Point.new(5.1, 4)).should == true }
+      it { subject.contains?(Hexagonly::Point.new(6, 4.2)).should == false }
+      it { subject.contains?(Hexagonly::Point.new(6, 5)).should == false }
+      it { subject.contains?(Hexagonly::Point.new(4.9, 3.5)).should == true }
+      it { subject.contains?(Hexagonly::Point.new(6, 6.2)).should == false }
+    end
+
+  end
+  
+end

data/spec/lib/hexagonly/space_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe Hexagonly::Space do
+
+  context "when initialized with sufficient points" do
+    before(:each) do
+      points_arr = [
+        [1, 2], [3, 2], [4, 3], [1, 5], [4, 4], [7, 2], [8, 1], [2, 6], [5, 9], [6, 5], [1, 4]
+      ]
+      @points = points_arr.map{ |point| Hexagonly::Point.new(point[0], point[1]) }
+      @space = Hexagonly::Space.new(@points)
+    end
+
+    it "assigns points to a readable attribute" do
+      @space.points.should == @points
+    end
+
+    it "computes the boundries of this space" do
+      @space.north.should == Hexagonly::Point.new(5, 9)
+      @space.west.should == Hexagonly::Point.new(1, 2)
+      @space.south.should == Hexagonly::Point.new(8, 1)
+      @space.east.should == Hexagonly::Point.new(8, 1)
+    end
+
+    it "computes the center of this space" do
+      @space.center.class.should == Hexagonly::Point
+      @space.center.should == Hexagonly::Point.new((8 - 1) / 2 + 1, (9 - 1) / 2 + 1)
+    end
+  end
+
+end

data/spec/lib/hexagonly_spec.rb

@@ -0,0 +1,5 @@
+require 'spec_helper'
+
+describe Hexagonly do
+  
+end

data/spec/spec_helper.rb

@@ -0,0 +1,8 @@
+require 'hexagonly'
+require 'factory_girl'
+
+FactoryGirl.find_definitions
+
+RSpec.configure do |config|
+  config.include FactoryGirl::Syntax::Methods
+end

metadata

@@ -0,0 +1,163 @@
+--- !ruby/object:Gem::Specification
+name: hexagonly
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Florin Lipan
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-10-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: factory_girl
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: redcarpet
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Hexagonal tiling in Ruby.
+email:
+- lipanski@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- .ruby-gemset
+- .ruby-version
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- hexagonly.gemspec
+- lib/hexagonly.rb
+- lib/hexagonly/geo_json.rb
+- lib/hexagonly/hexagon.rb
+- lib/hexagonly/point.rb
+- lib/hexagonly/polygon.rb
+- lib/hexagonly/space.rb
+- lib/hexagonly/version.rb
+- localities.rb
+- spec/factories.rb
+- spec/fixtures/localities.csv
+- spec/lib/hexagonly/hexagon_spec.rb
+- spec/lib/hexagonly/point_spec.rb
+- spec/lib/hexagonly/polygon_spec.rb
+- spec/lib/hexagonly/space_spec.rb
+- spec/lib/hexagonly_spec.rb
+- spec/spec_helper.rb
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.5
+signing_key: 
+specification_version: 4
+summary: Provides helper classes for performing regular, flat-topped hexagonal tiling
+  and other polygon-related operations.
+test_files:
+- spec/factories.rb
+- spec/fixtures/localities.csv
+- spec/lib/hexagonly/hexagon_spec.rb
+- spec/lib/hexagonly/point_spec.rb
+- spec/lib/hexagonly/polygon_spec.rb
+- spec/lib/hexagonly/space_spec.rb
+- spec/lib/hexagonly_spec.rb
+- spec/spec_helper.rb
+has_rdoc: