faml 0.2.0

data/lib/faml/element_parser.rb

@@ -0,0 +1,235 @@
+require 'strscan'
+require 'faml/ast'
+require 'faml/parser_utils'
+require 'faml/ruby_multiline'
+require 'faml/script_parser'
+require 'faml/syntax_error'
+
+module Faml
+  class ElementParser
+    def initialize(line_parser)
+      @line_parser = line_parser
+    end
+
+    ELEMENT_REGEXP = /\A%([-:\w]+)([-:\w.#]*)(.+)?\z/o
+
+    def parse(text)
+      m = text.match(ELEMENT_REGEXP)
+      unless m
+        syntax_error!('Invalid element declaration')
+      end
+
+      element = Ast::Element.new
+      element.tag_name = m[1]
+      element.static_class, element.static_id = parse_class_and_id(m[2])
+      rest = m[3] || ''
+
+      element.attributes, rest = parse_attributes(rest)
+      element.nuke_inner_whitespace, element.nuke_outer_whitespace, rest = parse_nuke_whitespace(rest)
+      element.self_closing, rest = parse_self_closing(rest)
+      element.oneline_child = ScriptParser.new(@line_parser).parse(rest)
+
+      element
+    end
+
+    private
+
+    def parse_class_and_id(class_and_id)
+      classes = []
+      id = ''
+      class_and_id.scan(/([#.])([-:_a-zA-Z0-9]+)/) do |type, prop|
+        case type
+        when '.'
+          classes << prop
+        when '#'
+          id = prop
+        end
+      end
+
+      [classes.join(' '), id]
+    end
+
+    OLD_ATTRIBUTE_BEGIN = '{'
+    NEW_ATTRIBUTE_BEGIN = '('
+
+    def parse_attributes(rest)
+      old_attributes = ''
+      new_attributes = ''
+
+      loop do
+        case rest[0]
+        when OLD_ATTRIBUTE_BEGIN
+          unless old_attributes.empty?
+            break
+          end
+          old_attributes, rest = parse_old_attributes(rest)
+        when NEW_ATTRIBUTE_BEGIN
+          unless new_attributes.empty?
+            break
+          end
+          new_attributes, rest = parse_new_attributes(rest)
+        else
+          break
+        end
+      end
+
+      attributes = old_attributes
+      unless new_attributes.empty?
+        t = to_old_syntax(new_attributes)
+        if attributes.empty?
+          attributes = t
+        else
+          attributes << ", " << t
+        end
+      end
+      [attributes, rest]
+    end
+
+    def parse_old_attributes(text)
+      text = text.dup
+      s = StringScanner.new(text)
+      s.pos = 1
+      depth = 1
+      loop do
+        depth = ParserUtils.balance(s, '{', '}', depth)
+        if depth == 0
+          attr = s.pre_match + s.matched
+          return [attr[1, attr.size-2], s.rest.lstrip]
+        else
+          if text[-1] == ',' && @line_parser.has_next?
+            text << @line_parser.next_line
+          else
+            syntax_error!('Unmatched brace')
+          end
+        end
+      end
+    end
+
+    def parse_new_attributes(text)
+      text = text.dup
+      s = StringScanner.new(text)
+      s.pos = 1
+      depth = 1
+      new_attributes = []
+      loop do
+        pre_pos = s.pos
+        depth = ParserUtils.balance(s, '(', ')', depth)
+        if depth == 0
+          t = s.string.byteslice(pre_pos ... s.pos-1)
+          new_attributes.concat(parse_new_attribute_list(t))
+          return [new_attributes, s.rest.lstrip]
+        else
+          if @line_parser.has_next?
+            text << ' ' << @line_parser.next_line
+          else
+            syntax_error!('Unmatched paren')
+          end
+        end
+      end
+    end
+
+    def parse_new_attribute_list(text)
+      s = StringScanner.new(text)
+      list = []
+      until s.eos?
+        name = scan_key(s)
+        s.skip(/\s*/)
+
+        if scan_operator(s)
+          s.skip(/\s*/)
+          value = scan_value(s)
+        else
+          value = 'true'
+        end
+        s.skip(/\s*/)
+
+        list << [name, value]
+      end
+      list
+    end
+
+    def scan_key(scanner)
+      scanner.scan(/[-:\w]+/).tap do |name|
+        unless name
+          syntax_error!('Invalid attribute list (missing attributename)')
+        end
+      end
+    end
+
+    def scan_operator(scanner)
+      scanner.skip(/=/)
+    end
+
+    def scan_value(scanner)
+      if quote = scanner.scan(/["']/)
+        scan_quoted_value(scanner, quote)
+      else
+        scan_variable_value(scanner)
+      end
+    end
+
+    def scan_quoted_value(scanner, quote)
+      re = /((?:\\.|\#(?!\{)|[^#{quote}\\#])*)(#{quote}|#\{)/
+      pos = scanner.pos
+      loop do
+        unless scanner.scan(re)
+          syntax_error!('Invalid attribute list (mismatched quotation)')
+        end
+        if scanner[2] == quote
+          break
+        end
+        depth = ParserUtils.balance(scanner, '{', '}')
+        if depth != 0
+          syntax_error!('Invalid attribute list (mismatched interpolation)')
+        end
+      end
+      str = scanner.string.byteslice(pos-1 .. scanner.pos-1)
+
+      # Even if the quote is single, string interpolation is performed in Haml.
+      str[0] = '"'
+      str[-1] = '"'
+      str
+    end
+
+    def scan_variable_value(scanner)
+      scanner.scan(/(@@?|\$)?\w+/).tap do |var|
+        unless var
+          syntax_error!('Invalid attribute list (invalid variable name)')
+        end
+      end
+    end
+
+    def to_old_syntax(new_attributes)
+      new_attributes.map { |k, v| "#{k.inspect} => #{v}" }.join(', ')
+    end
+
+    def parse_nuke_whitespace(rest)
+      m = rest.match(/\A(><|<>|[><])(.*)\z/)
+      if m
+        nuke_whitespace = m[1]
+        [
+          nuke_whitespace.include?('<'),
+          nuke_whitespace.include?('>'),
+          m[2],
+        ]
+      else
+        [false, false, rest]
+      end
+    end
+
+    def parse_self_closing(rest)
+      if rest[0] == '/'
+        if rest.size > 1
+          syntax_error!("Self-closing tags can't have content")
+        end
+        [true, '']
+      else
+        [false, rest]
+      end
+    end
+
+    def syntax_error!(message)
+      raise SyntaxError.new(message, @line_parser.lineno)
+    end
+  end
+end

data/lib/faml/engine.rb

@@ -0,0 +1,34 @@
+require 'temple'
+require 'faml/compiler'
+require 'faml/html'
+require 'faml/newline'
+require 'faml/parser'
+
+module Faml
+  class Engine < Temple::Engine
+    define_options(
+      generator: Temple::Generators::ArrayBuffer,
+    )
+
+    DEFAULT_OPTIONS = {
+        format: :html,
+        attr_quote: "'",
+    }.freeze
+
+    def initialize(opts = {})
+      super(DEFAULT_OPTIONS.merge(opts))
+    end
+
+    use Parser
+    use Compiler
+    use Html
+    filter :Escapable
+    filter :ControlFlow
+    filter :MultiFlattener
+    use Newline
+    filter :StaticMerger
+    use :Generator do
+      options[:generator].new(options.to_hash.reject {|k,v| !options[:generator].options.valid_key?(k) })
+    end
+  end
+end

data/lib/faml/filter_compilers.rb

@@ -0,0 +1,41 @@
+module Faml
+  module FilterCompilers
+    class NotFound < StandardError
+      attr_reader
+
+      def initialize(name)
+        super("Unable to find compiler for #{name}")
+        @name = name
+      end
+    end
+
+    def self.compilers
+      @compilers ||= {}
+    end
+
+    def self.register(name, compiler)
+      compilers[name.to_s] = compiler
+    end
+
+    def self.find(name)
+      name = name.to_s
+      if compilers.has_key?(name.to_s)
+        compilers[name].new
+      else
+        raise NotFound.new(name)
+      end
+    end
+  end
+end
+
+require 'faml/filter_compilers/cdata'
+require 'faml/filter_compilers/coffee'
+require 'faml/filter_compilers/css'
+require 'faml/filter_compilers/escaped'
+require 'faml/filter_compilers/javascript'
+require 'faml/filter_compilers/markdown'
+require 'faml/filter_compilers/plain'
+require 'faml/filter_compilers/preserve'
+require 'faml/filter_compilers/ruby'
+require 'faml/filter_compilers/sass'
+require 'faml/filter_compilers/scss'

data/lib/faml/filter_compilers/base.rb

@@ -0,0 +1,43 @@
+require 'faml/text_compiler'
+
+module Faml
+  module FilterCompilers
+    class Base
+      def need_newline?
+        true
+      end
+
+      protected
+
+      def compile_texts(temple, texts, tab_width: 0, keep_last_empty_lines: false)
+        tabs = ' ' * tab_width
+        n = 0
+        unless keep_last_empty_lines
+          texts, n = strip_last_empty_lines(texts)
+        end
+        texts.each do |text|
+          temple << [:static, tabs] << text_compiler.compile(text)
+          unless texts.last.equal?(text)
+            temple << [:static, "\n"] << [:newline]
+          end
+        end
+        temple.concat([[:newline]] * n)
+        nil
+      end
+
+      def text_compiler
+        @text_compiler ||= TextCompiler.new(escape_html: false)
+      end
+
+      def strip_last_empty_lines(texts)
+        n = 0
+        texts = texts.dup
+        while texts.last && texts.last.empty?
+          n += 1
+          texts.pop
+        end
+        [texts, n]
+      end
+    end
+  end
+end

data/lib/faml/filter_compilers/cdata.rb

@@ -0,0 +1,15 @@
+require 'faml/filter_compilers/base'
+
+module Faml
+  module FilterCompilers
+    class Cdata < Base
+      def compile(texts)
+        temple = [:multi, [:static, "<![CDATA[\n"], [:newline]]
+        compile_texts(temple, texts, tab_width: 4)
+        temple << [:static, "\n]]>"]
+      end
+    end
+
+    register(:cdata, Cdata)
+  end
+end

data/lib/faml/filter_compilers/coffee.rb

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

data/lib/faml/filter_compilers/css.rb

@@ -0,0 +1,16 @@
+require 'faml/filter_compilers/base'
+
+module Faml
+  module FilterCompilers
+    class Css < Base
+      def compile(texts)
+        temple = [:multi, [:static, "\n"], [:newline]]
+        compile_texts(temple, texts, tab_width: 2)
+        temple << [:static, "\n"]
+        [:haml, :tag, 'style', false, [:html, :attrs], temple]
+      end
+    end
+
+    register(:css, Css)
+  end
+end

data/lib/faml/filter_compilers/escaped.rb

@@ -0,0 +1,23 @@
+require 'faml/filter_compilers/base'
+
+module Faml
+  module FilterCompilers
+    class Escaped < Base
+      include Temple::Utils
+
+      def compile(texts)
+        temple = [:multi, [:newline]]
+        compile_texts(temple, texts)
+        temple << [:static, "\n"]
+        escape_code = Temple::Filters::Escapable.new.instance_variable_get(:@escape_code)
+        sym = unique_name
+        [:multi,
+          [:capture, sym, temple],
+          [:dynamic, escape_code % sym],
+        ]
+      end
+    end
+
+    register(:escaped, Escaped)
+  end
+end

data/lib/faml/filter_compilers/javascript.rb

@@ -0,0 +1,16 @@
+require 'faml/filter_compilers/base'
+
+module Faml
+  module FilterCompilers
+    class Javascript < Base
+      def compile(texts)
+        temple = [:multi, [:static, "\n"], [:newline]]
+        compile_texts(temple, texts, tab_width: 2)
+        temple << [:static, "\n"]
+        [:haml, :tag, 'script', false, [:html, :attrs], [:html, :js, temple]]
+      end
+    end
+
+    register(:javascript, Javascript)
+  end
+end