opal-wedge 0.9.0.dev

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
+
+# RUBYOPT="-rbundler/setup -rmspec/opal/special_calls" bundle exec mspec run -t opal -pspec/rubyspec/spec_helper spec/rubyspec/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 'opal-repl depends on therubyracer gem, which is not currently 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 = :error
+
+use Rack::ShowExceptions
+use Rack::ShowStatus
+use MSpec::Opal::Index
+run MSpec::Opal::Environment.new
+
+

data/docs/compiler_directives.md

@@ -0,0 +1,127 @@
+# @title Compiler Directives
+
+# Compiler Directives
+
+The Opal compiler supports some special directives that can optimize or
+enhance the output of compiled Ruby code to suit the Ruby environment.
+
+## Require Directive
+
+All calls to `require` are captured so that the compiler and build tools
+can determine which dependencies a file has. In the case of `Builder`,
+these are collated and then added to a list of files to be processed.
+
+### `require`
+
+Assuming we have a file `foo.rb`:
+
+    # foo.rb
+    require 'bar'
+    require 'baz'
+
+The compiler will collect these two dependencies, and then `Builder`
+will attempt to discover them within the Opal load path to also compile
+them into the target output. If these dependencies cannot be resolved,
+then a compile time error will be thrown.
+
+#### Dynamic Requires
+
+Opal only supports hard-coded requires. This means that any dynamically
+generated require statements cannot be discovered. Opal may raise an
+error or just produce a warning if a dynamic require is used. A dynamic
+require is any require that cannot be resolved using static analysis. A
+common use case of dynamic requires is to include a directory of Ruby
+files. In this case, see `require_tree` below.
+
+### `require_relative`
+
+`require_relative` is also supported by Opal's compiler for ahead-of-time
+inclusion.
+
+    # foo.rb
+    require_relative 'bar'
+
+This example will try to resolve `bar.rb` in the same directory.
+
+### `autoload`
+
+`autoload` is used to load a modules and classes within a modules
+namespace. As long as the string argument given to `autoload` can be
+resolved in Opal's load paths, in the same way as `require`, then these
+referenced dependencies will also be compiled.
+
+    # foo.rb
+    module Foo
+      autoload :Bar, 'bar'
+    end
+
+In this example, `bar.rb` will also be required.
+
+### `require_tree`
+
+`require_tree` can be used as an Opal-friendly alternative to globbing
+over a directory to require a list of dependencies.
+
+    # foo.rb
+    require_tree './models'
+
+This will, at compile time, resolve all files inside the `models/`
+directory and also compile them to the output. At runtime this method
+will then loop over all modules defined, and require them if they match
+that given module path.
+
+Note: The given directory **must** be inside Opal's load path, otherwise
+no files will be compiled.
+
+### Handling non-Ruby requirements
+
+Opal's `require` method is also special as it allows non-Ruby source
+files to be required and generated in the output. The obvious example of
+this is requiring JavaScript source files. JavaScript sources are
+treated as first class citizens in Opal. The Opal gem also supports
+compiling `.erb` files using the same process.
+
+## Opal Specific Code Compilation
+
+A special case `if` and `unless` statements can hide or show blocks of
+code from the Opal compiler. These check against `RUBY_ENGINE` or
+`RUBY_PLATFORM`. As these are valid Ruby statements against constants
+that exist in all Ruby runtimes, they will not affect any running code:
+
+    if RUBY_ENGINE == 'opal'
+      # this code compiles
+    else
+      # this code never compiles
+    end
+
+Unless statements are also supported:
+
+    unless RUBY_ENGINE == 'opal'
+      # this code will not run
+    end
+
+Also `!=` statements work:
+
+    if RUBY_ENGINE != 'opal'
+      puts 'do not run this code'
+    end
+
+These blocks of code don't run at all at runtime, but they also never
+compile so will never be in the output JavaScript code. This is
+particularly useful for using code in both MRI and Opal.
+
+Some uses are:
+
+  * Avoid `require` statements being picked up by Opal compile time
+    require handling.
+
+  * To stop certain requires taking place for Opal (and vice-versa for
+    shared libraries).
+
+  * To wrap x-strings which might break in compiled JavaScript output.
+
+  * To simply avoid compiling large blocks of code that are not needed
+    in the JavaScript/Opal version of an app.
+
+In all these examples `RUBY_PLATFORM` can be used instead of
+`RUBY_ENGINE`.

data/examples/rack/.gitignore

@@ -0,0 +1 @@
+tmp

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,22 @@
+class User
+  def initialize(name)
+    puts "wow"
+    @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,20 @@
+require 'bundler'
+Bundler.require
+
+# Instructions: bundle in this directory
+# then run bundle exec rackup to start the server
+# and browse to localhost:9292
+
+# a very small application that just tries to authenticate a user and fails
+# it just writes to the console in the browser (no visible html)
+
+# with gems like opal-jquery or opal-browser you could manipulate the dom directly
+
+run Opal::Server.new { |s|
+  # the name of the ruby file to load. To use more files they must be required from here (see app)
+  s.main = 'application'
+  # the directory where the code is (add to opal load path )
+  s.append_path 'app'
+  # need to set the index explicitly for opal server to pick it up
+  s.index_path = 'index.html.erb'
+}

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,5 @@
+source 'https://rubygems.org'
+
+gem 'opal', :path => '../..'
+gem 'thin' # webrick has a bug with safari
+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,38 @@
+require 'opal'
+require 'sinatra'
+
+opal = Opal::Server.new {|s|
+  s.append_path 'app'
+  s.main = 'application'
+}
+
+sprockets   = opal.sprockets
+maps_prefix = '/__OPAL_SOURCE_MAPS__'
+maps_app    = Opal::SourceMapServer.new(sprockets, maps_prefix)
+
+# Monkeypatch sourcemap header support into sprockets
+::Opal::Sprockets::SourceMapHeaderPatch.inject!(maps_prefix)
+
+map maps_prefix do
+  run maps_app
+end
+
+map '/assets' do
+  run sprockets
+end
+
+get '/' do
+  opal_boot_code = Opal::Processor.load_asset_code(sprockets, 'application')
+
+  <<-HTML
+    <!doctype html>
+    <html>
+      <head>
+        <script src="/assets/application.js"></script>
+        <script>#{opal_boot_code}</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