text2path 0.0.2 → 0.0.4

data/lib/ext/savage/lib/savage/directions/coordinate_target.rb

@@ -1,17 +0,0 @@
-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
-    end
-  end
-end

data/lib/ext/savage/lib/savage/directions/cubic_curve_to.rb

@@ -1,40 +0,0 @@
-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
-    end
-  end
-end

data/lib/ext/savage/lib/savage/directions/horizontal_to.rb

@@ -1,19 +0,0 @@
-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
-    end
-  end
-end

data/lib/ext/savage/lib/savage/directions/line_to.rb

@@ -1,15 +0,0 @@
-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/ext/savage/lib/savage/directions/move_to.rb

@@ -1,15 +0,0 @@
-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

data/lib/ext/savage/lib/savage/directions/point_target.rb

@@ -1,17 +0,0 @@
-module Savage
-  module Directions
-    class PointTarget < Direction
-
-      attr_accessor :target
-
-      def initialize(x, y, absolute=true)
-        @target = Point.new(x,y)
-        super(absolute)
-      end
-
-      def to_a
-        [command_code, @target.x, @target.y]
-      end
-    end
-  end
-end

data/lib/ext/savage/lib/savage/directions/quadratic_curve_to.rb

@@ -1,44 +0,0 @@
-module Savage
-  module Directions
-    class QuadraticCurveTo < PointTarget
-      attr_accessor :control
-
-      def initialize(*args)
-        raise ArgumentError if args.length < 2
-        case args.length
-        when 2
-          super(args[0],args[1],true)
-        when 3
-          raise ArgumentError if args[2].kind_of?(Numeric)
-          super(args[0],args[1],args[2])
-        when 4
-          @control = Point.new(args[0],args[1])
-          super(args[2],args[3],true)
-        when 5
-          @control = Point.new(args[0],args[1])
-          super(args[2],args[3],args[4])
-        end
-      end
-
-      def to_a
-        if @control
-          [command_code, @control.x, @control.y, @target.x, @target.y]
-        else
-          [command_code, @target.x, @target.y]
-        end
-      end
-
-      def command_code
-        return (absolute?) ? 'Q' : 'q' if @control
-        (absolute?) ? 'T' : 't'
-      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)
-        transform_dot( control, scale_x, skew_x, skew_y, scale_y, tx, ty)
-      end
-    end
-  end
-end

data/lib/ext/savage/lib/savage/directions/vertical_to.rb

@@ -1,19 +0,0 @@
-module Savage
-  module Directions
-    class VerticalTo < CoordinateTarget
-      def command_code
-        (absolute?) ? 'V' : 'v'
-      end
-
-      def transform(scale_x, skew_x, skew_y, scale_y, tx, ty)
-
-        unless skew_x.zero?
-          raise 'rotating or skewing (in X axis) an "vertical_to" direction is not supported yet.'
-        end
-        
-        self.target *= scale_y
-        self.target += ty if absolute?
-      end
-    end
-  end
-end

data/lib/ext/savage/lib/savage/parser.rb

@@ -1,108 +0,0 @@
-module Savage
-  class Parser
-    DIRECTIONS = {
-      :m => {:class => Directions::MoveTo,
-             :args => 2},
-      :l => {:class => Directions::LineTo,
-             :args => 2},
-      :h => {:class => Directions::HorizontalTo,
-             :args => 1},
-      :v => {:class => Directions::VerticalTo,
-             :args => 1},
-      :c => {:class => Directions::CubicCurveTo,
-             :args => 6},
-      :s => {:class => Directions::CubicCurveTo,
-             :args => 4},
-      :q => {:class => Directions::QuadraticCurveTo,
-             :args => 4},
-      :t => {:class => Directions::QuadraticCurveTo,
-             :args => 2},
-      :a => {:class => Directions::ArcTo,
-             :args => 7}
-    }
-
-    class << self
-      def parse(parsable)
-        raise TypeError if parsable.class != String
-        subpaths = extract_subpaths parsable
-        raise TypeError if (subpaths.empty?)
-        path = Path.new
-        path.subpaths = []
-        subpaths.each_with_index do |subpath, i|
-          path.subpaths << parse_subpath(subpath, i == 0)
-        end
-        path
-      end
-      
-      private
-        def extract_subpaths(parsable)
-          subpaths = []
-          if move_index = parsable.index(/[Mm]/)
-            subpaths << parsable[0...move_index] if move_index > 0
-            parsable.scan(/[Mm](?:\d|[eE.,+-]|[LlHhVvQqCcTtSsAaZz]|\W)+/m) do |match_group|
-              subpaths << $&
-            end
-          else
-            subpaths << parsable
-          end
-          subpaths
-        end
-        
-        def parse_subpath(parsable, force_absolute=false)
-          subpath = SubPath.new
-          subpath.directions = extract_directions parsable, force_absolute
-          subpath
-        end
-        
-        def extract_directions(parsable, force_absolute=false)
-          directions = []
-          i = 0
-          parsable.scan(/[MmLlHhVvQqCcTtSsAaZz](?:\d|[eE.,+-]|\W)*/m) do |match_group|
-            direction = build_direction $&, force_absolute && i == 0
-            if direction.kind_of?(Array)
-              directions.concat direction
-            else
-              directions << direction
-            end
-            i += 1
-          end
-          directions
-        end
-        
-        def build_direction(parsable, force_absolute=false)
-          directions = []
-          @coordinates = extract_coordinates parsable
-          recurse_code = parsable[0,1]
-          first_absolute = force_absolute
-          
-          # we need to handle this separately, since ClosePath doesn't take any coordinates
-          if @coordinates.empty? && recurse_code =~ /[Zz]/
-            directions << Directions::ClosePath.new(parsable[0,1] == parsable[0,1].upcase)
-          end
-          
-          until @coordinates.empty?
-            absolute = (first_absolute || parsable[0,1] == parsable[0,1].upcase)
-            directions << construct_direction(recurse_code.strip[0].downcase.intern, absolute)
-            recurse_code = 'L' if recurse_code.downcase =~ /m/
-            first_absolute = false
-          end
-          
-          directions
-        end
-
-        def construct_direction(recurse_code, absolute)
-          args = @coordinates.shift DIRECTIONS[recurse_code][:args]
-          raise TypeError if args.any?(&:nil?)
-          DIRECTIONS[recurse_code][:class].new(*args, absolute)
-        end
-        
-        def extract_coordinates(command_string)
-          coordinates = []
-          command_string.scan(/-?\d+(\.\d+)?([eE][+-]?\d+)?/) do |match_group|
-            coordinates << $&.to_f
-          end
-          coordinates
-        end
-    end
-  end
-end

data/lib/ext/savage/lib/savage/path.rb

@@ -1,50 +0,0 @@
-module Savage
-  class Path
-    require File.dirname(__FILE__) + "/direction_proxy"
-    require File.dirname(__FILE__) + "/sub_path"
-
-    include Utils
-    include DirectionProxy
-    include Transformable
-
-    attr_accessor :subpaths
-
-    define_proxies do |sym,const|
-      define_method(sym) do |*args|
-        @subpaths.last.send(sym,*args)
-      end
-    end
-
-    def initialize(*args)
-      @subpaths = [SubPath.new]
-      @subpaths.last.move_to(*args) if (2..3).include?(*args.length)
-      yield self if block_given?
-    end
-
-    def directions
-      directions = []
-      @subpaths.each { |subpath| directions.concat(subpath.directions) }
-      directions
-    end
-
-    def move_to(*args)
-      unless (@subpaths.last.directions.empty?)
-        (@subpaths << SubPath.new(*args)).last
-      else
-        @subpaths.last.move_to(*args)
-      end
-    end
-
-    def closed?
-      @subpaths.last.closed?
-    end
-
-    def to_command
-      @subpaths.collect { |subpath| subpath.to_command }.join
-    end
-
-    def transform(*args)
-      @subpaths.each {|subpath| subpath.transform *args }
-    end
-  end
-end

data/lib/ext/savage/lib/savage/sub_path.rb

@@ -1,54 +0,0 @@
-module Savage
-  class SubPath
-    include Utils
-    include DirectionProxy
-    include Transformable
-
-    define_proxies do |sym,const|
-      define_method(sym) do |*args|
-        raise TypeError if const == "QuadraticCurveTo" && @directions.last.class != Directions::QuadraticCurveTo && [2,3].include?(args.length)
-        raise TypeError if const == "CubicCurveTo" && @directions.last.class != Directions::CubicCurveTo && [4,5].include?(args.length)
-        (@directions << Savage::Directions.const_get(const).new(*args)).last
-      end
-    end
-
-    attr_accessor :directions
-
-    def move_to(*args)
-      return nil unless @directions.empty?
-      (@directions << Directions::MoveTo.new(*args)).last
-    end
-
-    def initialize(*args)
-      @directions = []
-      move_to(*args) if (2..3).include?(args.length)
-      yield self if block_given?
-    end
-
-    def to_command
-      @directions.to_enum(:each_with_index).collect { |dir, i|
-        command_string = dir.to_command
-        if i > 0
-          prev_command_code = @directions[i-1].command_code
-          if dir.command_code == prev_command_code || (prev_command_code.match(/^[Mm]$/) && dir.command_code == 'L')
-            command_string.gsub!(/^[A-Za-z]/,'')
-            command_string.insert(0,' ') unless command_string.match(/^-/)
-          end
-        end
-        command_string
-      }.join
-    end
-
-    def commands
-      @directions
-    end
-
-    def closed?
-      @directions.last.kind_of? Directions::ClosePath
-    end
-
-    def transform(*args)
-      directions.each { |dir| dir.transform *args }
-    end
-  end
-end

data/lib/ext/savage/lib/savage/transformable.rb

@@ -1,48 +0,0 @@
-require 'bigdecimal'
-require 'bigdecimal/util'
-
-module Savage
-
-  module Transformable
-
-    # Matrix:
-    def transform(scale_x, skew_x, skew_y, scale_y, tx, ty)
-    end
-
-    def translate(tx, ty=0)
-      transform( 1, 0, 0, 1, tx, ty )
-    end
-
-    def scale(sx, sy=sx)
-      transform( sx, 0, 0, sy, 0, 0 )
-    end
-
-    # TODO:
-    # make cx, cy be origin center
-    def rotate( angle, cx=0, cy=0 )
-      a = (angle.to_f/180).to_d * Math::PI
-      translate( cx, cy )
-      transform( Math.cos(a),  Math.sin(a), -Math.sin(a), Math.cos(a), 0, 0)
-      translate( -cx, -cy )
-    end
-
-    def skew_x( angle )
-      a = angle.to_f/180 * Math::PI
-      transform( 1, 0, Math.tan(a), 1, 0, 0 )
-    end
-
-    def skew_y( angle )
-      a = angle.to_f/180 * Math::PI
-      transform( 1, Math.tan(a), 0, 1, 0, 0 )
-    end
-
-    protected
-
-      def transform_dot( dot, scale_x, skew_x, skew_y, scale_y, tx, ty )
-        x, y  = dot.x, dot.y
-        dot.x = x*scale_x + y*skew_x  + tx
-        dot.y = x*skew_y  + y*scale_y + ty
-      end
-
-  end
-end