giga-fast-kit 0.0.1

data/prawn-2.5.0/lib/prawn/measurements.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+# rubocop: disable Naming/MethodParameterName
+module Prawn
+  # @group Stable API
+
+  # Distance unit conversions between metric, imperial, and PDF.
+  module Measurements
+    # metric conversions
+
+    # Convert centimeter to millimeters.
+    #
+    # @param cm [Number]
+    # @return [Number]
+    def cm2mm(cm)
+      cm * 10
+    end
+
+    # Convert decimeters to millimeters.
+    #
+    # @param dm [Number]
+    # @return [Number]
+    def dm2mm(dm)
+      dm * 100
+    end
+
+    # Convert meters to millimeters.
+    #
+    # @param m [Number]
+    # @return [Number]
+    def m2mm(m)
+      m * 1000
+    end
+
+    # imperial conversions
+    # from http://en.wikipedia.org/wiki/Imperial_units
+
+    # Convert feet to inches.
+    #
+    # @param ft [Number]
+    # @return [Number]
+    def ft2in(ft)
+      ft * 12
+    end
+
+    # Convert yards to inches.
+    #
+    # @param yd [Number]
+    # @return [Number]
+    def yd2in(yd)
+      yd * 36
+    end
+
+    # PostscriptPoint-converisons
+
+    # Convert points to points. For completeness.
+    #
+    # @param pt [Number]
+    # @return [Number]
+    def pt2pt(pt)
+      pt
+    end
+
+    # Convert inches to points.
+    #
+    # @param inch [Number]
+    # @return [Number]
+    def in2pt(inch)
+      inch * 72
+    end
+
+    # Convert feet to points.
+    #
+    # @param ft [Number]
+    # @return [Number]
+    def ft2pt(ft)
+      in2pt(ft2in(ft))
+    end
+
+    # Convert yards to points.
+    #
+    # @param yd [Number]
+    # @return [Number]
+    def yd2pt(yd)
+      in2pt(yd2in(yd))
+    end
+
+    # Convert millimeters to points.
+    #
+    # @param mm [Number]
+    # @return [Number]
+    def mm2pt(mm)
+      mm * (72 / 25.4)
+    end
+
+    # Convert centimeters to points.
+    #
+    # @param cm [Number]
+    # @return [Number]
+    def cm2pt(cm)
+      mm2pt(cm2mm(cm))
+    end
+
+    # Convert decimeters to points.
+    #
+    # @param dm [Number]
+    # @return [Number]
+    def dm2pt(dm)
+      mm2pt(dm2mm(dm))
+    end
+
+    # Convert meters to points.
+    #
+    # @param m [Number]
+    # @return [Number]
+    def m2pt(m)
+      mm2pt(m2mm(m))
+    end
+
+    # Convert points to millimeters.
+    #
+    # @param pt [Number]
+    # @return [Number]
+    def pt2mm(pt)
+      pt * 1 / mm2pt(1) # (25.4 / 72)
+    end
+  end
+end
+# rubocop: enable Naming/MethodParameterName

data/prawn-2.5.0/lib/prawn/outline.rb

@@ -0,0 +1,316 @@
+# frozen_string_literal: true
+
+module Prawn
+  class Document # rubocop: disable Style/Documentation
+    # @group Stable API
+
+    # Lazily instantiates a Prawn::Outline object for document. This is used as
+    # point of entry to methods to build the outline tree for a document's table
+    # of contents.
+    #
+    # @return [Prawn::Outline]
+    def outline
+      @outline ||= Outline.new(self)
+    end
+  end
+
+  # The Outline class organizes the outline tree items for the document. Note
+  # that the {prev} and {parent} are adjusted while navigating through the
+  # nested blocks. These attributes along with the presence or absence of blocks
+  # are the primary means by which the relations for the various
+  # `PDF::Core::OutlineItem`s and the `PDF::Core::OutlineRoot` are set.
+  #
+  # Some ideas for the organization of this class were gleaned from `name_tree`.
+  # In particular the way in which the `PDF::Core::OutlineItem`s are finally
+  # rendered into document objects through a hash.
+  class Outline
+    # @private
+    attr_accessor :parent, :prev, :document, :items
+
+    # @param document [Prawn::Document]
+    def initialize(document)
+      @document = document
+      @parent = root
+      @prev = nil
+      @items = {}
+    end
+
+    # @group Stable API
+
+    # Returns the current page number of the document.
+    #
+    # @return [Integer]
+    def page_number
+      @document.page_number
+    end
+
+    # Defines/Updates an outline for the document.
+    #
+    # The outline is an optional nested index that appears on the side of a PDF
+    # document usually with direct links to pages. The outline DSL is defined by
+    # nested blocks involving two methods: {section} and {page}. Note that one
+    # can also use {update} to add more sections to the end of the outline tree
+    # using the same syntax and scope.
+    #
+    # The syntax is best illustrated with an example:
+    #
+    # ```ruby
+    # Prawn::Document.generate('outlined_document.pdf') do
+    #   text "Page 1. This is the first Chapter. "
+    #   start_new_page
+    #   text "Page 2. More in the first Chapter. "
+    #   start_new_page
+    #   outline.define do
+    #     section 'Chapter 1', destination: 1, closed: true do
+    #       page destination: 1, title: 'Page 1'
+    #       page destination: 2, title: 'Page 2'
+    #     end
+    #   end
+    #   start_new_page do
+    #   outline.update do
+    #     section 'Chapter 2', destination: 2, do
+    #       page destination: 3, title: 'Page 3'
+    #     end
+    #   end
+    # end
+    # ```
+    #
+    # @yield
+    # @return [void]
+    def define(&block)
+      instance_eval(&block) if block
+    end
+
+    alias update define
+
+    # Inserts an outline section to the outline tree (see {define}).
+    #
+    # Although you will probably choose to exclusively use {define} so that your
+    # outline tree is contained and easy to manage, this method gives you the
+    # option to insert sections to the outline tree at any point during document
+    # generation. This method allows you to add a child subsection to any other
+    # item at any level in the outline tree. Currently the only way to locate
+    # the place of entry is with the title for the item. If your title names are
+    # not unique consider using {define}.
+    #
+    # Consider using this method instead of {update} if you want to have the
+    # outline object to be scoped as self (see {insert_section_after} example).
+    #
+    # ```ruby
+    # go_to_page 2
+    # start_new_page
+    # text "Inserted Page"
+    # outline.add_subsection_to title: 'Page 2', :first do
+    #   outline.page destination: page_number, title: "Inserted Page"
+    # end
+    # ```
+    #
+    # @param title [String] An outline title to add the subsection to.
+    # @param position [:first, :last] (:last)
+    #   Where the subsection will be placed relative to other child elements. If
+    #   you need to position your subsection in between other elements then
+    #   consider using {insert_section_after}.
+    # @yield Uses the same DSL syntax as {define}
+    # @return [void]
+    def add_subsection_to(title, position = :last, &block)
+      @parent = items[title]
+      unless @parent
+        raise Prawn::Errors::UnknownOutlineTitle,
+          "\n No outline item with title: '#{title}' exists in the outline tree"
+      end
+      @prev = position == :first ? nil : @parent.data.last
+      nxt = position == :first ? @parent.data.first : nil
+      insert_section(nxt, &block)
+    end
+
+    # Inserts an outline section to the outline tree (see {define}).
+    #
+    # Although you will probably choose to exclusively use {define} so that your
+    # outline tree is contained and easy to manage, this method gives you the
+    # option to insert sections to the outline tree at any point during document
+    # generation. Unlike {add_subsection_to}, this method allows you to enter
+    # a section after any other item at any level in the outline tree.
+    # Currently the only way to locate the place of entry is with the title for
+    # the item. If your title names are not unique consider using
+    # {define}.
+    #
+    # @example
+    #   go_to_page 2
+    #   start_new_page
+    #   text "Inserted Page"
+    #   update_outline do
+    #     insert_section_after :title => 'Page 2' do
+    #       page :destination => page_number, :title => "Inserted Page"
+    #     end
+    #   end
+    #
+    # @param title [String]
+    #   The title of other section or page to insert new section after.
+    # @yield Uses the same DSL syntax as {define}.
+    # @return [void]
+    def insert_section_after(title, &block)
+      @prev = items[title]
+      unless @prev
+        raise Prawn::Errors::UnknownOutlineTitle,
+          "\n No outline item with title: '#{title}' exists in the outline tree"
+      end
+      @parent = @prev.data.parent
+      nxt = @prev.data.next
+      insert_section(nxt, &block)
+    end
+
+    # Adds an outline section to the outline tree.
+    #
+    # Although you will probably choose to exclusively use {define} so that your
+    # outline tree is contained and easy to manage, this method gives you the
+    # option to add sections to the outline tree at any point during document
+    # generation. When not being called from within another {section} block the
+    # section will be added at the top level after the other root elements of
+    # the outline. For more flexible placement try using {insert_section_after}
+    # and/or {add_subsection_to}.
+    #
+    # @example
+    #   outline.section 'Added Section', destination: 3 do
+    #     outline.page destionation: 3, title: 'Page 3'
+    #   end
+    #
+    # @param title [String] The outline text that appears for the section.
+    # @param options [Hash{Symbol => any}]
+    # @option options :destination [Integer, Array]
+    #   - Optional page number for a destination link to the top of the page
+    #     (using a `:FIT` destination).
+    #   - An array with a custom destination (see the `#dest_*` methods of the
+    #     `PDF::Core::Destination` module).
+    # @option options :closed [Boolean] (false)
+    #   Whether the section should show its nested outline elements.
+    # @yield More nested subsections and/or page blocks.
+    # @return [void]
+    def section(title, options = {}, &block)
+      add_outline_item(title, options, &block)
+    end
+
+    # Adds a page to the outline.
+    #
+    # Although you will probably choose to exclusively use {define} so that your
+    # outline tree is contained and easy to manage, this method also gives you
+    # the option to add pages to the root of outline tree at any point during
+    # document generation. Note that the page will be added at the top level
+    # after the other root outline elements. For more flexible placement try
+    # using {insert_section_after} and/or {add_subsection_to}.
+    #
+    # @note This method is almost identical to {section} except that it does not
+    #   accept a block thereby defining the outline item as a leaf on the
+    #   outline tree structure.
+    #
+    # @example
+    #   outline.page title: "Very Last Page"
+    #
+    # @param options [Hash{Symbol => any}]
+    # @option options :title [String] REQUIRED.
+    #   The outline text that appears for the page.
+    # @option options :destination [Integer, Array]
+    #   - The page number for a destination link to the top of the page (using
+    #     a `:FIT` destination).
+    #   - An array with a custom destination (see the `#dest_*` methods of the
+    #     `PDF::Core::Destination` module).
+    # @option options :closed [Boolean] (false)
+    #   Whether the section should show its nested outline elements.
+    # @return [void]
+    def page(options = {})
+      if options[:title]
+        title = options[:title]
+      else
+        raise Prawn::Errors::RequiredOption,
+          "\nTitle is a required option for page"
+      end
+      add_outline_item(title, options)
+    end
+
+    private
+
+    # The Outline dictionary (12.3.3) for this document.  It is
+    # lazily initialized, so that documents that do not have an outline
+    # do not incur the additional overhead.
+    def root
+      document.state.store.root.data[:Outlines] ||=
+        document.ref!(PDF::Core::OutlineRoot.new)
+    end
+
+    def add_outline_item(title, options, &block)
+      outline_item = create_outline_item(title, options)
+      establish_relations(outline_item)
+      increase_count
+      set_variables_for_block(outline_item, block)
+      yield if block
+      reset_parent(outline_item)
+    end
+
+    def create_outline_item(title, options)
+      outline_item = PDF::Core::OutlineItem.new(title, parent, options)
+
+      case options[:destination]
+      when Integer
+        page_index = options[:destination] - 1
+        outline_item.dest = [document.state.pages[page_index].dictionary, :Fit]
+      when Array
+        outline_item.dest = options[:destination]
+      end
+
+      outline_item.prev = prev if @prev
+      items[title] = document.ref!(outline_item)
+    end
+
+    def establish_relations(outline_item)
+      prev.data.next = outline_item if prev
+      parent.data.first = outline_item unless prev
+      parent.data.last = outline_item
+    end
+
+    def increase_count
+      counting_parent = parent
+      while counting_parent
+        counting_parent.data.count += 1
+        counting_parent =
+          if counting_parent == root
+            nil
+          else
+            counting_parent.data.parent
+          end
+      end
+    end
+
+    def set_variables_for_block(outline_item, block)
+      self.prev = block ? nil : outline_item
+      self.parent = outline_item if block
+    end
+
+    def reset_parent(outline_item)
+      if parent == outline_item
+        self.prev = outline_item
+        self.parent = outline_item.data.parent
+      end
+    end
+
+    def insert_section(nxt, &block)
+      last = @parent.data.last
+      if block
+        yield
+      end
+      adjust_relations(nxt, last)
+      reset_root_positioning
+    end
+
+    def adjust_relations(nxt, last)
+      if nxt
+        nxt.data.prev = @prev
+        @prev.data.next = nxt
+        @parent.data.last = last
+      end
+    end
+
+    def reset_root_positioning
+      @parent = root
+      @prev = root.data.last
+    end
+  end
+end

data/prawn-2.5.0/lib/prawn/repeater.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+module Prawn
+  class Document # rubocop: disable Style/Documentation
+    # A list of all repeaters in the document.
+    # See {repeat} for details.
+    #
+    # @private
+    # @return [Array]
+    def repeaters
+      @repeaters ||= []
+    end
+
+    # @group Experimental API
+
+    # Provides a way to execute a block of code repeatedly based on
+    # a `page_filter`. Since Stamp is used under the hood, this method is very
+    # space efficient.
+    #
+    # Also accepts an optional second argument for dynamic content which
+    # executes the code in the context of the filtered pages without using
+    # a Stamp.
+    #
+    # @example
+    #   Prawn::Document.generate("repeat.pdf", skip_page_creation: true) do
+    #     repeat :all do
+    #       draw_text "ALLLLLL", at: bounds.top_left
+    #     end
+    #
+    #     repeat :odd do
+    #       draw_text "ODD", at: [0, 0]
+    #     end
+    #
+    #     repeat :even do
+    #       draw_text "EVEN", at: [0, 0]
+    #     end
+    #
+    #     repeat [1, 2] do
+    #       draw_text "[1, 2]", at: [100, 0]
+    #     end
+    #
+    #     repeat 2..4 do
+    #       draw_text "2..4", at: [200, 0]
+    #     end
+    #
+    #     repeat(lambda { |pg| pg % 3 == 0 }) do
+    #       draw_text "Every third", at: [250, 20]
+    #     end
+    #
+    #     10.times do
+    #       start_new_page
+    #       draw_text "A wonderful page", at: [400, 400]
+    #     end
+    #
+    #     repeat(:all, dynamic: true) do
+    #       text page_number, at: [500, 0]
+    #     end
+    #   end
+    #
+    # @param page_filter [:all, :odd, :even, Array<Integer>, Range, Proc]
+    #   Pages to draw the repeater content on.
+    #
+    #   Available page filters are:
+    #
+    #   - `:all` -- repeats on every page.
+    #   - `:odd` -- repeats on odd pages.
+    #   - `:even` -- repeats on even pages.
+    #   - Array of Integers -- repeats on every page listed in the array.
+    #   - Range -- repeats on every page included in the range.
+    #   - Proc -- yields page number and repeats for true return values.
+    # @param options [Hash]
+    # @option options :dynamic [Boolean] (false)
+    #   A dynamic repeater executes block on every matched page. A static
+    #   repeater uses {stamp} to prepare the content (runs the block once) and
+    #   puts it on every matched page.
+    # @return [void]
+    def repeat(page_filter, options = {}, &block)
+      dynamic = options.fetch(:dynamic, false)
+      repeaters << Prawn::Repeater.new(
+        self, page_filter, dynamic, &block
+      )
+    end
+  end
+
+  # Repeater object.
+  #
+  # @private
+  class Repeater
+    class << self
+      attr_writer :count
+
+      # Repeater counter.
+      #
+      # It's not an exact number of repeaters but a counter used to generate
+      # unique repeater stamp names.
+      #
+      # @return [Integer]
+      def count
+        @count ||= 0
+      end
+    end
+
+    attr_reader :name
+
+    def initialize(document, page_filter, dynamic = false, &block)
+      @document = document
+      @page_filter = page_filter
+      @dynamic = dynamic
+      @stamp_name = "prawn_repeater(#{Repeater.count})"
+      @document.create_stamp(@stamp_name, &block) unless dynamic
+      @block = block if dynamic
+      @graphic_state = document.state.page.graphic_state.dup
+
+      Repeater.count += 1
+    end
+
+    # Should this repeater run on this page?
+    #
+    # @param page_number [Integer]
+    # @return [Boolean]
+    def match?(page_number)
+      @document.page_match?(@page_filter, page_number)
+    end
+
+    # Run repeater.
+    #
+    # @param page_number [Integer]
+    # @return [void]
+    def run(page_number)
+      if !@dynamic
+        @document.stamp(@stamp_name) if match?(page_number)
+      elsif @block && match?(page_number)
+        @document.save_graphics_state(@graphic_state) do
+          @document.__send__(:freeze_stamp_graphics)
+          @block.call
+        end
+      end
+    end
+  end
+end

data/prawn-2.5.0/lib/prawn/security/arcfour.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+# Implementation of the "ARCFOUR" algorithm ("alleged RC4 (tm)"). Implemented
+# as described at:
+# http://www.mozilla.org/projects/security/pki/nss/draft-kaukonen-cipher-arcfour-03.txt
+#
+# "RC4" is a trademark of RSA Data Security, Inc.
+#
+# @private
+class Arcfour
+  def initialize(key)
+    # Convert string key to Array of integers
+    key = key.unpack('c*') if key.is_a?(String)
+
+    # 1. Allocate an 256 element array of 8 bit bytes to be used as an S-box
+    # 2. Initialize the S-box.  Fill each entry first with it's index
+    @sbox = (0..255).to_a
+
+    # 3. Fill another array of the same size (256) with the key, repeating
+    #    bytes as necessary.
+    s2 = []
+    while s2.length < 256
+      s2 += key
+    end
+    s2 = s2[0, 256]
+
+    # 4. Set j to zero and initialize the S-box
+    j = 0
+    (0..255).each do |i|
+      j = (j + @sbox[i] + s2[i]) % 256
+      @sbox[i], @sbox[j] = @sbox[j], @sbox[i]
+    end
+
+    @i = @j = 0
+  end
+
+  # Encrypt string.
+  #
+  # @param string [String]
+  # @return [String]
+  def encrypt(string)
+    string.unpack('c*').map { |byte| byte ^ key_byte }.pack('c*')
+  end
+
+  private
+
+  # Produces the next byte of key material in the stream (3.2 Stream Generation)
+  def key_byte
+    @i = (@i + 1) % 256
+    @j = (@j + @sbox[@i]) % 256
+    @sbox[@i], @sbox[@j] = @sbox[@j], @sbox[@i]
+    @sbox[(@sbox[@i] + @sbox[@j]) % 256]
+  end
+end