prawn-extras 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 0674038f691b219cab7a8e3974ff74d97bba0c95
+  data.tar.gz: 996793d3a1e293886c9553b5cdbb6205ada35039
+SHA512:
+  metadata.gz: 5f4dc02abfc5e4163615539cda0f3423b3f1dfb2ac14dfd9449e0a3ac5f24697cb2c78a91ec7e4b6bd8eeec1e4801a95d12bfeae7c9ed0e053ba13611b506749
+  data.tar.gz: 977b5273cd914f7bdaa72a502afeaf5e09e1e466879d7f4cabe946fc7d6c2d78affea2046de91d74d762d75b9230f04fdce905bef1a7983dc923e54214216f04

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2016 Rodrigo Castro
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,32 @@
+# Prawn::Extras
+Short description and motivation.
+
+## Usage
+Just install it and all extra stuff below will be available!
+
+TODO: List all the great extra stuff I just mentioned
+
+## Installation
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'prawn-extras'
+```
+
+And then execute:
+```bash
+$ bundle
+```
+
+Or install it yourself as:
+```bash
+$ gem install prawn-extras
+```
+
+## Contributing
+All contributions are welcome, please raise an issue for any problems or
+suggestions.
+
+## License
+The gem is available as open source under the terms of the
+[MIT License](http://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,22 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Prawn::Extras'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.md')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+APP_RAKEFILE = File.expand_path('../spec/dummy/Rakefile', __FILE__)
+load 'rails/tasks/engine.rake'
+
+load 'rails/tasks/statistics.rake'
+
+require 'bundler/gem_tasks'

data/lib/prawn/extras/box.rb

@@ -0,0 +1,176 @@
+module Prawn
+  module Extras
+    module Box
+      delegate :top_left, :width, :height, to: :bounds
+
+      def last_created_box
+        @last_created_box ||= nil
+      end
+
+      # Retorna um valor absoluto de width correspondente a porcentagem indicada,
+      # nos limites do relatório, que é entre '0' e 'bounds.width'.
+      # O parâmetro value deve ser um valor entre 0 e 100.
+      # Ex: chamando percent_w(50) fora de um bounding_box: 50% da width da página
+      # Ex: chamando percent_w(9) em um bounding_box: 9% da width do bounding_box
+      def percent_w(value)
+        # Faz o clamp no valor para garantir que ele fique entre 0% e 100%
+        clamped_value = [0, value, 100].sort[1]
+        bounds.width * (clamped_value / 100.0)
+      end
+
+      # Retorna um valor absoluto de height correspondente a porcentagem indicada,
+      # nos limites do relatório, que é entre 'bounds.height' e '0'.
+      # O parâmetro value deve ser um valor entre 0 e 100.
+      # Ex: chamando percent_h(50) fora de um bounding_box: 50% da height da página
+      # Ex: chamando percent_h(9) em um bounding_box: 9% da height do bounding_box
+      def percent_h(value)
+        # Faz o clamp no valor para garantir que ele fique entre 0% e 100%
+        clamped_value = [0, value, 100].sort[1]
+        bounds.height * (clamped_value / 100.0)
+      end
+
+      # Retorna um valor absoluto de height correspondente à height restante abaixo
+      # de base_height. base_height deve ser um objeto do tipo Bounds
+      def remaining_height(base_height)
+        base_height.anchor[1] - bounds.anchor[1]
+      end
+
+      # Cria um bounding_box. Esse método é basicamente um alias de bounding_box,
+      # exceto que oferece mais flexibilidade e facilidade na entrada dos
+      # parâmetros, permitindo expressar width e height como porcentagens, ex:
+      # box(top_left, '25%', '100%') {}
+      def box(position, width, height, options = {})
+        size = build_size_options(position, width, height)
+        box = bounding_box(position, size) do
+          padding(options[:padding] || [0, 0, 0, 0]) { yield if block_given? }
+        end
+        @last_created_box = box unless options[:dont_track]
+        box
+      end
+
+      # Cria um novo bounding_box posicionado à direita do bounding_box pai.
+      # O comportamento é o mesmo de chamar 'bounding_box', e aceita um bloco.
+      # Este método retorna o bounding_box criado, para ser referenciado depois.
+      # O parâmetro espaçamento é opcional e indica o tamanho do espaço entre a
+      # direita do pai e a esquerda do novo bounding_box.
+      def box_beside(origin_box, width, height, options = {}, &block)
+        posicao = position_beside(origin_box, options[:gutter] || 0)
+        box(posicao, width, height, options, &block)
+      end
+
+      # Cria um novo bounding_box posicionado à direita do último box criado.
+      # Funciona como o método acima box_a_direita_de, exceto que ele pega o box
+      # automaticamente. Caso não exista um último box criado (esse foi o primeiro),
+      # ele irá posicionar o box no top_left.
+      def box_beside_previous(width, height, options = {}, &block)
+        box_beside(last_created_box, width, height, options, &block)
+      end
+
+      # Cria um novo bounding_box posicionado abaixo do bounding_box pai.
+      # O comportamento é o mesmo de chamar 'bounding_box', e aceita um bloco.
+      # Este método retorna o bounding_box criado, para ser referenciado depois.
+      # O parâmetro espaçamento é opcional e indica o tamanho do espaço entre o
+      # limite inferior do pai e o topo do novo bounding_box.
+      def box_below(origin_box, width, height, options = {}, &block)
+        posicao = position_below(origin_box, options[:gutter] || 0)
+        box(posicao, width, height, options, &block)
+      end
+
+      # Cria um novo bounding_box posicionado abaixo do último box criado.
+      # Funciona como o método acima box_abaixo_de, exceto que ele pega o box
+      # automaticamente. Caso não exista um último box criado (esse foi o primeiro),
+      # ele irá posicionar o box no top_left.
+      def box_below_previous(width, height, opcoes = {}, &block)
+        box_below(last_created_box, width, height, opcoes, &block)
+      end
+
+      # Retorna uma posição (para um novo bounding_box), imediatamente à direita
+      # de um bounding_box pai, alinhado verticalmente ao topo do pai.
+      # O parâmetro espaçamento é opcional e indica o tamanho do espaço entre a
+      # direita do pai e a esquerda dessa nova posição.
+      def position_beside(origin_box, gutter = 0)
+        correct_origin = Array(origin_box).first
+        return top_left if origin_box.nil?
+        diff = [gutter - bounds.anchor[0], -bounds.anchor[1]]
+        sum_dimensions(correct_origin.absolute_top_right, diff)
+      end
+
+      # Retorna uma posição (para um novo bounding_box), imediatamente abaixo de um
+      # bounding_box pai, alinhado horizontalmente com a esquerda do pai.
+      # O parâmetro espaçamento é opcional e indica o tamanho do espaço entre o
+      # limite inferior do pai e o topo dessa nova posição.
+      def position_below(origin_box, gutter = 0)
+        correct_origin = Array(origin_box).first
+        return top_left if correct_origin.nil?
+        diff = [-@margin[1], -gutter.to_f - @margin[2]]
+        sum_dimensions(correct_origin.absolute_bottom_left, diff)
+      end
+
+      # Cria um bounding box para agir como se fosse um padding (igual ao do CSS).
+      # Tamanho pode ser um número, que será aplicado aos quatro lados, ou pode ser
+      # um array com 4 valores, para o padding de cima, direita, baixo e esquerda,
+      # nessa ordem.
+      def padding(values)
+        values = build_padding_values(values)
+        posicao = padding_position(values)
+        width, height = padding_size(values)
+        bounding_box(posicao, width: width, height: height) { yield }
+      end
+
+      protected
+
+      # Checa se o valor da width é uma string e contém o caractere %. Se tiver,
+      # fazer o cálculo correto da width, senão, retornar a mesma width.
+      # O cálculo da width é relativo ao espaço horizontal global. Para fazer ele
+      # ser relativo ao espaço restante, basta adicionar um 'l' depois de '%'.
+      # Espaço restante é o espaço que sobrou após a posição passada no parâmetro,
+      # ou seja, se o pai ocupar metade da width da página, o valor em porcentagem
+      # será relativo aos 50% livres, e não à width total da página.
+      def t_width(position, width)
+        return width unless width.to_s.include? '%'
+        valor = percent_w(width.to_f) # Valor percentual global
+        return valor unless width.to_s.include? 'l' # 'l' de 'local'
+        valor * (1.0 - (position.first / bounds.width)) # Valor percentual relativo
+      end
+
+      # Checa se o valor da height é uma string e contém o caractere %. Se tiver,
+      # fazer o cálculo correto da width, senão, retornar a mesma height.
+      # O cálculo da height é relativo ao espaço vertical global. Para fazer ele
+      # ser relativo ao espaço restante, basta adicionar um 'l' depois de '%'.
+      # Espaço restante é o espaço que sobrou após a posição passada no parâmetro,
+      # ou seja, se o pai ocupar metade da height da página, o valor em porcentagem
+      # será relativo aos 50% livres, e não à height total da página.
+      def t_height(position, height)
+        return height unless height.to_s.include? '%'
+        valor = percent_h(height.to_f) # Valor percentual global
+        return valor unless height.to_s.include? 'l' # 'l' de 'local'
+        valor * (position.last / bounds.height) # Valor percentual relativo
+      end
+
+      def build_padding_values(values)
+        values = [values.to_i] * 4 unless values.is_a? Array
+        values.map(&:to_i)[0..3]
+      end
+
+      def padding_position(values)
+        [values[3], bounds.top - values[0]]
+      end
+
+      def padding_size(values)
+        horizontal_padding = values[1] + values[3]
+        vertical_padding = values[0] + values[2]
+        [bounds.width - horizontal_padding, bounds.height - vertical_padding]
+      end
+
+      def sum_dimensions(dim_a, dim_b)
+        [dim_a, dim_b].transpose.map { |x| x.reduce(:+) }
+      end
+
+      def build_size_options(position, width, height)
+        { width: t_width(position, width), height: t_height(position, height) }
+      end
+    end
+  end
+end
+
+Prawn::Document.include Prawn::Extras::Box

data/lib/prawn/extras/dynamic_repeater.rb

@@ -0,0 +1,87 @@
+module Prawn
+  module Extras
+    # ==============================================================================
+    #
+    # Esse módulo contém helpers para facilitar a inserção de conteúdo dinâmico
+    # em repeaters que são dinâmicos.
+    #
+    # Esses métodos controlam um hash de valores mapeados pelo número da página.
+    # Utilizar esse repeater_values é necessário, pois ao contrário do repeater
+    # normal, que o Prawn renderiza na hora e mantém o mesmo até o final, com o
+    # repeater dinâmico ele deixa para renderizá-lo no final de tudo, por isso
+    # se o valor de alguma variável mudar no meio da geração do relatório, o
+    # repeater dinâmico não terá acesso ao valor anterior.
+
+    # Exemplo de utilização: Deseja-se agrupar alunos por curso, e cada vez que
+    # o curso muda há uma quebra de página, de forma que o nome do curso deve
+    # ser impresso no cabeçalho do relatório, sempre o curso do grupo atual de
+    # alunos.
+    #
+    # Nesse caso, no cabeçalho terá algo do tipo:
+    # 'text(valor_na_pagina(:nome_curso, page_number))'
+    #
+    # E, dentro do '.each' que itera sobre os cursos, algo do tipo:
+    # cursos.each do |curso|
+    #   start_new_line
+    #   set_valor_na_pagina(:nome_curso, curso, page_number)
+    #   /* Tabela de alunos */
+    # end
+    #
+    # ==========================================================================
+    module DynamicRepeater
+      # Saves a named value for a specific page of the generated PDF. This will
+      # save the value for the specified page down to the first page of the
+      # document (page 1), or until there's already another value saved for a
+      # previous page.
+      #
+      # Example:
+      #
+      # store_value_in_page(:name, 'John', 3)
+      #
+      # This will save the value "John" at the :name key for the pages 1, 2
+      # and 3. Any subsequent calls to this method (for the same key) will not
+      # override these values.
+      #
+      def store_value_in_page(key, value, page = page_number)
+        page.downto(1).each do |page_index|
+          next if repeater_values(key).keys.include?[page_index]
+          repeater_values(key)[page_index] = value
+        end
+      end
+
+      # Returns the value for a key at a specific page. If the page is greater
+      # than the highest saved page, the highest value is returned.
+      #
+      # Examples:
+      #
+      # save_repeater_value(:name, 'John', 3)
+      # save_repeater_value(:name, 'Jane', 5)
+      #
+      # value_in_page(:name, 1) => "John"
+      # value_in_page(:name, 2) => "John"
+      # value_in_page(:name, 3) => "John"
+      # value_in_page(:name, 4) => "Jane"
+      # value_in_page(:name, 5) => "Jane"
+      # value_in_page(:name, 6) => "Jane"
+      # value_in_page(:name, -1) => ""
+      #
+      def value_in_page(key, page, default_value = '')
+        repeater_values(key)[[page, max_index(key).min]] || default_value
+      end
+
+      private
+
+      def max_index(key)
+        repeater_values(key).keys.max
+      end
+
+      def repeater_values(key)
+        @repeater_values ||= {}
+        @repeater_values[key] ||= {}
+        @repeater_values[key]
+      end
+    end
+  end
+end
+
+Prawn::Document.include Prawn::Extras::DynamicRepeater

data/lib/prawn/extras/engine.rb

@@ -0,0 +1,7 @@
+module Prawn
+  module Extras
+    class Engine < ::Rails::Engine
+      isolate_namespace Prawn::Extras
+    end
+  end
+end

data/lib/prawn/extras/grid.rb

@@ -0,0 +1,88 @@
+module Prawn
+  module Extras
+    # Módulo para gerar um grid de células de tamanhos definidos. Parecido com uma
+    # tabela HTML, mas com maior facilidade e flexibilidade para fazer colspans.
+
+    # Não deve ser usado para dados tabulares, para isso deve-se usar o Prawn Table.
+    #
+    # O método gerar grid gera um grid com o número de linhas e colunas passados nos
+    # parâmetros. O tamanho será 100% do bounding_box que ele se encontra, exceto
+    # quando houver um padding, nesse caso o tamanho será o do box menos o padding.
+    #
+    # Para gerar um grid de, por exemplo, 4 colunas e 3 linhas, chame:
+    #
+    #   gerar_grid(4, 3, opcoes_que_sao_opcionais_e_podem_ser_omitidas) do
+    #     campo_grid(linha, coluna, titulo, texto)
+    #   end
+    #
+    # Para gerar cada célula individualmente, use o método campo_grid ou os métodos
+    # derivados desse. O parâmetro linha é a linha do grid aonde o campo vai ficar,
+    # e o parâmetro colunas pode ser tanto um número quando um array com 2
+    # elementos. Se for um número, a coluna vai ser a do número, mas se for um
+    # array, como por exemplo [0, 2], significa que a célula vai ocupar as colunas
+    # 0, 1 e 2 da linha selecionada. Isso é equivalente ao colspan do HTML.
+    #
+    # Ilustração de um grid de 4 colunas, 3 linhas com um padding de, por exemplo,
+    # 10pt (para exemplificar, digamos que 10pt = 1 linha de comentário):
+    #
+    # Bounding Box:
+    # |------------------------------------------------------------------------|
+    # |   Grid:                                                                |
+    # |   |---------------|---------------|---------------|---------------|    |
+    # |   | Cell 1        | Cell 2        | ...           | Index: [0, 3] |    |
+    # |   |---------------|---------------|---------------|---------------|    |
+    # |   | Index: [1, 0] | Index: [1, 1] | Index: [1, 2] | Index: [1, 3] |    |
+    # |   |---------------|---------------|---------------|---------------|    |
+    # |   | Index: [2, 0] | Index: [2, 1] | Index: [2, 2] | Index: [2, 3] |    |
+    # |   |---------------|---------------|---------------|---------------|    |
+    # |                                                                        |
+    # |------------------------------------------------------------------------|
+    #
+    # Exemplos: gerar células no grid acima:
+    #
+    #   campo_grid(0, 1)      ==> Corresponde à Célula 2
+    #   campo_grid(1, [0, 3]) ==> Corresponde a toda a segunda linha
+    #
+    # Na hora de gerar o grid, algumas opções podem ser passadas:
+    #
+    # Padding: Adiciona um padding no grid inteiro em relação ao bonding_box que
+    #          contém o grid.
+    # Leading: Usa o leading escolhido no grid. O leading é resetado para o valor
+    #          anterior quando o grid terminar de ser definido.
+    # Gutter:  O espaço entre as células, em pts. Funciona como o cellspacing da tag
+    #          <table> do HTML.
+    module Grid
+      include Text
+      include Box
+
+      def define_grid_block(columns, rows, options = {})
+        options = build_grid_options(columns, rows, options)
+        padding(options.delete(:padding)) do
+          leading = options.delete(:leading)
+          define_grid(options)
+          save_leading(leading) { yield }
+        end
+      end
+
+      def grid_cell(row, columns)
+        columns = [columns] * 2 unless columns.is_a? Array
+        grid([row, columns[0]], [row, columns[1]]).bounding_box { yield }
+      end
+
+      def text_grid_cell(row, columns, label_or_text, text = nil)
+        grid_cell(row, columns) do
+          titled_text(label_or_text, text) if text
+          text_box(label_or_text) unless text
+        end
+      end
+
+      protected
+
+      def build_grid_options(columns, rows, options)
+        options.merge(columns: columns, rows: rows)
+      end
+    end
+  end
+end
+
+Prawn::Document.include Prawn::Extras::Grid

data/lib/prawn/extras/text.rb

@@ -0,0 +1,127 @@
+module Prawn
+  module Extras
+    module Text
+      # Changes the font family, style, size and leading. When a block is used,
+      # the font is applied transactionally and is rolled back when the block
+      # exits.
+      #
+      # The accepted options are:
+      #
+      # family: A string that can be one of the 14 built-in fonts supported by
+      # PDF, or the location of a TTF file. The Font::AFM::BUILT_INS array
+      # specifies the valid built in font values.
+      #
+      # leading: A number that sets the document-wide text leading.
+      #
+      # size: A number indicating the font size, in points.
+      #
+      # style: The font style. To use the :style option you need to map those
+      # font styles to their respective font files. See font_families for
+      # more information.
+      #
+      def switch_font(options)
+        return font_and_leading(options) unless block_given?
+        save_leading { font_and_leading(options) { yield } }
+      end
+
+      # Sets the font to the same as before, but removing italic or bold style.
+      # All options from set_font may also be used here.
+      def regular_font(options = {}, &block)
+        switch_font(options.merge(style: :normal), &block)
+      end
+
+      # Sets the font to the same as before, but applying the bold style.
+      # All options from set_font may also be used here.
+      def bold_font(options = {}, &block)
+        switch_font(options.merge(style: :bold), &block)
+      end
+
+      # Sets the font to the same as before, but applying the italic style.
+      # All options from set_font may also be used here.
+      def italic_font(options = {}, &block)
+        switch_font(options.merge(style: :italic), &block)
+      end
+
+      # Transactionally changes the fill color, rolling back the previous color
+      # when the block exits.
+      def save_color(new_color)
+        current_color = fill_color
+        fill_color(new_color)
+        yield
+        fill_color current_color
+      end
+
+      # Outputs a horizontal line, similar to the HMTL equivalent <hr>, at the
+      # current cursor position.
+      #
+      # The padding parameter is optional, and when specified sets a
+      # horizontal padding before and after the sides of the line with the
+      # corresponding size in points. This reduces the width of the line by a
+      # factor of 2 * padding.
+      #
+      # This method returns the Document, and therefore is chainable with other
+      # Document methods.
+      #
+      def horizontal_line(padding = 0)
+        left_position = [padding, cursor]
+        right_position = [bounds.width - padding, cursor]
+        stroke_line(left_position, right_position)
+        self
+      end
+
+      # Outputs one or more vertical lines, at the specified horizontal
+      # position, going all the way from the top to the bottom of the current
+      # bounds object.
+      #
+      # This method returns the Document, and therefore is chainable with other
+      # Document methods.
+      #
+      def vertical_line(*horizontal_positions)
+        horizontal_positions.each do |horiz_pos|
+          stroke_line([horiz_pos, percent_h(100)], [horiz_pos, 0])
+        end
+        self
+      end
+
+      # Outputs the text prepended with a bold title. It is possible to change
+      # the title to italic by specifying the appropriate :styles option.
+      #
+      # Example:
+      #
+      # titled_text('Name', 'John') => "Name: John", where "Name" is bold
+      #
+      def titled_text(title, text, options = {})
+        style = options.delete(:styles) || [:bold]
+        title_options = { styles: style, text: "#{t(title)}: " }
+        formatted_text_box([title_options, { text: t(text) }], options)
+      end
+
+      # Alias to the corresponding i18n method, with the additional caveat that,
+      # if a String is passed, the same string will be returned. It will only
+      # try to translate the text if text_or_key parameter is a Symbol.
+      #
+      # It also namespaces the i18n context to the @i18n_scope variable.
+      #
+      def t(text_or_key, options = {})
+        return text_or_key.to_s unless text_or_key.is_a?(Symbol)
+        I18n.t(text_or_key, { scope: @i18n_scope }.merge(options))
+      end
+
+      protected
+
+      def save_leading(new_leading = nil)
+        leading = default_leading
+        default_leading(new_leading) if new_leading.present?
+        yield
+        default_leading(leading)
+      end
+
+      def font_and_leading(options, &block)
+        default_leading(options.delete(:leading)) if options[:leading]
+        font(options[:family] || 'Helvetica', options, &block)
+      end
+    end
+  end
+end
+
+Prawn::Document.include Prawn::Extras::Text

data/lib/prawn/extras/version.rb

@@ -0,0 +1,5 @@
+module Prawn
+  module Extras
+    VERSION = '0.1.0'.freeze
+  end
+end

data/lib/prawn/extras.rb

@@ -0,0 +1,11 @@
+require 'prawn/extras/engine'
+require 'prawn/document'
+require 'prawn/extras/box'
+require 'prawn/extras/text'
+require 'prawn/extras/grid'
+require 'prawn/extras/dynamic_repeater'
+
+module Prawn
+  module Extras
+  end
+end

metadata

@@ -0,0 +1,96 @@
+--- !ruby/object:Gem::Specification
+name: prawn-extras
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Rodrigo Castro
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-12-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.2.0
+- !ruby/object:Gem::Dependency
+  name: prawn
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Extra functions for the great Prawn gem
+email:
+- rod.c.azevedo@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- Rakefile
+- lib/prawn/extras.rb
+- lib/prawn/extras/box.rb
+- lib/prawn/extras/dynamic_repeater.rb
+- lib/prawn/extras/engine.rb
+- lib/prawn/extras/grid.rb
+- lib/prawn/extras/text.rb
+- lib/prawn/extras/version.rb
+homepage: https://github.com/roooodcastro/prawn-extras
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: Extra functions for the great Prawn gem
+test_files: []