opal 0.3.2 → 0.3.6

data/opal_lib/opal/bundle.rb

@@ -0,0 +1,70 @@
+require 'opal/build_methods'
+
+module Opal
+
+  class Bundle
+    include BuildMethods
+
+    attr_reader :gem
+
+    def initialize(gem)
+      @gem = gem
+    end
+
+    def wrap_source(full_path, relative_path = nil)
+      relative_path ||= full_path
+      content = compile_source full_path
+      "'#{relative_path}': #{content}\n"
+    end
+
+    # Actually build the bundle. Returns the result, for now, as a string.
+    #
+    # @return {String} bundled packages
+    def build(options = {})
+      gem = @gem
+      if options[:test]
+        result = build_test_files
+      else
+        result = build_lib_files
+      end
+
+      if options[:out]
+        FileUtils.mkdir_p File.dirname(options[:out])
+        File.open(options[:out], 'w+') { |o| o.write result }
+      else
+        result
+      end
+    end
+
+    def build_lib_files
+      files = @gem.lib_files
+
+      bundle = []
+      bundle << %[opal.register("#{gem.name}", {]
+      bundle << %[  "name": #{gem.name.inspect},]
+      bundle << %[  "version": #{gem.version.inspect},]
+      bundle << %[  "require_paths": #{gem.require_paths.inspect},]
+      bundle << %[  "files": {]
+      bundle << %[    #{files.map { |f| wrap_source f }.join(",\n    ")}]
+      bundle << %[  }]
+      bundle << %[});]
+
+      result = bundle.join ''
+    end
+
+    def build_test_files
+      files = @gem.test_files
+
+      bundle = []
+      bundle << %[opal.register("#{gem.name}", {]
+      bundle << %[  "name": #{gem.name.inspect},]
+      bundle << %[  "files": {]
+      bundle << %[    #{files.map { |f| wrap_source f }.join(",\n    ")}]
+      bundle << %[  }]
+      bundle << %[});]
+
+      result = bundle.join ''
+    end
+  end
+end
+

data/opal_lib/opal/command.rb

@@ -0,0 +1,68 @@
+module Opal
+  class Command < Thor
+
+    desc "irb", "Opens interactive opal/ruby repl"
+    def irb
+      require 'opal/context'
+      ctx = Opal::Context.new
+      ctx.start_repl
+    end
+
+    desc "spec [FILENAME]", "ospec runner"
+    long_desc %[
+      This will run the ospec gem in the current working directory
+      to load the given specs. If no input files are given then
+      ospec will run all specs it can find in the spec/ dir.
+    ]
+    def spec(*specs)
+      require 'opal/context'
+
+      argv = specs
+
+      ctx = Opal::Context.new
+      ctx.argv = argv
+      ctx.require_file 'ospec/autorun'
+    end
+
+    desc "compile [FILE]", "Compile and puts compiled code to stdout"
+    long_desc %[
+      Basically compile the given file, and output it to the
+      stdout. This is useful for testing the compiler to see
+      what the generated code will be. If the str name is a
+      file that exists, it will be read, otherwise the
+      content will be run as a string.
+    ]
+    method_options :out => :string, :watch => :boolean, :main => :string
+    def compile(*path)
+      opts = options
+      builder = Builder.new
+      builder.build :files => path,
+        :out => opts["out"], :watch => opts["watch"], :main => opts["main"]
+    end
+
+    desc "bundle", "Bundle the gem in the given directory ready for browser"
+    method_options :out => :string
+    def bundle
+      opts = options
+      bundle = Opal::Bundle.new(Opal::Gem.new(Dir.getwd))
+      bundle.build opts
+    end
+
+    desc "exec [FILENAME]", "Run the given ruby file"
+    def exec(file)
+      puts "need to run #{file.inspect}"
+      require 'opal/context'
+      ctx = Opal::Context.new
+      ctx.require_file file
+    end
+
+    def method_missing(task, *)
+      if File.exist? task.to_s
+        exec task.to_s
+      else
+        super
+      end
+    end
+  end
+end
+

data/{lib → opal_lib}/opal/context.rb

@@ -15,8 +15,11 @@ require 'opal/context/file_system'
 module Opal
   class Context < V8::Context
 
+    RUNTIME_PATH = File.expand_path File.join('..', '..', '..', 'runtime.js'), __FILE__
+
     def initialize(opts = {})
       super opts
+      @builder = Opal::Builder.new
       setup_context
     end
 
@@ -25,19 +28,28 @@ module Opal
     # default "browser" loader cannot access files from disk.
     def setup_context
       self['console'] = Console.new
-      load opal_js_path
+      eval "OPAL_DEBUG = true;", "(opal)"
+      eval @builder.build_runtime, "(opal)"
 
       opal = self['opal']
       opal['loader'] = Loader.new opal, self
-      # opal['fs'] = FileSystem.new opal, self
+      opal['fs'] = FileSystem.new opal, self
+      opal['platform']['engine'] = 'opal-gem'
+
+      # eval "opal.require('core');", "(opal)"
+      require_file 'core'
+    end
 
-      eval "opal.require('core');", "(opal)"
+    # Require the given id as if it was required in the context. This simply
+    # passes the require through to the underlying context.
+    def require_file(path)
+      eval "opal.require('#{path}');", "(opal)"
     end
 
-    # Returns the path to our main opal.js file. This makes it easier as
-    # we will likely require this file more than once (once per context).
-    def opal_js_path
-      File.expand_path File.join(File.dirname(__FILE__), '..', '..', 'lib', 'opal.js')
+    # Set ARGV for the context
+    def argv=(args)
+      puts "setting argv to #{args.inspect}"
+      eval "opal.runtime.cs(opal.runtime.Object, 'ARGV', #{args.inspect});"
     end
 
     # Start normal js repl
@@ -53,11 +65,11 @@ module Opal
     def eval_ruby(content, line = "")
       begin
         code = Opal::RubyParser.new(content).parse!.generate_top
-        code = "var VM = opal.vm, self = VM.top, __FILE__ = '(opal)';" + code
+        code = "opal.run(function() {var $rb = opal.runtime, self = $rb.top, __FILE__ = '(opal)';" + code + "});"
         # puts code
         self['$opal_irb_result'] = eval code, line
         # self['$code'].to_s + "ww"
-        eval "$opal_irb_result.$m.inspect($opal_irb_result);"
+        eval "!$opal_irb_result.$m.inspect.$rbMM ? $opal_irb_result.$m.inspect($opal_irb_result) : '(Object doesnt support #inspect)'"
       rescue => e
         puts e
         puts("\t" + e.backtrace.join("\n\t"))

data/{lib → opal_lib}/opal/context/console.rb

@@ -1,6 +1,4 @@
-
 module Opal
-
   class Console
 
     def log(*str)

data/opal_lib/opal/context/file_system.rb

@@ -0,0 +1,34 @@
+module Opal
+  class FileSystem
+
+    def initialize(opal, context)
+      @opal = opal
+      @ctx = context
+    end
+
+    def cwd
+      Dir.getwd
+    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
+end
+

data/{lib → opal_lib}/opal/context/loader.rb

@@ -1,6 +1,6 @@
 
 module Opal
-  # Custom loader class, which an instance is set on the vienna.loader property
+  # Custom loader class, which an instance is set on the opal.loader property
   # to allow for disk based loading and access to modules/packages/gems.
   #
   # For now, this simply adds hard-coded paths to the load path. In future,
@@ -22,6 +22,10 @@ module Opal
       @vienna = vienna
       @ctx = context
       @paths = []
+
+      # core lib/std lib
+      @paths << File.expand_path(File.join('..', '..', '..', '..', 'lib'), __FILE__)
+
       hardcode_gems
     end
 
@@ -29,6 +33,7 @@ module Opal
     # proper package manager. This needs to be replaced to be more dynamic in
     # lookup.
     def hardcode_gems
+      return nil
       core = File.expand_path(File.join(__FILE__, '..', '..', '..', '..', 'gems'))
 
       Dir.open(core).each do |entry|
@@ -58,14 +63,14 @@ module Opal
     end
 
     # Exposed as replacement method.
-    def resolve_module(id, parent)
-      resolved = find_module id, @paths
-      raise "Cannot find module '#{id}'" unless resolved
+    def resolve_lib(id)
+      resolved = find_lib id, @paths
+      raise "Cannot find lib '#{id}'" unless resolved
       resolved
     end
 
     # Resolve the id requested with the given valid paths
-    def find_module(id, paths)
+    def find_lib(id, paths)
       extensions = valid_extensions
 
       @paths.each do |path|
@@ -76,6 +81,19 @@ module Opal
           # if file exists, return it!
           return candidate if File.exists? candidate
         end
+
+        # if has extension already
+        candidate = File.join(path, id)
+        return candidate if File.exists? candidate
+      end
+
+      # alternatively, if id is a full path, just load it
+      if File.exist? id
+        return File.expand_path id
+      end
+
+      if File.exist? id + '.rb'
+        return File.expand_path(id + '.rb')
       end
 
       # if we cannot find it, just return nil
@@ -88,7 +106,7 @@ module Opal
     #
     # @param {String} filename The filename to load. This is a full filename,
     # not just a module id.
-    def module_contents(filename)
+    def file_contents(filename)
       File.read filename
     end
 
@@ -97,7 +115,7 @@ module Opal
     # to vienna so that it makes it easier to compile and run ruby from the
     # v8 context. The default implementation of this throws an error to say
     # that in browser ruby code cannot be run.
-    def ruby_module_contents(filename)
+    def ruby_file_contents(filename)
       parser = Opal::RubyParser.new File.read(filename)
       result = parser.parse!.generate_top
       result
@@ -108,7 +126,7 @@ module Opal
     # require etc, and returns the function ready for calling. If an
     # error occures (likely a parse error) it is just thrown as normal
     def wrap(content, filename)
-      code = "(function(VM, self, __FILE__) { #{content} });"
+      code = "(function($rb, self, __FILE__) { #{content} });"
       # puts code
       @ctx.eval code, filename
     end

data/opal_lib/opal/gem.rb

@@ -0,0 +1,84 @@
+module Opal
+
+  # The gem class wraps around RubyGem's Gem::Specification class to basically add
+  # support for building a gem ready for the browser. The actual gem object can be
+  # accessed through {#spec}.
+  class Gem
+
+    # The real Gem::Specification object, which is used for accessing gem info
+    attr_reader :spec
+
+    # Root directory for the package
+    attr_reader :root_dir
+
+    def initialize(rootdir = Dir.getwd)
+      require 'rubygems'
+      @root_dir = rootdir
+      path = File.expand_path File.join(@root_dir, File.basename(@root_dir) + '.gemspec')
+
+      # we MUST chdir here to make sure files globs etc in the gemspec use the basedir
+      # as the working directory, otherwise opal, or the main gem working dir will
+      # accidentally be the cwd.
+      Dir.chdir(File.dirname(path)) do
+        @spec = ::Gem::Specification.load path
+      end
+
+      raise "Bad/missing gemspec in #{rootdir}" unless @spec
+    end
+
+    def bundle(opts = {})
+      Opal::Bundle.new(self).build opts
+    end
+
+    def name
+      @spec.name
+    end
+
+    def version
+      @spec.version.to_s
+    end
+
+    def require_paths
+      @spec.require_paths
+    end
+
+    def files
+      @spec.files
+    end
+
+    def test_files
+      @spec.test_files
+    end
+
+    def to_s
+      "#<Gem '#{name}'>"
+    end
+
+    # Returns an array of dependencies for this package. Version requirements
+    # are ignored for now. This simply returns the array of package names that
+    # are needed. If the package.json does not declare any, then an empty
+    # array is returned.
+    #
+    # @return {Array<String>}
+    def dependencies
+      dependencies = @spec.dependencies
+
+      dependencies.map { |d| d.name }
+    end
+
+    # Returns the files from the .files property of the gem that are only
+    # available from the require_paths array. Basically, these are the files
+    # that are our 'lib' files. They are returned as relative to the root.
+    #
+    # @return [Array<String>]
+    def lib_files
+      paths = require_paths
+      ext = %w[.rb .js] 
+
+      files.select do |f|
+        f.start_with?(*paths) && ext.include?(File.extname(f)) 
+      end
+    end
+  end
+end
+

data/{lib → opal_lib}/opal/rake/builder_task.rb

@@ -34,8 +34,8 @@ module Opal
           options[:main]  = @main if @main
           options[:watch] = @watch
 
-          builder = Opal::Builder.new options
-          builder.build
+          builder = Opal::Builder.new
+          builder.build options
         end
       end
     end

data/opal_lib/opal/rake/spec_task.rb

@@ -0,0 +1,32 @@
+require 'rake'
+require 'rake/tasklib'
+
+module Opal
+
+  module Rake
+
+    class SpecTask < ::Rake::TaskLib
+
+      def initialize(name = :spec)
+        @name = name
+        yield self if block_given?
+        define
+      end
+
+      def define
+        desc "Build ospec files ready for browser"
+        task(@name) do
+          base = File.basename Dir.getwd
+          gem = Opal::Gem.new Dir.getwd
+          content = gem.bundle :dependencies => 'ospec',
+            :main => 'ospec/autorun', :test_files => true
+
+          File.open("tmp/#{base}.spec.js", 'w+') do |out|
+            out.write content
+          end
+        end
+      end
+    end
+  end
+end
+