gamba 2.0.0

data/lib/gamba/graphics.rb

@@ -0,0 +1,212 @@
+# frozen_string_literal: true
+
+module Prawn
+  module Graphics
+    include BlendMode
+    include Color
+    include Dash
+    include CapStyle
+    include JoinStyle
+    include Transparency
+    include Transformation
+    include Patterns
+
+    # Distance of a cubic Bézier control point approximating a quarter circle of radius 1.
+    KAPPA = 4.0 * ((Math.sqrt(2) - 1.0) / 3.0)
+
+    def move_to(*point)
+      x, y = map_to_absolute(point)
+      add_content("#{PDF::Core.real(x)} #{PDF::Core.real(y)} m")
+    end
+
+    def line_to(*point)
+      x, y = map_to_absolute(point)
+      add_content("#{PDF::Core.real(x)} #{PDF::Core.real(y)} l")
+    end
+
+    def curve_to(destination, options = {})
+      options[:bounds] || raise(Errors::InvalidGraphicsPath, "Bounding points for bezier curve must be specified as :bounds => [[x1,y1],[x2,y2]]")
+
+      add_content("#{PDF::Core.real_params((options[:bounds] << destination).flat_map { map_to_absolute(_1) })} c")
+    end
+
+    def rectangle(point, width, height)
+      x, y = map_to_absolute(point)
+      add_content("#{PDF::Core.real_params([x, y - height, width, height])} re")
+    end
+
+    def rounded_rectangle(point, width, height, radius)
+      x, y = point
+      rounded_polygon(radius, point, [x + width, y], [x + width, y - height], [x, y - height])
+    end
+
+    def line_width=(width)
+      graphic_state.line_width = width
+      write_line_width
+    end
+
+    def line_width(width = nil)
+      return graphic_state.line_width unless width
+
+      self.line_width = width
+    end
+
+    def line(*points)
+      x0, y0, x1, y1 = points.flatten
+      move_to(x0, y0)
+      line_to(x1, y1)
+    end
+
+    def horizontal_line(x1, x2, options = {})
+      y1 = options[:at] || (y - bounds.absolute_bottom)
+      line(x1, y1, x2, y1)
+    end
+
+    def horizontal_rule
+      horizontal_line(bounds.left, bounds.right)
+    end
+
+    def vertical_line(y1, y2, params)
+      line(params[:at], y1, params[:at], y2)
+    end
+
+    def curve(origin, destination, options = {})
+      move_to(*origin)
+      curve_to(destination, options)
+    end
+
+    def circle(center, radius)
+      ellipse(center, radius, radius)
+    end
+
+    def ellipse(point, radius1, radius2 = radius1)
+      x, y = point
+      l1 = radius1 * KAPPA
+      l2 = radius2 * KAPPA
+      move_to(x + radius1, y)
+      curve_to([x, y + radius2], bounds: [[x + radius1, y + l2], [x + l1, y + radius2]])
+      curve_to([x - radius1, y], bounds: [[x - l1, y + radius2], [x - radius1, y + l2]])
+      curve_to([x, y - radius2], bounds: [[x - radius1, y - l2], [x - l1, y - radius2]])
+      curve_to([x + radius1, y], bounds: [[x + l1, y - radius2], [x + radius1, y - l2]])
+      move_to(x, y)
+    end
+
+    def polygon(*points)
+      move_to(points[0])
+      (points.drop(1) << points[0]).each { line_to(*_1) }
+      add_content("h")
+    end
+
+    def rounded_polygon(radius, *points)
+      move_to(point_on_line(radius, points[1], points[0]))
+      sides = points.size
+      points << points[0] << points[1]
+      sides.times { |side| rounded_vertex(radius, points[side], points[side + 1], points[side + 2]) }
+      add_content("h")
+    end
+
+    def rounded_vertex(radius, *points)
+      radial_point1 = point_on_line(radius, points[0], points[1])
+      bezier_point1 = point_on_line(radius - (radius * KAPPA), points[0], points[1])
+      radial_point2 = point_on_line(radius, points[2], points[1])
+      bezier_point2 = point_on_line(radius - (radius * KAPPA), points[2], points[1])
+      line_to(radial_point1)
+      curve_to(radial_point2, bounds: [bezier_point1, bezier_point2])
+    end
+
+    def stroke
+      yield if block_given?
+      add_content("S")
+    end
+
+    def close_and_stroke
+      yield if block_given?
+      add_content("s")
+    end
+
+    def stroke_bounds
+      stroke_rectangle(bounds.top_left, bounds.width, bounds.height)
+    end
+
+    def stroke_axis(options = {})
+      origin = options[:at] || [0, 0]
+      options = {
+        at: [0, 0], height: bounds.height - origin[1], width: bounds.width - origin[0],
+        step_length: 100, negative_axes_length: 20, color: "000000"
+      }.merge(options)
+      Prawn.verify_options(%i[at width height step_length negative_axes_length color], options)
+      x, y = options[:at]
+
+      save_graphics_state do
+        fill_color(options[:color])
+        stroke_color(options[:color])
+        dash(1, space: 4)
+        stroke_horizontal_line(x - options[:negative_axes_length], x + options[:width], at: y)
+        stroke_vertical_line(y - options[:negative_axes_length], y + options[:height], at: x)
+        undash
+        fill_circle(options[:at], 1)
+        (options[:step_length]..options[:width]).step(options[:step_length]) do |point|
+          fill_circle([x + point, y], 1)
+          draw_text(point, at: [x + point - 5, y - 10], size: 7)
+        end
+        (options[:step_length]..options[:height]).step(options[:step_length]) do |point|
+          fill_circle([x, y + point], 1)
+          draw_text(point, at: [x - 17, y + point - 2], size: 7)
+        end
+      end
+    end
+
+    def fill(options = {})
+      yield if block_given?
+      add_content((options[:fill_rule] == :even_odd) ? "f*" : "f")
+    end
+
+    def fill_and_stroke(options = {})
+      yield if block_given?
+      add_content((options[:fill_rule] == :even_odd) ? "b*" : "b")
+    end
+
+    def close_path
+      add_content("h")
+    end
+
+    SHAPES = %i[
+      line_to curve_to rectangle rounded_rectangle line horizontal_line horizontal_rule vertical_line curve circle_at circle
+      ellipse_at ellipse polygon rounded_polygon rounded_vertex
+    ].freeze
+
+    %i[fill stroke fill_and_stroke].product(SHAPES).each do |operation, shape|
+      define_method(:"#{operation}_#{shape}") do |*arguments|
+        public_send(operation) { public_send(shape, *arguments) }
+      end
+    end
+
+    private
+
+    def write_line_width
+      add_content("#{graphic_state.line_width} w")
+    end
+
+    # Called with x, y or [x, y] for every point drawn: those two shapes skip the copy flatten makes.
+    def map_to_absolute(*point)
+      point = point[0] if point.size == 1 && point[0].is_a?(Array)
+      x, y = (point.size == 2 && point[0].is_a?(Numeric) && point[1].is_a?(Numeric)) ? point : point.flatten
+      [@bounding_box.absolute_left + x, @bounding_box.absolute_bottom + y]
+    end
+
+    def map_to_absolute!(point)
+      point.replace(map_to_absolute(point))
+    end
+
+    def degree_to_rad(angle)
+      angle * Math::PI / 180
+    end
+
+    def point_on_line(distance_from_end, *points)
+      x0, y0, x1, y1 = points.flatten
+      length = Math.sqrt(((x1 - x0)**2) + ((y1 - y0)**2))
+      ratio = (length - distance_from_end) / length
+      [x0 + (ratio * (x1 - x0)), y0 + (ratio * (y1 - y0))]
+    end
+  end
+end

data/lib/gamba/grid.rb

@@ -0,0 +1,216 @@
+# frozen_string_literal: true
+
+module Prawn
+  class Document
+    def define_grid(options = {})
+      @boxes = nil
+      @grid = Grid.new(self, options)
+    end
+
+    def grid(*arguments)
+      @boxes ||= {}
+      @boxes[arguments] ||=
+        if arguments.empty?
+          @grid
+        else
+          first, second = arguments
+          if first.is_a?(Array) && second.is_a?(Array) && first.length == 2 && second.length == 2
+            MultiBox.new(self, GridBox.new(self, *first), GridBox.new(self, *second))
+          else
+            GridBox.new(self, first, second)
+          end
+        end
+    end
+
+    # Rows and columns of equal size dividing the current bounds, separated by gutters.
+    class Grid
+      attr_reader :pdf, :columns, :rows, :gutter, :row_gutter, :column_gutter
+
+      def initialize(pdf, options = {})
+        Prawn.verify_options(%i[columns rows gutter row_gutter column_gutter], options)
+        @pdf = pdf
+        @columns = options[:columns]
+        @rows = options[:rows]
+        if options.key?(:gutter)
+          @gutter = Float(options[:gutter])
+          @row_gutter = @gutter
+          @column_gutter = @gutter
+        else
+          @row_gutter = Float(options[:row_gutter])
+          @column_gutter = Float(options[:column_gutter])
+          @gutter = 0
+        end
+      end
+
+      def column_width
+        @column_width ||= subdivide(pdf.bounds.width, columns, column_gutter)
+      end
+
+      def row_height
+        @row_height ||= subdivide(pdf.bounds.height, rows, row_gutter)
+      end
+
+      def show_all(color = "CCCCCC")
+        rows.times { |row| columns.times { |column| pdf.grid(row, column).show(color) } }
+      end
+
+      private
+
+      def subdivide(total, count, gutter)
+        (Float(total) - (gutter * Float(count - 1))) / Float(count)
+      end
+    end
+
+    # What a grid cell and a span of cells share: corners, a bounding box, and a way to show themselves.
+    module GridArea
+      def top_left
+        [left, top]
+      end
+
+      def top_right
+        [right, top]
+      end
+
+      def bottom_left
+        [left, bottom]
+      end
+
+      def bottom_right
+        [right, bottom]
+      end
+
+      def bounding_box(&)
+        pdf.bounding_box(top_left, width:, height:, &)
+      end
+
+      def show(grid_color = "CCCCCC")
+        bounding_box do
+          original_stroke_color = pdf.stroke_color
+          pdf.stroke_color = grid_color
+          pdf.text(name)
+          pdf.stroke_bounds
+          pdf.stroke_color = original_stroke_color
+        end
+      end
+    end
+
+    class GridBox
+      include GridArea
+
+      attr_reader :pdf
+
+      def initialize(pdf, rows, columns)
+        @pdf = pdf
+        @rows = rows
+        @columns = columns
+      end
+
+      def name
+        "#{@rows},#{@columns}"
+      end
+
+      def total_height
+        Float(pdf.bounds.height)
+      end
+
+      def width
+        Float(grid.column_width)
+      end
+
+      def height
+        Float(grid.row_height)
+      end
+
+      def gutter
+        Float(grid.gutter)
+      end
+
+      def left
+        @left ||= (width + grid.column_gutter) * Float(@columns)
+      end
+
+      def right
+        @right ||= left + width
+      end
+
+      def top
+        @top ||= total_height - ((height + grid.row_gutter) * Float(@rows))
+      end
+
+      def bottom
+        @bottom ||= top - height
+      end
+
+      private
+
+      def grid
+        pdf.grid
+      end
+    end
+
+    class MultiBox
+      include GridArea
+
+      attr_reader :pdf
+
+      def initialize(pdf, box1, box2)
+        @pdf = pdf
+        @boxes = [box1, box2]
+      end
+
+      def name
+        @boxes.map(&:name).join(":")
+      end
+
+      def total_height
+        @boxes[0].total_height
+      end
+
+      def width
+        right_box.right - left_box.left
+      end
+
+      def height
+        top_box.top - bottom_box.bottom
+      end
+
+      def gutter
+        @boxes[0].gutter
+      end
+
+      def left
+        left_box.left
+      end
+
+      def right
+        right_box.right
+      end
+
+      def top
+        top_box.top
+      end
+
+      def bottom
+        bottom_box.bottom
+      end
+
+      private
+
+      def left_box
+        @left_box ||= @boxes.min_by(&:left)
+      end
+
+      def right_box
+        @right_box ||= @boxes.max_by(&:right)
+      end
+
+      def top_box
+        @top_box ||= @boxes.max_by(&:top)
+      end
+
+      def bottom_box
+        @bottom_box ||= @boxes.min_by(&:bottom)
+      end
+    end
+  end
+end

data/lib/gamba/images/image.rb

@@ -0,0 +1,271 @@
+# frozen_string_literal: true
+
+module Prawn
+  module Images
+    class Image
+      attr_accessor :scaled_width, :scaled_height
+
+      def calc_image_dimensions(options)
+        w = options[:width] || width
+        h = options[:height] || height
+        if options[:width] && !options[:height]
+          ratio = w / Float(width)
+          w = width * ratio
+          h = height * ratio
+        elsif options[:height] && !options[:width]
+          ratio = h / Float(height)
+          w = width * ratio
+          h = height * ratio
+        elsif options[:scale]
+          w = width * options[:scale]
+          h = height * options[:scale]
+        elsif options[:fit]
+          box_width, box_height = options[:fit]
+          if width / Float(height) > box_width / Float(box_height)
+            w = box_width
+            h = box_width / (width / Float(height))
+          else
+            h = box_height
+            w = box_height * (width / Float(height))
+          end
+        end
+        self.scaled_width = w
+        self.scaled_height = h
+        [w, h]
+      end
+    end
+
+    class JPG < Image
+      class FormatError < StandardError
+      end
+
+      START_OF_FRAME_MARKERS = [0xC0, 0xC1, 0xC2, 0xC3, 0xC5, 0xC6, 0xC7, 0xC9, 0xCA, 0xCB, 0xCD, 0xCE, 0xCF].freeze
+      MARKER_PREFIX = 0xFF
+      COLOR_SPACE_BY_CHANNELS = {1 => :DeviceGray, 3 => :DeviceRGB, 4 => :DeviceCMYK}.freeze
+      # Adobe's CMYK JPEGs store inverted values.
+      INVERTED_CMYK_DECODE = [1.0, 0.0, 1.0, 0.0, 1.0, 0.0, 1.0, 0.0].freeze
+
+      attr_reader :width, :height, :bits, :channels
+
+      def self.can_render?(image_blob)
+        image_blob.byteslice(0, 3).bytes == [255, 216, 255]
+      end
+
+      def initialize(data)
+        super()
+        @data = data
+        position = 2
+        loop do
+          marker, code, length = data.byteslice(position, 4)&.unpack("CCn")
+          raise FormatError, "JPEG marker not found!" if marker != MARKER_PREFIX
+
+          if START_OF_FRAME_MARKERS.include?(code)
+            @bits, @height, @width, @channels = data.unpack("@#{position + 4} CnnC")
+            break
+          end
+          position += 2 + length
+        end
+      end
+
+      def build_pdf_object(document)
+        color_space = COLOR_SPACE_BY_CHANNELS.fetch(channels) { raise ArgumentError, "JPG uses an unsupported number of channels" }
+        dictionary = {Type: :XObject, Subtype: :Image, ColorSpace: color_space, BitsPerComponent: bits, Width: width, Height: height, Filter: :DCTDecode}
+        dictionary[:Decode] = INVERTED_CMYK_DECODE if color_space == :DeviceCMYK
+        document.ref!(dictionary, @data)
+      end
+    end
+
+    class PNG < Image
+      SIGNATURE = [137, 80, 78, 71, 13, 10, 26, 10].freeze
+      GRAYSCALE = 0
+      TRUE_COLOR = 2
+      INDEXED = 3
+      GRAYSCALE_ALPHA = 4
+      TRUE_COLOR_ALPHA = 6
+      PNG_PREDICTORS = 15
+      # Compressed input fed at a time: at zlib's highest ratio, 4 KB inflate to about 4 MB before the size check.
+      INFLATE_CHUNK_BYTES = 4096
+      MAXIMUM_IMAGE_BYTES = 1 << 30
+      # Pixels split at a time: the unpack layout and its integers stay a few kilobytes, whatever the width.
+      ALPHA_SPLIT_CHUNK_PIXELS = 1024
+      # The bit depths the PNG specification allows for each color type.
+      BIT_DEPTHS = {GRAYSCALE => [1, 2, 4, 8, 16], TRUE_COLOR => [8, 16], INDEXED => [1, 2, 4, 8],
+                    GRAYSCALE_ALPHA => [8, 16], TRUE_COLOR_ALPHA => [8, 16]}.freeze
+
+      attr_reader :palette, :transparency, :width, :height, :bits, :color_type, :compression_method,
+        :filter_method, :interlace_method, :alpha_channel
+
+      def self.can_render?(image_blob)
+        image_blob.byteslice(0, 8).bytes == SIGNATURE
+      end
+
+      def initialize(data)
+        super()
+        @palette = +"".b
+        compressed = +"".b
+        @transparency = {}
+        position = 8
+        loop do
+          raise Errors::UnsupportedImageType, "Truncated PNG" if position + 8 > data.bytesize
+
+          length, section = data.unpack("@#{position} N a4")
+          raise Errors::UnsupportedImageType, "Truncated PNG #{section} chunk" if position + 8 + length > data.bytesize
+
+          chunk = data.byteslice(position + 8, length)
+          case section
+          when "IHDR"
+            @width, @height, @bits, @color_type, @compression_method, @filter_method, @interlace_method = chunk.unpack("NNCCCCC")
+          when "PLTE" then @palette << chunk
+          when "IDAT" then compressed << chunk
+          when "tRNS"
+            @transparency =
+              case @color_type
+              when INDEXED then {palette: chunk.unpack("C*")}
+              when GRAYSCALE then {grayscale: chunk.unpack1("n")}
+              when TRUE_COLOR then {rgb: chunk.unpack("nnn")}
+              else {}
+              end
+          when "IEND" then break
+          end
+          position += 12 + length
+        end
+        raise Errors::UnsupportedImageType, "PNG without a valid IHDR chunk" unless @width.to_i.positive? && @height.to_i.positive? && @bits.to_i.positive?
+
+        @compressed_data = compressed
+      end
+
+      # Inflated up to the size the header announces, never more: a few kilobytes of crafted data could otherwise
+      # inflate into gigabytes.
+      def img_data
+        @img_data ||= begin
+          samples = (colors || 1) + ((alpha_channel? && color_type != INDEXED) ? 1 : 0)
+          expected_bytes = height * (1 + (((width * bits * samples) + 7) / 8))
+          raise Errors::UnsupportedImageType, "PNG of #{width}x#{height} pixels is too large" if expected_bytes > MAXIMUM_IMAGE_BYTES
+
+          inflater = Zlib::Inflate.new
+          inflated = +"".b
+          (0...@compressed_data.bytesize).step(INFLATE_CHUNK_BYTES) do |offset|
+            inflated << inflater.inflate(@compressed_data.byteslice(offset, INFLATE_CHUNK_BYTES))
+            raise Errors::UnsupportedImageType, "PNG data inflates beyond its #{width}x#{height} size" if inflated.bytesize > expected_bytes
+          end
+          inflated << inflater.finish
+          inflated
+        rescue Zlib::Error => exception
+          raise Errors::UnsupportedImageType, "Corrupt PNG data: #{exception.message}"
+        ensure
+          # A refused stream is still mid-inflate: closing it as is warns under -w.
+          inflater&.reset
+          inflater&.close
+        end
+      end
+
+      def colors
+        case color_type
+        when GRAYSCALE, INDEXED, GRAYSCALE_ALPHA then 1
+        when TRUE_COLOR, TRUE_COLOR_ALPHA then 3
+        end
+      end
+
+      def alpha_channel?
+        return true if color_type == GRAYSCALE_ALPHA || color_type == TRUE_COLOR_ALPHA
+        return @transparency.any? if color_type == INDEXED
+
+        false
+      end
+
+      def min_pdf_version
+        if bits > 8 then 1.5
+        elsif alpha_channel? then 1.4
+        else 1.0
+        end
+      end
+
+      def build_pdf_object(document)
+        raise Errors::UnsupportedImageType, "PNG uses an unsupported compression method" if compression_method != 0
+        raise Errors::UnsupportedImageType, "PNG uses an unsupported filter method" if filter_method != 0
+        raise Errors::UnsupportedImageType, "PNG uses unsupported interlace method" if interlace_method != 0
+        raise Errors::UnsupportedImageType, "PNG uses an invalid bit depth" if BIT_DEPTHS[color_type]&.include?(bits) == false
+
+        dictionary = {Type: :XObject, Subtype: :Image, Height: height, Width: width, BitsPerComponent: bits}
+        if color_type == INDEXED && alpha_channel?
+          index_samples, alpha_samples = split_palette_transparency
+          image = document.ref!(dictionary, index_samples)
+          image.data[:SMask] = document.ref!(alpha_dictionary(8), alpha_samples)
+        elsif alpha_channel?
+          color_rows, alpha_rows = split_alpha_channel
+          image = document.ref!(dictionary.merge(DecodeParms: predictors(colors)), color_rows)
+          image.data[:SMask] = document.ref!(alpha_dictionary(bits).merge(DecodeParms: predictors(1)), alpha_rows)
+        else
+          image = document.ref!(dictionary.merge(DecodeParms: predictors(colors)), img_data)
+        end
+        image.data[:ColorSpace] = if palette.empty?
+          (colors == 1) ? :DeviceGray : :DeviceRGB
+        else
+          [:Indexed, :DeviceRGB, (palette.bytesize / 3) - 1, document.ref!({}, palette)]
+        end
+        if transparency[:grayscale]
+          image.data[:Mask] = [transparency[:grayscale]] * 2
+        elsif transparency[:rgb]
+          image.data[:Mask] = transparency[:rgb].flat_map { [_1, _1] }
+        end
+        image
+      end
+
+      private
+
+      # The reader undoes the PNG filters itself; the stream gets compressed again when the document is written.
+      def predictors(color_count)
+        {Predictor: PNG_PREDICTORS, Colors: color_count, BitsPerComponent: bits, Columns: width}
+      end
+
+      def alpha_dictionary(bits_per_component)
+        {Type: :XObject, Subtype: :Image, Height: height, Width: width, BitsPerComponent: bits_per_component, ColorSpace: :DeviceGray, Decode: [0, 1]}
+      end
+
+      # Color and alpha rows, each keeping its filter byte: PNG filters predict a byte from the same channel of
+      # the neighbouring pixels, which stays at the same relative place once the channels are apart.
+      def split_alpha_channel
+        sample_bytes = bits / 8
+        pixel_bytes = (colors + 1) * sample_bytes
+        row_bytes = (width * pixel_bytes) + 1
+        row_count = img_data.bytesize / row_bytes
+        chunk_pixels = [width, ALPHA_SPLIT_CHUNK_PIXELS].min
+        chunk_count, remainder_pixels = width.divmod(chunk_pixels)
+        chunk_layouts = alpha_split_layouts(sample_bytes, chunk_pixels)
+        remainder_layouts = alpha_split_layouts(sample_bytes, remainder_pixels)
+        color = +"".b
+        alpha = +"".b
+        row_count.times do |row_index|
+          start = row_index * row_bytes
+          filter = img_data.getbyte(start)
+          color << filter
+          alpha << filter
+          chunk_count.times { split_pixels(start + 1 + (_1 * chunk_pixels * pixel_bytes), chunk_layouts, color, alpha) }
+          split_pixels(start + 1 + (chunk_count * chunk_pixels * pixel_bytes), remainder_layouts, color, alpha) if remainder_pixels.positive?
+        end
+        [color, alpha]
+      end
+
+      def alpha_split_layouts(sample_bytes, pixels)
+        color_bytes = colors * sample_bytes
+        ["C#{color_bytes}x#{sample_bytes}" * pixels, "x#{color_bytes}C#{sample_bytes}" * pixels]
+      end
+
+      def split_pixels(offset, (color_layout, alpha_layout), color, alpha)
+        img_data.unpack(color_layout, offset:).pack("C*", buffer: color)
+        img_data.unpack(alpha_layout, offset:).pack("C*", buffer: alpha)
+      end
+
+      # Palette indices and their opacity: indices only mean something once the rows are unfiltered.
+      def split_palette_transparency
+        rows = PngDecoder.unfilter(img_data, ((width * bits) + 7) / 8, 1)
+        alpha_by_index = Array.new(256) { |index| transparency[:palette][index] || 0xFF }
+        alpha = rows.map do |row|
+          indices = (bits == 8) ? row.bytes : row.unpack1("B*").scan(/.{#{bits}}/).first(width).map! { _1.to_i(2) }
+          indices.map { alpha_by_index[_1] }.pack("C*")
+        end
+        [rows.join, alpha.join]
+      end
+    end
+  end
+end