opal-cj 0.7.0.beta1

data/benchmarks/operators.rb

@@ -0,0 +1,11 @@
+require "benchmark"
+
+time = Benchmark.measure do
+  a = 0
+  100000.times do
+    a = a + 1
+  end
+  puts a
+end
+
+puts time

data/bin/opal

@@ -0,0 +1,22 @@
+#!/usr/bin/env ruby
+
+# Error codes are taken from /usr/include/sysexits.h
+
+require 'opal/cli_options'
+options = Opal::CLIOptions.new
+begin
+  options.parse!
+rescue OptionParser::InvalidOption => e
+  $stderr.puts "#{$0}: #{e.message} (-h will show valid options)"
+  exit 64
+end
+
+require 'opal/cli'
+cli = Opal::CLI.new options.options.merge(:file => ARGF.file, :argv => ARGV.dup)
+
+begin
+  cli.run
+rescue Opal::CliRunners::RunnerError => e
+  $stderr.puts e.message
+  exit 72
+end

data/bin/opal-build

@@ -0,0 +1,77 @@
+#!/usr/bin/env ruby
+
+require 'optparse'
+
+module Opal
+  class BuilderOptions < OptionParser
+    def initialize
+      @options = {}
+
+      super do |opts|
+        opts.banner = 'Usage: opal-build [options] -- [libname]'
+
+        opts.separator ''
+        opts.separator 'Options:'
+
+        opts.on("-h", "--help", "Show this message") do
+          puts opts
+          exit
+        end
+
+        opts.on('-g', '--gem GEM_NAME', String,
+                'Adds the specified GEM_NAME lib dir to Opal\'s load path.',
+                'E.g.: opal-build --gem erubis -- erubis`',
+                'Will build erubis.rb from the regular "erubis" gem') do |g|
+          options[:gems] ||= []
+          options[:gems] << g
+        end
+
+        opts.on('-s', '--stub STUB', String) do |stub|
+          options[:stubs] ||= []
+          options[:stubs] << stub
+        end
+
+        opts.on('-r', '--require LIBRARY', String,
+                'Require the library before executing your script',
+                'E.g.: opal-build --require opal-browser browser`',
+                'Will build browser.rb from the Opal gem opal-browser') do |library|
+          options[:requires] ||= []
+          options[:requires] << library
+        end
+
+        opts.on('-o', '--output FILE', String,
+                'Write the built lib to a file (defaults to STDOUT)') do |file|
+          options[:output] = file
+        end
+      end
+    end
+
+    attr_reader :options
+  end
+end
+
+option_parser = Opal::BuilderOptions.new
+option_parser.parse!
+
+if ARGV.empty?
+  puts option_parser
+else
+  require 'opal'
+  options = option_parser.options
+
+  if options[:gems]
+    require 'rubygems'
+    options[:gems].each { |gem_name| Opal.use_gem gem_name }
+  end
+
+  if options[:requires]
+    options[:requires].each { |required_lib| require required_lib }
+  end
+
+  lib_name = ARGV.first
+
+  output = options[:output] ? File.open(options[:output], 'w') : $stdout
+  output.puts Opal::Builder.build(lib_name.dup.untaint)
+end
+
+

data/bin/opal-mspec

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+
+specs = ARGV.map do |s|
+  s.end_with?('.rb') ? s : "#{s}/**/*_spec.rb"
+end
+pattern = %Q{MSPEC_PATTERN="{#{specs.join(',')}}"} if specs.any?
+command = [pattern, 'rake mspec'].compact.join(' ')
+exec command
+
+# bundle exec mspec run -t opal -pspec/corelib/spec_helper spec/corelib/core/true/*

data/bin/opal-repl

@@ -0,0 +1,72 @@
+#!/usr/bin/env ruby
+
+require 'opal'
+
+module Opal
+  class V8Context
+    def initialize
+      @builder = Opal::Builder.new
+    end
+
+    def run(filename = nil)
+      return if @v8
+
+      begin
+        require 'v8'
+      rescue LoadError
+        abort 'therubyracer must be installed'
+      end
+
+      @v8 = V8::Context.new
+      @v8['console'] = self
+      @v8.eval Opal::Builder.new.build('opal').to_s
+
+      if filename
+        if File.exist? filename
+          eval_ruby File.read(filename)
+        else
+          fail "file does not exist: #{filename}"
+        end
+      end
+
+      run_repl
+    end
+
+    def log(*str)
+      puts(*str)
+    end
+
+    def run_repl
+      require 'readline'
+
+      loop do
+        # on SIGINT lets just return from the loop..
+        trap("SIGINT") { finish; return }
+        line = Readline.readline '>> ', true
+
+        # if we type exit, then we need to close down context
+        if line == "exit" or line.nil?
+          break
+        end
+
+        puts "=> #{eval_ruby line}"
+      end
+
+      finish
+    end
+
+    def eval_ruby(str)
+      code = Opal::Builder.new.build_str(str, '(irb)', :irb => true, :const_missing => true)
+      code.processed[0...-1].each{ |c| @v8.eval(c.to_s) }
+      @v8.eval "var $_result = #{code.processed.last.to_s} ($_result == null ? 'nil' : $_result.$inspect());"
+    rescue => e
+      puts "#{e.message}\n\t#{e.backtrace.join("\n\t")}"
+    end
+
+    def finish
+      @v8 = nil
+    end
+  end
+end
+
+Opal::V8Context.new.run ARGV.first

data/config.ru

@@ -0,0 +1,14 @@
+require 'bundler'
+Bundler.require
+
+require 'mspec/opal/rake_task'
+
+::Opal::Processor.arity_check_enabled = true
+::Opal::Processor.dynamic_require_severity = :raise
+
+use Rack::ShowExceptions
+use Rack::ShowStatus
+use MSpec::Opal::Index
+run MSpec::Opal::Environment.new
+
+

data/examples/rack/Gemfile

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

data/examples/rack/app/application.rb

@@ -0,0 +1,13 @@
+require 'opal'
+require 'user'
+
+module MyApp
+  class Application
+    def initialize
+      @user = User.new('Bill')
+      @user.authenticated?
+    end
+  end
+end
+
+MyApp::Application.new

data/examples/rack/app/user.rb

@@ -0,0 +1,21 @@
+class User
+  def initialize(name)
+    @name = name
+  end
+
+  def authenticated?
+    if admin? or special_permission?
+      true
+    else
+      raise "not authenticated"
+    end
+  end
+
+  def admin?
+    @name == 'Bob'
+  end
+
+  def special_permission?
+    false
+  end
+end

data/examples/rack/config.ru

@@ -0,0 +1,7 @@
+require 'bundler'
+Bundler.require
+
+run Opal::Server.new { |s|
+  s.main = 'application'
+  s.append_path 'app'
+}

data/examples/rack/index.html.erb

@@ -0,0 +1,10 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>opal-sprockets demo</title>
+
+    <%= javascript_include_tag 'application' %>
+  </head>
+  <body>
+  </body>
+</html>

data/examples/sinatra/Gemfile

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

data/examples/sinatra/app/application.rb

@@ -0,0 +1,7 @@
+require 'opal'
+
+def alert(msg)
+  `alert(msg)`
+end
+
+alert "Hi there!"

data/examples/sinatra/config.ru

@@ -0,0 +1,28 @@
+require 'opal'
+require 'sinatra'
+
+opal = Opal::Server.new {|s|
+  s.append_path 'app'
+  s.main = 'application'
+}
+
+map opal.source_maps.prefix do
+  run opal.source_maps
+end
+
+map '/assets' do
+  run opal.sprockets
+end
+
+get '/' do
+  <<-HTML
+    <!doctype html>
+    <html>
+      <head>
+        <script src="/assets/application.js"></script>
+      </head>
+    </html>
+  HTML
+end
+
+run Sinatra::Application

data/lib/mspec/opal/main.rb.erb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+# This file just greps for all spec files in spec/ and requires them
+<% ENV['OPAL_SPEC'].split(',').each do |s| %>
+  require <%= s.inspect %>
+<% end %>
+
+# All specs have been run, so we notify mspec that we are done
+OSpecRunner.main.did_finish

data/lib/mspec/opal/rake_task.rb

@@ -0,0 +1,278 @@
+require 'opal/nodes'
+class Opal::Nodes::CallNode
+  # Rubyspec uses this call to load in language specific features at runtime.
+  # We can't do this at runtime, so handle it during compilation
+  add_special :language_version do
+    if meth == :language_version and scope.top?
+      lang_type = arglist[2][1]
+      target = "corelib/language/versions/#{lang_type}_1.9"
+
+      if File.exist?(target)
+        compiler.requires << target
+      end
+
+      push fragment("nil")
+    end
+  end
+
+  add_special :not_supported_on do
+    unless meth == :not_supported_on and arglist[1][1] == :opal
+      compile_default!
+    end
+  end
+end
+
+
+require 'rack'
+require 'webrick'
+
+module MSpec
+  module Opal
+    DEFAULT_BASEDIR = 'spec'
+
+    require 'rake'
+    require 'rake/tasklib'
+    class RakeTask < ::Rake::TaskLib
+      include ::Rake::DSL if defined?(::Rake::DSL)
+
+      def initialize(name, &task_block)
+        namespace name do
+          desc 'Run MSpec::Opal code examples' unless ::Rake.application.last_comment
+          task :default do
+            puts 'Starting MSpec Runner...'
+            runner = Runner.new(&task_block)
+            runner.run
+          end
+
+          desc 'Build specs to build/specs.js and build/specs.min.js'
+          task :build do
+            require 'opal/util'
+            path = './build/specs.js'
+            min_path = './build/specs.min.js'
+            Environment.new.build_specs(path)
+            min = ::Opal::Util.uglify File.read(path)
+            File.open(min_path, 'w') { |f| f << min_path }
+          end
+        end
+
+        task name => "#{name}:default"
+      end
+    end
+
+    class Runner
+      def initialize &block
+        @app = RackApp.new(&block).to_app
+        @port = 9999
+      end
+
+      attr_reader :app, :server
+      attr_accessor :port
+
+      def passed?
+        @passed
+      end
+
+      def run
+        start_server
+        start_phantomjs
+
+        exit 1 unless passed?
+      rescue => e
+        puts e.message
+      ensure
+        stop_server if server
+      end
+
+      def stop_server
+        server.kill
+      end
+
+      require 'opal/util'
+      class PhantomJS < ::Opal::Util::Command
+        require 'shellwords'
+
+        def initialize(runner, url)
+          runner = runner.shellescape
+          url    = url.shellescape
+          super 'phantomjs', "#{runner} #{url}", '. Please install PhantomJS'
+        end
+
+        def run
+          system "#{command} #{options}"
+        end
+      end
+
+      def start_phantomjs
+        runner  = File.expand_path('../sprockets.js', __FILE__).shellescape
+        url     = "http://localhost:#{port}/".shellescape
+        command = PhantomJS.new(runner, url)
+        @passed = command.run
+      end
+
+      def start_server
+        @server = Thread.new do
+          Rack::Server.start(:app => app, :Port => port, :AccessLog => [],
+            :Logger => WEBrick::Log.new("/dev/null"))
+        end
+      end
+    end
+
+    class Environment < ::Opal::Environment
+      attr_reader :basedir, :pattern
+
+      def initialize(basedir = nil, pattern = nil)
+        ::Opal::Processor.arity_check_enabled = true
+        ::Opal::Processor.dynamic_require_severity = :error
+
+        @pattern = pattern
+        @basedir = basedir = File.expand_path(basedir || DEFAULT_BASEDIR)
+
+        ::Opal.append_path basedir
+        ::Opal.use_gem 'mspec'
+
+        stubs.each do |asset|
+          ::Opal::Processor.stub_file asset
+        end
+
+        ENV['OPAL_SPEC'] ||= files_to_run(pattern).join(',')
+
+        super()
+      end
+
+      def stubs
+        # missing stdlib
+        stubs = %w[fileutils iconv yaml]
+
+        # use x-strings which generate bad javascript
+        stubs << "mspec/helpers/tmp"
+        stubs << "mspec/helpers/environment"
+        stubs << "mspec/guards/block_device"
+        stubs << "mspec/guards/endian"
+
+        stubs
+      end
+
+      def specs
+        @specs ||= self['mspec/opal/main'] || raise("Cannot find mspec/opal/main inside #{paths.inspect}")
+      end
+
+      def build_min file = "#{basedir}/build/specs.min.js"
+        require 'opal/util'
+        build ::Opal::Util.uglify(specs.to_s), file
+      end
+
+      def files
+        @files ||= []
+      end
+
+      def add_files specs, tag = ''
+        tag = "[#{tag}] "
+        puts "#{tag}Adding #{specs.size} spec files..."
+        specs = specs.flatten.map do |path|
+          dirname = File.join([basedir, path])
+          if File.directory? dirname
+            rubyspec_paths_in_dir(dirname, path)
+          else
+            path
+          end
+        end.flatten
+        files.concat specs
+      end
+
+      def paths_from_glob pattern
+        Dir.glob(File.expand_path(pattern)).map do |s|
+          s.sub(/^#{basedir}\//, '').sub(/\.rb$/, '')
+        end
+      end
+
+      def rubyspec_paths_in_dir(dirname, path)
+        Dir.entries(dirname).select do |spec|
+          spec.end_with? '.rb'
+        end.map do |spec|
+          File.join path, spec
+        end
+      end
+
+      def rubyspec_white_list
+        File.read("#{basedir}/rubyspecs").split("\n").reject do |line|
+          line.sub(/#.*/, '').strip.empty?
+        end
+      end
+
+      def files_to_run(pattern=nil)
+        # add any filters in spec/filters of specs we dont want to run
+        add_files paths_from_glob("#{basedir}/filters/**/*.rb"), :filters
+
+        if pattern
+          # add custom opal specs from spec/
+          add_files paths_from_glob(pattern) & rubyspec_white_list, :rubyspec_custom_pattern
+          add_files paths_from_glob(pattern).grep(/(?!spec\/(corelib|stdlib)\/)/), :other_custom_pattern
+
+        else
+          # add opal specific specs
+          add_files paths_from_glob("#{basedir}/opal/**/*_spec.rb"), 'opal/*'
+          add_files paths_from_glob("#{basedir}/lib/{lexer_spec.rb,parser/**/*_spec.rb}"), 'lib/{lexer,parser}'
+
+          # add any rubyspecs we want to run (defined in spec/rubyspecs)
+          add_files rubyspec_white_list, :rubyspec_white_list
+        end
+      end
+
+      def build_specs file = "#{basedir}/build/specs.js"
+        code = specs.to_s
+        FileUtils.mkdir_p File.dirname(file)
+        puts "Building #{file}..."
+        File.open(file, 'w+') { |o| o << code }
+      end
+    end
+
+    class RackApp < Rack::Builder
+      attr_accessor :pattern, :basedir
+
+      def initialize
+        self.pattern = nil
+        self.basedir = DEFAULT_BASEDIR
+
+        yield(self) if block_given?
+        super()
+
+        use Rack::ShowExceptions
+        use Rack::ShowStatus
+        use Index
+        run environment
+      end
+
+      def environment
+        @environment ||= Environment.new(basedir, pattern)
+      end
+    end
+
+    class Index
+      HTML = <<-HTML
+      <!DOCTYPE html>
+      <html>
+        <head>
+          <meta charset="UTF-8" />
+          <title>Opal Specs</title>
+        </head>
+        <body>
+          <script src="/mspec/opal/main.js"></script>
+        </body>
+      </html>
+      HTML
+
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        if %w[/ /index.html].include? env['PATH_INFO']
+          [200, { 'Content-Type' => 'text/html' }, [HTML]]
+        else
+          @app.call env
+        end
+      end
+    end
+
+  end
+end