ultra-lite-tool 0.0.1

data/haml-7.2.0/lib/haml/filters/tilt_base.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+require 'tilt'
+
+module Haml
+  class Filters
+    class TiltBase < Base
+      def self.render(name, source, indent_width: 0)
+        text = ::Tilt["t.#{name}"].new { source }.render
+        return text if indent_width == 0
+        if text.frozen?
+          text.gsub(/^/, ' ' * indent_width)
+        else
+          text.gsub!(/^/, ' ' * indent_width)
+        end
+      end
+
+      def explicit_require?(needed_registration)
+        Gem::Version.new(Tilt::VERSION) >= Gem::Version.new('2.0.0') &&
+          !Tilt.registered?(needed_registration)
+      end
+
+      private
+
+      # TODO: support interpolation
+      def precompiled_with_tilt(node, name)
+        src = ::Tilt["t.#{name}"].new { node.value[:text] }.send(:precompiled, {}).first
+        [:dynamic, src]
+      end
+
+      def compile_with_tilt(node, name, indent_width: 0)
+        if ::Haml::Util.contains_interpolation?(node.value[:text])
+          dynamic_compile(node, name, indent_width: indent_width)
+        else
+          static_compile(node, name, indent_width: indent_width)
+        end
+      end
+
+      def static_compile(node, name, indent_width: 0)
+        temple = [:multi, [:static, TiltBase.render(name, node.value[:text], indent_width: indent_width)]]
+        node.value[:text].split("\n").size.times do
+          temple << [:newline]
+        end
+        temple
+      end
+
+      def dynamic_compile(node, name, indent_width: 0)
+        # original: Haml::Filters#compile
+        text = ::Haml::Util.unescape_interpolation(node.value[:text]).gsub(/(\\+)n/) do |s|
+          escapes = $1.size
+          next s if escapes % 2 == 0
+          "#{'\\' * (escapes - 1)}\n"
+        end
+        text.prepend("\n").sub!(/\n"\z/, '"')
+
+        [:dynamic, "::Haml::Filters::TiltBase.render('#{name}', #{text}, indent_width: #{indent_width})"]
+      end
+    end
+  end
+end

data/haml-7.2.0/lib/haml/filters.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+require 'haml/filters/base'
+require 'haml/filters/text_base'
+require 'haml/filters/tilt_base'
+require 'haml/filters/coffee'
+require 'haml/filters/css'
+require 'haml/filters/erb'
+require 'haml/filters/escaped'
+require 'haml/filters/javascript'
+require 'haml/filters/less'
+require 'haml/filters/markdown'
+require 'haml/filters/plain'
+require 'haml/filters/preserve'
+require 'haml/filters/ruby'
+require 'haml/filters/sass'
+require 'haml/filters/scss'
+require 'haml/filters/cdata'
+
+module Haml
+  class Filters
+    @registered = {}
+
+    class << self
+      attr_reader :registered
+
+      def remove_filter(name)
+        registered.delete(name.to_s.downcase.to_sym)
+        if constants.map(&:to_s).include?(name.to_s)
+          remove_const name.to_sym
+        end
+      end
+
+      private
+
+      def register(name, compiler)
+        registered[name] = compiler
+      end
+    end
+
+    register :coffee,       Coffee
+    register :coffeescript, CoffeeScript
+    register :css,          Css
+    register :erb,          Erb
+    register :escaped,      Escaped
+    register :javascript,   Javascript
+    register :less,         Less
+    register :markdown,     Markdown
+    register :plain,        Plain
+    register :preserve,     Preserve
+    register :ruby,         Ruby
+    register :sass,         Sass
+    register :scss,         Scss
+    register :cdata,        Cdata
+
+    def initialize(options = {})
+      @options = options
+      @compilers = {}
+    end
+
+    def compile(node)
+      node.value[:text] ||= ''
+      find_compiler(node).compile(node)
+    end
+
+    private
+
+    def find_compiler(node)
+      name = node.value[:name].to_sym
+      compiler = Filters.registered[name]
+      raise FilterNotFound.new("FilterCompiler for '#{name}' was not found", node.line.to_i - 1) unless compiler
+
+      @compilers[name] ||= compiler.new(@options)
+    end
+  end
+end

data/haml-7.2.0/lib/haml/force_escape.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+require 'haml/escape'
+
+module Haml
+  # This module allows Temple::Filter to dispatch :fescape on `#compile`.
+  module FescapeDispathcer
+    def on_fescape(flag, exp)
+      [:fescape, flag, compile(exp)]
+    end
+  end
+  ::Temple::Filter.include FescapeDispathcer
+
+  # Unlike Haml::Escape, this escapes value even if it's html_safe.
+  class ForceEscape < Escape
+    def initialize(opts = {})
+      super
+      @escape_code = options[:escape_code] || "::Haml::Util.escape_html((%s))"
+      @escaper = eval("proc {|v| #{@escape_code % 'v'} }")
+    end
+
+    alias_method :on_fescape, :on_escape
+
+    # ForceEscape doesn't touch :escape expression.
+    # This method is not used if it's inserted after Haml::Escape.
+    def on_escape(flag, exp)
+      [:escape, flag, compile(exp)]
+    end
+  end
+end

data/haml-7.2.0/lib/haml/helpers.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+module Haml
+  module Helpers
+    def self.preserve(input)
+      s = input.to_s.chomp("\n")
+      s.gsub!(/\n/, '
')
+      s.delete!("\r")
+      s
+    end
+
+    def preserve(input)
+      Helpers.preserve(input)
+    end
+  end
+end

data/haml-7.2.0/lib/haml/html.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+module Haml
+  class HTML < Temple::HTML::Fast
+    DEPRECATED_FORMATS = %i[html4 html5].freeze
+
+    def initialize(opts = {})
+      if DEPRECATED_FORMATS.include?(opts[:format])
+        opts = opts.dup
+        opts[:format] = :html
+      end
+      super(opts)
+    end
+
+    # This dispatcher supports Haml's "revealed" conditional comment.
+    def on_html_condcomment(condition, content, revealed = false)
+      on_html_comment [:multi,
+                       [:static, "[#{condition}]>#{'<!-->' if revealed}"],
+                       content,
+                       [:static, "#{'<!--' if revealed}<![endif]"]]
+    end
+  end
+end

data/haml-7.2.0/lib/haml/identity.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+module Haml
+  class Identity
+    def initialize
+      @unique_id = 0
+    end
+
+    def generate
+      @unique_id += 1
+      "_haml_compiler#{@unique_id}"
+    end
+  end
+end

data/haml-7.2.0/lib/haml/object_ref.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+module Haml
+  module ObjectRef
+    class << self
+      def parse(args)
+        object, prefix = args
+        return {} unless object
+
+        suffix =
+          if object.respond_to?(:haml_object_ref)
+            object.haml_object_ref
+          else
+            underscore(object.class)
+          end
+        {
+          'class' => [prefix, suffix].compact.join('_'),
+          'id'    => [prefix, suffix, object.id || 'new'].compact.join('_'),
+        }
+      end
+
+      private
+
+      # Haml::Buffer.underscore
+      def underscore(camel_cased_word)
+        word = camel_cased_word.to_s.dup
+        word.gsub!(/::/, '_')
+        word.gsub!(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+        word.gsub!(/([a-z\d])([A-Z])/, '\1_\2')
+        word.tr!('-', '_')
+        word.downcase!
+        word
+      end
+    end
+  end
+end