wicket 0.0.2 → 0.1.0

data/lib/wicket/svg_path.rb

@@ -1,36 +1,51 @@
 module Wicket
   class SVGPath
-    attr_reader :text
-    def initialize(text)
+    attr_reader :text, :subpaths
+    def initialize(text,opts={})
       @text = text
+      @opts = Wicket.configuration.merge(opts)
       @subpaths = []
       parse
     end
 
-    def to_polygon
-      poly = @subpaths.first.to_polygon
+    def to_polygon(opts={})
+      poly = @subpaths.first.to_polygon(opts)
       "POLYGON#{poly}"
     end
 
-    def to_multipolygon
-      polys = @subpaths.map(&:to_polygon).join(",")
+    def to_multipolygon(opts={})
+      polys = @subpaths.map{|s| s.to_polygon(opts) }.join(",")
       "MULTIPOLYGON(#{polys})"
     end
 
+    def to_svg(opts={},style="fill:none;stroke:lawngreen")
+      o = @opts.merge(opts)
+      paths = @subpaths.map{|s| s.to_svg(o) }.join(" ")
+      <<-SVG
+        <svg>
+          <path d="#{@text}" style="fill: slateblue; opacity:0.2"/>
+          <path d="#{paths}" style="#{style}" stroke-weight="2"/>
+        </svg>
+      SVG
+    end
+
     private
 
       def parse
         commands = @text.scan(/(?:([MmLlHhVvQqCcTtSsAaZz])([\d\.\,\-\s]+)*)/)
-        commands.each_with_index.inject(new_subpath) do |subpath,((code,arg_string),index)|
+        commands.inject(new_subpath) do |subpath,(code,arg_string)|
+          subpath = new_subpath if subpath.closed?
           # pass the code and arguments for parsing into individual commands and add them to the subpath
-          subpath.add_command( *Command.from_code(code,arg_string,subpath) )
-          # if the path closes, provision a new subpath for future commands unless done
-          (subpath.closed? && (index + 1) < commands.length) ? new_subpath : subpath
+          subpath.add_command( *Command.from_code(code,arg_string,subpath,@opts) )
         end
       end
 
       def new_subpath
         Subpath.new.tap {|s| @subpaths << s }
       end
+
+      def default_opts
+        Wicket.configuration.to_h
+      end
   end
 end

data/lib/wicket/utilities.rb

@@ -0,0 +1,60 @@
+module Wicket
+  module Utilities
+    class << self
+      def radians_tolerance(opts={})
+        t = opts[:min_angle]
+        case opts[:min_angle_unit] || determine_tolerance(t)
+        when nil,:radians 
+          check_range(Math::PI,t)
+          t
+        when :degrees
+          check_range(180,t)
+          (t / 180.0) * Math::PI
+        when :percentage
+          check_range(100,t)
+          (t / 100.0) * Math::PI
+        when :decimal_percentage
+          check_range(1,t)
+          t * Math::PI
+        end
+      end
+
+      def format(n,opts={})
+        s = scale(opts)
+        if s == 0 
+          n.to_i.to_s
+        else
+          n.round(s).to_s("F")
+        end
+      end
+
+      private
+
+        def determine_tolerance(t)
+          if t > 0 && t < 1
+            :decimal_percentage
+          elsif t >= 1 && t < Math::PI
+            :radians
+          elsif t >= Math::PI && t < 100
+            :percentage
+          elsif t >= 100 && t < 180
+            :degrees
+          else
+            raise_error(0,180)
+          end
+        end
+
+        def check_range(upper,val)
+          raise_error(0,upper) unless val < upper
+        end
+
+        def raise_error(lower,upper)
+          raise ArgumentError.new("Tolerance must be greater than #{lower} and less than #{upper}")
+        end
+
+        def scale(o={})
+          o[:scale] || o[:_scale]
+        end
+    end
+  end
+end

data/lib/wicket/version.rb

@@ -1,3 +1,3 @@
 module Wicket
-  VERSION = "0.0.2"
+  VERSION = "0.1.0"
 end

data/spec/coordinate_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+module Wicket
+  describe Coordinate do
+    let(:coord){ Coordinate.new(3,4) }
+    let(:remote){ Coordinate.new(0,0) }
+
+    it "calculates distance" do
+      expect(coord.distance_to(remote)).to eq(5)
+    end
+
+    it "absolutizes" do
+      ab = coord.absolutize(2,-4)
+      expect(ab.x).to eq(5)
+      expect(ab.y).to eq(0)
+    end
+
+    it "relativizes" do
+      expect(coord.relativize(remote)).to eq([-3,-4])
+    end
+
+    it "reflects" do
+      reflection = coord.reflect(remote)
+      expect(reflection.x).to eq(6)
+      expect(reflection.y).to eq(8)       
+    end
+  end
+end

data/spec/svg_path_spec.rb

@@ -1,126 +1,45 @@
 require 'spec_helper'
+require 'yaml'
 
 module Wicket
   describe SVGPath do
-    let(:path){ SVGPath.new("M10 10 20 20") }
 
-    it "knows its text" do
-      expect(path.text).to eq("M10 10 20 20")
-    end
-
-    context "absolute h shortcuts" do
-      let(:path){ SVGPath.new("M10 10H20l10 10H10z") }
-      it "parses to polygon" do
-        expect(path.to_polygon).to eq("POLYGON((10.0 -10.0,20.0 -10.0,30.0 -20.0,10.0 -20.0,10.0 -10.0))")
-      end
-
-      it "parses to a multipolygon" do
-        expect(path.to_multipolygon).to eq("MULTIPOLYGON(((10.0 -10.0,20.0 -10.0,30.0 -20.0,10.0 -20.0,10.0 -10.0)))")
-      end
-    end
-
-    context "relative h shortcuts" do
-      let(:path){ SVGPath.new("M10 10h20h10l10 10h-10z") }
-      it "parses to polygon" do
-        expect(path.to_polygon).to eq("POLYGON((10.0 -10.0,30.0 -10.0,40.0 -10.0,50.0 -20.0,40.0 -20.0,10.0 -10.0))")
-      end
-
-      it "parses to a multipolygon" do
-        expect(path.to_multipolygon).to eq("MULTIPOLYGON(((10.0 -10.0,30.0 -10.0,40.0 -10.0,50.0 -20.0,40.0 -20.0,10.0 -10.0)))")
-      end
-    end
-
-    context "absolute h shortcuts" do
-      let(:path){ SVGPath.new("M10 10l20 20V50V80z") }
-      it "parses to polygon" do
-        expect(path.to_polygon).to eq("POLYGON((10.0 -10.0,30.0 -30.0,30.0 -50.0,30.0 -80.0,10.0 -10.0))")
-      end
-
-      it "parses to a multipolygon" do
-        expect(path.to_multipolygon).to eq("MULTIPOLYGON(((10.0 -10.0,30.0 -30.0,30.0 -50.0,30.0 -80.0,10.0 -10.0)))")
-      end
-    end
-
-    context "relative h shortcuts" do
-      let(:path){ SVGPath.new("M10 10h20h10l10 10h-10z") }
-      it "parses to polygon" do
-        expect(path.to_polygon).to eq("POLYGON((10.0 -10.0,30.0 -10.0,40.0 -10.0,50.0 -20.0,40.0 -20.0,10.0 -10.0))")
-      end
-
-      it "parses to a multipolygon" do
-        expect(path.to_multipolygon).to eq("MULTIPOLYGON(((10.0 -10.0,30.0 -10.0,40.0 -10.0,50.0 -20.0,40.0 -20.0,10.0 -10.0)))")
-      end
-    end
-
-    context "single subpath, manually closed, no explicit commands" do
-      let(:path){ SVGPath.new("M197.5977 356.0957 227.0786 325.3271 229.667 328.4067 200.8188 358.5156 197.5977 356.0957") }
+    # examples from test_cases.yml
+    YAML.load(File.open("spec/test_cases.yml","r")).each do |title,data|
+      wkts = data["wkt"].map{|w| "((#{w}))" }
+      context(title) do
+        let(:path){ SVGPath.new(data["path"]) }
+        it "parses to polygon" do
+          expect(path.to_polygon(:min_angle => 165)).to eq("POLYGON#{wkts.first}")
+        end
 
-      it "parses to polygon" do
-        expect(path.to_polygon).to eq("POLYGON((197.5977 -356.0957,227.0786 -325.3271,229.667 -328.4067,200.8188 -358.5156,197.5977 -356.0957))")
-      end
-
-      it "parses to a multipolygon" do
-        expect(path.to_multipolygon).to eq("MULTIPOLYGON(((197.5977 -356.0957,227.0786 -325.3271,229.667 -328.4067,200.8188 -358.5156,197.5977 -356.0957)))")
-      end
-    end
-
-    context "single subpath, z closed, no explicit commands" do
-      let(:path){ SVGPath.new("M227.1177 371.5405 247.7852 349.9634 250.373 353.0425 230.2959 374.0044 z") }
-
-      it "parses to polygon" do
-        expect(path.to_polygon).to eq("POLYGON((227.1177 -371.5405,247.7852 -349.9634,250.373 -353.0425,230.2959 -374.0044,227.1177 -371.5405))")
-      end
-
-      it "parses to a multipolygon" do
-        expect(path.to_multipolygon).to eq("MULTIPOLYGON(((227.1177 -371.5405,247.7852 -349.9634,250.373 -353.0425,230.2959 -374.0044,227.1177 -371.5405)))")
-      end
-    end
-
-
-    context "single subpath, z closed, no explicit commands" do
-      let(:path){ SVGPath.new("M227.1177 371.5405 247.7852 349.9634 250.373 353.0425 230.2959 374.0044 z") }
-
-      it "parses to polygon" do
-        expect(path.to_polygon).to eq("POLYGON((227.1177 -371.5405,247.7852 -349.9634,250.373 -353.0425,230.2959 -374.0044,227.1177 -371.5405))")
-      end
-
-      it "parses to a multipolygon" do
-        expect(path.to_multipolygon).to eq("MULTIPOLYGON(((227.1177 -371.5405,247.7852 -349.9634,250.373 -353.0425,230.2959 -374.0044,227.1177 -371.5405)))")
+        it "parses to a multipolygon" do
+          expect(path.to_multipolygon(:min_angle => 165)).to eq("MULTIPOLYGON(#{wkts.join(",")})")
+        end
       end
     end
 
-    context "single subpath, z closed, relative and absolute commands" do
-      let(:path){ SVGPath.new("M722.3984,688.502L710,693.5693l-1.8115-3.5811l12.3096-5.0313L732.3984,688.502z") }
-
-      it "parses to polygon" do
-        expect(path.to_polygon).to eq("POLYGON((722.3984 -688.502,710.0 -693.5693,708.1885 -689.9882,720.4981 -684.9569,732.3984 -688.502,722.3984 -688.502))")
-      end
-
-      it "parses to a multipolygon" do
-        expect(path.to_multipolygon).to eq("MULTIPOLYGON(((722.3984 -688.502,710.0 -693.5693,708.1885 -689.9882,720.4981 -684.9569,732.3984 -688.502,722.3984 -688.502)))")
-      end
+    it "knows its text" do
+      path = SVGPath.new("M10 10 20 20")
+      expect(path.text).to eq("M10 10 20 20")
     end
 
-    context "two subpaths, z closed, no explicit commands" do
-      let(:path){ SVGPath.new("M227.1177 371.5405 247.7852 349.9634 250.373 353.0425 230.2959 374.0044 z M197.5977 356.0957 227.0786 325.3271 229.667 328.4067 200.8188 358.5156 197.5977 356.0957") }
+    context "curved paths" do
+      let(:path){ SVGPath.new("M0 0,C0 200,200 200,200 0z") }
+      let(:wkt){ path.to_polygon(:min_angle => 160) }
 
-      it "parses the first subpath to polygon" do
-        expect(path.to_polygon).to eq("POLYGON((227.1177 -371.5405,247.7852 -349.9634,250.373 -353.0425,230.2959 -374.0044,227.1177 -371.5405))")
+      it "contains the vertices" do
+        ["0 0","200 0"].each do |vertex|
+          expect(path.to_multipolygon).to include(vertex)
+        end
       end
 
-      it "parses both to a multipolygon" do
-        expect(path.to_multipolygon).to eq("MULTIPOLYGON(((227.1177 -371.5405,247.7852 -349.9634,250.373 -353.0425,230.2959 -374.0044,227.1177 -371.5405)),((197.5977 -356.0957,227.0786 -325.3271,229.667 -328.4067,200.8188 -358.5156,197.5977 -356.0957)))")
-      end
-    end
-
-    context "the kitchen sink" do
-      let(:path){ SVGPath.new("M293.9214,533.9287l-6.3857-18.1475l3.9316-0.8857l6.0811,17.29L293.9214,533.9287z M287.5356,515.7813V496.5h3.9316v18.3955 L287.5356,515.7813z") }
-      it "parses the first subpath to polygon" do
-        expect(path.to_polygon).to eq("POLYGON((293.9214 -533.9287,287.5357 -515.7812,291.4673 -514.8955,297.5484 -532.1855,293.9214 -533.9287,293.9214 -533.9287))")
+      it "allows you to make a lower resolution curve" do
+        expect(path.to_polygon(:min_angle => 150).length).to be < wkt.length
       end
 
-      it "parses both to a multipolygon" do
-        expect(path.to_multipolygon).to eq("MULTIPOLYGON(((293.9214 -533.9287,287.5357 -515.7812,291.4673 -514.8955,297.5484 -532.1855,293.9214 -533.9287,293.9214 -533.9287)),((287.5356 -515.7813,287.5356 -496.5,291.4672 -496.5,291.4672 -514.8955,287.5356 -515.7813,287.5356 -515.7813)))")
+      it "allows you to make a higher resolution curve" do
+        expect(path.to_polygon(:min_angle => 175).length).to be > wkt.length
       end
     end
   end

data/spec/test_cases.yml

@@ -0,0 +1,91 @@
+"absolute h":
+  path: 'M10 10H20l10 10H10z'
+  wkt:
+    - '10 -10,20 -10,30 -20,10 -20,10 -10'
+
+"relative h":
+  path: "M10 10h20h10l10 10h-10z"
+  wkt:
+    - '10 -10,30 -10,40 -10,50 -20,40 -20,10 -10'
+
+"absolute v":
+  path: 'M10 10l20 20V50V80z'
+  wkt:
+    - '10 -10,30 -30,30 -50,30 -80,10 -10'
+
+"relative v":
+  path: "M10 10L20 10v10L10 20z"
+  wkt:
+    - '10 -10,20 -10,20 -20,10 -20,10 -10'
+
+"absolute c":
+  path: 'M0 0,C0 200,200 200,200 0z'
+  wkt:
+    - '0 0,2 -35,8 -65,31 -112,46 -128,63 -140,81 -147,100 -150,118 -147,136 -140,153 -128,168 -112,181 -91,191 -65,200 0,0 0'
+
+"relative c":
+  path: 'M100 100,c0 200,200 200,200 0z'
+  wkt:
+    - '100 -100,102 -135,108 -165,131 -212,146 -228,163 -240,181 -247,200 -250,218 -247,236 -240,253 -228,268 -212,281 -191,291 -165,300 -100,100 -100'
+
+"absolute s":
+  path: 'M0 0,C0 200,200 200,200 0 S 400,-200 400 0 v400h-400z'
+  wkt:
+    - '0 0,2 -35,8 -65,31 -112,46 -128,63 -140,81 -147,100 -150,118 -147,136 -140,153 -128,168 -112,181 -91,191 -65,200 0,202 35,208 65,231 112,246 128,263 140,281 147,300 150,318 147,336 140,353 128,368 112,381 91,391 65,400 0,400 -400,0 -400,0 0'
+
+"relative s":
+  path: 'M100 100,c0 200,200 200,200 0 s 200,-200 200 0 v400h-400z'
+  wkt:
+    - '100 -100,102 -135,108 -165,131 -212,146 -228,163 -240,181 -247,200 -250,218 -247,236 -240,253 -228,268 -212,281 -191,291 -165,300 -100,302 -64,308 -34,331 12,346 28,363 40,381 47,400 50,418 47,436 40,453 28,468 12,481 -8,491 -34,500 -100,500 -500,100 -500,100 -100'
+
+"absolute q":
+  path: 'M10 10,Q110 210 210 10z'
+  wkt: 
+    - '10 -10,35 -53,60 -85,72 -95,85 -103,97 -108,110 -110,122 -108,135 -103,147 -95,160 -85,185 -53,210 -10,10 -10'
+
+"relative q":
+  path: 'M100 100,q100 100 200 0z'
+  wkt:
+    - '100 -100,125 -121,150 -137,175 -146,200 -150,225 -146,250 -137,275 -121,300 -100,100 -100'
+
+"absolute t":
+  path: 'M100 100,q100 100 200 0T500 100v200h-400z'
+  wkt:
+    - '100 -100,125 -121,150 -137,175 -146,200 -150,225 -146,250 -137,275 -121,300 -100,325 -78,350 -62,375 -53,400 -50,425 -53,450 -62,475 -78,500 -100,500 -300,100 -300,100 -100'
+
+"relative t":
+  path: 'M100 100,q100 100 200 0t100 100v200h-300z'
+  wkt:
+    - '100 -100,125 -121,150 -137,175 -146,200 -150,225 -146,250 -137,275 -121,300 -100,323 -79,343 -68,352 -66,360 -67,364 -68,368 -69,375 -75,380 -82,385 -92,393 -118,400 -200,400 -400,100 -400,100 -100'
+
+"only M":
+  path: 'M197.5977 356.0957 227.0786 325.3271 229.667 328.4067 200.8188 358.5156 197.5977 356.0957'
+  wkt:
+    - '197.5977 -356.0957,227.0786 -325.3271,229.667 -328.4067,200.8188 -358.5156,197.5977 -356.0957'
+
+"M with z":
+  path: 'M227.1177 371.5405 247.7852 349.9634 250.373 353.0425 230.2959 374.0044 z'
+  wkt:
+    - '227.1177 -371.5405,247.7852 -349.9634,250.373 -353.0425,230.2959 -374.0044,227.1177 -371.5405'
+
+"L and l":
+  path: 'M722.3984,688.502L710,693.5693l-1.8115-3.5811l12.3096-5.0313L732.3984,688.502z'
+  wkt:
+   - '722.3984 -688.502,710.0 -693.5693,708.1885 -689.9882,720.4981 -684.9569,732.3984 -688.502,722.3984 -688.502'
+
+"Two subpaths":
+  path: 'M227.1177 371.5405 247.7852 349.9634 250.373 353.0425 230.2959 374.0044 z M197.5977 356.0957 227.0786 325.3271 229.667 328.4067 200.8188 358.5156 197.5977 356.0957'
+  wkt:
+   - '227.1177 -371.5405,247.7852 -349.9634,250.373 -353.0425,230.2959 -374.0044,227.1177 -371.5405'
+   - '197.5977 -356.0957,227.0786 -325.3271,229.667 -328.4067,200.8188 -358.5156,197.5977 -356.0957'
+
+"complex linear":
+  path: 'M293.9214,533.9287l-6.3857-18.1475l3.9316-0.8857l6.0811,17.29L293.9214,533.9287z M287.5356,515.7813V496.5h3.9316v18.3955 L287.5356,515.7813z'
+  wkt:
+    - '293.9214 -533.9287,287.5357 -515.7812,291.4673 -514.8955,297.5484 -532.1855,293.9214 -533.9287,293.9214 -533.9287'
+    - '287.5356 -515.7813,287.5356 -496.5,291.4672 -496.5,291.4672 -514.8955,287.5356 -515.7813,287.5356 -515.7813'
+
+"complex curved":
+  path: 'M889.9277,494.0005c0,12.1528-0.8057,23.9614-2.3066,35.4341h10.1104 c1.4434-11.4824,2.1963-23.2969,2.1963-35.4341s-0.7529-23.9526-2.1963-35.4351h-10.1104 C889.1221,470.0381,889.9277,481.8467,889.9277,494.0005z'
+  wkt:
+    - '889.9277 -494.0005,889.3372 -511.9726,887.6211 -529.4346,897.7315 -529.4346,899.3709 -511.9631,899.9278 -494.0005,899.3709 -476.0374,897.7315 -458.5654,887.6211 -458.5654,889.3373 -476.0275,889.9277 -494.0005,889.9277 -494.0005'

data/spec/utilities_spec.rb

@@ -0,0 +1,91 @@
+require 'spec_helper'
+
+module Wicket
+  describe Utilities do
+    describe "#radians_tolerance" do
+      it "raises for 0" do
+        expect{Utilities.radians_tolerance(:min_angle => 0)}.to raise_error
+        
+      end
+      context "radians" do
+        it "does not convert when implicitly radians" do
+          t = Utilities.radians_tolerance(:min_angle => 3)
+          expect(t).to eq(3)
+        end
+
+        it "does not convert if explicitly set as radians" do
+          t = Utilities.radians_tolerance(:min_angle => 3.1, :min_angle_unit => :radians)
+          expect(t).to eq(3.1)
+        end
+
+        it "does not convert a radian explcitly set but out of range" do
+          t = Utilities.radians_tolerance(:min_angle => 0.9, :min_angle_unit => :radians)
+          expect(t).to eq(0.9)
+        end
+
+        it "raises if over pi" do
+          expect{Utilities.radians_tolerance(:min_angle => 4, :min_angle_unit => :radians)}.to raise_error
+        end
+      end
+
+      context "degrees" do
+        it "converts degrees explicitly" do
+          t = Utilities.radians_tolerance(:min_angle => 170, :min_angle_unit => :degrees)
+          expect(t).to be_within(0.00000001).of(2.96705973)
+        end
+
+        it "converts degrees implicitly" do
+          t = Utilities.radians_tolerance(:min_angle => 175)
+          expect(t).to be_within(0.00000001).of(3.05432619)
+        end
+
+        it "converts degrees out of range when explicit" do
+          t = Utilities.radians_tolerance(:min_angle => 95, :min_angle_unit => :degrees)
+          expect(t).to be_within(0.00000001).of(1.65806279)
+        end
+
+        it "raises if over 180" do
+          expect{Utilities.radians_tolerance(:min_angle => 190, :min_angle_unit => :degrees)}.to raise_error
+        end
+      end
+
+      context "percentage" do
+        it "converts percentages explicitly" do
+          t = Utilities.radians_tolerance(:min_angle => 95, :min_angle_unit => :percentage)
+          expect(t).to be_within(0.00000001).of(2.98451302)
+        end
+
+        it "converts percentages implicitly" do
+          t = Utilities.radians_tolerance(:min_angle => 90)
+          expect(t).to be_within(0.00000001).of(2.82743339)
+        end
+
+        it "converts percentages out of range when explicit" do
+          t = Utilities.radians_tolerance(:min_angle => 2, :min_angle_unit => :percentage)
+          expect(t).to be_within(0.00000001).of(0.06283185)
+        end
+
+        it "raises if over 100" do
+          expect{Utilities.radians_tolerance(:min_angle => 115, :min_angle_unit => :percentage)}.to raise_error
+        end
+      end
+
+
+      context "decimal percentage" do
+        it "converts decimal percentages explicitly" do
+          t = Utilities.radians_tolerance(:min_angle => 0.95, :min_angle_unit => :decimal_percentage)
+          expect(t).to be_within(0.00000001).of(2.98451302)
+        end
+
+        it "converts decimal percentages implicitly" do
+          t = Utilities.radians_tolerance(:min_angle => 0.90)
+          expect(t).to be_within(0.00000001).of(2.82743339)
+        end
+
+        it "raises if over 1" do
+          expect{Utilities.radians_tolerance(:min_angle => 1.15, :min_angle_unit => :decimal_percentage)}.to raise_error
+        end
+      end
+    end
+  end
+end