giga-fast-kit 0.0.1

data/prawn-2.5.0/lib/prawn/graphics/cap_style.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Prawn
+  module Graphics
+    # Implements stroke cap styling
+    module CapStyle
+      # @group Stable API
+
+      # @private
+      CAP_STYLES = { butt: 0, round: 1, projecting_square: 2 }.freeze
+
+      # Sets the cap style for stroked lines and curves.
+      #
+      # @overload cap_style(style)
+      #   @param style [:butt, :round, :projecting_square] (:butt)
+      #   @return [void]
+      # @overload cap_style()
+      #   @return [Symbol]
+      def cap_style(style = nil)
+        return current_cap_style || :butt if style.nil?
+
+        self.current_cap_style = style
+
+        write_stroke_cap_style
+      end
+
+      alias cap_style= cap_style
+
+      private
+
+      def current_cap_style
+        graphic_state.cap_style
+      end
+
+      def current_cap_style=(style)
+        graphic_state.cap_style = style
+      end
+
+      def write_stroke_cap_style
+        renderer.add_content("#{CAP_STYLES[current_cap_style]} J")
+      end
+    end
+  end
+end

data/prawn-2.5.0/lib/prawn/graphics/color.rb

@@ -0,0 +1,257 @@
+# frozen_string_literal: true
+
+module Prawn
+  module Graphics
+    # Implements color handling.
+    module Color
+      # @group Stable API
+
+      # Sets or returns the fill color.
+      #
+      # @overload fill_color
+      #   Returns the current fill color.
+      #
+      #   @return [String, Array<Number>]
+      #
+      # @overload fill_color(color)
+      #   Sets the fill color.
+      #
+      #   If a single argument is provided, it should be a 6 digit HTML color
+      #   code.
+      #
+      #   ```ruby
+      #   pdf.fill_color "f0ffc1"
+      #   ```
+      #
+      #   If 4 arguments are provided, the color is assumed to be a CMYK value.
+      #   Values range is 0–100.
+      #
+      #   ```ruby
+      #   pdf.fill_color 0, 99, 95, 0
+      #   ```
+      #
+      #   @param color [String, Array<Number>]
+      #   @return [void]
+      def fill_color(*color)
+        return current_fill_color if color.empty?
+
+        self.current_fill_color = process_color(*color)
+        set_fill_color
+      end
+
+      alias fill_color= fill_color
+
+      # Sets or returns the line stroking color.
+      #
+      # @overload stroke_color
+      #   When called with no argument, it returns the current stroking color.
+      #
+      #   @return [String, Array<Number>]
+      #
+      # @overload stroke_color(color)
+      #   Sets the stroking color.
+      #
+      #   @param color [String, Array<Number>] new stroking color:
+      #     - In String form it should be a 6 digit HTML color code.
+      #
+      #       ```ruby
+      #       pdf.stroke_color "f0ffc1"
+      #       ```
+      #     - If 4 arguments are provided, the color is assumed to be a CMYK
+      #       value. Values range from 0 to 100.
+      #
+      #       ```ruby
+      #       pdf.stroke_color 0, 99, 95, 0
+      #       ```
+      #   @return [void]
+      def stroke_color(*color)
+        return current_stroke_color if color.empty?
+
+        color = process_color(*color)
+        self.current_stroke_color = color
+        set_stroke_color(color)
+      end
+
+      alias stroke_color= stroke_color
+
+      module_function
+
+      # Converts RGB value array to hex string suitable for use with
+      # {fill_color} and {stroke_color}.
+      #
+      # @example
+      #   Prawn::Graphics::Color.rgb2hex([255, 120, 8])
+      #   #=> "ff7808"
+      #
+      # @param rgb [Array(Number, Number, Number)]
+      #   Each component has to be in the range from 0 to 255.
+      # @return [String]
+      def rgb2hex(rgb)
+        rgb.map { |e| format('%<value>02x', value: e) }.join
+      end
+
+      # Converts hex string into RGB value array.
+      #
+      # @example
+      #   Prawn::Graphics::Color.hex2rgb("ff7808")
+      #   #=> [255, 120, 8]
+      #
+      # @param hex [String] must be 6-digits long.
+      # @return [Array(Integer, Integer, Integer)]
+      def hex2rgb(hex)
+        r = hex[0..1]
+        g = hex[2..3]
+        b = hex[4..5]
+        [r, g, b].map { |e| e.to_i(16) }
+      end
+
+      private
+
+      def process_color(*color)
+        case color.size
+        when 1
+          color[0]
+        when 4
+          color
+        else
+          raise ArgumentError, 'wrong number of arguments supplied'
+        end
+      end
+
+      def color_type(color)
+        case color
+        when String
+          if /\A\h{6}\z/.match?(color)
+            :RGB
+          else
+            raise ArgumentError, "Unknown type of color: #{color.inspect}"
+          end
+        when Array
+          case color.length
+          when 3
+            :RGB
+          when 4
+            :CMYK
+          else
+            raise ArgumentError, "Unknown type of color: #{color.inspect}"
+          end
+        end
+      end
+
+      def normalize_color(color)
+        case color_type(color)
+        when :RGB
+          r, g, b = hex2rgb(color)
+          [r / 255.0, g / 255.0, b / 255.0]
+        when :CMYK
+          c, m, y, k = *color
+          [c / 100.0, m / 100.0, y / 100.0, k / 100.0]
+        end
+      end
+
+      def color_to_s(color)
+        PDF::Core.real_params(normalize_color(color))
+      end
+
+      def color_space(color)
+        case color_type(color)
+        when :RGB
+          :DeviceRGB
+        when :CMYK
+          :DeviceCMYK
+        end
+      end
+
+      COLOR_SPACES = %i[DeviceRGB DeviceCMYK Pattern].freeze
+
+      def set_color_space(type, color_space)
+        # don't set the same color space again
+        if current_color_space(type) == color_space &&
+            !state.page.in_stamp_stream?
+          return
+        end
+
+        set_current_color_space(color_space, type)
+
+        unless COLOR_SPACES.include?(color_space)
+          raise ArgumentError, "unknown color space: '#{color_space}'"
+        end
+
+        operator =
+          case type
+          when :fill
+            'cs'
+          when :stroke
+            'CS'
+          else
+            raise ArgumentError, "unknown type '#{type}'"
+          end
+
+        renderer.add_content("/#{color_space} #{operator}")
+      end
+
+      def set_color(type, color, options = {})
+        operator =
+          case type
+          when :fill
+            'scn'
+          when :stroke
+            'SCN'
+          else
+            raise ArgumentError, "unknown type '#{type}'"
+          end
+
+        if options[:pattern]
+          set_color_space(type, :Pattern)
+          renderer.add_content("/#{color} #{operator}")
+        else
+          set_color_space(type, color_space(color))
+          color = color_to_s(color)
+          write_color(color, operator)
+        end
+      end
+
+      def set_fill_color(color = nil)
+        set_color(:fill, color || current_fill_color)
+      end
+
+      def set_stroke_color(color = nil)
+        set_color(:stroke, color || current_stroke_color)
+      end
+
+      def update_colors
+        set_fill_color
+        set_stroke_color
+      end
+
+      def current_color_space(type)
+        graphic_state.color_space[type]
+      end
+
+      def set_current_color_space(color_space, type)
+        save_graphics_state if graphic_state.nil?
+        graphic_state.color_space[type] = color_space
+      end
+
+      def current_fill_color
+        graphic_state.fill_color
+      end
+
+      def current_fill_color=(color)
+        graphic_state.fill_color = color
+      end
+
+      def current_stroke_color
+        graphic_state.stroke_color
+      end
+
+      def current_stroke_color=(color)
+        graphic_state.stroke_color = color
+      end
+
+      def write_color(color, operator)
+        renderer.add_content("#{color} #{operator}")
+      end
+    end
+  end
+end

data/prawn-2.5.0/lib/prawn/graphics/dash.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+module Prawn
+  module Graphics
+    # Implements stroke dashing.
+    module Dash
+      # @group Stable API
+
+      # Get or set stroke dash pattern.
+      #
+      # @overload dash()
+      #   Returns the current dash pattern.
+      #
+      #   @return [Hash{:dash => Number, Array<Number>, :space => Number, nil, :phase => Number}]
+      #
+      # @overload dash(length, options ={})
+      #   Sets the dash pattern for stroked lines and curves.
+      #
+      #   Integers or Floats may be used for length and the option values.
+      #   Dash units are in PDF points (1/72 inch).
+      #
+      #   @param length [Number, Array<Number>]
+      #     * If `length` is a Number (Integer or Float), it specifies the
+      #       length of the dash and of the gap. The length of the gap can be
+      #       customized by setting the `:space` option.
+      #
+      #       Examples:
+      #
+      #       length = 3
+      #       : 3 on, 3 off, 3 on, 3 off, ...
+      #
+      #       length = 3, :space = 2
+      #       : 3 on, 2 off, 3 on, 2 off, ...
+      #
+      #     * If `length` is an array, it specifies the lengths of alternating
+      #       dashes and gaps. The numbers must be non-negative and not all
+      #       zero. The `:space` option is ignored in this case.
+      #
+      #       Examples:
+      #
+      #       length = [2, 1]
+      #       : 2 on, 1 off, 2 on, 1 off, ...
+      #
+      #       length = [3, 1, 2, 3]
+      #       : 3 on, 1 off, 2 on, 3 off, 3 on, 1 off, ...
+      #
+      #       length = [3, 0, 1]
+      #       : 3 on, 0 off, 1 on, 3 off, 0 on, 1 off, ...
+      #   @param options [Hash{Symbol => any}]
+      #   @option options :space [Number]
+      #     The space between the dashes (only used when `length` is not an
+      #     array).
+      #   @option options :phase [Number] (0)
+      #     The distance into the dash pattern at which to start the dash. For
+      #     example, a phase of 0 starts at the beginning of the dash; whereas,
+      #     if the phase is equal to the length of the dash, then stroking will
+      #     begin at the beginning of the space.
+      #   @return [void]
+      def dash(length = nil, options = {})
+        return current_dash_state if length.nil?
+
+        length = Array(length)
+
+        if length.all?(&:zero?)
+          raise ArgumentError,
+            'Zero length dashes are invalid. Call #undash to disable dashes.'
+        elsif length.any?(&:negative?)
+          raise ArgumentError,
+            'Negative numbers are not allowed for dash lengths.'
+        end
+
+        length = length.first if length.length == 1
+
+        self.current_dash_state = {
+          dash: length,
+          space: length.is_a?(Array) ? nil : options[:space] || length,
+          phase: options[:phase] || 0,
+        }
+
+        write_stroke_dash
+      end
+
+      alias dash= dash
+
+      # Stops dashing, restoring solid stroked lines and curves.
+      #
+      # @return [void]
+      def undash
+        self.current_dash_state = undashed_setting
+        write_stroke_dash
+      end
+
+      # Returns `true` when stroke is dashed, `false` otherwise.
+      #
+      # @return [Boolean]
+      def dashed?
+        current_dash_state != undashed_setting
+      end
+
+      private
+
+      def write_stroke_dash
+        renderer.add_content(dash_setting)
+      end
+
+      def undashed_setting
+        { dash: nil, space: nil, phase: 0 }
+      end
+
+      def current_dash_state=(dash_options)
+        graphic_state.dash = dash_options
+      end
+
+      def current_dash_state
+        graphic_state.dash
+      end
+
+      def dash_setting
+        graphic_state.dash_setting
+      end
+    end
+  end
+end

data/prawn-2.5.0/lib/prawn/graphics/join_style.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Prawn
+  module Graphics
+    # Implements stroke join styling.
+    module JoinStyle
+      # @private
+      JOIN_STYLES = { miter: 0, round: 1, bevel: 2 }.freeze
+
+      # @group Stable API
+
+      # Get or set the join style for stroked lines and curves.
+      #
+      # @overload join_style
+      #   Get current join style.
+      #
+      #   @return [:miter, :round, :bevel]
+      #
+      # @overload join_style(style)
+      #   Set join style.
+      #
+      #   @note If this method is never called, `:miter` will be used for join
+      #     style throughout the document.
+      #
+      #   @param style [:miter, :round, :bevel]
+      #   @return [void]
+      #
+      #
+      def join_style(style = nil)
+        return current_join_style || :miter if style.nil?
+
+        self.current_join_style = style
+
+        unless JOIN_STYLES.key?(current_join_style)
+          raise Prawn::Errors::InvalidJoinStyle,
+            "#{style} is not a recognized join style. Valid styles are " +
+              JOIN_STYLES.keys.join(', ')
+        end
+
+        write_stroke_join_style
+      end
+
+      alias join_style= join_style
+
+      private
+
+      def current_join_style
+        graphic_state.join_style
+      end
+
+      def current_join_style=(style)
+        graphic_state.join_style = style
+      end
+
+      def write_stroke_join_style
+        renderer.add_content("#{JOIN_STYLES[current_join_style]} j")
+      end
+    end
+  end
+end