opal 0.3.11 → 0.3.15

data/lib/opal.rb

@@ -1,20 +1,19 @@
-require "opal/parser"
-require "opal/builder"
-require "opal/context"
-require "opal/version"
+require 'opal/parser/parser'
+require 'opal/builder'
+require 'opal/dependency_builder'
+require 'opal/context'
+require 'opal/version'
 
-# Opal is a set of build tools and runtime utilies for compiling ruby
-# source code into javascript. Opal can use therubyracer to provide a
-# ruby context for evaluating the generated javascript against the
-# provided runtime.
 module Opal
-  # Root opal directory (root of gem)
-  OPAL_DIR = File.expand_path('../..', __FILE__)
+  def self.opal_dir
+    File.expand_path '../..', __FILE__
+  end
 
-  # Full path to our opal.js runtime file
-  OPAL_JS_PATH = File.join OPAL_DIR, "opal.js"
+  def self.runtime_code
+    File.read File.join(opal_dir, 'opal.js')
+  end
 
-  # Full path to our opal-parser.js parser file
-  OPAL_PARSER_JS_PATH = File.join OPAL_DIR, "opal-parser.js"
+  def self.runtime_debug_code
+    File.read File.join(opal_dir, 'opal.debug.js')
+  end
 end
-

data/lib/opal/builder.rb

@@ -1,177 +1,75 @@
 require 'fileutils'
-require 'opal/parser'
-require 'opal/version'
 
 module Opal
-  # The Builder class is used for building single ruby sources, or
-  # building the core library ready for the browser/v8 context. It
-  # is not used directly for building gem.
   class Builder
+    def initialize(sources, options = {})
+      @sources = Array(sources)
+      @options = options
 
-    OPAL_PATH = File.expand_path(File.join('..', '..', '..'), __FILE__)
-
-    STDLIB_PATH = File.join OPAL_PATH, 'stdlib'
-
-    def initialize
-      @parser = Parser.new
-    end
-
-    def parse(source, options = {})
-      @parser.parse source, options
-    end
-
-    # Returns the result of the compiled file ready for opal to load.
-    #
-    # `relative_path` is used for the name the built file should have.
-    # This is used for building a singular rb or js file into the
-    # compiled output, and will avoid the user's dir setup being exposed
-    # in production code. It will be of the form
-    # `lib/some_lib/some_lib.rb`
-    #
-    # @param [String] full_path The full pathname to the file to build
-    # @paeam [String] relative_path The pathname to be used in the build
-    # file.
-    #
-    # @return [String]
-    def wrap_source(full_path, relative_path = nil)
-      relative_path ||= full_path
-      ext = File.extname full_path
-      # relative_path = relative_path.sub(/\.rb/, '.js') if ext == '.rb'
-      content = compile_source full_path
-
-      "opal.lib('#{relative_path}', #{content});\n"
+      @options[:out] = '.' if @options[:out] == '' or !@options[:out]
     end
 
-    # Simply compile the given source code at the given path. This is
-    # for compiling ruby or javascript sources only. This can be used
-    # for any method that builds for the browser.
-    #
-    # @param [String] full_path location of the source to build
-    # @return [String] compiled source
-    def compile_source(full_path)
-      ext = File.extname full_path
-      src = File.read full_path
+    def build
+      @parser     = Parser.new @options
+      @factories  = {}
 
-      case ext
-      when '.js'
-        "function($rb, self, __FILE__) { #{src} }"
+      @sources.each { |s| build_source '.', s }
 
-      when '.rb'
-        return parse src
-
-      else
-        raise "Bad file type for wrapping. Must be ruby or javascript"
-      end
-    end
-
-    # Build the given sources from the standard library. These can be
-    # globs. Returns a string of all content.
-    def build_stdlib(*files)
-      code = []
-      Dir.chdir(STDLIB_PATH) do
-        files.each do |file|
-          lib = Dir[file + '.rb']
-          full_path = File.join STDLIB_PATH, lib.first
-          code << wrap_source(full_path, file)
+      if @options[:join]
+        File.open(@options[:join], 'w+') do |o|
+          @factories.each { |path, factory| o.write factory }
         end
       end
-
-      code.join ''
     end
 
-    # Takes a hash of build options.
-    #
-    # :project_dir - The base directory to work in. If not given then cwd is used.
-    #
-    # :files - May be a single source, a directory, or an array of ruby/js src
-    #
-    # :out - The output file. All sources are built into a single output file.
-    # If this is not given, it will default to project_dir/javascripts/name.js
-    # where name is the basename of the given project_dir or cwd.
-    #
-    # :main - only useful when more than one input is given to determine which
-    # file is automatically loaded on running in the browser.
-    #
-    # :watch - watch all sources and automatically recompile if one changes
-    #
-    # :pre - pre content to add. Could be copyright, or extra code etc
-    #
-    # :post - post content.. could be extra code etc
-    #
-    # Also, if no output is given, then one file will be used for all sources,
-    # and the files name will be taken as the basename of the root_dir/cwd.
-    #
-    # @param {Hash} options Build options to use
-    def build(options = {})
-      files = options[:files] || []
-      files = [files] unless files.is_a? Array
-      options[:files] = files = Dir.[](*files)
-
-      raise "Opal::Builder - No input files could be found" if files.empty?
+    def build_source(base, source)
+      path = base == '.' ? source : File.join(base, source)
 
-      main = options[:main]
+      if File.directory? path
+        Dir.entries(path).each do |e|
+          next if e == '.' or e == '..'
+          build_source path, e
+        end
 
-      if main == true
-        options[:main] = files.first
-      elsif main
-        raise "Opal::Builder - Main file does not exist!" unless File.exists? main
-        files << main unless files.include? main
-      elsif main == false
-        options[:main] = false
-      else
-        options[:main] = files.first
+      elsif File.extname(path) == '.rb'
+        build_file base, source
       end
+    end
 
-      main = options[:main]
+    def build_file(base, source)
+      path  = base == '.' ? source : File.join(base, source)
+      code  = @parser.parse File.read(path), path
 
-      unless options[:out]
-        options[:out] = main.sub /\.rb$/, '.js'
+      if /^lib/ =~ path
+        code = "opal.lib('#{path[4..-4]}', function() {\n#{code}\n});\n"
+      else
+        code = "opal.file('/#{path}', function() {\n#{code}\n});\n"
       end
 
-      FileUtils.mkdir_p File.dirname(options[:out])
+      if @options[:join]
+        @factories[path] = code
+      elsif @options[:out]
+        out = output_path base, source
 
-      rebuild options
-      if options[:watch]
-        puts "Watching for changes.."
-        loop do
-          out_mtime = File.stat(options[:out]).mtime
-          options[:files].each do |file|
-            if File.stat(file).mtime > out_mtime
-              puts "#{Time.now} rebuilding - changes detected in #{file}"
-              rebuild options
-            end
-          end
-
-          begin
-            sleep 1
-          rescue Interrupt
-            exit 0
-          end
-        end
+        FileUtils.mkdir_p File.dirname(out)
+        File.open(out, 'w+') { |o| o.write code }
       end
     end
 
-    private
-
-    # Does the actual rebuild of a project
-    def rebuild(options)
-      puts "rebuilding to #{options[:out]}"
-      puts options[:files].inspect
-      File.open(options[:out], 'w') do |out|
-        # out.write @pre if @pre
-
-        options[:files].each do |file|
-          out.write wrap_source file
-        end
-
-        if options[:main]
-          main = options[:main].sub(/\.rb$/, '')
-          out.write "opal.require('#{main}');\n"
+    def output_path(base, source)
+      fname = source.chomp('.rb') + '.js'
+      if @options[:out] == '.'
+        base == '.' ? fname : File.join(base, fname)
+      else
+        if base == '.'
+          File.join @options[:out], fname
+        else
+          parts = base.split '/'
+          parts[0] = @options[:out]
+          parts << fname
+          File.join *parts
         end
-
-        # out.write @post if @post
       end
     end
   end
 end
-

data/lib/opal/command.rb

@@ -1,143 +1,73 @@
 require 'optparse'
 require 'fileutils'
 require 'opal/builder'
+require 'opal/version'
 
 module Opal
-  # Command runner. When using the `opal` bin file, this class is used to
-  # delegate commands based on the options passed from the command line.
   class Command
 
-    # Valid command line arguments
-    COMMANDS = [:help, :irb, :compile, :bundle, :exec, :eval, :install, :init]
-
     def initialize(args)
-      command = args.shift
-
-      if command and COMMANDS.include?(command.to_sym)
-        __send__ command.to_sym
-      elsif command and File.exists? command
-        eval command
-      else
-        help
+      options = {}
+      if ARGV.first == 'init'
+        options[:init] = true
+        ARGV.shift
       end
-    end
-
-    # Initialize a project either in current directory, or directory
-    # specified in ARGV.
-    def init
-      path = File.expand_path(ARGV.first || Dir.getwd)
-      base = File.basename(path)
-      template = File.join(OPAL_DIR, "templates", "init")
-
-      Dir.chdir(template) do
-        Dir["**/*"].each do |f|
-          next if File.directory? f
-
-          full = File.expand_path f, template
-          dest = File.join path, f.sub(/__NAME__/, base)
 
-          if File.exists? dest
-            puts "Skipping #{f}"
-            next
-          end
-
-          FileUtils.mkdir_p File.dirname(dest)
-
-          File.open(dest, 'w+') do |o|
-            o.write File.read(full).gsub(/__NAME__/, base)
-          end
+      OptionParser.new do |opts|
+        opts.on('-c', '--compile', 'Compile ruby') do |c|
+          options[:compile] = c
         end
-      end
 
-      FileUtils.mkdir_p File.join(path, "js")
-
-      %w[opal.js opal-parser.js].each do |src|
-        File.open(File.join(path, "js", src), "w+") do |o|
-          o.write File.read(File.join(OPAL_DIR, src))
+        opts.on('-o', '--out [DIR]', 'Output directory') do |o|
+          options[:out] = o || ''
         end
-      end
-    end
 
-    def help
-      puts "need to print help"
-    end
+        opts.on('-j', '--join [OUT]', 'Join out') do |j|
+          options[:join] = j || ''
+        end
 
-    # Starts an irb session using an inline v8 context. Commands can be
-    # entered just like IRB. Use Ctrl-C or type `exit` to quit.
-    def irb(*)
-      ctx = Context.new :method_missing      => true,
-                        :overload_arithmetic => true,
-                        :overload_comparison => true,
-                        :overload_bitwise    => true
-      ctx.start_repl
-    end
+        opts.on('-d', '--debug', 'Debug mode') do |d|
+          options[:debug] = true
+        end
 
-    # If the given arg exists as a file, then the source code is compiled
-    # and then run through a javascript context and the result printed out.
-    #
-    # If the arg isn't a file, then it is assumed to be raw ruby code and it
-    # is compiled and run directly with the result being printed out.
-    #
-    # Usage:
-    #
-    #   opal eval path/to/some/file.rb
-    #   # => "some result"
-    #
-    #   opal eval "1.class"
-    #   # => Numeric
-    #
-    # @param [String] code path or ruby code to eval
-    def eval(code = nil, *)
-      abort "Usage: opal eval [Ruby code or file path]" unless code
+        opts.on_tail("-v", "--version", "Show version") do
+          puts Opal::VERSION
+          exit
+        end
+      end.parse!
 
-      if File.exists? code
-        code = Parser.new.parse File.read(code)
+      if options[:init]
+        init options
+      elsif options[:compile]
+        build options
+      else
+        run options
       end
-
-      context = Context.new :method_missing      => true,
-                            :overload_arithmetic => true,
-                            :overload_comparison => true,
-                            :overload_bitwise    => true
-
-      puts context.eval code
     end
 
-    # If the given path exists, then compiles the source code of that
-    # file and spits out the generated javascript.
-    #
-    # If this file does not exist, then assumes the input is ruby code
-    # to compile and return.
-    #
-    # Usage:
-    #
-    #   opal compile path/to/ruby.rb
-    #   # => "generated code"
-    #
-    #   opal compile "some ruby code"
-    #   # => generated code
-    #
-    # @param [String] path file path or ruby code
-    def compile(path = nil, *)
-      abort "Usage: opal compile [Ruby code or file path]" unless path
-
-      if File.exists? path
-        puts Parser.new.parse File.read(path)
+    def run(options)
+      if ARGV.empty?
+        Context.new.start_repl
+      elsif File.exists? ARGV.first
+        Context.runner ARGV.first
       else
-        puts Parser.new.parse path
+        puts "#{ARGV.first} does not exist"
       end
     end
 
-    # Bundle the gem (browserify) ready for the browser
-    def bundle(*)
-      # lazy load incase user does not have rbp installed
-      require 'opal/bundle'
+    def init(options)
+      out   = options[:out]
+      src   = options[:debug] ? Opal.runtime_debug_code : Opal.runtime_code
+      out ||= (options[:debug] ? 'opal.debug.js' : 'opal.js')
 
-      path    = File.join Dir.getwd, 'package.yml'
-      package = Rbp::Package.load_path path
-      bundle  = Bundle.new package
+      FileUtils.mkdir_p File.dirname(out)
+      File.open(out, 'w+') { |o| o.write src }
 
-      puts bundle.build
+      puts "Wrote Opal to #{out}#{options[:debug] && ' (debug)'}"
     end
-  end
-end
 
+    def build(options)
+      Builder.new(ARGV, options).build
+    end
+  end # Command
+end

data/lib/opal/context.rb

@@ -1,30 +1,38 @@
+require 'opal/environment'
+
 module Opal
   class Context
-    # Options are mainly just passed onto the builder/parser.
-    def initialize(options = {})
-      @options      = options
-      @root_dir     = options[:dir] || Dir.getwd
-      @builder      = Opal::Builder.new
-      @loaded_paths = false
 
-      setup_v8
-    end
+    attr_reader :v8
+    attr_reader :parser
+    attr_reader :environment
 
     ##
-    # Require the given id as if it was required in the context. This simply
-    # passes the require through to the underlying context.
+    # Glob may be a file or glob path, as a string.
 
-    def require_file(path)
-      setup_v8
-      @v8.eval "opal.run(function() {opal.require('#{path}');});", path
-      finish
+    def self.runner(glob)
+      ctx = self.new
+      ctx.v8['opal_tmp_glob'] = Dir[glob]
+
+      runner = <<-CODE
+        files = `opal_tmp_glob`
+
+        files.each do |a|
+          require a
+        end
+      CODE
+
+      ctx.eval_irb runner, '(runner)'
+      ctx.finish
     end
 
-    # Set ARGV for the context.
-    # @param [Array<String>] args
-    def argv=(args)
-      puts "setting argv to #{args.inspect}"
-      @v8.eval "opal.runtime.cs(opal.runtime.Object, 'ARGV', #{args.inspect});"
+    def initialize root = Dir.getwd
+      @environment  = Environment.load root
+      @root         = root
+      @parser       = Opal::Parser.new :debug => true
+      @loaded_paths = false
+
+      setup_v8
     end
 
     # Start normal js repl
@@ -42,18 +50,33 @@ module Opal
           break
         end
 
-        puts "=> #{eval line, '(opal)'}"
+        puts "=> #{eval_irb line, '(irb)'}"
       end
 
       finish
     end
 
-    def eval(content, file = "(opal)", line = "")
-      js = @builder.parse content, @options
-      code =  "opal.run(function() { var result = (#{js})(opal.runtime, "
-      code += "opal.runtime.top, '(opal)'); if (result == null || !result"
-      code += ".m$inspect) { return '(Object does not support #inspect)'; }"
-      code += "else { return result.m$inspect() } });"
+    def eval_builder(content, file)
+      @parser.parse content, file
+    end
+
+    def eval(content, file = "(irb)", line = "")
+      @v8.eval eval_builder(content, file), file
+    end
+
+    def eval_irb(content, file = '(irb)')
+      code = <<-CODE
+        (function() { try {
+          opal.FILE = '#{file}';
+          var res = #{ eval_builder content, file };
+          return res.m$inspect();
+         }
+         catch (e) {
+           opal.bt(e);
+           return "nil";
+         }
+        })()
+      CODE
 
       @v8.eval code, file
     end
@@ -64,7 +87,7 @@ module Opal
     # #setup_v8
     def finish
       return unless @v8
-      @v8.eval "opal.runtime.do_at_exit()", "(opal)"
+      @v8.eval "opal.do_at_exit()", "(irb)"
 
       @v8 = nil
     end
@@ -83,13 +106,30 @@ module Opal
 
       @v8 = V8::Context.new
       @v8['console'] = Console.new
+      @v8['opal_filesystem'] = FileSystem.new(self)
+
+      load_runtime
+      load_gem_runtime
+    end
 
-      @v8.eval File.read(OPAL_JS_PATH), "(opal)"
-      opal = @v8['opal']
-      opal['fs'] = FileSystem.new self
+    ##
+    # Loads the runtime from build/*.js. This isnt included in the git repo,
+    # so needs to be built before running (gems should have these files included)
+
+    def load_runtime
+      @v8.eval Opal.runtime_debug_code, '(runtime)'
+    end
 
-      # FIXME: we cant use a ruby array as a js array :(
-      opal['loader'] = Loader.new self, @v8.eval("[]")
+    ##
+    # Load gem specific runtime.
+
+    def load_gem_runtime
+      dir = File.join Opal.opal_dir, 'runtime', 'gemlib'
+      order = File.read(File.join dir, 'load_order').strip.split("\n")
+      order.each do |f|
+        path = File.join dir, "#{f}.rb"
+        eval File.read(path), path
+      end
     end
 
     ##
@@ -110,78 +150,99 @@ module Opal
 
     class FileSystem
 
-      def initialize(context)
-        @context = context
+      def initialize context
+        @context     = context
+        @environment = context.environment
+        @cache       = {}
       end
 
-      def cwd
-        Dir.getwd
-      end
+      ##
+      # Used to bootstrap loadpaths.
 
-      def glob(*arr)
-        Dir.glob arr
-      end
+      def find_paths
+        return @paths if @paths
 
-      def exist_p(path)
-        File.exist? path
-      end
+        paths = [File.join(Opal.opal_dir, 'runtime', 'stdlib')]
 
-      def expand_path(filename, dir_string = nil)
-        File.expand_path filename, dir_string
-      end
+        @environment.require_paths.each do |p|
+          paths << File.join(@environment.root, p)
+        end
 
-      def dirname(file)
-        File.dirname file
-      end
+        @environment.specs.each do |spec|
+          paths.push *spec.load_paths
+        end
 
-      def join(*parts)
-        File.join *parts
+        @paths = @context.v8.eval paths.inspect
       end
-    end
 
-    # Loader for v8 context
-    class Loader
+      ##
+      # Require a file from context
 
-      attr_reader :paths
+      def require path, paths
+        resolved = find_lib path, paths
 
-      def initialize(context, paths)
-        @context = context
-        @paths = paths
-      end
+        return nil unless resolved
+
+        return false if @cache[resolved]
 
-      def resolve_lib(id)
-        resolved = find_lib id
-        raise "Cannot find lib `#{id}'" unless resolved
+        @cache[resolved] = true
+        @context.v8.eval "opal.FILE = '#{resolved}'"
+        @context.eval File.read(resolved), resolved
 
-        resolved
+        true
       end
 
-      def find_lib(id)
-        @paths.each do |path|
-          candidate = File.join path, "#{id}.rb"
+      def find_lib path, paths
+        paths.each do |l|
+          candidate = File.join l, "#{path}.rb"
           return candidate if File.exists? candidate
 
-          candidate = File.join path, id
+          candidate = File.join l, path
           return candidate if File.exists? candidate
-        end
 
-        return File.expand_path id if File.exists? id
-        return File.expand_path(id + '.rb') if File.exists?(id + '.rb')
+          candidate = File.expand_path path
+          return candidate if File.exists? candidate
+
+          candidate = File.expand_path("#{path}.rb")
+          return candidate if File.exists? candidate
+        end
 
         nil
       end
 
-      def ruby_file_contents(filename)
-        Opal::Parser.new.parse File.read(filename)
+      ##
+      # Build body for given ruby file. Should return a function
+      # capable of being executed by opal of form:
+      #
+      #     function(self, FILE) { ... }
+
+      def file_body(path)
+        @context.eval File.read(path), path
       end
 
-      def wrap(content, filename)
-        code = "(function($rb, self, __FILE__) { #{content} });"
-        @context.eval code, filename
-        # code
+      def cwd
+        Dir.getwd
       end
-    end
 
+      def glob(*arr)
+        Dir.glob arr
+      end
+
+      def exist_p(path)
+        File.exist? path
+      end
+
+      def expand_path(filename, dir_string = nil)
+        File.expand_path filename, dir_string
+      end
+
+      def dirname(file)
+        File.dirname file
+      end
+
+      def join(*parts)
+        File.join *parts
+      end
+    end # FileSystem
   end
 end
-