opal 0.0.1 → 0.1.0

data/opals/opal/spec/language/super_spec.rb

@@ -0,0 +1,26 @@
+# 
+# describe "The super keyword" do
+#   
+#   it "calls the method on the calling class" do
+#     Super::S1::A.new.foo([]).should == ["A#foo", "A#bar"]
+#     Super::S1::A.new.bar([]).should == ["A#bar"]
+#     Super::S1::B.new.foo([]).should == ["B#foo","A#foo","B#bar","A#bar"]
+#     Super::S1::B.new.bar([]).should == ["B#bar", "A#bar"]
+#   end
+#   
+#   it "searches the full inheritence chain" do
+#     Super::S2::B.new.foo([]).should == ["B#foo", "A#baz"]
+#     Super::S2::B.new.baz([]).should == ["A#baz"]
+#     Super::S2::C.new.foo([]).should == ["B#foo","C#baz","A#baz"]
+#     Super::S2::C.new.baz([]).should == ["C#baz","A#baz"]
+#   end
+#   
+#   it "searches class methods" do
+#     Super::S3::A.new.foo([]).should == ["A#foo"]
+#     Super::S3::A.foo([]).should == ["A::foo"]
+#     Super::S3::A.bar([]).should == ["A::bar","A::foo"]
+#     Super::S3::B.new.foo([]).should == ["A#foo"]
+#     Super::S3::B.foo([]).should == ["B::foo","A::foo"]
+#     Super::S3::B.bar([]).should == ["B::bar","A::bar","B::foo","A::foo"]
+#   end
+# end

data/opals/opal/spec/language/until_spec.rb

@@ -0,0 +1,157 @@
+
+describe "The until expression" do
+  it "runs while the expression is false" do
+    i = 0
+    until i > 9
+      i = i + 1
+    end
+    
+    i.should == 10
+  end
+  
+  it "optionally takes a 'do' after the expression" do
+    i = 0
+    until i > 9 do
+      i = i + 1
+    end
+    
+    i.should == 10
+  end
+  
+  it "allows body begin on the same line if do is used" do
+    i = 0
+    until i > 9 do i = i + 1
+    end
+    
+    i.should == 10
+  end
+  
+  it "executes code in containing variable scope" do
+    i = 0
+    until i == 1
+      a = 123
+      i = 1
+    end
+    
+    a.should == 123
+  end
+  
+  it "executes code in containing variable scope with 'do'" do
+    i = 0
+    until i == 1 do
+      a = 123
+      i = 1
+    end
+    
+    a.should == 123
+  end
+  
+  it "returns nil if ended when condition became true" do
+    i = 0
+    until i > 9
+      i = i + 1
+    end.should == nil
+  end
+  
+  it "evaluates the body if expression is empty" do
+    a = []
+    until ()
+      a << :body_evaluated
+      break
+    end
+    a.should == [:body_evaluated]
+  end
+  
+  it "stops running body if interrupted by break" do
+    i = 0
+    until i > 9
+      i = i + 1
+      break if i > 5
+    end
+    i.should == 6
+  end
+  
+  it "returns value passed to break if interrupted by break" do
+    until false
+      break 123
+    end.should == 123
+  end
+  
+  it "returns nil if interrupted by break with no arguments" do
+    until false
+      break
+    end.should == nil
+  end
+  
+  it "skips to end of body with next" do
+    a = []
+    i = 0
+    until (i = i + 1) >= 5
+      next if i == 3
+      a << i
+    end
+    
+    a.should == [1, 2, 4]
+  end
+  
+  it "restarts the current iteration without reevaluating condition with redo" do
+    a = []
+    i = 0
+    j = 0
+    until (i = i + 1) >= 3
+      a << i
+      j = j + 1
+      redo if j < 3
+    end
+    a.should == [1, 1, 1, 2]
+  end
+end
+
+describe "The until modifier" do
+  it "runs preceding statement while the condition is false" do
+    i = 0
+    i = i + 1 until i > 9
+    i.should == 10
+  end
+  
+  it "evaluates condition before statement execution" do
+    a = []
+    i = 0
+    a << i until (i = i + 1) >= 3
+    a.should == [1, 2]
+  end
+  
+  it "does not run preceding statement if the condition is true" do
+    i = 0
+    i = i + 1 until true
+    i.should == 0
+  end
+  
+  it "returns nil if ended when condition became true" do
+    i = 0
+    (i = i + 1 until i > 9).should == nil
+  end
+  
+  it "returns value passed to break if interrupted by break" do
+    (break 123 until false).should == 123
+  end
+  
+  it "returns nil if interrupted by break with no arguments" do
+    (break until false).should == nil
+  end
+  
+  it "skips to end of body with next" do
+    i = 0
+    j = 0
+    (i = i + 1) == 3 ? next : j = j + i until i > 10
+    j.should == 63
+  end
+  
+  it "restarts the current iteration without reevaluating condition with redo" do
+    i = 0
+    j = 0
+    (i = i + 1) == 4 ? redo : j = j + i until (i = i + 1) > 10
+    j.should == 34
+  end
+end
+

data/opals/opal/spec/language/while_spec.rb

@@ -0,0 +1,163 @@
+
+describe "The while expression" do
+  it "runs while the expression is true" do
+    i = 0
+    while i < 3
+      i = i + 1
+    end
+    
+    i.should == 3
+  end
+  
+  it "optionally takes a 'do' after the expression" do
+    i = 0
+    while i < 3 do
+      i = i + 1
+    end
+    
+    i.should == 3
+  end
+  
+  it "allows body begin on the same line if do is used" do
+    i = 0
+    while i < 3 do i = i + 1
+    end
+    
+    i.should == 3
+  end
+  
+  it "executes code in containing variable scope" do
+    i = 0
+    while i != 1
+      a = 123
+      i = 1
+    end
+    
+    a.should == 123
+  end
+  
+  it "executes code in containing variable scope with 'do'" do
+    i = 0
+    while i != 1 do
+      a = 123
+      i = 1
+    end
+    
+    a.should == 123
+  end
+  
+  it "returns nil if ended when condition became false" do
+    i = 0
+    while i < 3
+      i = i + 1
+    end.should == nil
+  end
+  
+  it "does not evaluate the body if expression is empty" do
+    a = []
+    while ()
+      a << :body_evaluated
+    end
+    a.should == []
+  end
+  
+  it "stops running body if interrupted by break" do
+    i = 0
+    while i < 10
+      i = i + 1
+      break if i > 5
+    end
+    
+    i.should == 6
+  end
+  
+  it "returns value passed to break if interrupted by break" do
+    while true
+      break 123
+    end.should == 123
+  end
+  
+  it "returns nil if interrupted by break with no arguments" do
+    while true
+      break
+    end.should == nil
+  end
+  
+  it "skips to end of body with next" do
+    a = []
+    i = 0
+    while (i = i + 1) < 5
+      next if i == 3
+      a << i
+    end
+    
+    a.should == [1, 2, 4]
+  end
+  
+  it "restarts the current iteration without reevaluating condition with redo" do
+    a = []
+    i = 0
+    j = 0
+    while (i = i + 1) < 3
+      a << i
+      j = j + 1
+      redo if j < 3
+    end
+    
+    a.should == [1, 1, 1, 2]
+  end
+end
+
+describe "The while modifier" do
+  it "runs preceding statement while the condition is true" do
+    i = 0
+    i = i + 1 while i < 3
+    i.should == 3
+  end
+  
+  it "evaluates condition before statement execution" do
+    a = []
+    i = 0
+    a << i while (i = i + 1) < 3
+    a.should == [1, 2]
+  end
+  
+  it "does not run preceding statement if the condition is false" do
+    i = 0
+    i = i + 1 while false
+    i.should == 0
+  end
+  
+  it "does not run preceding statement if the condition is empty" do
+    i = 0
+    i = i + 1 while ()
+    i.should == 0
+  end
+  
+  it "returns nil if ended when condition became false" do
+    i = 0
+    (i = i + 1 while i < 10).should == nil
+  end
+  
+  it "returns value passed to break if interrupetd by break" do
+    (break 123 while true).should == 123
+  end
+  
+  it "returns nil if interrupted by break with no arguments" do
+    (break while true).should == nil
+  end
+  
+  it "skips to end of body with next" do
+    i = 0
+    j = 0
+    (( i = i + 1) == 3 ? next : j = j + i) while i <= 10
+    j.should == 63
+  end
+  
+  it "restarts the current iteration without reevaluating condition with redo" do
+    i = 0
+    j = 0
+    (i = i + 1) == 4 ? redo : j = j + i while (i = i + 1) <= 10
+    j.should == 34
+  end
+end

data/opals/opal/spec/spec_helper.rb

@@ -0,0 +1,5 @@
+# Usually do this to require our libs, but as we are in opal, these are already
+# included.
+# require File.join(File.dirname(__FILE__), '..', 'lib', 'opal.rb')
+
+# puts "in spec helper"

data/opals/runtime/Opalfile

@@ -0,0 +1,68 @@
+# For spec..
+mode :spec do
+  # opal must require the spec opal itself. Also, we are the main target, so we
+  # can set the bin file aswell (to use the spec's bin ruby file)
+  config :runtime,
+    :required         => [:spec],
+    :bin_file         => :spec
+    
+  # Configure :spec to include its bin file, so opal can use it
+  config :spec,
+    :include_bin  => true
+end
+
+namespace :build do
+  
+  # opal needs a completely custom opal (gem) builder as its not actually an
+  # opal..ish...kinda
+  task :opal do
+    
+    # puts "building opal for opal"
+    
+    FileUtils.mkdir_p File.dirname(@dst_path)
+
+    # Get all ruby sources, then sort them (kernel.rb then module.rb then any)
+    rb_sources = @build_item.source_items.select do |item|
+      item.resource == :ruby
+    end
+
+    # make sure these two are at the start
+    ['lib/kernel.rb', 'lib/module.rb'].reverse.each do |order|
+      rb_sources.unshift rb_sources.select { |item|
+        item.filename == order
+      }.first
+    end
+    # make sure we remove the duplicates left over
+    rb_sources.uniq!
+
+    File.open(@dst_path, 'w') do |out|
+      js_sources = %w(pre_opal opal browser debug post_opal)
+      js_str = []
+      
+      js_sources.each do |src|
+        # puts @target.target_root, 'runtime', 
+        js_str << File.read(File.join(@target.target_root, 'runtime', "#{src}.js"))
+      end
+      
+      out.puts js_str.join
+      
+      # out.puts "var opal = {};"
+      # out.puts "(function(global, exports) {"
+      # js_sources.each do |js|
+      #   puts js.filename
+      #   out.puts File.read(js.stage!.staging_path)
+      # end
+      # out.puts "})(this.window || global, opal);"
+      
+      
+      
+      
+      rb_sources.each do |rb|
+        out.puts "// ##################### #{rb.filename} #####################"
+        out.puts "opal.load_raw_file('opal/#{rb.filename}', "
+        out.puts File.read(rb.stage!.staging_path)
+        out.puts ");"
+      end
+    end
+  end
+end

data/opals/runtime/README.md

@@ -0,0 +1,12 @@
+# Opal
+
+Opal comprises of the actual ruby runtime, as well as all the core libraries that are default in ruby. This includes the usual {Array}, {String}, {Proc}, {Hash} classes etc. 
+
+## Spec
+
+Opal also has some (of the many!) specs from RSpec in it's `spec/` directory. Opal attempts to be as sytactially compatible with ruby as possible, so uses the very same specs as vanilla ruby does so completeness can be determined. The specs are accessible from this documentation at [spec/index.html](spec/index.html). This is not the result of the specs, as instead the specs are run in the browser on demand. What you will see is the ruby specs being run within the browser itself, and the results output directly. This also helps determine any errors that happen to be browser specific.
+
+## Debugging
+
+Opal, when built in debug mode, contains some useful tools for debugging applications including stack traces and method missing errors.
+See {file:docs/debugging.md debugging documentation} for more.

data/opals/runtime/docs/debugging.md

@@ -0,0 +1,51 @@
+Debugging
+=========
+
+As described in other places, the code generated by opal and the vienna build tools is not very easy to read, which can become a problem when debugging errors in code. A lot of the properties and methods added to javascript objects are very unfriendly and are often coded. For example, searching a constant uses the `.cs()` method found on every ruby object, and a long chained command might contain many of these method calls before an error occurs, making it difficult to see what is going on.
+
+Stack traces
+------------
+The ruby stack trace is a great (and often only) place to catch errors. The ruby stack trace lists all the method calls that lead to an error. Opal provides a stack trace, which is available within the browser. Opal additionally adds some extra information on the stack trace. Every method call lists the file and line number that the method implementation is on (in order), but in addition to ruby, opal lists the receiver of the method call (using `inspect`) as well as all the arguments passed to a method. This clearly helps to identify problem code. Inspecting the arguments passed to methods quickly helps to identify where a problem occurred (for example, seeing a `nil` passed into a method is often a good indication that something has gone wrong).
+
+### Example stack trace
+
+Create a new project and enter the code into the document. This is an obvious error, but works well to show the problem.
+  
+    def something(a, b)
+      raise a
+    end
+    
+    def something_a(a, b, c)
+      something "adam", [a, b, c]
+    end
+
+    something_a 100, 200, 400
+
+Here we know eventually `something` will be called which will raise an error. So on running the given file, the console shows us the following error:
+
+    !!!plain
+    RuntimeError: adam
+      from request/request.rb:29:in main.something("adam", [100, 200, 400])
+      from request/request.rb:33:in main.something_a(100, 200, 400)
+
+The output is clean and simple. The error print out is on the top string. The stack is listed to the left with the filename and line number of each method in the stack. Now, instead of the usual ruby method of just listing the method call, opal lists the receiver (using `inspect`), the method call as expected but also every argument passed to the method (again using `inspect`). It is very easy now to follow what is being passed to what, and where possible errors come from. And, as expected, execution stops on the error.
+
+### Dealing with null and undefined
+
+Occasionally, when writing code that talks to javascript objects, it is possible that null and undefined might slip into the ruby side of things. Trying to send messages to either of these will result in an error. To assist in point out these errors, opal marks a method which takes one of these natives as a warning in the stack trace (supported by Firefox, Safari, IE8, Opera, Chrome) as an indication that this might be the root of the problem. It is not always the cause of the problem, as some methods might accept these objects, but it is a useful indication for most circumstances. Also, any object that slips in which is not a ruby object (like a JSON object for instance) will also get marked with this warning. Try the following code to see an example:
+
+    def some_method(a, b, c)
+      puts a
+      puts b
+      puts c
+    end
+    
+    some_method 10, 20, `null`
+
+Which should produce the following stack trace:
+
+    !!!plain
+    RuntimeError
+      from browser_test.rb:1: in main.some_method(10, 20, <null>)
+      
+The second output line should be marked in yellow, or however your browser console identifies warnings. Try a different browser if you do not notice a difference.