twostroke 0.0.1

data/lib/twostroke/ast/array.rb

@@ -0,0 +1,14 @@
+module Twostroke::AST
+  class Array < Base
+    attr_accessor :items
+    
+    def initialize(*args)
+      @items = []
+      super *args
+    end
+    
+    def collapse
+      self.class.new items: items.map(&:collapse)
+    end
+  end
+end

data/lib/twostroke/ast/assignment.rb

@@ -0,0 +1,9 @@
+module Twostroke::AST
+  class Assignment < Base
+    attr_accessor :left, :right
+    
+    def collapse
+      self.class.new left: left.collapse, right: right.collapse
+    end
+  end
+end

data/lib/twostroke/ast/binary_operators.rb

@@ -0,0 +1,13 @@
+module Twostroke::AST
+  %w( Addition Subtraction Multiplication Division Modulus
+      LeftShift RightArithmeticShift RightLogicalShift
+      LessThan LessThanEqual GreaterThan GreaterThanEqual
+      In InstanceOf Equality Inequality StrictEquality
+      StrictInequality BitwiseAnd BitwiseXor BitwiseOr
+      And Or).each do |op|
+    klass = Class.new Base do
+      attr_accessor :left, :right
+    end
+    const_set op, klass
+  end
+end

data/lib/twostroke/ast/body.rb

@@ -0,0 +1,14 @@
+module Twostroke::AST
+  class Body < Base
+    attr_accessor :statements
+    
+    def initialize(*args)
+      @statements = []
+      super *args
+    end
+    
+    def collapse
+      self.class.new statements: statements.reject(&:nil?).map(&:collapse)
+    end
+  end
+end

data/lib/twostroke/ast/call.rb

@@ -0,0 +1,14 @@
+module Twostroke::AST
+  class Call < Base
+    attr_accessor :callee, :arguments
+    
+    def initialize(*args)
+      @arguments = []
+      super *args
+    end
+    
+    def collapse
+      self.class.new callee: callee.collapse, arguments: arguments.map(&:collapse)
+    end
+  end
+end

data/lib/twostroke/ast/declaration.rb

@@ -0,0 +1,9 @@
+module Twostroke::AST
+  class Declaration < Base
+    attr_accessor :name
+    
+    def collapse
+      self
+    end
+  end
+end

data/lib/twostroke/ast/for_loop.rb

@@ -0,0 +1,9 @@
+module Twostroke::AST
+  class ForLoop < Base
+    attr_accessor :initializer, :condition, :increment, :body
+    
+    def collapse
+      self.class.new initializer: initializer.collapse, condition: condition.collapse, increment: increment.collapse, body: body.collapse
+    end
+  end
+end

data/lib/twostroke/ast/function.rb

@@ -0,0 +1,15 @@
+module Twostroke::AST
+  class Function < Base
+    attr_accessor :name, :arguments, :statements
+    
+    def initialize(*args)
+      @arguments = []
+      @statements = []
+      super *args
+    end
+    
+    def collapse
+      self.class.new name: name, arguments: arguments, statements: statements.reject(&:nil?).map(&:collapse)
+    end
+  end
+end

data/lib/twostroke/ast/if.rb

@@ -0,0 +1,10 @@
+require 'pry'
+module Twostroke::AST
+  class If < Base
+    attr_accessor :condition, :then, :else
+    
+    def collapse
+      self.class.new condition: condition.collapse, then: @then.collapse, else: @else && @else.collapse
+    end
+  end
+end

data/lib/twostroke/ast/index.rb

@@ -0,0 +1,9 @@
+module Twostroke::AST
+  class Index < Base
+    attr_accessor :object, :index
+    
+    def collapse
+      self.class.new object: object.collapse, index: index.collapse
+    end
+  end
+end

data/lib/twostroke/ast/member_access.rb

@@ -0,0 +1,9 @@
+module Twostroke::AST
+  class MemberAccess < Base
+    attr_accessor :object, :member
+    
+    def collapse
+      self.class.new object: object.collapse, member: member
+    end
+  end
+end

data/lib/twostroke/ast/multi_expression.rb

@@ -0,0 +1,9 @@
+module Twostroke::AST
+  class MultiExpression < Base
+    attr_accessor :left, :right
+    
+    def collapse
+      self.class.new left: left.collapse, right: right.collapse
+    end
+  end
+end

data/lib/twostroke/ast/number.rb

@@ -0,0 +1,9 @@
+module Twostroke::AST
+  class Number < Base
+    attr_accessor :number
+    
+    def collapse
+      self
+    end
+  end
+end

data/lib/twostroke/ast/object_literal.rb

@@ -0,0 +1,15 @@
+module Twostroke::AST
+  class ObjectLiteral < Base
+    attr_accessor :items
+    
+    def initialize(*args)
+      @items = []
+      super *args
+    end
+    
+    def collapse
+      collapsed = items.map { |k,v| [k, v.collapse] }
+      self.class.new items: collapsed
+    end
+  end
+end

data/lib/twostroke/ast/return.rb

@@ -0,0 +1,9 @@
+module Twostroke::AST
+  class Return < Base
+    attr_accessor :expression
+    
+    def collapse
+      self.class.new expression: expression.collapse
+    end
+  end
+end

data/lib/twostroke/ast/string.rb

@@ -0,0 +1,9 @@
+module Twostroke::AST
+  class String < Base
+    attr_accessor :string
+    
+    def collapse
+      self
+    end
+  end
+end

data/lib/twostroke/ast/ternary.rb

@@ -0,0 +1,9 @@
+module Twostroke::AST
+  class Ternary < Base
+    attr_accessor :condition, :if_true, :if_false
+    
+    def collapse
+      self.class.new condition: condition.collapse, if_true: if_true.collapse, if_false: if_false.collapse
+    end
+  end
+end

data/lib/twostroke/ast/unary_operators.rb

@@ -0,0 +1,13 @@
+module Twostroke::AST
+  [ :PostIncrement, :PreIncrement, :PostDecrement, :PreDecrement,
+    :BinaryNot, :UnaryPlus, :Negation, :TypeOf, :Not ].each do |op|
+      klass = Class.new Base do
+        attr_accessor :value
+      
+        def collapse
+          self.class.new value: value.collapse
+        end
+      end
+      const_set op, klass
+    end
+end

data/lib/twostroke/ast/unsorted_binop.rb

@@ -0,0 +1,99 @@
+module Twostroke::AST
+  class UnsortedBinop < Base
+    attr_accessor :left, :op, :right
+    
+    def self.operator_class
+      @@classes ||= {
+        :ASTERISK           => Multiplication,
+        :SLASH              => Division,
+        :MOD                => Modulus,
+        :PLUS               => Addition,
+        :MINUS              => Subtraction,
+        :LEFT_SHIFT         => LeftShift,
+        :RIGHT_SHIFT        => RightArithmeticShift,
+        :RIGHT_TRIPLE_SHIFT => RightLogicalShift,
+        :LT                 => LessThan,
+        :LTE                => LessThanEqual,
+        :GT                 => GreaterThan,
+        :GTE                => GreaterThanEqual,
+        :IN                 => In,
+        :INSTANCE_OF        => InstanceOf,
+        :DOUBLE_EQUALS      => Equality,
+        :NOT_EQUALS         => Inequality,
+        :TRIPLE_EQUALS      => StrictEquality,
+        :NOT_DOUBLE_EQUALS  => StrictInequality,
+        :AMPERSAND          => BitwiseAnd,
+        :CARET              => BitwiseXor,
+        :PIPE               => BitwiseOr,
+        :AND                => And,
+        :OR                 => Or
+        
+      }
+    end
+    
+    def self.operator_precedence
+      @precedences ||= {
+        :ASTERISK           => 5,
+        :SLASH              => 5,
+        :MOD                => 5,
+        :PLUS               => 6,
+        :MINUS              => 6,
+        :LEFT_SHIFT         => 7,
+        :RIGHT_SHIFT        => 7,
+        :RIGHT_TRIPLE_SHIFT => 7,
+        :LT                 => 8,
+        :LTE                => 8,
+        :GT                 => 8,
+        :GTE                => 8,
+        :IN                 => 8,
+        :INSTANCE_OF        => 8,
+        :DOUBLE_EQUALS      => 9,
+        :NOT_EQUALS         => 9,
+        :TRIPLE_EQUALS      => 9,
+        :NOT_DOUBLE_EQUALS  => 9,
+        :AMPERSAND          => 10,
+        :CARET              => 11,
+        :PIPE               => 12,
+        :AND                => 13,
+        :OR                 => 14
+      }
+    end
+    
+    def collapse(called_by_binop = false)
+      left_collapsed = left.is_a?(UnsortedBinop) ? left.collapse(true) : left.collapse
+      right_collapsed = right.is_a?(UnsortedBinop) ? right.collapse(true) : right.collapse
+      input = [*left_collapsed, op, *right_collapsed]
+      
+      unless called_by_binop
+        stack = []
+        output = []
+        input.each do |token|
+          if token.is_a? Symbol
+            while stack.size > 0 && UnsortedBinop.operator_precedence[stack.last] <= UnsortedBinop.operator_precedence[token]
+              output.push stack.pop
+            end
+            stack.push token
+          else
+            output.push token
+          end
+        end
+        output.push stack.pop until stack.empty?
+        
+        output.each do |token|
+          if token.is_a? Symbol
+            r = stack.pop
+            l = stack.pop
+            puts token
+            stack.push UnsortedBinop.operator_class[token].new(left: l, right: r)
+          else
+            stack.push token
+          end
+        end
+        
+        stack.last
+      else
+        input
+      end
+    end
+  end
+end

data/lib/twostroke/ast/variable.rb

@@ -0,0 +1,9 @@
+module Twostroke::AST
+  class Variable < Base
+    attr_accessor :name
+    
+    def collapse
+      self
+    end
+  end
+end

data/lib/twostroke/ast.rb

@@ -0,0 +1,15 @@
+module Twostroke
+  module AST
+    class Base
+      def initialize(hash = {})
+        hash.each do |k,v|
+          send "#{k}=", v
+        end
+      end
+    end
+    
+    Dir.glob File.expand_path("../ast/*", __FILE__) do |f|
+      require f
+    end
+  end
+end

data/lib/twostroke/error.rb

@@ -0,0 +1,4 @@
+module Twostroke
+  class Error < StandardError
+  end
+end

data/lib/twostroke/lexer.rb

@@ -0,0 +1,51 @@
+module Twostroke
+  class LexError < Twostroke::Error
+  end
+  
+  class Token
+    attr_accessor :type, :val, :line, :col
+    def initialize(hash = {})
+      hash.each do |k,v|
+        send "#{k}=", v
+      end
+    end
+    def is?(t)
+      if t.is_a? Array
+        t.include? type
+      else
+        t == type
+      end
+    end
+  end
+  
+  class Lexer
+    attr_reader :str, :col, :line, :tokens
+    def initialize(str)
+      @str = str
+      @col = 1
+      @line = 1
+      @tokens = []
+    end
+    def lex
+      until @str.empty?
+        read_token
+      end
+    end
+  private
+    def read_token
+      TOKENS.each do |token|
+        m = token[1].match @str
+        if m
+          @tokens.push Token.new(:type => token[0], :val => token[2] ? token[2].call(m) : nil, :line => @line, :col => @col) unless [:WHITESPACE, :MULTI_COMMENT, :SINGLE_COMMENT].include? token[0]
+          @str = m.post_match
+          newlines = m[0].count "\n"
+          @col = 1 if !newlines.zero?
+          @line += newlines
+          @col += m[0].length - (m[0].rindex("\n") || 0)
+          return
+        end
+      end
+      raise LexError, "Illegal character '#{@str[0]}' at line #{@line}, col #{@col}. (read #{@tokens.count} tokens)"
+    end
+  end
+end

data/lib/twostroke/parser.rb

@@ -0,0 +1,379 @@
+module Twostroke
+  class ParseError < Error
+  end
+  
+  class Parser
+    attr_reader :statements
+    
+    def initialize(tokens)
+      @i = -1
+      @tokens = tokens + [Token.new(type: :SEMICOLON)]
+      @statements = []
+    end
+    
+    def parse
+      while @i + 1 < @tokens.length
+        st = statement
+        statements.push st.collapse if st
+      end
+    end
+  
+  private
+    def error!(msg)
+      raise ParseError, "Syntax error at line #{token.line}, col #{token.col}. #{msg}"
+    end
+    def assert_type(tok, *types)
+      error! "Found #{tok.type}#{"<#{tok.val}>" if tok.val}, expected #{types.join ", "}" unless types.include? tok.type
+    end
+    def stack
+      @stack
+    end
+    def stack_top
+      @stack.last
+    end
+    def token
+      @tokens[@i] or raise ParseError, "unexpected end of input"
+    end
+    def next_token
+      @i += 1
+      token
+    end
+    def try_peek_token
+      @i + 1 < @tokens.length ? peek_token : nil
+    end
+    def peek_token
+      @tokens[@i + 1] or raise ParseError, "unexpected end of input"
+    end
+    def look_ahead(n = 1)
+      @tokens[@i + n]
+    end
+    
+    ####################
+    
+    def statement(consume_semicolon = true)
+      st = case peek_token.type
+      when :RETURN;     send :return
+      when :VAR;        var
+      when :IF;         consume_semicolon = false; send :if
+      when :FOR;        consume_semicolon = false; send :for
+      when :OPEN_BRACE; consume_semicolon = false; body
+      when :SEMICOLON;  nil
+      else; expression
+      end
+      if consume_semicolon
+        #next_token if try_peek_token && peek_token.type == :SEMICOLON
+        assert_type next_token, :SEMICOLON
+      end
+      st
+    end
+    
+    def expression(no_comma = false)
+      expr = expression_after_unary no_comma
+      if [:PLUS, :MINUS, :ASTERISK, :SLASH, :GT, :LT,
+          :GTE, :LTE, :DOUBLE_EQUALS, :TRIPLE_EQUALS,
+          :NOT_EQUALS, :NOT_DOUBLE_EQUALS, :AND, :OR,
+          :AMPERSAND, :PIPE, :CARET, :MOD, :LEFT_SHIFT,
+          :RIGHT_SHIFT, :RIGHT_TRIPLE_SHIFT,  ].include? peek_token.type
+        binop expr
+      elsif peek_token.type == :EQUALS
+        next_token
+        AST::Assignment.new left: expr, right: expression(no_comma)
+      elsif peek_token.type == :QUESTION
+        ternary(expr)
+      else
+        expr
+      end
+    end
+    
+    def expression_after_unary(no_comma = false)
+      expr = case peek_token.type
+      when :FUNCTION; function
+      when :STRING; string
+      when :NUMBER; number
+      when :BAREWORD; bareword
+      when :OPEN_PAREN; parens
+      when :OPEN_BRACE; object_literal
+      when :OPEN_BRACKET; array
+      when :NOT; send :not
+      when :TILDE; tilde
+      when :INCREMENT; pre_increment
+      when :DECREMENT; pre_decrement
+      when :PLUS; unary_plus
+      when :MINUS; unary_minus
+      when :TYPEOF; typeof
+      else error! "Unexpected #{peek_token.type}"
+      end
+      loop do
+        if peek_token.type == :OPEN_PAREN
+          expr = call expr
+        elsif peek_token.type == :OPEN_BRACKET
+          expr = index expr
+        elsif peek_token.type == :MEMBER_ACCESS
+          expr = member_access expr
+        elsif !no_comma && peek_token.type == :COMMA
+          expr = comma(expr)
+        elsif peek_token.type == :INCREMENT
+          expr = post_increment expr
+        elsif peek_token.type == :DECREMENT
+          expr = post_decrement expr
+        else
+          return expr
+        end
+      end
+      expr
+    end
+    
+    def binop(left)
+      next_token
+      AST::UnsortedBinop.new left: left, op: token.type, right: expression
+    end
+    
+    def body
+      assert_type next_token, :OPEN_BRACE
+      body = AST::Body.new
+      while peek_token.type != :CLOSE_BRACE
+        body.statements.push statement
+      end
+      assert_type next_token, :CLOSE_BRACE
+      body
+    end
+    
+    def bareword
+      assert_type next_token, :BAREWORD
+      AST::Variable.new name: token.val
+    end
+    
+    def ternary(cond)
+      assert_type next_token, :QUESTION
+      ternary = AST::Ternary.new condition: cond
+      ternary.if_true = expression
+      assert_type next_token, :COLON
+      ternary.if_false = expression
+      ternary
+    end
+    
+    def if
+      assert_type next_token, :IF
+      assert_type next_token, :OPEN_PAREN
+      node = AST::If.new condition: expression
+      assert_type next_token, :CLOSE_PAREN
+      node.then = statement
+      if try_peek_token && peek_token.type == :ELSE
+        assert_type next_token, :ELSE
+        node.else = statement
+      end
+      node
+    end
+    
+    def for
+      assert_type next_token, :FOR
+      assert_type next_token, :OPEN_PAREN
+      # decide if this is a for(... in ...) or a for(;;) loop
+      stmt = statement(false)
+      assert_type next_token, :SEMICOLON, :CLOSE_PAREN
+      if token.type == :CLOSE_PAREN
+        # this is a for(... in ...) loop. we'll figure out how to deal with that in a sec
+        error! "for..in loops not implemented yet!" # @TODO
+      else
+        initializer = stmt
+        condition = statement(false)
+        assert_type next_token, :SEMICOLON
+        increment = statement(false)
+        assert_type next_token, :CLOSE_PAREN
+        AST::ForLoop.new initializer: initializer, condition: condition, increment: increment, body: statement
+      end
+    end
+    
+    def member_access(obj)
+      assert_type next_token, :MEMBER_ACCESS
+      assert_type next_token, :BAREWORD
+      access = AST::MemberAccess.new object: obj, member: token.val
+      if peek_token.type == :MEMBER_ACCESS
+        member_access access
+      elsif peek_token.type == :OPEN_PAREN
+        call access
+      elsif peek_token.type == :EQUALS
+        assignment access
+      else
+        access
+      end
+    end
+    
+    def call(callee)
+      assert_type next_token, :OPEN_PAREN
+      c = AST::Call.new callee: callee
+      while peek_token.type != :CLOSE_PAREN
+        c.arguments.push expression(true)
+        if peek_token.type == :COMMA
+          next_token
+          redo
+        end
+      end
+      next_token
+      c
+    end
+    
+    def index(obj)
+      assert_type next_token, :OPEN_BRACKET
+      ind = expression
+      assert_type next_token, :CLOSE_BRACKET
+      AST::Index.new object: obj, index: ind
+    end
+    
+    def return
+      assert_type next_token, :RETURN
+      AST::Return.new expression: expression
+    end
+    
+    def var
+      assert_type next_token, :VAR
+      var_rest
+    end
+    
+    def var_rest
+      assert_type next_token, :BAREWORD
+      decl = AST::Declaration.new(name: token.val)
+      return decl if peek_token.type == :SEMICOLON
+      
+      assert_type next_token, :COMMA, :EQUALS
+      
+      if token.type == :COMMA
+        AST::MultiExpression.new left: decl, right: var_rest
+      else
+        assignment = AST::Assignment.new left: decl, right: expression(true)
+        if peek_token.type == :SEMICOLON
+          assignment
+        elsif peek_token.type == :COMMA
+          next_token
+          AST::MultiExpression.new left: assignment, right: var_rest
+        else
+          error! "Unexpected #{peek_token.type}"
+        end
+      end
+    end
+    
+    def assignment(lval)
+      assert_type next_token, :EQUALS
+      AST::Assignment.new left: lval, right: expression
+    end
+    
+    def comma(left)
+      assert_type next_token, :COMMA
+      AST::MultiExpression.new left: left, right: expression
+    end
+    
+    def number
+      assert_type next_token, :NUMBER
+      AST::Number.new number: token.val
+    end
+    
+    def string
+      assert_type next_token, :STRING
+      AST::String.new string: token.val
+    end
+    
+    def object_literal
+      assert_type next_token, :OPEN_BRACE
+      obj = AST::ObjectLiteral.new
+      while peek_token.type != :CLOSE_BRACE
+        assert_type next_token, :BAREWORD, :STRING, :NUMBER
+        key = token
+        assert_type next_token, :COLON
+        obj.items.push [key, expression(true)]
+        if peek_token.type == :COMMA
+          next_token
+          redo
+        end
+      end
+      next_token
+      obj
+    end
+    
+    def array
+      assert_type next_token, :OPEN_BRACKET
+      ary = AST::Array.new
+      while peek_token.type != :CLOSE_BRACKET
+        ary.items.push expression(true)
+        if peek_token.type == :COMMA
+          next_token
+          redo
+        end
+      end
+      next_token
+      ary
+    end
+    
+    def parens
+      assert_type next_token, :OPEN_PAREN
+      expr = expression
+      assert_type next_token, :CLOSE_PAREN
+      expr
+    end
+    
+    def function
+      assert_type next_token, :FUNCTION
+      fn = AST::Function.new arguments: [], statements: []
+      error! unless [:BAREWORD, :OPEN_PAREN].include? next_token.type
+      if token.type == :BAREWORD
+        fn.name = token.val
+        assert_type next_token, :OPEN_PAREN
+      end
+      while peek_token.type == :BAREWORD
+        fn.arguments.push next_token.val
+        next_token if peek_token.type == :COMMA
+      end
+      assert_type next_token, :CLOSE_PAREN
+      assert_type next_token, :OPEN_BRACE
+      while peek_token.type != :CLOSE_BRACE
+        fn.statements.push statement
+      end
+      assert_type next_token, :CLOSE_BRACE
+      fn
+    end
+    
+    def not
+      assert_type next_token, :NOT
+      AST::Not.new value: expression_after_unary
+    end
+    
+    def tilde
+      assert_type next_token, :TILDE
+      AST::BinaryNot.new value: expression_after_unary
+    end
+    
+    def unary_plus
+      assert_type next_token, :PLUS
+      AST::UnaryPlus.new value: expression_after_unary
+    end
+    
+    def unary_minus
+      assert_type next_token, :MINUS
+      AST::Negation.new value: expression_after_unary
+    end
+    
+    def post_increment(obj)
+      assert_type next_token, :INCREMENT
+      AST::PostIncrement.new value: obj
+    end
+    
+    def post_decrement(obj)
+      assert_type next_token, :INCREMENT
+      AST::PostDecrement.new value: obj
+    end
+    
+    def pre_increment(obj)
+      assert_type next_token, :INCREMENT
+      AST::PreIncrement.new value: obj
+    end
+    
+    def pre_decrement(obj)
+      assert_type next_token, :INCREMENT
+      AST::PreDecrement.new value: obj
+    end
+    
+    def typeof
+      assert_type next_token, :TYPEOF
+      AST::TypeOf.new value: expression_after_unary
+    end
+  end
+end

data/lib/twostroke/tokens.rb

@@ -0,0 +1,78 @@
+module Twostroke
+  class Lexer
+    TOKENS = [
+
+      [ :MULTI_COMMENT, %r{/\*.*?\*/} ],
+      [ :SINGLE_COMMENT, /\/\/.*?$/ ],
+
+      [ :WHITESPACE, /\s+/ ],
+      [ :NUMBER, /\d+(\.\d*(e[+-]?\d+)?)?/, ->m { m[0].to_f } ],
+
+      *%w(function var if instanceof in else for while do this return throw typeof try catch).map do |w|
+        [ w.upcase.intern, /#{w}/ ]
+      end,
+      [ :BAREWORD, /[a-zA-Z_][a-zA-Z_0-9]*/, ->m { m[0] } ],
+
+      [ :STRING, /(["'])((\\.|[^\1])*?[^\1\\]?)\1/, ->m do
+        m[2].gsub(/\\([bfnrt])/) { |m|
+          case m[1]
+          when "b"; "\b"
+          when "n"; "\n"
+          when "f"; "\f"
+          when "r"; "\r"
+          when "t"; "\t"
+          end
+        }
+        .gsub(/\\([0-6]{1,3})/) { |m| m[1].to_i(7).chr }
+        .gsub(/\\x([a-f0-9]{2})/i) { |m| m[1].to_i(16).chr }
+        .gsub(/\\u([a-f0-9]{4})/i) { |m| m[1].to_i(16).chr }
+        .gsub(/\\(.)/) { |m| m[1] }
+      end ],
+
+      [ :OPEN_PAREN, /\(/ ],
+      [ :CLOSE_PAREN, /\)/ ],
+      [ :OPEN_BRACKET, /\[/ ],
+      [ :CLOSE_BRACKET, /\]/ ],
+      [ :OPEN_BRACE, /\{/ ],
+      [ :CLOSE_BRACE, /\}/ ],
+
+      [ :MEMBER_ACCESS, /\./ ],
+
+      [ :INCREMENT, /\+\+/ ],
+      [ :DECREMENT, /--/ ],
+      [ :PLUS, /\+/ ],
+      [ :MINUS, /-/ ],
+      [ :ASTERISK, /\*/ ],
+      [ :SLASH, /\// ],
+      [ :MOD, /%/ ],
+      [ :QUESTION, /\?/ ],
+      [ :COMMA, /,/ ],
+      [ :SEMICOLON, /;/ ],
+      [ :COLON, /:/ ],
+
+      [ :AND, /&&/ ],
+      [ :AMPERSAND, /&/ ],
+      [ :OR, /\|\|/ ],
+      [ :PIPE, /\|/ ],
+      [ :TRIPLE_EQUALS, /===/ ],
+      [ :DOUBLE_EQUALS, /==/ ],
+      [ :EQUALS, /=/ ],
+      [ :NOT_DOUBLE_EQUALS, /!==/ ],
+      [ :NOT_EQUALS, /!=/ ],
+      [ :NOT, /!/ ],
+      [ :TILDE, /~/ ],
+      [ :CARET, /\^/ ],
+
+      [ :LEFT_SHIFT, /<</ ],
+      [ :RIGHT_TRIPLE_SHIFT, />>>/ ],
+      [ :RIGHT_SHIFT, />>/ ],
+      [ :LTE, /<=/ ],
+      [ :GTE, />=/ ],
+      [ :LT, /</ ],
+      [ :GT, />/ ],
+
+    ].map do |a|
+      [a[0], Regexp.new("\\A#{a[1].source}", Regexp::MULTILINE), a[2]]
+    end
+  end
+end

data/lib/twostroke.rb

@@ -0,0 +1,5 @@
+require "twostroke/error"
+require "twostroke/tokens"
+require "twostroke/lexer"
+require "twostroke/parser"
+require "twostroke/ast"

metadata

@@ -0,0 +1,72 @@
+--- !ruby/object:Gem::Specification
+name: twostroke
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Charlie Somerville
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-10-04 00:00:00.000000000Z
+dependencies: []
+description: An implementation of Javascript written in pure Ruby. This project currently
+  includes a WIP parser, and will include a runtime.
+email:
+- charlie@charliesomerville.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/twostroke/ast/array.rb
+- lib/twostroke/ast/assignment.rb
+- lib/twostroke/ast/binary_operators.rb
+- lib/twostroke/ast/body.rb
+- lib/twostroke/ast/call.rb
+- lib/twostroke/ast/declaration.rb
+- lib/twostroke/ast/for_loop.rb
+- lib/twostroke/ast/function.rb
+- lib/twostroke/ast/if.rb
+- lib/twostroke/ast/index.rb
+- lib/twostroke/ast/member_access.rb
+- lib/twostroke/ast/multi_expression.rb
+- lib/twostroke/ast/number.rb
+- lib/twostroke/ast/object_literal.rb
+- lib/twostroke/ast/return.rb
+- lib/twostroke/ast/string.rb
+- lib/twostroke/ast/ternary.rb
+- lib/twostroke/ast/unary_operators.rb
+- lib/twostroke/ast/unsorted_binop.rb
+- lib/twostroke/ast/variable.rb
+- lib/twostroke/ast.rb
+- lib/twostroke/error.rb
+- lib/twostroke/lexer.rb
+- lib/twostroke/parser.rb
+- lib/twostroke/tokens.rb
+- lib/twostroke.rb
+homepage: http://github.com/charliesome/twostroke
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: A Ruby implementation of Javascript
+test_files: []