super-pro-kit 0.0.1

data/slim-5.2.1/lib/slim/code_attributes.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+module Slim
+  # @api private
+  class CodeAttributes < Filter
+    define_options :merge_attrs
+
+    # Handle attributes expression `[:html, :attrs, *attrs]`
+    #
+    # @param [Array] attrs Array of temple expressions
+    # @return [Array] Compiled temple expression
+    def on_html_attrs(*attrs)
+      [:multi, *attrs.map { |a| compile(a) }]
+    end
+
+    # Handle attribute expression `[:html, :attr, name, value]`
+    #
+    # @param [String] name Attribute name
+    # @param [Array] value Value expression
+    # @return [Array] Compiled temple expression
+    def on_html_attr(name, value)
+      if value[0] == :slim && value[1] == :attrvalue && !options[:merge_attrs][name]
+        # We handle the attribute as a boolean attribute
+        escape, code = value[2], value[3]
+        case code
+        when 'true'
+          [:html, :attr, name, [:multi]]
+        when 'false', 'nil'
+          [:multi]
+        else
+          tmp = unique_name
+          [:multi,
+           [:code, "#{tmp} = #{code}"],
+           [:if, tmp,
+            [:if, "#{tmp} == true",
+             [:html, :attr, name, [:multi]],
+             [:html, :attr, name, [:escape, escape, [:dynamic, tmp]]]]]]
+        end
+      else
+        # Attribute with merging
+        @attr = name
+        super
+      end
+    end
+
+    # Handle attribute expression `[:slim, :attrvalue, escape, code]`
+    #
+    # @param [Boolean] escape Escape html
+    # @param [String] code Ruby code
+    # @return [Array] Compiled temple expression
+    def on_slim_attrvalue(escape, code)
+      # We perform attribute merging on Array values
+      if delimiter = options[:merge_attrs][@attr]
+        tmp = unique_name
+        [:multi,
+         [:code, "#{tmp} = #{code}"],
+         [:if, "Array === #{tmp}",
+          [:multi,
+           [:code, "#{tmp} = #{tmp}.flatten"],
+           [:code, "#{tmp}.map!(&:to_s)"],
+           [:code, "#{tmp}.reject!(&:empty?)"],
+           [:escape, escape, [:dynamic, "#{tmp}.join(#{delimiter.inspect})"]]],
+          [:escape, escape, [:dynamic, tmp]]]]
+      else
+        [:escape, escape, [:dynamic, code]]
+      end
+    end
+  end
+end

data/slim-5.2.1/lib/slim/command.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+require 'slim'
+require 'optparse'
+
+module Slim
+  Engine.set_options pretty: false
+
+  # Slim commandline interface
+  # @api private
+  class Command
+    def initialize(args)
+      @args = args
+      @options = {}
+    end
+
+    # Run command
+    def run
+      @opts = OptionParser.new(&method(:set_opts))
+      @opts.parse!(@args)
+      process
+    end
+
+    private
+
+    # Configure OptionParser
+    def set_opts(opts)
+      opts.on('-s', '--stdin', 'Read input from standard input instead of an input file') do
+        @options[:input] = $stdin
+      end
+
+      opts.on('--trace', 'Show a full traceback on error') do
+        @options[:trace] = true
+      end
+
+      opts.on('-c', '--compile', 'Compile only but do not run') do
+        @options[:compile] = true
+      end
+
+      opts.on('-e', '--erb', 'Convert to ERB') do
+        @options[:erb] = true
+      end
+
+      opts.on('--rails', 'Generate rails compatible code (Implies --compile)') do
+        Engine.set_options disable_capture: true, generator: Temple::Generators::RailsOutputBuffer
+        @options[:compile] = true
+      end
+
+      opts.on('-r', '--require library', 'Load library or plugin with -r slim/plugin') do |lib|
+        require lib.strip
+      end
+
+      opts.on('-p', '--pretty', 'Produce pretty html') do
+        Engine.set_options pretty: true
+      end
+
+      opts.on('-o', '--option name=code', String, 'Set slim option') do |str|
+        parts = str.split('=', 2)
+        Engine.options[parts.first.gsub(/\A:/, '').to_sym] = eval(parts.last)
+      end
+
+      opts.on('-l', '--locals Hash|YAML|JSON', String, 'Set local variables') do |locals|
+        @options[:locals] =
+          if locals =~ /\A\s*\{\s*\p{Word}+:/
+            eval(locals)
+          else
+            require 'yaml'
+            YAML.load(locals)
+          end
+      end
+
+      opts.on_tail('-h', '--help', 'Show this message') do
+        puts opts
+        exit
+      end
+
+      opts.on_tail('-v', '--version', 'Print version') do
+        puts "Slim #{VERSION}"
+        exit
+      end
+    end
+
+    # Process command
+    def process
+      args = @args.dup
+      unless @options[:input]
+        file = args.shift
+        if file
+          @options[:file] = file
+          @options[:input] = File.open(file, 'r')
+        else
+          @options[:file] = 'STDIN'
+          @options[:input] = $stdin
+        end
+      end
+
+      locals = @options.delete(:locals) || {}
+      result =
+        if @options[:erb]
+          require 'slim/erb_converter'
+          ERBConverter.new(file: @options[:file]).call(@options[:input].read)
+        elsif @options[:compile]
+          Engine.new(file: @options[:file]).call(@options[:input].read)
+        else
+          Template.new(@options[:file]) { @options[:input].read }.render(nil, locals)
+        end
+
+    rescue Exception => ex
+      raise ex if @options[:trace] || SystemExit === ex
+      $stderr.print "#{ex.class}: " if ex.class != RuntimeError
+      $stderr.puts ex.message
+      $stderr.puts '  Use --trace for backtrace.'
+      exit 1
+    else
+      unless @options[:output]
+        file = args.shift
+        @options[:output] = file ? File.open(file, 'w') : $stdout
+      end
+      @options[:output].puts(result)
+      exit 0
+    end
+  end
+end

data/slim-5.2.1/lib/slim/controls.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+module Slim
+  # @api private
+  class Controls < Filter
+    define_options :disable_capture
+
+    IF_RE = /\A(if|unless)\b|\bdo\s*(\|[^\|]*\|)?\s*$/
+
+    # Handle control expression `[:slim, :control, code, content]`
+    #
+    # @param [String] code Ruby code
+    # @param [Array] content Temple expression
+    # @return [Array] Compiled temple expression
+    def on_slim_control(code, content)
+      [:multi,
+        [:code, code],
+        compile(content)]
+    end
+
+    # Handle output expression `[:slim, :output, escape, code, content]`
+    #
+    # @param [Boolean] escape Escape html
+    # @param [String] code Ruby code
+    # @param [Array] content Temple expression
+    # @return [Array] Compiled temple expression
+    def on_slim_output(escape, code, content)
+      if code =~ IF_RE
+        tmp = unique_name
+
+        [:multi,
+         # Capture the result of the code in a variable. We can't do
+         # `[:dynamic, code]` because it's probably not a complete
+         # expression (which is a requirement for Temple).
+         [:block, "#{tmp} = #{code}",
+
+          # Capture the content of a block in a separate buffer. This means
+          # that `yield` will not output the content to the current buffer,
+          # but rather return the output.
+          #
+          # The capturing can be disabled with the option :disable_capture.
+          # Output code in the block writes directly to the output buffer then.
+          # Rails handles this by replacing the output buffer for helpers.
+          options[:disable_capture] ? compile(content) : [:capture, unique_name, compile(content)]],
+
+         # Output the content.
+         [:escape, escape, [:dynamic, tmp]]]
+      else
+        [:multi, [:escape, escape, [:dynamic, code]], content]
+      end
+    end
+
+    # Handle text expression `[:slim, :text, type, content]`
+    #
+    # @param [Symbol] type Text type
+    # @param [Array] content Temple expression
+    # @return [Array] Compiled temple expression
+    def on_slim_text(type, content)
+      compile(content)
+    end
+  end
+end

data/slim-5.2.1/lib/slim/do_inserter.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+module Slim
+  # In Slim you don't need the do keyword sometimes. This
+  # filter adds the missing keyword.
+  #
+  #   - 10.times
+  #     | Hello
+  #
+  # @api private
+  class DoInserter < Filter
+    BLOCK_REGEX = /(\A(if|unless|else|elsif|when|in|begin|rescue|ensure|case)\b)|\bdo\s*(\|[^\|]*\|\s*)?\Z/
+
+    # Handle control expression `[:slim, :control, code, content]`
+    #
+    # @param [String] code Ruby code
+    # @param [Array] content Temple expression
+    # @return [Array] Compiled temple expression
+    def on_slim_control(code, content)
+      code += ' do' unless code =~ BLOCK_REGEX || empty_exp?(content)
+      [:slim, :control, code, compile(content)]
+    end
+
+    # Handle output expression `[:slim, :output, escape, code, content]`
+    #
+    # @param [Boolean] escape Escape html
+    # @param [String] code Ruby code
+    # @param [Array] content Temple expression
+    # @return [Array] Compiled temple expression
+    def on_slim_output(escape, code, content)
+      code += ' do' unless code =~ BLOCK_REGEX || empty_exp?(content)
+      [:slim, :output, escape, code, compile(content)]
+    end
+  end
+end

data/slim-5.2.1/lib/slim/embedded.rb

@@ -0,0 +1,248 @@
+# frozen_string_literal: true
+module Slim
+  # @api private
+  class TextCollector < Filter
+    def call(exp)
+      @collected = ''.dup
+      super(exp)
+      @collected
+    end
+
+    def on_slim_interpolate(text)
+      @collected << text
+      nil
+    end
+  end
+
+  # @api private
+  class NewlineCollector < Filter
+    def call(exp)
+      @collected = [:multi]
+      super(exp)
+      @collected
+    end
+
+    def on_newline
+      @collected << [:newline]
+      nil
+    end
+  end
+
+  # @api private
+  class OutputProtector < Filter
+    def call(exp)
+      @protect, @collected, @tag = [], ''.dup, object_id.abs.to_s(36)
+      super(exp)
+      @collected
+    end
+
+    def on_static(text)
+      @collected << text
+      nil
+    end
+
+    def on_slim_output(escape, text, content)
+      @collected << "%#{@tag}%#{@protect.length}%"
+      @protect << [:slim, :output, escape, text, content]
+      nil
+    end
+
+    def unprotect(text)
+      block = [:multi]
+      while text =~ /%#{@tag}%(\d+)%/
+        block << [:static, $`]
+        block << @protect[$1.to_i]
+        text = $'
+      end
+      block << [:static, text]
+    end
+  end
+
+  # Temple filter which processes embedded engines
+  # @api private
+  class Embedded < Filter
+    @engines = {}
+
+    class << self
+      attr_reader :engines
+
+      # Register embedded engine
+      #
+      # @param [String] name Name of the engine
+      # @param [Class]  klass Engine class
+      # @param option_filter List of options to pass to engine.
+      #                      Last argument can be default option hash.
+      def register(name, klass, *option_filter)
+        name = name.to_sym
+        local_options = option_filter.last.respond_to?(:to_hash) ? option_filter.pop.to_hash : {}
+        define_options(name, *option_filter)
+        klass.define_options(name)
+        engines[name.to_sym] = proc do |options|
+          klass.new({}.update(options).delete_if {|k,v| !option_filter.include?(k) && k != name }.update(local_options))
+        end
+      end
+
+      def create(name, options)
+        constructor = engines[name] || raise(Temple::FilterError, "Embedded engine #{name} not found")
+        constructor.call(options)
+      end
+    end
+
+    define_options :enable_engines, :disable_engines
+
+    def initialize(opts = {})
+      super
+      @engines = {}
+      @enabled = normalize_engine_list(options[:enable_engines])
+      @disabled = normalize_engine_list(options[:disable_engines])
+    end
+
+    def on_slim_embedded(name, body, attrs)
+      name = name.to_sym
+      raise(Temple::FilterError, "Embedded engine #{name} is disabled") unless enabled?(name)
+      @engines[name] ||= self.class.create(name, options)
+      @engines[name].on_slim_embedded(name, body, attrs)
+    end
+
+    def enabled?(name)
+      (!@enabled || @enabled.include?(name)) &&
+        (!@disabled || !@disabled.include?(name))
+    end
+
+    protected
+
+    def normalize_engine_list(list)
+      raise(ArgumentError, "Option :enable_engines/:disable_engines must be String or Symbol list") unless !list || Array === list
+      list && list.map(&:to_sym)
+    end
+
+    class Engine < Filter
+      protected
+
+      def collect_text(body)
+        @text_collector ||= TextCollector.new
+        @text_collector.call(body)
+      end
+
+      def collect_newlines(body)
+        @newline_collector ||= NewlineCollector.new
+        @newline_collector.call(body)
+      end
+    end
+
+    # Basic tilt engine
+    class TiltEngine < Engine
+      def on_slim_embedded(engine, body, attrs)
+        tilt_engine = Tilt[engine] || raise(Temple::FilterError, "Tilt engine #{engine} is not available.")
+        tilt_options = options[engine.to_sym] || {}
+        tilt_options[:default_encoding] ||= 'utf-8'
+        [:multi, tilt_render(tilt_engine, tilt_options, collect_text(body)), collect_newlines(body)]
+      end
+
+      protected
+
+      def tilt_render(tilt_engine, tilt_options, text)
+        [:static, tilt_engine.new(tilt_options) { text }.render]
+      end
+    end
+
+    # Sass engine which supports :pretty option
+    class SassEngine < TiltEngine
+      define_options :pretty
+
+      protected
+
+      def tilt_render(tilt_engine, tilt_options, text)
+        text = tilt_engine.new(tilt_options.merge(
+          style: options[:pretty] ? :expanded : :compressed
+        )) { text }.render
+        text = text.chomp
+        [:static, text]
+      end
+    end
+
+    # Static template with interpolated ruby code
+    class InterpolateTiltEngine < TiltEngine
+      def collect_text(body)
+        output_protector.call(interpolation.call(body))
+      end
+
+      def tilt_render(tilt_engine, tilt_options, text)
+        output_protector.unprotect(tilt_engine.new(tilt_options) { text }.render)
+      end
+
+      private
+
+      def interpolation
+        @interpolation ||= Interpolation.new
+      end
+
+      def output_protector
+        @output_protector ||= OutputProtector.new
+      end
+    end
+
+    # Tag wrapper engine
+    # Generates a html tag and wraps another engine (specified via :engine option)
+    class TagEngine < Engine
+      disable_option_validator!
+      set_options attributes: {}
+
+      def on_slim_embedded(engine, body, attrs)
+        unless options[:attributes].empty?
+          options[:attributes].map do |k, v|
+            attrs << [:html, :attr, k, [:static, v]]
+          end
+        end
+
+        if options[:engine]
+          opts = {}.update(options)
+          opts.delete(:engine)
+          opts.delete(:tag)
+          opts.delete(:attributes)
+          @engine ||= options[:engine].new(opts)
+          body = @engine.on_slim_embedded(engine, body, attrs)
+        end
+
+        [:html, :tag, options[:tag], attrs, body]
+      end
+    end
+
+    # Javascript wrapper engine.
+    # Like TagEngine, but can wrap content in html comment or cdata.
+    class JavaScriptEngine < TagEngine
+      disable_option_validator!
+
+      set_options tag: :script
+
+      def on_slim_embedded(engine, body, attrs)
+        super(engine, [:html, :js, body], attrs)
+      end
+    end
+
+    # Embeds ruby code
+    class RubyEngine < Engine
+      def on_slim_embedded(engine, body, attrs)
+        [:multi, [:newline], [:code, "#{collect_text(body)}\n"]]
+      end
+    end
+
+    # These engines are executed at compile time, embedded ruby is interpolated
+    register :markdown,   InterpolateTiltEngine
+    register :textile,    InterpolateTiltEngine
+    register :rdoc,       InterpolateTiltEngine
+
+    # These engines are executed at compile time
+    register :coffee,     JavaScriptEngine,                engine: TiltEngine
+    register :less,       TagEngine,          tag: :style, engine: TiltEngine
+    register :sass,       TagEngine, :pretty, tag: :style, engine: SassEngine
+    register :scss,       TagEngine, :pretty, tag: :style, engine: SassEngine
+
+    # Embedded javascript/css
+    register :javascript, JavaScriptEngine
+    register :css,        TagEngine, tag: :style
+
+    # Embedded ruby code
+    register :ruby,       RubyEngine
+  end
+end

data/slim-5.2.1/lib/slim/end_inserter.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+module Slim
+  # In Slim you don't need to close any blocks:
+  #
+  #   - if Slim.awesome?
+  #     | But of course it is!
+  #
+  # However, the parser is not smart enough (and that's a good thing) to
+  # automatically insert end's where they are needed. Luckily, this filter
+  # does *exactly* that (and it does it well!)
+  #
+  # @api private
+  class EndInserter < Filter
+    IF_RE = /\A(if|begin|unless|else|elsif|when|in|rescue|ensure)\b|\bdo\s*(\|[^\|]*\|)?\s*$/
+    ELSE_RE = /\A(else|elsif|when|in|rescue|ensure)\b/
+    END_RE = /\Aend\b/
+
+    # Handle multi expression `[:multi, *exps]`
+    #
+    # @return [Array] Corrected Temple expression with ends inserted
+    def on_multi(*exps)
+      result = [:multi]
+      # This variable is true if the previous line was
+      # (1) a control code and (2) contained indented content.
+      prev_indent = false
+
+      exps.each do |exp|
+        if control?(exp)
+          raise(Temple::FilterError, 'Explicit end statements are forbidden') if exp[2] =~ END_RE
+
+          # Two control code in a row. If this one is *not*
+          # an else block, we should close the previous one.
+          append_end(result) if prev_indent && exp[2] !~ ELSE_RE
+
+          # Indent if the control code starts a block.
+          prev_indent = exp[2] =~ IF_RE
+        elsif exp[0] != :newline && prev_indent
+          # This is *not* a control code, so we should close the previous one.
+          # Ignores newlines because they will be inserted after each line.
+          append_end(result)
+          prev_indent = false
+        end
+
+        result << compile(exp)
+      end
+
+      # The last line can be a control code too.
+      prev_indent ? append_end(result) : result
+    end
+
+    private
+
+    # Appends an end
+    def append_end(result)
+      result << [:code, 'end']
+    end
+
+    # Checks if an expression is a Slim control code
+    def control?(exp)
+      exp[0] == :slim && exp[1] == :control
+    end
+  end
+end

data/slim-5.2.1/lib/slim/engine.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+# The Slim module contains all Slim related classes (e.g. Engine, Parser).
+# Plugins might also reside within the Slim module (e.g. Include, Smart).
+# @api public
+module Slim
+  # Slim engine which transforms slim code to executable ruby code
+  # @api public
+  class Engine < Temple::Engine
+    # This overwrites some Temple default options or sets default options for Slim specific filters.
+    # It is recommended to set the default settings only once in the code and avoid duplication. Only use
+    # `define_options` when you have to override some default settings.
+    define_options pretty: false,
+                   sort_attrs: true,
+                   format: :xhtml,
+                   attr_quote: '"',
+                   merge_attrs: {'class' => ' '},
+                   generator: Temple::Generators::StringBuffer,
+                   default_tag: 'div'
+
+    filter :Encoding
+    filter :RemoveBOM
+    use Slim::Parser
+    use Slim::Embedded
+    use Slim::Interpolation
+    use Slim::Splat::Filter
+    use Slim::DoInserter
+    use Slim::EndInserter
+    use Slim::Controls
+    html :AttributeSorter
+    html :AttributeMerger
+    use Slim::CodeAttributes
+    use(:AttributeRemover) { Temple::HTML::AttributeRemover.new(remove_empty_attrs: options[:merge_attrs].keys) }
+    html :Pretty
+    filter :Ambles
+    filter :Escapable
+    filter :StaticAnalyzer
+    filter :ControlFlow
+    filter :MultiFlattener
+    filter :StaticMerger
+    use(:Generator) { options[:generator] }
+  end
+end

data/slim-5.2.1/lib/slim/erb_converter.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+require 'slim'
+
+module Slim
+  # Slim to ERB converter
+  #
+  # @example Conversion
+  #   Slim::ERBConverter.new(options).call(slim_code) # outputs erb_code
+  #
+  # @api public
+  class ERBConverter < Engine
+    replace :StaticMerger, Temple::Filters::CodeMerger
+    replace :Generator, Temple::Generators::ERB
+  end
+end

data/slim-5.2.1/lib/slim/filter.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+module Slim
+  # Base class for Temple filters used in Slim
+  #
+  # This base filter passes everything through and allows
+  # to override only some methods without affecting the rest
+  # of the expression.
+  #
+  # @api private
+  class Filter < Temple::HTML::Filter
+    # Pass-through handler
+    def on_slim_text(type, content)
+      [:slim, :text, type, compile(content)]
+    end
+
+    # Pass-through handler
+    def on_slim_embedded(type, content, attrs)
+      [:slim, :embedded, type, compile(content), attrs]
+    end
+
+    # Pass-through handler
+    def on_slim_control(code, content)
+      [:slim, :control, code, compile(content)]
+    end
+
+    # Pass-through handler
+    def on_slim_output(escape, code, content)
+      [:slim, :output, escape, code, compile(content)]
+    end
+  end
+end