opal 0.3.10 → 0.3.11

data/README.md

@@ -17,16 +17,10 @@ Opal does not aim to be 100% comaptible with other ruby implementations,
 but does so where the generated code can be efficient on all modern web
 browsers - including older versions of IE and mobile devices.
 
-Using opal
+Installing opal
 ----------
 
-Opal can currently be used in three ways: through a distributed ruby gem,
-directly in the web browser or with rbp - a new package manager designed
-for opal but usable for any ruby project.
-
-### Using the gem
-
-Install via ruby gems:
+Install the gem:
 
 ```
 $ gem install opal
@@ -38,66 +32,73 @@ The `opal` command should then be available. To run the simple repl use:
 opal irb
 ```
 
-The `opal` command can also be used directly from this source repo, so
-to download and run opal:
+Usage
+-----
+
+The quickest way to get opal running is to use the project generator.
+Simply run the command:
 
 ```
-$ git clone https://github.com/adambeynon/opal.git
-$ cd opal
-$ bin/opal
+opal init my_project
 ```
 
-### Using rbp
+replacing "my_project" with any name. This will make a "my_project"
+directory with a Rakefile, html document and libs needed for running
+opal in the browser.
 
-rbp installs dependencies locally to your project, so edit your
-package.yml file to add the following dependency:
+### Using opal in the browser
 
-```yaml
-dev_dependencies:
-  opal: "0.3.9"
-  therubyracer: "0.9.4"
-```
+Opal runs directly in the browser, and is distributed as two files,
+`opal.js` and `opal-parser.js`. To just run precompiled code, just the
+`opal.js` runtime is required which includes the runtime and opals
+implementation of the ruby core library (pre compiled).
+
+To evaluate ruby code directly in the browser, `opal-parser.js` is also
+required which will also load any ruby code found in script tags.
 
-Install them with:
+### Bundle
+
+The Rakefile has a task to build your ruby project, so just run:
 
 ```
-$ rbp install
+rake bundle
 ```
 
-This will install them into vendor/ ready to use. therubyracer is only
-needed if you want to run your ruby code, compiled into javascript,
-directly on the commandline. If you are just compiling ruby then just
-the opal package is sufficient.
+Open `index.html` in a browser, and now it should run. Edit, build and
+run to suit.
 
-Running tests
--------------
+Project structure
+-----------------
 
-To run tests, you need opaltest which is the testing framework for opal
-based on minitest. To get opaltest, run the following in the opal
-directory:
+This repo contains the code for the opal gem as well as the opal core
+library and runtime. Files inside `bin/` and `lib/` are the files that
+are used as part of the gem and run directly on your ruby environment.
 
-```
-$ rbp install
-```
+`corelib/` contains opal's core library implementation and is not used
+directly by the gem. These files are precompiled during development
+ready to be used in the gem or in a browser.
 
-This will put opaltest into `packages/opaltest` so it will be available
-for running. To test `array.rb` for example, run:
+`runtime/` contains opal's runtime written in javascript. It is not used
+directly by the gem, but is built ready to use in the js contexts that
+opal runs.
 
-```
-$ rbp exec opal test/array.rb
-```
+`stdlib/` contains the stdlib files that opal comes packaged with. The
+gem does use these, but only as required. Opal does not include the full
+opal stdlib, and some parts are actually written in javascript for
+optimal performance. These can be `require()` at runtime.
 
-The results should be printed to the console.
+`opal.js` and `opal-parser.js` are included in the gem, but not the
+source repo. They are the latest built versions of opal and its parser
+which are built before the gem is published.
 
 Differences from ruby
 ---------------------
 
-### No method\_missing
+### Optional method\_missing
 
-To optimize method dispatch, `method_missing` is not supported in opal.
-It is supported in debug mode to improve readability of error messages
-from calling undefined methods, but should/will not be used in
-production code.
+To optimize method dispatch, `method_missing` is, by default, turned off
+in opal. It can easily be enabled by passing `:method_missing => true`
+in the parser options.
 
 ### Immutable strings and removed symbols
 

data/lib/opal.rb

@@ -1,12 +1,20 @@
-require 'opal/parser'
-require 'opal/builder'
-require 'opal/context'
+require "opal/parser"
+require "opal/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__)
+
+  # Full path to our opal.js runtime file
+  OPAL_JS_PATH = File.join OPAL_DIR, "opal.js"
+
+  # Full path to our opal-parser.js parser file
+  OPAL_PARSER_JS_PATH = File.join OPAL_DIR, "opal-parser.js"
 end
 

data/lib/opal/builder.rb

@@ -1,21 +1,17 @@
 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 packages.
+  # is not used directly for building gem.
   class Builder
 
     OPAL_PATH = File.expand_path(File.join('..', '..', '..'), __FILE__)
 
     STDLIB_PATH = File.join OPAL_PATH, 'stdlib'
 
-    RUNTIME_PATH = File.join OPAL_PATH, 'runtime'
-
-    CORE_PATH = File.join OPAL_PATH, 'corelib'
-
     def initialize
       @parser = Parser.new
     end
@@ -43,7 +39,7 @@ module Opal
       # relative_path = relative_path.sub(/\.rb/, '.js') if ext == '.rb'
       content = compile_source full_path
 
-      "opal.lib('#{relative_path}.rb', #{content});\n"
+      "opal.lib('#{relative_path}', #{content});\n"
     end
 
     # Simply compile the given source code at the given path. This is
@@ -61,51 +57,13 @@ module Opal
         "function($rb, self, __FILE__) { #{src} }"
 
       when '.rb'
-        src = Opal::Parser.new(src).parse!.generate_top
-        "function($rb, self, __FILE__) { #{src} }"
+        return parse src
 
       else
         raise "Bad file type for wrapping. Must be ruby or javascript"
       end
     end
 
-    # Builds core opal runtime + core libs, and returns as a string.
-    # This can then just be used directly by any compiled code. The
-    # core lib is then auto loaded so it is ready for running.
-    def build_core
-      code = ''
-
-      %w[pre runtime init class module fs loader].each do |f|
-        code += File.read(File.join RUNTIME_PATH, f + '.js')
-      end
-
-      order = File.read(File.join(CORE_PATH, 'load_order')).strip.split
-
-      core = order.map do |o|
-        File.read File.join(CORE_PATH, o + '.rb')
-      end
-
-      code += "var core_lib = #{parse core.join};"
-
-      code + File.read(File.join RUNTIME_PATH, 'post.js')
-    end
-
-    # Builds the opal parser and dev.rb file, and returns as a string.
-    def build_parser
-      code = ''
-
-      %w[opal/nodes opal/lexer opal/parser].each do |src|
-        full = File.join OPAL_PATH, 'lib', src + '.rb'
-        compiled = compile_source full
-        code += "opal.lib('#{src}.rb', #{compiled});"
-      end
-
-      code += build_stdlib 'racc/parser', 'strscan', 'dev'
-      code += "opal.require('dev');"
-
-      code
-    end
-
     # Build the given sources from the standard library. These can be
     # globs. Returns a string of all content.
     def build_stdlib(*files)

data/lib/opal/bundle.rb

@@ -1,41 +1,27 @@
 require 'opal/builder'
 
-begin
-  require 'rbp/package'
-rescue LoadError
-  abort "You need to install rbp. `gem install rbp`."
-end
-
 module Opal
-  # Takes a package and builds it ready for the browser
   class Bundle
-    # @return [Rbp::Package] the package this is bundling
-    attr_reader :package
-
+    attr_accessor :name
+    attr_accessor :version
     attr_accessor :options
 
-    def initialize(package)
-      @package        = package
-      @builder        = Builder.new
+    def initialize
+      @builder = Builder.new
       @options = {}
     end
 
-    # Simple build - returns a string which can be written to a file
-    # FIXME: hardcoded lib directory to './lib'
     def build
-      package_dir = @package.package_dir
-
-      lib_files = @package.relative_lib_files.map do |lib|
-        path = File.join package_dir, lib
-        code = @builder.parse File.read(path), options
-
-        "\"#{lib}\": #{code}"
+      lib_files = Dir["{lib}/**/*.rb"].map do |lib|
+        code = @builder.parse File.read(lib), options
+        path = lib[4, lib.length - 7]
+        "\"#{path}\": #{code}"
       end
 
       bundle = []
-      bundle << %[opal.package({\n]
-      bundle << %[  name: "#{@package.name}",\n]
-      bundle << %[  version: "#{@package.version}",\n]
+      bundle << %[opal.gem({\n]
+      bundle << %[  name: "#{@name}",\n]
+      bundle << %[  version: "#{@version}",\n]
       bundle << %[  libs: {\n]
       bundle << %[    #{lib_files.join ",\n    "}\n]
       bundle << %[  }\n]

data/lib/opal/command.rb

@@ -1,15 +1,20 @@
-module Opal
+require 'optparse'
+require 'fileutils'
+require 'opal/builder'
 
+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]
+    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, *args
+        __send__ command.to_sym
       elsif command and File.exists? command
         eval command
       else
@@ -17,36 +22,113 @@ module Opal
       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
+        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))
+        end
+      end
+    end
+
     def help
       puts "need to print help"
     end
 
-    # desc "irb", "Opens interactive opal/ruby repl"
-    def irb
-      ctx = Opal::Context.new
+    # 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
 
-    def eval(path = nil)
-      return "no path given for eval" unless path
+    # 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
+
+      if File.exists? code
+        code = Parser.new.parse File.read(code)
+      end
 
-      abort "path does not exist `#{path}'" unless File.exist? path
+      context = Context.new :method_missing      => true,
+                            :overload_arithmetic => true,
+                            :overload_comparison => true,
+                            :overload_bitwise    => true
 
-      ctx = Opal::Context.new
-      ctx.require_file File.expand_path(path)
+      puts context.eval code
     end
 
-    def compile(path)
-      puts Opal::Parser.new(File.read(path)).parse!.generate_top
-    end
-
-    def install
-      install = RBP::Install.new
-      install.install
+    # 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)
+      else
+        puts Parser.new.parse path
+      end
     end
 
     # Bundle the gem (browserify) ready for the browser
-    def bundle
+    def bundle(*)
       # lazy load incase user does not have rbp installed
       require 'opal/bundle'
 
@@ -54,9 +136,6 @@ module Opal
       package = Rbp::Package.load_path path
       bundle  = Bundle.new package
 
-      puts bundle
-      puts bundle.package
-
       puts bundle.build
     end
   end