savage-transform 1.3.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: cf1e69ab33f99df9fad325436299518c244b3177
+  data.tar.gz: 170690ea6f0578153fc7b5871fb15bf0fd008a31
+SHA512:
+  metadata.gz: 183580c5e2024cb45d96c63c2c505242fd31d66da527559fa29791247c446102a0b207a061212c44ec5a0058017ac291e764bf374873e0722e7e4654eae918f6
+  data.tar.gz: 968a69b2944465fb32a34b1113b8c95bccaf002575c1632ea60da43e598acc6a627270b5433c7b6c67d95716505b1a5c254dcad3ebef00cde72faeeaad5e31a6

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,22 @@
+## MAC OS
+.DS_Store
+
+## TEXTMATE
+*.tmproj
+tmtags
+
+## EMACS
+*~
+\#*
+.\#*
+
+## VIM
+*.swp
+
+## PROJECT::GENERAL
+coverage
+rdoc
+pkg
+.rvmrc
+
+## PROJECT::SPECIFIC

data/.rspec

@@ -0,0 +1 @@
+--color

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010 Jeremy Holland
+
+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.rdoc

@@ -0,0 +1,108 @@
+= Savage
+
+A little gem for extracting and manipulating SVG vector path data, Savage will make your life easier when it comes time to dynamically draw new and manipulate existing SVG paths. No more wacky regex to capture those cryptic path data strings; just pass the whole "d" attribute into Savage's parser, et voilá: You'll be given an instance of Savage::Path, replete with an array of subpaths split on the "move to" commands (to better help with those pesky winding issues). In turn, each subpath contains its own array of directions that can be swapped around, reconfigured, and otherwise manipulated to your heart's content in a truly human-readable way.
+
+== Latest Update
+
+Version 1.2.0 includes a new array abstraction (see below) and optimized implementation of Direction#to_command, courtesy of {bdon}[https://github.com/bdon]!
+
+== Usage
+
+<b>Parsing existing data</b>
+
+Easy-peasy Japanesey. Just take a look at the below:
+
+  path = Savage::Parser.parse my_path_data_string
+  path.subpaths # [subpath_1, subpath_2, ... subpath_n]
+  path.subpaths.last.directions # [direction_1, direction_2, ... direction_n]
+
+Once extracted, you can manipulate, add, and remove the subpaths and directions as you see fit. See below for instructions on using the various direction types
+
+<b>Creating from scratch</b>
+
+What if you want to roll your own from the get-go? No problem:
+
+  path = Savage::Path.new do |p|
+    p.move_to 100, 200
+    p.line_to 300, 400
+    p.horizontal_to 500
+    p.close_path
+  end
+
+We'll learn more about the actual drawing methods here shortly, but suffice it to say they are provided both as methods on the constructor block parameter for the sake of your visual organization, and the path itself after instantiation, as below:
+
+  path = Savage::Path.new
+  path.move_to 100, 200
+  path.line_to 300, 400
+  path.horizontal_to 500
+  path.close_path
+
+<b>Drawing with Savage</b>
+
+So what are the different directions we can give our virtual pen? Here I'll refer you first to the SVG 1.1 specification by our friends down at the W3C, as they can describe all the specifics much better than I: http://www.w3.org/TR/SVG/paths.html#PathData. Each "command" listed in that section has an analog method on the Savage::SubPath class as well as the Savage::Path class (calling one of the methods on an instance of the Savage::Path class actually just delegates the call to the last SubPath in that path's selection of subpaths). Every parameter of these methods is expected to be a Numeric except where noted otherwise.  The methods are as follows:
+
+* <b>path.move_to(target_x, target_y)</b> - Move the 'pen' to the specified coordinates on the 'canvas' without drawing anything. Note that you can only call this method on a subpath if it's otherwise empty. Most of the time, just call this on an instance of the Path class, which will actually create a new subpath for you to continue drawing into
+* <b>path.close_path()</b> - Draw a straight line from the current position to the coordinates of the start of the current subpath
+* <b>path.line_to(target_x, target_y)</b> - Draw a straight line from the current position to the specified coordinates
+* <b>path.horizontal_to(target_x)</b> - Draw a straight horizontal line to the provided x coordinate
+* <b>path.vertical_to(target_y)</b> - Draw a straight vertical line to the provided y coordinate
+* <b>path.cubic_curve_to(control_1_x, control_1_y, control_2_x, control_2_y, target_x, target_y)</b> - Draw a cubic Bézier curve from the current position to the target coordinates (target_x/y) using the control points specified - see the SVG specification referred to above for more info
+* <b>path.cubic_curve_to(control_2_x, control_2_y, target_x, target_y)</b> - Shorthand cubic Bézier curve; assumes continuation of previous curve. See SVG specification
+* <b>path.quadratic_curve_to(control_x, control_y, target_x, target_y)</b> - Draw a quadratic Bézier curve from the current position to the target coordinates (target_x/y) using the control point specified - see the SVG specification referred to above for more info
+* <b>path.quadratic_curve_to(target_x, target_y)</b> - Shorthand quadratic Bézier curve; assumes continuation of previous curve. See SVG specification
+* <b>path.arc_to(radius_x,radius_y,rotation,large_arc_flag,sweep_flag,target_x,target_y)</b> - This is a doozy and complicated as sin to explain, so we'll let the W3C do it for us - see the spec. Otherwise, be aware that the large_arc_flag and sweep_flag arguments are expected to be boolean values, not Numeric.
+
+There you have it, pretty much right out of the book. One thing to keep in mind is that all of these methods use ABSOLUTE coordinates by default; if you want to use relative coordinates (based on the current position of the 'pen'), just pass false as the final argument to any of them:
+
+  path.line_to 100, 200, false
+
+Each of these commands just creates a new instance of the appropriate subclass of the Savage::Direction class and pushes it onto the end of the directions list in question. Don't necessarily want to draw onto the end? Just create your own instance using the standard constructor and insert it wherever it butters your biscuit so to do:
+
+  direction = Savage::Directions::LineTo.new(100,200)
+  subpath.directions.insert(3,direction)
+
+Did you mess up before and need to change a directions coordinates after you drew it (or, more likely, after you parsed it out of some pre-existing data)? No problem:
+
+  direction = Savage::Directions::LineTo.new(100,200)
+  direction.target.x = 234
+
+As you may have guessed, Savage::Path#subpaths and Savage::SubPath#directions are both just good old-fashioned arrays, so you can fiddle with them using all your favorite Enumerable tricks as always.
+
+<b>Abstracting it to an array (new in v1.2.0!)</b>
+
+Bang!:
+
+  path.to_a # => ["M", 100, 200, ...]
+
+<b>Turning it back into a path data string</b>
+
+Bang!:
+
+  path.to_command # => 'M100 200-342 43.5Q-34.88 123.9 13-532' or whatever...
+
+Note that the #to_command method exists on Savage::Path, Savage::SubPath, and each subclass of Savage::Direction, so you can be as fine-grained with it as needed.
+
+== Issues / Feature Requests
+
+I have no doubt that will be some problems with this thing, as well as features missing that some of you fine folks might want. Please, please, please check Github's issue-tracking system to see if a ticket for the problem has already been submitted, or create a new one if not. I'll check the issues listed therein regularly, but you email me directly at your own risk (and by risk, I mean risk of not receiving a reply). :)
+
+== Note on Patches/Pull Requests
+
+* Fork the project.
+* Make your feature addition or bug fix. I very much prefer feature-specific branches.
+* Add specs for it. This is important so I don't break it in a future version unintentionally, which I can guarantee I will do.
+* Commit. Do not mess with rakefile, version, or history, please.
+* Send me a pull request - again, bonus points for topic branches.
+
+== Contributors
+
+* Jeremy Holland (jeremy@jeremypholland.com, github:{awebneck}[https://github.com/awebneck]) -- author
+* Christoffer Klang (toffeklang@yahoo.se, github:{christoffer}[https://github.com/christoffer]) -- regexp improvements
+* Bartosz Dz (github:{MatmaRex}[https://github.com/matmarex]) -- parser improvements, scientific notation support, bug fixes
+* Brandon Liu (github:{bdon}[https://github.com/bdon]) -- spec improvements, array abstraction
+
+== Copyright
+
+Copyright (c) 2010 Jeremy Holland. See LICENSE for details.
+
+

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/VERSION

@@ -0,0 +1 @@
+1.3.0

data/lib/savage.rb

@@ -0,0 +1,3 @@
+%w[ utils transformable direction path parser ].each do |library|
+  require_relative "savage/#{library}"
+end

data/lib/savage/direction.rb

@@ -0,0 +1,56 @@
+module Savage
+  module Directions
+    Point = Struct.new :x, :y
+  end
+
+  class Direction
+
+    include Utils
+    include Transformable
+
+    def initialize(absolute)
+      @absolute = absolute
+    end
+
+    def absolute?
+      @absolute
+    end
+
+    def relative?
+      !absolute?
+    end
+
+    def to_command
+      arr = to_a
+      arr[0] + arr[1..-1].map {|i| to_short_f(i)}.join(' ').gsub(/ -/,'-')
+    end
+
+    # Public: determine if this direction is fully transformable.
+    #         A fully transformable directions can accept any
+    #         transform including rotate.
+    #
+    # Returns: true by default
+    def fully_transformable?
+      true
+    end
+
+    private
+      
+      def to_short_f n
+        f = 1000000.0
+        n = (n * f).round / f
+        n == n.to_i ? n.to_i : n
+      end
+  end
+end
+
+require File.dirname(__FILE__) + "/directions/close_path"
+require File.dirname(__FILE__) + "/directions/coordinate_target"
+require File.dirname(__FILE__) + "/directions/horizontal_to"
+require File.dirname(__FILE__) + "/directions/vertical_to"
+require File.dirname(__FILE__) + "/directions/point_target"
+require File.dirname(__FILE__) + "/directions/move_to"
+require File.dirname(__FILE__) + "/directions/line_to"
+require File.dirname(__FILE__) + "/directions/quadratic_curve_to"
+require File.dirname(__FILE__) + "/directions/cubic_curve_to"
+require File.dirname(__FILE__) + "/directions/arc_to"

data/lib/savage/direction_proxy.rb

@@ -0,0 +1,19 @@
+module Savage
+  module DirectionProxy
+    def self.included(klass)
+      klass.extend ClassMethods
+    end
+
+    module ClassMethods
+      def define_proxies(&block)
+        Directions.constants.each do |constant_sym|
+          constant = (constant_sym.is_a?(Symbol)) ? constant_sym.to_s : constant_sym
+          unless %w[PointTarget CoordinateTarget Point MoveTo].include? constant
+            sym = constant.to_s.gsub(/[A-Z]/) { |p| '_' + p.downcase }[1..-1].to_sym
+            block.call(sym,constant)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/savage/directions/arc_to.rb

@@ -0,0 +1,30 @@
+module Savage
+  module Directions
+    class ArcTo < PointTarget
+      attr_accessor :radius, :rotation, :large_arc, :sweep
+
+      def initialize(radius_x, radius_y, rotation, large_arc, sweep, target_x, target_y, absolute=true)
+        super(target_x, target_y, absolute)
+        @radius = Point.new(radius_x, radius_y)
+        @rotation = rotation
+        @large_arc = large_arc.is_a?(Numeric) ? large_arc > 0 : large_arc
+        @sweep = sweep.is_a?(Numeric) ? sweep > 0 : sweep
+      end
+
+      def to_a
+        [command_code, @radius.x, @radius.y, @rotation, bool_to_int(@large_arc), bool_to_int(@sweep), target.x, target.y]
+      end
+
+      def command_code
+        (absolute?) ? 'A' : 'a'
+      end
+
+      def transform(scale_x, skew_x, skew_y, scale_y, tx, ty)
+        # relative arc_to dont't need to be tranlated
+        tx = ty = 0 if relative?
+        transform_dot( target,  scale_x, skew_x, skew_y, scale_y, tx, ty)
+      end
+
+    end
+  end
+end

data/lib/savage/directions/close_path.rb

@@ -0,0 +1,22 @@
+module Savage
+  module Directions
+    class ClosePath < Direction
+
+      def initialize(absolute=true)
+        super(absolute)
+      end
+
+      def to_a
+        [command_code]
+      end
+
+      def command_code
+        (absolute?) ? 'Z' : 'z'
+      end
+
+      def movement
+        [0, 0]
+      end
+    end
+  end
+end

data/lib/savage/directions/coordinate_target.rb

@@ -0,0 +1,21 @@
+module Savage
+  module Directions
+    class CoordinateTarget < Direction
+
+      attr_accessor :target
+
+      def initialize(target, absolute=true)
+        @target = target
+        super(absolute)
+      end
+
+      def to_a
+        [command_code, @target]
+      end
+
+      def fully_transformable?
+        false
+      end
+    end
+  end
+end

data/lib/savage/directions/cubic_curve_to.rb

@@ -0,0 +1,47 @@
+module Savage
+  module Directions
+    class CubicCurveTo < QuadraticCurveTo
+      attr_accessor :control_1
+
+      def initialize(*args)
+        raise ArgumentError if args.length < 4
+        case args.length
+        when 4
+          super(args[0],args[1],args[2],args[3],true)
+        when 5
+          raise ArgumentError if args[4].kind_of?(Numeric)
+          super(args[0],args[1],args[2],args[3],args[4])
+        when 6
+          @control_1 = Point.new(args[0],args[1])
+          super(args[2],args[3],args[4],args[5],true)
+        when 7
+          @control_1 = Point.new(args[0],args[1])
+          super(args[2],args[3],args[4],args[5],args[6])
+        end
+      end
+
+      def to_a
+        if @control_1
+          [command_code, @control_1.x, @control_1.y, @control.x, @control.y, @target.x, @target.y]
+        else
+          [command_code, @control.x, @control.y, @target.x, @target.y]
+        end
+      end
+
+      def control_2; @control; end
+      def control_2=(value); @control = value; end
+
+      def command_code
+        return (absolute?) ? 'C' : 'c' if @control_1
+        (absolute?) ? 'S' : 's'
+      end
+
+      def transform(scale_x, skew_x, skew_y, scale_y, tx, ty)
+        super
+        tx = ty = 0 if relative?
+        transform_dot( control_1, scale_x, skew_x, skew_y, scale_y, tx, ty) if control_1
+      end
+
+    end
+  end
+end

data/lib/savage/directions/horizontal_to.rb

@@ -0,0 +1,31 @@
+module Savage
+  module Directions
+    class HorizontalTo < CoordinateTarget
+      def command_code
+        (absolute?) ? 'H' : 'h'
+      end
+
+      def transform(scale_x, skew_x, skew_y, scale_y, tx, ty)
+
+        unless skew_y.zero?
+          raise 'rotating or skewing (in Y axis) an "horizontal_to" direction is not supported yet.'
+        end
+        
+        self.target *= scale_x
+        self.target += tx if absolute?
+      end
+
+      def to_fully_transformable_dir( pen_x, pen_y )
+        if absolute?
+          LineTo.new( target, pen_y, true )
+        else
+          LineTo.new( target, 0, false )
+        end
+      end
+
+      def movement
+        [target, nil]
+      end
+    end
+  end
+end

data/lib/savage/directions/line_to.rb

@@ -0,0 +1,15 @@
+module Savage
+  module Directions
+    class LineTo < PointTarget
+      def command_code
+        (absolute?) ? 'L' : 'l'
+      end
+
+      def transform(scale_x, skew_x, skew_y, scale_y, tx, ty)
+        # relative line_to dont't need to be tranlated
+        tx = ty = 0 if relative?
+        transform_dot( target, scale_x, skew_x, skew_y, scale_y, tx, ty)
+      end
+    end
+  end
+end

data/lib/savage/directions/move_to.rb

@@ -0,0 +1,15 @@
+module Savage
+  module Directions
+    class MoveTo < PointTarget
+      def command_code
+        (absolute?) ? 'M' : 'm'
+      end
+
+      def transform(scale_x, skew_x, skew_y, scale_y, tx, ty)
+        # relative move_to dont't need to be tranlated
+        tx = ty = 0 if relative?
+        transform_dot( target, scale_x, skew_x, skew_y, scale_y, tx, ty )
+      end
+    end
+  end
+end