vectory 0.1.0 → 0.3.0

data/lib/vectory/file_magic.rb

@@ -0,0 +1,53 @@
+module Vectory
+  class FileMagic
+    EPS_30_MAGIC = "\x25\x21\x50\x53\x2d\x41\x64\x6f\x62\x65\x2d\x33\x2e\x30" \
+                   "\x20\x45\x50\x53\x46\x2d\x33\x2e\x30"
+      .force_encoding("BINARY") # "%!PS-Adobe-3.0 EPSF-3.0"
+
+    EPS_31_MAGIC = "\x25\x21\x50\x53\x2d\x41\x64\x6f\x62\x65\x2d\x33\x2e\x31" \
+                   "\x20\x45\x50\x53\x46\x2d\x33\x2e\x30"
+      .force_encoding("BINARY") # "%!PS-Adobe-3.1 EPSF-3.0"
+
+    PS_MAGIC = "\x25\x21\x50\x53\x2d\x41\x64\x6f\x62\x65\x2d\x33\x2e\x30"
+      .force_encoding("BINARY") # "%!PS-Adobe-3.0"
+
+    EMF_MAGIC = "\x01\x00\x00\x00".force_encoding("BINARY")
+
+    def self.detect(path)
+      new(path).detect
+    end
+
+    def initialize(path)
+      @path = path
+    end
+
+    def detect
+      beginning = File.read(@path, 100, mode: "rb")
+
+      eps_slice = beginning.byteslice(0, EPS_30_MAGIC.size)
+      Vectory.ui.debug("File magic is '#{to_bytes(beginning)}' of '#{@path}'.")
+
+      return :eps if [EPS_30_MAGIC, EPS_31_MAGIC].include?(eps_slice)
+
+      ps_slice = beginning.byteslice(0, PS_MAGIC.size)
+      return :ps if ps_slice == PS_MAGIC
+
+      emf_slice = beginning.byteslice(0, EMF_MAGIC.size)
+      return :emf if emf_slice == EMF_MAGIC
+
+      return :svg if contain_svg_tag?
+    end
+
+    private
+
+    def to_bytes(str)
+      str.unpack("c*").map { |e| "\\x#{e.to_s(16).rjust(2, '0')}" }.join
+    end
+
+    def contain_svg_tag?
+      content = File.read(@path, 4096)
+
+      return :svg if content.include?("<svg")
+    end
+  end
+end

data/lib/vectory/image.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require "tmpdir"
+
+module Vectory
+  class Image
+    class << self
+      def from_path(path)
+        new(File.read(path, mode: "rb"))
+      end
+
+      def from_content(content)
+        new(content)
+      end
+    end
+
+    attr_reader :content
+
+    def initialize(content)
+      @content = content
+    end
+
+    private
+
+    attr_writer :content
+  end
+end

data/lib/vectory/inkscape_converter.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+require "singleton"
+require_relative "system_call"
+
+module Vectory
+  class InkscapeConverter
+    include Singleton
+
+    def self.convert(uri, output_extension, option)
+      instance.convert(uri, output_extension, option)
+    end
+
+    def convert(uri, output_extension, option)
+      exe = inkscape_path_or_raise_error(uri)
+      uri = external_path uri
+      exe = external_path exe
+      cmd = %(#{exe} #{option} #{uri})
+
+      call = SystemCall.new(cmd).call
+
+      output_path = find_output(uri, output_extension)
+      raise_conversion_error(call) unless output_path
+
+      # and return Vectory::Utils::datauri(file)
+
+      output_path
+    end
+
+    private
+
+    def inkscape_path_or_raise_error(path)
+      inkscape_path or raise(InkscapeNotFoundError,
+                             "Inkscape missing in PATH, unable to " \
+                             "convert image #{path}. Aborting.")
+    end
+
+    def inkscape_path
+      @inkscape_path ||= find_inkscape
+    end
+
+    def find_inkscape
+      cmds.each do |cmd|
+        extensions.each do |ext|
+          paths.each do |path|
+            exe = File.join(path, "#{cmd}#{ext}")
+
+            return exe if File.executable?(exe) && !File.directory?(exe)
+          end
+        end
+      end
+
+      nil
+    end
+
+    def cmds
+      ["inkscapecom", "inkscape"]
+    end
+
+    def extensions
+      ENV["PATHEXT"] ? ENV["PATHEXT"].split(";") : [""]
+    end
+
+    def paths
+      ENV["PATH"].split(File::PATH_SEPARATOR)
+    end
+
+    def find_output(source_path, output_extension)
+      basenames = [File.basename(source_path, ".*"),
+                   File.basename(source_path)]
+
+      paths = basenames.map do |basename|
+        "#{File.join(File.dirname(source_path), basename)}.#{output_extension}"
+      end
+
+      paths.find { |p| File.exist?(p) }
+    end
+
+    def raise_conversion_error(call)
+      raise Vectory::ConversionError,
+            "Could not convert with Inkscape. " \
+            "Inkscape cmd: '#{call.cmd}',\n" \
+            "status: '#{call.status}',\n" \
+            "stdout: '#{call.stdout.strip}',\n" \
+            "stderr: '#{call.stderr.strip}'."
+    end
+
+    def external_path(path)
+      win = !!((RUBY_PLATFORM =~ /(win|w)(32|64)$/) ||
+               (RUBY_PLATFORM =~ /mswin|mingw/))
+      if win
+        path.gsub!(%{/}, "\\")
+        path[/\s/] ? "\"#{path}\"" : path
+      else
+        path
+      end
+    end
+  end
+end

data/lib/vectory/ps.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Vectory
+  class Ps < Vector
+    def self.default_extension
+      "ps"
+    end
+
+    def self.mimetype
+      "application/postscript"
+    end
+
+    def to_eps
+      convert_with_inkscape("--export-type=eps", Eps)
+    end
+
+    def to_emf
+      convert_with_inkscape("--export-type=emf", Emf)
+    end
+
+    def to_svg
+      convert_with_inkscape("--export-type=svg", Svg)
+    end
+  end
+end

data/lib/vectory/svg.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+require "nokogiri"
+
+module Vectory
+  class Svg < Vector
+    SVG_NS = "http://www.w3.org/2000/svg"
+
+    def self.default_extension
+      "svg"
+    end
+
+    def self.mimetype
+      "image/svg+xml"
+    end
+
+    def content
+      @document&.to_xml || @content
+    end
+
+    def to_emf
+      convert_with_inkscape("--export-type=emf", Emf)
+    end
+
+    def to_eps
+      convert_with_inkscape("--export-type=eps", Eps)
+    end
+
+    def to_ps
+      convert_with_inkscape("--export-type=ps", Ps)
+    end
+
+    def namespace(suffix, links, xpath_to_remove)
+      remap_links(links)
+      suffix_ids(suffix)
+      remove_xpath(xpath_to_remove)
+    end
+
+    def remap_links(map)
+      document.xpath(".//m:a", "m" => SVG_NS).each do |a|
+        href_attrs = ["xlink:href", "href"]
+        href_attrs.each do |p|
+          a[p] and x = map[File.expand_path(a[p])] and a[p] = x
+        end
+      end
+
+      self
+    end
+
+    def suffix_ids(suffix)
+      ids = collect_ids
+      return if ids.empty?
+
+      update_ids_attrs(ids, suffix)
+      update_ids_css(ids, suffix)
+
+      self
+    end
+
+    def remove_xpath(xpath)
+      document.xpath(xpath).remove
+
+      self
+    end
+
+    private
+
+    def content=(content)
+      if @document
+        @document = Nokogiri::XML(content)
+      else
+        @content = content
+      end
+    end
+
+    def document
+      @document ||= begin
+        doc = Nokogiri::XML(@content)
+        @content = nil
+        doc
+      end
+    end
+
+    def collect_ids
+      document.xpath("./@id | .//@id").map(&:value)
+    end
+
+    def update_ids_attrs(ids, suffix)
+      document.xpath(". | .//*[@*]").each do |a|
+        a.attribute_nodes.each do |x|
+          ids.include?(x.value) and x.value += sprintf("_%09d", suffix)
+        end
+      end
+    end
+
+    def update_ids_css(ids, suffix)
+      document.xpath("//m:style", "m" => SVG_NS).each do |s|
+        c = s.children.to_xml
+        ids.each do |i|
+          c = c.gsub(%r[##{i}\b],
+                     sprintf("#%<id>s_%<suffix>09d", id: i, suffix: suffix))
+            .gsub(%r(\[id\s*=\s*['"]?#{i}['"]?\]),
+                  sprintf("[id='%<id>s_%<suffix>09d']", id: i, suffix: suffix))
+        end
+
+        s.children = c
+      end
+    end
+  end
+end

data/lib/vectory/svg_mapping.rb

@@ -0,0 +1,118 @@
+require_relative "svg"
+
+module Vectory
+  class SvgMapping
+    class Namespace
+      def initialize(xmldoc)
+        @namespace = xmldoc.root.namespace
+      end
+
+      def ns(path)
+        return path if @namespace.nil?
+
+        path.gsub(%r{/([a-zA-z])}, "/xmlns:\\1")
+          .gsub(%r{::([a-zA-z])}, "::xmlns:\\1")
+          .gsub(%r{\[([a-zA-z][a-z0-9A-Z@/]* ?=)}, "[xmlns:\\1")
+          .gsub(%r{\[([a-zA-z][a-z0-9A-Z@/]*\])}, "[xmlns:\\1")
+      end
+    end
+
+    SVG_NS = "http://www.w3.org/2000/svg".freeze
+    PROCESSING_XPATH =
+      "processing-instruction()|.//processing-instruction()".freeze
+
+    def self.from_path(path)
+      new(File.read(path))
+    end
+
+    def initialize(xml, local_directory = "")
+      @xml = xml
+      @local_directory = local_directory
+    end
+
+    def call
+      xmldoc = Nokogiri::XML(@xml)
+      @namespace = Namespace.new(xmldoc)
+
+      xmldoc.xpath(@namespace.ns("//svgmap")).each_with_index do |svgmap, index|
+        process_svgmap(svgmap, index)
+      end
+
+      xmldoc.to_xml
+    end
+
+    private
+
+    def process_svgmap(svgmap, suffix)
+      image = extract_image_tag(svgmap)
+      return unless image
+
+      content = generate_content(image, svgmap, suffix)
+      return unless content
+
+      image.replace(content)
+
+      simplify_svgmap(svgmap)
+    end
+
+    def extract_image_tag(svgmap)
+      image = svgmap.at(@namespace.ns(".//image"))
+      return image if image && image["src"] && !image["src"].empty?
+
+      svgmap.at(".//m:svg", "m" => SVG_NS)
+    end
+
+    def generate_content(image, svgmap, suffix)
+      vector = build_vector(image)
+      return unless vector
+
+      links_map = from_targets_to_links_map(svgmap)
+      vector.namespace(suffix, links_map, PROCESSING_XPATH)
+
+      vector.content
+    end
+
+    def build_vector(image)
+      return Vectory::Svg.from_content(image.to_xml) if image.name == "svg"
+
+      return unless image.name == "image"
+
+      src = image["src"]
+      return Vectory::Datauri.new(src).to_vector if /^data:/.match?(src)
+
+      path = @local_directory.empty? ? src : File.join(@local_directory, src)
+      return unless File.exist?(path)
+
+      Vectory::Svg.from_path(path)
+    end
+
+    def from_targets_to_links_map(svgmap)
+      targets = svgmap.xpath(@namespace.ns("./target"))
+      targets.each_with_object({}) do |target_tag, m|
+        target = link_target(target_tag)
+        next unless target
+
+        href = File.expand_path(target_tag["href"])
+        m[href] = target
+
+        target_tag.remove
+      end
+    end
+
+    def link_target(target_tag)
+      xref = target_tag.at(@namespace.ns("./xref"))
+      return "##{xref['target']}" if xref
+
+      link = target_tag.at(@namespace.ns("./link"))
+      return unless link
+
+      link["target"]
+    end
+
+    def simplify_svgmap(svgmap)
+      return if svgmap.at(@namespace.ns("./target/eref"))
+
+      svgmap.replace(svgmap.at(@namespace.ns("./figure")))
+    end
+  end
+end

data/lib/vectory/system_call.rb

@@ -0,0 +1,58 @@
+require "open3"
+
+module Vectory
+  class SystemCall
+    TIMEOUT = 60
+
+    attr_reader :status, :stdout, :stderr, :cmd
+
+    def initialize(cmd, timeout = TIMEOUT)
+      @cmd = cmd
+      @timeout = timeout
+    end
+
+    def call
+      log_cmd(@cmd)
+
+      execute(@cmd)
+
+      log_result
+
+      raise_error unless @status.success?
+
+      self
+    end
+
+    private
+
+    def log_cmd(cmd)
+      Vectory.ui.debug("Cmd: '#{cmd}'")
+    end
+
+    def execute(cmd)
+      result = Utils.capture3_with_timeout(cmd,
+                                           timeout: @timeout,
+                                           kill_after: @timeout)
+      Vectory.ui.error(result.inspect)
+      @stdout = result[:stdout]
+      @stderr = result[:stderr]
+      @status = result[:status]
+    rescue Errno::ENOENT => e
+      raise SystemCallError, e.inspect
+    end
+
+    def log_result
+      Vectory.ui.debug("Status: #{@status.inspect}")
+      Vectory.ui.debug("Stdout: '#{@stdout.strip}'")
+      Vectory.ui.debug("Stderr: '#{@stderr.strip}'")
+    end
+
+    def raise_error
+      raise SystemCallError,
+            "Failed to run #{@cmd},\n  " \
+            "status: #{@status.exitstatus},\n  " \
+            "stdout: '#{@stdout.strip}',\n  " \
+            "stderr: '#{@stderr.strip}'"
+    end
+  end
+end

data/lib/vectory/utils.rb

@@ -0,0 +1,165 @@
+# frozen_string_literal: true
+
+require "marcel"
+require "timeout"
+
+module Vectory
+  class Utils
+    # Extracted from https://github.com/metanorma/metanorma-utils/blob/v1.5.2/lib/utils/image.rb
+    class << self
+      # sources/plantuml/plantuml20200524-90467-1iqek5i.png
+      # already includes localdir
+      # Check whether just the local path or the other specified relative path
+      # works.
+      def datauri(uri, local_dir = ".")
+        return uri if datauri?(uri) || url?(uri)
+
+        options = absolute_path?(uri) ? [uri] : [uri, File.join(local_dir, uri)]
+        path = options.detect do |p|
+          File.exist?(p) ? p : nil
+        end
+
+        unless path
+          warn "Image specified at `#{uri}` does not exist."
+          return uri # Return original provided location
+        end
+
+        encode_datauri(path)
+      end
+
+      def encode_datauri(path)
+        return nil unless File.exist?(path)
+
+        type = Marcel::MimeType.for(Pathname.new(path)) ||
+          'text/plain; charset="utf-8"'
+
+        bin = File.binread(path)
+        data = Base64.strict_encode64(bin)
+        "data:#{type};base64,#{data}"
+      rescue StandardError
+        warn "Data-URI encoding of `#{path}` failed."
+        nil
+      end
+
+      def datauri?(uri)
+        /^data:/.match?(uri)
+      end
+
+      def url?(url)
+        %r{^[A-Z]{2,}://}i.match?(url)
+      end
+
+      def absolute_path?(uri)
+        %r{^/}.match?(uri) || %r{^[A-Z]:/}.match?(uri)
+      end
+
+      # rubocop:disable all
+      #
+      # Originally from https://gist.github.com/pasela/9392115
+      #
+      # Capture the standard output and the standard error of a command.
+      # Almost same as Open3.capture3 method except for timeout handling and return value.
+      # See Open3.capture3.
+      #
+      #   result = capture3_with_timeout([env,] cmd... [, opts])
+      #
+      # The arguments env, cmd and opts are passed to Process.spawn except
+      # opts[:stdin_data], opts[:binmode], opts[:timeout], opts[:signal]
+      # and opts[:kill_after].  See Process.spawn.
+      #
+      # If opts[:stdin_data] is specified, it is sent to the command's standard input.
+      #
+      # If opts[:binmode] is true, internal pipes are set to binary mode.
+      #
+      # If opts[:timeout] is specified, SIGTERM is sent to the command after specified seconds.
+      #
+      # If opts[:signal] is specified, it is used instead of SIGTERM on timeout.
+      #
+      # If opts[:kill_after] is specified, also send a SIGKILL after specified seconds.
+      # it is only sent if the command is still running after the initial signal was sent.
+      #
+      # The return value is a Hash as shown below.
+      #
+      #   {
+      #     :pid     => PID of the command,
+      #     :status  => Process::Status of the command,
+      #     :stdout  => the standard output of the command,
+      #     :stderr  => the standard error of the command,
+      #     :timeout => whether the command was timed out,
+      #   }
+      def capture3_with_timeout(*cmd)
+        spawn_opts = Hash === cmd.last ? cmd.pop.dup : {}
+        opts = {
+          :stdin_data => spawn_opts.delete(:stdin_data) || "",
+          :binmode    => spawn_opts.delete(:binmode) || false,
+          :timeout    => spawn_opts.delete(:timeout),
+          :signal     => spawn_opts.delete(:signal) || :TERM,
+          :kill_after => spawn_opts.delete(:kill_after),
+        }
+
+        in_r,  in_w  = IO.pipe
+        out_r, out_w = IO.pipe
+        err_r, err_w = IO.pipe
+        in_w.sync = true
+
+        if opts[:binmode]
+          in_w.binmode
+          out_r.binmode
+          err_r.binmode
+        end
+
+        spawn_opts[:in]  = in_r
+        spawn_opts[:out] = out_w
+        spawn_opts[:err] = err_w
+
+        result = {
+          :pid     => nil,
+          :status  => nil,
+          :stdout  => nil,
+          :stderr  => nil,
+          :timeout => false,
+        }
+
+        out_reader = nil
+        err_reader = nil
+        wait_thr = nil
+
+        begin
+          Timeout.timeout(opts[:timeout]) do
+            result[:pid] = spawn(*cmd, spawn_opts)
+            wait_thr = Process.detach(result[:pid])
+            in_r.close
+            out_w.close
+            err_w.close
+
+            out_reader = Thread.new { out_r.read }
+            err_reader = Thread.new { err_r.read }
+
+            in_w.write opts[:stdin_data]
+            in_w.close
+
+            result[:status] = wait_thr.value
+          end
+        rescue Timeout::Error
+          result[:timeout] = true
+          pid = spawn_opts[:pgroup] ? -result[:pid] : result[:pid]
+          Process.kill(opts[:signal], pid)
+          if opts[:kill_after]
+            unless wait_thr.join(opts[:kill_after])
+              Process.kill(:KILL, pid)
+            end
+          end
+        ensure
+          result[:status] = wait_thr.value if wait_thr
+          result[:stdout] = out_reader.value if out_reader
+          result[:stderr] = err_reader.value if err_reader
+          out_r.close unless out_r.closed?
+          err_r.close unless err_r.closed?
+        end
+
+        result
+      end
+      # rubocop:enable all
+    end
+  end
+end