rkelly 1.0.0

data/lib/rkelly/js.rb

@@ -0,0 +1,14 @@
+require 'rkelly/js/nan'
+require 'rkelly/js/property'
+require 'rkelly/js/base'
+require 'rkelly/js/global_object'
+require 'rkelly/js/object'
+require 'rkelly/js/object_prototype'
+require 'rkelly/js/function_prototype'
+require 'rkelly/js/array'
+require 'rkelly/js/boolean'
+require 'rkelly/js/math'
+require 'rkelly/js/number'
+require 'rkelly/js/string'
+require 'rkelly/js/scope'
+require 'rkelly/js/function'

data/lib/rkelly/js/array.rb

@@ -0,0 +1,15 @@
+module RKelly
+  module JS
+    class Array < Base
+      class << self
+        def create(*args)
+          self.new(*args)
+        end
+      end
+
+      def initialize(*args)
+        super()
+      end
+    end
+  end
+end

data/lib/rkelly/js/base.rb

@@ -0,0 +1,91 @@
+module RKelly
+  module JS
+    class Base
+      attr_reader :properties, :return, :value
+      def initialize
+        @properties = Hash.new { |h,k|
+          h[k] = Property.new(k, :undefined, self)
+        }
+        @return     = nil
+        @returned   = false
+        @value      = self
+        self['Class'] = self.class.to_s.split('::').last
+      end
+
+      def [](name)
+        return self.properties[name] if has_property?(name)
+        if self.properties['prototype'].value != :undefined
+          self.properties['prototype'].value[name]
+        else
+          RKelly::Runtime::UNDEFINED
+        end
+      end
+
+      def []=(name, value)
+        return unless can_put?(name)
+        if has_property?(name)
+          self.properties[name].value = value
+        else
+          self.properties[name] = Property.new(name, value, self)
+        end
+      end
+
+      def can_put?(name)
+        if !has_property?(name)
+          return true if self.properties['prototype'].nil?
+          return true if self.properties['prototype'].value.nil?
+          return true if self.properties['prototype'].value == :undefined
+          return self.properties['prototype'].value.can_put?(name)
+        end
+        !self.properties[name].read_only?
+      end
+
+      def has_property?(name)
+        return true if self.properties.has_key?(name)
+        return false if self.properties['prototype'].nil?
+        return false if self.properties['prototype'].value.nil?
+        return false if self.properties['prototype'].value == :undefined
+        self.properties['prototype'].value.has_property?(name)
+      end
+
+      def delete(name)
+        return true unless has_property?(name)
+        return false if self.properties[name].dont_delete?
+        self.properties.delete(name)
+        true
+      end
+
+      def default_value(hint)
+        case hint
+        when 'Number'
+          value_of = self['valueOf']
+          if value_of.function || value_of.value.is_a?(RKelly::JS::Function)
+            return value_of
+          end
+          to_string = self['toString']
+          if to_string.function || to_string.value.is_a?(RKelly::JS::Function)
+            return to_string
+          end
+        end
+      end
+
+      def return=(value)
+        @returned = true
+        @return = value
+      end
+
+      def returned?; @returned; end
+
+      private
+      def unbound_method(name, object_id = nil, &block)
+        name = "#{name}_#{self.class.to_s.split('::').last}_#{object_id}"
+        unless RKelly::JS::Base.instance_methods.include?(name.to_sym)
+          RKelly::JS::Base.class_eval do
+            define_method(name, &block)
+          end
+        end
+        RKelly::JS::Base.instance_method(name)
+      end
+    end
+  end
+end

data/lib/rkelly/js/boolean.rb

@@ -0,0 +1,21 @@
+module RKelly
+  module JS
+    class Boolean < Base
+      class << self
+        def create(*args)
+          return false if args.length == 0
+          self.new(args.first)
+        end
+      end
+      def initialize(*args)
+        super()
+        value = args.first.nil? ? false : args.first
+        self['valueOf'] = value
+        self['valueOf'].function = lambda {
+          value
+        }
+        self['toString'] = args.first.to_s
+      end
+    end
+  end
+end

data/lib/rkelly/js/function.rb

@@ -0,0 +1,39 @@
+module RKelly
+  module JS
+    class Function < Base
+      class << self
+        def create(*args)
+          if args.length > 0
+            parser = RKelly::Parser.new
+            body = args.pop
+            tree = parser.parse("function x(#{args.join(',')}) { #{body} }")
+            func = tree.value.first
+            self.new(func.function_body, func.arguments)
+          else
+            self.new
+          end
+        end
+      end
+
+      attr_reader :body, :arguments
+      def initialize(body = nil, arguments = [])
+        super()
+        @body = body
+        @arguments = arguments
+        self['prototype'] = JS::FunctionPrototype.new(self)
+        self['toString'] = :undefined
+        self['length'] = arguments.length
+      end
+
+      def js_call(scope_chain, *params)
+        arguments.each_with_index { |name, i|
+          scope_chain[name.value] = params[i] || RKelly::Runtime::UNDEFINED
+        }
+        function_visitor  = RKelly::Visitors::FunctionVisitor.new(scope_chain)
+        eval_visitor      = RKelly::Visitors::EvaluationVisitor.new(scope_chain)
+        body.accept(function_visitor) if body
+        body.accept(eval_visitor) if body
+      end
+    end
+  end
+end

data/lib/rkelly/js/function_prototype.rb

@@ -0,0 +1,15 @@
+module RKelly
+  module JS
+    # This is the object protytpe
+    # ECMA-262 15.2.4
+    class FunctionPrototype < ObjectPrototype
+      def initialize(function)
+        super()
+        self['Class'] = 'Object'
+        self['constructor'] = function
+        self['arguments'].value = nil
+      end
+    end
+  end
+end
+

data/lib/rkelly/js/global_object.rb

@@ -0,0 +1,52 @@
+module RKelly
+  module JS
+    class GlobalObject < Base
+      def initialize
+        super
+        self['class']     = 'GlobalObject'
+        self['NaN']       = JS::NaN.new
+        self['NaN'].attributes << :dont_enum
+        self['NaN'].attributes << :dont_delete
+
+        self['Infinity']  = 1.0/0.0
+        self['Infinity'].attributes << :dont_enum
+        self['Infinity'].attributes << :dont_delete
+
+        self['undefined'] = :undefined
+        self['undefined'].attributes << :dont_enum
+        self['undefined'].attributes << :dont_delete
+
+        self['Array'] = JS::Array.new
+        self['Array'].function = lambda { |*args|
+          JS::Array.create(*args)
+        }
+
+        self['Object'] = JS::Object.new
+        self['Object'].function = lambda { |*args|
+          JS::Object.create(*args)
+        }
+
+        self['Math'] = JS::Math.new
+
+        self['Function'] = :undefined
+        self['Function'].function = lambda { |*args|
+          JS::Function.create(*args)
+        }
+
+        self['Number'] = JS::Number.new
+        self['Number'].function = lambda { |*args|
+          JS::Number.create(*args)
+        }
+
+        self['Boolean'] = JS::Boolean.new
+        self['Boolean'].function = lambda { |*args|
+          JS::Boolean.create(*args)
+        }
+        self['String'] = JS::String.new('')
+        self['String'].function = lambda { |*args|
+          JS::String.create(*args)
+        }
+      end
+    end
+  end
+end

data/lib/rkelly/js/math.rb

@@ -0,0 +1,10 @@
+module RKelly
+  module JS
+    class Math < Base
+      def initialize
+        super
+        self['PI'] = ::Math::PI
+      end
+    end
+  end
+end

data/lib/rkelly/js/nan.rb

@@ -0,0 +1,18 @@
+module RKelly
+  module JS
+    # Class to represent Not A Number
+    # In Ruby NaN != NaN, but in JS, NaN == NaN
+    class NaN < ::Numeric
+      def ==(other)
+        other.respond_to?(:nan?) && other.nan?
+      end
+
+      def nan?
+        true
+      end
+
+      def +(o); self; end
+      def -(o); self; end
+    end
+  end
+end

data/lib/rkelly/js/number.rb

@@ -0,0 +1,22 @@
+module RKelly
+  module JS
+    class Number < Base
+      class << self
+        def create(*args)
+          self.new(args.first || 0)
+        end
+      end
+
+      def initialize(value = 0)
+        super()
+        self['MAX_VALUE'] = 1.797693134862315e+308
+        self['MIN_VALUE'] = 1.0e-306
+        self['NaN']       = JS::NaN.new
+        self['POSITIVE_INFINITY'] = 1.0/0.0
+        self['NEGATIVE_INFINITY'] = -1.0/0.0
+        self['valueOf'] = lambda { value }
+        self['toString'] = value.to_s
+      end
+    end
+  end
+end

data/lib/rkelly/js/object.rb

@@ -0,0 +1,30 @@
+module RKelly
+  module JS
+    class Object < Base
+      attr_reader :value
+      class << self
+        def create(*args)
+          arg = args.first
+          return self.new if arg.nil? || arg == :undefined
+          case arg
+          when true, false
+            JS::Boolean.new(arg)
+          when Numeric
+            JS::Number.new(arg)
+          when ::String
+            JS::String.new(arg)
+          else
+            self.new(arg)
+          end
+        end
+      end
+
+      def initialize(*args)
+        super()
+        self['prototype'] = JS::ObjectPrototype.new
+        self['valueOf'] = lambda { args.first || self }
+        self['valueOf'].function = lambda { args.first || self }
+      end
+    end
+  end
+end

data/lib/rkelly/js/object_prototype.rb

@@ -0,0 +1,14 @@
+module RKelly
+  module JS
+    # This is the object protytpe
+    # ECMA-262 15.2.4
+    class ObjectPrototype < Base
+      def initialize
+        super
+        self['toString'].function = unbound_method(:toString) do
+          "[object #{self['Class'].value}]"
+        end
+      end
+    end
+  end
+end

data/lib/rkelly/js/property.rb

@@ -0,0 +1,20 @@
+module RKelly
+  module JS
+    class Property
+      attr_accessor :name, :value, :attributes, :function, :binder
+      def initialize(name, value, binder = nil, function = nil, attributes = [])
+        @name = name
+        @value = value
+        @binder = binder
+        @function = function
+        @attributes = attributes
+      end
+
+      [:read_only, :dont_enum, :dont_delete, :internal].each do |property|
+        define_method(:"#{property}?") do
+          self.attributes.include?(property)
+        end
+      end
+    end
+  end
+end

data/lib/rkelly/js/scope.rb

@@ -0,0 +1,6 @@
+module RKelly
+  module JS
+    class Scope < Base
+    end
+  end
+end

data/lib/rkelly/js/string.rb

@@ -0,0 +1,21 @@
+module RKelly
+  module JS
+    class String < Base
+      class << self
+        def create(*args)
+          self.new(args.first || '')
+        end
+      end
+
+      def initialize(value)
+        super()
+        self['valueOf'] = value
+        self['valueOf'].function = lambda { value }
+        self['toString'] = value
+        self['fromCharCode'] = unbound_method(:fromCharCode) { |*args|
+          args.map { |x| x.chr }.join
+        }
+      end
+    end
+  end
+end

data/lib/rkelly/lexeme.rb

@@ -0,0 +1,18 @@
+require 'rkelly/token'
+
+module RKelly
+  class Lexeme
+    attr_reader :name, :pattern
+    def initialize(name, pattern, &block)
+      @name       = name
+      @pattern    = pattern
+      @block      = block
+    end
+
+    def match(string)
+      match = pattern.match(string)
+      return Token.new(name, match.to_s, &@block) if match
+      match
+    end
+  end
+end

data/lib/rkelly/nodes.rb

@@ -0,0 +1,5 @@
+require 'rkelly/nodes/node'
+require 'rkelly/nodes/function_expr_node'
+Dir[File.join(File.dirname(__FILE__), "nodes/*_node.rb")].each do |file|
+  require file[/rkelly\/nodes\/.*/]
+end

data/lib/rkelly/nodes/binary_node.rb

@@ -0,0 +1,18 @@
+module RKelly
+  module Nodes
+    class BinaryNode < Node
+      attr_reader :left
+      def initialize(left, right)
+        super(right)
+        @left = left
+      end
+    end
+
+    %w[Subtract LessOrEqual GreaterOrEqual Add Multiply While NotEqual
+       DoWhile Switch LogicalAnd UnsignedRightShift Modulus While
+       NotStrictEqual Less With In Greater BitOr StrictEqual LogicalOr
+       BitXOr LeftShift Equal BitAnd InstanceOf Divide RightShift].each do |node|
+      eval "class #{node}Node < BinaryNode; end"
+    end
+  end
+end