brakeman 6.0.0 → 7.0.0

data/bundle/ruby/3.1.0/gems/terminal-table-3.0.2/lib/terminal-table/style.rb

@@ -0,0 +1,284 @@
+# coding: utf-8
+require 'forwardable'
+
+module Terminal
+  class Table
+
+    class Border
+
+      attr_accessor :data, :top, :bottom, :left, :right
+      def initialize
+        @top, @bottom, @left, @right = true, true, true, true
+      end
+      def []=(key, val)
+        @data[key] = val
+      end
+      def [](key)
+        @data[key]
+      end
+      def initialize_dup(other)
+        super
+        @data = other.data.dup
+      end
+      def remove_verticals 
+        self.class.const_get("VERTICALS").each { |key| @data[key] = "" }
+        self.class.const_get("INTERSECTIONS").each { |key| @data[key] = "" }
+      end
+      def remove_horizontals 
+        self.class.const_get("HORIZONTALS").each { |key| @data[key] = "" }
+      end
+      
+      # If @left, return the edge else empty-string.
+      def maybeleft(key) ; @left ? @data[key] : '' ; end
+      
+      # If @right, return the edge else empty-string.
+      def mayberight(key) ; @right ? @data[key] : '' ; end
+
+    end
+    
+    class AsciiBorder < Border
+      HORIZONTALS = %i[x]
+      VERTICALS = %i[y]
+      INTERSECTIONS = %i[i]
+      
+      def initialize
+        super
+        @data = { x: "-", y: "|", i:  "+" }
+      end
+      
+      # Get vertical border elements
+      # @return [Array] 3-element list of [left, center, right]
+      def vertical
+        [maybeleft(:y), @data[:y], mayberight(:y)] # left, center, right
+      end
+      
+      # Get horizontal border elements
+      # @return [Array] a 6 element list of: [i-left, horizontal-bar, i-up/down, i-right, i-down, i-up]
+      def horizontal(_type)
+        x, i = @data[:x], @data[:i]
+        [maybeleft(:i), x, i, mayberight(:i), i, i]
+      end
+    end
+
+    class MarkdownBorder < AsciiBorder
+      def initialize
+        super
+        @top, @bottom = false, false
+        @data = { x: "-", y: "|", i:  "|" }
+      end
+    end
+    
+    class UnicodeBorder < Border
+
+      ALLOWED_SEPARATOR_BORDER_STYLES = %i[
+      top bot 
+      div dash dot3 dot4 
+      thick thick_dash thick_dot3 thick_dot4
+      heavy heavy_dash heavy_dot3 heavy_dot4
+      bold bold_dash bold_dot3 bold_dot4
+      double
+      ]  
+
+      HORIZONTALS = %i[x sx ax bx nx bx_dot3 bx_dot4 bx_dash x_dot3 x_dot4 x_dash]
+      VERTICALS = %i[y yw ye]
+      INTERSECTIONS = %i[nw n ne nd 
+                         aw ai ae ad au
+                         bw bi be bd bu
+                         w i e dn up 
+                         sw s se su]
+      def initialize
+        super
+        @data = {
+          nil => nil,
+          nw: "┌", nx: "─", n:  "┬", ne: "┐",
+          yw: "│",          y:  "│", ye: "│", 
+          aw: "╞", ax: "═", ai: "╪", ae: "╡", ad: '╤', au: "╧", # double
+          bw: "┝", bx: "━", bi: "┿", be: "┥", bd: '┯', bu: "┷", # heavy/bold/thick
+          w:  "├", x:  "─", i:  "┼", e:  "┤", dn: "┬", up: "┴", # normal div
+          sw: "└", sx: "─", s:  "┴", se: "┘",
+          # alternative dots/dashes
+          x_dot4:  '┈', x_dot3:  '┄', x_dash:  '╌',
+          bx_dot4: '┉', bx_dot3: '┅', bx_dash: '╍',
+        }
+      end
+      # Get vertical border elements
+      # @return [Array] 3-element list of [left, center, right]
+      def vertical
+        [maybeleft(:yw), @data[:y], mayberight(:ye)] 
+      end
+
+      # Get horizontal border elements
+      # @return [Array] a 6 element list of: [i-left, horizontal-bar, i-up/down, i-right, i-down, i-up]
+      def horizontal(type)
+        raise ArgumentError, "Border type is #{type.inspect}, must be one of #{ALLOWED_SEPARATOR_BORDER_STYLES.inspect}" unless ALLOWED_SEPARATOR_BORDER_STYLES.include?(type)
+        lookup = case type
+                 when :top
+                   [:nw, :nx, :n, :ne, :n, nil]
+                 when :bot
+                   [:sw, :sx, :s, :se, nil, :s]
+                 when :double
+                   # typically used for the separator below the heading row or above a footer row)
+                   [:aw, :ax, :ai, :ae, :ad, :au]
+                 when :thick, :thick_dash, :thick_dot3, :thick_dot4,
+                      :heavy, :heavy_dash, :heavy_dot3, :heavy_dot4,
+                      :bold, :bold_dash, :bold_dot3, :bold_dot4
+                   # alternate thick/bold border
+                   xref = type.to_s.sub(/^(thick|heavy|bold)/,'bx').to_sym
+                   [:bw, xref, :bi, :be, :bd, :bu]
+                 when :dash, :dot3, :dot4
+                   # alternate thin dividers
+                   xref = "x_#{type}".to_sym
+                   [:w, xref, :i, :e, :dn, :up]
+                 else  # :div (center, non-emphasized)
+                   [:w, :x, :i, :e, :dn, :up]
+                 end
+        rval = lookup.map { |key| @data.fetch(key) }
+        rval[0] = '' unless @left
+        rval[3] = '' unless @right
+        rval
+      end
+    end
+
+    # Unicode Border With rounded edges
+    class UnicodeRoundBorder < UnicodeBorder
+      def initialize
+        super
+        @data.merge!({nw: '╭', ne: '╮', sw: '╰', se: '╯'})
+      end
+    end
+
+    # Unicode Border with thick outer edges
+    class UnicodeThickEdgeBorder < UnicodeBorder
+      def initialize
+        super
+        @data = {
+          nil => nil,
+          nw: "┏", nx: "━", n:  "┯", ne: "┓", nd: nil,
+          yw: "┃",          y:  "│", ye: "┃", 
+          aw: "┣", ax: "═", ai: "╪", ae: "┫", ad: '╤', au: "╧", # double
+          bw: "┣", bx: "━", bi: "┿", be: "┫", bd: '┯', bu: "┷", # heavy/bold/thick
+          w:  "┠", x:  "─", i:  "┼", e:  "┨", dn: "┬", up: "┴", # normal div
+          sw: "┗", sx: "━", s:  "┷", se: "┛", su:  nil,
+          # alternative dots/dashes
+          x_dot4:  '┈', x_dot3:  '┄', x_dash:  '╌',
+          bx_dot4: '┉', bx_dot3: '┅', bx_dash: '╍',
+        }
+      end
+    end
+    
+    # A Style object holds all the formatting information for a Table object
+    #
+    # To create a table with a certain style, use either the constructor
+    # option <tt>:style</tt>, the Table#style object or the Table#style= method
+    #
+    # All these examples have the same effect:
+    #
+    #     # by constructor
+    #     @table = Table.new(:style => {:padding_left => 2, :width => 40})
+    #
+    #     # by object
+    #     @table.style.padding_left = 2
+    #     @table.style.width = 40
+    #
+    #     # by method
+    #     @table.style = {:padding_left => 2, :width => 40}
+    #
+    # To set a default style for all tables created afterwards use Style.defaults=
+    #
+    #     Terminal::Table::Style.defaults = {:width => 80}
+    #
+    class Style
+      extend Forwardable
+      def_delegators :@border, :vertical, :horizontal, :remove_verticals, :remove_horizontals
+      
+      @@defaults = {
+        :border => AsciiBorder.new,
+        :padding_left => 1, :padding_right => 1,
+        :margin_left => '',
+        :width => nil, :alignment => nil,
+        :all_separators => false,
+      }
+
+      ## settors/gettor for legacy ascii borders
+      def border_x=(val) ; @border[:x] = val ; end
+      def border_y=(val) ; @border[:y] = val ; end
+      def border_i=(val) ; @border[:i] = val ; end
+      def border_y ; @border[:y] ; end
+      def border_y_width ; Util::ansi_escape(@border[:y]).length ; end
+
+      # Accessor for instance of Border
+      attr_reader :border
+      def border=(val)
+        if val.is_a? Symbol
+          # convert symbol name like :foo_bar to get class FooBarBorder
+          klass_str = val.to_s.split('_').collect(&:capitalize).join + "Border"
+          begin
+            klass = Terminal::Table::const_get(klass_str)
+            @border = klass.new
+          rescue NameError
+            raise "Cannot lookup class Terminal::Table::#{klass_str} from symbol #{val.inspect}"
+          end
+        else
+          @border = val
+        end
+      end
+
+      def border_top=(val) ; @border.top = val ; end
+      def border_bottom=(val) ; @border.bottom = val ; end
+      def border_left=(val) ; @border.left = val ; end
+      def border_right=(val) ; @border.right = val ; end
+
+      def border_top ; @border.top ; end
+      def border_bottom ; @border.bottom ; end
+      def border_left ; @border.left ; end
+      def border_right ; @border.right ; end
+
+
+      attr_accessor :padding_left
+      attr_accessor :padding_right
+
+      attr_accessor :margin_left
+
+      attr_accessor :width
+      attr_accessor :alignment
+
+      attr_accessor :all_separators
+
+      
+      def initialize options = {}
+        apply self.class.defaults.merge(options)
+      end
+
+      def apply options
+        options.each do |m, v|
+          __send__ "#{m}=", v
+        end
+      end
+      
+      class << self
+        def defaults
+          klass_defaults = @@defaults.dup
+          # border is an object that needs to be duplicated on instantiation,
+          # otherwise everything will be referencing the same object-id.
+          klass_defaults[:border] = klass_defaults[:border].dup
+          klass_defaults
+        end
+        
+        def defaults= options
+          @@defaults = defaults.merge(options)
+        end
+
+      end
+
+      def on_change attr
+        method_name = :"#{attr}="
+        old_method = method method_name
+        define_singleton_method(method_name) do |value|
+          old_method.call value
+          yield attr.to_sym, value
+        end
+      end
+          
+    end
+  end
+end

data/bundle/ruby/{3.0.0/gems/terminal-table-1.8.0 → 3.1.0/gems/terminal-table-3.0.2}/lib/terminal-table/table.rb

@@ -7,9 +7,10 @@ module Terminal
     attr_reader :headings
 
     ##
-    # Generates a ASCII table with the given _options_.
+    # Generates a ASCII/Unicode table with the given _options_.
 
     def initialize options = {}, &block
+      @elaborated = false
       @headings = []
       @rows = []
       @column_widths = []
@@ -26,9 +27,8 @@ module Terminal
     # Align column _n_ to the given _alignment_ of :center, :left, or :right.
 
     def align_column n, alignment
-      r = rows
-      column(n).each_with_index do |col, i|
-        cell = r[i][n]
+      # nil forces the column method to return the cell itself
+      column(n, nil).each do |cell|
         cell.alignment = alignment unless cell.alignment?
       end
     end
@@ -46,12 +46,12 @@ module Terminal
     ##
     # Add a separator.
 
-    def add_separator
-      self << :separator
+    def add_separator(border_type: :div)
+      @rows << Separator.new(self, border_type: border_type)
     end
 
     def cell_spacing
-      cell_padding + style.border_y.length
+      cell_padding + style.border_y_width
     end
 
     def cell_padding
@@ -118,28 +118,57 @@ module Terminal
     end
 
     ##
-    # Render the table.
+    # Elaborate rows to form an Array of Rows and Separators with adjacency properties added.
+    #
+    # This is separated from the String rendering so that certain features may be tweaked
+    # before the String is built.
 
-    def render
-      separator = Separator.new(self)
-      buffer = style.border_top ? [separator] : []
+    def elaborate_rows
+
+      buffer = style.border_top ? [Separator.new(self, border_type: :top, implicit: true)] : []
       unless @title.nil?
         buffer << Row.new(self, [title_cell_options])
-        buffer << separator
+        buffer << Separator.new(self, implicit: true)
       end
       @headings.each do |row|
         unless row.cells.empty?
           buffer << row
-          buffer << separator
+          buffer << Separator.new(self, border_type: :double, implicit: true)
         end
       end
       if style.all_separators
-        buffer += @rows.product([separator]).flatten
+        @rows.each_with_index do |row, idx|
+          # last separator is bottom, others are :div
+          border_type = (idx == @rows.size - 1) ? :bot : :div
+          buffer << row
+          buffer << Separator.new(self, border_type: border_type, implicit: true)
+        end
       else
         buffer += @rows
-        buffer << separator if style.border_bottom
+        buffer << Separator.new(self, border_type: :bot, implicit: true) if style.border_bottom
+      end
+
+      # After all implicit Separators are inserted we need to save off the
+      # adjacent rows so that we can decide what type of intersections to use
+      # based on column spans in the adjacent row(s).
+      buffer.each_with_index do |r, idx|
+        if r.is_a?(Separator)
+          prev_row = idx > 0 ? buffer[idx - 1] : nil
+          next_row = buffer.fetch(idx + 1, nil)
+          r.save_adjacent_rows(prev_row, next_row)
+        end
       end
-      buffer.map { |r| style.margin_left + r.render.rstrip }.join("\n")
+      
+      @elaborated = true
+      @rows = buffer
+    end
+
+    ##
+    # Render the table.
+
+    def render
+      elaborate_rows unless @elaborated
+      @rows.map { |r| style.margin_left + r.render.rstrip }.join("\n")
     end
     alias :to_s :render
 
@@ -181,7 +210,7 @@ module Terminal
     private
 
     def columns_width
-      column_widths.inject(0) { |s, i| s + i + cell_spacing } + style.border_y.length
+      column_widths.inject(0) { |s, i| s + i + cell_spacing } + style.border_y_width
     end
 
     def recalc_column_widths
@@ -300,7 +329,7 @@ module Terminal
 
       full_width = dp[n_cols][0].keys.first
       unless style.width.nil?
-        new_width = style.width - space_width - style.border_y.length
+        new_width = style.width - space_width - style.border_y_width
         if new_width < full_width
           raise "Table width exceeds wanted width " +
                 "of #{style.width} characters."

data/bundle/ruby/3.1.0/gems/terminal-table-3.0.2/lib/terminal-table/util.rb

@@ -0,0 +1,13 @@
+module Terminal
+  class Table
+    module Util
+      # removes all ANSI escape sequences (e.g. color)
+      def ansi_escape(line)
+        line.to_s.gsub(/\x1b(\[|\(|\))[;?0-9]*[0-9A-Za-z]/, '').
+          gsub(/\x1b(\[|\(|\))[;?0-9]*[0-9A-Za-z]/, '').
+          gsub(/(\x03|\x1a)/, '')
+      end
+      module_function :ansi_escape
+    end
+  end
+end

data/bundle/ruby/{3.0.0/gems/terminal-table-1.8.0 → 3.1.0/gems/terminal-table-3.0.2}/lib/terminal-table/version.rb

@@ -1,5 +1,5 @@
 module Terminal
   class Table
-    VERSION = '1.8.0'
+    VERSION = '3.0.2'
   end
 end

data/bundle/ruby/{3.0.0/gems/terminal-table-1.8.0 → 3.1.0/gems/terminal-table-3.0.2}/lib/terminal-table.rb

@@ -21,6 +21,6 @@
 # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 #++
 
-%w(cell row separator style table table_helper version).each do |file|
-  require "terminal-table/#{file}"
+%w(cell row separator style table table_helper util version).each do |file|
+  require_relative "./terminal-table/#{file}"
 end

data/bundle/ruby/{3.0.0/gems/terminal-table-1.8.0 → 3.1.0/gems/terminal-table-3.0.2}/terminal-table.gemspec

@@ -16,11 +16,11 @@ Gem::Specification.new do |spec|
   spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
   spec.require_paths = ["lib"]
 
-  spec.add_development_dependency "bundler", "~> 1.10"
-  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "bundler", "~> 2"
+  spec.add_development_dependency "rake", "~> 13.0"
   spec.add_development_dependency "rspec", ">= 3.0"
   spec.add_development_dependency "term-ansicolor"
   spec.add_development_dependency "pry"
 
-  spec.add_runtime_dependency "unicode-display_width", ["~> 1.1", ">= 1.1.1"]
+  spec.add_runtime_dependency "unicode-display_width", [">= 1.1.1", "< 3"]
 end

data/bundle/ruby/{3.0.0/gems/tilt-2.0.11 → 3.1.0/gems/tilt-2.5.0}/COPYING

@@ -1,4 +1,5 @@
 Copyright (c) 2010-2016 Ryan Tomayko <http://tomayko.com/about>
+Copyright (c) 2015-2023 Jeremy Evans
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to

data/bundle/ruby/3.1.0/gems/tilt-2.5.0/lib/tilt/_emacs_org.rb

@@ -0,0 +1,2 @@
+warn "Lazy loading of emacs org templates is deprecated and will be removed in Tilt 3.  Require tilt/emacs_org manually.", uplevel: 1
+require "tilt/emacs_org"

data/bundle/ruby/3.1.0/gems/tilt-2.5.0/lib/tilt/_handlebars.rb

@@ -0,0 +1,2 @@
+warn "Lazy loading of handlebars templates is deprecated and will be removed in Tilt 3.  Require tilt/handlebars manually.", uplevel: 1
+require "tilt/handlebars"

data/bundle/ruby/3.1.0/gems/tilt-2.5.0/lib/tilt/_jbuilder.rb

@@ -0,0 +1,2 @@
+warn "Lazy loading of jbuilder templates is deprecated and will be removed in Tilt 3.  Require tilt/jbuilder manually.", uplevel: 1
+require "tilt/jbuilder"

data/bundle/ruby/3.1.0/gems/tilt-2.5.0/lib/tilt/_org.rb

@@ -0,0 +1,2 @@
+warn "Lazy loading of org templates is deprecated and will be removed in Tilt 3.  Require org-ruby manually.", uplevel: 1
+require "org-ruby"

data/bundle/ruby/3.1.0/gems/tilt-2.5.0/lib/tilt/asciidoc.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+require_relative 'template'
+require 'asciidoctor'
+# AsciiDoc see: http://asciidoc.org/
+
+# Asciidoctor implementation for AsciiDoc see:
+# http://asciidoctor.github.com/
+#
+# Asciidoctor is an open source, pure-Ruby processor for
+# converting AsciiDoc documents or strings into HTML 5,
+# DocBook 4.5 and other formats.
+Tilt::AsciidoctorTemplate = Tilt::StaticTemplate.subclass do
+  @options[:header_footer] = false if @options[:header_footer].nil?
+  Asciidoctor.render(@data, @options)
+end

data/bundle/ruby/3.1.0/gems/tilt-2.5.0/lib/tilt/babel.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+require_relative 'template'
+require 'babel/transpiler'
+
+Tilt::BabelTemplate = Tilt::StaticTemplate.subclass(mime_type: 'application/javascript') do
+  @options[:filename] ||= @file
+  Babel::Transpiler.transform(@data)["code"]
+end

data/bundle/ruby/3.1.0/gems/tilt-2.5.0/lib/tilt/builder.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+require_relative 'template'
+require 'builder'
+
+module Tilt
+  # Builder template implementation.
+  class BuilderTemplate < Template
+    self.default_mime_type = 'text/xml'
+
+    def prepare
+      @options[:indent] ||= 2
+    end
+
+    def evaluate(scope, locals, &block)
+      if @data.respond_to?(:to_str)
+        unless locals[:xml]
+          locals = Hash[locals]
+          locals[:xml] = xml_builder
+        end
+        return super
+      end
+
+      xml = locals[:xml] || xml_builder
+      @data.call(xml)
+      xml.target!
+    end
+
+    def precompiled_postamble(locals)
+      "xml.target!"
+    end
+
+    def precompiled_template(locals)
+      @data.to_str
+    end
+
+    private
+
+    def xml_builder
+      ::Builder::XmlMarkup.new(options)
+    end
+  end
+end

data/bundle/ruby/3.1.0/gems/tilt-2.5.0/lib/tilt/cli.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+require_relative '../tilt'
+require 'optparse'
+
+module Tilt::CLI
+  USAGE = (<<USAGE).freeze
+Usage: tilt <options> <file>
+Process template <file> and write output to stdout. With no <file> or
+when <file> is '-', read template from stdin and use the --type option
+to determine the template's type.
+
+Options
+  -l, --list                List template engines + file patterns and exit
+  -t, --type=<pattern>      Use this template engine; required if no <file>
+  -y, --layout=<file>       Use <file> as a layout template
+
+  -D<name>=<value>          Define variable <name> as <value>
+  -d, --define-file=<file>  Load YAML from <file> and use for variables
+  --vars=<ruby>             Evaluate <ruby> to Hash and use for variables
+
+  -h, --help                Show this help message
+
+Convert markdown to HTML:
+  $ tilt foo.markdown > foo.html
+
+Process ERB template:
+  $ echo "Answer: <%= 2 + 2 %>" | tilt -t erb
+  Answer: 4
+
+Define variables:
+  $ echo "Answer: <%= 2 + n %>" | tilt -t erb --vars="{:n=>40}"
+  Answer: 42
+  $ echo "Answer: <%= 2 + n.to_i %>" | tilt -t erb -Dn=40
+  Answer: 42
+USAGE
+  private_constant :USAGE
+
+  # Backbone of the tilt command line utility. Allows mocking input/output
+  # for simple testing. Returns program exit code.
+  def self.run(argv: ARGV, stdout: $stdout, stdin: $stdin, stderr: $stderr, script_name: File.basename($0))
+    pattern = nil
+    layout = nil
+    locals = {}
+    abort = proc do |msg|
+      stderr.puts msg
+      return 1
+    end
+
+    OptionParser.new do |o|
+      o.program_name = script_name
+
+      # list all available template engines
+      o.on("-l", "--list") do
+        groups = {}
+        Tilt.lazy_map.each do |pattern,engines|
+          engines.each do |engine,|
+            engine = engine.split('::').last.sub(/Template\z/, '')
+            (groups[engine] ||= []) << pattern
+          end
+        end
+        groups.sort { |(k1,v1),(k2,v2)| k1 <=> k2 }.each do |engine,files|
+          stdout.printf "%-20s %s\n", engine, files.sort.join(', ')
+        end
+        return 0
+      end
+
+      # the template type / pattern
+      o.on("-t", "--type=PATTERN", String) do |val|
+        abort.("unknown template type: #{val}") unless Tilt[val]
+        pattern = val
+      end
+
+      # pass template output into the specified layout template
+      o.on("-y", "--layout=FILE", String)  do |file|
+        paths = [file, "~/.tilt/#{file}", "/etc/tilt/#{file}"]
+        layout = paths.
+          map  { |p| File.expand_path(p) }.
+          find { |p| File.exist?(p) }
+        abort.("no such layout: #{file}") if layout.nil?
+      end
+
+      # define a local variable
+      o.on("-D", "--define=PAIR", String) do |pair|
+        key, value = pair.split(/[=:]/, 2)
+        locals[key.to_sym] = value
+      end
+
+      # define local variables from YAML or JSON
+      o.on("-d", "--define-file=FILE", String) do |file|
+        require 'yaml'
+        abort.("no such define file: #{file}") unless File.exist? file
+        hash = File.open(file, 'r:bom|utf-8') { |f| YAML.load(f.read) }
+        abort.("vars must be a Hash, not instance of #{hash.class}") unless hash.is_a?(Hash)
+        hash.each { |key, value| locals[key.to_sym] = value }
+      end
+
+      # define local variables using a Ruby hash
+      o.on("--vars=RUBY") do |ruby|
+        hash = eval(ruby)
+        abort.("vars must be a Hash, not instance of #{hash.class}") unless hash.is_a?(Hash)
+        hash.each { |key, value| locals[key.to_sym] = value }
+      end
+
+      o.on_tail("-h", "--help") do
+        stdout.puts USAGE
+        return 0
+      end
+    end.parse!(argv)
+
+    file = argv.first || '-'
+    pattern = file if pattern.nil?
+    abort.("template type not given. see: #{script_name} --help") if ['-', ''].include?(pattern)
+
+    engine = Tilt[pattern]
+    abort.("template engine not found for: #{pattern}") unless engine
+
+    template =
+      engine.new(file) {
+        if file == '-'
+          stdin.read
+        else
+          File.read(file)
+        end
+      }
+    output = template.render(self, locals)
+
+    # process layout
+    output = Tilt.new(layout).render(self, locals) { output } if layout
+
+    stdout.write(output)
+
+    0
+  end
+end