claricle 0.1.0 → 0.2.0

data/lib/claricle/postscript_fidelity/view_box.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require_relative "../detector"
+
+module Claricle
+  module PostscriptFidelity
+    # The root viewBox, which postsvg reads as [llx lly urx ury] instead of
+    # [x y width height]: only an origin of 0 0 is read correctly.
+    module ViewBox
+      module_function
+
+      # [x, y, width, height], or nil unless four numbers.
+      def parse(text)
+        parts = text.to_s.strip.split(/[\s,]+/).map { |part| Float(part, exception: false) }
+        parts if parts.length == 4 && parts.all?
+      end
+
+      def root(svg) = parse(Detector.read_root(svg)&.last&.fetch("viewBox", nil))
+
+      # The height of the viewport `orient` flips about, or nil when unknown.
+      def viewport_sum(svg)
+        attributes = Detector.read_root(svg)&.last or return
+        return height_at_origin(attributes["viewBox"]) if attributes["viewBox"]
+
+        height = PostscriptFidelity::LENGTH.match(attributes["height"].to_s)
+        Float(height[1]) if height
+      end
+
+      # [width, height, scale, dx, dy] mapping the viewBox into the width/height
+      # viewport (preserveAspectRatio's default, xMidYMid meet), or nil when
+      # the viewBox already is the viewport.
+      def fit(svg)
+        attributes = Detector.read_root(svg)&.last or return
+        box = parse(attributes["viewBox"])
+        return unless box && box[2].positive? && box[3].positive?
+
+        width, height = viewport(attributes, box)
+        place(width, height, box) unless [width, height] == box[2, 2]
+      end
+
+      def place(width, height, box)
+        scale = [width / box[2], height / box[3]].min
+        [width, height, scale, *[width - (scale * box[2]), height - (scale * box[3])].map { |slack| slack / 2 }]
+      end
+
+      # A missing width or height follows the viewBox's aspect ratio.
+      def viewport(attributes, box)
+        width, height = %w[width height].map { |name| length(attributes[name]) }
+        width ||= height ? height * box[2] / box[3] : box[2]
+        [width, height || (width * box[3] / box[2])]
+      end
+
+      def length(text)
+        match = PostscriptFidelity::LENGTH.match(text.to_s)
+        Float(match[1]) if match
+      end
+      private_class_method :place, :viewport, :length
+
+      # The origin the delegate was NOT shown: `rebase_origin?` zeroed it, so `orient` must shift by it.
+      def rebased_origin(original, fixed)
+        before = root(original)
+        after = root(fixed)
+        after && after[0, 2] == [0.0, 0.0] && before ? before[0, 2] : [0.0, 0.0]
+      end
+
+      # Rewrites a non-zero origin to 0 0; true when it changed.
+      def rebase_origin?(element)
+        box = parse(element.attributes["viewBox"])
+        return false if box.nil? || box[0, 2] == [0.0, 0.0]
+
+        element.attributes["viewBox"] = "0 0 #{box[2]} #{box[3]}"
+        true
+      end
+
+      def height_at_origin(text)
+        x, y, _, height = parse(text)
+        height if x&.zero? && y&.zero?
+      end
+      private_class_method :height_at_origin
+    end
+  end
+end

data/lib/claricle/postscript_fidelity.rb

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+require "rexml/document"
+require_relative "detector"
+require_relative "postscript_fidelity/view_box"
+require_relative "postscript_fidelity/verdict"
+
+module Claricle
+  # Closes seven silent losses in postsvg-0.3.0's SVG -> PS/EPS writer, so the
+  # `:lossless` verdict for the shapes Lossiness proves kept is true.
+  # `repair` rewrites the SVG before the writer sees it; `orient` fixes the
+  # PostScript it returns. Both pass their input through untouched when they
+  # cannot read it, leaving the writer's own error to surface.
+  #
+  #   color.rb:60             /\argb\(/ is BEL, not \A: rgb() never parses, paint is dropped
+  #   attribute_parser.rb:25  number() takes bare "-?\d+(\.\d+)?" only: "10px", ".5", "+5" read as 0
+  #   line_handler.rb:12      a <line> is always stroked; SVG's default stroke is none
+  #   (no code)               user space is y-down; PostScript is y-up and nothing flips it.
+  #                         `translate` + `scale`, not `concat`: Postsvg.to_svg ignores concat.
+  #   svg/parser.rb:27-33     viewBox is read as [llx lly urx ury], so a non-zero origin is
+  #                         misplaced: `repair` rewrites it to origin 0 0, `orient` shifts by it.
+  #   (no code)               width/height are ignored when a viewBox is present: `orient` fits the
+  #                         viewBox into them (xMidYMid meet) and sizes the page to them.
+  #   (no code)               the flip mirrors `show` text: each is counter-flipped about its origin.
+  #                         (`<image>` is emitted as a bare `image` operator with no data: nothing to flip.)
+  module PostscriptFidelity
+    SVG_NAMESPACE = "http://www.w3.org/2000/svg"
+    LENGTH_ATTRIBUTES = %w[width height x y x1 y1 x2 y2].freeze
+    PAINT_ATTRIBUTES = %w[fill stroke].freeze
+    LENGTH = /\A[ \t\r\n]*([+-]?(?:\d+\.\d+|\.\d+|\d+))(?:px)?[ \t\r\n]*\z/i
+    RGB = /\A[ \t\r\n]*rgb\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*\)[ \t\r\n]*\z/
+    STROKE_INHERITING = %w[stroke style class].freeze
+    BBOX = /^%%BoundingBox: (\S+) (\S+) (\S+) (\S+)$/
+    HINT = /px|rgb\(|<line|[+.]\d|viewBox/i
+    SHOW = /^(\S+) (\S+) moveto\n(\((?:\\.|[^\\)])*\) show)$/
+
+    POSTSCRIPT_TARGETS = %i[eps ps].freeze
+
+    module_function
+
+    # Yields the SVG to hand the delegate and returns what it produced,
+    # corrected. Other targets pass straight through.
+    def convert(svg, target)
+      return yield(svg) unless POSTSCRIPT_TARGETS.include?(target)
+
+      fixed = repair(svg)
+      orient(yield(fixed), fixed, ViewBox.rebased_origin(svg, fixed))
+    end
+
+    def repair(svg)
+      return svg unless svg.match?(HINT)
+
+      doc = REXML::Document.new(svg)
+      return svg unless doc.root && doc.encoding == "UTF-8"
+
+      changed = svg_elements(doc.root).map { |element| repaired?(element, doc) }
+      changed << ViewBox.rebase_origin?(doc.root)
+      changed.any? ? doc.to_s : svg
+    rescue REXML::ParseException, RuntimeError, EncodingError, ArgumentError
+      svg
+    end
+
+    def orient(postscript, svg, origin = [0.0, 0.0])
+      match = BBOX.match(postscript)
+      return postscript unless match && postscript.include?("%%EndComments\n")
+
+      box = match.captures.map { |text| Float(text, exception: false) }
+      return postscript unless box.all?
+
+      fit = ViewBox.fit(svg)
+      return upright(scaled(postscript, fit, origin)) if fit
+
+      upright(reflect(postscript, box, ViewBox.viewport_sum(svg) || (box[1] + box[3]), origin))
+    end
+
+    # width/height differ from the viewBox: postsvg sized the page to the viewBox and applied no scale.
+    def scaled(postscript, fit, origin)
+      width, height, scale, dx, dy = fit
+      shift = origin_shift(origin)
+      steps = "#{number(dx)} #{number(dy)} translate\n#{number(scale)} #{number(scale)} scale\n"
+      postscript.sub(BBOX) { "%%BoundingBox: 0 0 #{number(width)} #{number(height)}" }
+                .sub("%%EndComments\n") { "%%EndComments\n0 #{number(height)} translate\n1 -1 scale\n#{steps}#{shift}" }
+    end
+
+    def origin_shift(origin)
+      origin.all?(&:zero?) ? "" : "#{origin.map { |value| number(-value) }.join(" ")} translate\n"
+    end
+
+    def reflect(postscript, box, sum, origin)
+      llx, lly, urx, ury = box
+      bbox = [llx, sum - ury, urx, sum - lly].map { |value| number(value) }.join(" ")
+      shift = origin_shift(origin)
+      postscript.sub(BBOX) { "%%BoundingBox: #{bbox}" }
+                .sub("%%EndComments\n") { "%%EndComments\n0 #{number(sum)} translate\n1 -1 scale\n#{shift}" }
+    end
+
+    # The page flip mirrors glyphs; flip each `show` back about its own origin.
+    def upright(postscript)
+      postscript.gsub(SHOW) do
+        x, y, text = Regexp.last_match.captures
+        "gsave\n#{x} #{y} translate\n1 -1 scale\n0 0 moveto\n#{text}\ngrestore"
+      end
+    end
+
+    def svg_elements(root)
+      found = [root]
+      root.each_recursive { |el| found << el }
+      found.select { |el| el.namespace == SVG_NAMESPACE }
+    end
+
+    def repaired?(element, doc)
+      return removed_unstroked_line?(element, doc) if element.name == "line"
+
+      edits = element.attributes.map { |name, value| [name, rewrite(name, value)] }
+      edits.reject! { |name, value| value.nil? || element.attributes[name] == value }
+      edits.each { |name, value| element.attributes[name] = value }
+      edits.any?
+    end
+
+    def rewrite(name, value)
+      if LENGTH_ATTRIBUTES.include?(name) && (match = LENGTH.match(value))
+        number(Float(match[1]))
+      elsif PAINT_ATTRIBUTES.include?(name) && (match = RGB.match(value))
+        match.captures.map { |channel| format("%02x", [channel.to_i, 255].min) }.join.prepend("#")
+      end
+    end
+
+    # Only a line whose stroke is certainly none: its own `stroke` says so, or
+    # nothing from it, its ancestors or a stylesheet can supply one.
+    def removed_unstroked_line?(line, doc)
+      return false if line.attributes["style"] || line.attributes["class"]
+      return false unless line.attributes["stroke"] == "none" || stroke_free?(line, doc)
+
+      line.remove
+      true
+    end
+
+    def stroke_free?(line, doc)
+      return false if line.attributes["stroke"] || svg_elements(doc.root).any? { |el| el.name == "style" }
+
+      ancestors = []
+      node = line.parent
+      while node.is_a?(REXML::Element)
+        ancestors << node
+        node = node.parent
+      end
+      ancestors.none? { |el| STROKE_INHERITING.any? { |name| el.attributes[name] } }
+    end
+
+    def number(value)
+      text = format("%.12f", value).sub(/\.?0+\z/, "")
+      text == "-0" ? "0" : text
+    end
+
+    private_class_method :svg_elements, :repaired?, :rewrite, :removed_unstroked_line?, :stroke_free?, :number,
+                         :reflect, :upright, :scaled, :origin_shift
+  end
+
+  private_constant :PostscriptFidelity
+end

data/lib/claricle/registry.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+# Requires live here, next to the derivation that needs them, so there is
+# no load order for the entry point to get wrong. Every file in handlers/
+# is loaded, so a new format is one new file there and nothing else.
+require_relative "errors"
+require_relative "handlers/base"
+Dir[File.join(__dir__, "handlers", "*.rb")].each { |file| require file }
+
+module Claricle
+  module Registry
+    # Every handler class loaded above, in name order so nothing depends on
+    # the order the filesystem listed the files in.
+    HANDLER_CLASSES = Handlers.const_get(:Base).subclasses.sort_by(&:to_s).freeze
+
+    class << self
+      def handler_for(format)
+        HANDLERS.fetch(format) { raise UnsupportedFormat, format }
+      end
+
+      def formats
+        HANDLERS.keys.sort
+      end
+
+      # What one format's handler can actually do -- the `formats`
+      # command builds its row from this. Derived from the handler, so a
+      # row cannot advertise an operation it has not implemented.
+      def capabilities_for(format)
+        handler_for(format).capabilities
+      end
+
+      # The profile names one format accepts. Sorted, so the order a
+      # handler happens to declare them in never leaks into a message.
+      def profiles_for(format)
+        handler_for(format).supported_profiles.sort
+      end
+
+      # Every profile name ANY registered format accepts. This is what
+      # lets a batch reject a typo before it opens a single file --
+      # whether the name fits the format in hand is a per-file question
+      # and is asked again there.
+      def profiles
+        HANDLERS.values.flat_map(&:supported_profiles).uniq.sort
+      end
+
+      # The user-facing level names for a profile, or nil when that
+      # profile has no separate level selector.
+      def levels_for_profile(profile)
+        owner = HANDLERS.values.uniq.find { |handler| handler.supported_profiles.include?(profile) }
+        owner&.levels_for(profile)
+      end
+
+      # What one format's handler can convert to -- the `formats` command's
+      # `convert_to` column builds from this, the same way `capabilities_for`
+      # builds the operations column.
+      #
+      # `- [format]` matters only for a handler owning more than one format
+      # (Handlers::Postscript, :eps and :ps): its `convert_to` declares the
+      # union both can reach, since a class-level declaration cannot vary
+      # per image, so the declared list itself still names the format asked
+      # about as one of its own targets. Every single-format handler's own
+      # format was never in its declared list to begin with, so this is a
+      # no-op for them.
+      #
+      # Targets another handler declared it can produce from this format
+      # (`convert_from`) are included, so adding a format makes it a target
+      # of every source it accepts without editing any of them.
+      def convert_targets_for(format)
+        (handler_for(format).convert_targets + inbound_targets(format)).uniq - [format]
+      end
+
+      # The handler to convert a `from` image to `to`, when `to` is a format
+      # whose own handler declared it accepts `from` and `from`'s handler
+      # does not already list `to`. nil means "ask the source's handler".
+      def inbound_handler(from:, to:)
+        return if HANDLERS[from]&.convert_targets&.include?(to)
+
+        owner = HANDLERS[to]
+        owner if owner&.convert_sources&.include?(from)
+      end
+
+      # The format a handler's declared detector recognises in these leading
+      # bytes, or nil. Reached by the detector only after its built-in
+      # probes have all declined.
+      def detect(header)
+        HANDLER_CLASSES.each do |handler|
+          format = handler.detect_format(header)
+          return format if format
+        end
+        nil
+      end
+
+      private
+
+      def inbound_targets(format)
+        HANDLERS.values.uniq.select { |handler| handler.convert_sources.include?(format) }
+                .flat_map(&:supported_formats)
+      end
+
+      # Two classes claiming a format is a configuration defect, not a
+      # last-one-wins: the design has one immutable owner per format.
+      def build(handler_classes)
+        handler_classes.each_with_object({}) do |handler, map|
+          handler.supported_formats.each do |format|
+            if map.key?(format)
+              raise Error, "duplicate handler for #{format.inspect}: " \
+                           "#{map[format]} and #{handler}"
+            end
+
+            map[format] = handler
+          end
+        end.freeze
+      end
+    end
+
+    HANDLERS = send(:build, HANDLER_CLASSES)
+
+    private_constant :HANDLER_CLASSES, :HANDLERS
+  end
+
+  # Here rather than in the entry point, for the same reason the requires
+  # above are: requiring this file on its own is a supported path, and it
+  # used to leave Registry public until claricle.rb happened to run.
+  private_constant :Registry
+end

data/lib/claricle/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Claricle
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end