origami 1.2.7 → 2.0.0

data/lib/origami/graphics/instruction.rb

@@ -1,104 +1,98 @@
 =begin
 
-= File
-	graphics/instruction.rb
-
-= Info
-	This file is part of Origami, PDF manipulation framework for Ruby
-	Copyright (C) 2010	Guillaume Delugré <guillaume AT security-labs DOT org>
-	All right reserved.
-	
-  Origami is free software: you can redistribute it and/or modify
-  it under the terms of the GNU Lesser General Public License as published by
-  the Free Software Foundation, either version 3 of the License, or
-  (at your option) any later version.
-
-  Origami is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU Lesser General Public License for more details.
-
-  You should have received a copy of the GNU Lesser General Public License
-  along with Origami.  If not, see <http://www.gnu.org/licenses/>.
+    This file is part of Origami, PDF manipulation framework for Ruby
+    Copyright (C) 2016	Guillaume Delugré.
+
+    Origami is free software: you can redistribute it and/or modify
+    it under the terms of the GNU Lesser General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    Origami is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public License
+    along with Origami.  If not, see <http://www.gnu.org/licenses/>.
 
 =end
 
 module Origami
 
-  class InvalidPDFInstructionError < Exception ; end
-  class PDF::Instruction
-    attr_reader :operator
-    attr_accessor :operands
+    class InvalidPDFInstructionError < Error; end
 
-    @@regexp = Regexp.new('([^ \\t\\r\\n\\0\\[\\]<>()%\\/]+)')
-    @insns = Hash.new(:operands => [], :render => lambda{})
+    class PDF::Instruction
+        using TypeConversion
 
-    def initialize(operator, *operands)
-      @operator = operator
-      @operands = operands.map!{|arg| arg.is_a?(Origami::Object) ? arg.value : arg}
+        attr_reader :operator
+        attr_accessor :operands
 
-      if self.class.has_op?(operator)
-        opdef = self.class.get_operands(operator)
+        @insns = Hash.new(operands: [], render: lambda{})
 
-        if not opdef.include?('*') and opdef.size != operands.size
-          raise InvalidPDFInstructionError, 
-            "Numbers of operands mismatch for #{operator}: #{operands.inspect}"
-        end
-      end
-    end
+        def initialize(operator, *operands)
+            @operator = operator
+            @operands = operands.map!{|arg| arg.is_a?(Origami::Object) ? arg.value : arg}
 
-    def render(canvas)
-      self.class.get_render_proc(@operator)[canvas, *@operands]
+            if self.class.has_op?(operator)
+                opdef = self.class.get_operands(operator)
 
-      self
-    end
+                if not opdef.include?('*') and opdef.size != operands.size
+                    raise InvalidPDFInstructionError,
+                            "Numbers of operands mismatch for #{operator}: #{operands.inspect}"
+                end
+            end
+        end
 
-    def to_s
-      "#{operands.map{|op| op.to_o.to_s}.join(' ')}#{' ' unless operands.empty?}#{operator}\n"
-    end
+        def render(canvas)
+            self.class.get_render_proc(@operator)[canvas, *@operands]
 
-    class << self
-      def insn(operator, *operands, &render_proc)
-        @insns[operator] = {}
-        @insns[operator][:operands] = operands
-        @insns[operator][:render] = render_proc || lambda{}
-      end
-
-      def has_op?(operator)
-        @insns.has_key? operator
-      end
-
-      def get_render_proc(operator)
-        @insns[operator][:render]
-      end
-
-      def get_operands(operator)
-        @insns[operator][:operands]
-      end
-
-      def parse(stream)
-        operands = []
-        while type = Object.typeof(stream, true)
-          operands.push type.parse(stream)
+            self
         end
-        
-        if not stream.eos?
-          if stream.scan(@@regexp).nil?
-            raise InvalidPDFInstructionError, 
-              "Operator: #{(stream.peek(10) + '...').inspect}"
-          end
-
-          operator = stream[1]
-          PDF::Instruction.new(operator, *operands)
-        else
-          if not operands.empty?
-            raise InvalidPDFInstructionError,
-              "No operator given for operands: #{operands.join}"
-          end
+
+        def to_s
+            "#{operands.map{|op| op.to_o.to_s}.join(' ')}#{' ' unless operands.empty?}#{operator}\n"
         end
-      end
-    end
 
-  end
-end
+        class << self
+            def insn(operator, *operands, &render_proc)
+                @insns[operator] = {}
+                @insns[operator][:operands] = operands
+                @insns[operator][:render] = render_proc || lambda{}
+            end
+
+            def has_op?(operator)
+                @insns.has_key? operator
+            end
+
+            def get_render_proc(operator)
+                @insns[operator][:render]
+            end
+
+            def get_operands(operator)
+                @insns[operator][:operands]
+            end
+
+            def parse(stream)
+                operands = []
+                while type = Object.typeof(stream, true)
+                    operands.push type.parse(stream)
+                end
+
+                if not stream.eos?
+                    if stream.scan(/(?<operator>[[:graph:]&&[^\[\]<>()%\/]]+)/).nil?
+                        raise InvalidPDFInstructionError, "Operator: #{(stream.peek(10) + '...').inspect}"
+                    end
+
+                    operator = stream['operator']
+                    PDF::Instruction.new(operator, *operands)
+                else
+                    unless operands.empty?
+                        raise InvalidPDFInstructionError, "No operator given for operands: #{operands.map(&:to_s).join(' ')}"
+                    end
+                end
+            end
+        end
 
+    end
+end

data/lib/origami/graphics/path.rb

@@ -1,188 +1,182 @@
 =begin
 
-= File
-	graphics/path.rb
-
-= Info
-	This file is part of Origami, PDF manipulation framework for Ruby
-	Copyright (C) 2010	Guillaume Delugré <guillaume AT security-labs DOT org>
-	All right reserved.
-	
-  Origami is free software: you can redistribute it and/or modify
-  it under the terms of the GNU Lesser General Public License as published by
-  the Free Software Foundation, either version 3 of the License, or
-  (at your option) any later version.
-
-  Origami is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU Lesser General Public License for more details.
-
-  You should have received a copy of the GNU Lesser General Public License
-  along with Origami.  If not, see <http://www.gnu.org/licenses/>.
+    This file is part of Origami, PDF manipulation framework for Ruby
+    Copyright (C) 2016	Guillaume Delugré.
+
+    Origami is free software: you can redistribute it and/or modify
+    it under the terms of the GNU Lesser General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    Origami is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public License
+    along with Origami.  If not, see <http://www.gnu.org/licenses/>.
 
 =end
 
 module Origami
 
-  module Graphics
+    module Graphics
 
-    module LineCapStyle
-      BUTT_CAP              = 0
-      ROUND_CAP             = 1
-      PROJECTING_SQUARE_CAP = 2
-    end
+        module LineCapStyle
+            BUTT_CAP              = 0
+            ROUND_CAP             = 1
+            PROJECTING_SQUARE_CAP = 2
+        end
 
-    module LineJoinStyle
-      MITER_JOIN = 0
-      ROUND_JOIN = 1
-      BEVEL_JOIN = 2
-    end
+        module LineJoinStyle
+            MITER_JOIN = 0
+            ROUND_JOIN = 1
+            BEVEL_JOIN = 2
+        end
 
-    class DashPattern
-      attr_accessor :array, :phase
-
-      def initialize(array, phase = 0)
-        @array = array
-        @phase = phase
-      end
-
-      def eql?(dash) #:nodoc
-        dash.array == @array and dash.phase == @phase
-      end
-      
-      def hash #:nodoc:
-        [ @array, @phase ].hash
-      end
-    end
+        class DashPattern
+            attr_accessor :array, :phase
 
-    class InvalidPathError < Exception; end
-    class Path
+            def initialize(array, phase = 0)
+                @array = array
+                @phase = phase
+            end
 
-      module Segment
-        attr_accessor :from, :to
+            def eql?(dash) #:nodoc
+                dash.array == @array and dash.phase == @phase
+            end
 
-        def initialize(from, to)
-          @from, @to = from, to
+            def hash #:nodoc:
+                [ @array, @phase ].hash
+            end
         end
-      end
 
-      class Line
-        include Segment 
-      end
-  
-      attr_accessor :current_point
-      attr_reader :segments
+        class InvalidPathError < Error #:nodoc:
+        end
 
-      def initialize
-        @segments = []
-        @current_point = nil
-        @closed = false
-      end
+        class Path
+            module Segment
+                attr_accessor :from, :to
 
-      def is_closed?
-        @closed
-      end
+                def initialize(from, to)
+                    @from, @to = from, to
+                end
+            end
 
-      def close!
-        from = @current_point
-        to = @segments.first.from
-        
-        @segments << Line.new(from, to)
-        @segments.freeze
-        @closed = true
-      end
+            class Line
+                include Segment
+            end
 
-      def add_segment(seg)
-        raise GraphicsStateError, "Cannot modify closed subpath" if is_closed?
+            attr_accessor :current_point
+            attr_reader :segments
 
-        @segments << seg
-        @current_point = seg.to
-      end
+            def initialize
+                @segments = []
+                @current_point = nil
+                @closed = false
+            end
 
-    end
+            def is_closed?
+                @closed
+            end
 
-  end
+            def close!
+                from = @current_point
+                to = @segments.first.from
 
-  class PDF::Instruction
-    insn  'm', Real, Real do |canvas, x,y|
-      canvas.gs.current_path << (subpath = Graphics::Path.new)
-      subpath.current_point = [x,y]
+                @segments << Line.new(from, to)
+                @segments.freeze
+                @closed = true
+            end
+
+            def add_segment(seg)
+                raise GraphicsStateError, "Cannot modify closed subpath" if is_closed?
+
+                @segments << seg
+                @current_point = seg.to
+            end
+        end
     end
 
-    insn  'l', Real, Real do |canvas, x,y|
-      if canvas.gs.current_path.empty? 
-        raise InvalidPathError, "No current point is defined"
-      end
+    class PDF::Instruction
+        insn  'm', Real, Real do |canvas, x,y|
+            canvas.gs.current_path << (subpath = Graphics::Path.new)
+            subpath.current_point = [x,y]
+        end
 
-      subpath = canvas.gs.current_path.last
+        insn  'l', Real, Real do |canvas, x,y|
+            if canvas.gs.current_path.empty?
+                raise InvalidPathError, "No current point is defined"
+            end
 
-      from = subpath.current_point
-      to = [x,y]
-      subpath.add_segment(Graphics::Path::Line.new(from, to))
-    end
+            subpath = canvas.gs.current_path.last
 
-    insn  'h' do |canvas|
-      unless canvas.gs.current_path.empty?
-        subpath = canvas.gs.current_path.last
-        subpath.close! unless subpath.is_closed?
-      end
-    end
+            from = subpath.current_point
+            to = [x,y]
+            subpath.add_segment(Graphics::Path::Line.new(from, to))
+        end
 
-    insn  're', Real, Real, Real, Real do |canvas, x,y,width,height|
-      tx = x + width
-      ty = y + height
-      canvas.gs.current_path << (subpath = Graphics::Path.new)
-      subpath.segments << Graphics::Path::Line.new([x,y], [tx,y])
-      subpath.segments << Graphics::Path::Line.new([tx,y], [tx, ty])
-      subpath.segments << Graphics::Path::Line.new([tx, ty], [x, ty])
-      subpath.close!
-    end
+        insn  'h' do |canvas|
+            unless canvas.gs.current_path.empty?
+                subpath = canvas.gs.current_path.last
+                subpath.close! unless subpath.is_closed?
+            end
+        end
 
-    insn  'S' do |canvas|
-      canvas.stroke_path
-    end
+        insn  're', Real, Real, Real, Real do |canvas, x,y,width,height|
+            tx = x + width
+            ty = y + height
+            canvas.gs.current_path << (subpath = Graphics::Path.new)
+            subpath.segments << Graphics::Path::Line.new([x,y], [tx,y])
+            subpath.segments << Graphics::Path::Line.new([tx,y], [tx, ty])
+            subpath.segments << Graphics::Path::Line.new([tx, ty], [x, ty])
+            subpath.close!
+        end
 
-    insn  's' do |canvas| 
-      canvas.gs.current_path.last.close! 
-      canvas.stroke_path
-    end
+        insn  'S' do |canvas|
+            canvas.stroke_path
+        end
 
-    insn  'f' do |canvas|
-      canvas.fill_path
-    end
+        insn  's' do |canvas|
+            canvas.gs.current_path.last.close!
+            canvas.stroke_path
+        end
 
-    insn  'F' do |canvas|
-      canvas.fill_path
-    end
+        insn  'f' do |canvas|
+            canvas.fill_path
+        end
 
-    insn  'f*' do |canvas|
-      canvas.fill_path
-    end
+        insn  'F' do |canvas|
+            canvas.fill_path
+        end
 
-    insn  'B' do |canvas|
-      canvas.fill_path
-      canvas.stroke_path
-    end
+        insn  'f*' do |canvas|
+            canvas.fill_path
+        end
 
-    insn  'B*' do |canvas|
-      canvas.fill_path
-      canvas.stroke_path
-    end
+        insn  'B' do |canvas|
+            canvas.fill_path
+            canvas.stroke_path
+        end
 
-    insn  'b' do |canvas| 
-      canvas.gs.current_path.last.close! 
-      canvas.fill_path
-      canvas.stroke_path
-    end
-    
-    insn  'b*' do |canvas| 
-      canvas.gs.current_path.last.close! 
-      canvas.fill_path
-      canvas.stroke_path
+        insn  'B*' do |canvas|
+            canvas.fill_path
+            canvas.stroke_path
+        end
+
+        insn  'b' do |canvas|
+            canvas.gs.current_path.last.close!
+            canvas.fill_path
+            canvas.stroke_path
+        end
+
+        insn  'b*' do |canvas|
+            canvas.gs.current_path.last.close!
+            canvas.fill_path
+            canvas.stroke_path
+        end
+
+        insn  'n'
     end
-    
-    insn  'n'
-  end
 
 end