stationery 0.1.0 → 0.3.0

data/lib/stationery/pdf/assembler.rb

@@ -4,31 +4,39 @@ module Stationery
   module PDF
     # Writes finished pages, their shared resources and document info as PDF.
     class Assembler
-      def initialize(pages:, resources:, info: {})
+      def initialize(pages:, resources:, info: {}, outline: [], encryption: nil)
         @pages = pages
         @resources = resources
         @info = info
+        @outline = outline
+        @encryption = encryption
       end
 
       def render
-        writer = Writer.new
+        writer = Writer.new(encryption: @encryption)
         tree = writer.reserve
         refs = @resources.build(writer)
-        kids = @pages.map { |page| write_page(writer, page, tree, refs) }
+        kids = @kids = @pages.map { writer.reserve }
+        @pages.each_with_index { |page, index| write_page(writer, page, kids[index], tree, refs) }
         writer.set(tree, { Type: :Pages, Kids: kids, Count: kids.size })
-        root = writer.add({ Type: :Catalog, Pages: tree })
+        root = writer.add(catalog(tree, OutlineWriter.new(writer, @outline, kids).write))
         writer.render(root:, info: writer.add(info_dictionary))
       end
 
       private
 
-      def write_page(writer, page, tree, refs)
+      def catalog(tree, outlines)
+        catalog = { Type: :Catalog, Pages: tree }
+        outlines ? catalog.merge(Outlines: outlines, PageMode: :UseOutlines) : catalog
+      end
+
+      def write_page(writer, page, ref, tree, refs)
         dictionary = {
           Type: :Page, Parent: tree, MediaBox: [0, 0, *page.size],
           Contents: writer.add(Stream.new(page.content)), Resources: page_resources(page, refs)
         }
         dictionary[:Annots] = page.annotations.map { |link| writer.add(annotation(link)) } if page.annotations.any?
-        writer.add(dictionary)
+        writer.set(ref, dictionary)
       end
 
       def page_resources(page, refs)
@@ -38,8 +46,12 @@ module Stationery
       end
 
       def annotation(link)
-        { Type: :Annot, Subtype: :Link, Rect: link[:rect], Border: [0, 0, 0],
-          A: { Type: :Action, S: :URI, URI: link[:url].b } }
+        target = if (dest = link[:dest])
+                   { Dest: [@kids.fetch(dest.page), :XYZ, nil, dest.top, nil] }
+                 else
+                   { A: { Type: :Action, S: :URI, URI: link[:url].b } }
+                 end
+        { Type: :Annot, Subtype: :Link, Rect: link[:rect], Border: [0, 0, 0], **target }
       end
 
       def info_dictionary

data/lib/stationery/pdf/encryption/aes.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "openssl"
+
+module Stationery
+  module PDF
+    module Encryption
+      # AES as PDF uses it: object data is CBC with a random IV in front and
+      # PKCS#5 padding; key material (UE, OE, Perms) is unpadded.
+      module AES
+        ZERO_IV = ("\0" * 16).b
+
+        module_function
+
+        def encrypt(key, data)
+          iv = OpenSSL::Random.random_bytes(16)
+          iv + run(cipher(key, "CBC", iv), data)
+        end
+
+        def raw(key, data, iv: ZERO_IV, mode: "CBC")
+          aes = cipher(key, mode, mode == "ECB" ? nil : iv)
+          aes.padding = 0
+          run(aes, data)
+        end
+
+        def cipher(key, mode, iv)
+          aes = OpenSSL::Cipher.new("AES-#{key.bytesize * 8}-#{mode}").encrypt
+          aes.key = key
+          aes.iv = iv if iv
+          aes
+        end
+
+        def run(aes, data) = aes.update(data.b) + aes.final
+      end
+    end
+  end
+end

data/lib/stationery/pdf/encryption/rc4.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Stationery
+  module PDF
+    module Encryption
+      # RC4 in Ruby: OpenSSL 3 builds drop it from the default provider.
+      module RC4
+        module_function
+
+        def crypt(key, data)
+          state = schedule(key.b.bytes)
+          i = j = 0
+          data.b.bytes.map do |byte|
+            i = (i + 1) & 0xFF
+            j = (j + state[i]) & 0xFF
+            state[i], state[j] = state[j], state[i]
+            byte ^ state[(state[i] + state[j]) & 0xFF]
+          end.pack("C*")
+        end
+
+        def schedule(key)
+          state = (0..255).to_a
+          j = 0
+          256.times do |i|
+            j = (j + state[i] + key[i % key.size]) & 0xFF
+            state[i], state[j] = state[j], state[i]
+          end
+          state
+        end
+      end
+    end
+  end
+end

data/lib/stationery/pdf/encryption/revision4.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require "digest/md5"
+
+module Stationery
+  module PDF
+    module Encryption
+      # The MD5 key derivation of security handler revisions 3 and 4
+      # (ISO 32000-1 algorithms 1-5) with a 128-bit key. Each object is
+      # encrypted with its own key: RC4 for R3, AES-128 (AESV2) for R4.
+      class Revision4
+        PADDING = ["28BF4E5E4E758A4164004E56FFFA01082E2E00B6D0683E802F0CA9FE6453697A"].pack("H*").freeze
+
+        def initialize(user:, owner:, permissions:, file_id:, aes:)
+          @aes = aes
+          user = pad(user)
+          @owner_key = rounds(stretch(Digest::MD5.digest(pad(owner))), user)
+          @key = stretch(Digest::MD5.digest(user + @owner_key + [permissions].pack("l<") + file_id))
+          @user_key = rounds(@key, Digest::MD5.digest(PADDING + file_id)) + PADDING.byteslice(0, 16)
+        end
+
+        def entries = { O: HexString.new(@owner_key), U: HexString.new(@user_key) }
+
+        def encrypt(data, number, generation)
+          key = object_key(number, generation)
+          @aes ? AES.encrypt(key, data) : RC4.crypt(key, data)
+        end
+
+        private
+
+        def pad(password) = (password.b + PADDING).byteslice(0, 32)
+
+        def stretch(digest) = 50.times.reduce(digest) { |previous, _| Digest::MD5.digest(previous) }
+
+        def rounds(key, data)
+          20.times.reduce(data) { |previous, round| RC4.crypt(xor(key, round), previous) }
+        end
+
+        def xor(key, value) = key.bytes.map { |byte| byte ^ value }.pack("C*")
+
+        def object_key(number, generation)
+          seed = @key + [number].pack("V").byteslice(0, 3) + [generation].pack("v")
+          Digest::MD5.digest(@aes ? "#{seed}sAlT" : seed)
+        end
+      end
+    end
+  end
+end

data/lib/stationery/pdf/encryption/revision6.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require "digest/sha2"
+require "openssl"
+
+module Stationery
+  module PDF
+    module Encryption
+      # Security handler revision 6 (ISO 32000-2, AES-256): a random file key
+      # wrapped once per password, with salted SHA-2 hashes that run through
+      # the hash iteration of algorithm 2.B. Every object uses the file key.
+      class Revision6
+        DIGESTS = [Digest::SHA256, Digest::SHA384, Digest::SHA512].freeze
+
+        def initialize(user:, owner:, permissions:)
+          @key = random(32)
+          user = password(user)
+          owner = password(owner)
+          validation = random(8)
+          key_salt = random(8)
+          @user_key = hash(user, validation) + validation + key_salt
+          @user_wrapped = AES.raw(hash(user, key_salt), @key)
+          validation = random(8)
+          key_salt = random(8)
+          @owner_key = hash(owner, validation, @user_key) + validation + key_salt
+          @owner_wrapped = AES.raw(hash(owner, key_salt, @user_key), @key)
+          @perms = AES.raw(@key, "#{[permissions, 0xFFFFFFFF].pack("l<V")}Tadb#{random(4)}", mode: "ECB")
+        end
+
+        def entries
+          { O: @owner_key, U: @user_key, OE: @owner_wrapped, UE: @user_wrapped, Perms: @perms }
+            .transform_values { |bytes| HexString.new(bytes) }
+        end
+
+        def encrypt(data, _number, _generation) = AES.encrypt(@key, data)
+
+        private
+
+        def random(size) = OpenSSL::Random.random_bytes(size)
+
+        def password(value) = value.encode(Encoding::UTF_8).b.byteslice(0, 127)
+
+        def hash(password, salt, user_key = "".b)
+          key = Digest::SHA256.digest(password + salt + user_key)
+          round = 0
+          loop do
+            block = AES.raw(key.byteslice(0, 16), (password + key + user_key) * 64, iv: key.byteslice(16, 16))
+            key = DIGESTS[block.byteslice(0, 16).bytes.sum % 3].digest(block)
+            round += 1
+            return key.byteslice(0, 32) if round >= 64 && block.getbyte(-1) <= round - 32
+          end
+        end
+      end
+    end
+  end
+end

data/lib/stationery/pdf/encryption/standard_security.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require "openssl"
+
+module Stationery
+  module PDF
+    module Encryption
+      # The standard security handler: passwords, permissions and the
+      # /Encrypt dictionary, plus the per-object encryption the writer applies
+      # to every string and stream.
+      #
+      #   StandardSecurity.new(owner_password: "s3cret", permissions: %i[print copy])
+      class StandardSecurity
+        PERMISSIONS = { print: 3, modify: 4, copy: 5, annotate: 6, fill_forms: 9, extract_accessible: 10,
+                        assemble: 11, print_high: 12 }.freeze
+        ALGORITHMS = {
+          aes_256: { V: 5, R: 6, Length: 256, CFM: :AESV3, key: 32 },
+          aes_128: { V: 4, R: 4, Length: 128, CFM: :AESV2, key: 16 },
+          rc4_128: { V: 2, R: 3, Length: 128 }
+        }.freeze
+
+        # Checks and normalizes the options without deriving any keys.
+        def self.options(owner_password:, user_password: "", permissions: PERMISSIONS.keys, algorithm: :aes_256)
+          raise ArgumentError, "encryption needs an owner_password" if owner_password.to_s.empty?
+
+          permissions = Array(permissions).map(&:to_sym)
+          unknown = permissions - PERMISSIONS.keys
+          raise ArgumentError, "unknown permission #{unknown.first.inspect}" if unknown.any?
+          raise ArgumentError, "unknown algorithm #{algorithm.inspect}" unless ALGORITHMS.key?(algorithm)
+
+          { owner_password: owner_password.to_s, user_password: user_password.to_s, permissions:, algorithm: }
+        end
+
+        # The signed 32-bit /P value: granted bits set, bits 1-2 clear, the rest set.
+        def self.permission_bits(permissions)
+          masks = PERMISSIONS.transform_values { |bit| 1 << (bit - 1) }
+          bits = 0xFFFFFFFC & ~masks.values.sum
+          bits |= permissions.sum { |name| masks.fetch(name) }
+          [bits].pack("L").unpack1("l")
+        end
+
+        attr_reader :file_id
+
+        def initialize(**)
+          options = self.class.options(**)
+          @algorithm = ALGORITHMS.fetch(options[:algorithm])
+          @permissions = self.class.permission_bits(options[:permissions])
+          @file_id = OpenSSL::Random.random_bytes(16)
+          @handler = handler(options[:user_password], options[:owner_password], options[:algorithm])
+        end
+
+        def dictionary
+          { Filter: :Standard, **@algorithm.slice(:V, :R, :Length), P: @permissions, **@handler.entries,
+            **crypt_filters }
+        end
+
+        def encrypt(data, number, generation = 0) = @handler.encrypt(data, number, generation)
+
+        private
+
+        def handler(user, owner, algorithm)
+          if algorithm == :aes_256
+            Revision6.new(user:, owner:, permissions: @permissions)
+          else
+            Revision4.new(user:, owner:, permissions: @permissions, file_id: @file_id, aes: algorithm == :aes_128)
+          end
+        end
+
+        def crypt_filters
+          return {} unless @algorithm[:CFM]
+
+          filter = { CFM: @algorithm[:CFM], AuthEvent: :DocOpen, Length: @algorithm[:key] }
+          { CF: { StdCF: filter }, StmF: :StdCF, StrF: :StdCF }
+        end
+      end
+    end
+  end
+end

data/lib/stationery/pdf/outline_writer.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Stationery
+  module PDF
+    # Writes outline items as the /Outlines tree. Each item nests under the
+    # nearest earlier item of a shallower level, so a level jump (1 → 3) or a
+    # leading level-2 item still lands somewhere sensible.
+    class OutlineWriter
+      Node = Data.define(:item, :ref, :children) do
+        def open? = item.nil? || item.open
+      end
+
+      def initialize(writer, items, page_refs)
+        @writer = writer
+        @items = items
+        @page_refs = page_refs
+      end
+
+      # The /Outlines root reference, or nil when there is nothing to write.
+      def write
+        return if @items.empty?
+
+        root = tree
+        write_children(root)
+        @writer.set(root.ref, { Type: :Outlines, First: root.children.first.ref, Last: root.children.last.ref,
+                                Count: visible(root) })
+      end
+
+      private
+
+      def tree
+        root = Node.new(nil, @writer.reserve, [])
+        stack = []
+        @items.each do |item|
+          stack.pop while stack.any? && stack.last.item.level >= item.level
+          node = Node.new(item, @writer.reserve, [])
+          (stack.last || root).children << node
+          stack << node
+        end
+        root
+      end
+
+      def write_children(parent)
+        parent.children.each_with_index do |node, index|
+          write_children(node)
+          siblings = { Prev: index.positive? ? parent.children[index - 1].ref : nil,
+                       Next: parent.children[index + 1]&.ref }
+          @writer.set(node.ref, dictionary(node, parent).merge(siblings).compact)
+        end
+      end
+
+      def dictionary(node, parent)
+        dest = node.item.dest
+        {
+          Title: TextString.new(node.item.title), Parent: parent.ref,
+          First: node.children.first&.ref, Last: node.children.last&.ref, Count: count(node),
+          Dest: [@page_refs.fetch(dest.page), :XYZ, nil, dest.top, nil]
+        }
+      end
+
+      # Items shown when `node` is expanded: its children plus the visible
+      # descendants of each open child.
+      def visible(node) = node.children.sum { |child| 1 + (child.open? ? visible(child) : 0) }
+
+      def count(node)
+        return if node.children.empty?
+
+        node.open? ? visible(node) : -visible(node)
+      end
+    end
+  end
+end

data/lib/stationery/pdf/serializer.rb

@@ -7,6 +7,9 @@ module Stationery
     # A plain String is always written as a literal byte string `( … )` — never
     # re-encoded — so a URI stays the 7-bit ASCII the spec requires. Use
     # TextString for human-readable text that may need UTF-16.
+    #
+    # `crypt`, when given, receives every string's bytes (the writer binds it
+    # to the object being written) and the result is written as hex.
     module Serializer
       NAME_ESCAPE = %r{[^\x21-\x7E]|[#%()/<>\[\]{}]}n
       LITERAL_ESCAPE = /[\\()\r]/n
@@ -14,15 +17,15 @@ module Stationery
 
       module_function
 
-      def dump(value)
+      def dump(value, crypt = nil)
         case value
         when Reference then "#{value.id} 0 R"
         when Symbol then name(value)
-        when Hash then "<<#{value.map { |k, v| "#{name(k)} #{dump(v)}" }.join(" ")}>>"
-        when Array then "[#{value.map { |v| dump(v) }.join(" ")}]"
-        when HexString then "<#{value.bytes.unpack1("H*").upcase}>"
-        when TextString then text(value.value)
-        when String then literal(value)
+        when Hash then "<<#{value.map { |k, v| "#{name(k)} #{dump(v, crypt)}" }.join(" ")}>>"
+        when Array then "[#{value.map { |v| dump(v, crypt) }.join(" ")}]"
+        when HexString then hex(value.bytes, crypt)
+        when TextString then text(value.value, crypt)
+        when String then crypt ? hex(value, crypt) : literal(value)
         when Integer, true, false then value.to_s
         when Float then number(value)
         when nil then "null"
@@ -38,18 +41,27 @@ module Stationery
         "(#{value.b.gsub(LITERAL_ESCAPE) { |c| c == "\r" ? "\\r" : "\\#{c}" }})"
       end
 
+      def hex(bytes, crypt = nil)
+        bytes = crypt.call(bytes.b) if crypt
+        "<#{bytes.unpack1("H*").upcase}>"
+      end
+
       def number(value)
         return value.to_s if value.is_a?(Integer)
 
-        str = format("%.4f", value).sub(/\.?0+\z/, "")
+        str = format("%.4f", value)
+        last = str.bytesize
+        last -= 1 while str.getbyte(last - 1) == 48 # "0"
+        last -= 1 if str.getbyte(last - 1) == 46 # "."
+        str = str.byteslice(0, last)
         str == "-0" ? "0" : str
       end
 
-      def text(value)
+      def text(value, crypt = nil)
         value = value.to_s
-        return literal(value) if value.ascii_only?
+        return dump(value, crypt) if value.ascii_only?
 
-        dump(HexString.new(UTF16_BOM + value.encode(Encoding::UTF_16BE).b))
+        hex(UTF16_BOM + value.encode(Encoding::UTF_16BE).b, crypt)
       end
     end
   end

data/lib/stationery/pdf/writer.rb

@@ -9,8 +9,11 @@ module Stationery
     class Writer
       HEADER = "%PDF-1.7\n%\xE2\xE3\xCF\xD3\n".b
 
-      def initialize
+      # `encryption` (an Encryption::StandardSecurity) encrypts every string
+      # and stream except those of its own /Encrypt dictionary.
+      def initialize(encryption: nil)
         @objects = []
+        @encryption = encryption
       end
 
       # Hands out a reference now and lets the object be set later, so a page
@@ -30,30 +33,50 @@ module Stationery
       end
 
       def render(root:, info:)
+        if (missing = @objects.index(nil))
+          raise Error, "object #{missing + 1} reserved but never set"
+        end
+
+        @encrypt = @encryption && add(@encryption.dictionary)
         out = HEADER.dup
         offsets = @objects.each_with_index.map { |object, index| write_object(out, index + 1, object) }
         xref = out.bytesize
-        id = HexString.new(Digest::MD5.digest(out))
+        id = HexString.new(@encryption ? @encryption.file_id : Digest::MD5.digest(out))
 
         out << "xref\n0 #{@objects.size + 1}\n0000000000 65535 f \n"
         offsets.each { |offset| out << format("%010d 00000 n \n", offset) }
-        out << "trailer\n" << Serializer.dump({ Size: @objects.size + 1, Root: root, Info: info, ID: [id, id] })
+        out << "trailer\n" << Serializer.dump(trailer(root, info, id))
         out << "\nstartxref\n#{xref}\n%%EOF\n"
       end
 
       private
 
+      def trailer(root, info, id)
+        trailer = { Size: @objects.size + 1, Root: root, Info: info, ID: [id, id] }
+        @encrypt ? trailer.merge(Encrypt: @encrypt) : trailer
+      end
+
       def write_object(out, number, object)
         offset = out.bytesize
+        crypt = crypt_for(number)
         out << "#{number} 0 obj\n"
         if object.is_a?(Stream)
-          out << Serializer.dump(object.dictionary) << "\nstream\n" << object.data << "\nendstream"
+          data = crypt ? crypt.call(object.data) : object.data
+          out << Serializer.dump(object.dictionary.merge(Length: data.bytesize), crypt)
+          out << "\nstream\n" << data << "\nendstream"
         else
-          out << Serializer.dump(object)
+          out << Serializer.dump(object, crypt)
         end
         out << "\nendobj\n"
         offset
       end
+
+      # The Serializer hook: encrypts a string or stream with this object's key.
+      def crypt_for(number)
+        return unless @encrypt && number != @encrypt.id
+
+        ->(bytes) { @encryption.encrypt(bytes, number) }
+      end
     end
   end
 end

data/lib/stationery/preview.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require "stationery"
+
+module Stationery
+  # Browsable sample documents, like ActionMailer previews. Each public method
+  # returns one document:
+  #
+  #   # spec/pdfs/previews/invoice_pdf_preview.rb
+  #   class InvoicePdfPreview < Stationery::Preview
+  #     def paid = InvoicePdf.new(Invoice.first)
+  #     def overdue(params) = InvoicePdf.new(Invoice.find(params.fetch("id")))
+  #   end
+  class Preview
+    REGISTRY_LOCK = Mutex.new
+
+    class << self
+      def inherited(subclass)
+        super
+        REGISTRY_LOCK.synchronize { Preview.registry << subclass }
+      end
+
+      # Named subclasses with at least one preview; a name defined again (a
+      # reloaded file) keeps its latest class.
+      def all
+        classes = REGISTRY_LOCK.synchronize { Preview.registry.dup }
+        classes.select { it.name && it.pdfs.any? }.reverse.uniq(&:name).sort_by(&:preview_name)
+      end
+
+      # `load`, not `require`: edited previews show up without a restart.
+      def load(paths)
+        paths.each { |path| Dir["#{path}/**/*_preview.rb"].each { |file| Kernel.load(file) } }
+      end
+
+      # "invoice_pdf/paid" => [InvoicePdfPreview, "paid"]
+      def find(path)
+        name, _, pdf = path.to_s.rpartition("/")
+        klass = all.find { it.preview_name == name }
+        [klass, pdf] if klass&.pdfs&.include?(pdf)
+      end
+
+      def preview_name = underscore(name.delete_suffix("Preview"))
+      def pdfs = public_instance_methods(false).sort.map(&:to_s)
+
+      protected
+
+      def registry = (@registry ||= []) # rubocop:disable ThreadSafety/ClassInstanceVariable
+
+      private
+
+      def underscore(name)
+        name.gsub("::", "/").gsub(/([A-Z\d]+)([A-Z][a-z])/, '\1_\2').gsub(/([a-z\d])([A-Z])/, '\1_\2').downcase
+      end
+    end
+
+    def render(name, params = {})
+      method = public_method(name)
+      document = method.arity.zero? ? method.call : method.call(params)
+      return document if document.respond_to?(:to_pdf)
+
+      raise Error, "#{self.class}##{name} must return a Stationery::Document (got #{document.class})"
+    end
+  end
+end

data/lib/stationery/rails/previews_controller.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require "erb"
+require "stationery/preview"
+
+module Stationery
+  # Serves Stationery::Preview classes at /rails/stationery/previews. Loaded
+  # by the Railtie when config.stationery.show_previews is on.
+  class PreviewsController < ActionController::Base
+    before_action :require_previews
+    before_action :load_previews
+
+    def index
+      paths = Preview.all.flat_map { |klass| klass.pdfs.map { "#{klass.preview_name}/#{it}" } }
+      render html: page(paths).html_safe
+    end
+
+    def show
+      klass, pdf = Preview.find(params[:path])
+      return head(:not_found) unless klass
+
+      document = klass.new.render(pdf, request.query_parameters.except("debug"))
+      send_data document.to_pdf(**debug_option(document)), type: "application/pdf", disposition: "inline"
+    end
+
+    private
+
+    def config = ::Rails.application.config.stationery
+
+    def require_previews
+      head :not_found unless config.show_previews
+    end
+
+    def load_previews
+      Preview.load(Railtie.preview_paths(::Rails.root, config.preview_paths))
+    end
+
+    def debug_option(document)
+      debug = params[:debug].present? && document.method(:to_pdf).parameters.include?(%i[key debug])
+      debug ? { debug: true } : {}
+    end
+
+    def page(paths)
+      items = paths.map do |path|
+        href = ERB::Util.html_escape("#{request.path.chomp("/")}/#{path}")
+        %(<li><a href="#{href}">#{ERB::Util.html_escape(path)}</a> <a href="#{href}?debug=1">debug</a></li>)
+      end
+      <<~HTML
+        <!doctype html>
+        <html>
+          <head><meta charset="utf-8"><title>PDF previews</title></head>
+          <body style="font-family: system-ui, sans-serif; margin: 2rem">
+            <h1>PDF previews</h1>
+            <ul>#{items.join("\n")}</ul>
+            #{"<p>No previews found in #{ERB::Util.html_escape(config.preview_paths.join(", "))}.</p>" if items.empty?}
+          </body>
+        </html>
+      HTML
+    end
+  end
+end

data/lib/stationery/rails.rb

@@ -18,3 +18,5 @@ end
 if defined?(ActiveSupport) && ActiveSupport.respond_to?(:on_load)
   ActiveSupport.on_load(:action_controller) { include Stationery::Rails }
 end
+
+require_relative "railtie" if defined?(Rails::Railtie)