opal 1.4.1 → 1.5.0.rc1

data/spec/lib/rewriters/explicit_writer_return_spec.rb

@@ -1,186 +0,0 @@
-require 'lib/spec_helper'
-
-RSpec.describe Opal::Rewriters::ExplicitWriterReturn do
-  def s(type, *children)
-    ::Opal::AST::Node.new(type, children)
-  end
-
-  let(:rewriter) { Opal::Rewriters::ExplicitWriterReturn.new }
-  let(:processed) { rewriter.process(input) }
-
-  def expect_rewritten(sexp)
-    processed = rewriter.process(sexp)
-    expect(processed)
-  end
-
-  def expect_no_rewriting_for(sexp)
-    expect_rewritten(sexp).to eq(sexp)
-  end
-
-  let(:receiver) do
-    # self.a
-    s(:send, nil, :a)
-  end
-
-  let(:single_argument) do
-    # self.c
-    s(:send, nil, :c)
-  end
-
-  let(:multiple_arguments) do
-    # [self.d, self.e]
-    s(:array,
-      s(:send, nil, :d),
-      s(:send, nil, :e)
-    )
-  end
-
-  let(:constant_returner) do
-    # $writer[$writer.length - 1]
-    s(:jsattr,
-      s(:lvar, "$writer"),
-      s(:send, s(:jsattr, s(:lvar, "$writer"), s(:str, "length")), :-, s(:int, 1))
-    )
-  end
-
-  shared_examples 'always returns a temporary argument' do
-    it 'returns a temporary argument' do
-      expect(processed.children[2]).to eq(constant_returner)
-    end
-  end
-
-  describe 'rewriting a.b = c' do
-    let(:input) do
-      s(:send, receiver, :b=, single_argument)
-    end
-
-    it 'generates a temporary argument for a method argument' do
-      expect(processed.children[0]).to eq(
-        s(:lvasgn, "$writer", s(:array, single_argument))
-      )
-    end
-
-    it 'calls receiver with this temporary argument as a splat' do
-      expect(processed.children[1]).to eq(
-        s(:send, receiver, :b=,
-          s(:splat, s(:lvar, "$writer"))
-        )
-      )
-    end
-
-    include_examples 'always returns a temporary argument'
-  end
-
-  describe 'rewriting a.b = c, d' do
-    let(:input) do
-      s(:send, receiver, :b=, multiple_arguments)
-    end
-
-    it 'generates a temporary argument for array of method arguments' do
-      expect(processed.children[0]).to eq(
-        s(:lvasgn, "$writer", s(:array, multiple_arguments))
-      )
-    end
-
-    it 'calls receiver with this temporary argument as a splat' do
-      expect(processed.children[1]).to eq(
-        s(:send, receiver, :b=,
-          s(:splat, s(:lvar, "$writer"))
-        )
-      )
-    end
-
-    include_examples 'always returns a temporary argument'
-  end
-
-  describe "[]= method" do
-    let(:idx) { s(:send, nil, :b) }
-
-    describe 'rewriting a[b] = c' do
-      let(:input) do
-        s(:send, receiver, :[]=, idx, single_argument)
-      end
-
-      it 'generates a temporary argument for all passed method arguments' do
-        expect(processed.children[0]).to eq(
-          s(:lvasgn, "$writer", s(:array, idx, single_argument))
-        )
-      end
-
-      it 'calls receiver with this temporary argument as a splat' do
-        expect(processed.children[1]).to eq(
-          s(:send, receiver, :[]=,
-            s(:splat, s(:lvar, "$writer"))
-          )
-        )
-      end
-
-      include_examples 'always returns a temporary argument'
-    end
-
-    describe 'rewriting a[b] = c, d' do
-      let(:input) do
-        s(:send, receiver, :[]=, idx, multiple_arguments)
-      end
-
-      it 'generates a temporary argument for array of method arguments' do
-        expect(processed.children[0]).to eq(
-          s(:lvasgn, "$writer", s(:array, idx, multiple_arguments))
-        )
-      end
-
-      it 'calls receiver with this temporary argument as a splat' do
-        expect(processed.children[1]).to eq(
-          s(:send, receiver, :[]=,
-            s(:splat, s(:lvar, "$writer"))
-          )
-        )
-      end
-
-      include_examples 'always returns a temporary argument'
-    end
-  end
-
-  describe 'mass assignment' do
-    let(:input) do
-      # a, b = c, d
-      s(:masgn,
-        s(:mlhs,
-          s(:lvasgn, :a),
-          s(:lvasgn, :b)),
-        s(:array,
-          s(:send, nil, :c),
-          s(:send, nil, :d)))
-    end
-
-    it 'does not affect it' do
-      expect_no_rewriting_for(input)
-    end
-  end
-
-  describe '.JS. syntax' do
-    let(:input) do
-      # a.JS.b = c
-      s(:jscall,
-        s(:send, nil, :a), :b=,
-        s(:send, nil, :c))
-    end
-
-    it 'does not affect it' do
-      expect_no_rewriting_for(input)
-    end
-  end
-
-  describe '.JS[] syntax' do
-    let(:input) do
-      s(:jsattrasgn,
-        s(:send, nil, :a),
-        s(:sym, :b),
-        s(:send, nil, :c))
-    end
-
-    it 'does not affect it' do
-      expect_no_rewriting_for(input)
-    end
-  end
-end

data/stdlib/nodejs/irb.rb

@@ -1,43 +0,0 @@
-require 'native'
-
-NodeRepl = Native(`OpalNode.node_require('repl')`)
-
-def NodeRepl.start(options = {})
-  Native::Object.new(`#{@native}.start(#{options.to_n})`)
-end
-
-line = 1
-prompt_interrupted = false
-
-prompt = ->(context) {
-  tip = prompt_interrupted ? '*' : '>'
-  "irb(#{context}):#{line.to_s.rjust(3, '0')}#{tip} "
-}
-
-$repl = NodeRepl.start(
-  prompt: prompt.call(self),
-  useGlobal: true,
-  ignoreUndefined: true,
-  eval: ->(cmd, context, filename, callback) {
-    line += 1
-    cmd = cmd[1...-1].chomp
-    if cmd.empty?
-      prompt_interrupted = true
-      $repl.prompt = prompt.call(self)
-      callback.call('')
-      next
-    end
-    prompt_interrupted = false
-    $repl.prompt = prompt.call(self)
-    begin
-      result = `OpalNode.run(cmd, filename)`
-      result = nil if `#{result} == nil`
-      callback.call('=> ' + result.inspect)
-    rescue => e
-      callback.call(e.backtrace.join("\n"))
-    end
-  },
-)
-
-# Add a newline before exiting
-$repl.on :exit, -> { puts }