opal 0.3.19 → 0.3.20

data/lib/opal/scope.rb

@@ -1,225 +1,236 @@
-module Opal; class Parser
-  class Scope
-    attr_reader :locals
-    attr_reader :temps
-    attr_accessor :parent
+module Opal
+  class Parser
+    class Scope
+      attr_reader :locals
+      attr_reader :temps
+      attr_accessor :parent
 
-    attr_accessor :name
+      attr_accessor :name
 
-    attr_accessor :block_name
+      attr_accessor :block_name
 
-    attr_reader :scope_name
-    attr_reader :ivars
+      attr_reader :scope_name
+      attr_reader :ivars
 
-    attr_accessor :donates_methods
+      attr_accessor :donates_methods
 
-    attr_reader :type
+      attr_reader :type
 
-    attr_accessor :defines_defn
-    attr_accessor :defines_defs
+      attr_accessor :defines_defn
+      attr_accessor :defines_defs
 
-    # used by modules to know what methods to donate to includees
-    attr_reader :methods
+      attr_accessor :mid
 
-    def initialize(type, parser)
-      @parser  = parser
-      @type    = type
-      @locals  = []
-      @temps   = []
-      @args    = []
-      @ivars   = []
-      @parent  = nil
-      @queue   = []
-      @unique  = "a"
-      @while_stack = []
+      # true if singleton def, false otherwise
+      attr_accessor :defs
 
-      @defines_defs = false
-      @defines_defn = false
+      # used by modules to know what methods to donate to includees
+      attr_reader :methods
 
-      @methods = []
+      # singleton methods defined on classes/modules
+      attr_reader :smethods
 
-      @uses_block = false
-      @catches_break = false
-    end
+      def initialize(type, parser)
+        @parser  = parser
+        @type    = type
+        @locals  = []
+        @temps   = []
+        @args    = []
+        @ivars   = []
+        @parent  = nil
+        @queue   = []
+        @unique  = "a"
+        @while_stack = []
 
-    # Returns true if this scope is a class/module body scope
-    def class_scope?
-      @type == :class or @type == :module
-    end
+        @defines_defs = false
+        @defines_defn = false
 
-    ##
-    # Vars to use inside each scope
-    def to_vars
-      vars = []
-
-      if @type == :class
-        vars << '__class = this'
-        vars << '__scope = this._scope'
-        vars << 'def = this._proto'
-      elsif @type == :module
-        vars << '__class = this'
-        vars << '__scope = this._scope'
-        vars << 'def = this._proto'
-      elsif @type == :sclass
-        vars << '__scope = this._scope'
-      elsif @type == :iter
-        vars << 'def = (this._isObject ? this._klass._proto : this._proto)' if @defines_defn
-      else
-        vars << 'def = (this._isObject ? this._klass._proto : this._proto)' if @defines_defn
-      end
-
-      locals.each { |l| vars << "#{l} = nil" }
-      temps.each { |t| vars << t }
-
-      iv = ivars.map do |ivar|
-       "if (this#{ivar} == null) this#{ivar} = nil;\n"
-      end
-
-      indent = @parser.parser_indent
-      res = vars.empty? ? '' : "var #{vars.join ', '}; "
-      ivars.empty? ? res : "#{res}\n#{indent}#{iv.join indent}"
-    end
+        @methods  = []
+        @smethods = []
 
-    # Generates code for this module to donate methods
-    def to_donate_methods
-      "#{@parser.parser_indent};__donate(this, [#{@methods.map { |m| m.inspect }.join ', '}]);"
-    end
+        @uses_block = false
 
-    def add_ivar ivar
-      @ivars << ivar unless @ivars.include? ivar
-    end
+        # used by classes to store all ivars used in direct def methods
+        @proto_ivars = []
+      end
 
-    def add_arg(arg)
-      @args << arg unless @args.include? arg
-    end
+      # Returns true if this scope is a class/module body scope
+      def class_scope?
+        @type == :class or @type == :module
+      end
 
-    def add_local(local)
-      return if has_local? local
+      def class?
+        @type == :class
+      end
 
-      @locals << local
-    end
+      def module?
+        @type == :module
+      end
 
-    def has_local?(local)
-      return true if @locals.include? local or @args.include? local
-      return @parent.has_local?(local) if @parent and @type == :iter
+      def top?
+        @type == :top
+      end
 
-      false
-    end
+      def iter?
+        @type == :iter
+      end
 
-    def add_temp(tmp)
-      @temps << tmp
-    end
+      # Is this a normal def method directly inside a class? This is
+      # used for optimizing ivars as we can set them to nil in the
+      # class body
+      def def_in_class?
+        @type == :def && @parent && @parent.class?
+      end
 
-    def new_temp
-      return @queue.pop unless @queue.empty?
+      def proto
+        "#{ @name }_prototype"
+      end
 
-      tmp = "__#{@unique}"
-      @unique = @unique.succ
-      @temps << tmp
-      tmp
-    end
+      ##
+      # Vars to use inside each scope
+      def to_vars
+        vars = locals.map { |l| "#{l} = nil" }
+        vars.push *temps
 
-    def queue_temp(name)
-      @queue << name
-    end
+        iv = ivars.map do |ivar|
+         "if (this#{ivar} == null) this#{ivar} = nil;\n"
+        end
 
-    def push_while
-      info = {}
-      @while_stack.push info
-      info
-    end
+        indent = @parser.parser_indent
+        res = vars.empty? ? '' : "var #{vars.join ', '};"
+        str = ivars.empty? ? res : "#{res}\n#{indent}#{iv.join indent}"
 
-    def pop_while
-      @while_stack.pop
-    end
+        if class? and !@proto_ivars.empty?
+          pvars = @proto_ivars.map { |i| "#{proto}#{i}"}.join(' = ')
+          "%s\n%s%s = nil;" % [str, indent, pvars]
+        else
+          str
+        end
+      end
 
-    def in_while?
-      !@while_stack.empty?
-    end
+      # Generates code for this module to donate methods
+      def to_donate_methods
+        out = ""
 
-    def uses_block!
-      if @type == :iter && @parent
-        @parent.uses_block!
-      else
-        @uses_block = true
-        identify!
+        unless @methods.empty?
+          out += "%s;#{@name}._donate([%s]);" %
+            [@parser.parser_indent, @methods.map(&:inspect).join(', ')]
+        end
+
+        unless @smethods.empty?
+          out += "%s;#{@name}._sdonate([%s]);" %
+            [@parser.parser_indent, @smethods.map(&:inspect).join(', ')]
+        end
+
+        out
       end
-    end
 
-    def identify!
-      @identity ||= @parser.unique_temp
-    end
+      def add_ivar(ivar)
+        if def_in_class?
+          @parent.add_proto_ivar ivar
+        else
+          @ivars << ivar unless @ivars.include? ivar
+        end
+      end
 
-    def identity
-      @identity
-    end
+      def add_proto_ivar(ivar)
+        @proto_ivars << ivar unless @proto_ivars.include? ivar
+      end
+
+      def add_arg(arg)
+        @args << arg unless @args.include? arg
+      end
+
+      def add_local(local)
+        return if has_local? local
+
+        @locals << local
+      end
+
+      def has_local?(local)
+        return true if @locals.include? local or @args.include? local
+        return @parent.has_local?(local) if @parent and @type == :iter
+
+        false
+      end
+
+      def add_temp(*tmps)
+        @temps.push *tmps
+      end
+
+      def new_temp
+        return @queue.pop unless @queue.empty?
+
+        tmp = "__#{@unique}"
+        @unique = @unique.succ
+        @temps << tmp
+        tmp
+      end
+
+      def queue_temp(name)
+        @queue << name
+      end
 
-    def get_super_chain
-      chain = []
-      scope = self
-      defn  = 'null'
-      mid   = 'null'
+      def push_while
+        info = {}
+        @while_stack.push info
+        info
+      end
 
-      while scope
-        if scope.type == :iter
-          chain << scope.identify!
-          scope = scope.parent if scope.parent
+      def pop_while
+        @while_stack.pop
+      end
 
-        elsif scope.type == :def
-          defn = scope.identify!
-          mid  = "'#{scope.mid}'"
-          break
+      def in_while?
+        !@while_stack.empty?
+      end
 
+      def uses_block!
+        if @type == :iter && @parent
+          @parent.uses_block!
         else
-          break
+          @uses_block = true
+          identify!
         end
       end
 
-      [chain, defn, mid]
-    end
+      def identify!
+        return @identity if @identity
 
-    def identify_def
-      if @type == :iter && @parent
-        identify!
-        @parent.identify_def
-      elsif @type == :def
-        identify!
-      end
-    end
+        @identity = @parser.unique_temp
+        @parent.add_temp @identity
 
-    def uses_block?
-      @uses_block
-    end
+        @identity
+      end
 
-    def catches_break!
-      if @type == :iter && @parent
-        @parent.catches_break!
-      else
-        @catches_break = true
+      def identity
+        @identity
       end
-    end
 
-    def catches_break?
-      @catches_break
-    end
+      def get_super_chain
+        chain, scope, defn, mid = [], self, 'null', 'null'
 
-    def mid=(mid)
-      @mid = mid
-    end
+        while scope
+          if scope.type == :iter
+            chain << scope.identify!
+            scope = scope.parent if scope.parent
+
+          elsif scope.type == :def
+            defn = scope.identify!
+            mid  = "'#{scope.mid}'"
+            break
+
+          else
+            break
+          end
+        end
+
+        [chain, defn, mid]
+      end
 
-    # Gets the method id (as a jsid) of the current scope, which is assumed
-    # to be a method (:def). If not, and this scope is a :iter, then the
-    # parent scope will be checked. As a fallback, nil is returned. This is
-    # used by super() to find out what method super() should be sent to.
-    def mid
-      if @type == :def
-        @mid
-      elsif @type == :iter && @parent
-        @parent.mid
-      else
-        nil
+      def uses_block?
+        @uses_block
       end
     end
   end
-
-end; end
+end

data/lib/opal/version.rb

@@ -1,3 +1,3 @@
 module Opal
-  VERSION = "0.3.19"
+  VERSION = "0.3.20"
 end

data/test/core/kernel/define_singleton_method_spec.rb

@@ -0,0 +1,21 @@
+class DefineMethodByProcScope
+  in_scope = true
+  method_proc = proc { in_scope }
+
+  define_singleton_method(:proc_test, &method_proc)
+end
+
+describe "Kernel#define_singleton_method" do
+  it "defines a new singleton method for objects" do
+    s = Object.new
+    s.define_singleton_method(:test) { "world!" }
+    s.test.should == "world!"
+    lambda {
+      Object.new.test
+    }.should raise_error(NoMethodError)
+  end
+
+  it "maintains the Proc's scope" do
+    DefineMethodByProcScope.proc_test.should == true
+  end
+end

data/test/core/time/at_spec.rb

@@ -0,0 +1,7 @@
+describe "Time#at" do
+  describe "passed Numeric" do
+    it "returns a Time object representing the given number of Integer seconds since 1970-01-01 00:00:00 UTC" do
+      Time.at(1184027924).should be_kind_of(Time)
+    end
+  end
+end

data/test/core/time/day_spec.rb

@@ -0,0 +1,5 @@
+describe "Time#day" do
+  it "returns the day of the month for a UTC Time" do
+    Time.new(1970, 1, 1).day.should == 1
+  end
+end