faml 0.2.0

data/lib/faml/filter_compilers/markdown.rb

@@ -0,0 +1,18 @@
+require 'faml/filter_compilers/tilt_base'
+
+module Faml
+  module FilterCompilers
+    class Markdown < TiltBase
+      def need_newline?
+        false
+      end
+
+      def compile(texts)
+        temple = [:multi, [:newline]]
+        compile_with_tilt(temple, 'markdown', texts)
+      end
+    end
+
+    register(:markdown, Markdown)
+  end
+end

data/lib/faml/filter_compilers/plain.rb

@@ -0,0 +1,15 @@
+require 'faml/filter_compilers/base'
+
+module Faml
+  module FilterCompilers
+    class Plain < Base
+      def compile(texts)
+        temple = [:multi, [:newline]]
+        compile_texts(temple, texts)
+        temple
+      end
+    end
+
+    register(:plain, Plain)
+  end
+end

data/lib/faml/filter_compilers/preserve.rb

@@ -0,0 +1,26 @@
+require 'faml/filter_compilers/base'
+
+module Faml
+  module FilterCompilers
+    class Preserve < Base
+      include Temple::Utils
+
+      def compile(texts)
+        temple = [:multi, [:newline]]
+        # I don't know why only :preserve filter keeps the last empty lines.
+        compile_texts(temple, texts, keep_last_empty_lines: true)
+        sym = unique_name
+        [:multi,
+          [:capture, sym, temple],
+          [:dynamic, "::Faml::FilterCompilers::Preserve.preserve(#{sym})"],
+        ]
+      end
+
+      def self.preserve(str)
+        str.gsub("\n", '&#x000A;')
+      end
+    end
+
+    register(:preserve, Preserve)
+  end
+end

data/lib/faml/filter_compilers/ruby.rb

@@ -0,0 +1,17 @@
+require 'faml/filter_compilers/base'
+
+module Faml
+  module FilterCompilers
+    class Ruby < Base
+      def need_newline?
+        false
+      end
+
+      def compile(texts)
+        [:multi, [:newline], [:code, strip_last_empty_lines(texts).join("\n")]]
+      end
+    end
+
+    register(:ruby, Ruby)
+  end
+end

data/lib/faml/filter_compilers/sass.rb

@@ -0,0 +1,15 @@
+require 'faml/filter_compilers/tilt_base'
+
+module Faml
+  module FilterCompilers
+    class Sass < TiltBase
+      def compile(texts)
+        temple = [:multi, [:static, "\n"], [:newline]]
+        compile_with_tilt(temple, 'sass', texts)
+        [:haml, :tag, 'style', false, [:html, :attrs], temple]
+      end
+    end
+
+    register(:sass, Sass)
+  end
+end

data/lib/faml/filter_compilers/scss.rb

@@ -0,0 +1,16 @@
+require 'faml/filter_compilers/tilt_base'
+
+module Faml
+  module FilterCompilers
+    class Scss < TiltBase
+      def compile(texts)
+        temple = [:multi, [:static, "\n"], [:newline]]
+        compile_with_tilt(temple, 'scss', texts)
+        temple << [:static, "\n"]
+        [:haml, :tag, 'style', false, [:html, :attrs], temple]
+      end
+    end
+
+    register(:scss, Scss)
+  end
+end

data/lib/faml/filter_compilers/tilt_base.rb

@@ -0,0 +1,34 @@
+require 'temple'
+require 'tilt'
+require 'faml/filter_compilers/base'
+require 'faml/text_compiler'
+
+module Faml
+  module FilterCompilers
+    class TiltBase < Base
+      include Temple::Utils
+
+      def self.render_with_tilt(name, source)
+        ::Tilt["t.#{name}"].new { source }.render
+      end
+
+      protected
+
+      def compile_with_tilt(temple, name, texts)
+        source = texts.join("\n")
+        if TextCompiler.contains_interpolation?(source)
+          text_temple = [:multi]
+          compile_texts(text_temple, texts)
+          sym = unique_name
+          temple << [:capture, sym, text_temple]
+          temple << [:dynamic, "::Faml::FilterCompilers::TiltBase.render_with_tilt(#{name.inspect}, #{sym})"]
+        else
+          compiled = self.class.render_with_tilt(name, source)
+          temple << [:static, compiled]
+          temple.concat([[:newline]] * (texts.size - 1))
+        end
+        temple
+      end
+    end
+  end
+end

data/lib/faml/filter_parser.rb

@@ -0,0 +1,54 @@
+module Faml
+  class FilterParser
+    def initialize(indent_tracker)
+      @ast = nil
+      @indent_level = nil
+      @indent_tracker = indent_tracker
+    end
+
+    def enabled?
+      !!@ast
+    end
+
+    def start(name)
+      @ast = Ast::Filter.new
+      @ast.name = name
+    end
+
+    def append(line)
+      indent, text = @indent_tracker.split(line)
+      if text.empty?
+        @ast.texts << ''
+        return
+      end
+      indent_level = indent.size
+
+      if @indent_level
+        if indent_level < @indent_level
+          # Finish filter
+          @indent_level = nil
+          ast = @ast
+          @ast = nil
+          return ast
+        end
+      else
+        if indent_level > @indent_tracker.current_level
+          # Start filter
+          @indent_level = indent_level
+        else
+          # Empty filter
+          @ast = nil
+          return nil
+        end
+      end
+
+      text = line[@indent_level .. -1]
+      @ast.texts << text
+      nil
+    end
+
+    def finish
+      @ast
+    end
+  end
+end

data/lib/faml/html.rb

@@ -0,0 +1,58 @@
+require 'faml/attribute_builder'
+
+module Faml
+  class Html < Temple::HTML::Fast
+    def on_haml_tag(name, self_closing, attrs, content = nil)
+      name = name.to_s
+      closed = self_closing && (!content || empty_exp?(content))
+      result = [:multi, [:static, "<#{name}"], compile(attrs)]
+      result << [:static, (closed && @format != :html ? ' /' : '') + '>']
+      result << compile(content) if content
+      result << [:static, "</#{name}>"] if !closed
+      result
+    end
+
+    def on_haml_attrs(code)
+      [:dynamic, "::Faml::AttributeBuilder.build(#{options[:attr_quote].inspect}, #{code})"]
+    end
+
+    def on_haml_attr(name, value)
+      if empty_exp?(value)
+        if @format == :html
+          [:static, " #{name}"]
+        else
+          [:static, " #{name}=#{options[:attr_quote]}#{name}#{options[:attr_quote]}"]
+        end
+      elsif value[0] == :dvalue
+        sym = unique_name
+        [:multi,
+          [:code, "#{sym} = (#{value[1]})"],
+          [:case, sym,
+            ['true', [:static, " #{name}"]],
+            ['false, nil', [:multi]],
+            [:else, [:multi,
+              [:static, " #{name}=#{options[:attr_quote]}"],
+              [:escape, true, [:dynamic, sym]],
+              [:static, options[:attr_quote]],
+            ]],
+          ],
+        ]
+      else
+        [:multi,
+          [:static, " #{name}=#{options[:attr_quote]}"],
+          compile(value),
+          [:static, options[:attr_quote]]]
+      end
+    end
+
+    def on_haml_doctype(type)
+      compile([:html, :doctype, type])
+    rescue Temple::FilterError
+      [:multi]
+    end
+
+    def on_haml_preserve(sym)
+      [:dynamic, "::Faml::Compiler.find_and_preserve(#{sym}.to_s)"]
+    end
+  end
+end

data/lib/faml/indent_tracker.rb

@@ -0,0 +1,84 @@
+module Faml
+  class IndentTracker
+    class IndentMismatch < StandardError
+      attr_reader :lineno
+
+      def initialize(message, lineno)
+        super("#{message} at line #{lineno}")
+        @lineno = lineno
+      end
+    end
+
+    def initialize(on_enter: nil, on_leave: nil)
+      @indent_levels = [0]
+      @on_enter = on_enter || lambda { |level, text| }
+      @on_leave = on_leave || lambda { |level, text| }
+      @comment_level = nil
+    end
+
+    def process(line, lineno)
+      indent, text = split(line)
+      indent_level = indent.size
+
+      unless text.empty?
+        track(indent_level, text, lineno)
+      end
+      [text, indent]
+    end
+
+    def split(line)
+      m = line.match(/\A( *)(.*)\z/)
+      [m[1], m[2]]
+    end
+
+    def finish
+      indent_leave(0, '', -1)
+    end
+
+    def current_level
+      @indent_levels.last
+    end
+
+    def enter_comment!
+      @comment_level = @indent_levels[-2]
+    end
+
+    private
+
+    def track(indent_level, text, lineno)
+      if indent_level > @indent_levels.last
+        indent_enter(indent_level, text)
+      elsif indent_level < @indent_levels.last
+        indent_leave(indent_level, text, lineno)
+      end
+    end
+
+    def indent_enter(indent_level, text)
+      unless @comment_level
+        @indent_levels.push(indent_level)
+        @on_enter.call(indent_level, text)
+      end
+    end
+
+    def indent_leave(indent_level, text, lineno)
+      if @comment_level
+        if indent_level <= @comment_level
+          # finish comment mode
+          @comment_level = nil
+        else
+          # still in comment
+          return
+        end
+      end
+
+      while indent_level < @indent_levels.last
+        @indent_levels.pop
+        @on_leave.call(indent_level, text)
+      end
+
+      if indent_level != @indent_levels.last
+        raise IndentMismatch.new("Unexpected indent level: #{indent_level}: indent_level=#{@indent_levels}", lineno)
+      end
+    end
+  end
+end

data/lib/faml/line_parser.rb

@@ -0,0 +1,66 @@
+module Faml
+  class LineParser
+    attr_reader :lineno
+
+    def initialize(template_str)
+      @lines = template_str.each_line.map { |line| line.chomp.rstrip }
+      @lineno = 0
+    end
+
+    def next_line
+      line = move_next
+      if is_multiline?(line)
+        next_multiline(line)
+      else
+        line
+      end
+    end
+
+    def has_next?
+      @lineno < @lines.size
+    end
+
+    private
+
+    MULTILINE_SUFFIX = ' |'
+
+    # Regex to check for blocks with spaces around arguments. Not to be confused
+    # with multiline script.
+    # For example:
+    #     foo.each do | bar |
+    #       = bar
+    #
+    BLOCK_WITH_SPACES = /do\s*\|\s*[^\|]*\s+\|\z/o
+
+    def is_multiline?(line)
+      line = line.lstrip
+      line.end_with?(MULTILINE_SUFFIX) && line !~ BLOCK_WITH_SPACES
+    end
+
+    def move_next
+      @lines[@lineno].tap do
+        @lineno += 1
+      end
+    end
+
+    def move_back
+      @lineno -= 1
+    end
+
+    def next_multiline(line)
+      buf = [line[0, line.size-1]]
+      while @lineno < @lines.size
+        line = move_next
+
+        if is_multiline?(line)
+          line = line[0, line.size-1]
+          buf << line.lstrip
+        else
+          move_back
+          break
+        end
+      end
+      buf.join
+    end
+  end
+end

data/lib/faml/newline.rb

@@ -0,0 +1,30 @@
+require 'temple'
+
+module Faml
+  class Newline < Temple::Filter
+    def on_multi(*exprs)
+      i = exprs.size-1
+      marker = false
+      while i >= 0
+        case exprs[i]
+        when [:rmnl]
+          if marker
+            raise "InternalError: double rmnl error"
+          else
+            marker = true
+            exprs.delete_at(i)
+          end
+        when [:mknl]
+          if marker
+            marker = false
+            exprs.delete_at(i)
+          else
+            exprs[i] = [:static, "\n"]
+          end
+        end
+        i -= 1
+      end
+      [:multi, *exprs]
+    end
+  end
+end