breadkit-render 0.1.0

data/lib/breadkit/render/cli.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require "optparse"
+
+module Breadkit
+  module Render
+    class CLI
+      def run(argv)
+        options = { scale: 2.0, theme: "light", orientation: "portrait", color_by: "wire", crop: "auto", backend: "auto", quality: 90 }
+        parser = OptionParser.new do |opts|
+          opts.banner = "Usage: bkrender [options] INPUT"
+          opts.on("-o", "--output PATH") { |value| options[:output] = value }
+          opts.on("-f", "--format FORMAT", %w[svg png jpeg jpg]) { |value| options[:format] = value == "jpg" ? "jpeg" : value }
+          opts.on("--scale N", Float) { |value| options[:scale] = value }
+          opts.on("--theme NAME", %w[light dark print]) { |value| options[:theme] = value }
+          opts.on("--orientation NAME", %w[portrait landscape]) { |value| options[:orientation] = value }
+          opts.on("--rail-pattern PATTERN", SvgRenderer::RAIL_PATTERNS) { |value| options[:rail_pattern] = value }
+          opts.on("--color-by MODE", %w[wire net]) { |value| options[:color_by] = value }
+          opts.on("--show-nets") { options[:show_nets] = true }
+          opts.on("--legend") { options[:legend] = true }
+          opts.on("--crop MODE", %w[auto none]) { |value| options[:crop] = value }
+          opts.on("--annotations FILE") { |value| options[:annotations] = value }
+          opts.on("--backend NAME", %w[auto rsvg vips magick]) { |value| options[:backend] = value }
+          opts.on("--background COLOR") { |value| options[:background] = value }
+          opts.on("--static") { options[:static] = true }
+          opts.on("--quality N", Integer) { |value| options[:quality] = value }
+          opts.on("--force") { options[:force] = true }
+          opts.on("-v", "--version") { puts "bkrender #{VERSION}"; return 0 }
+          opts.on("-h", "--help") { puts opts; return 0 }
+        end
+        parser.parse!(argv)
+        input = argv.shift
+        raise ArgumentError, "input file required\n#{parser}" unless input
+        raise ArgumentError, "unexpected arguments: #{argv.join(' ')}" unless argv.empty?
+        format = output_format(options)
+        raise ArgumentError, "--background is only supported for JPEG" if options[:background] && format != "jpeg"
+        raise ArgumentError, "cannot write binary image data to a terminal; use -o PATH" if format != "svg" && !options[:output] && $stdout.tty?
+        circuit = Breadkit.load(input)
+        errors = circuit.diagnostics.reject { |item| %w[warning info].include?(item.severity) }
+        if !errors.empty? && !options[:force]
+          errors.each do |item|
+            location = [item.location&.path, item.location&.line].compact.join(":")
+            warn [location, item.message].compact.reject(&:empty?).join(": ")
+          end
+          return 1
+        end
+        svg = SvgRenderer.new.render(circuit, crop: options[:crop], theme: options[:theme], orientation: options[:orientation],
+                                    show_nets: options[:show_nets], legend: options[:legend], color_by: options[:color_by],
+                                    annotations: read_annotations(options[:annotations], input), rail_pattern: options[:rail_pattern],
+                                    interactive_layers: format == "svg" && !options[:static])
+        output = if format == "svg"
+          svg
+        else
+          Rasterizer.new.rasterize(svg, format: format, scale: options[:scale],
+                                   background: options[:background] || "white", quality: options[:quality], backend: options[:backend])
+        end
+        options[:output] ? File.binwrite(options[:output], output) : $stdout.write(output)
+        0
+      rescue OptionParser::ParseError, ArgumentError, JSON::ParserError, Breadkit::Error, Error => e
+        warn "bkrender: #{e.message}"
+        2
+      rescue StandardError => e
+        warn "bkrender: #{e.message}"
+        2
+      end
+
+      private
+
+      def output_format(options)
+        extension = File.extname(options[:output].to_s).downcase
+        from_path = { ".svg" => "svg", ".png" => "png", ".jpg" => "jpeg", ".jpeg" => "jpeg" }[extension]
+        raise ArgumentError, "unsupported output extension: #{extension}" if options[:output] && !from_path
+        if options[:format] && from_path && options[:format] != from_path
+          raise ArgumentError, "--format conflicts with output extension"
+        end
+        options[:format] || from_path || "svg"
+      end
+
+      def read_annotations(path, input)
+        return [] unless path
+        data = JSON.parse(File.read(path, encoding: "UTF-8"))
+        raise ArgumentError, "unsupported lint JSON schema_version" unless data["schema_version"] == 1
+        files = Array(data["files"])
+        match = files.find { |file| File.expand_path(file["path"].to_s) == File.expand_path(input) }
+        match ||= files.first if files.length == 1
+        Array(match && match["offenses"])
+      end
+    end
+  end
+end

data/lib/breadkit/render/rasterizer.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+module Breadkit
+  module Render
+    class Rasterizer
+      def rasterize(svg, format:, scale: 2.0, background: "white", quality: 90, backend: "auto")
+        format = format.to_s
+        backend = backend.to_s
+        raise Error, "unsupported raster format: #{format}" unless %w[png jpeg].include?(format)
+        raise Error, "unsupported raster backend: #{backend}" unless %w[auto rsvg vips magick].include?(backend)
+
+        begin
+          scale = Float(scale)
+        rescue ArgumentError, TypeError
+          raise Error, "scale must be a positive finite number"
+        end
+        raise Error, "scale must be a positive finite number" unless scale.finite? && scale.positive?
+        raise Error, "quality must be an integer between 0 and 100" unless quality.is_a?(Integer) && quality.between?(0, 100)
+        background = color(background) if format == "jpeg"
+
+        candidates = case backend
+        when "rsvg" then ["rsvg"]
+        when "magick" then ["magick"]
+        when "vips" then ["vips"]
+        else format == "png" ? %w[rsvg vips magick] : %w[vips magick]
+        end
+        candidates.each do |name|
+          next unless supports?(name, format)
+          begin
+            return send(name, svg, format, scale, background, quality)
+          rescue Error
+            raise if backend != "auto"
+          end
+        end
+        raise Error, "no raster backend found for #{format}; install librsvg (brew install librsvg / apt install librsvg2-bin) or ImageMagick"
+      end
+
+      private
+
+      def supports?(name, format)
+        return !!executable("rsvg-convert") if name == "rsvg" && format == "png"
+        return !!magick_command if name == "magick"
+        return false unless name == "vips"
+        require "vips"
+        true
+      rescue LoadError
+        false
+      end
+
+      def rsvg(svg, _format, scale, _background, _quality)
+        stdout, stderr, status = Open3.capture3(executable("rsvg-convert"), "--format=png", "--zoom=#{scale}", stdin_data: svg, binmode: true)
+        raise Error, "rsvg-convert failed: #{stderr}" unless status.success?
+        stdout
+      end
+
+      def magick(svg, format, scale, background, quality)
+        command = magick_command
+        background_color = format == "png" ? "none" : "##{background.map { |channel| channel.to_s(16).rjust(2, "0") }.join}"
+        args = ["-density", (96 * scale).to_s, "-background", background_color]
+        font = font_file
+        args.concat(["-font", font]) if font
+        args << "svg:-"
+        args += ["-background", background_color, "-alpha", "remove"] if format == "jpeg"
+        args += ["-quality", quality.to_s] if format == "jpeg"
+        args << "#{format}:-"
+        stdout, stderr, status = Open3.capture3(command, *args, stdin_data: svg, binmode: true)
+        raise Error, "ImageMagick failed: #{stderr}" unless status.success?
+        stdout
+      end
+
+      def vips(svg, format, scale, background, quality)
+        image = Vips::Image.svgload_buffer(svg, scale: scale.to_f)
+        if format == "jpeg"
+          image = image.flatten(background: background) if image.has_alpha?
+          image.jpegsave_buffer(Q: quality.to_i)
+        else
+          image.pngsave_buffer
+        end
+      rescue StandardError => e
+        raise Error, "libvips failed: #{e.message}"
+      end
+
+      def color(value)
+        named = { "aqua" => [0, 255, 255], "black" => [0, 0, 0], "blue" => [0, 0, 255],
+                  "fuchsia" => [255, 0, 255], "gray" => [128, 128, 128], "green" => [0, 128, 0],
+                  "lime" => [0, 255, 0], "maroon" => [128, 0, 0], "navy" => [0, 0, 128],
+                  "olive" => [128, 128, 0], "purple" => [128, 0, 128], "red" => [255, 0, 0],
+                  "silver" => [192, 192, 192], "teal" => [0, 128, 128], "white" => [255, 255, 255],
+                  "yellow" => [255, 255, 0] }
+        name = value.to_s.downcase
+        return named[name] if named.key?(name)
+
+        hex = value.to_s.delete_prefix("#")
+        raise Error, "unsupported JPEG background color: #{value}; use a basic CSS color name, #RGB, or #RRGGBB" unless /\A(?:[0-9a-f]{3}|[0-9a-f]{6})\z/i.match?(hex)
+
+        hex = hex.chars.map { |char| char * 2 }.join if hex.length == 3
+        hex.scan(/../).map { |part| part.to_i(16) }
+      end
+
+      def executable(name)
+        extensions = RbConfig::CONFIG["host_os"].match?(/mswin|mingw/i) ? ENV.fetch("PATHEXT", ".EXE;.COM;.BAT;.CMD").split(";") : [""]
+        ENV.fetch("PATH", "").split(File::PATH_SEPARATOR).each do |dir|
+          extensions.each do |extension|
+            path = File.join(dir, "#{name}#{extension}")
+            return path if File.executable?(path)
+          end
+        end
+        nil
+      end
+
+      def magick_command
+        executable("magick") || (executable("convert") unless RbConfig::CONFIG["host_os"].match?(/mswin|mingw/i))
+      end
+
+      def font_file
+        candidates = if RbConfig::CONFIG["host_os"].match?(/darwin/i)
+          ["/System/Library/Fonts/Supplemental/Arial Unicode.ttf", "/System/Library/Fonts/Supplemental/Arial.ttf"]
+        elsif RbConfig::CONFIG["host_os"].match?(/mswin|mingw/i)
+          ["C:/Windows/Fonts/arial.ttf"]
+        else
+          ["/usr/share/fonts/truetype/noto/NotoSansCJK-Regular.ttc", "/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf"]
+        end
+        candidates.find { |path| File.file?(path) }
+      end
+    end
+  end
+end