opal 0.3.44 → 0.4.0

data/.travis.yml

@@ -3,7 +3,6 @@ language: ruby
 rvm:
   - 1.8.7
   - 1.9.3
-  - 2.0.0
 
 notifications:
   irc: "irc.freenode.org#opal"

data/CHANGELOG.md

@@ -1,3 +1,55 @@
+## 0.4.0 2013-06-15
+
+*   Added fragments to parser. All parser methods now generate one or
+    more Fragments which store the original sexp. This allows us to
+    enumerate over them after parsing to map generated lines back to
+    original line numbers.
+
+*   Reverted `null` for `nil`. Too buggy at this time.
+
+*   Add Opal::SprocketsParser as Parser subclass for handling parsing
+    for sprockets environment. This subclass handles require statements
+    and stores them for sprockets to use.
+
+*   Add :irb option to parser to keep top level lvars stored inside
+    opal runtime so that an irb session can be persisted and maintain
+    access to local variables.
+
+*   Add Opal::Environment#use_gem() helper to add a gem to opals load
+    path.
+
+*   Stop pre-setting ivars to `nil`. This is no longer needed as `nil`
+    is now `null` or `undefined`.
+
+*   Use `null` as `nil` in opal. This allows us to send methods to
+    `null` and `undefined`, and both act as `nil`. This makes opal a
+    much better javascript citizen. **REVERTED**
+
+*   Add Enumerable#none? with specs.
+
+*   Add Opal.block_send() runtime helper for sending methods to an
+    object which uses a block.
+
+*   Remove \_klass variable for denoting ruby classes, and use
+    constructor instead. constructor is a javascript property used for
+    the same purpose, and this makes opal fit in as a better js citizen.
+
+*   Add Class.bridge\_class method to bridge a native constructor into an
+    opal class which will set it up with all methods from Object, as
+    well as giving it a scope and name.
+
+*   Added native #[]= and #to_h methods, for setting properties and
+    converting to a hash respectivaly.
+
+*   Fix bug where '::' was parsed as :colon2 instead of :colon3 when in
+    an args scope. Fixes #213
+
+*   Remove lots of properties added to opal classes. This makes normal
+    js constructors a lot closer to opal classes, making is easier to
+    treat js classes as opal classes.
+
+*   Merge Hash.from_native into Hash.new
+
 ## 0.3.44 2013-05-31
 
 *   Cleanup runtime, and remove various flags and functions from opal

data/README.md

@@ -41,9 +41,9 @@ javascript. These are built using `rake`, as above.
 
 ### spec
 
-* **core** contains rubyspecs that apply to opal.
-* **language** applicable specs from rubyspec for testing language semantics
-* **grammar** specs for opal lib (parser, lexer, grammar etc)
+* **rubyspec** contains rubyspecs that apply to opal (core + language)
+* **opal** opal additions/special behaviour in the runtime/corelib
+* **parser** specs for opal lib (parser, lexer, grammar etc)
 
 ## License
 

data/Rakefile

@@ -13,7 +13,7 @@ class RunSpec
     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.use_gem 'mspec'
         s.debug = false
         s.main = 'ospec/main'
       }
@@ -25,10 +25,11 @@ class RunSpec
     system "phantomjs \"spec/ospec/sprockets.js\" \"http://localhost:9999/\""
     success = $?.success?
 
+    exit 1 unless success
+
+  ensure
     Process.kill(:SIGINT, server)
     Process.wait
-
-    exit 1 unless success
   end
 end
 
@@ -37,16 +38,39 @@ task :default do
   RunSpec.new
 end
 
+desc "Build specs to build/specs.js and build/specs.min.js"
+task :build_specs do
+  require 'uglifier'
+
+  Opal::Processor.arity_check_enabled = true
+  ENV['OPAL_SPEC'] = ["#{Dir.pwd}/spec/"].join(',')
+
+  env = Opal::Environment.new
+  env.append_path 'spec'
+  env.use_gem 'mspec'
+
+  FileUtils.mkdir_p 'build'
+
+  puts " * build/specs.js"
+  specs = env['ospec/main'].to_s
+
+#  puts " * build/specs.min.js"
+#  min = Uglifier.compile(specs)
+
+  File.open('build/specs.js', 'w+') { |o| o << specs }
+#  File.open('build/specs.min.js', 'w+') { |o| o << min }
+end
+
 desc "Run task with spec:dir:file helper"
 namespace :spec do
   task 'dirs' do
   end
-  rule '' do |t|
+  rule '' do |task|
 
     #build path for spec files\dirs.
     #Example:
     #spec:core => spec/core/
-    #spec:core:array:allocae => spec/core/array/allocate_spec.rb
+    #spec:core:array:allocate => spec/core/array/allocate_spec.rb
     def path(dirs)
       path = "#{Dir.pwd}"
       dirs.each do |dir|
@@ -58,11 +82,11 @@ namespace :spec do
         end
       end
       path = [path].flatten
-      raise "File or Dir with task #{t.name} not found." if path.empty?
+      raise ArgumentError, "File or Dir with task #{dirs.join('/')} not found." if path.empty?
       path
     end
 
-    RunSpec.new(path(t.name.split(":")))
+    RunSpec.new(path(task.name.split(":")))
   end
 end
 
@@ -104,7 +128,7 @@ end
 
 # Used for uglifying source to minify
 def uglify(str)
-  IO.popen('uglifyjs --no-mangle --compress warnings=false', 'r+') do |i|
+  IO.popen('uglifyjs', 'r+') do |i|
     i.puts str
     i.close_write
     return i.read

data/bin/opal

@@ -1,33 +1,86 @@
 #!/usr/bin/env ruby
 
 require 'optparse'
-require 'opal'
 
 options = {}
 parser = OptionParser.new do |opts|
-  opts.banner = "Usage: opal [options] file.rb"
+  opts.banner = 'Usage: opal [options] -- [programfile]'
 
-  opts.on("-v", "--version", "Opal Version") do |v|
-    puts Opal::VERSION
+  opts.on('-v', '--version', 'Display Opal Version') do |v|
+    require 'opal/version'
+    puts "Opal v#{Opal::VERSION}"
     exit
   end
 
-  opts.on("-s", "--sexp", "Show Sexps") do
+  opts.on("-h", "--help", "Show this message") do
+    puts opts
+    exit
+  end
+
+  opts.separator ''
+  opts.separator 'Basic Options:'
+
+  opts.on('-I', '--include DIR',
+          'Append a load path (may be used more than once)') do |i|
+    options[:load_paths] ||= []
+    options[:load_paths] << i
+  end
+
+  opts.on('-e', '--eval SOURCE', String,
+          'One line of script. Several -e\'s allowed. Omit [programfile]') do |source|
+    options[:evals] ||= []
+    options[:evals] << source
+  end
+
+  opts.on('-s', '--sexp', 'Show Sexps') do
     options[:sexp] = true
   end
-end
 
-parser.parse!
+  opts.on('-c', '--compile', 'Compile to JavaScript') do
+    options[:compile] = true
+  end
+
+  opts.on('-s', '--server [PORT]', 'Start a server (default port: 3000)') do |port|
+    options[:server] = port.to_i
+  end
+
+
+  opts.separator ''
+  opts.separator 'Compilation Options:'
 
-if ARGV.empty?
-  puts parser.banner
-else
-  src = ARGV.first
-  src = File.read src if File.exist? src
+  opts.on('-M', '--no-method-missing', 'Disable method missing') do |value|
+    options[:method_missing_enabled] = false
+  end
+
+  opts.on('-O', '--no-optimized-operators', 'Disable optimized operators') do |value|
+    options[:optimized_operators_enabled] = false
+  end
+
+  opts.on('-A', '--arity-check', 'Enable arity check') do |value|
+    options[:arity_check] = true
+  end
+
+  opts.on('-C', '--no-const-missing', 'Disable const missing') do |value|
+    options[:const_missing_enabled] = false
+  end
 
-  if options[:sexp]
-    puts Opal::Grammar.new.parse(src).inspect
-  else
-    puts Opal.parse(src)
+  dynamic_require_levels = %w[error warning ignore]
+  opts.on('-D', '--dynamic-require LEVEL', dynamic_require_levels,
+                'Set levelDynamic require severity') do |level|
+    options[:dynamic_require_severity] = level
   end
+
+  opts.on('-P', '--no-source-map', 'Disable source map') do |value|
+    options[:source_map_enabled] = false
+  end
+
+  opts.on("--irb", "IRB var mode") do |i|
+    options[:irb] = true
+  end
+
 end
+
+parser.parse!
+
+require 'opal/cli'
+Opal::CLI.new ARGV.first, options

data/config.ru

@@ -1,7 +1,7 @@
 require 'bundler'
 Bundler.require
 
-require 'opal-sprockets'
+ENV['OPAL_SPEC'] = ["#{Dir.pwd}/spec/"].join(',')
 
 run Opal::Server.new { |s|
   Opal::Processor.arity_check_enabled = true

data/examples/native/app/app.rb

@@ -1,21 +1,41 @@
 require 'opal'
 
-$window.addEventListener 'DOMContentLoaded', proc {
+# We can treat native objects (in this case `window`) as a ruby object
+# and open up a singleton class on it and define methods on the object
+# directly. This basically defines just a single ruby method onto
+# `window`.
+class << $global
+
+  # on_ready is a simple method that just adds a 'DOMContentLoaded'
+  # event onto window. `self` inside this method will be `window`,
+  # so we can call addEventListener as we would in ruby
+  def on_ready(&block)
+    addEventListener 'DOMContentLoaded', block, false
+  end
+end
 
+# Call our new method on window (which is accessed by `$global`
+$global.on_ready do
   css = <<-CSS
     body {
       font-family: 'Arial';
     }
+
+    h1 {
+      color: rgb(10, 94, 232);
+    }
   CSS
 
-  title = $document.createElement 'h1'
+  document = $global.document
+
+  title = document.createElement 'h1'
   title.className = 'main-title'
   title.innerHTML = 'Opal Native Example'
 
-  desc = $document.createElement 'p'
+  desc = document.createElement 'p'
   desc.innerHTML = "Hello world! From Opal."
 
-  target = $document.getElementById 'native-example'
+  target = document.getElementById 'native-example'
 
   unless target
     raise "'native-example' doesn't exist?"
@@ -24,15 +44,14 @@ $window.addEventListener 'DOMContentLoaded', proc {
   target.appendChild title
   target.appendChild desc
 
-  styles = $document.createElement 'style'
+  styles = document.createElement 'style'
   styles.type = 'text/css'
 
   if styles.respond_to? :styleSheet
     styles.styleSheet.cssText = css
   else
-    styles.appendChild $document.createTextNode css
+    styles.appendChild document.createTextNode css
   end
 
-  $document.getElementsByTagName('head')[0].appendChild(styles)
-
-}, false
+  document.getElementsByTagName('head')[0].appendChild(styles)
+end

data/examples/rack/app/app.rb

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

data/lib/opal.rb

@@ -1,6 +1,5 @@
 require 'opal/parser'
 require 'opal/processor'
-require 'opal/erb'
 require 'opal/server'
 require 'opal/version'
 

data/lib/opal/cli.rb

@@ -0,0 +1,106 @@
+require 'opal'
+
+module Opal
+  class CLI
+    attr_reader :options, :filename
+
+    def initialize _filename, options
+      @options = options
+      @filename = _filename
+
+      processor_options.each do |option|
+        key = option.to_sym
+        next unless options.has_key? key
+        Opal::Processor.send("#{option}=", options[key])
+      end
+
+      if options[:evals] and options[:evals].any?
+        require 'tempfile'
+        path = File.join(Dir.tmpdir,"opal-#{$$}.js.rb")
+        File.open(path, 'w') do |tempfile|
+          options[:load_paths] ||= []
+          options[:load_paths] << File.dirname(path)
+
+          options[:evals].each do |code|
+            tempfile.puts 'require "opal"'
+            tempfile.puts code
+          end
+        end
+        @filename = File.basename(path)
+      end
+
+      case
+      when options[:sexp]
+        puts sexp.inspect
+      when options[:compile]
+        if File.exist?(filename)
+          puts sprockets[filename].to_a.last
+        else
+          puts Opal.parse(filename, options)
+        end
+      when options[:server]
+        server_start
+      else
+        run
+      end
+    end
+
+    def run
+      begin
+        full_source = sprockets[filename]
+        IO.popen('node', 'w') do |stdin|
+          stdin.write full_source
+        end
+      rescue Errno::ENOENT
+        $stderr.puts 'Please install Node.js to be able to run Opal scripts.'
+        exit 127
+      end
+    end
+
+    def sexp
+      Opal::Grammar.new.parse(source)
+    end
+
+    def source
+      File.exist?(filename) ? File.read(filename) : filename
+    end
+
+    def processor_options
+      %w[
+        method_missing_enabled
+        optimized_operators_enabled
+        arity_check_enabled
+        const_missing_enabled
+        dynamic_require_severity
+        source_map_enabled
+        irb_enabled
+      ]
+    end
+
+    def sprockets
+      server.sprockets
+    end
+
+    def server
+      @server ||= Opal::Server.new do |s|
+        (options[:load_paths] || []).each do |path|
+          s.append_path path
+        end
+        s.main = File.basename(filename, '.rb')
+      end
+    end
+
+    def server_start
+      require 'rack'
+      require 'webrick'
+      require 'logger'
+
+      Rack::Server.start(
+        :app       => server,
+        :Port      => options[:port] || 3000,
+        :AccessLog => [],
+        :Logger    => Logger.new($stdout)
+      )
+    end
+  end
+end