mega-quick-lib 0.0.1

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+module Slim
+  # Slim expression grammar
+  # @api private
+  module Grammar
+    extend Temple::Grammar
+
+    TextTypes << :verbatim | :explicit | :implicit | :inline
+
+    Expression <<
+      [:slim, :control, String, Expression]                 |
+      [:slim, :output, Bool, String, Expression]            |
+      [:slim, :interpolate, String]                         |
+      [:slim, :embedded, String, Expression, HTMLAttrGroup] |
+      [:slim, :text, TextTypes, Expression]                 |
+      [:slim, :attrvalue, Bool, String]
+
+    HTMLAttr <<
+      [:slim, :splat, String]
+
+    HTMLAttrGroup <<
+      [:html, :attrs, 'HTMLAttr*']
+  end
+end

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

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+require 'slim'
+
+module Slim
+  # Handles inlined includes
+  #
+  # Slim files are compiled, non-Slim files are included as text with `#{interpolation}`
+  #
+  # @api private
+  class Include < Slim::Filter
+    define_options :file, include_dirs: [Dir.pwd, '.']
+
+    def on_html_tag(tag, attributes, content = nil)
+      return super if tag != 'include'
+      name = content.to_a.flatten.select {|s| String === s }.join
+      raise ArgumentError, 'Invalid include statement' unless attributes == [:html, :attrs] && !name.empty?
+      unless file = find_file(name)
+        name = "#{name}.slim" if name !~ /\.slim\Z/i
+        file = find_file(name)
+      end
+      raise Temple::FilterError, "'#{name}' not found in #{options[:include_dirs].join(':')}" unless file
+      content = File.read(file)
+      if file =~ /\.slim\Z/i
+        Thread.current[:slim_include_engine].call(content)
+      else
+        [:slim, :interpolate, content]
+      end
+    end
+
+    protected
+
+    def find_file(name)
+      current_dir = File.dirname(File.expand_path(options[:file]))
+      options[:include_dirs].map {|dir| File.expand_path(File.join(dir, name), current_dir) }.find {|file| File.file?(file) }
+    end
+  end
+
+  class Engine
+    after Slim::Parser, Slim::Include
+    after Slim::Include, :stop do |exp|
+      throw :stop, exp if Thread.current[:slim_include_level] > 1
+      exp
+    end
+
+    # @api private
+    alias call_without_include call
+
+    # @api private
+    def call(input)
+      Thread.current[:slim_include_engine] = self
+      Thread.current[:slim_include_level] ||= 0
+      Thread.current[:slim_include_level] += 1
+      catch(:stop) { call_without_include(input) }
+    ensure
+      Thread.current[:slim_include_engine] = nil if (Thread.current[:slim_include_level] -= 1) == 0
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+module Slim
+  # Perform interpolation of #{var_name} in the
+  # expressions `[:slim, :interpolate, string]`.
+  #
+  # @api private
+  class Interpolation < Filter
+    # Handle interpolate expression `[:slim, :interpolate, string]`
+    #
+    # @param [String] string Static interpolate
+    # @return [Array] Compiled temple expression
+    def on_slim_interpolate(string)
+      # Interpolate variables in text (#{variable}).
+      # Split the text into multiple dynamic and static parts.
+      block = [:multi]
+      begin
+        case string
+        when /\A\\#\{/
+          # Escaped interpolation
+          block << [:static, '#{']
+          string = $'
+        when /\A#\{((?>[^{}]|(\{(?>[^{}]|\g<1>)*\}))*)\}/
+          # Interpolation
+          string, code = $', $1
+          escape = code !~ /\A\{.*\}\Z/
+          block << [:slim, :output, escape, escape ? code : code[1..-2], [:multi]]
+        when /\A([#\\]?[^#\\]*([#\\][^\\#\{][^#\\]*)*)/
+          # Static text
+          block << [:static, $&]
+          string = $'
+        end
+      end until string.empty?
+      block
+    end
+  end
+end

data/slim-5.2.1/lib/slim/logic_less/context.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+module Slim
+  class LogicLess
+    # @api private
+    class Context
+      def initialize(dict, lookup)
+        @scope = [Scope.new(dict, lookup)]
+      end
+
+      def [](name)
+        scope[name]
+      end
+
+      def lambda(name)
+        scope.lambda(name) do |*dict|
+          if dict.empty?
+            yield
+          else
+            new_scope do
+              dict.inject(''.dup) do |result, d|
+                scope.dict = d
+                result << yield
+              end
+            end
+          end
+        end
+      end
+
+      def section(name)
+        if dict = scope[name]
+          if !dict.respond_to?(:has_key?) && dict.respond_to?(:each)
+            new_scope do
+              dict.each do |d|
+                scope.dict = d
+                yield
+              end
+            end
+          else
+            new_scope(dict) { yield }
+          end
+        end
+      end
+
+      def inverted_section(name)
+        value = scope[name]
+        yield if !value || (value.respond_to?(:empty?) && value.empty?)
+      end
+
+      def to_s
+        scope.to_s
+      end
+
+      private
+
+      class Scope
+        attr_reader :lookup
+        attr_writer :dict
+
+        def initialize(dict, lookup, parent = nil)
+          @dict, @lookup, @parent = dict, lookup, parent
+        end
+
+        def lambda(name, &block)
+          @lookup.each do |lookup|
+            case lookup
+            when :method
+              return @dict.public_send(name, &block) if @dict.respond_to?(name, false)
+            when :symbol
+              return @dict[name].call(&block) if has_key?(name)
+            when :string
+              return @dict[name.to_s].call(&block) if has_key?(name.to_s)
+            when :instance_variable
+              var_name = "@#{name}"
+              return @dict.instance_variable_get(var_name).call(&block) if instance_variable?(var_name)
+            end
+          end
+          @parent.lambda(name, &block) if @parent
+        end
+
+        def [](name)
+          @lookup.each do |lookup|
+            case lookup
+            when :method
+              return @dict.public_send(name) if @dict.respond_to?(name, false)
+            when :symbol
+              return @dict[name] if has_key?(name)
+            when :string
+              return @dict[name.to_s] if has_key?(name.to_s)
+            when :instance_variable
+              var_name = "@#{name}"
+              return @dict.instance_variable_get(var_name) if instance_variable?(var_name)
+            end
+          end
+          @parent[name] if @parent
+        end
+
+        def to_s
+          @dict.to_s
+        end
+
+        private
+
+        def has_key?(name)
+          @dict.respond_to?(:has_key?) && @dict.has_key?(name)
+        end
+
+        def instance_variable?(name)
+          @dict.instance_variable_defined?(name)
+        rescue NameError
+          false
+        end
+      end
+
+      def scope
+        @scope.last
+      end
+
+      def new_scope(dict = nil)
+        @scope << Scope.new(dict, scope.lookup, scope)
+        yield
+      ensure
+        @scope.pop
+      end
+    end
+  end
+end

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

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+module Slim
+  # Handle logic less mode
+  # This filter can be activated with the option "logic_less"
+  # @api private
+  class LogicLess < Filter
+    # Default dictionary access order, change it with the option :dictionary_access
+    DEFAULT_ACCESS_ORDER = [:symbol, :string, :method, :instance_variable].freeze
+
+    define_options logic_less: true,
+                   dictionary: 'self',
+                   dictionary_access: DEFAULT_ACCESS_ORDER
+
+    def initialize(opts = {})
+      super
+      access = [options[:dictionary_access]].flatten.compact
+      access.each do |type|
+        raise ArgumentError, "Invalid dictionary access #{type.inspect}" unless DEFAULT_ACCESS_ORDER.include?(type)
+      end
+      raise ArgumentError, 'Option dictionary access is missing' if access.empty?
+      @access = access.inspect
+    end
+
+    def call(exp)
+      if options[:logic_less]
+        @context = unique_name
+        [:multi,
+         [:code, "#{@context} = ::Slim::LogicLess::Context.new(#{options[:dictionary]}, #{@access})"],
+         super]
+      else
+        exp
+      end
+    end
+
+    # Interpret control blocks as sections or inverted sections
+    def on_slim_control(name, content)
+      method =
+        if name =~ /\A!\s*(.*)/
+          name = $1
+          'inverted_section'
+        else
+          'section'
+        end
+      [:block, "#{@context}.#{method}(#{name.to_sym.inspect}) do", compile(content)]
+    end
+
+    def on_slim_output(escape, name, content)
+      [:slim, :output, escape, empty_exp?(content) ? access(name) :
+       "#{@context}.lambda(#{name.to_sym.inspect}) do", compile(content)]
+    end
+
+    def on_slim_attrvalue(escape, value)
+      [:slim, :attrvalue, escape, access(value)]
+    end
+
+    def on_slim_splat(code)
+      [:slim, :splat, access(code)]
+    end
+
+    def on_dynamic(code)
+      raise Temple::FilterError, 'Embedded code is forbidden in logic less mode'
+    end
+
+    def on_code(code)
+      raise Temple::FilterError, 'Embedded code is forbidden in logic less mode'
+    end
+
+    private
+
+    def access(name)
+      case name
+      when 'yield'
+        'yield'
+      when 'self'
+        "#{@context}.to_s"
+      else
+        "#{@context}[#{name.to_sym.inspect}]"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+require 'slim'
+require 'slim/logic_less/filter'
+require 'slim/logic_less/context'
+
+Slim::Engine.after Slim::Interpolation, Slim::LogicLess