opal-wedge 0.9.0.dev

data/lib/opal/nodes/defined.rb

@@ -0,0 +1,113 @@
+require 'opal/nodes/base'
+
+module Opal
+  module Nodes
+    class DefinedNode < Base
+      handle :defined
+
+      children :value
+
+      def compile
+        type = value.type
+
+        case type
+        when :self, :nil, :false, :true
+          push type.to_s.inspect
+        when :lasgn, :iasgn, :gasgn, :cvdecl, :masgn, :op_asgn_or, :op_asgn_and
+          push "'assignment'"
+        when :paren, :not
+          push expr(s(:defined, value[1]))
+        when :lvar
+          push "'local-variable'"
+        else
+          if respond_to? "compile_#{type}"
+            __send__ "compile_#{type}"
+          else
+            push "'expression'"
+          end
+        end
+      end
+
+      def compile_call
+        mid = mid_to_jsid value[2].to_s
+        recv = value[1] ? expr(value[1]) : 'self'
+
+        with_temp do |tmp|
+          push "(((#{tmp} = ", recv, "#{mid}) && !#{tmp}.$$stub) || ", recv
+          push "['$respond_to_missing?']('#{value[2].to_s}') ? 'method' : nil)"
+        end
+      end
+
+      def compile_ivar
+        # FIXME: this check should be positive for ivars initialized as nil too.
+        # Since currently all known ivars are inialized to nil in the constructor
+        # we can't tell if it was the user that put nil and made the ivar #defined?
+        # or not.
+        with_temp do |tmp|
+          name = value[1].to_s[1..-1]
+
+          push "((#{tmp} = self['#{name}'], #{tmp} != null && #{tmp} !== nil) ? "
+          push "'instance-variable' : nil)"
+        end
+      end
+
+      def compile_super
+        push expr(s(:defined_super, value))
+      end
+
+      def compile_yield
+        push compiler.handle_block_given_call(@sexp)
+        wrap '((',  ') != null ? "yield" : nil)'
+      end
+
+      def compile_xstr
+        push expr(value)
+        wrap '(typeof(', ') !== "undefined")'
+      end
+      alias compile_dxstr compile_xstr
+
+      def compile_const
+        push "($scope.#{value[1]} != null)"
+      end
+
+      def compile_colon2
+        # TODO: avoid try/catch, probably a #process_colon2 alternative that
+        # does not raise errors is needed
+        push "(function(){ try { return (("
+        push expr(value)
+        push ") != null ? 'constant' : nil); } catch (err) { if (err.$$class"
+        push " === Opal.NameError) { return nil; } else { throw(err); }}; })()"
+      end
+
+      def compile_colon3
+        push "(Opal.Object.$$scope.#{value[1]} == null ? nil : 'constant')"
+      end
+
+      def compile_cvar
+        push "(Opal.cvars['#{value[1]}'] != null ? 'class variable' : nil)"
+      end
+
+      def compile_gvar
+        name = value[1].to_s[1..-1]
+
+        if %w[~ !].include? name
+          push "'global-variable'"
+        elsif %w[` ' + &].include? name
+          with_temp do |tmp|
+            push "((#{tmp} = $gvars['~'], #{tmp} != null && #{tmp} !== nil) ? "
+            push "'global-variable' : nil)"
+          end
+        else
+          push "($gvars[#{name.inspect}] != null ? 'global-variable' : nil)"
+        end
+      end
+
+      def compile_nth_ref
+        with_temp do |tmp|
+          push "((#{tmp} = $gvars['~'], #{tmp} != null && #{tmp} != nil) ? "
+          push "'global-variable' : nil)"
+        end
+      end
+    end
+  end
+end

data/lib/opal/nodes/definitions.rb

@@ -0,0 +1,168 @@
+require 'opal/nodes/base'
+
+module Opal
+  module Nodes
+
+    class SvalueNode < Base
+      handle :svalue
+
+      children :value
+
+      def compile
+        push process(value, @level)
+      end
+    end
+
+    class UndefNode < Base
+      handle :undef
+
+      children :mid
+
+      # FIXME: we should be setting method to a stub method here
+      def compile
+        push "delete #{scope.proto}#{mid_to_jsid mid[1].to_s}"
+      end
+    end
+
+    class AliasNode < Base
+      handle :alias
+
+      children :new_name, :old_name
+
+      def new_mid
+        mid_to_jsid new_name[1].to_s
+      end
+
+      def old_mid
+        mid_to_jsid old_name[1].to_s
+      end
+
+      def compile
+        if scope.class? or scope.module?
+          scope.methods << "$#{new_name[1]}"
+          push "Opal.defn(self, '$#{new_name[1]}', #{scope.proto}#{old_mid})"
+        else
+          push "self.$$proto#{new_mid} = self.$$proto#{old_mid}"
+        end
+      end
+    end
+
+    class BeginNode < Base
+      handle :begin
+
+      children :body
+
+      def compile
+        if !stmt? and body.type == :block
+          push stmt(compiler.returns(body))
+          wrap '(function() {', '})()'
+        else
+          push process(body, @level)
+        end
+      end
+    end
+
+    class ParenNode < Base
+      handle :paren
+
+      children :body
+
+      def compile
+        if body.type == :block
+          body.children.each_with_index do |child, idx|
+            push ', ' unless idx == 0
+            push expr(child)
+          end
+
+          wrap '(', ')'
+        else
+          push process(body, @level)
+          wrap '(', ')' unless stmt?
+        end
+      end
+    end
+
+    class BlockNode < Base
+      handle :block
+
+      def compile
+        return push "nil" if children.empty?
+
+        children.each_with_index do |child, idx|
+          push stmt_join unless idx == 0
+
+          if yasgn = find_inline_yield(child)
+            push compiler.process(yasgn, @level)
+            push ";"
+          end
+
+          push compiler.process(child, @level)
+          push ";" if child_is_expr?(child)
+        end
+      end
+
+      def stmt_join
+        scope.class_scope? ? "\n\n#{current_indent}" : "\n#{current_indent}"
+      end
+
+      def child_is_expr?(child)
+        raw_expression?(child) and [:stmt, :stmt_closure].include?(@level)
+      end
+
+      def raw_expression?(child)
+        ![:xstr, :dxstr].include?(child.type)
+      end
+
+      # When a block sexp gets generated, any inline yields (i.e. yield
+      # statements that are not direct members of the block) need to be
+      # generated as a top level member. This is because if a yield
+      # is returned by a break statement, then the method must return.
+      #
+      # As inline expressions in javascript cannot return, the block
+      # must be rewritten.
+      #
+      # For example, a yield inside an array:
+      #
+      #     [1, 2, 3, yield(4)]
+      #
+      # Must be rewitten into:
+      #
+      #     tmp = yield 4
+      #     [1, 2, 3, tmp]
+      #
+      # This rewriting happens on sexps directly.
+      #
+      # @param [Sexp] stmt sexps to (maybe) rewrite
+      # @return [Sexp]
+      def find_inline_yield(stmt)
+        found = nil
+        case stmt.first
+        when :js_return
+          if found = find_inline_yield(stmt[1])
+            found = found[2]
+          end
+        when :array
+          stmt[1..-1].each_with_index do |el, idx|
+            if el.first == :yield
+              found = el
+              stmt[idx+1] = s(:js_tmp, '$yielded')
+            end
+          end
+        when :call
+          arglist = stmt[3]
+          arglist[1..-1].each_with_index do |el, idx|
+            if el.first == :yield
+              found = el
+              arglist[idx+1] = s(:js_tmp, '$yielded')
+            end
+          end
+        end
+
+        if found
+          scope.add_temp '$yielded' unless scope.has_temp? '$yielded'
+          s(:yasgn, '$yielded', found)
+        end
+      end
+    end
+  end
+end

data/lib/opal/nodes/for.rb

@@ -0,0 +1,48 @@
+require 'opal/nodes/base'
+
+module Opal
+  module Nodes
+    class ForNode < Base
+      handle :for
+
+      children :value, :args_sexp, :body_sexp
+
+      def compile
+        with_temp do |loop_var|
+          if args_sexp.type == :array
+            assign = s(:masgn, args_sexp)
+            assign << s(:to_ary, s(:js_tmp, loop_var))
+          else
+            assign = args_sexp << s(:js_tmp, loop_var)
+          end
+
+          if body_sexp
+            if body_sexp.first == :block
+              body_sexp.insert 1, assign
+              assign = body_sexp
+            else
+              assign = s(:block, assign, body_sexp)
+            end
+          end
+
+          assign.children.each do |sexp|
+            case sexp[0]
+            when :lasgn
+              add_local sexp[1]
+            when :masgn
+              if sexp[1][0] == :array
+                sexp[1][1].each do |sexp|
+                  add_local sexp[1] if sexp[0] == :lasgn
+                end
+              end
+            end
+          end
+
+          iter = s(:iter, s(:lasgn, loop_var), assign)
+          sexp = s(:call, value, :each, s(:arglist), iter)
+          push expr(sexp)
+        end
+      end
+    end
+  end
+end

data/lib/opal/nodes/hash.rb

@@ -0,0 +1,67 @@
+require 'opal/nodes/base'
+
+module Opal
+  module Nodes
+    class HashNode < Base
+      handle :hash
+
+      def keys_and_values
+        keys, values = [], []
+
+        children.each_with_index do |obj, idx|
+          if idx.even?
+            keys << obj
+          else
+            values << obj
+          end
+        end
+
+        [keys, values]
+      end
+
+      def simple_keys?(keys)
+        keys.all? { |key| [:sym, :str].include? key.type }
+      end
+
+      def compile
+        keys, values = keys_and_values
+
+        if simple_keys? keys
+          compile_hash2 keys, values
+        else
+          compile_hash
+        end
+      end
+
+      def compile_hash
+        helper :hash
+
+        children.each_with_index do |child, idx|
+          push ', ' unless idx == 0
+          push expr(child)
+        end
+
+        wrap '$hash(', ')'
+      end
+
+      def compile_hash2(keys, values)
+        hash_obj, hash_keys = {}, []
+        helper :hash2
+
+        keys.size.times do |idx|
+          key = keys[idx][1].to_s.inspect
+          hash_keys << key unless hash_obj.include? key
+          hash_obj[key] = expr(values[idx])
+        end
+
+        hash_keys.each_with_index do |key, idx|
+          push ', ' unless idx == 0
+          push "#{key}: "
+          push hash_obj[key]
+        end
+
+        wrap "$hash2([#{hash_keys.join ', '}], {", "})"
+      end
+    end
+  end
+end

data/lib/opal/nodes/helpers.rb

@@ -0,0 +1,116 @@
+require 'opal/regexp_anchors'
+
+module Opal
+  module Nodes
+    module Helpers
+
+      # Reserved javascript keywords - we cannot create variables with the
+      # same name (ref: http://stackoverflow.com/a/9337272/601782)
+      ES51_RESERVED_WORD = /#{REGEXP_START}(?:do|if|in|for|let|new|try|var|case|else|enum|eval|false|null|this|true|void|with|break|catch|class|const|super|throw|while|yield|delete|export|import|public|return|static|switch|typeof|default|extends|finally|package|private|continue|debugger|function|arguments|interface|protected|implements|instanceof)#{REGEXP_END}/
+
+      # ES3 reserved words that aren’t ES5.1 reserved words
+      ES3_RESERVED_WORD_EXCLUSIVE = /#{REGEXP_START}(?:int|byte|char|goto|long|final|float|short|double|native|throws|boolean|abstract|volatile|transient|synchronized)#{REGEXP_END}/
+
+      # Immutable properties of the global object
+      IMMUTABLE_PROPS = /#{REGEXP_START}(?:NaN|Infinity|undefined)#{REGEXP_END}/
+
+      # Doesn't take in account utf8
+      BASIC_IDENTIFIER_RULES = /#{REGEXP_START}[$_a-z][$_a-z\d]*#{REGEXP_END}/i
+
+
+      def property(name)
+        valid_name?(name) ? ".#{name}" : "[#{name.inspect}]"
+      end
+
+      def valid_name?(name)
+        BASIC_IDENTIFIER_RULES =~ name and not(
+          ES51_RESERVED_WORD          =~ name or
+          ES3_RESERVED_WORD_EXCLUSIVE =~ name or
+          IMMUTABLE_PROPS             =~ name
+        )
+      end
+
+      def variable(name)
+        valid_name?(name.to_s) ? name : "#{name}$"
+      end
+
+      # Converts a ruby lvar/arg name to a js identifier. Not all ruby names
+      # are valid in javascript. A $ suffix is added to non-valid names.
+      # varibales
+      def lvar_to_js(var)
+        var = "#{var}$" unless valid_name? var.to_s
+        var.to_sym
+      end
+
+      # Converts a ruby method name into its javascript equivalent for
+      # a method/function call. All ruby method names get prefixed with
+      # a '$', and if the name is a valid javascript identifier, it will
+      # have a '.' prefix (for dot-calling), otherwise it will be
+      # wrapped in brackets to use reference notation calling.
+      def mid_to_jsid(mid)
+        if /\=|\+|\-|\*|\/|\!|\?|<|\>|\&|\||\^|\%|\~|\[/ =~ mid.to_s
+          "['$#{mid}']"
+        else
+          '.$' + mid
+        end
+      end
+
+      def indent(&block)
+        compiler.indent(&block)
+      end
+
+      def current_indent
+        compiler.parser_indent
+      end
+
+      def line(*strs)
+        push "\n#{current_indent}"
+        push(*strs)
+      end
+
+      def empty_line
+        push "\n"
+      end
+
+      def js_truthy(sexp)
+        if optimize = js_truthy_optimize(sexp)
+          return optimize
+        end
+
+        with_temp do |tmp|
+          [fragment("((#{tmp} = "), expr(sexp), fragment(") !== nil && (!#{tmp}.$$is_boolean || #{tmp} == true))")]
+        end
+      end
+
+      def js_falsy(sexp)
+        if sexp.type == :call
+          mid = sexp[2]
+          if mid == :block_given?
+            scope.uses_block!
+            return "#{scope.block_name} === nil"
+          end
+        end
+
+        with_temp do |tmp|
+          [fragment("((#{tmp} = "), expr(sexp), fragment(") === nil || (#{tmp}.$$is_boolean && #{tmp} == false))")]
+        end
+      end
+
+      def js_truthy_optimize(sexp)
+        if sexp.type == :call
+          mid = sexp[2]
+
+          if mid == :block_given?
+            expr(sexp)
+          elsif Compiler::COMPARE.include? mid.to_s
+            expr(sexp)
+          elsif mid == :"=="
+            expr(sexp)
+          end
+        elsif [:lvar, :self].include? sexp.type
+          [expr(sexp.dup), fragment(" !== false && "), expr(sexp.dup), fragment(" !== nil")]
+        end
+      end
+    end
+  end
+end