opal-wedge 0.9.0.dev

data/lib/opal/nodes/if.rb

@@ -0,0 +1,81 @@
+require 'opal/nodes/base'
+
+module Opal
+  module Nodes
+    class IfNode < Base
+      handle :if
+
+      children :test, :true_body, :false_body
+
+      RUBY_ENGINE_CHECK = [:call, [:const, :RUBY_ENGINE],
+                              :==, [:arglist, [:str, "opal"]]]
+
+      RUBY_ENGINE_CHECK_NOT = [:call, [:const, :RUBY_ENGINE],
+                              :!=, [:arglist, [:str, "opal"]]]
+
+      RUBY_PLATFORM_CHECK = [:call, [:const, :RUBY_PLATFORM],
+                              :==, [:arglist, [:str, "opal"]]]
+
+      RUBY_PLATFORM_CHECK_NOT = [:call, [:const, :RUBY_PLATFORM],
+                              :!=, [:arglist, [:str, "opal"]]]
+
+      def compile
+        truthy, falsy = self.truthy, self.falsy
+
+        if skip_check_present?
+          falsy = nil
+        end
+
+        if skip_check_present_not?
+          truthy = nil
+        end
+
+        push "if (", js_truthy(test), ") {"
+
+        # skip if-body if no truthy sexp
+        indent { line stmt(truthy) } if truthy
+
+        if falsy
+          if falsy.type == :if
+            line "} else ", stmt(falsy)
+          else
+            indent do
+              line "} else {"
+              line stmt(falsy)
+            end
+
+            line "}"
+          end
+        else
+          push "}"
+        end
+
+        wrap "(function() {", "; return nil; })()" if needs_wrapper?
+      end
+
+      # pre-processing only effects falsy blocks. If engine is
+      # opal, then falsy block gets generated as normal. Unless
+      # engine is opal then that code gets generated as the
+      # falsy block
+      def skip_check_present?
+        test == RUBY_ENGINE_CHECK or test == RUBY_PLATFORM_CHECK
+      end
+
+      def skip_check_present_not?
+        test == RUBY_ENGINE_CHECK_NOT or test == RUBY_PLATFORM_CHECK_NOT
+      end
+
+      def truthy
+        needs_wrapper? ? compiler.returns(true_body || s(:nil)) : true_body
+      end
+
+      def falsy
+        needs_wrapper? ? compiler.returns(false_body || s(:nil)) : false_body
+      end
+
+      def needs_wrapper?
+        expr? or recv?
+      end
+    end
+  end
+end

data/lib/opal/nodes/iter.rb

@@ -0,0 +1,136 @@
+require 'opal/nodes/scope'
+
+module Opal
+  module Nodes
+    class IterNode < ScopeNode
+      handle :iter
+
+      children :args_sexp, :body_sexp
+
+      def compile
+        opt_args  = extract_opt_args
+        block_arg = extract_block_arg
+
+        # find any splat args
+        if args.last.is_a?(Sexp) and args.last.type == :splat
+          splat = args.last[1][1]
+          args.pop
+          len = args.length
+        end
+
+        params = args_to_params(args[1..-1])
+        params << splat if splat
+
+        to_vars = identity = body_code = nil
+
+        in_scope do
+          identity = scope.identify!
+          add_temp "self = #{identity}.$$s || this"
+
+          compile_args(args[1..-1], opt_args, params)
+
+          if splat
+            scope.add_arg splat
+            push "#{splat} = $slice.call(arguments, #{len - 1});"
+          end
+
+          if block_arg
+            scope.block_name = block_arg
+            scope.add_temp block_arg
+            scope_name = scope.identify!
+
+            line "#{block_arg} = #{scope_name}.$$p || nil, #{scope_name}.$$p = null;"
+          end
+
+          body_code = stmt(body)
+          to_vars = scope.to_vars
+        end
+
+        line body_code
+
+        unshift to_vars
+
+        unshift "(#{identity} = function(#{params.join ', '}){"
+        push "}, #{identity}.$$s = self, #{identity})"
+      end
+
+      def compile_args(args, opt_args, params)
+        args.each_with_index do |arg, idx|
+          if arg.type == :lasgn
+            arg = variable(arg[1])
+
+            if opt_args and current_opt = opt_args.find { |s| s[1] == arg.to_sym }
+              push "if (#{arg} == null) #{arg} = ", expr(current_opt[2]), ";"
+            else
+              push "if (#{arg} == null) #{arg} = nil;"
+            end
+          elsif arg.type == :array
+            vars = {}
+            arg[1..-1].each_with_index do |_arg, _idx|
+              _arg = variable(_arg[1])
+              unless vars.has_key?(_arg) || params.include?(_arg)
+                vars[_arg] = "#{params[idx]}[#{_idx}]"
+              end
+            end
+            push "var #{ vars.map{|k, v| "#{k} = #{v}"}.join(', ') };"
+          else
+            raise "Bad block arg type"
+          end
+        end
+      end
+
+      # opt args are last (if present) and are a s(:block)
+      def extract_opt_args
+        if args.last.is_a?(Sexp) and args.last.type == :block
+          opt_args = args.pop
+          opt_args.shift
+          opt_args
+        end
+      end
+
+      # does this iter define a block_pass
+      def extract_block_arg
+        if args.last.is_a?(Sexp) and args.last.type == :block_pass
+          block_arg = args.pop
+          block_arg = block_arg[1][1].to_sym
+        end
+      end
+
+      def args
+        if Fixnum === args_sexp or args_sexp.nil?
+          s(:array)
+        elsif args_sexp.type == :lasgn
+          s(:array, args_sexp)
+        else
+          args_sexp[1]
+        end
+      end
+
+      def body
+        compiler.returns(body_sexp || s(:nil))
+      end
+
+      # Maps block args into array of jsid. Adds $ suffix to invalid js
+      # identifiers.
+      #
+      # s(:args, parts...) => ["a", "b", "break$"]
+      def args_to_params(sexp)
+        result = []
+        sexp.each do |arg|
+          if arg[0] == :lasgn
+            ref = variable(arg[1])
+            next if ref == :_ && result.include?(ref)
+            self.add_arg ref
+            result << ref
+          elsif arg[0] == :array
+            result << scope.next_temp
+          else
+            raise "Bad js_block_arg: #{arg[0]}"
+          end
+        end
+
+        result
+      end
+    end
+  end
+end

data/lib/opal/nodes/literal.rb

@@ -0,0 +1,247 @@
+require 'opal/nodes/base'
+
+module Opal
+  module Nodes
+    class ValueNode < Base
+      handle :true, :false, :self, :nil
+
+      def compile
+        push type.to_s
+      end
+    end
+
+    class NumericNode < Base
+      handle :int, :float
+
+      children :value
+
+      def compile
+        push value.to_s
+        wrap '(', ')' if recv?
+      end
+    end
+
+    class StringNode < Base
+      handle :str
+
+      children :value
+
+      ESCAPE_CHARS = {
+        ?a => '\\u0007',
+        ?e => '\\u001b'
+      }
+
+      ESCAPE_REGEX = /(\\+)([#{ ESCAPE_CHARS.keys.join('') }])/
+
+      def translate_escape_chars(inspect_string)
+        inspect_string.gsub(ESCAPE_REGEX) do |original|
+          if $1.length.even?
+            original
+          else
+            $1.chop + ESCAPE_CHARS[$2]
+          end
+        end
+      end
+
+      def compile
+        push translate_escape_chars(value.inspect)
+      end
+    end
+
+    class SymbolNode < Base
+      handle :sym
+
+      children :value
+
+      def compile
+        push value.to_s.inspect
+      end
+    end
+
+    class RegexpNode < Base
+      handle :regexp
+
+      children :value, :flags
+
+      def compile
+        case value
+        when ''
+          push('/(?:)/')
+        when %r{\?<\w+\>}
+          message = "named captures are not supported in javascript: #{value.inspect}"
+          push "self.$raise(new SyntaxError('#{message}'))"
+        else
+          push "#{Regexp.new(value).inspect}#{flags}"
+        end
+      end
+    end
+
+    module XStringLineSplitter
+      def compile_split_lines(value, sexp)
+        idx = 0
+        value.each_line do |line|
+          if idx == 0
+            push line
+          else
+            line_sexp = s()
+            line_sexp.source = [sexp.line + idx, 0]
+            frag = Fragment.new(line, line_sexp)
+            push frag
+          end
+
+          idx += 1
+        end
+      end
+    end
+
+    class XStringNode < Base
+      include XStringLineSplitter
+
+      handle :xstr
+
+      children :value
+
+      def needs_semicolon?
+        stmt? and !value.to_s.include?(';')
+      end
+
+      def compile
+        compile_split_lines(value.to_s, @sexp)
+
+        push ';' if needs_semicolon?
+
+        wrap '(', ')' if recv?
+      end
+
+      def start_line
+        @sexp.line
+      end
+    end
+
+    class DynamicStringNode < Base
+      handle :dstr
+
+      def compile
+        children.each_with_index do |part, idx|
+          push " + " unless idx == 0
+
+          if String === part
+            push part.inspect
+          elsif part.type == :evstr
+            push "("
+            push expr(part[1])
+            push ")"
+          elsif part.type == :str
+            push part[1].inspect
+          elsif part.type == :dstr
+            push "("
+            push expr(part)
+            push ")"
+          else
+            raise "Bad dstr part #{part.inspect}"
+          end
+
+          wrap '(', ')' if recv?
+        end
+      end
+    end
+
+    class DynamicSymbolNode < Base
+      handle :dsym
+
+      def compile
+        children.each_with_index do |part, idx|
+          push " + " unless idx == 0
+
+          if String === part
+            push part.inspect
+          elsif part.type == :evstr
+            push expr(s(:call, part.last, :to_s, s(:arglist)))
+          elsif part.type == :str
+            push part.last.inspect
+          else
+            raise "Bad dsym part"
+          end
+        end
+
+        wrap '(', ')'
+      end
+    end
+
+    class DynamicXStringNode < Base
+      include XStringLineSplitter
+
+      handle :dxstr
+
+      def requires_semicolon(code)
+        stmt? and !code.include?(';')
+      end
+
+      def compile
+        needs_semicolon = false
+
+        children.each do |part|
+          if String === part
+            compile_split_lines(part.to_s, @sexp)
+
+            needs_semicolon = true if requires_semicolon(part.to_s)
+          elsif part.type == :evstr
+            push expr(part[1])
+          elsif part.type == :str
+            compile_split_lines(part.last.to_s, part)
+            needs_semicolon = true if requires_semicolon(part.last.to_s)
+          else
+            raise "Bad dxstr part"
+          end
+        end
+
+        push ';' if needs_semicolon
+        wrap '(', ')' if recv?
+      end
+    end
+
+    class DynamicRegexpNode < Base
+      handle :dregx
+
+      def compile
+        children.each_with_index do |part, idx|
+          push " + " unless idx == 0
+
+          if String === part
+            push part.inspect
+          elsif part.type == :str
+            push part[1].inspect
+          else
+            push expr(part[1])
+          end
+        end
+
+        wrap '(new RegExp(', '))'
+      end
+    end
+
+    class InclusiveRangeNode < Base
+      handle :irange
+
+      children :start, :finish
+
+      def compile
+        helper :range
+
+        push '$range(', expr(start), ', ', expr(finish), ', false)'
+      end
+    end
+
+    class ExclusiveRangeNode < Base
+      handle :erange
+
+      children :start, :finish
+
+      def compile
+        helper :range
+
+        push '$range(', expr(start), ', ', expr(finish), ', true)'
+      end
+    end
+  end
+end