RubyGems - papercraft - Versions diffs - 0.8.3 → 0.11 - Mend

papercraft 0.8.3 → 0.11

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 +4 -4
data/CHANGELOG.md +18 -0
data/README.md +172 -111
data/lib/papercraft/extension_proxy.rb +30 -0
data/lib/papercraft/html.rb +27 -3
data/lib/papercraft/renderer.rb +101 -5
data/lib/papercraft/version.rb +1 -1
data/lib/papercraft.rb +8 -0
metadata +50 -7

checksums.yaml CHANGED Viewed

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 125df0455a1b4c3373b36b3f52b6d965249a7ddf470439ec48df3f7216ea3991
-  data.tar.gz: be9cea2084785a3dc135b852b66f0d91375cafd6050834d06f26f8a6b497f95f
+  metadata.gz: 3452d115d85742018d1497b369ea27970f0c144e3dcb1772f4d81e33315dce51
+  data.tar.gz: e7217a9d9bcfd7af0dc92482650bc03392b0406cf4f3d6141c253a2918638545
 SHA512:
-  metadata.gz: f45e9101d8bb14bfdde19958988343d6e4d87e270462a0db13630860aff5d6adc560df90aefd78317642f6987d3853cc68ad8adb7d0b74e381b43930424d7a79
-  data.tar.gz: c7a153329948a8fa5dbe90602a293b22e060f0118cc3cdfd629f9af9644f57bea4add8ec13e40a5194178bdebc5dd43a26c0507f03e8dd78e3a3a5662968e390
+  metadata.gz: 8f76b9e73aa48f91af932af3308d3dd43239c3d5ca39e305cb1535417b5997483aa884f0e34ed128800b07a3135ebc1d18ea81d0df64e6170726a66c86969288
+  data.tar.gz: dbe744ca25996c3d263ff609ca26f42076784fdbceabd2dd1604dd1016e2d840830230f4205a673b9e5ba14eb8e480627612971b71ca6631e0a6e473d59ccb73

data/CHANGELOG.md CHANGED Viewed

@@ -1,3 +1,21 @@
+## 0.11 2022-01-04
+- Add deferred evaluation
+## 0.10.1 2021-12-25
+- Fix tag rendering with empty text in Ruby 3.0
+## 0.10 2021-12-25
+- Add support for extensions
+## 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

data/README.md CHANGED Viewed

@@ -1,30 +1,56 @@
-# Papercraft - Composable HTML templating for Ruby
+<h1 align="center">
+  Papercraft
+</h1>
+<h4 align="center">Composable HTML templating for Ruby</h4>
+<p align="center">
+  <a href="http://rubygems.org/gems/papercraft">
+    <img src="https://badge.fury.io/rb/papercraft.svg" alt="Ruby gem">
+  </a>
+  <a href="https://github.com/digital-fabric/papercraft/actions?query=workflow%3ATests">
+    <img src="https://github.com/digital-fabric/papercraft/workflows/Tests/badge.svg" alt="Tests">
+  </a>
+  <a href="https://github.com/digital-fabric/papercraft/blob/master/LICENSE">
+    <img src="https://img.shields.io/badge/license-MIT-blue.svg" alt="MIT License">
+  </a>
+</p>
+<p align="center">
+  <a href="https://www.rubydoc.info/gems/papercraft">API reference</a>
+</p>
-[INSTALL](#installing-papercraft) |
-[TUTORIAL](#getting-started) |
-[EXAMPLES](examples) |
-[REFERENCE](#api-reference)
+# Papercraft - Composable HTML templating for Ruby
 ## 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!
-With Papercraft you can structure your templates as nested HTML components, in a
-somewhat similar fashion to React.
+- Built-in support for rendering [Markdown](#emitting-markdown)
+- Support for namespaced extensions
 ## Installing Papercraft
@@ -42,42 +68,25 @@ $ gem install papercraft
 ## Getting started
-To use Papercraft in your code just require it:
+To create a template use the global method `Kernel#H`:
 ```ruby
 require 'papercraft'
-```
-To create a template use `Papercraft.new` or the global method `Kernel#H`:
-```ruby
-# can also use Papercraft.new
 html = H {
-  div { p 'hello' }
+  div(id: 'greeter') { p 'Hello!' }
 }
 ```
-## Rendering a template
-To render a Papercraft template use the `#render` method:
+Rendering a template is done using `#render`:
 ```ruby
-H { span 'best span' }.render  #=> "<span>best span</span>"
-```
-The render method accepts an arbitrary context variable:
-```ruby
-html = H {
-  h1 context[:title]
-}
-html.render(title: 'My title') #=> "<h1>My title</h1>"
+html.render #=> "<div id="greeter"><p>Hello!</p></div>"
 ```
 ## All about tags
-Tags are added using unqualified method calls, and are nested using blocks:
+Tags are added using unqualified method calls, and can be nested using blocks:
 ```ruby
 H {
@@ -114,8 +123,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 +338,161 @@ 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`
+The deafult options can be configured by accessing
+`Papercraft::HTML.kramdown_options`:
-- `context`: local context hash
-- `block`: template block
+```ruby
+Papercraft::HTML.kramdown_options[:auto_ids] = false
+```
-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.
+## Deferred evaluation
-#### `Papercraft#render(**context)`
+Deferred evaluation allows deferring the rendering of parts of a template until
+the last moment, thus allowing an inner component to manipulate the state of the
+outer component. To in order to defer a part of a template, use `#defer`, and
+include any markup in the provided block. This technique, in in conjunction with
+holding state in instance variables, is an alternative to passing parameters,
+which can be limiting in some situations.
-- `context`: global context hash
+A few use cases for deferred evaulation come to mind:
-Renders the template with an optional [global context](#global-context)
-hash.
+- Setting the page title.
+- Adding a flash message to a page.
+- Using components that dynamically add static dependencies (JS and CSS) to the
+  page.
-#### Methods accessible inside template blocks
+The last use case is particularly interesting. Imagine a `DependencyMananger`
+class that can collect JS and CSS dependencies from the different components
+integrated into the page, and adds them to the page's `<head>` element:
-#### `#<tag/component>(*args, **props, &block)`
+```ruby
+default_layout = H { |**args|
+  @dependencies = DependencyMananger.new
+  head {
+    defer { emit @dependencies.head_markup }
+  }
+  body { emit_yield **args }
+}
-- `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
+button = proc { |text, onclick|
+  @dependencies.js '/static/js/button.js'
+  @dependencies.css '/static/css/button.css'
-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).
+  button text, onclick: onclick
+}
-If a text argument is given for a tag, it will be escaped.
+heading = proc { |text|
+  @dependencies.js '/static/js/heading.js'
+  @dependencies.css '/static/css/heading.css'
-#### `#cache(*vary, &block)`
+  h1 text
+}
-- `vary`: variables used in cached block. The given values will be used to
-  create a separate cache entry.
-- `block`: inner HTML block
+page = default_layout.apply {
+  emit heading, "What's your favorite cheese?"
-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.
+  emit button, 'Beaufort', 'eat_beaufort()'
+  emit button, 'Mont d''or', 'eat_montdor()'
+  emit button, 'Époisses', 'eat_epoisses()'
+}
+```
-#### `#context`
+## Papercraft extensions
+Papercraft extensions are modules that contain one or more methods that can be
+used to render complex HTML components. Extension modules can be used by
+installing them as a namespaced extension using `Papercraft.extension`.
+Extensions are particularly useful when you work with CSS frameworks such as
+[Bootstrap](https://getbootstrap.com/), [Tailwind](https://tailwindui.com/) or
+[Primer](https://primer.style/).
+For example, to create a Bootstrap card component, the following HTML markup is
+needed (example taken from the [Bootstrap
+docs](https://getbootstrap.com/docs/5.1/components/card/#titles-text-and-links)):
+```html
+<div class="card" style="width: 18rem;">
+  <div class="card-body">
+    <h5 class="card-title">Card title</h5>
+    <h6 class="card-subtitle mb-2 text-muted">Card subtitle</h6>
+    <p class="card-text">Some quick example text to build on the card title and make up the bulk of the card's content.</p>
+    <a href="#" class="card-link">Card link</a>
+    <a href="#" class="card-link">Another link</a>
+  </div>
+</div>
+```
-Accesses the [global context](#global-context).
+With Papercraft, we could create a `Bootstrap` extension with a `#card` method
+and other associated methods:
-#### `#emit(object)` a.k.a. `#e(object)`
+```ruby
+module BootstrapComponents
+  ...
-- `object`: `Proc`, `Papercraft` instance or `String`
+  def card(**props)
+    div(class: 'card', **props) {
+      div(class: 'card-body') {
+        emit_yield
+      }
+    }
+  end
-Adds the given object to the current template. If a `String` is given, it is
-rendered verbatim, i.e. without escaping.
+  def card_title(title)
+    h5 title, class: 'card-title'
+  end
-#### `html5(&block)`
+  ...
+end
-- `block`: inner HTML block
+Papercraft.extension(bootstrap: BootstrapComponents)
+```
-Adds an HTML5 `doctype` tag, followed by an `html` tag with the given block.
+The call to `Papercraft.extension` lets us access the different methods of
+`BootstrapComponents` by calling `#bootstrap` inside a template. With this,
+we'll be able to express the above markup as follows:
-#### `#text(data)`
+```ruby
+H {
+  bootstrap.card(style: 'width: 18rem') {
+    bootstrap.card_title 'Card title'
+    bootstrap.card_subtitle 'Card subtitle'
+    bootstrap.card_text 'Some quick example text to build on the card title and make up the bulk of the card''s content.'
+    bootstrap.card_link '#', 'Card link'
+    bootstrap.card_link '#', 'Another link'
+  }
+}
+```
-- `data` - text to add
+## API Reference
-Adds text without wrapping it in a tag. The text will be escaped.
+The API reference for this library can be found
+[here](https://www.rubydoc.info/gems/papercraft).

data/lib/papercraft/extension_proxy.rb ADDED Viewed

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+module Papercraft
+  # An ExtensionProxy proxies method calls to a renderer. Extension proxies are
+  # used to provide an namespaced interface to Papercraft extensions. When an
+  # extension is installed using `Papercraft.extension`, a corresponding method
+  # is defined on the `Papercraft::Renderer` class that creates an extension
+  # proxy that gives access to the different extension methods.
+  class ExtensionProxy
+    # Initializes a new ExtensionProxy.
+    # @param renderer [Papercraft::Renderer] renderer to proxy to
+    # @param mod [Module] extension module
+    # @return [void]
+    def initialize(renderer, mod)
+      @renderer = renderer
+      extend(mod)
+    end
+    # Proxies missing methods to the renderer
+    # @param sym [Symbol] method name
+    # @param *args [Array] arguments
+    # @param &block [Proc] block
+    # @return void
+    def method_missing(sym, *args, &block)
+      @renderer.send(sym, *args, &block)
+    end
+  end
+end

data/lib/papercraft/html.rb CHANGED Viewed

@@ -1,9 +1,10 @@
 # frozen_string_literal: true
-require_relative './html'
+require 'kramdown'
+require 'rouge'
+require 'kramdown-parser-gfm'
-module Papercraft
+module Papercraft
   # HTML Markup extensions
   module HTML
     # Emits the p tag (overrides Object#p)
@@ -42,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

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 require_relative './html'
+require_relative './extension_proxy'
 module Papercraft
@@ -31,15 +32,39 @@ module Papercraft
         if param_count > args.size
           raise Papercraft::Error, "Missing template parameters"
         end
-      end
+      end
+      # Installs the given extensions, mapping a method name to the extension
+      # module.
+      # @param map [Hash] hash mapping methods to extension modules
+      # @return [void]
+      def extension(map)
+        map.each do |sym, mod|
+          define_extension_method(sym, mod)
+        end
+      end
+      private
+      # Defines a method returning an extension proxy for the given module
+      # @param sym [Symbol] method name
+      # @param mod [Module] extension module
+      # @return [void]
+      def define_extension_method(sym, mod)
+        define_method(sym) do
+          (@extension_proxies ||= {})[mod] ||= ExtensionProxy.new(self, mod)
+        end
+      end
     end
+    INITIAL_BUFFER_CAPACITY = 8192
     # Initializes the renderer and evaulates the given template in the
     # renderer's scope.
     #
     # @param &template [Proc] template block
     def initialize(&template)
-      @buffer = +''
+      @buffer = String.new(capacity: INITIAL_BUFFER_CAPACITY)
       instance_eval(&template)
     end
@@ -47,6 +72,20 @@ module Papercraft
     #
     # @return [String]
     def to_s
+      if @parts
+        last = @buffer
+        @buffer = String.new(capacity: INITIAL_BUFFER_CAPACITY)
+        parts = @parts
+        @parts = nil
+        parts.each do |p|
+          if Proc === p
+            render_deferred_proc(&p)
+          else
+            @buffer << p
+          end
+        end
+        @buffer << last unless last.empty?
+      end
       @buffer
     end
@@ -56,6 +95,11 @@ module Papercraft
       S_TAG_%<TAG>s_CLOSE = '</%<tag>s>'.tr('_', '-')
       def %<tag>s(text = nil, **props, &block)
+        if text.is_a?(Hash) && props.empty?
+          props = text
+          text = nil
+        end
         @buffer << S_TAG_%<TAG>s_PRE
         emit_props(props) unless props.empty?
@@ -83,9 +127,6 @@ module Papercraft
     # @param &block [Proc] block passed to method
     # @return [void]
     def method_missing(sym, *args, **opts, &block)
-      value = @local && @local[sym]
-      return value if value
       tag = sym.to_s
       code = S_TAG_METHOD % { tag: tag, TAG: tag.upcase }
       self.class.class_eval(code, __FILE__, S_TAG_METHOD_LINE)
@@ -135,6 +176,42 @@ module Papercraft
       instance_exec(*a, **b, &@inner_block)
     end
+    # Defers the given block to be evaluated later. Deferred evaluation allows
+    # Papercraft components to inject state into sibling components, regardless
+    # of the component's order in the container component. For example, a nested
+    # component may set an instance variable used by another component. This is
+    # an elegant solution to the problem of setting the HTML page's title, or
+    # adding elements to the `<head>` section. Here's how a title can be
+    # controlled from a nested component:
+    #
+    #   layout = H {
+    #     html {
+    #       head {
+    #         defer { title @title }
+    #       }
+    #       body {
+    #         emit_yield
+    #       }
+    #     }
+    #   }
+    #
+    #   html.render {
+    #     @title = 'My super page'
+    #     h1 'content'
+    #   }
+    #
+    # @param &block [Proc] Deferred block to be emitted
+    # @return [void]
+    def defer(&block)
+      if !@parts
+        @parts = [@buffer, block]
+      else
+        @parts << @buffer unless @buffer.empty?
+        @parts << block
+      end
+      @buffer = String.new(capacity: INITIAL_BUFFER_CAPACITY)
+    end
     S_LT              = '<'
     S_GT              = '>'
@@ -192,6 +269,23 @@ module Papercraft
         end
       }
     end
+    # Renders a deferred proc by evaluating it, then adding the rendered result
+    # to the buffer.
+    #
+    # @param &block [Proc] deferred proc
+    # @return [void]
+    def render_deferred_proc(&block)
+      old_buffer = @buffer
+      @buffer = String.new(capacity: INITIAL_BUFFER_CAPACITY)
+      @parts = nil
+      instance_eval(&block)
+      old_buffer << to_s
+      @buffer = old_buffer
+    end
   end
   # Implements an HTML renderer
@@ -200,6 +294,7 @@ module Papercraft
     private
+    # Escapes the given text using HTML entities.
     def escape_text(text)
       EscapeUtils.escape_html(text.to_s)
     end
@@ -209,6 +304,7 @@ module Papercraft
   class XMLRenderer < Renderer
     private
+    # Escapes the given text using XML entities.
     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.3'
+  VERSION = '0.11'
 end

data/lib/papercraft.rb CHANGED Viewed

@@ -11,6 +11,14 @@ require_relative 'papercraft/encoding'
 module Papercraft
   # Exception class used to signal templating-related errors
   class Error < RuntimeError; end
+  # Installs one or more extensions. Extensions enhance templating capabilities
+  # by adding namespaced methods to emplates. An extension is implemented as a
+  # Ruby module containing one or more methods. Each method in the extension
+  # module can be used to render a specific HTML element or a set of elements.
+  def self.extension(map)
+    Renderer.extension(map)
+  end
 end
 # Kernel extensions

metadata CHANGED Viewed

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: papercraft
 version: !ruby/object:Gem::Version
-  version: 0.8.3
+  version: '0.11'
 platform: ruby
 authors:
 - Sharon Rosner
-autorequire:
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-12-23 00:00:00.000000000 Z
+date: 2022-01-04 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
@@ -80,7 +122,7 @@ dependencies:
     - - '='
       - !ruby/object:Gem::Version
         version: 2.0.9
-description:
+description:
 email: sharon@noteflakes.com
 executables: []
 extensions: []
@@ -93,6 +135,7 @@ files:
 - lib/papercraft/compiler.rb
 - lib/papercraft/component.rb
 - lib/papercraft/encoding.rb
+- lib/papercraft/extension_proxy.rb
 - lib/papercraft/html.rb
 - lib/papercraft/renderer.rb
 - lib/papercraft/version.rb
@@ -104,7 +147,7 @@ metadata:
   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:
+post_install_message:
 rdoc_options:
 - "--title"
 - Papercraft
@@ -123,8 +166,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.6
-signing_key:
+rubygems_version: 3.3.3
+signing_key:
 specification_version: 4
 summary: 'Papercraft: component-based HTML templating for Ruby'
 test_files: []