slimi 0.4.1 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 299f0ea50391c15aed1b99b4fb2cb1a8eae63a3ba97e2abc31cf676472a38cd8
-  data.tar.gz: 6119285d8a753ab001bf29eff8df574dfab52636fc092d324db50ec7d094e7eb
+  metadata.gz: 12b1a25a767a9ca17da4d9d99cf520d857131cd9d28acaf73d18a7696354c694
+  data.tar.gz: fee58aeb65387fd4846e74ce6885bb96e97dca9db3f2f95578693e20752249a6
 SHA512:
-  metadata.gz: 9269ec0c3c35efd6665a3f7aff882737479b72998b28cc067a80823885316a267958f3bf2a62107c7d56fd31bb12675f17b77053f7372c40fe768e3865775c13
-  data.tar.gz: 7c03ac659b980eb512c87c0fa8a3bc2b991faac079f71426e67a3ede722455677b3647d7ceb8af286aae3a38730b4e42c40ac07a62662c2db7d34339060a6055
+  metadata.gz: d97004ce75686f701d0a27bb8ac200e56956d5556fe4dbc874e523870d4c0467ee6eba5d5a1d7e34fc6d792d6df17ec85df689a297e94be56d44dadd33902c66
+  data.tar.gz: d719cc21f5288051ae6e7be83cb1f85e82000dc0e7345160d0087f3d61d9aab9a17ce45978437ceefa6d47ce063034022170e2062fd5404ee4182f245edf0792

data/.rubocop.yml

@@ -1,3 +1,6 @@
+require:
+  - rubocop-rspec
+
 AllCops:
   NewCops: enable
   SuggestExtensions: false
@@ -12,5 +15,21 @@ Lint/InterpolationCheck:
 Metrics:
   Enabled: false
 
+RSpec/AnyInstance:
+  Enabled: false
+
+RSpec/ImplicitSubject:
+  Enabled: false
+
+RSpec/MultipleExpectations:
+  Enabled: false
+
+RSpec/NamedSubject:
+  Enabled: false
+
+Security/Eval:
+  Exclude:
+    - 'spec/**/*.rb'
+
 Style/Documentation:
   Enabled: false

data/CHANGELOG.md

@@ -2,6 +2,42 @@
 
 ## Unreleased
 
+## 0.6.0 - 2022-01-03
+
+### Added
+
+- Support annotate_rendered_view_with_filenames.
+
+### Changed
+
+- Rename expression name from slim to slimi.
+
+### Fixed
+
+- Fix bug at registering handler to ActionView.
+- Fix Engine options at RailsTemplateHandler.
+- Define missing :generator option at Engine.
+
+## 0.5.1 - 2022-01-02
+
+### Changed
+
+- Wrap slim attrvalue by slimi position expression.
+
+## 0.5.0 - 2022-01-02
+
+### Added
+
+- Add Slimi::Engine.
+
+## 0.4.2 - 2021-12-27
+
+### Fixed
+
+- Fix bug on quoted attribute parser.
+- Remove trailing line-ending from source line of syntax error message.
+- Support multi-line attributes.
+
 ## 0.4.1 - 2021-12-26
 
 ### Fixed
@@ -24,7 +60,7 @@
 
 ### Added
 
-- Support unquoted attributes.
+- Support Ruby attributes.
 
 ### Fixed
 

data/Gemfile

@@ -5,7 +5,8 @@ source 'https://rubygems.org'
 # Specify your gem's dependencies in slimi.gemspec
 gemspec
 
+gem 'actionview'
 gem 'rake', '~> 13.0'
-gem 'rspec', '~> 3.0'
-gem 'rubocop', '~> 1.21'
-gem 'slim'
+gem 'rspec'
+gem 'rubocop'
+gem 'rubocop-rspec'

data/Gemfile.lock

@@ -1,17 +1,47 @@
 PATH
   remote: .
   specs:
-    slimi (0.4.1)
+    slimi (0.6.0)
       temple
+      tilt
 
 GEM
   remote: https://rubygems.org/
   specs:
+    actionview (7.0.0)
+      activesupport (= 7.0.0)
+      builder (~> 3.1)
+      erubi (~> 1.4)
+      rails-dom-testing (~> 2.0)
+      rails-html-sanitizer (~> 1.1, >= 1.2.0)
+    activesupport (7.0.0)
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      i18n (>= 1.6, < 2)
+      minitest (>= 5.1)
+      tzinfo (~> 2.0)
     ast (2.4.2)
+    builder (3.2.4)
+    concurrent-ruby (1.1.9)
+    crass (1.0.6)
     diff-lcs (1.4.4)
+    erubi (1.10.0)
+    i18n (1.8.11)
+      concurrent-ruby (~> 1.0)
+    loofah (2.13.0)
+      crass (~> 1.0.2)
+      nokogiri (>= 1.5.9)
+    minitest (5.15.0)
+    nokogiri (1.12.5-x86_64-linux)
+      racc (~> 1.4)
     parallel (1.21.0)
     parser (3.0.3.2)
       ast (~> 2.4.1)
+    racc (1.6.0)
+    rails-dom-testing (2.0.3)
+      activesupport (>= 4.2.0)
+      nokogiri (>= 1.6)
+    rails-html-sanitizer (1.4.2)
+      loofah (~> 2.3)
     rainbow (3.0.0)
     rake (13.0.6)
     regexp_parser (2.2.0)
@@ -40,22 +70,24 @@ GEM
       unicode-display_width (>= 1.4.0, < 3.0)
     rubocop-ast (1.15.0)
       parser (>= 3.0.1.1)
+    rubocop-rspec (2.6.0)
+      rubocop (~> 1.19)
     ruby-progressbar (1.11.0)
-    slim (4.1.0)
-      temple (>= 0.7.6, < 0.9)
-      tilt (>= 2.0.6, < 2.1)
     temple (0.8.2)
     tilt (2.0.10)
+    tzinfo (2.0.4)
+      concurrent-ruby (~> 1.0)
     unicode-display_width (2.1.0)
 
 PLATFORMS
   x86_64-linux
 
 DEPENDENCIES
+  actionview
   rake (~> 13.0)
-  rspec (~> 3.0)
-  rubocop (~> 1.21)
-  slim
+  rspec
+  rubocop
+  rubocop-rspec
   slimi!
 
 BUNDLED WITH

data/README.md

@@ -5,28 +5,56 @@
 
 Yet another implementation for [Slim](https://github.com/slim-template/slim) template language.
 
-Slimi is used by [Slimcop](https://github.com/r7kamura/slimcop).
+## Introduction
 
-## Installation
+Slimi provides almost the same functionality as Slim, with a few additional useful features,
+such as generating AST with detailed location information about embedded Ruby codes.
 
-Add this line to your application's Gemfile:
+Originally, Slimi was developed for [Slimcop](https://github.com/r7kamura/slimcop), a RuboCop runner for Slim template.
+It uses Slimi to apply `rubocop --auto-correct` to embedded Ruby codes in Slim template.
 
-```ruby
-gem 'slimi'
-```
-
-And then execute:
-
-```
-bundle install
-```
+## Usage
 
-Or install it yourself as:
+Just replace `gem 'slim'` with `gem 'slimi'` in your application's Gemfile.
 
+```ruby
+gem 'slimi'
 ```
-gem install slimi
-```
-
-## Usage
 
-TBD.
+## Compatibility
+
+- Line indicators
+    - [x] Vebatim text
+    - [x] Inline HTML
+    - [x] Control
+    - [x] Output
+    - [x] HTML comment
+    - [x] Code comment
+    - [x] IE conditional comment
+- Tags
+    - [x] Doctype declaration
+    - [x] Closed tags
+    - [x] Trailing and leading white space
+    - [x] Inline tags
+    - [x] Text content
+    - [x] Dynamic content
+    - [x] Tag shortcuts
+    - [ ] Dynamic tags
+- Attributes
+    - [x] Attributes wrapper
+    - [x] Quoted attributes
+    - [x] Ruby attributes
+    - [x] Boolean attributes
+    - [x] Attribute merging
+    - [x] Attribute shortcuts
+    - [ ] Splat attributes
+- Plugins
+    - [ ] Include partials
+    - [ ] Translator/I18n
+    - [ ] Logic-less mode
+    - [ ] Smart text mode
+- Etc.
+    - [ ] CLI tools
+- Slimi-only features
+    - [x] Embedded Ruby code location
+    - [x] annotate_rendered_view_with_filenames

data/lib/slimi/engine.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require 'temple'
+
+module Slimi
+  # Convert Slim code into Ruby code.
+  class Engine < ::Temple::Engine
+    define_options(
+      attr_quote: '"',
+      default_tag: 'div',
+      format: :xhtml,
+      generator: ::Temple::Generators::StringBuffer,
+      merge_attrs: { 'class' => ' ' },
+      pretty: false,
+      sort_attrs: true
+    )
+
+    use Parser
+    use Filters::Unposition
+    use Filters::Embedded
+    use Filters::Interpolation
+    use Filters::DoInserter
+    use Filters::EndInserter
+    use Filters::Control
+    use Filters::Output
+    use Filters::Text
+    html :AttributeSorter
+    html :AttributeMerger
+    use Filters::Attribute
+    use(:AttributeRemover) { ::Temple::HTML::AttributeRemover.new(remove_empty_attrs: options[:merge_attrs].keys) }
+    html :Pretty
+    use Filters::Amble
+    filter :Escapable
+    filter :ControlFlow
+    filter :MultiFlattener
+    filter :StaticMerger
+    generator :StringBuffer
+  end
+end

data/lib/slimi/errors.rb

@@ -23,7 +23,7 @@ module Slimi
       def to_s
         <<~TEXT
           #{error_type} at #{@file_path}:#{@line_number}:#{@column}
-          #{@line}
+          #{@line.rstrip}
           #{' ' * (@column - 1)}^
         TEXT
       end
@@ -36,6 +36,9 @@ module Slimi
       end
     end
 
+    class AttributeClosingDelimiterNotFoundError < SlimSyntaxError
+    end
+
     class InvalidEmptyAttributeError < SlimSyntaxError
     end
 

data/lib/slimi/filters/amble.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Slimi
+  module Filters
+    # Support Rails annotate_rendered_view_with_filenames feature.
+    class Amble < Base
+      define_options(
+        :postamble,
+        :preamble
+      )
+
+      # @param [Array] expression
+      # @return [Array]
+      def call(expression)
+        result = %i[multi]
+        result << [:static, options[:preamble]] if options[:preamble]
+        result << expression
+        result << [:static, options[:postamble]] if options[:postamble]
+        result
+      end
+    end
+  end
+end

data/lib/slimi/filters/attribute.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Slimi
+  module Filters
+    # Handle `[:slimi, :attributes, ...]`.
+    class Attribute < Base
+      define_options :merge_attrs
+
+      # @param [Array<Array>] expressions
+      # @return [Array]
+      def on_html_attrs(*expressions)
+        [:multi, *expressions.map { |expression| compile(expression) }]
+      end
+
+      # @param [String] name
+      # @param [Array] value
+      # @return [Array]
+      def on_html_attr(name, value)
+        if value[0] == :slimi && value[1] == :attrvalue && !options[:merge_attrs][name]
+          escape = value[2]
+          code = 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
+          @attr = name
+          super
+        end
+      end
+
+      # @param [Boolean] escape
+      # @param [String] code\
+      # @return [Array]\
+      def on_slimi_attrvalue(escape, code)
+        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
+end

data/lib/slimi/filters/base.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require 'temple'
+
+module Slimi
+  module Filters
+    # Pass-through some expressions which are unknown for Temple.
+    class Base < ::Temple::HTML::Filter
+      # @param [String] code
+      # @param [Array] expression
+      # @return [Array]
+      def on_slimi_control(code, expression)
+        [:slimi, :control, code, compile(expression)]
+      end
+
+      # @param [String] type
+      # @param [String] code
+      # @param [Array] expression
+      # @param [Array] attributes
+      # @return [Array]
+      def on_slimi_embedded(type, expression, attributes)
+        [:slimi, :embedded, type, compile(expression), attributes]
+      end
+
+      # @param [Boolean] escape
+      # @param [String] code
+      # @param [Array] expression
+      # @return [Array]
+      def on_slimi_output(escape, code, expression)
+        [:slimi, :output, escape, code, compile(expression)]
+      end
+
+      # @param [String] type
+      # @param [Array] expression
+      # @return [Array]
+      def on_slimi_text(type, expression)
+        [:slimi, :text, type, compile(expression)]
+      end
+    end
+  end
+end

data/lib/slimi/filters/control.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Slimi
+  module Filters
+    # Handle `[:slimi, :control, code, multi]`.
+    class Control < Base
+      # @param [String] code
+      # @param [Array] multi
+      # @return [Array]
+      def on_slimi_control(code, multi)
+        [
+          :multi,
+          [:code, code],
+          compile(multi)
+        ]
+      end
+    end
+  end
+end

data/lib/slimi/filters/do_inserter.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Slimi
+  module Filters
+    # Append missing `do` to embedded Ruby code.
+    class DoInserter < Base
+      VALID_RUBY_LINE_REGEXP = /(\A(if|unless|else|elsif|when|begin|rescue|ensure|case)\b)|\bdo\s*(\|[^|]*\|\s*)?\Z/.freeze
+
+      # @param [String] code
+      # @param [Array] expressio
+      # @return [Array]
+      def on_slimi_control(code, expression)
+        code += ' do' unless code.match?(VALID_RUBY_LINE_REGEXP) || empty_exp?(expression)
+        [:slimi, :control, code, compile(expression)]
+      end
+
+      # @param [Boolean] escape
+      # @param [String] code
+      # @param [Array] expression
+      # @return [Array]
+      def on_slimi_output(escape, code, expression)
+        code += ' do' unless code.match?(VALID_RUBY_LINE_REGEXP) || empty_exp?(expression)
+        [:slimi, :output, escape, code, compile(expression)]
+      end
+    end
+  end
+end

data/lib/slimi/filters/embedded.rb

@@ -0,0 +1,255 @@
+# frozen_string_literal: true
+
+module Slimi
+  module Filters
+    # @api private
+    class TextCollector < Base
+      def call(exp)
+        @collected = ''
+        super(exp)
+        @collected
+      end
+
+      def on_slimi_interpolate(text)
+        @collected << text
+        nil
+      end
+    end
+
+    # @api private
+    class NewlineCollector < Base
+      def call(exp)
+        @collected = [:multi]
+        super(exp)
+        @collected
+      end
+
+      def on_newline
+        @collected << [:newline]
+        nil
+      end
+    end
+
+    # @api private
+    class OutputProtector < Base
+      def call(exp)
+        @protect = []
+        @collected = ''
+        @tag = "%#{object_id.abs.to_s(36)}%"
+        super(exp)
+        @collected
+      end
+
+      def on_static(text)
+        @collected << text
+        nil
+      end
+
+      def on_slimi_output(escape, text, content)
+        @collected << @tag
+        @protect << [:slimi, :output, escape, text, content]
+        nil
+      end
+
+      def unprotect(text)
+        block = [:multi]
+        while text =~ /#{@tag}/
+          block << [:static, Regexp.last_match.pre_match]
+          block << @protect.shift
+          text = Regexp.last_match.post_match
+        end
+        block << [:static, text]
+      end
+    end
+
+    # Temple filter which processes embedded engines
+    # @api private
+    class Embedded < Base
+      @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_slimi_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_slimi_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 || list.is_a?(Array)
+
+        list&.map(&:to_sym)
+      end
+
+      class Engine < Base
+        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_slimi_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,
+                                   cache: false
+                                 )) { 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!
+
+        def on_slimi_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_slimi_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, attributes: {}
+
+        def on_slimi_embedded(engine, body, attrs)
+          super(engine, [:html, :js, body], attrs)
+        end
+      end
+
+      # Embeds ruby code
+      class RubyEngine < Engine
+        def on_slimi_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,  attributes: { type: 'text/css' },         engine: TiltEngine
+      register :sass,       TagEngine, :pretty, tag: :style, attributes: { type: 'text/css' }, engine: SassEngine
+      register :scss,       TagEngine, :pretty, tag: :style, attributes: { type: 'text/css' }, engine: SassEngine
+
+      # Embedded javascript/css
+      register :javascript, JavaScriptEngine
+      register :css,        TagEngine, tag: :style, attributes: { type: 'text/css' }
+
+      # Embedded ruby code
+      register :ruby,       RubyEngine
+    end
+  end
+end

data/lib/slimi/filters/end_inserter.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Slimi
+  module Filters
+    # Append missing `end` line to embedded Ruby code in control block.
+    class EndInserter < Base
+      # @param [Array<Array>] expressions
+      def on_multi(*expressions)
+        result = [:multi]
+        prev_indent = false
+        expressions.each do |source|
+          expression = Expression.new(source)
+          if expression.control?
+            raise ::Temple::FilterError, 'Explicit end statements are forbidden.' if expression.end?
+
+            result << code_end if prev_indent && !expression.else?
+
+            prev_indent = expression.if?
+          elsif !expression.newline? && prev_indent
+            result << code_end
+            prev_indent = false
+          end
+
+          result << compile(source)
+        end
+
+        result << code_end if prev_indent
+        result
+      end
+
+      private
+
+      # @return [Array]
+      def code_end
+        [:code, 'end']
+      end
+
+      class Expression
+        IF_REGEXP = /\A(if|begin|unless|else|elsif|when|rescue|ensure)\b|\bdo\s*(\|[^|]*\|)?\s*$/.freeze
+
+        ELSE_REGEXP = /\A(else|elsif|when|rescue|ensure)\b/.freeze
+
+        END_REGEXP = /\Aend\b/.freeze
+
+        # @param [Array] expression
+        def initialize(expression)
+          @expression = expression
+        end
+
+        # @return [Boolean]
+        def control?
+          @expression[0] == :slimi && @expression[1] == :control
+        end
+
+        # @return [Boolean]
+        def if?
+          @expression[2].match?(IF_REGEXP)
+        end
+
+        # @return [Boolean]
+        def else?
+          @expression[2].match?(ELSE_REGEXP)
+        end
+
+        # @return [Boolean]
+        def end?
+          @expression[2].match?(END_REGEXP)
+        end
+
+        # @return [Boolean]
+        def newline?
+          @expression[0] == :newline
+        end
+      end
+    end
+  end
+end

data/lib/slimi/filters/interpolation.rb

@@ -4,29 +4,7 @@ require 'strscan'
 
 module Slimi
   module Filters
-    class Interpolation
-      def initialize(*); end
-
-      def call(node)
-        convert(node)
-      end
-
-      private
-
-      def convert(value)
-        if value.instance_of?(::Array)
-          if value[0] == :slimi && value[1] == :interpolate
-            on_slimi_interpolate(value[2], value[3], value[4])
-          else
-            value.map do |element|
-              call(element)
-            end
-          end
-        else
-          value
-        end
-      end
-
+    class Interpolation < Base
       # @param [Integer] begin_
       # @param [Integer] end_
       # @return [Array] S-expression.
@@ -47,7 +25,7 @@ module Slimi
             else
               escape = false
             end
-            block << [:slimi, :position, begin2, begin2 + code.length, [:slim, :output, escape, code, [:multi]]]
+            block << [:slimi, :position, begin2, begin2 + code.length, [:slimi, :output, escape, code, [:multi]]]
           elsif (value = scanner.scan(/([#\\]?[^#\\]*([#\\][^\\\#{][^#\\]*)*)/)) # rubocop:disable Lint/DuplicateBranch
             block << [:static, value]
           end

data/lib/slimi/filters/output.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Slimi
+  module Filters
+    # Handle `[:slimi, :output, escape, code, multi]`.
+    class Output < Base
+      define_options :disable_capture
+
+      IF_REGEXP = /\A(if|unless)\b|\bdo\s*(\|[^|]*\|)?\s*$/.freeze
+
+      # @param [Boolean] escape
+      # @param [String] code
+      # @param [Array] multi
+      # @return [Array]
+      def on_slimi_output(escape, code, multi)
+        if code.match?(IF_REGEXP)
+          tmp = unique_name
+          [
+            :multi,
+            [:block, "#{tmp} = #{code}", options[:disable_capture] ? compile(multi) : [:capture, unique_name, compile(multi)]],
+            [:escape, escape, [:dynamic, tmp]]
+          ]
+        else
+          [
+            :multi,
+            [:escape, escape, [:dynamic, code]],
+            multi
+          ]
+        end
+      end
+    end
+  end
+end

data/lib/slimi/filters/text.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Slimi
+  module Filters
+    # Handle `[:slimi, :text, multi]`.
+    class Text < Base
+      # @param [Symbol] _type
+      # @param [Array] multi
+      # @return [Array]
+      def on_slimi_text(_type, multi)
+        compile(multi)
+      end
+    end
+  end
+end

data/lib/slimi/filters/unposition.rb

@@ -2,29 +2,13 @@
 
 module Slimi
   module Filters
-    class Unposition
-      def initialize(*); end
-
-      # @param [Array] node S-expression.
-      # @return [Array] S-expression.
-      def call(node)
-        convert(node)
-      end
-
-      private
-
-      def convert(value)
-        if value.instance_of?(::Array)
-          if value[0] == :slimi && value[1] == :position
-            call(value[4])
-          else
-            value.map do |element|
-              call(element)
-            end
-          end
-        else
-          value
-        end
+    class Unposition < Base
+      # @param [Integer] _begin
+      # @param [Integer] _end
+      # @param [Array] expression
+      # @return [Array]
+      def on_slimi_position(_begin, _end, expression)
+        compile(expression)
       end
     end
   end

data/lib/slimi/filters.rb

@@ -2,7 +2,16 @@
 
 module Slimi
   module Filters
+    autoload :Amble, 'slimi/filters/amble'
+    autoload :Attribute, 'slimi/filters/attribute'
+    autoload :Base, 'slimi/filters/base'
+    autoload :Control, 'slimi/filters/control'
+    autoload :DoInserter, 'slimi/filters/do_inserter'
+    autoload :Embedded, 'slimi/filters/embedded'
+    autoload :EndInserter, 'slimi/filters/end_inserter'
     autoload :Interpolation, 'slimi/filters/interpolation'
+    autoload :Output, 'slimi/filters/output'
+    autoload :Text, 'slimi/filters/text'
     autoload :Unposition, 'slimi/filters/unposition'
   end
 end

data/lib/slimi/parser.rb

@@ -115,7 +115,7 @@ module Slimi
 
       embedded_template_engine_name = @scanner[1]
       attributes = parse_attributes
-      @stacks.last << [:slim, :embedded, embedded_template_engine_name, parse_text_block, attributes]
+      @stacks.last << [:slimi, :embedded, embedded_template_engine_name, parse_text_block, attributes]
     end
 
     # @return [Boolean]
@@ -150,14 +150,14 @@ module Slimi
           block = [:multi]
           @stacks.last.insert(-2, [:static, ' ']) if with_leading_white_space2
           @scanner.skip(/[ \t]+/)
-          tag << with_position { [:slim, :output, escape, parse_broken_lines, block] }
+          tag << with_position { [:slimi, :output, escape, parse_broken_lines, block] }
           @stacks.last << [:static, ' '] if with_trailing_white_space2
           @stacks << block
         elsif @scanner.skip(%r{[ \t]*/[ \t]*})
           syntax_error!(Errors::UnexpectedTextAfterClosedTagError) unless @scanner.match?(/\r?\n/)
         else
           @scanner.skip(/[ \t]+/)
-          tag << [:slim, :text, :inline, parse_text_block]
+          tag << [:slimi, :text, :inline, parse_text_block]
         end
         true
       else
@@ -220,18 +220,24 @@ module Slimi
       value = +''
       count = 0
       loop do
-        if @scanner.match?(/#{quote}/) && count.zero?
-          end_ = @scanner.charpos
-          @scanner.pos += @scanner.matched_size
-          break
-        end
-
-        if @scanner.skip(/\{/)
+        if @scanner.match?(/#{quote}/)
+          if count.zero?
+            end_ = @scanner.charpos
+            @scanner.pos += @scanner.matched_size
+            break
+          else
+            @scanner.pos += @scanner.matched_size
+            value << @scanner.matched
+          end
+        elsif @scanner.skip(/\{/)
           count += 1
+          value << @scanner.matched
         elsif @scanner.skip(/\}/)
           count -= 1
+          value << @scanner.matched
+        else
+          value << @scanner.scan(/[^{}#{quote}]*/)
         end
-        value << @scanner.scan(/[^{}#{quote}]*/)
       end
       [:slimi, :interpolate, begin_, end_, value]
     end
@@ -263,9 +269,10 @@ module Slimi
         elsif @scanner.skip(@ruby_attribute_regexp)
           attribute_name = @scanner[1]
           escape = @scanner[2].empty?
+          charpos = @scanner.charpos
           attribute_value = parse_ruby_attribute_value(attribute_delimiter_closing)
           syntax_error!(Errors::InvalidEmptyAttributeError) if attribute_value.empty?
-          attributes << [:html, :attr, attribute_name, [:slim, :attrvalue, escape, attribute_value]]
+          attributes << [:html, :attr, attribute_name, [:slimi, :position, charpos, charpos + attribute_value.length, [:slimi, :attrvalue, escape, attribute_value]]]
         elsif !attribute_delimiter_closing_part_regexp
           break
         elsif @scanner.skip(boolean_attribute_regexp)
@@ -273,7 +280,10 @@ module Slimi
         elsif @scanner.skip(attribute_delimiter_closing_part_regexp) # rubocop:disable Lint/DuplicateBranch
           break
         else
-          raise ::NotImplementedError
+          @scanner.skip(/[ \t]+/)
+          expect_line_ending
+
+          syntax_error!(Errors::AttributeClosingDelimiterNotFoundError) if @scanner.eos?
         end
       end
 
@@ -324,7 +334,7 @@ module Slimi
     def parse_html_comment
       if @scanner.skip(%r{/!})
         text_block = parse_text_block
-        text = [:slim, :text, :verbatim, text_block]
+        text = [:slimi, :text, :verbatim, text_block]
         @stacks.last << [:html, :comment, text]
         true
       else
@@ -371,7 +381,7 @@ module Slimi
     def parse_verbatim_text_block_inner
       if @scanner.skip(/([|']) ?/)
         with_trailing_white_space = @scanner[1] == "'"
-        @stacks.last << [:slim, :text, :verbatim, parse_text_block]
+        @stacks.last << [:slimi, :text, :verbatim, parse_text_block]
         @stacks.last << [:static, ' '] if with_trailing_white_space
         true
       else
@@ -410,7 +420,7 @@ module Slimi
       if @scanner.skip(/-/)
         block = [:multi]
         @scanner.skip(/[ \t]+/)
-        @stacks.last << with_position { [:slim, :control, parse_broken_lines, block] }
+        @stacks.last << with_position { [:slimi, :control, parse_broken_lines, block] }
         @stacks << block
         true
       else
@@ -433,7 +443,7 @@ module Slimi
         block = [:multi]
         @stacks.last << [:static, ' '] if with_trailing_white_space
         @scanner.skip(/[ \t]+/)
-        @stacks.last << with_position { [:slim, :output, escape, parse_broken_lines, block] }
+        @stacks.last << with_position { [:slimi, :output, escape, parse_broken_lines, block] }
         @stacks.last << [:static, ' '] if with_leading_white_space
         @stacks << block
       else

data/lib/slimi/rails_template_handler.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Slimi
+  # Render Slim template in response to requests from Rails.
+  class RailsTemplateHandler
+    # @param [ActionView::Template] template
+    # @param [String, nil] source
+    # @return [String]
+    def call(template, source = nil)
+      Renderer.new(
+        source: source,
+        template: template
+      ).call
+    end
+
+    # Render HTML from given source and options.
+    class Renderer
+      # @param [String] source
+      # @param [ActionView::Template] template
+      def initialize(
+        source:,
+        template:
+      )
+        @source = source
+        @template = template
+      end
+
+      # @return [String]
+      def call
+        engine.call(source)
+      end
+
+      private
+
+      # @return [Slimi::Engine]
+      def engine
+        Engine.new(engine_options)
+      end
+
+      # @return [Hash{Symbol => Object}]
+      def engine_options
+        engine_default_options.merge(engine_amble_options)
+      end
+
+      # @return [Hash{Symbol => Object}]
+      def engine_default_options
+        {
+          generator: ::Temple::Generators::RailsOutputBuffer,
+          streaming: true,
+          use_html_safe: true
+        }
+      end
+
+      # @return [Hash{Symbol => Object}]
+      def engine_amble_options
+        if with_annotate_rendered_view_with_filenames?
+          {
+            postamble: "<!-- END #{@template.short_identifier} -->\n",
+            preamble: "<!-- BEGIN #{@template.short_identifier} -->\n"
+          }
+        else
+          {}
+        end
+      end
+
+      # @return [String]
+      def source
+        @source || @template.source
+      end
+
+      # @return [Boolean]
+      def with_annotate_rendered_view_with_filenames?
+        ::ActionView::Base.try(:annotate_rendered_view_with_filenames) && @template.format == :html
+      end
+    end
+  end
+end

data/lib/slimi/railtie.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Slimi
+  class Railtie < ::Rails::Railtie
+    initializer 'Register Slimi template handler' do
+      ::ActiveSupport.on_load(:action_view) do
+        ::ActionView::Template.register_template_handler(
+          :slim,
+          RailsTemplateHandler.new
+        )
+      end
+    end
+  end
+end

data/lib/slimi/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Slimi
-  VERSION = '0.4.1'
+  VERSION = '0.6.0'
 end

data/lib/slimi.rb

@@ -3,8 +3,12 @@
 require_relative 'slimi/version'
 
 module Slimi
+  autoload :Engine, 'slimi/engine'
   autoload :Errors, 'slimi/errors'
   autoload :Filters, 'slimi/filters'
   autoload :Parser, 'slimi/parser'
+  autoload :RailsTemplateHandler, 'slimi/rails_template_handler'
   autoload :Range, 'slimi/range'
 end
+
+require_relative 'slimi/railtie' if defined?(Rails)

data/slimi.gemspec

@@ -32,4 +32,5 @@ Gem::Specification.new do |spec|
   }
 
   spec.add_dependency 'temple'
+  spec.add_dependency 'tilt'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: slimi
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 0.6.0
 platform: ruby
 authors:
 - Ryo Nakamura
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-12-26 00:00:00.000000000 Z
+date: 2022-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: temple
@@ -24,6 +24,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: tilt
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: 
 email:
 - r7kamura@gmail.com
@@ -43,11 +57,23 @@ files:
 - bin/console
 - bin/setup
 - lib/slimi.rb
+- lib/slimi/engine.rb
 - lib/slimi/errors.rb
 - lib/slimi/filters.rb
+- lib/slimi/filters/amble.rb
+- lib/slimi/filters/attribute.rb
+- lib/slimi/filters/base.rb
+- lib/slimi/filters/control.rb
+- lib/slimi/filters/do_inserter.rb
+- lib/slimi/filters/embedded.rb
+- lib/slimi/filters/end_inserter.rb
 - lib/slimi/filters/interpolation.rb
+- lib/slimi/filters/output.rb
+- lib/slimi/filters/text.rb
 - lib/slimi/filters/unposition.rb
 - lib/slimi/parser.rb
+- lib/slimi/rails_template_handler.rb
+- lib/slimi/railtie.rb
 - lib/slimi/range.rb
 - lib/slimi/version.rb
 - slimi.gemspec