opal 0.3.42 → 0.3.43

data/CHANGELOG.md

@@ -1,3 +1,32 @@
+## 0.3.43 2013-05-02
+
+*   Stop inlining respond_to? inside the parser. This now fully respects
+    an object overriding respond_to?.
+
+*   Expose `Opal.eval()` function when parser is loaded for parsing
+    and running strings of ruby code.
+
+*   Add erb to corelib (as well as compiler to gem lib). ERB files with
+    .opalerb extension will automatically be compiled into Template
+    constant.
+
+*   Added some examples into examples/ dir.
+
+*   Add Opal.send() javascript function for sending methods to ruby
+    objects.
+
+*   Native class for wrapping and interacting with native objects and
+    function calls.
+
+*   Add local_storage to stdlib as a basic wrapper around localStorage.
+
+*   Make method_missing more performant by reusing same dispatch function
+    instead of reallocating one for each run.
+
+*   Fix Kernel#format to work in firefox. String.prototype.replace() had
+    different semantics for empty matching groups which was breaking
+    Kernel#format.
+
 ## 0.3.42 2013-03-21
 
 *   Fix/add lots of language specs.

data/CONTRIBUTING.md

@@ -21,4 +21,12 @@ and all specs, run:
 
 ```
 $ rake
-```
+```
+
+You can alternatively run tests in a browser using:
+
+```
+$ rackup
+```
+
+And then opening `http://127.0.0.1:9292` in a web browser.

data/Rakefile

@@ -1,34 +1,69 @@
 require 'bundler'
 Bundler.require
 
-require 'opal-sprockets'
+require 'rack'
+require 'webrick'
 
-desc "Run tests through mspec"
-task :default do
-  require 'rack'
-  require 'webrick'
+class RunSpec
+  def initialize(file=nil)
+    Opal::Processor.arity_check_enabled = true
 
-  Opal::Processor.arity_check_enabled = true
+    ENV['OPAL_SPEC'] = file.nil? ? ["#{Dir.pwd}/spec/"].join(',') : file.join(',')
 
-  server = fork do
-    serv = Opal::Server.new { |s|
-      s.append_path 'spec' # before mspec, so we use our overrides
-      s.append_path File.join(Gem::Specification.find_by_name('mspec').gem_dir, 'lib')
-      s.debug = false
-      s.main = 'ospec/main'
-    }
+    server = fork do
+      serv = Opal::Server.new { |s|
+        s.append_path 'spec' # before mspec, so we use our overrides
+        s.append_path File.join(Gem::Specification.find_by_name('mspec').gem_dir, 'lib')
+        s.debug = false
+        s.main = 'ospec/main'
+      }
 
-    Rack::Server.start(:app => serv, :Port => 9999, :AccessLog => [],
-      :Logger => WEBrick::Log.new("/dev/null"))
-  end
+      Rack::Server.start(:app => serv, :Port => 9999, :AccessLog => [],
+        :Logger => WEBrick::Log.new("/dev/null"))
+    end
 
-  system "phantomjs \"spec/ospec/sprockets.js\" \"http://localhost:9999/\""
-  success = $?.success?
+    system "phantomjs \"spec/ospec/sprockets.js\" \"http://localhost:9999/\""
+    success = $?.success?
 
-  Process.kill(:SIGINT, server)
-  Process.wait
+    Process.kill(:SIGINT, server)
+    Process.wait
 
-  exit 1 unless success
+    exit 1 unless success
+  end
+end
+
+desc "Run tests through mspec"
+task :default do
+  RunSpec.new
+end
+
+desc "Run task with spec:dir:file helper"
+namespace :spec do
+  task 'dirs' do
+  end
+  rule '' do |t|
+
+    #build path for spec files\dirs.
+    #Example:
+    #spec:core => spec/core/
+    #spec:core:array:allocae => spec/core/array/allocate_spec.rb
+    def path(dirs) 
+      path = "#{Dir.pwd}"
+      dirs.each do |dir|
+        base = path + "/#{dir}" 
+        if Dir.exists?(base)
+          path = base
+        else
+          path = Dir.glob("#{base}_spec.rb")
+        end  
+      end
+      path = [path].flatten
+      raise "File or Dir with task #{t.name} not found." if path.empty?
+      path
+    end
+    
+    RunSpec.new(path(t.name.split(":")))
+  end
 end
 
 desc "Build opal.js and opal-parser.js to build/"
@@ -38,6 +73,8 @@ task :dist do
   env = Sprockets::Environment.new
   Opal.paths.each { |p| env.append_path p }
 
+  Dir.mkdir 'build' unless File.directory? 'build'
+
   File.open('build/opal.js', 'w+') { |f| f << env['opal'].to_s }
   File.open('build/opal-parser.js', 'w+') { |f| f << env['opal-parser'].to_s }
 end

data/config.ru

@@ -0,0 +1,14 @@
+require 'bundler'
+Bundler.require
+
+require 'opal-sprockets'
+
+run Opal::Server.new { |s|
+  Opal::Processor.arity_check_enabled = true
+
+  s.append_path 'spec'
+  s.append_path File.join(Gem::Specification.find_by_name('mspec').gem_dir, 'lib')
+
+  s.debug = false
+  s.main = 'ospec/main'
+}

data/examples/rack/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gem 'opal', :path => '../..'

data/examples/rack/README.md

@@ -0,0 +1,22 @@
+# Opal Rack example
+
+This example uses a simple rack server, along with sprockets to serve
+the assets. Sprockets makes opal easy to use, and is the basis for
+integration with rails (via opal-rails).
+
+## Running
+
+Install dependencies (opal):
+
+```
+$ bundle install
+```
+
+Run rack server:
+
+```
+$ bundle exec rackup
+```
+
+Open any browser to `http://127.0.0.1/index.html`, and enjoy!
+

data/examples/rack/app/app.rb

@@ -0,0 +1,5 @@
+require 'opal'
+
+# use native alert from browser
+Native.global.alert "Boo! From opal."
+

data/examples/rack/config.ru

@@ -0,0 +1,20 @@
+require 'bundler'
+Bundler.require
+
+# Use sprockets for handling our assets
+map '/assets' do
+  env = Sprockets::Environment.new
+
+  # add all our opal load paths to sprockets
+  Opal.paths.each { |p| env.append_path p }
+
+  # add 'app' dir for serving app.rb
+  env.append_path 'app'
+
+  # run!
+  run env
+end
+
+# Use simple Rack::Directory for serving current dir
+run Rack::Directory.new('.')
+

data/examples/rack/index.html

@@ -0,0 +1,12 @@
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>Opal rack example</title>
+
+  <script src="/assets/app.js"></script>
+
+</head>
+<body>
+</body>
+</html>

data/examples/server/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gem 'opal', :path => '../..'

data/examples/server/README.md

@@ -0,0 +1,22 @@
+# Opal Example Application
+
+This example shows how to use `Opal::Server` on top of a rack app to run
+a simple opal application.
+
+## Run example
+
+Change into this directory, and install dependencies:
+
+```
+$ bundle install
+```
+
+Start the rack server (which will compile/build opal runtime for you):
+
+```
+$ bundle exec rackup
+```
+
+Then just open `http://127.0.0.1:9292` in any browser and checkout the console.
+
+Happy hacking.

data/examples/server/app/app.rb

@@ -0,0 +1,18 @@
+require 'opal'
+
+[1, 2, 3, 4].each do |a|
+  puts a
+end
+
+class Foo
+  attr_accessor :name
+
+  def method_missing(sym, *args, &block)
+    puts "You tried to call: #{sym}"
+  end
+end
+
+adam = Foo.new
+adam.name = 'Adam Beynon'
+puts adam.name
+adam.do_task

data/examples/server/config.ru

@@ -0,0 +1,10 @@
+require 'bundler'
+Bundler.require
+
+run Opal::Server.new { |s|
+  s.append_path 'app'
+
+  s.index_path = 'index.html.erb'
+  s.debug = true
+  s.main = 'app'
+}

data/examples/server/index.html.erb

@@ -0,0 +1,10 @@
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>opal server example</title>
+  <%= javascript_include_tag 'app' %>
+</head>
+<body>
+</body>
+</html>

data/lib/opal.rb

@@ -1,4 +1,7 @@
 require 'opal/parser'
+require 'opal/processor'
+require 'opal/erb'
+require 'opal/server'
 require 'opal/version'
 
 # Opal is a ruby to javascript compiler, with a runtime for running
@@ -35,6 +38,6 @@ module Opal
 
   # Private, don't add to these directly (use .append_path instead).
   def self.paths
-    @paths ||= [Opal.core_dir]
+    @paths ||= [core_dir]
   end
 end

data/lib/opal/erb.rb

@@ -0,0 +1,41 @@
+require 'opal/parser'
+
+module Opal
+  module ERB
+    def self.parse(str, name='(erb)')
+      body = str.gsub('"', '\\"').gsub(/<%=([\s\S]+?)%>/) do
+        inner = $1.gsub(/\\'/, "'").gsub(/\\"/, '"')
+        "\")\nout.<<(#{ inner })\nout.<<(\""
+      end.gsub(/<%([\s\S]+?)%>/) do
+        "\")\n#{ $1 }\nout.<<(\""
+      end
+
+      code = "ERB.new('#{name}') do\nout = []\nout.<<(\"#{ body }\")\nout.join\nend\n"
+      Opal.parse code
+    end
+
+    class Processor < Tilt::Template
+      self.default_mime_type = 'application/javascript'
+
+      def self.engine_initialized?
+        true
+      end
+
+      def initialize_engine
+        require_template_library 'opal'
+      end
+
+      def prepare
+        # ...
+      end
+
+      def evaluate(scope, locals, &block)
+        Opal::ERB.parse data, scope.logical_path.sub(/^templates\//, '')
+      end
+    end
+  end
+end
+
+Tilt.register 'opalerb',               Opal::ERB::Processor
+Sprockets.register_engine '.opalerb',  Opal::ERB::Processor
+

data/lib/opal/lexer.rb

@@ -533,7 +533,7 @@ module Opal
           end
 
         elsif scanner.scan(/\^\=/)
-          @lex_state = :exor_beg
+          @lex_state = :expr_beg
           return :OP_ASGN, '^'
         elsif scanner.scan(/\^/)
           if @lex_state == :expr_fname

data/lib/opal/parser.rb

@@ -565,7 +565,9 @@ module Opal
         "false"
       when :ivar
         ivar_name = part[1].to_s[1..-1]
-        "(#{current_self}[#{ivar_name.inspect}] != null ? 'instance-variable' : 'nil')"
+        with_temp do |t|
+          "((#{t} = #{current_self}[#{ivar_name.inspect}], #{t} != null && #{t} !== nil) ? 'instance-variable' : nil)"
+        end
       else
         raise "bad defined? part: #{part[0]}"
       end
@@ -714,13 +716,6 @@ module Opal
       "%s%s = %s.%s" % [@scope.proto, meth, @scope.proto, func]
     end
 
-    def handle_respond_to(sexp, level)
-      recv, mid, arglist = sexp
-      recv ||= s(:self)
-      meth = process(arglist[1], level) if arglist[1]
-      "(!!#{process(recv, level)}['$' + #{meth}])"
-    end
-
     # s(:call, recv, :mid, s(:arglist))
     # s(:call, nil, :mid, s(:arglist))
     def process_call(sexp, level)
@@ -736,8 +731,6 @@ module Opal
         return handle_alias_native(sexp) if @scope.class_scope?
       when :require
         return handle_require arglist[1]
-      when :respond_to?
-        return handle_respond_to(sexp, level)
       end
 
       splat = arglist[1..-1].any? { |a| a.first == :splat }
@@ -1345,7 +1338,7 @@ module Opal
       elsif rhs[0] == :to_ary
         code = ["((#{tmp} = #{process rhs[1], :expr})._isArray ? #{tmp} : (#{tmp} = [#{tmp}]))"]
       elsif rhs[0] == :splat
-        code = ["#{tmp} = #{process rhs[1], :expr}"]
+        code = ["(#{tmp} = #{process(rhs[1], :expr)})['$to_a'] ? (#{tmp} = #{tmp}['$to_a']()) : (#{tmp})._isArray ? #{tmp} : (#{tmp} = [#{tmp}])"]
       else
         raise "Unsupported mlhs type"
       end
@@ -1769,7 +1762,7 @@ module Opal
 
       with_temp do |t|
         base = process base, :expr
-        "((#{t} = (#{base})._scope.#{cname}) == null ? __opal.cm(#{cname.inspect}) : #{t})"
+        "((#{t} = (#{base})._scope).#{cname} == null ? #{t}.cm(#{cname.inspect}) : #{t}.#{cname})"
       end
     end
 

data/lib/opal/processor.rb

@@ -0,0 +1,70 @@
+require 'sprockets'
+
+module Opal
+  # Proccess using Sprockets
+  #
+  #   Opal.process('opal-jquery')   # => String
+  def self.process(asset)
+    env = Sprockets::Environment.new
+    Opal.paths.each { |p| env.append_path p }
+    env[file].to_s
+  end
+
+  # The Processor class is used to make ruby files (with rb or opal extensions)
+  # available to any sprockets based server. Processor will then get passed any
+  # ruby source file to build. There are some options you can override globally
+  # which effect how certain ruby features are handled:
+  #
+  #   * method_missing_enabled [true by default]
+  #   * optimized_operators_enabled [true by default]
+  #   * arity_check_enabled [false by default]
+  #
+  class Processor < Tilt::Template
+    self.default_mime_type = 'application/javascript'
+
+    def self.engine_initialized?
+      true
+    end
+
+    class << self
+      attr_accessor :method_missing_enabled
+      attr_accessor :optimized_operators_enabled
+      attr_accessor :arity_check_enabled
+      attr_accessor :const_missing_enabled
+    end
+
+    self.method_missing_enabled = true
+    self.optimized_operators_enabled = true
+    self.arity_check_enabled = false
+    self.const_missing_enabled = true
+
+    def initialize_engine
+      require_template_library 'opal'
+    end
+
+    def prepare
+    end
+
+    def evaluate(context, locals, &block)
+      options = {
+        :method_missing       => self.class.method_missing_enabled,
+        :optimized_operators  => self.class.optimized_operators_enabled,
+        :arity_check          => self.class.arity_check_enabled,
+        :const_missing        => self.class.const_missing_enabled,
+        :file                 => context.logical_path
+      }
+
+      parser = Opal::Parser.new
+      result = parser.parse data, options
+
+      parser.requires.each { |r| context.require_asset r }
+      result
+    end
+  end
+end
+
+Tilt.register 'rb',               Opal::Processor
+Sprockets.register_engine '.rb',  Opal::Processor
+
+Tilt.register 'opal',               Opal::Processor
+Sprockets.register_engine '.opal',  Opal::Processor