rux 1.0.0

data/lib/rux/rux_lexer.rb

@@ -0,0 +1,157 @@
+require 'csv'
+
+module Rux
+  class RuxLexer
+    class << self
+      # See: https://docs.google.com/spreadsheets/d/11ikKuySIKoaj-kFIfhlzebUwH31cRt_1flGjWfk7RMg
+      def state_table
+        @state_table ||= {}.tap do |table|
+          state_table_data = CSV.read(state_table_path)
+          input_patterns = state_table_data[0][1..-1]
+
+          inputs = input_patterns.map do |pattern|
+            parse_pattern(pattern)
+          end
+
+          state_table_data[1..-1].each do |row|
+            next unless row[0]  # allows blank lines in csv
+
+            state = Lex::State.parse(row[0], row[1..-1], inputs)
+            table[state.name] = state
+          end
+        end
+      end
+
+      def state_table_path
+        @state_table_path ||=
+          ::File.expand_path(::File.join('.', 'lex', 'states.csv'), __dir__)
+      end
+
+      def parse_pattern(pattern)
+        if pattern == "(space)"
+          Lex::CharsetPattern.new([' ', "\r", "\n"])
+        elsif pattern == "(default)"
+          Lex::DefaultPattern.new
+        elsif pattern.start_with?('[^')
+          Lex::NegatedCharsetPattern.parse(pattern[2..-2])
+        else
+          Lex::CharsetPattern.parse(pattern[1..-2])
+        end
+      end
+    end
+
+
+    def initialize(source_buffer, init_pos)
+      @p = init_pos
+      @source_buffer = source_buffer
+      @source_pts = @source_buffer.source.unpack('U*')
+      @generator = to_enum(:each_token)
+    end
+
+    def advance
+      @generator.next
+    end
+
+    def reset_to(pos)
+      @p = pos
+      @eof = false
+    end
+
+    def next_lexer(pos)
+      RubyLexer.new(@source_buffer, pos)
+    end
+
+    private
+
+    def each_token
+      tag_stack = []
+      @eof = false
+
+      each_rux_token do |token|
+        state, (text, pos) = token
+
+        if ruby_code?(state)
+          @eof = true
+
+          # @eof is set to false by reset_to above, which is called after
+          # popping the previous lexer off the lexer stack (see lexer.rb)
+          while @eof
+            yield [nil, ['$eof', pos]]
+          end
+
+          next
+        end
+
+        yield token
+
+        case state
+          when :tRUX_TAG_OPEN, :tRUX_TAG_SELF_CLOSING
+            tag_stack.push(text)
+          when :tRUX_TAG_CLOSE
+            tag_stack.pop
+          when :tRUX_TAG_CLOSE_END
+            break if tag_stack.empty?
+          when :tRUX_TAG_SELF_CLOSING_END
+            tag_stack.pop
+            break if tag_stack.empty?
+        end
+      end
+    end
+
+    def each_rux_token(&block)
+      cur_state = :tRUX_START
+      last_idx = @p
+
+      loop do
+        check_eof
+
+        chr = @source_pts[@p].chr
+        cur_trans = self.class.state_table[cur_state][chr]
+
+        unless cur_trans
+          raise Rux::Lexer::TransitionError,
+            "no transition found from #{cur_state} at position #{@p} while "\
+            'lexing rux code'
+        end
+
+        cur_state = cur_trans.to_state
+        @p += cur_trans.advance_count
+
+        if self.class.state_table[cur_state].terminal?
+          token_text = @source_buffer.source[last_idx...@p]
+          yield [cur_state, [token_text, make_range(last_idx, @p)]]
+
+          check_eof
+
+          next_chr = @source_pts[@p].chr
+
+          # no transition from the current state means we need to reset to the
+          # start state
+          unless self.class.state_table[cur_state][next_chr]
+            cur_state = :tRUX_START
+          end
+
+          last_idx = @p
+        end
+      end
+    end
+
+    def check_eof
+      if @p >= @source_pts.length
+        raise Rux::Lexer::EOFError, 'unexpected end of rux input'
+      end
+    end
+
+    def make_range(start, stop)
+      ::Parser::Source::Range.new(@source_buffer, start, stop)
+    end
+
+    # Ruby code can only exist in two places: attribute values and inside tag
+    # bodies. Eventually I'd like to also allow passing a Ruby hash to
+    # dynamically specify attributes, but we're not there yet.
+    def ruby_code?(state)
+      state == :tRUX_ATTRIBUTE_VALUE_RUBY_CODE ||
+        state == :tRUX_LITERAL_RUBY_CODE
+    end
+  end
+end

data/lib/rux/utils.rb

@@ -0,0 +1,15 @@
+module Rux
+  module Utils
+    def attr_to_hash_elem(key, value)
+      key = key.gsub('-', '_')
+
+      if key =~ /\A[\w\d]+\z/
+        "#{key}: #{value}"
+      else
+        ":\"#{key}\" => #{value}"
+      end
+    end
+  end
+
+  Utils.extend(Utils)
+end

data/lib/rux/version.rb

@@ -0,0 +1,3 @@
+module Rux
+  VERSION = '1.0.0'
+end

data/lib/rux/visitor.rb

@@ -0,0 +1,33 @@
+module Rux
+  class Visitor
+    def visit(node)
+      node.accept(self)
+    end
+
+    def visit_list(node)
+      visit_children(node)
+    end
+
+    def visit_ruby(node)
+      visit_children(node)
+    end
+
+    def visit_string(node)
+      visit_children(node)
+    end
+
+    def visit_tag(node)
+      visit_children(node)
+    end
+
+    def visit_text(node)
+      visit_children(node)
+    end
+
+    def visit_children(node)
+      if node.respond_to?(:children)
+        node.children.each { |child| visit(child) }
+      end
+    end
+  end
+end

data/rux.gemspec

@@ -0,0 +1,20 @@
+$:.unshift File.join(File.dirname(__FILE__), 'lib')
+require 'rux/version'
+
+Gem::Specification.new do |s|
+  s.name     = 'rux'
+  s.version  = ::Rux::VERSION
+  s.authors  = ['Cameron Dutro']
+  s.email    = ['camertron@gmail.com']
+  s.homepage = 'http://github.com/camertron/rux'
+  s.description = s.summary = 'A jsx-inspired way to write view components.'
+  s.platform = Gem::Platform::RUBY
+
+  s.add_dependency 'parser', '~> 3.0'
+  s.add_dependency 'unparser', '~> 0.5'
+
+  s.require_path = 'lib'
+  s.executables << 'ruxc'
+
+  s.files = Dir['{lib,spec}/**/*', 'Gemfile', 'LICENSE', 'CHANGELOG.md', 'README.md', 'Rakefile', 'rux.gemspec']
+end

data/spec/parser_spec.rb

@@ -0,0 +1,229 @@
+require 'spec_helper'
+require 'parser'
+require 'unparser'
+
+describe Rux::Parser do
+  def compile(rux_code)
+    Rux.to_ruby(rux_code)
+  end
+
+  it 'handles a single self-closing tag' do
+    expect(compile("<Hello/>")).to eq("render(Hello.new)")
+  end
+
+  it 'handles a self-closing tag with spaces preceding the closing punctuation' do
+    expect(compile("<Hello />")).to eq("render(Hello.new)")
+  end
+
+  it 'handles a single opening and closing tag' do
+    expect(compile("<Hello></Hello>")).to eq('render(Hello.new)')
+  end
+
+  it 'handles a single tag with a text body' do
+    expect(compile("<Hello>foo</Hello>")).to eq(<<~RUBY.strip)
+      render(Hello.new) {
+        "foo"
+      }
+    RUBY
+  end
+
+  it 'handles single-quoted rux attributes' do
+    expect(compile("<Hello foo='bar' />")).to eq(
+      'render(Hello.new({ foo: "bar" }))'
+    )
+
+    expect(compile("<Hello foo='bar'></Hello>")).to eq(
+      'render(Hello.new({ foo: "bar" }))'
+    )
+  end
+
+  it 'handles double-quoted rux attributes' do
+    expect(compile('<Hello foo="bar" />')).to eq(
+      'render(Hello.new({ foo: "bar" }))'
+    )
+
+    expect(compile('<Hello foo="bar"></Hello>')).to eq(
+      'render(Hello.new({ foo: "bar" }))'
+    )
+  end
+
+  it 'handles non-uniform spacing between attributes' do
+    expect(compile('<Hello  foo="bar"    baz= "boo" bix  ="bit" />')).to eq(
+      'render(Hello.new({ foo: "bar", baz: "boo", bix: "bit" }))'
+    )
+  end
+
+  it 'handles boolean attributes' do
+    expect(compile('<Hello disabled />')).to eq(
+      'render(Hello.new({ disabled: "true" }))'
+    )
+
+    expect(compile('<Hello disabled/>')).to eq(
+      'render(Hello.new({ disabled: "true" }))'
+    )
+
+    expect(compile('<Hello disabled></Hello>')).to eq(
+      'render(Hello.new({ disabled: "true" }))'
+    )
+  end
+
+  it 'converts dashes to underscores in attribute keys' do
+    expect(compile('<Hello foo-bar="baz" />')).to eq(
+      'render(Hello.new({ foo_bar: "baz" }))'
+    )
+  end
+
+  it 'handles simple ruby statements in attributes' do
+    expect(compile('<Hello foo={true} />')).to eq(
+      'render(Hello.new({ foo: true }))'
+    )
+  end
+
+  it 'handles ruby hashes in attributes' do
+    expect(compile('<Hello foo={{ foo: "bar", baz: "boo" }} />')).to eq(
+      'render(Hello.new({ foo: { foo: "bar", baz: "boo" } }))'
+    )
+  end
+
+  it 'handles ruby code with curly braces in attributes' do
+    expect(compile('<Hello foo={[1, 2, 3].map { |n| n * 2 }} />')).to eq(<<~RUBY.strip)
+      render(Hello.new({ foo: [1, 2, 3].map { |n,|
+        n * 2
+      } }))
+    RUBY
+  end
+
+  it 'handles simple ruby statements in tag bodies' do
+    expect(compile('<Hello>{"foo"}</Hello>')).to eq(<<~RUBY.strip)
+      render(Hello.new) {
+        "foo"
+      }
+    RUBY
+  end
+
+  it 'handles tag bodies containing ruby code with curly braces' do
+    expect(compile('<Hello>{[1, 2, 3].map { |n| n * 2 }.join(", ")}</Hello>')).to eq(<<~RUBY.strip)
+      render(Hello.new) {
+        [1, 2, 3].map { |n,|
+          n * 2
+        }.join(", ")
+      }
+    RUBY
+  end
+
+  it 'handles tag bodies with intermixed text and ruby code' do
+    expect(compile('<Hello>abc {foo} def {bar} baz</Hello>')).to eq(<<~RUBY.strip)
+      render(Hello.new) {
+        Rux.create_buffer.tap { |_rux_buf_,|
+          _rux_buf_ << "abc "
+          _rux_buf_ << foo
+          _rux_buf_ << " def "
+          _rux_buf_ << bar
+          _rux_buf_ << " baz"
+        }.to_s
+      }
+    RUBY
+  end
+
+  it 'handles rux tags inside ruby code' do
+    rux_code = <<~RUX
+      <Outer>
+        {5.times.map do
+          <Inner>What a {@thing}</Inner>
+        end}
+      </Outer>
+    RUX
+
+    expect(compile(rux_code)).to eq(<<~RUBY.strip)
+      render(Outer.new) {
+        Rux.create_buffer.tap { |_rux_buf_,|
+          _rux_buf_ << " "
+          _rux_buf_ << 5.times.map {
+            render(Inner.new) {
+              Rux.create_buffer.tap { |_rux_buf_,|
+                _rux_buf_ << "What a "
+                _rux_buf_ << @thing
+              }.to_s
+            }
+          }
+          _rux_buf_ << " "
+        }.to_s
+      }
+    RUBY
+  end
+
+  it 'handles regular HTML tags' do
+    expect(compile('<div>foo</div>')).to eq(<<~RUBY.strip)
+      Rux.tag("div") {
+        "foo"
+      }
+    RUBY
+  end
+
+  it 'handles regular HTML tags inside ruby code' do
+    rux_code = <<~RUX
+      <Outer>
+        {5.times.map do
+          <div>So {@cool}</div>
+        end}
+      </Outer>
+    RUX
+
+    expect(compile(rux_code)).to eq(<<~RUBY.strip)
+      render(Outer.new) {
+        Rux.create_buffer.tap { |_rux_buf_,|
+          _rux_buf_ << " "
+          _rux_buf_ << 5.times.map {
+            Rux.tag("div") {
+              Rux.create_buffer.tap { |_rux_buf_,|
+                _rux_buf_ << "So "
+                _rux_buf_ << @cool
+              }.to_s
+            }
+          }
+          _rux_buf_ << " "
+        }.to_s
+      }
+    RUBY
+  end
+
+  it 'escapes HTML entities in strings' do
+    expect(compile('<Hello>"foo"</Hello>')).to eq(<<~RUBY.strip)
+      render(Hello.new) {
+        "&quot;foo&quot;"
+      }
+    RUBY
+  end
+
+  it 'raises an error on premature end of input' do
+    expect { compile('<Hello') }.to raise_error(Rux::Lexer::EOFError)
+  end
+
+  it 'raises an error when no state transition can be found' do
+    expect { compile('<Hello <foo>') }.to(
+      raise_error(Rux::Lexer::TransitionError,
+        'no transition found from tRUX_ATTRIBUTE_SPACES_BODY at position 7 '\
+          'while lexing rux code')
+    )
+  end
+
+  it 'raises an error on tag mismatch' do
+    expect { compile('<Hello></Goodbye>') }.to(
+      raise_error(Rux::Parser::TagMismatchError,
+        "closing tag 'Goodbye' on line 1 did not match opening tag 'Hello' "\
+        'on line 1')
+    )
+  end
+
+  it 'emits handles spaces between adjacent ruby code snippets' do
+    expect(compile("<Hello>{first} {second}</Hello>")).to eq(<<~RUBY.strip)
+      render(Hello.new) {
+        Rux.create_buffer.tap { |_rux_buf_,|
+          _rux_buf_ << first
+          _rux_buf_ << " "
+          _rux_buf_ << second
+        }.to_s
+      }
+    RUBY
+  end
+end