sade 0.1.0.pre

data/lib/sade/for_builder.rb

@@ -0,0 +1,33 @@
+require_relative 'parser_helper'
+
+module Sade
+  class ForBuilder
+    attr_reader :parser
+
+    include ParserHelper
+
+    def initialize(parser) = @parser = parser
+
+    def build(it)
+      last_it    = it.matching_rparen
+
+      return nil unless for_expr?(it)
+      error("')' that should match '(' is not found", it) if last_it.nil?
+
+      it.next.skip_space  # ( とその後ろのスペースをスキップ
+      it.next.skip_space  # %for とその後ろのスペースをスキップ
+
+      error("'#{it.val}' is not available as %for's first parameter.", it) unless it.symbol?
+
+      placeholder = it.val
+      it.next.skip_space  # placeholderとその後ろのスペースをスキップ
+
+      error("the second parameter of %if must be variable", it) unless it.variable?
+
+      collection = Variable.new(it.val[1..-1])
+      it.next.skip_space  # 変数とその後ろのスペースをスキップ
+
+      For.new(collection, placeholder, parser.read_children(it, last_it))
+    end
+  end
+end

data/lib/sade/heredoc_builder.rb

@@ -0,0 +1,27 @@
+require_relative 'parser_helper'
+require_relative 'interpolation'
+
+module Sade
+  class HeredocBuilder
+    attr_reader :parser
+
+    include ParserHelper
+    include Interpolation
+
+    def initialize(parser) = @parser = parser
+
+    def build(it)
+      return nil unless it.heredoc?
+      return nil if it.val.size.zero?
+
+      val = it.val
+      return Heredoc.new([Text.new(val)]) unless include_interpolation?(val)
+
+      contents = parse_interpolated_text(val, it)
+
+      return nil if contents.empty?
+
+      Heredoc.new(contents)
+    end
+  end
+end

data/lib/sade/heredoc_reader.rb

@@ -0,0 +1,70 @@
+module Sade
+  class HeredocReader
+    attr_reader :doc, :itr
+
+    def read(doc, itr)
+      @doc = doc
+      @itr = itr
+
+      return nil unless delimiter?
+
+      indent_size = get_indent_size
+      indent      = " " * indent_size
+      error %(a newline shold be placed after """) unless peek(3) == "\n"
+
+      step(3).newline  # """の後ろの改行は内容に含めない
+
+      content = String.new
+      until self.end? || delimiter?
+        line = read_line
+        error "indent size doesn't match #{indent_size}" unless line[0...indent_size] == indent
+        content << line[indent_size..-1]
+      end
+
+      error 'unterminated heredoc'                     unless delimiter?
+      error "indent size doesn't match #{indent_size}" unless indent_size == get_indent_size
+      error 'a newline shold be placed after """'      unless peek(3) == "\n"
+
+      step(3) # """ の後ろの改行は消費しない
+      content
+    end
+
+    private
+
+    def peek(offset) = itr.peek(offset)
+    def step(count)  = itr.step(count)
+    def end?         = itr.end?
+
+    def delimiter?
+      it = itr.clone
+      it.step(3)
+      doc.match?(itr, it, '"""')
+    end
+
+    def read_line
+      it = itr.clone
+      itr.next until itr.end? || itr.current == "\n" || delimiter?
+      itr.newline if itr.current == "\n"
+      doc.substr(it, itr)
+    end
+
+    def error(msg)
+      error_msg = "%s: line %d col %d" % [msg, itr.line, itr.col]
+      raise LexerError, error_msg
+    end
+
+    def get_indent_size
+      return 0 if itr.offset.zero?
+      
+      decrement = 1
+      ch        = itr.peek(-decrement)
+      until (itr.offset - decrement).negative? || ch == "\n"
+        error "indents must contain only spaces." unless ch == ' '
+        decrement += 1
+        ch = itr.peek(-decrement)
+      end
+
+      decrement - 1
+    end
+  end
+end

data/lib/sade/if_builder.rb

@@ -0,0 +1,45 @@
+require_relative 'parser_helper'
+
+module Sade
+  class IfBuilder
+    attr_reader :parser
+
+    include ParserHelper
+
+    def initialize(parser) = @parser = parser
+
+    def build(it)
+      last_it    = it.matching_rparen
+
+      return nil unless if_expr?(it)
+      error("')' that should match '(' is not found", it) if last_it.nil?
+
+      it.next.skip_space  # ( とその後ろのスペースをスキップ
+      it.next.skip_space  # %if とその後ろのスペースをスキップ
+
+      error("the first parameter of %if must be variable", it) unless it.variable?
+
+      var = Variable.new(it.val[1..-1])
+
+      it.next.skip_space  # 変数とその後ろのスペースをスキップ
+
+      then_nodes, else_nodes = read_then_and_else_nodes(it, last_it)
+
+      If.new(var, then_nodes, else_nodes)
+    end
+
+    def read_then_and_else_nodes(it, last_it)
+      then_nodes = []
+      else_nodes = []
+
+      then_nodes = parser.read_children(it, last_it) do |expr|
+        if expr.is_a?(Else)
+          else_nodes = expr.children
+          it.step(last_it.offset - it.offset) # (%else ...) の後に書かれたものは全無視
+          true
+        end
+      end
+      [then_nodes, else_nodes]
+    end
+  end
+end

data/lib/sade/import_builder.rb

@@ -0,0 +1,41 @@
+require_relative 'parser_helper'
+
+module Sade
+  class ImportBuilder
+    attr_reader :parser
+
+    include ParserHelper
+
+    def initialize(parser) = @parser = parser
+
+    def build(it)
+      last_it      = it.matching_rparen
+      variable_map = {}
+
+      return nil unless import_expr?(it)
+      error("')' that should match '(' is not found", it) if last_it.nil?
+
+      it.next.skip_space  # ( とその後ろのスペースをスキップ
+      it.next.skip_space  # %import とその後ろのスペースをスキップ
+
+      path = read_path(it, last_it)
+      error("file path is empty", it) if path&.size.zero?
+
+      it.move_at(last_it.offset) # イテレータ位置調整
+
+      content = read_content(path, it)
+      return nil if content.size.zero?
+
+      Import.new(path, content)
+    end
+
+    def read_content(path, it)
+      content = ''
+      File.open("#{parser.import_path}/#{path}"){ |f| content =f.read }
+      content = content[0..-2] if content[-1] == "\n"
+      content
+    rescue Errno::ENOENT => e
+      error(e.message, it)
+    end
+  end
+end

data/lib/sade/include_builder.rb

@@ -0,0 +1,82 @@
+require_relative 'parser_helper'
+
+module Sade
+  class IncludeBuilder
+    attr_reader :parser
+
+    include ParserHelper
+
+    def initialize(parser) = @parser = parser
+
+    def build(it)
+      last_it      = it.matching_rparen
+      variable_map = {}
+
+      return nil unless include_expr?(it)
+      error("')' that should match '(' is not found", it) if last_it.nil?
+
+      it.next.skip_space  # ( とその後ろのスペースをスキップ
+      it.next.skip_space  # %include とその後ろのスペースをスキップ
+
+      path = read_path(it, last_it)
+      error("file path is empty", it) if path&.size.zero?
+
+      if end_of_tag?(it, last_it)
+        children = read_content(path, it)
+        return children.size == 0 ? nil : Include.new(path, variable_map, children)
+      end
+
+      it.next.skip_space # path とその後ろのスペースをスキップ
+
+      variable_map = read_variable_map(it) || {}
+      it.move_at(last_it.offset) # イテレータ位置調整
+
+      children = read_content(path, it)
+      return nil if children.size.zero?
+
+      Include.new(path, variable_map, children)
+    end
+
+    def read_content(path, it)
+      content = ''
+      File.open("#{parser.include_path}/#{path}"){ |f| content =f.read }
+      content = content[0..-2] if content[-1] == "\n"
+      token_stream = Lexer.new.lex(content)
+      parser.parse(token_stream)
+    rescue Errno::ENOENT => e
+      error(e.message, it)
+    end
+
+    def read_path(it, last_it)
+      return it.val if it.text?
+
+      path = String.new
+      loop do
+        break if it.eof?
+        break if end_of_tag?(it, last_it)
+
+        path << it.val
+
+        break if it.peek(1).type == :space
+
+        it.next
+      end
+
+      path
+    end
+
+    def read_variable_map(it)
+      return {} unless it.lbrace?
+
+      map = parser.attr_block_reader.read(it)
+
+      return {} if map.nil? || map.empty?
+
+      map.each do |key, node|
+        error("the value of the key '#{key}' must be variable", it) unless node.is_a?(Variable)
+      end
+
+      map
+    end
+  end
+end

data/lib/sade/interpolation.rb

@@ -0,0 +1,38 @@
+module Sade
+  module Interpolation
+    # 「補完が含まれているか」だけを判定する軽いフィルタ
+    def include_interpolation?(text) = text.index('${')
+
+    # text 内の ${...} をすべて走査し、
+    # Text / Variable のフラットなノード配列を返す
+    def parse_interpolated_text(text, it)
+      nodes = []
+      pos = 0
+      len = text.size
+
+      while (start = text.index('${', pos))
+        # ${ の前にテキストがあれば Text として追加
+        if start > pos
+          nodes << Text.new(text[pos...start])
+        end
+
+        end_pos = text.index('}', start + 2)
+        error('"}" not found for interpolation', it) if end_pos.nil?
+
+        variable_name = text[(start + 2)...end_pos].strip
+        error('variable name not found between ${ and }', it) if variable_name.size.zero?
+
+        nodes << Variable.new(variable_name)
+
+        pos = end_pos + 1
+      end
+
+      # 残りのテキストがあれば Text として追加
+      if pos < len
+        nodes << Text.new(text[pos...len])
+      end
+
+      nodes
+    end
+  end
+end

data/lib/sade/iterator.rb

@@ -0,0 +1,49 @@
+module Sade
+  class Iterator
+  State = Struct.new(:buf, :offset)
+
+    attr_reader :state
+
+    def initialize(buf, offset)
+      @state = State.new(buf: buf, offset: offset)
+    end
+
+    def offset = state.offset
+    def begin? = state.offset.zero?
+    def end?   = state.offset >= buf_size
+
+    def current
+      self.end? ? nil : state.buf[state.offset]
+    end
+
+    def next
+      state.offset += 1 unless self.end?
+      self
+    end
+    
+    def step(count)
+      if (state.offset + count).negative?
+        state.offset = 0
+      elsif state.offset + count >= buf_size
+        state.offset = buf_size
+      else
+        state.offset += count 
+      end
+
+      self
+    end
+
+    def peek(count)
+      return state.buf[-1] if state.offset + count >= buf_size
+      return state.buf[0]  if (state.offset + count).negative?
+
+      state.buf[state.offset + count]
+    end
+
+    def clone = self.class.new(state.buf, state.offset)
+
+    private
+
+    def buf_size = state.buf.size
+  end
+end

data/lib/sade/lexer.rb

@@ -0,0 +1,13 @@
+require_relative 'exception'
+require_relative 'token'
+require_relative 'document'
+require_relative 'tokenizer'
+
+module Sade
+  class Lexer
+    def lex(string, debug: false)
+      doc = Document.new(string)
+      Tokenizer.new(doc, debug: debug).run
+    end
+  end
+end

data/lib/sade/node.rb

@@ -0,0 +1,12 @@
+module Sade
+  Element   = Struct.new(:name, :attrs, :children)
+  Text      = Struct.new(:value)
+  Variable  = Struct.new(:key)
+  Composite = Struct.new(:contents)
+  Heredoc   = Struct.new(:contents)
+  If        = Struct.new(:condition,  :then_node,   :else_node)
+  Else      = Struct.new(:children)
+  For       = Struct.new(:collection, :placeholder, :body)
+  Include   = Struct.new(:path, :variable_map, :children)
+  Import    = Struct.new(:path, :content)
+end

data/lib/sade/parser.rb

@@ -0,0 +1,134 @@
+require_relative 'parser_helper'
+require_relative 'composite_builder'
+require_relative 'attr_value_reader'
+require_relative 'attr_shortcut_reader'
+require_relative 'attr_block_reader'
+require_relative 'element_builder'
+require_relative 'if_builder'
+require_relative 'else_builder'
+require_relative 'for_builder'
+require_relative 'include_builder'
+require_relative 'import_builder'
+require_relative 'heredoc_builder'
+
+module Sade
+  class Parser
+    attr_reader :attr_shortcut_reader,
+                :attr_value_reader,
+                :attr_block_reader,
+                :composite_builder,
+                :element_builder,
+                :if_builder,
+                :else_builder,
+                :for_builder,
+                :include_builder,
+                :import_builder,
+                :heredoc_builder,
+                :include_path,
+                :import_path
+
+    include ParserHelper
+
+    def initialize(include_path: ".", import_path: ".")
+      @composite_builder    = CompositeBuilder.new
+      @attr_value_reader    = AttrValueReader.new(self)
+      @attr_shortcut_reader = AttrShortcutReader.new(self)
+      @attr_block_reader    = AttrBlockReader.new(self)
+      @element_builder      = ElementBuilder.new(self)
+      @if_builder           = IfBuilder.new(self)
+      @else_builder         = ElseBuilder.new(self)
+      @for_builder          = ForBuilder.new(self)
+      @include_builder      = IncludeBuilder.new(self)
+      @import_builder       = ImportBuilder.new(self)
+      @heredoc_builder      = HeredocBuilder.new(self)
+      @include_path         = include_path == '.' ? File.expand_path('.') : include_path
+      @import_path          = import_path  == '.' ? File.expand_path('.') : import_path
+    end
+
+
+    def parse(token_stream)
+      it    = token_stream.begin
+      nodes = []
+
+      return [] if space_all?(it)
+
+      until it.eof?
+        composite = read_text(it)
+        nodes.push(composite) unless composite.nil?
+
+        break if it.eof?
+
+        node = read_next_node(it)
+        nodes.push(node) unless node.nil?
+        it.next unless it.eof?
+      end
+
+      nodes
+    end
+
+    def next_node_type(it)
+      return :heredoc if it.heredoc?
+      return :text    unless it.lparen?
+      return :if      if if_expr?(it)
+      return :else    if else_expr?(it)
+      return :for     if for_expr?(it)
+      return :include if include_expr?(it)
+      return :import  if import_expr?(it)
+
+      :element
+    end
+
+    def read_next_node(it)
+      case next_node_type(it)
+      when :text
+        composite_builder.build(it)
+      when :heredoc
+        read_heredoc(it)
+      when :element
+        element_builder.build(it)
+      when :if
+        if_builder.build(it)
+      when :else
+        else_builder.build(it)
+      when :for
+        for_builder.build(it)
+      when :include
+        include_builder.build(it)
+      when :import
+        import_builder.build(it)
+      end
+    end
+
+    def read_heredoc(it) = heredoc_builder.build(it)
+
+    def read_children(it, last_it, &else_check)
+      children = []
+      until it.eof? || end_of_tag?(it, last_it)
+        composite = read_text(it, has_parent: true)
+        children << composite unless composite.nil?
+
+        break if end_of_tag?(it, last_it)
+
+        node = read_next_node(it)
+
+        else_node_found = false
+        else_node_found = else_check.call(node) if block_given?
+
+        break if else_node_found
+
+        children << node unless node.nil?
+        it.next          unless end_of_tag?(it, last_it)
+      end
+      children
+    end
+
+    def read_text(it, has_parent: false) = composite_builder.build(it, has_parent: has_parent)
+
+    def space_all?(it)
+      _it = it.clone
+      _it.next while _it.space?
+
+      _it.eof?
+    end
+  end
+end

data/lib/sade/parser_helper.rb

@@ -0,0 +1,40 @@
+module Sade
+  module ParserHelper
+    def eof_error(it)     = error("unexpected eof", it)
+    def error(msg, it)    = raise Sade::ParseError, "%s: line %d col %d" % [msg, it.line, it.col]
+    def if_expr?(it)      = control_expr?(it, '%if')
+    def else_expr?(it)    = control_expr?(it, '%else')
+    def for_expr?(it)     = control_expr?(it, '%for')
+    def include_expr?(it) = control_expr?(it, '%include')
+    def import_expr?(it)  = control_expr?(it, '%import')
+
+    def control_expr?(iterator, type)
+      it = iterator.clone
+      return false unless it.lparen?
+
+      it.next.skip_space
+
+      it.val == type
+    end
+
+    def end_of_tag?(it, last_it) = it.offset == last_it.offset
+
+    def read_path(it, last_it)
+      return it.val if it.text?
+
+      path = String.new
+      loop do
+        break if it.eof?
+        break if end_of_tag?(it, last_it)
+
+        path << it.val
+
+        break if it.peek(1).type == :space
+
+        it.next
+      end
+
+      path
+    end
+  end
+end

data/lib/sade/quoted_string_reader.rb

@@ -0,0 +1,38 @@
+module Sade
+  class QuotedStringReader
+    attr_reader :itr, :delimiter
+
+    def read(itr, delimiter)
+      return nil unless itr.current == delimiter
+
+      buf = String.new
+      first_itr = itr.clone
+      last_itr  = first_itr.next.clone
+      until last_itr.end?
+        ch = last_itr.current
+        case ch
+        when delimiter
+          if last_itr.peek(-1) == "\\"
+            buf[-1] = ch
+          else
+            break
+          end
+        else
+          buf << last_itr.current unless last_itr.end?
+        end
+        last_itr.next
+      end
+
+      error('Unterminated string literal', itr) unless last_itr.current == delimiter
+
+      itr.step(last_itr.offset - itr.offset + 1)
+      
+      buf
+    end
+
+    def error(msg, itr)
+      error_msg = "%s: line %d col %d" % [msg, itr.line, itr.col]
+      raise LexerError, error_msg
+    end
+  end
+end