RubyGems - papercraft - Versions diffs - 0.8 → 0.9 - Mend

papercraft 0.8 → 0.9

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (9) hide show

checksums.yaml CHANGED Viewed

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4404d5b6a84318eab12f0c7d13b4c3be4355c8ebb36b6a3fbd65c6f62af8f361
-  data.tar.gz: 175a60878f6770ae52d956b6e7c72326af5a0db9faefecae2bd2c3e2fb406f97
+  metadata.gz: e1f7aa5872a78830c1a5662f055639ae2012b5b9d0f029640dce041f58d1ef4e
+  data.tar.gz: 0c5acc8b14254c63db2132caab42ce003a8ae4713ae6daea7225d0390a420219
 SHA512:
-  metadata.gz: 307d3e37cb946b0adb54fa2d6b2939ec0016cc81205f3b4d4dfb6c01d57b65b1f609024b0499f6b5717c858b6dc5aea472f0b82585df44f761f4ac9fdb8c2eae
-  data.tar.gz: 96162c1707785e3d54ce6cb55bd9a5801658b92d294e28b4168b78ee68e49027ec945eab13d47142382e458fdd33c6d26182a7a08bfc403038c170a8f119984f
+  metadata.gz: 02bf1f7bc1300f4fa7871a6942c6a2eae2dd2f8202c7f3cc354171806f82e8a68262c3ca5e2232b7b6dcf6788a33b134b5811641561fa5baba3b7c342643b082
+  data.tar.gz: 97a68a0f854f631a6a36b52a350faae4b1da1e337b27701209c6eec9dc16c62856555fdff3ab3d8f33e144e7fed8dc892b22433f38dd3f951a04010f710b63c4

data/CHANGELOG.md CHANGED Viewed

@@ -1,3 +1,13 @@
+## 0.9 2021-12-23
+- Add support for emitting Markdown
+- Add support for passing proc as argument to `#H` and `#X`
+- Deprecate `Encoding` module
+## 0.8.1 2021-12-22
+- Fix gemspec
 ## 0.8 2021-12-22
 - Cleanup and refactor code

data/README.md CHANGED Viewed

@@ -2,26 +2,36 @@
 [INSTALL](#installing-papercraft) |
 [TUTORIAL](#getting-started) |
-[EXAMPLES](examples) |
-[REFERENCE](#api-reference)
+[DOCS](https://www.rubydoc.info/gems/papercraft)
 ## What is Papercraft?
+```ruby
+require 'papercraft'
+page = H { |*args|
+  html {
+    head { }
+    body { emit_yield *args }
+  }
+}
+hello = H.apply { |name| h1 "Hello, #{name}!" }
+hello.render('world')
+#=> "<html><head/><body><h1>Hello, world!</h1></body></html>"
+```
 Papercraft is an HTML templating engine for Ruby that offers the following
 features:
-- HTML templating using plain Ruby syntax
+- HTML and XML templating using plain Ruby syntax
 - Minimal boilerplate
 - Mix logic and tags freely
-- Use global and local contexts to pass values to reusable components
-- Automatic HTML escaping
+- Automatic HTML and XML escaping
 - Composable components
+- Explicit parameter passing to nested components
 - Higher order components
-- Built-in support for rendering Markdown
-> **Note** Papercraft is a new library and as such may be missing features and
-> contain bugs. Also, its API may change unexpectedly. Your issue reports and
-> code contributions are most welcome!
+- Built-in support for rendering [Markdown](#emitting-markdown)
 With Papercraft you can structure your templates as nested HTML components, in a
 somewhat similar fashion to React.
@@ -48,7 +58,8 @@ To use Papercraft in your code just require it:
 require 'papercraft'
 ```
-To create a template use `Papercraft.new` or the global method `Kernel#H`:
+To create a template use `Papercraft::Component.new` or the global method
+`Kernel#H`:
 ```ruby
 # can also use Papercraft.new
@@ -114,8 +125,9 @@ H { p "foobar", class: 'important' }.render #=> "<p class=\"important\">foobar</
 ## Template parameters
-Template parameters are specified as block parameters, and are passed to the
-template on rendering:
+In Papercraft, parameters are always passed explicitly. This means that template
+parameters are specified as block parameters, and are passed to the template on
+rendering:
 ```ruby
 greeting = H { |name| h1 "Hello, #{name}!" }
@@ -328,110 +340,43 @@ H { str 'hi&lo' }.render #=> "hi&amp;lo"
 ## Emitting Markdown
-To emit Markdown, use `#emit_markdown`:
+Markdown is rendered using the
+[Kramdown](https://kramdown.gettalong.org/index.html) gem. To emit Markdown, use
+`#emit_markdown`:
 ```ruby
 template = H { |md| div { emit_markdown md } }
-template.render("Here's some *Markdown*") #=> "<div>Here's some <em>Markdown</em></div>"
+template.render("Here's some *Markdown*") #=> "<div><p>Here's some <em>Markdown</em><p>\n</div>"
 ```
-## Some interesting use cases
-Papercraft opens up all kinds of new possibilities when it comes to putting
-together pieces of HTML. Feel free to explore the API!
+[Kramdown
+options](https://kramdown.gettalong.org/options.html#available-options) can be
+specified by adding them to the `#emit_markdown` call:
-### A higher-order list component
+```ruby
+template = H { |md| div { emit_markdown md, auto_ids: false } }
+template.render("# title") #=> "<div><h1>title</h1></div>"
+```
-Here's another demonstration of a higher-order component, a list component that
-takes an item component as an argument. The `List` component can be reused for
-rendering any kind of unordered list, and with any kind of item component:
+The default Kramdown options are:
 ```ruby
-List = ->(items, item_component) {
-  H {
-    ul {
-      items.each { |item|
-        with(item: item) {
-          li { emit item_component }
-        }
-      }
-    }
-  }
+{
+  entity_output: :numeric,
+  syntax_highlighter: :rouge,
+  input: 'GFM',
+  hard_wrap: false
 }
-TodoItem = H {
-  span item.text, class: item.completed ? 'completed' : 'pending'
-}
-def todo_list(items)
-  H {
-    div { List(items, TodoItem) }
-  }
-end
 ```
-## API Reference
-#### `Papercraft#initialize(**context, &block)` a.k.a. `Kernel#H`
-- `context`: local context hash
-- `block`: template block
+The deafult options can be configured by accessing
+`Papercraft::HTML.kramdown_options`:
-Initializes a new Papercraft instance. This method takes a block of template
-code, and an optional [local context](#local-context) in the form of a hash.
-The `Kernel#H` method serves as a shortcut for creating Papercraft instances.
-#### `Papercraft#render(**context)`
-- `context`: global context hash
-Renders the template with an optional [global context](#global-context)
-hash.
-#### Methods accessible inside template blocks
-#### `#<tag/component>(*args, **props, &block)`
-- `args`: tag arguments. For an HTML tag Papercraft expects a single `String`
-  argument containing the inner text of the tag.
-- `props`: hash of tag attributes
-- `block`: inner HTML block
-Adds a tag or component to the current template. If the method name starts with
-an upper-case letter, it is considered a [component](#templates-as-components).
-If a text argument is given for a tag, it will be escaped.
-#### `#cache(*vary, &block)`
-- `vary`: variables used in cached block. The given values will be used to
-  create a separate cache entry.
-- `block`: inner HTML block
-Caches the markup in the given block, storing it in the Papercraft cache store.
-If a cache entry for the given block is found, it will be used instead of
-invoking the block. If one or more variables given, those will be used to create
-a separate cache entry.
-#### `#context`
-Accesses the [global context](#global-context).
-#### `#emit(object)` a.k.a. `#e(object)`
-- `object`: `Proc`, `Papercraft` instance or `String`
-Adds the given object to the current template. If a `String` is given, it is
-rendered verbatim, i.e. without escaping.
-#### `html5(&block)`
-- `block`: inner HTML block
-Adds an HTML5 `doctype` tag, followed by an `html` tag with the given block.
-#### `#text(data)`
+```ruby
+Papercraft::HTML.kramdown_options[:auto_ids] = false
+```
-- `data` - text to add
+## Documentation
-Adds text without wrapping it in a tag. The text will be escaped.
+The complete documentation for this library can be found
+[here](https://www.rubydoc.info/gems/papercraft).

data/lib/papercraft/component.rb CHANGED Viewed

@@ -3,18 +3,19 @@
 require_relative './html'
 module Papercraft
   # Component represents a distinct, reusable HTML template. A component can
   # include other components, and also be nested inside other components.
   #
   # Since in Papercraft HTML is expressed using blocks (or procs,) the Component
   # class is simply a special kind of Proc, which has some enhanced
   # capabilities, allowing it to be easily composed in a variety of ways.
+  #
   # Components are usually created using the global methods `H` or `X`, for HTML
   # or XML templates, respectively:
   #
-  #   greeter = H { |name| h1 "Hello, #{name}!" } greeter.render('world') #=>
-  #   "<h1>Hello, world!</h1>"
+  #   greeter = H { |name| h1 "Hello, #{name}!" }
+  #   greeter.render('world') #=> "<h1>Hello, world!</h1>"
   #
   # Components can also be created using the normal constructor:
   #
@@ -23,9 +24,71 @@ module Papercraft
   #
   # In the component block, HTML elements are created by simply calling
   # unqualified methods:
+  #
+  #   page_layout = H {
+  #     html5 {
+  #       head {
+  #         title 'foo'
+  #       }
+  #       body {
+  #         h1 "Hello, world!"
+  #       }
+  #     }
+  #   }
+  #
+  # Papercraft components can take explicit parameters in order to render
+  # dynamic content. This can be in the form of regular or named parameters. The
+  # `greeter` template shown above takes a single `name` parameter. Here's how a
+  # anchor component could be implemented with named parameters:
+  #
+  #   anchor = H { |uri: , text: | a(text, href: uri) }
+  #
+  # The above component could later be rendered by passing the needed arguments:
+  #
+  #   anchor.render(uri: 'https://example.com', text: 'Example')
+  #
+  # ## Component Composition
+  #
+  # A component can be included in another component using the `emit` method:
+  #
+  #   links = H {
+  #     emit anchor, uri: '/posts',   text: 'Posts'
+  #     emit anchor, uri: '/archive', text: 'Archive'
+  #     emit anchor, uri: '/about',   text: 'About'
+  #   }
+  #
+  # Another way of composing components is to pass the components themselves as
+  # parameters:
+  #
+  #   links = H { |anchors|
+  #     anchors.each { |a| emit a }
+  #   }
+  #   links.render([
+  #     anchor.apply(uri: '/posts', text: 'Posts'),
+  #     anchor.apply(uri: '/archive', text: 'Archive'),
+  #     anchor.apply(uri: '/about', text: 'About')
+  #   ])
+  #
+  # The `#apply` method creates a new component, applying the given parameters
+  # such that the component can be rendered without parameters:
+  #
+  #   links_with_anchors = links.apply([
+  #     anchor.apply(uri: '/posts', text: 'Posts'),
+  #     anchor.apply(uri: '/archive', text: 'Archive'),
+  #     anchor.apply(uri: '/about', text: 'About')
+  #   ])
+  #   links_with_anchors.render
+  #
   class Component < Proc
-    # Initializes a component with the given block
-    # @param mode [Symbol] local context
+    # Determines the rendering mode: `:html` or `:xml`.
+    attr_accessor :mode
+    # Initializes a component with the given block. The rendering mode (HTML or
+    # XML) can be passed in the `mode:` parameter. If `mode:` is not specified,
+    # the component defaults to HTML.
+    #
+    # @param mode [:html, :xml] rendering mode
     # @param block [Proc] nested HTML block
     def initialize(mode: :html, &block)
       @mode = mode
@@ -34,7 +97,9 @@ module Papercraft
     H_EMPTY = {}.freeze
-    # Renders the associated block and returns the string result
+    # Renders the template with the given parameters and or block, and returns
+    # the string result.
+    #
     # @param context [Hash] context
     # @return [String]
     def render(*a, **b, &block)
@@ -51,6 +116,24 @@ module Papercraft
       raise Papercraft::Error, e.message
     end
+    # Creates a new component, applying the given parameters and or block to the
+    # current one. Application is one of the principal methods of composing
+    # components, particularly when passing inner components as blocks:
+    #
+    #   article_wrapper = H {
+    #     article {
+    #       emit_yield
+    #     }
+    #   }
+    #   wrapped_article = article_wrapper.apply {
+    #     h1 'Article title'
+    #   }
+    #   wrapped_article.render #=> "<article><h1>Article title</h1></article>"
+    #
+    # @param *a [<any>] normal parameters
+    # @param **b [Hash] named parameters
+    # @param &block [Proc] inner block
+    # @return [Papercraft::Component] applied component
     def apply(*a, **b, &block)
       template = self
       if block
@@ -64,6 +147,10 @@ module Papercraft
       end
     end
+    # Returns the Renderer class used for rendering the templates, according to
+    # the component's mode.
+    #
+    # @return [Papercraft::Renderer] Renderer used for rendering the component
     def renderer_class
       case @mode
       when :html

data/lib/papercraft/html.rb CHANGED Viewed

@@ -1,11 +1,14 @@
 # frozen_string_literal: true
-require_relative './html'
+require 'kramdown'
+require 'rouge'
+require 'kramdown-parser-gfm'
-module Papercraft
-  # Markup extensions
+module Papercraft
+  # HTML Markup extensions
   module HTML
     # Emits the p tag (overrides Object#p)
+    #
     # @param text [String] text content of tag
     # @param props [Hash] tag attributes
     # @para block [Proc] nested HTML block
@@ -16,7 +19,8 @@ module Papercraft
     S_HTML5_DOCTYPE = '<!DOCTYPE html>'
-    # Emits an HTML5 doctype tag and an html tag with the given block
+    # Emits an HTML5 doctype tag and an html tag with the given block.
+    #
     # @param block [Proc] nested HTML block
     # @return [void]
     def html5(&block)
@@ -24,6 +28,11 @@ module Papercraft
       self.html(&block)
     end
+    # Emits a link element with a stylesheet.
+    #
+    # @param href [String] stylesheet URL
+    # @param custom_attributes [Hash] optional custom attributes for the link element
+    # @return [void]
     def link_stylesheet(href, custom_attributes = nil)
       attributes = {
         rel: 'stylesheet',
@@ -34,5 +43,28 @@ module Papercraft
       end
       link(**attributes)
     end
+    def emit_markdown(markdown, **opts)
+      emit Kramdown::Document.new(markdown, **kramdown_options(opts)).to_html
+    end
+    def kramdown_options(opts)
+      HTML.kramdown_options.merge(**opts)
+    end
+    class << self
+      def kramdown_options
+        @kramdown_options ||= {
+          entity_output: :numeric,
+          syntax_highlighter: :rouge,
+          input: 'GFM',
+          hard_wrap: false
+        }
+      end
+      def kramdown_options=(opts)
+        @kramdown_options = opts
+      end
+    end
   end
 end

data/lib/papercraft/renderer.rb CHANGED Viewed

@@ -3,9 +3,19 @@
 require_relative './html'
 module Papercraft
   # A Renderer renders a Papercraft component into a string
   class Renderer
     class << self
+      # Verifies that the given template proc can be called with the given
+      # arguments and named arguments. If the proc demands named argument keys
+      # that do not exist in `named_args`, `Papercraft::Error` is raised.
+      #
+      # @param template [Proc] proc to verify
+      # @param args [Array<any>] arguments passed to proc
+      # @param named_args [Hash] named arguments passed to proc
       def verify_proc_parameters(template, args, named_args)
         param_count = 0
         template.parameters.each do |(type, name)|
@@ -24,31 +34,22 @@ module Papercraft
       end
     end
-    attr_reader :context
-    # Initializes attributes and renders the given block
-    # @param context [Hash] rendering context
-    # @param block [Proc] template block
-    # @return [void]
+    # Initializes the renderer and evaulates the given template in the
+    # renderer's scope.
+    #
+    # @param &template [Proc] template block
     def initialize(&template)
       @buffer = +''
       instance_eval(&template)
     end
-    # Returns the result of the rendering
+    # Returns the rendered template.
+    #
     # @return [String]
     def to_s
       @buffer
     end
-    def escape_text(text)
-      raise NotImplementedError
-    end
-    def escape_uri(uri)
-      EscapeUtils.escape_uri(v)
-    end
     S_TAG_METHOD_LINE = __LINE__ + 1
     S_TAG_METHOD = <<~EOF
       S_TAG_%<TAG>s_PRE = '<%<tag>s'.tr('_', '-')
@@ -74,10 +75,12 @@ module Papercraft
       end
     EOF
-    # Catches undefined tag method call and handles them by defining the method
+    # Catches undefined tag method call and handles it by defining the method.
+    #
     # @param sym [Symbol] HTML tag or component identifier
-    # @param args [Array] method call arguments
-    # @param block [Proc] block passed to method call
+    # @param args [Array] method arguments
+    # @param opts [Hash] named method arguments
+    # @param &block [Proc] block passed to method
     # @return [void]
     def method_missing(sym, *args, **opts, &block)
       value = @local && @local[sym]
@@ -89,18 +92,28 @@ module Papercraft
       send(sym, *args, **opts, &block)
     end
-    # Emits the given object into the rendering buffer
+    # Emits the given object into the rendering buffer. If the given object is a
+    # proc or a component, `emit` will passes any additional arguments and named
+    # arguments to the object when rendering it. If the given object is nil,
+    # nothing is emitted. Otherwise, the object is converted into a string using
+    # `#to_s` which is then added to the rendering buffer, without any escaping.
+    #
+    #   greeter = proc { |name| h1 "Hello, #{name}!" }
+    #   H { emit(greeter, 'world') }.render #=> "<h1>Hello, world!</h1>"
+    #
+    #   H { emit 'hi&<bye>' }.render #=> "hi&<bye>"
+    #
+    #   H { emit nil }.render #=> ""
+    #
     # @param o [Proc, Papercraft::Component, String] emitted object
+    # @param *a [Array<any>] arguments to pass to a proc
+    # @param **b [Hash] named arguments to pass to a proc
     # @return [void]
     def emit(o, *a, **b)
       case o
       when ::Proc
         Renderer.verify_proc_parameters(o, a, b)
         instance_exec(*a, **b, &o)
-      # when Papercraft::Component
-      #   o = o.template
-      #   Renderer.verify_proc_parameters(o, a, b)
-      #   instance_exec(*a, **b, &o)
       when nil
       else
         @buffer << o.to_s
@@ -108,14 +121,15 @@ module Papercraft
     end
     alias_method :e, :emit
-    def with_block(block, &run_block)
-      old_block = @inner_block
-      @inner_block = block
-      instance_eval(&run_block)
-    ensure
-      @inner_block = old_block
-    end
+    # Emits a block supplied using `Component#apply` or `Component#render`.
+    #
+    #   div_wrap = H { |*args| div { emit_yield(*args) } }
+    #   greeter = div_wrap.apply { |name| h1 "Hello, #{name}!" }
+    #   greeter.render('world') #=> "<div><h1>Hello, world!</h1></div>"
+    #
+    # @param *a [Array<any>] arguments to pass to a proc
+    # @param **b [Hash] named arguments to pass to a proc
+    # @return [void]
     def emit_yield(*a, **b)
       raise Papercraft::Error, "No block given" unless @inner_block
@@ -131,6 +145,31 @@ module Papercraft
     S_EQUAL_QUOTE     = '="'
     S_QUOTE           = '"'
+    # Emits text into the rendering buffer, escaping any special characters to
+    # the respective HTML entities.
+    #
+    # @param data [String] text
+    # @return [void]
+    def text(data)
+      @buffer << escape_text(data)
+    end
+    private
+    # Escapes text. This method must be overriden in descendant classes.
+    def escape_text(text)
+      raise NotImplementedError
+    end
+    # Sets up a block to be called with `#emit_yield`
+    def with_block(block, &run_block)
+      old_block = @inner_block
+      @inner_block = block
+      instance_eval(&run_block)
+    ensure
+      @inner_block = old_block
+    end
     # Emits tag attributes into the rendering buffer
     # @param props [Hash] tag attributes
     # @return [void]
@@ -153,23 +192,23 @@ module Papercraft
         end
       }
     end
-    # Emits text into the rendering buffer
-    # @param data [String] text
-    def text(data)
-      @buffer << escape_text(data)
-    end
   end
+  # Implements an HTML renderer
   class HTMLRenderer < Renderer
     include HTML
+    private
     def escape_text(text)
       EscapeUtils.escape_html(text.to_s)
     end
   end
+  # Implements an XML renderer
   class XMLRenderer < Renderer
+    private
     def escape_text(text)
       EscapeUtils.escape_xml(text.to_s)
     end

data/lib/papercraft/version.rb CHANGED Viewed

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 module Papercraft
-  VERSION = '0.8'
+  VERSION = '0.9'
 end

data/lib/papercraft.rb CHANGED Viewed

@@ -15,20 +15,32 @@ end
 # Kernel extensions
 module ::Kernel
-  # Convenience method for creating a new Papercraft
-  # @param ctx [Hash] local context
+  # Creates a new papercraft component. `#H` can take either a proc argument or
+  # a block. In both cases, the proc is converted to a `Papercraft::Component`.
+  #
+  # H(proc { h1 'hi' }).render #=> "<h1>hi</h1>"
+  # H { h1 'hi' }.render #=> "<h1>hi</h1>"
+  #
   # @param template [Proc] template block
-  # @return [Papercraft] Papercraft template
-  def H(&template)
-    Papercraft::Component.new(&template)
+  # @return [Papercraft::Component] Papercraft component
+  def H(o = nil, &template)
+    return o if o.is_a?(Papercraft::Component)
+    template ||= o
+    Papercraft::Component.new(mode: :html, &template)
   end
-  def X(&template)
+  # Creates a new papercraft component in XML mode. `#X` can take either a proc argument or
+  # a block. In both cases, the proc is converted to a `Papercraft::Component`.
+  #
+  # X(proc { item 'foo' }).render #=> "<item>foo</item>"
+  # X { item 'foo' }.render #=> "<item>foo</item>"
+  #
+  # @param template [Proc] template block
+  # @return [Papercraft::Component] Papercraft component
+  def X(o = nil, &template)
+    return o if o.is_a?(Papercraft::Component)
+    template ||= o
     Papercraft::Component.new(mode: :xml, &template)
   end
 end
-# Object extensions
-class Object
-  include Papercraft::Encoding
-end

metadata CHANGED Viewed

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: papercraft
 version: !ruby/object:Gem::Version
-  version: '0.8'
+  version: '0.9'
 platform: ruby
 authors:
 - Sharon Rosner
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-12-22 00:00:00.000000000 Z
+date: 2021-12-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: escape_utils
@@ -24,6 +24,48 @@ dependencies:
     - - '='
       - !ruby/object:Gem::Version
         version: 1.2.1
+- !ruby/object:Gem::Dependency
+  name: kramdown
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.3.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.3.0
+- !ruby/object:Gem::Dependency
+  name: rouge
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.26.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.26.0
+- !ruby/object:Gem::Dependency
+  name: kramdown-parser-gfm
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.1.0
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
@@ -101,6 +143,9 @@ licenses:
 - MIT
 metadata:
   source_code_uri: https://github.com/digital-fabric/papercraft
+  documentation_uri: https://www.rubydoc.info/gems/papercraft
+  homepage_uri: https://github.com/digital-fabric/papercraft
+  changelog_uri: https://github.com/digital-fabric/papercraft/blob/master/CHANGELOG.md
 post_install_message:
 rdoc_options:
 - "--title"