super-pro-kit 0.0.1

data/slim-5.2.1/lib/slim/smart/parser.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+module Slim
+  module Smart
+    # @api private
+    class Parser < ::Slim::Parser
+      define_options implicit_text: true
+
+      def initialize(opts = {})
+        super
+        word_re = options[:implicit_text] ? '[_a-z0-9]' : '\p{Word}'
+        attr_keys = Regexp.union(@attr_shortcut.keys.sort_by { |k| -k.size })
+        @attr_shortcut_re = /\A(#{attr_keys}+)((?:\p{Word}|-)*)/
+        tag_keys = Regexp.union((@tag_shortcut.keys - @attr_shortcut.keys).sort_by { |k| -k.size })
+        @tag_re = /\A(?:#{attr_keys}(?=-*\p{Word})|#{tag_keys}|\*(?=[^\s]+)|(#{word_re}(?:#{word_re}|:|-)*#{word_re}|#{word_re}+))/
+      end
+
+      def unknown_line_indicator
+        if @line =~ /\A>( ?)/
+          # Found explicit text block.
+          @stacks.last << [:slim, :text, :explicit, parse_text_block($', @indents.last + $1.size + 1)]
+        else
+          unless options[:implicit_text]
+            syntax_error! 'Illegal shortcut' if @line =~ @attr_shortcut_re
+            super
+          end
+          # Found implicit smart text block.
+          if line = @lines.first
+            indent = (line =~ /\A\s*\Z/ ? @indents.last + 1 : get_indent(line))
+          end
+          @stacks.last << [:slim, :text, :implicit, parse_text_block(@line, indent)]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+require 'slim'
+require 'slim/smart/filter'
+require 'slim/smart/escaper'
+require 'slim/smart/parser'
+
+Slim::Engine.replace Slim::Parser, Slim::Smart::Parser
+Slim::Engine.after Slim::Smart::Parser, Slim::Smart::Filter
+Slim::Engine.after Slim::Interpolation, Slim::Smart::Escaper

data/slim-5.2.1/lib/slim/splat/builder.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+module Slim
+  class InvalidAttributeNameError < StandardError; end
+  module Splat
+    # @api private
+    class Builder
+      # https://html.spec.whatwg.org/multipage/syntax.html#attributes-2
+      INVALID_ATTRIBUTE_NAME_REGEX = /[ \0"'>\/=]/
+
+      def initialize(options)
+        @options = options
+        @attrs = {}
+      end
+
+      def code_attr(name, escape, value)
+        if delim = @options[:merge_attrs][name]
+          value = Array === value ? value.join(delim) : value.to_s
+          attr(name, escape_html(escape, value)) unless value.empty?
+        elsif @options[:hyphen_attrs].include?(name) && Hash === value
+          hyphen_attr(name, escape, value)
+        elsif value != false && value != nil
+          attr(name, escape_html(escape, value))
+        end
+      end
+
+      def splat_attrs(splat)
+        splat.each do |name, value|
+          code_attr(name.to_s, true, value)
+        end
+      end
+
+      def attr(name, value)
+        if name =~ INVALID_ATTRIBUTE_NAME_REGEX
+          raise InvalidAttributeNameError, "Invalid attribute name '#{name}' was rendered"
+        end
+        if @attrs[name]
+          if delim = @options[:merge_attrs][name]
+            @attrs[name] = @attrs[name].to_s + delim + value.to_s
+          else
+            raise("Multiple #{name} attributes specified")
+          end
+        else
+          @attrs[name] = value
+        end
+      end
+
+      def build_tag(&block)
+        tag = @attrs.delete('tag').to_s
+        tag = @options[:default_tag] if tag.empty?
+        if block
+          # This is a bit of a hack to get a universal capturing.
+          #
+          # TODO: Add this as a helper somewhere to solve these capturing issues
+          # once and for all.
+          #
+          # If we have Slim capturing disabled and the scope defines the method `capture` (i.e. Rails)
+          # we use this method to capture the content.
+          #
+          # otherwise we just use normal Slim capturing (yield).
+          #
+          # See https://github.com/slim-template/slim/issues/591
+          #     https://github.com/slim-template/slim#helpers-capturing-and-includes
+          #
+          content =
+            if @options[:disable_capture] && (scope = block.binding.eval('self')).respond_to?(:capture)
+              scope.capture(&block)
+            else
+              yield
+            end
+          "<#{tag}#{build_attrs}>#{content}</#{tag}>"
+        else
+          "<#{tag}#{build_attrs} />"
+        end
+      end
+
+      def build_attrs
+        attrs = @options[:sort_attrs] ? @attrs.sort_by(&:first) : @attrs
+        attrs.map do |k, v|
+          if v == true
+            if @options[:format] == :xhtml
+              " #{k}=#{@options[:attr_quote]}#{@options[:attr_quote]}"
+            else
+              " #{k}"
+            end
+          else
+            " #{k}=#{@options[:attr_quote]}#{v}#{@options[:attr_quote]}"
+          end
+        end.join
+      end
+
+      private
+
+      def hyphen_attr(name, escape, value)
+        if Hash === value
+          if @options[:hyphen_underscore_attrs]
+            value.each do |n, v|
+              hyphen_attr("#{name}-#{n.to_s.tr('_', '-')}", escape, v)
+            end
+          else
+            value.each do |n, v|
+              hyphen_attr("#{name}-#{n}", escape, v)
+            end
+          end
+        else
+          attr(name, escape_html(escape, value))
+        end
+      end
+
+      def escape_html(escape, value)
+        return value if !escape || value == true
+        @options[:use_html_safe] ? Temple::Utils.escape_html_safe(value) : Temple::Utils.escape_html(value)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+module Slim
+  module Splat
+    # @api private
+    class Filter < ::Slim::Filter
+      define_options :merge_attrs, :attr_quote, :sort_attrs, :default_tag, :format, :disable_capture,
+                     hyphen_attrs: %w(data aria), use_html_safe: ''.respond_to?(:html_safe?),
+                     hyphen_underscore_attrs: false
+
+      def call(exp)
+        @splat_options = nil
+        exp = compile(exp)
+        if @splat_options
+          opts = options.to_hash.reject { |k, v| !Filter.options.valid_key?(k) }.inspect
+          [:multi, [:code, "#{@splat_options} = #{opts}"], exp]
+        else
+          exp
+        end
+      end
+
+      # Handle tag expression `[:html, :tag, name, attrs, content]`
+      #
+      # @param [String] name Tag name
+      # @param [Array] attrs Temple expression
+      # @param [Array] content Temple expression
+      # @return [Array] Compiled temple expression
+      def on_html_tag(name, attrs, content = nil)
+        return super if name != '*'
+        builder, block = make_builder(attrs[2..-1])
+        if content
+          [:multi,
+           block,
+           [:slim, :output, false,
+            "#{builder}.build_tag #{empty_exp?(content) ? '{}' : 'do'}",
+            compile(content)]]
+        else
+          [:multi,
+           block,
+           [:dynamic, "#{builder}.build_tag"]]
+        end
+      end
+
+      # Handle attributes expression `[:html, :attrs, *attrs]`
+      #
+      # @param [Array] attrs Array of temple expressions
+      # @return [Array] Compiled temple expression
+      def on_html_attrs(*attrs)
+        if attrs.any? { |attr| splat?(attr) }
+          builder, block = make_builder(attrs)
+          [:multi,
+           block,
+           [:dynamic, "#{builder}.build_attrs"]]
+        else
+          super
+        end
+      end
+
+      protected
+
+      def splat?(attr)
+        # Splat attribute given
+        attr[0] == :slim && attr[1] == :splat ||
+          # Hyphenated attribute also needs splat handling
+          (attr[0] == :html && attr[1] == :attr && options[:hyphen_attrs].include?(attr[2]) &&
+           attr[3][0] == :slim && attr[3][1] == :attrvalue)
+      end
+
+      def make_builder(attrs)
+        @splat_options ||= unique_name
+        builder = unique_name
+        result = [:multi, [:code, "#{builder} = ::Slim::Splat::Builder.new(#{@splat_options})"]]
+        attrs.each do |attr|
+          result <<
+            if attr[0] == :html && attr[1] == :attr
+              if attr[3][0] == :slim && attr[3][1] == :attrvalue
+                [:code, "#{builder}.code_attr(#{attr[2].inspect}, #{attr[3][2]}, (#{attr[3][3]}))"]
+              else
+                tmp = unique_name
+                [:multi,
+                 [:capture, tmp, compile(attr[3])],
+                 [:code, "#{builder}.attr(#{attr[2].inspect}, #{tmp})"]]
+              end
+            elsif attr[0] == :slim && attr[1] == :splat
+              [:code, "#{builder}.splat_attrs((#{attr[2]}))"]
+            else
+              attr
+            end
+        end
+        [builder, result]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+module Slim
+  # Tilt template implementation for Slim
+  # @api public
+  Template = Temple::Templates::Tilt(Slim::Engine, register_as: :slim)
+end

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

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+require 'slim'
+
+module Slim
+  # @api private
+  class Translator < Filter
+    define_options :tr,
+                   tr_mode: :dynamic,
+                   tr_fn: '_'
+
+    if defined?(::I18n)
+      set_options tr_fn: '::Slim::Translator.i18n_text',
+                  tr: true
+    elsif defined?(::GetText)
+      set_options tr_fn: '::GetText._',
+                  tr: true
+    elsif defined?(::FastGettext)
+      set_options tr_fn: '::FastGettext::Translation._',
+                  tr: true
+    end
+
+    def self.i18n_text(text)
+      I18n.t!(text)
+    rescue I18n::MissingTranslationData
+      text
+    end
+
+    def self.i18n_key(text)
+      key = text.parameterize.underscore
+      I18n.t!(key)
+    rescue I18n::MissingTranslationData
+      text
+    end
+
+    def call(exp)
+      options[:tr] ? super : exp
+    end
+
+    def initialize(opts = {})
+      super
+      case options[:tr_mode]
+      when :static
+        @translator = StaticTranslator.new(tr_fn: options[:tr_fn])
+      when :dynamic
+        @translator = DynamicTranslator.new(tr_fn: options[:tr_fn])
+      else
+        raise ArgumentError, "Invalid translator mode #{options[:tr_mode].inspect}"
+      end
+    end
+
+    def on_slim_text(type, exp)
+      [:slim, :text, type, @translator.call(exp)]
+    end
+
+    private
+
+    class StaticTranslator < Filter
+      define_options :tr_fn
+
+      def initialize(opts = {})
+        super
+        @translate = eval("proc {|string| #{options[:tr_fn]}(string) }")
+      end
+
+      def call(exp)
+        @text, @captures = ''.dup, []
+        result = compile(exp)
+
+        text = @translate.call(@text)
+        while text =~ /%(\d+)/
+          result << [:static, $`] << @captures[$1.to_i - 1]
+          text = $'
+        end
+        result << [:static, text]
+      end
+
+      def on_static(text)
+        @text << text
+        [:multi]
+      end
+
+      def on_slim_output(escape, code, content)
+        @captures << [:slim, :output, escape, code, content]
+        @text << "%#{@captures.size}"
+        [:multi]
+      end
+    end
+
+    class DynamicTranslator < Filter
+      define_options :tr_fn
+
+      def call(exp)
+        @captures_count, @captures_var, @text = 0, unique_name, ''.dup
+
+        result = compile(exp)
+
+        if @captures_count > 0
+          result.insert(1, [:code, "#{@captures_var}=[]"])
+          result << [:slim, :output, false, "#{options[:tr_fn]}(#{@text.inspect}).gsub(/%(\\d+)/) { #{@captures_var}[$1.to_i-1] }", [:multi]]
+        else
+          result << [:slim, :output, false, "#{options[:tr_fn]}(#{@text.inspect})", [:multi]]
+        end
+      end
+
+      def on_static(text)
+        @text << text
+        [:multi]
+      end
+
+      def on_slim_output(escape, code, content)
+        @captures_count += 1
+        @text << "%#{@captures_count}"
+        [:capture, "#{@captures_var}[#{@captures_count - 1}]", [:slim, :output, escape, code, content]]
+      end
+    end
+  end
+end
+
+Slim::Engine.before Slim::EndInserter, Slim::Translator

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

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+module Slim
+  # Slim version string
+  # @api public
+  VERSION = '5.2.1'
+end

data/slim-5.2.1/lib/slim.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+require 'temple'
+require 'slim/parser'
+require 'slim/filter'
+require 'slim/do_inserter'
+require 'slim/end_inserter'
+require 'slim/embedded'
+require 'slim/interpolation'
+require 'slim/controls'
+require 'slim/splat/filter'
+require 'slim/splat/builder'
+require 'slim/code_attributes'
+require 'slim/engine'
+require 'slim/template'
+require 'slim/version'
+require 'slim/railtie' if defined?(Rails::Railtie)

data/slim-5.2.1/slim.gemspec

@@ -0,0 +1,33 @@
+require File.dirname(__FILE__) + '/lib/slim/version'
+require 'date'
+
+Gem::Specification.new do |s|
+  s.name              = 'slim'
+  s.version           = Slim::VERSION
+  s.date              = Date.today.to_s
+  s.authors           = ['Daniel Mendler', 'Andrew Stone', 'Fred Wu']
+  s.email             = ['mail@daniel-mendler.de', 'andy@stonean.com', 'ifredwu@gmail.com']
+  s.summary           = 'Slim is a template language.'
+  s.description       = 'Slim is a template language whose goal is reduce the syntax to the essential parts without becoming cryptic.'
+  s.homepage          = 'https://slim-template.github.io/'
+  s.license           = 'MIT'
+
+  s.metadata = {
+    "bug_tracker_uri"   => "https://github.com/slim-template/slim/issues",
+    "changelog_uri"     => "https://github.com/slim-template/slim/blob/main/CHANGES",
+    "documentation_uri" => "https://rubydoc.info/gems/slim/frames",
+    "homepage_uri"      => "https://slim-template.github.io/",
+    "source_code_uri"   => "https://github.com/slim-template/slim",
+    "wiki_uri"          => "https://github.com/slim-template/slim/wiki",
+    "funding_uri"       => "https://github.com/sponsors/slim-template"
+  }
+
+  s.files             = `git ls-files`.split("\n")
+  s.executables       = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths     = %w(lib)
+
+  s.required_ruby_version = '>= 2.5.0'
+
+  s.add_runtime_dependency('temple', ['~> 0.10.0'])
+  s.add_runtime_dependency('tilt', ['>= 2.1.0'])
+end

data/slim-5.2.1/test/core/helper.rb

@@ -0,0 +1,201 @@
+begin
+  require 'simplecov'
+  SimpleCov.start
+rescue LoadError
+end
+
+require 'minitest/autorun'
+require 'slim'
+require 'slim/grammar'
+
+Slim::Engine.after  Slim::Parser, Temple::Filters::Validator, grammar: Slim::Grammar
+Slim::Engine.before :Pretty, Temple::Filters::Validator
+
+class TestSlim < Minitest::Test
+  def setup
+    @env = Env.new
+  end
+
+  def render(source, options = {}, &block)
+    scope = options.delete(:scope)
+    locals = options.delete(:locals)
+    Slim::Template.new(options[:file], options) { source }.render(scope || @env, locals, &block)
+  end
+
+  class HtmlSafeString < String
+    def html_safe?
+      true
+    end
+
+    def to_s
+      self
+    end
+  end
+
+  def with_html_safe
+    String.send(:define_method, :html_safe?) { false }
+    String.send(:define_method, :html_safe) { HtmlSafeString.new(self) }
+    yield
+  ensure
+    String.send(:undef_method, :html_safe?) if String.method_defined?(:html_safe?)
+    String.send(:undef_method, :html_safe) if String.method_defined?(:html_safe)
+  end
+
+  def assert_html(expected, source, options = {}, &block)
+    assert_equal expected, render(source, options, &block)
+  end
+
+  def assert_syntax_error(message, source, options = {})
+    render(source, options)
+    raise 'Syntax error expected'
+  rescue Slim::Parser::SyntaxError => ex
+    assert_equal message, ex.message
+    message =~ /([^\s]+), Line (\d+)/
+    assert_backtrace ex, "#{$1}:#{$2}"
+  end
+
+  def assert_ruby_error(error, from, source, options = {})
+    render(source, options)
+    raise 'Ruby error expected'
+  rescue error => ex
+    assert_backtrace(ex, from)
+  end
+
+  def assert_backtrace(ex, from)
+    ex.backtrace[0] =~ /([^\s]+:\d+)/
+    assert_equal from, $1
+  end
+
+  def assert_ruby_syntax_error(from, source, options = {})
+    render(source, options)
+    raise 'Ruby syntax error expected'
+  rescue SyntaxError => ex
+    ex.message =~ /([^\s]+:\d+):/
+    assert_equal from, $1
+  end
+
+  def assert_runtime_error(message, source, options = {})
+    render(source, options)
+    raise Exception, 'Runtime error expected'
+  rescue RuntimeError => ex
+    assert_equal message, ex.message
+  end
+end
+
+class Env
+  attr_reader :var, :x
+
+  def initialize
+    @var = 'instance'
+    @x = 0
+  end
+
+  def id_helper
+    "notice"
+  end
+
+  def hash
+    {a: 'The letter a', b: 'The letter b'}
+  end
+
+  def show_first?(show = false)
+    show
+  end
+
+  def define_macro(name, &block)
+    @macro ||= {}
+    @macro[name.to_s] = block
+    ''
+  end
+
+  def call_macro(name, *args)
+    @macro[name.to_s].call(*args)
+  end
+
+  def hello_world(text = "Hello World from @env", opts = {})
+    text = text + (opts.to_a * " ") if opts.any?
+    if block_given?
+      "#{text} #{yield} #{text}"
+    else
+      text
+    end
+  end
+
+  def message(*args)
+    args.join(' ')
+  end
+
+  def action_path(*args)
+    "/action-#{args.join('-')}"
+  end
+
+  def in_keyword
+    "starts with keyword"
+  end
+
+  def evil_method
+    "<script>do_something_evil();</script>"
+  end
+
+  def output_number
+    1337
+  end
+
+  def succ_x
+    @x = @x.succ
+  end
+
+end
+
+class ViewEnv
+  def output_number
+     1337
+  end
+
+  def person
+    [{name: 'Joe'}, {name: 'Jack'}]
+  end
+
+  def people
+    %w(Andy Fred Daniel).collect{|n| Person.new(n)}
+  end
+
+  def cities
+    %w{Atlanta Melbourne Karlsruhe}
+  end
+
+  def people_with_locations
+    array = []
+    people.each_with_index do |p,i|
+      p.location = Location.new cities[i]
+      array << p
+    end
+    array
+  end
+end
+
+require 'forwardable'
+
+class Person
+  extend Forwardable
+
+  attr_accessor :name
+
+  def initialize(name)
+    @name = name
+  end
+
+  def location=(location)
+    @location = location
+  end
+
+  def_delegators :@location, :city
+end
+
+class Location
+  attr_accessor :city
+
+  def initialize(city)
+    @city   = city
+  end
+end