pdfrb 0.1.0

data/lib/pdfrb/content/operators/color.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module Content
+    module Operator
+      # Color operators (s8.6). Lowercase sets fill color, uppercase
+      # sets stroke color.
+
+      class FillGray < Base
+        def self.name; "g"; end
+        def self.invoke(processor, n)
+          processor.update_graphics_state(fill_color: [:gray, n.to_f])
+        end
+        register
+      end
+
+      class StrokeGray < Base
+        def self.name; "G"; end
+        def self.invoke(processor, n)
+          processor.update_graphics_state(stroke_color: [:gray, n.to_f])
+        end
+        register
+      end
+
+      class FillRGB < Base
+        def self.name; "rg"; end
+        def self.invoke(processor, r, g, b)
+          processor.update_graphics_state(fill_color: [:rgb, r.to_f, g.to_f, b.to_f])
+        end
+        register
+      end
+
+      class StrokeRGB < Base
+        def self.name; "RG"; end
+        def self.invoke(processor, r, g, b)
+          processor.update_graphics_state(stroke_color: [:rgb, r.to_f, g.to_f, b.to_f])
+        end
+        register
+      end
+
+      class FillCMYK < Base
+        def self.name; "k"; end
+        def self.invoke(processor, c, m, y, k)
+          processor.update_graphics_state(fill_color: [:cmyk, c.to_f, m.to_f, y.to_f, k.to_f])
+        end
+        register
+      end
+
+      class StrokeCMYK < Base
+        def self.name; "K"; end
+        def self.invoke(processor, c, m, y, k)
+          processor.update_graphics_state(stroke_color: [:cmyk, c.to_f, m.to_f, y.to_f, k.to_f])
+        end
+        register
+      end
+
+      class SetFillColorSpace < Base
+        def self.name; "cs"; end
+        def self.invoke(processor, name)
+          processor.update_graphics_state(fill_color: [:color_space, name])
+        end
+        register
+      end
+
+      class SetStrokeColorSpace < Base
+        def self.name; "CS"; end
+        def self.invoke(processor, name)
+          processor.update_graphics_state(stroke_color: [:color_space, name])
+        end
+        register
+      end
+
+      class SetFillColor < Base
+        def self.name; "sc"; end
+        def self.invoke(processor, *components)
+          processor.update_graphics_state(fill_color: [:components, components])
+        end
+        register
+      end
+
+      class SetStrokeColor < Base
+        def self.name; "SC"; end
+        def self.invoke(processor, *components)
+          processor.update_graphics_state(stroke_color: [:components, components])
+        end
+        register
+      end
+
+      class SetFillColorN < Base
+        def self.name; "scn"; end
+        def self.invoke(processor, *components)
+          processor.update_graphics_state(fill_color: [:components_n, components])
+        end
+        register
+      end
+
+      class SetStrokeColorN < Base
+        def self.name; "SCN"; end
+        def self.invoke(processor, *components)
+          processor.update_graphics_state(stroke_color: [:components_n, components])
+        end
+        register
+      end
+    end
+  end
+end

data/lib/pdfrb/content/operators/general.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module Content
+    module Operator
+      # General graphics-state operators (s8.4.4): q Q cm BT ET.
+      # `q`/`Q` push/pop the graphics-state stack on the Processor.
+      # `cm` concatenates a matrix onto the CTM.
+      # `BT`/`ET` begin/end a text object (reset text + line matrices).
+
+      class SaveGraphicsState < NoArg
+        def self.name; "q"; end
+        def self.invoke(processor, *); processor.push_graphics_state; end
+        register
+      end
+
+      class RestoreGraphicsState < NoArg
+        def self.name; "Q"; end
+        def self.invoke(processor, *); processor.pop_graphics_state; end
+        register
+      end
+
+      class ConcatMatrix < Base
+        def self.name; "cm"; end
+        def self.invoke(processor, a, b, c, d, e, f)
+          m = Pdfrb::Model::Matrix.new(a, b, c, d, e, f)
+          processor.update_graphics_state(ctm: m * processor.graphics_state.ctm)
+        end
+        register
+      end
+
+      class BeginText < NoArg
+        def self.name; "BT"; end
+        def self.invoke(processor, *)
+          ts = processor.graphics_state.text_state.with(
+            text_matrix: Pdfrb::Model::Matrix.identity,
+            line_matrix: Pdfrb::Model::Matrix.identity
+          )
+          processor.update_graphics_state(text_state: ts)
+        end
+        register
+      end
+
+      class EndText < NoArg
+        def self.name; "ET"; end
+        register
+      end
+    end
+  end
+end

data/lib/pdfrb/content/operators/graphics_state_params.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module Content
+    module Operator
+      # Graphics-state parameter operators (s8.4.4 minus q/Q/cm which
+      # live in operators/general.rb). These update the named slot on
+      # the current GraphicsState.
+
+      class LineWidth < Base
+        def self.name; "w"; end
+        def self.invoke(processor, n)
+          processor.update_graphics_state(line_width: n.to_f)
+        end
+        register
+      end
+
+      class LineCap < Base
+        def self.name; "J"; end
+        def self.invoke(processor, n)
+          processor.update_graphics_state(line_cap: n.to_i)
+        end
+        register
+      end
+
+      class LineJoin < Base
+        def self.name; "j"; end
+        def self.invoke(processor, n)
+          processor.update_graphics_state(line_join: n.to_i)
+        end
+        register
+      end
+
+      class MiterLimit < Base
+        def self.name; "M"; end
+        def self.invoke(processor, n)
+          processor.update_graphics_state(miter_limit: n.to_f)
+        end
+        register
+      end
+
+      class DashPattern < Base
+        def self.name; "d"; end
+        def self.invoke(processor, array, phase)
+          processor.update_graphics_state(dash_pattern: [array.to_a, phase.to_i])
+        end
+        register
+      end
+
+      class RenderingIntent < Base
+        def self.name; "ri"; end
+        def self.invoke(processor, name)
+          processor.update_graphics_state(blend_mode: name)
+        end
+        register
+      end
+
+      class Flatness < Base
+        def self.name; "i"; end
+        def self.invoke(processor, n)
+          processor.update_graphics_state(flatness: n.to_i)
+        end
+        register
+      end
+
+      # `gs` applies a named ExtGState dictionary. Lookup happens via
+      # the document; fields in the named dict replace matching state
+      # slots. We delegate to a +apply_extgstate+ hook on the Processor.
+      class ApplyExtGState < Base
+        def self.name; "gs"; end
+        def self.invoke(processor, name)
+          processor.apply_extgstate(name)
+        end
+        register
+      end
+    end
+  end
+end

data/lib/pdfrb/content/operators/marked_content.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module Content
+    module Operator
+      # Marked-content operators (s14.6) — used for tagged PDF /
+      # structure trees. The Processor maintains a marked-content
+      # stack; EMC pops.
+
+      class BeginMarkedContent < Base
+        def self.name; "BMC"; end
+        def self.invoke(processor, tag)
+          processor.begin_marked_content(tag)
+        end
+        register
+      end
+
+      class BeginMarkedContentWithProperties < Base
+        def self.name; "BDC"; end
+        def self.invoke(processor, tag, properties)
+          processor.begin_marked_content(tag, properties)
+        end
+        register
+      end
+
+      class EndMarkedContent < NoArg
+        def self.name; "EMC"; end
+        def self.invoke(processor, *)
+          processor.end_marked_content
+        end
+        register
+      end
+
+      class MarkedContentPoint < Base
+        def self.name; "MP"; end
+        def self.invoke(processor, tag)
+          processor.marked_content_point(tag)
+        end
+        register
+      end
+
+      class MarkedContentPointWithProperties < Base
+        def self.name; "DP"; end
+        def self.invoke(processor, tag, properties)
+          processor.marked_content_point(tag, properties)
+        end
+        register
+      end
+    end
+  end
+end

data/lib/pdfrb/content/operators/painting.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module Content
+    module Operator
+      # Path painting operators (s8.5.3). Each calls a +paint_path+
+      # hook on the Processor with the right (fill, stroke, close)
+      # flag tuple so renderers can dispatch one method.
+
+      class Stroke < NoArg
+        def self.name; "S"; end
+        def self.invoke(processor, *)
+          processor.paint_path(fill: false, stroke: true, close: false, rule: :nonzero)
+        end
+        register
+      end
+
+      class CloseAndStroke < NoArg
+        def self.name; "s"; end
+        def self.invoke(processor, *)
+          processor.paint_path(fill: false, stroke: true, close: true, rule: :nonzero)
+        end
+        register
+      end
+
+      class FillNonZero < NoArg
+        def self.name; "f"; end
+        def self.invoke(processor, *)
+          processor.paint_path(fill: true, stroke: false, close: false, rule: :nonzero)
+        end
+        register
+      end
+
+      # /F is a deprecated alias of /f — keep it in the registry for
+      # round-trip fidelity when reading old PDFs.
+      class FillDeprecatedAlias < FillNonZero
+        def self.name; "F"; end
+        register
+      end
+
+      class FillEvenOdd < NoArg
+        def self.name; "f*"; end
+        def self.invoke(processor, *)
+          processor.paint_path(fill: true, stroke: false, close: false, rule: :even_odd)
+        end
+        register
+      end
+
+      class FillStrokeNonZero < NoArg
+        def self.name; "B"; end
+        def self.invoke(processor, *)
+          processor.paint_path(fill: true, stroke: true, close: false, rule: :nonzero)
+        end
+        register
+      end
+
+      class FillStrokeEvenOdd < NoArg
+        def self.name; "B*"; end
+        def self.invoke(processor, *)
+          processor.paint_path(fill: true, stroke: true, close: false, rule: :even_odd)
+        end
+        register
+      end
+
+      class CloseFillStrokeNonZero < NoArg
+        def self.name; "b"; end
+        def self.invoke(processor, *)
+          processor.paint_path(fill: true, stroke: true, close: true, rule: :nonzero)
+        end
+        register
+      end
+
+      class CloseFillStrokeEvenOdd < NoArg
+        def self.name; "b*"; end
+        def self.invoke(processor, *)
+          processor.paint_path(fill: true, stroke: true, close: true, rule: :even_odd)
+        end
+        register
+      end
+    end
+  end
+end

data/lib/pdfrb/content/operators/path.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module Content
+    module Operator
+      # Path construction operators (s8.5).
+
+      class MoveTo < Base
+        def self.name; "m"; end
+        def self.invoke(processor, x, y)
+          processor.path_move_to(x.to_f, y.to_f)
+        end
+        register
+      end
+
+      class LineTo < Base
+        def self.name; "l"; end
+        def self.invoke(processor, x, y)
+          processor.path_line_to(x.to_f, y.to_f)
+        end
+        register
+      end
+
+      class CurveTo < Base
+        def self.name; "c"; end
+        def self.invoke(processor, x1, y1, x2, y2, x3, y3)
+          processor.path_curve_to([x1.to_f, y1.to_f], [x2.to_f, y2.to_f], [x3.to_f, y3.to_f])
+        end
+        register
+      end
+
+      class CurveToFirstReflected < Base
+        def self.name; "v"; end
+        def self.invoke(processor, x2, y2, x3, y3)
+          processor.path_curve_to(nil, [x2.to_f, y2.to_f], [x3.to_f, y3.to_f])
+        end
+        register
+      end
+
+      class CurveToLastEqual < Base
+        def self.name; "y"; end
+        def self.invoke(processor, x1, y1, x3, y3)
+          processor.path_curve_to([x1.to_f, y1.to_f], [x3.to_f, y3.to_f], [x3.to_f, y3.to_f])
+        end
+        register
+      end
+
+      class ClosePath < NoArg
+        def self.name; "h"; end
+        def self.invoke(processor, *); processor.path_close; end
+        register
+      end
+
+      class Rectangle < Base
+        def self.name; "re"; end
+        def self.invoke(processor, x, y, width, height)
+          processor.path_rectangle(x.to_f, y.to_f, width.to_f, height.to_f)
+        end
+        register
+      end
+
+      class EndPath < NoArg
+        def self.name; "n"; end
+        def self.invoke(processor, *); processor.path_end; end
+        register
+      end
+    end
+  end
+end

data/lib/pdfrb/content/operators/text_positioning.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module Content
+    module Operator
+      # Text-positioning operators (s9.4.2). Update text_matrix and
+      # line_matrix inside the current TextState.
+
+      class TextTranslate < Base
+        def self.name; "Td"; end
+        def self.invoke(processor, tx, ty)
+          processor.move_text(tx.to_f, ty.to_f, set_leading: false)
+        end
+        register
+      end
+
+      class TextTranslateSetLeading < Base
+        def self.name; "TD"; end
+        def self.invoke(processor, tx, ty)
+          processor.move_text(tx.to_f, ty.to_f, set_leading: true, neg_leading: true)
+        end
+        register
+      end
+
+      class SetTextMatrix < Base
+        def self.name; "Tm"; end
+        def self.invoke(processor, a, b, c, d, e, f)
+          m = Pdfrb::Model::Matrix.new(a, b, c, d, e, f)
+          processor.set_text_matrix(m)
+        end
+        register
+      end
+
+      class NextLine < NoArg
+        def self.name; "T*"; end
+        def self.invoke(processor, *)
+          leading = processor.graphics_state.text_state.leading
+          processor.move_text(0, -leading, set_leading: false)
+        end
+        register
+      end
+    end
+  end
+end

data/lib/pdfrb/content/operators/text_showing.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module Content
+    module Operator
+      # Text-showing operators (s9.4.3). Each invokes a +show_text+
+      # hook on the Processor.
+
+      class ShowText < Base
+        def self.name; "Tj"; end
+        def self.invoke(processor, str)
+          processor.show_text(str.to_s)
+        end
+        register
+      end
+
+      class ShowTextWithSpacing < Base
+        def self.name; "TJ"; end
+        def self.invoke(processor, array)
+          processor.show_text_array(array.to_a)
+        end
+        register
+      end
+
+      class MoveToNextLineShowText < Base
+        def self.name; "'"; end
+        def self.invoke(processor, str)
+          leading = processor.graphics_state.text_state.leading
+          processor.move_text(0, -leading, set_leading: false)
+          processor.show_text(str.to_s)
+        end
+        register
+      end
+
+      class SetSpacingMoveToShowText < Base
+        def self.name; "\""; end
+        def self.invoke(processor, word_spacing, char_spacing, str)
+          processor.update_text_state(word_spacing: word_spacing.to_f,
+                                      char_spacing: char_spacing.to_f)
+          leading = processor.graphics_state.text_state.leading
+          processor.move_text(0, -leading, set_leading: false)
+          processor.show_text(str.to_s)
+        end
+        register
+      end
+    end
+  end
+end

data/lib/pdfrb/content/operators/text_state.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module Content
+    module Operator
+      # Text-state operators (s9.3). Each updates a slot in the
+      # Processor's current TextState.
+
+      class CharSpacing < Base
+        def self.name; "Tc"; end
+        def self.invoke(processor, n)
+          processor.update_text_state(char_spacing: n.to_f)
+        end
+        register
+      end
+
+      class WordSpacing < Base
+        def self.name; "Tw"; end
+        def self.invoke(processor, n)
+          processor.update_text_state(word_spacing: n.to_f)
+        end
+        register
+      end
+
+      class HorizontalScaling < Base
+        def self.name; "Tz"; end
+        def self.invoke(processor, n)
+          processor.update_text_state(horizontal_scaling: n.to_f)
+        end
+        register
+      end
+
+      class Leading < Base
+        def self.name; "TL"; end
+        def self.invoke(processor, n)
+          processor.update_text_state(leading: n.to_f)
+        end
+        register
+      end
+
+      class Font < Base
+        def self.name; "Tf"; end
+        def self.invoke(processor, name, size)
+          processor.update_text_state(font_name: name, font_size: size.to_f)
+        end
+        register
+      end
+
+      class RenderingMode < Base
+        def self.name; "Tr"; end
+        def self.invoke(processor, mode)
+          processor.update_text_state(rendering_mode: mode.to_i)
+        end
+        register
+      end
+
+      class Rise < Base
+        def self.name; "Ts"; end
+        def self.invoke(processor, n)
+          processor.update_text_state(rise: n.to_f)
+        end
+        register
+      end
+    end
+  end
+end

data/lib/pdfrb/content/parser.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require "stringio"
+
+module Pdfrb
+  module Content
+    # Groups a token stream into (operator, operands) invocations.
+    # Reuses +Source::Tokenizer+ for operand lexing (content streams
+    # use the same PDF object syntax as COS values).
+    #
+    # Each invocation is yielded as `[operator_class, operands]`.
+    class Parser
+      attr_reader :tokenizer
+
+      def initialize(tokenizer)
+        @tokenizer = tokenizer
+      end
+
+      def self.parse(io_or_string)
+        io = io_or_string.is_a?(::String) ? StringIO.new(io_or_string.b) : io_or_string
+        new(Pdfrb::Source::Tokenizer.new(io))
+      end
+
+      # Yields (operator_class, operands) pairs. Returns an Enumerator
+      # if no block.
+      def each_invocation
+        return enum_for(:each_invocation) unless block_given?
+
+        operands = []
+        while (tok = tokenizer.next_token)
+          case tok.type
+          when :keyword
+            op = Pdfrb::Content::Operator[tok.value]
+            yield(op || Pdfrb::Content::Operator::Unknown, operands) if op
+            operands = []
+          when :name
+            operands << Pdfrb::Model::Cos::NameEncoding.decode(tok.value)
+          when :integer, :real, :true, :false, :null
+            operands << tok.value
+          when :string, :hex_string
+            operands << tok.value
+          when :array_open
+            operands << consume_array
+          when :dict_open
+            operands << consume_dict
+          end
+        end
+        self
+      end
+
+      private
+
+      def consume_array
+        arr = []
+        loop do
+          tok = tokenizer.next_token
+          raise Pdfrb::SyntaxError, "unterminated array in content stream" if tok.nil?
+
+          break if tok.type == :array_close
+
+          arr << token_value(tok)
+        end
+        arr
+      end
+
+      def consume_dict
+        hash = {}
+        loop do
+          tok = tokenizer.next_token
+          raise Pdfrb::SyntaxError, "unterminated dict in content stream" if tok.nil?
+
+          break if tok.type == :dict_close
+
+          raise Pdfrb::SyntaxError, "dict key must be a name" unless tok.type == :name
+
+          key = Pdfrb::Model::Cos::NameEncoding.decode(tok.value)
+          val_tok = tokenizer.next_token
+          hash[key] = token_value(val_tok)
+        end
+        hash
+      end
+
+      def token_value(tok)
+        case tok.type
+        when :name then Pdfrb::Model::Cos::NameEncoding.decode(tok.value)
+        when :integer, :real, :true, :false, :null then tok.value
+        when :string, :hex_string then tok.value
+        when :array_open then consume_array
+        when :dict_open then consume_dict
+        else nil
+        end
+      end
+    end
+
+    module Operator
+      # Placeholder for unknown operators (typically private
+      # extensions). The Processor skips these.
+      class Unknown < Base
+        def self.name; "??"; end
+      end
+    end
+  end
+end