rux 1.0.0

data/lib/rux.rb

@@ -0,0 +1,73 @@
+require 'stringio'
+
+# Racc uses LoadErrors for flow control and in certain ruby versions will
+# print one along with its stack trace when required. To avoid receiving a
+# long, arresting, and entirely irrelevant stack trace every time you invoke
+# rux, temporarily redirect STDOUT here and throw away the output.
+begin
+  old_stdout = $stdout
+  $stdout = StringIO.new
+  require 'racc/parser'
+ensure
+  $stdout = old_stdout
+end
+
+require 'cgi'
+require 'parser/current'
+require 'unparser'
+
+module Rux
+  autoload :AST,               'rux/ast'
+  autoload :Buffer,            'rux/buffer'
+  autoload :Component,         'rux/component'
+  autoload :DefaultTagBuilder, 'rux/default_tag_builder'
+  autoload :DefaultVisitor,    'rux/default_visitor'
+  autoload :File,              'rux/file'
+  autoload :Lex,               'rux/lex'
+  autoload :Lexer,             'rux/lexer'
+  autoload :Parser,            'rux/parser'
+  autoload :RubyLexer,         'rux/ruby_lexer'
+  autoload :RuxLexer,          'rux/rux_lexer'
+  autoload :Utils,             'rux/utils'
+  autoload :Visitor,           'rux/visitor'
+
+  class << self
+    attr_accessor :tag_builder, :buffer
+
+    def to_ruby(str, visitor: default_visitor, pretty: true)
+      ruby_code = visitor.visit(Parser.parse(str))
+      return ruby_code unless pretty
+
+      ::Unparser.unparse(
+        ::Parser::CurrentRuby.parse(ruby_code)
+      )
+    end
+
+    def default_visitor
+      @default_visitor ||= DefaultVisitor.new
+    end
+
+    def default_tag_builder
+      @default_tag_builder ||= DefaultTagBuilder.new
+    end
+
+    def default_buffer
+      @default_buffer ||= Buffer
+    end
+
+    def tag(tag_name, attributes = {}, &block)
+      tag_builder.call(tag_name, attributes, &block)
+    end
+
+    def create_buffer
+      buffer.new
+    end
+
+    def library_paths
+      @library_paths ||= []
+    end
+  end
+
+  self.tag_builder = self.default_tag_builder
+  self.buffer = self.default_buffer
+end

data/lib/rux/ast.rb

@@ -0,0 +1,9 @@
+module Rux
+  module AST
+    autoload :ListNode,   'rux/ast/list_node'
+    autoload :RubyNode,   'rux/ast/ruby_node'
+    autoload :StringNode, 'rux/ast/string_node'
+    autoload :TagNode,    'rux/ast/tag_node'
+    autoload :TextNode,   'rux/ast/text_node'
+  end
+end

data/lib/rux/ast/list_node.rb

@@ -0,0 +1,15 @@
+module Rux
+  module AST
+    class ListNode
+      attr_reader :children
+
+      def initialize(children)
+        @children = children
+      end
+
+      def accept(visitor)
+        visitor.visit_list(self)
+      end
+    end
+  end
+end

data/lib/rux/ast/ruby_node.rb

@@ -0,0 +1,15 @@
+module Rux
+  module AST
+    class RubyNode
+      attr_reader :code
+
+      def initialize(code)
+        @code = code
+      end
+
+      def accept(visitor)
+        visitor.visit_ruby(self)
+      end
+    end
+  end
+end

data/lib/rux/ast/string_node.rb

@@ -0,0 +1,15 @@
+module Rux
+  module AST
+    class StringNode
+      attr_reader :str
+
+      def initialize(str)
+        @str = str
+      end
+
+      def accept(visitor)
+        visitor.visit_string(self)
+      end
+    end
+  end
+end

data/lib/rux/ast/tag_node.rb

@@ -0,0 +1,17 @@
+module Rux
+  module AST
+    class TagNode
+      attr_reader :name, :attrs, :children
+
+      def initialize(name, attrs)
+        @name = name
+        @attrs = attrs
+        @children = []
+      end
+
+      def accept(visitor)
+        visitor.visit_tag(self)
+      end
+    end
+  end
+end

data/lib/rux/ast/text_node.rb

@@ -0,0 +1,17 @@
+require 'cgi'
+
+module Rux
+  module AST
+    class TextNode
+      attr_reader :text
+
+      def initialize(text)
+        @text = text
+      end
+
+      def accept(visitor)
+        visitor.visit_text(self)
+      end
+    end
+  end
+end

data/lib/rux/buffer.rb

@@ -0,0 +1,15 @@
+module Rux
+  class Buffer
+    def initialize(init_str = '')
+      @string = init_str.dup
+    end
+
+    def <<(str)
+      @string << (str || '')
+    end
+
+    def to_s
+      @string
+    end
+  end
+end

data/lib/rux/default_tag_builder.rb

@@ -0,0 +1,20 @@
+module Rux
+  class DefaultTagBuilder
+    def call(tag_name, attributes = {})
+      "<#{tag_name} #{serialize_attrs(attributes)}>" <<
+        (block_given? ? Array(yield) : []).join <<
+        "</#{tag_name}>"
+    end
+
+    private
+
+    def serialize_attrs(attributes)
+      ''.tap do |result|
+        attributes.each_pair.with_index do |(k, v), idx|
+          result << ' ' unless idx == 0
+          result << "#{k.to_s.gsub('-', '_')}=\"#{CGI.escape_html(v.to_s)}\""
+        end
+      end
+    end
+  end
+end

data/lib/rux/default_visitor.rb

@@ -0,0 +1,67 @@
+require 'cgi'
+
+module Rux
+  class DefaultVisitor < Visitor
+    def visit_list(node)
+      node.children.map { |child| visit(child) }.join
+    end
+
+    def visit_ruby(node)
+      node.code
+    end
+
+    def visit_string(node)
+      node.str
+    end
+
+    def visit_tag(node)
+      ''.tap do |result|
+        block_arg = if (as = node.attrs['as'])
+          visit(as)
+        end
+
+        at = node.attrs.each_with_object([]) do |(k, v), ret|
+          next if k == 'as'
+          ret << Utils.attr_to_hash_elem(k, visit(v))
+        end
+
+        if node.name.start_with?(/[A-Z]/)
+          result << "render(#{node.name}.new"
+
+          unless node.attrs.empty?
+            result << "({ #{at.join(', ')} })"
+          end
+        else
+          result << "Rux.tag('#{node.name}'"
+
+          unless node.attrs.empty?
+            result << ", { #{at.join(', ')} }"
+          end
+        end
+
+        result << ')'
+
+        if node.children.size > 1
+          result << " { "
+          result << "|#{block_arg}| " if block_arg
+          result << "Rux.create_buffer.tap { |_rux_buf_| "
+
+          node.children.each do |child|
+            result << "_rux_buf_ << #{visit(child).strip};"
+          end
+
+          result << " }.to_s }"
+        elsif node.children.size == 1
+          result << ' { '
+          result << "|#{block_arg}| " if block_arg
+          result << visit(node.children.first).strip
+          result << ' }'
+        end
+      end
+    end
+
+    def visit_text(node)
+      "\"#{CGI.escape_html(node.text)}\""
+    end
+  end
+end

data/lib/rux/file.rb

@@ -0,0 +1,27 @@
+module Rux
+  class File
+    attr_reader :path
+
+    def initialize(path)
+      @path = path
+    end
+
+    def to_ruby(visitor: Rux.default_visitor, **kwargs)
+      Rux.to_ruby(contents, visitor: visitor, **kwargs)
+    end
+
+    def write(outfile = nil, **kwargs)
+      ::File.write(outfile || default_outfile, to_ruby(**kwargs))
+    end
+
+    def default_outfile
+      @outfile ||= "#{path.chomp('.rux')}.rb"
+    end
+
+    private
+
+    def contents
+      @contents ||= ::File.read(path)
+    end
+  end
+end

data/lib/rux/lex.rb

@@ -0,0 +1,9 @@
+module Rux
+  module Lex
+    autoload :CharsetPattern,        'rux/lex/patterns'
+    autoload :DefaultPattern,        'rux/lex/patterns'
+    autoload :NegatedCharsetPattern, 'rux/lex/patterns'
+    autoload :State,                 'rux/lex/state'
+    autoload :Transition,            'rux/lex/transition'
+  end
+end

data/lib/rux/lex/patterns.rb

@@ -0,0 +1,41 @@
+module Rux
+  module Lex
+    class DefaultPattern
+      def matches?(_)
+        true
+      end
+    end
+
+    class CharsetPattern
+      def self.parse(str)
+        pairs = str.scan(/(.)-?(.)?/)
+
+        new(
+          pairs.flat_map do |pair|
+            if pair[1]
+              (pair[0]..pair[1]).to_a
+            else
+              [pair[0]]
+            end
+          end
+        )
+      end
+
+      attr_reader :chars
+
+      def initialize(chars)
+        @chars = Set.new(chars)
+      end
+
+      def matches?(char)
+        chars.include?(char)
+      end
+    end
+
+    class NegatedCharsetPattern < CharsetPattern
+      def matches?(char)
+        !chars.include?(char)
+      end
+    end
+  end
+end

data/lib/rux/lex/state.rb

@@ -0,0 +1,33 @@
+module Rux
+  module Lex
+    class State
+      def self.parse(state_str, transition_strs, inputs)
+        is_terminal = state_str.end_with?('*')
+        state_name = "tRUX_#{state_str.chomp('*').upcase}".to_sym
+
+        transitions = transition_strs.each_with_object([]).with_index do |(ts, ret), idx|
+          ret << Transition.parse(ts, inputs[idx]) if ts
+        end
+
+        new(state_name, is_terminal, transitions)
+      end
+
+      attr_reader :name, :is_terminal, :transitions
+
+      alias_method :terminal?, :is_terminal
+
+      def initialize(name, is_terminal, transitions)
+        @name = name
+        @is_terminal = is_terminal
+        @transitions = transitions
+        @cache = {}
+      end
+
+      def [](chr)
+        @cache[chr] ||= transitions.find do |trans|
+          trans.matches?(chr)
+        end
+      end
+    end
+  end
+end

data/lib/rux/lex/states.csv

@@ -0,0 +1,39 @@
+,[<],[a-zA-Z0-9_-_---:-:],[>],[/],(space),[=],"[""]",['],"[^""]",[^'],[{],[}],(default)
+start,tag_open_test,,,,,,,,,,literal_ruby_code_start,,literal_body
+tag_open_test,,tag_open_start[0],,tag_close_start,,,,,,,,,
+tag_open_start*,,tag_open_body,,,,,,,,,,,
+tag_open_body,,tag_open_body,tag_open[0],tag_self_closing[0],tag_open[0],,,,,,,,
+tag_open*,,,tag_open_end,,attribute_spaces_body,,,,,,,,
+tag_open_end*,,,,,,,,,,,,,
+tag_close_start*,,tag_close_body,,,,,,,,,,,
+tag_close_body,,tag_close_body,tag_close[0],,tag_close[0],,,,,,,,
+tag_close*,,,tag_close_end,tag_self_closing[0],tag_close_spaces_body,,,,,,,,
+tag_close_spaces_body,,,tag_close_spaces[0],,tag_close_spaces_body,,,,,,,,
+tag_close_spaces*,,,tag_close_end,,,,,,,,,,
+tag_close_end*,,,,,,,,,,,,,
+tag_self_closing*,,,,tag_self_closing_start,,,,,,,,,
+tag_self_closing_start,,,tag_self_closing_end,,,,,,,,,,
+tag_self_closing_end*,,,,,,,,,,,,,
+,,,,,,,,,,,,,
+attribute_spaces_body,,attribute_spaces[0],attribute_spaces[0],attribute_spaces[0],attribute_spaces_body,,,,,,,,
+attribute_spaces*,,attribute_name_body,tag_close_start,tag_self_closing_start,,,,,,,,,
+attribute_name_body,,attribute_name_body,attribute_name[0],attribute_name[0],attribute_name[0],attribute_name[0],,,,,,,
+attribute_name*,,,tag_open_end,tag_self_closing_start,attribute_equals_spaces_body,attribute_equals,,,,,,,
+attribute_equals_spaces_body,,,attribute_equals_spaces[0],,attribute_equals_spaces_body,attribute_equals_spaces[0],,,,,,,attribute_equals_spaces[0]
+attribute_equals_spaces*,,,tag_open_end,tag_self_closing_start,,attribute_equals,,,,,,,attribute_name_body
+attribute_equals*,,attribute_uq_body,,,attribute_value_spaces_body[0],,attribute_dq_body,attribute_sq_body,,,attribute_value_ruby_code_start,,
+attribute_value_spaces_body,,attribute_value_spaces[0],,,attribute_value_spaces_body,,attribute_value_spaces[0],attribute_value_spaces[0],,,attribute_value_spaces[0],,
+attribute_value_spaces*,,attribute_uq_body,,,,,attribute_dq_body,attribute_sq_body,,,attribute_value_ruby_code_start,,
+attribute_dq_body,,,,,,,attribute_value,,attribute_dq_body,,,,
+attribute_sq_body,,,,,,,,attribute_value,,attribute_sq_body,,,
+attribute_uq_body,,attribute_uq_body,,,attribute_value,,,,,,,,
+attribute_value_ruby_code_start*,,,,,,,,,,,,,attribute_value_ruby_code
+attribute_value_ruby_code*,,,,,,,,,,,,attribute_value_ruby_code_end,
+attribute_value_ruby_code_end*,,attribute_name,tag_open_end,tag_self_closing_start,attribute_spaces_body,,,,,,,,
+attribute_value*,,attribute_name,tag_open_end,tag_self_closing_start,attribute_spaces_body,,attribute_value_ending,attribute_value_ending,,,,,
+,,,,,,,,,,,,,
+literal_body,literal[0],,,,,,,,,,literal[0],,literal_body
+literal*,,,,,,,,,,,literal_ruby_code_start,,
+literal_ruby_code_start*,,,,,,,,,,,,,literal_ruby_code[0]
+literal_ruby_code*,,,,,,,,,,,,literal_ruby_code_end,
+literal_ruby_code_end*,,,,,,,,,,,,,

data/lib/rux/lex/transition.rb

@@ -0,0 +1,22 @@
+module Rux
+  module Lex
+    class Transition
+      attr_reader :input, :to_state, :advance_count
+
+      def self.parse(str, input)
+        to_state, advance_count = str.match(/\A(\w+)\[?(-?\d+)?\]?/).captures
+        new(input, :"tRUX_#{to_state.upcase}", (advance_count || 1).to_i)
+      end
+
+      def initialize(input, to_state, advance_count)
+        @input = input
+        @to_state = to_state
+        @advance_count = advance_count
+      end
+
+      def matches?(chr)
+        input.matches?(chr)
+      end
+    end
+  end
+end