pdfrb 0.2.1 → 0.6.0

data/lib/pdfrb/writer.rb

@@ -23,9 +23,42 @@ module Pdfrb
       @io = io
       @serializer = Serializer.new(
         compress_streams: document.config["writer.compress_streams"],
-        compress_min_size: document.config["writer.compress_min_size"]
+        compress_min_size: document.config["writer.compress_min_size"],
+        **serializer_encrypter_opts
       )
-      @xref_offsets = {} # oid -> byte offset
+      @xref_offsets = {}
+    end
+
+    # Build the encrypter option for the Serializer from the document's
+    # /Encrypt dict. If the document isn't encrypted, returns empty hash.
+    # The SecurityHandler's encrypt_data method becomes the Serializer's
+    # encrypter, which encrypts string/stream payloads per-object.
+    def serializer_encrypter_opts
+      # Use a pre-configured handler if the document provides one
+      # (e.g., set by the encryption CLI).
+      handler = document.config["encryption.handler"]
+      return { encrypter: handler } if handler
+
+      trailer = document.trailer
+      return {} unless trailer
+
+      encrypt_ref = trailer[:Encrypt]
+      return {} unless encrypt_ref
+
+      encrypt_dict = encrypt_ref.is_a?(Pdfrb::Model::Reference) ?
+                        document.object(encrypt_ref) : encrypt_ref
+      return {} unless encrypt_dict
+
+      handler = Pdfrb::Encryption::StandardSecurityHandler.new(
+        Encrypt: encrypt_dict.value,
+        ID: trailer[:ID]
+      )
+      password = document.config["encryption.password"] || ""
+      handler.verify_user_password(password)
+
+      { encrypter: handler }
+    rescue StandardError
+      {}
     end
 
     def self.write(document, io)
@@ -38,7 +71,7 @@ module Pdfrb
 
     def write
       @io.binmode
-      @io.truncate(0) if @io.respond_to?(:truncate)
+      @io.truncate(0) if @io.is_a?(StringIO)
       write_header
       dispatch_before_write
 
@@ -81,7 +114,7 @@ module Pdfrb
       @io << document.io.read
       dispatch_before_write
       # Emit only the modified objects.
-      document.instance_variable_get(:@objects).each_value do |obj|
+      document.each_indirect_object do |obj|
         next unless obj.indirect?
 
         @xref_offsets[obj.oid] = @io.pos
@@ -106,13 +139,16 @@ module Pdfrb
       max_oid = oids.max || 0
       @io << "xref\n"
       @io << "0 #{max_oid + 1}\n"
-      @io << sprintf("0000000000 65535 f \r\n")
+      # Each entry must be EXACTLY 20 bytes per s7.5.4: 10-digit offset,
+      # 1 space, 5-digit gen, 1 space, 1-char type, 2-byte EOL (CR+LF).
+      # No trailing space before the EOL — that was the bug.
+      @io << format("%010d %05d f\r\n", 0, 65_535)
       (1..max_oid).each do |oid|
         offset = @xref_offsets[oid]
         if offset
-          @io << sprintf("%010d %05d n \r\n", offset, 0)
+          @io << format("%010d %05d n\r\n", offset, 0)
         else
-          @io << sprintf("0000000000 00000 f \r\n")
+          @io << format("%010d %05d f\r\n", 0, 0)
         end
       end
       pos
@@ -132,25 +168,11 @@ module Pdfrb
       w_type = 1
       w_field2 = 3
       w_field3 = 1
-      w_type + w_field2 + w_field3
-
-      data = +""
-      (0..max_oid).each do |oid|
-        if oid.zero?
-          data << encode_xref_entry(0, 0, 0, w_type, w_field2, w_field3)
-        elsif @xref_offsets.key?(oid)
-          data << encode_xref_entry(1, @xref_offsets[oid], 0,
-                                    w_type, w_field2, w_field3)
-        elsif packed.key?(oid)
-          objstm_oid, index = packed[oid]
-          data << encode_xref_entry(2, objstm_oid, index,
-                                    w_type, w_field2, w_field3)
-        end
-      end
 
+      data = build_xref_stream_data(max_oid, packed, w_type, w_field2, w_field3)
       compressed = ::Zlib::Deflate.deflate(data)
 
-      xref_stream_oid = document.instance_variable_get(:@next_oid) || (max_oid + 1)
+      xref_stream_oid = document.next_oid || (max_oid + 1)
       stream_offset = @io.pos
       header = "#{xref_stream_oid} 0 obj\n"
 
@@ -172,6 +194,33 @@ module Pdfrb
       stream_offset
     end
 
+    # Build the binary xref stream body. Always emits max_oid + 1
+    # entries (one per oid 0..max_oid) so the reader's per-oid index
+    # stays aligned. Gaps from dedup'd oids become free entries.
+    def build_xref_stream_data(max_oid, packed, w_type, w_field2, w_field3)
+      data = +""
+      (0..max_oid).each do |oid|
+        entry = xref_entry_for(oid, packed)
+        data << encode_xref_entry(entry[0], entry[1], entry[2],
+                                  w_type, w_field2, w_field3)
+      end
+      data
+    end
+
+    # Returns [type, field2, field3] for the xref entry of +oid+.
+    def xref_entry_for(oid, packed)
+      return [0, 0, 0] if oid.zero?
+
+      if @xref_offsets.key?(oid)
+        [1, @xref_offsets[oid], 0]
+      elsif packed.key?(oid)
+        objstm_oid, index = packed[oid]
+        [2, objstm_oid, index]
+      else
+        [0, 0, 0]
+      end
+    end
+
     def write_xref_stream_trailer(xref_pos)
       @io << "startxref\n#{xref_pos}\n%%EOF\n"
     end
@@ -237,9 +286,9 @@ module Pdfrb
 
     def write_trailer(xref_pos, prev: nil)
       root = document.catalog
-      root_ref = root && root.respond_to?(:indirect?) && root.indirect? ?
+      root_ref = root && root.is_a?(Pdfrb::Model::Object) && root.indirect? ?
                    Pdfrb::Model::Reference.new(root.oid, root.gen) : nil
-      size = [(@xref_offsets.keys.max || 0) + 1, document.instance_variable_get(:@next_oid) || 1].max
+      size = [(@xref_offsets.keys.max || 0) + 1, document.next_oid || 1].max
 
       existing = document.trailer || {}
       trailer_hash = {}
@@ -267,10 +316,12 @@ module Pdfrb
 
     def dispatch_before_write
       document.dispatch_message(:before_write)
+      compress_content_streams if document.config["writer.compress_streams"]
     end
 
     def version
-      document.version || DEFAULT_VERSION
+      v = document.version || DEFAULT_VERSION
+      detect_version_features(v)
     end
 
     def each_indirect_object
@@ -296,8 +347,47 @@ module Pdfrb
         hash[k] = v
       end
       [(@xref_offsets.keys.max || 0) + 1,
-       document.instance_variable_get(:@next_oid) || 1].max
+       document.next_oid || 1].max
       hash
     end
+
+    def detect_version_features(current)
+      catalog = document.catalog
+      return current unless catalog
+
+      v = current
+      if (catalog.value[:AF] || catalog.value[:Collection]) && compare_versions(v, "2.0").negative?
+        v = "2.0"
+      end
+      if catalog.value[:OCProperties] && compare_versions(v, "1.5").negative?
+        v = "1.5"
+      end
+      document.version = v
+      v
+    end
+
+    def compare_versions(a, b)
+      aa = a.to_s.split(".").map(&:to_i)
+      bb = b.to_s.split(".").map(&:to_i)
+      (aa <=> bb) || 0
+    end
+
+    def compress_content_streams
+      require "zlib"
+      document.each_indirect_object do |obj|
+        next unless obj.is_a?(Pdfrb::Model::Cos::Stream)
+        next if obj.value[:Filter]
+        next unless obj.stream
+        next if obj.value[:Type] == :Metadata
+
+        min = document.config["writer.compress_min_size"] || 50
+        next if obj.stream.bytesize < min
+
+        compressed = ::Zlib::Deflate.deflate(obj.stream)
+        obj.stream = compressed
+        obj.value[:Filter] = :FlateDecode
+        obj.value[:Length] = compressed.bytesize
+      end
+    end
   end
 end

data/lib/pdfrb/xmp/packet.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+begin; require "lutaml/model"; rescue LoadError; end
+
+module Pdfrb
+  module XMP
+    # XMP packet wrapper. An XMP packet is an XML document wrapped in
+    # processing instructions: <?xpacket begin?> ... <?xpacket end?>.
+    #
+    # The packet contains an RDF document with one Description element
+    # per schema. This class assembles the schemas into a single RDF
+    # Description and wraps it in the packet PI.
+    class Packet
+      XMP_BEGIN = "<?xpacket begin=\"\" id=\"W5M0MpCehiHzreSzNTczkc9d\"?>\n"
+      XMP_END = "<?xpacket end=\"w\"?>\n"
+
+      attr_reader :dc, :pdf, :xmp, :rights
+
+      def initialize
+        @dc = Schemas::DublinCore.new
+        @pdf = Schemas::PDF.new
+        @xmp = Schemas::XMPBasic.new
+        @rights = Schemas::XMPRights.new
+      end
+
+      def title=(value); @dc.title = Array(value); end
+      def title; @dc.title.first; end
+      def creator=(value); @dc.creator = Array(value); end
+      def creator; @dc.creator.first; end
+
+      def author=(value); @dc.creator = Array(value); end
+      def author; @dc.creator.first; end
+      def description=(value); @dc.description = Array(value); end
+      def description; @dc.description.first; end
+      def subject=(value); @dc.subject = Array(value); end
+      def subject; @dc.subject; end
+
+      def keywords=(value); @pdf.keywords = value; end
+      def keywords; @pdf.keywords; end
+      def producer=(value); @pdf.producer = value; end
+      def producer; @pdf.producer; end
+
+      def creator_tool=(value); @xmp.creator_tool = value; end
+      def creator_tool; @xmp.creator_tool; end
+
+      def to_xmp
+        XMP_BEGIN + rdf_body + XMP_END
+      end
+
+      private
+
+      def rdf_body
+        lines = [
+          '<x:xmpmeta xmlns:x="adobe:ns:meta/">',
+          '<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">',
+          '<rdf:Description rdf:about=""',
+          '    xmlns:dc="http://purl.org/dc/elements/1.1/"',
+          '    xmlns:pdf="http://ns.adobe.com/pdf/1.3/"',
+          '    xmlns:xmp="http://ns.adobe.com/xap/1.0/">',
+        ]
+        lines += schema_lines
+        lines << "</rdf:Description>"
+        lines << "</rdf:RDF>"
+        lines << "</x:xmpmeta>"
+        "#{lines.join("\n")}\n"
+      end
+
+      def schema_lines
+        parts = []
+        parts += dc_lines if has_dc?
+        parts += pdf_lines if has_pdf?
+        parts += xmp_lines if has_xmp?
+        parts
+      end
+
+      def has_dc?
+        (@dc.title && !@dc.title.empty?) ||
+          (@dc.creator && !@dc.creator.empty?) ||
+          (@dc.description && !@dc.description.empty?) ||
+          (@dc.subject && !@dc.subject.empty?)
+      end
+
+      def has_pdf?
+        @pdf.keywords || @pdf.producer || @pdf.trapped
+      end
+
+      def has_xmp?
+        @xmp.creator_tool || @xmp.create_date || @xmp.modify_date
+      end
+
+      def dc_lines
+        lines = (@dc.title || []).map { |t| "  <dc:title><rdf:Alt><rdf:li xml:lang=\"x-default\">#{escape(t)}</rdf:li></rdf:Alt></dc:title>" }
+        (@dc.creator || []).each { |c| lines << "  <dc:creator><rdf:Seq><rdf:li>#{escape(c)}</rdf:li></rdf:Seq></dc:creator>" }
+        (@dc.description || []).each { |d| lines << "  <dc:description><rdf:Alt><rdf:li xml:lang=\"x-default\">#{escape(d)}</rdf:li></rdf:Alt></dc:description>" }
+        (@dc.subject || []).each { |s| lines << "  <dc:subject><rdf:Bag><rdf:li>#{escape(s)}</rdf:li></rdf:Bag></dc:subject>" }
+        lines
+      end
+
+      def pdf_lines
+        lines = []
+        lines << "  <pdf:Keywords>#{escape(@pdf.keywords)}</pdf:Keywords>" if @pdf.keywords
+        lines << "  <pdf:Producer>#{escape(@pdf.producer)}</pdf:Producer>" if @pdf.producer
+        lines
+      end
+
+      def xmp_lines
+        lines = []
+        lines << "  <xmp:CreatorTool>#{escape(@xmp.creator_tool)}</xmp:CreatorTool>" if @xmp.creator_tool
+        lines << "  <xmp:CreateDate>#{@xmp.create_date}</xmp:CreateDate>" if @xmp.create_date
+        lines << "  <xmp:ModifyDate>#{@xmp.modify_date}</xmp:ModifyDate>" if @xmp.modify_date
+        lines
+      end
+
+      def escape(str)
+        str.to_s
+          .gsub("&", "&amp;")
+          .gsub("<", "&lt;")
+          .gsub(">", "&gt;")
+      end
+    end
+  end
+end

data/lib/pdfrb/xmp/schemas.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+begin; require "lutaml/model"; rescue LoadError; end
+
+module Pdfrb
+  module XMP
+    module Schemas
+      # Namespace definitions for XMP schemas.
+      class DublinCoreNS < Lutaml::Xml::Namespace
+        uri "http://purl.org/dc/elements/1.1/"
+        prefix_default "dc"
+      end
+
+      class PdfNS < Lutaml::Xml::Namespace
+        uri "http://ns.adobe.com/pdf/1.3/"
+        prefix_default "pdf"
+      end
+
+      class XmpNS < Lutaml::Xml::Namespace
+        uri "http://ns.adobe.com/xap/1.0/"
+        prefix_default "xmp"
+      end
+
+      class XmpRightsNS < Lutaml::Xml::Namespace
+        uri "http://ns.adobe.com/xap/1.0/rights/"
+        prefix_default "xmpRights"
+      end
+
+      # Dublin Core (dc:) — basic descriptive metadata.
+      class DublinCore < Lutaml::Model::Serializable
+        attribute :title, :string, collection: true
+        attribute :creator, :string, collection: true
+        attribute :description, :string, collection: true
+        attribute :subject, :string, collection: true
+        attribute :identifier, :string, collection: true
+        attribute :language, :string, collection: true
+
+        xml do
+          root "dc"
+          namespace DublinCoreNS
+          map_element "title", to: :title
+          map_element "creator", to: :creator
+          map_element "description", to: :description
+          map_element "subject", to: :subject
+          map_element "identifier", to: :identifier
+          map_element "language", to: :language
+        end
+      end
+
+      # PDF (pdf:) — PDF-specific metadata.
+      class PDF < Lutaml::Model::Serializable
+        attribute :keywords, :string
+        attribute :producer, :string
+        attribute :trapped, :string
+
+        xml do
+          root "pdf"
+          namespace PdfNS
+          map_element "Keywords", to: :keywords
+          map_element "Producer", to: :producer
+          map_element "Trapped", to: :trapped
+        end
+      end
+
+      # XMP basic (xmp:) — document lifecycle metadata.
+      class XMPBasic < Lutaml::Model::Serializable
+        attribute :creator_tool, :string
+        attribute :create_date, :string
+        attribute :modify_date, :string
+        attribute :metadata_date, :string
+
+        xml do
+          root "xmp"
+          namespace XmpNS
+          map_element "CreatorTool", to: :creator_tool
+          map_element "CreateDate", to: :create_date
+          map_element "ModifyDate", to: :modify_date
+          map_element "MetadataDate", to: :metadata_date
+        end
+      end
+
+      # XMP Rights (xmpRights:) — rights management metadata.
+      class XMPRights < Lutaml::Model::Serializable
+        attribute :marked, :boolean
+        attribute :web_statement, :string
+
+        xml do
+          root "xmpRights"
+          namespace XmpRightsNS
+          map_element "Marked", to: :marked
+          map_element "WebStatement", to: :web_statement
+        end
+      end
+    end
+  end
+end

data/lib/pdfrb/xmp.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module XMP
+    autoload :Packet, "pdfrb/xmp/packet"
+    autoload :Schemas, "pdfrb/xmp/schemas"
+  end
+end
+
+Pdfrb::Document.prepend(Module.new do
+  def write(path = nil, io: nil)
+    sync_xmp_metadata! unless self.io
+    super
+  end
+
+  private
+
+  def sync_xmp_metadata!
+    info = trailer&.[](:Info)
+    return unless info
+
+    info_obj = object(info)
+    return unless info_obj
+
+    title = info_obj.value[:Title]
+    return unless title
+
+    packet = begin
+      xmp
+    rescue StandardError
+      nil
+    end
+    return unless packet
+
+    xmp_data = packet.to_xmp
+    stream = add(
+      { Type: :Metadata, Subtype: :XML, Length: xmp_data.bytesize },
+      type: Pdfrb::Model::Cos::Stream
+    )
+    stream.stream = xmp_data
+    catalog.value[:Metadata] =
+      Pdfrb::Model::Reference.new(stream.oid, stream.gen)
+  end
+end)

data/lib/pdfrb/xref_section.rb

@@ -38,8 +38,8 @@ module Pdfrb
       @entries[oid]
     end
 
-    def each_entry(&block)
-      @entries.each(&block)
+    def each_entry(&)
+      @entries.each(&)
     end
 
     def merge!(other)

data/lib/pdfrb.rb

@@ -1,35 +1,8 @@
 # frozen_string_literal: true
 
-# Pdfrb — pure-Ruby PDF library.
-#
-# Two-direction contract:
-#   * "PDF file <=> Model" — parse PDF bytes into a typed Model, serialize
-#     a Model back to PDF bytes. Round-trip is the correctness backbone.
-#   * "API Builder Input => Model" — Document / Canvas build a typed
-#     Model from user intent, which is then serialized.
-#
-# Pdfrb is deliberately scoped to the PDF byte format. Layout concerns
-# (page templates, flows, line breaking, tables, etc.) live in the
-# sibling `arroolio` gem.
-#
-# The PDF object model is sourced directly from the vendored Arlington
-# PDF Model TSVs (data/pdfrb/arlington/*.tsv). Field metadata, version
-# predicates, and validators stay aligned with ISO 32000-2:2020 by data,
-# not by hand-coded mimicry.
-#
-# Layering (mirrors the sibling postscript gem):
-#   Source      — bytes → tokens → COS graph (read direction)
-#   Model       — typed domain model (COS values + Type::* semantics)
-#   Arlington   — TSV loader + predicate evaluator (drives Model field defs)
-#   Filter      — stream filter pipeline (Flate, ASCII-85, LZW, ...)
-#   Content     — content-stream operators + Canvas drawing API
-#   Serializer  — Model → bytes
-#   Writer      — Document → file (xref + trailer assembly)
-#   Document    — top-level facade
 module Pdfrb
   autoload :VERSION, "pdfrb/version"
 
-  # Errors — every failure mode in the gem subclasses Pdfrb::Error.
   autoload :Error, "pdfrb/error"
   autoload :ParseError, "pdfrb/error"
   autoload :LexError, "pdfrb/error"
@@ -42,13 +15,10 @@ module Pdfrb
   autoload :ValidationError, "pdfrb/error"
   autoload :ObjectReferenceError, "pdfrb/error"
 
-  # Cross-cutting helpers.
   autoload :Configuration, "pdfrb/configuration"
   autoload :DataDir, "pdfrb/data_dir"
   autoload :PdfConstants, "pdfrb/pdf_constants"
 
-  # Sub-namespaces. Each lives in its own file which holds the autoloads
-  # for that namespace's children (the "immediate parent" rule).
   autoload :Source, "pdfrb/source"
   autoload :Model, "pdfrb/model"
   autoload :Arlington, "pdfrb/arlington"
@@ -57,32 +27,22 @@ module Pdfrb
   autoload :Encryption, "pdfrb/encryption"
   autoload :DigitalSignature, "pdfrb/digital_signature"
 
-  # Eager-load Type::* subclasses so they self-register in the
-  # /Type-symbol type_map before any wrap call happens. Without
-  # this, the first read of a Catalog wouldn't upgrade to
-  # Type::Catalog (because the constant hadn't been autoloaded yet
-  # and therefore hadn't called register_type).
-  require "pdfrb/model/type/file_trailer"
-  require "pdfrb/model/type/catalog"
-  require "pdfrb/model/type/info"
-  require "pdfrb/model/type/page_tree_node"
-  require "pdfrb/model/type/page"
-  require "pdfrb/model/type/resources"
-  require "pdfrb/model/type/metadata"
-  require "pdfrb/model/type/object_stream"
-  require "pdfrb/model/type/xref_stream"
-  require "pdfrb/model/type/graphics_state_parameter"
-  require "pdfrb/model/type/optional_content_group"
-  require "pdfrb/model/type/struct_tree_root"
-  require "pdfrb/model/type/font_type1"
-  require "pdfrb/model/type/annotation"
-  require "pdfrb/model/type/action"
   autoload :Font, "pdfrb/font"
   autoload :FontLoader, "pdfrb/font_loader"
+  autoload :FontResolver, "pdfrb/font_resolver"
   autoload :ImageLoader, "pdfrb/image_loader"
+  autoload :Image, "pdfrb/image"
   autoload :Task, "pdfrb/task"
+  autoload :Color, "pdfrb/color"
+  autoload :Annotation, "pdfrb/annotation"
+  autoload :Appearance, "pdfrb/appearance"
+  autoload :Conformance, "pdfrb/conformance"
+  autoload :Validator, "pdfrb/validator"
+  autoload :XMP, "pdfrb/xmp"
+  autoload :Destination, "pdfrb/destination"
+  autoload :Linearization, "pdfrb/linearization"
+  autoload :Action, "pdfrb/action"
 
-  # Top-level orchestrators.
   autoload :Serializer, "pdfrb/serializer"
   autoload :Writer, "pdfrb/writer"
   autoload :Importer, "pdfrb/importer"
@@ -91,7 +51,19 @@ module Pdfrb
   autoload :XrefSection, "pdfrb/xref_section"
   autoload :Document, "pdfrb/document"
 
-  # CLI (only loaded when invoked via the +pdfrb+ executable; avoids
-  # pulling in thor for library-only users).
+  autoload :Layout, "pdfrb/layout"
+  autoload :Composer, "pdfrb/composer"
+  autoload :Compare, "pdfrb/compare"
+  autoload :TestUtils, "pdfrb/test_utils"
   autoload :CLI, "pdfrb/cli"
+
+  require "logger"
+
+  def self.logger
+    @logger ||= Logger.new($stderr, level: Logger::WARN)
+  end
+
+  def self.logger=(log)
+    @logger = log
+  end
 end

data/pdfrb.gemspec

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require_relative "lib/pdfrb/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "pdfrb"
+  spec.version = Pdfrb::VERSION
+  spec.authors = ["Ribose Inc."]
+  spec.email = ["open.source@ribose.com"]
+
+  spec.summary = "Pure-Ruby PDF parser, Arlington-model-driven domain model, and serializer"
+  spec.description = <<~HEREDOC
+    Pdfrb is a pure-Ruby PDF library: a byte-level reader, an
+    Arlington-model-driven typed domain model, and a serializer. The
+    PDF object model is sourced directly from the vendored Arlington
+    PDF Model TSVs (machine-readable ISO 32000-2:2020), so field
+    metadata, version predicates, and validators stay aligned with
+    the spec by data, not by hand-coded mimicry.
+
+    Two-direction contract: "PDF file <=> Model" and "API Builder
+    Input => Model". Mirrors the layered design of the sibling
+    postscript gem.
+  HEREDOC
+
+  spec.homepage = "https://github.com/claricle/pdfrb"
+  spec.license = "BSD-2-Clause"
+  spec.required_ruby_version = ">= 3.2.0"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/claricle/pdfrb"
+  spec.metadata["changelog_uri"] = "https://github.com/claricle/pdfrb/blob/main/CHANGELOG.md"
+  spec.metadata["bug_tracker_uri"] = "https://github.com/claricle/pdfrb/issues"
+  spec.metadata["rubygems_mfa_required"] = "true"
+
+  spec.files = Dir.chdir(__dir__) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (f == __FILE__) || f.match(%r{\A(?:(?:bin|test|spec|features)/|\.(?:git|travis|circleci)|appveyor)})
+    end
+  end
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "thor"
+end