opal 0.2.2 → 0.3.0

data/lib/opal.rb

@@ -1,75 +1,12 @@
-# 
-# vienna.rb
-# vienna
-# 
-# Created by Adam Beynon.
-# Copyright 2010 Adam Beynon.
-#
-# Permission is hereby granted, free of charge, to any person obtaining a copy
-# of this software and associated documentation files (the "Software"), to deal
-# in the Software without restriction, including without limitation the rights
-# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-# copies of the Software, and to permit persons to whom the Software is
-# furnished to do so, subject to the following conditions:
-# 
-# The above copyright notice and this permission notice shall be included in
-# all copies or substantial portions of the Software.
-# 
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-# THE SOFTWARE.
-#
-
-require 'fileutils'
-require 'base64'
 require 'rubygems'
 
-module Vienna
-  
-  # :stopdoc:
-  VERSION = '0.2.0'
-  LIBPATH = ::File.expand_path(::File.dirname(__FILE__)) + ::File::SEPARATOR
-  PATH = ::File.dirname(LIBPATH) + ::File::SEPARATOR
-  # :startdoc:
-
-  # Returns the version string for the library.
-  #
-  def self.version
-    VERSION
-  end
-
-  # Returns the library path for the module. If any arguments are given,
-  # they will be joined to the end of the libray path using
-  # <tt>File.join</tt>.
-  #
-  def self.libpath( *args )
-    args.empty? ? LIBPATH : ::File.join(LIBPATH, args.flatten)
-  end
+module Opal
 
-  # Returns the lpath for the module. If any arguments are given,
-  # they will be joined to the end of the path using
-  # <tt>File.join</tt>.
-  #
-  def self.path( *args )
-    args.empty? ? PATH : ::File.join(PATH, args.flatten)
-  end
+end
 
-  # Utility method used to require all files ending in .rb that lie in the
-  # directory below this file that has the same name as the filename passed
-  # in. Optionally, a specific _directory_ name can be passed in such that
-  # the _filename_ does not have to be equivalent to the directory.
-  #
-  def self.require_all_libs_relative_to( fname, dir = nil )
-    dir ||= ::File.basename(fname, '.*')
-    search_me = ::File.expand_path(
-      ::File.join(::File.dirname(fname), dir, '**', '*.rb'))
+require 'opal/ruby/parser'
 
-    Dir.glob(search_me).sort.each {|rb| require rb}
-  end
-end
+require 'opal/gem'
+require 'opal/bundle'
+require 'opal/builder'
 
-Vienna.require_all_libs_relative_to(__FILE__)

data/lib/opal/builder.rb

@@ -0,0 +1,115 @@
+require 'fileutils'
+
+module Opal
+  # Builder is used for compiling simple ruby files into javascript files
+  # through the command line or a rake task. It is used for non bundle based
+  # building systems, and is meant for building small scale pages rather than
+  # applications.
+  class Builder
+    # 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
+    #
+    # 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 initialize(options = {})
+      @project_dir = options[:project_dir] || Dir.getwd
+      @project_name = File.basename @project_dir
+
+      out = options[:out] || File.join('javascripts', "#@project_name.js")
+      @out = File.join @project_dir, out
+      FileUtils.mkdir_p File.dirname(@out)
+
+      files = options[:files] || []
+      @files = []
+
+      if Array === files
+        files.each do |file|
+          @files << file
+        end
+      else
+        Dir.glob(File.join(@project_dir, files)) do |file|
+          @files << file
+        end
+      end
+
+      @watch = options[:watch]
+
+      raise "Opal::Builder - No input files!" if @files.empty?
+    end
+
+    # Actually build the simple builder. This is simply used as a looper to
+    # rebuild if a source file changes. The trigger for a rebuild is when a
+    # source file changes. So on each loop, we check if any source file has
+    # a newer mtime than the destination file.
+    def build
+      rebuild
+      if @watch
+        puts "Watching for changes.."
+        loop do
+          out_mtime = File.stat(@out).mtime
+          @files.each do |file|
+            if File.stat(file).mtime > out_mtime
+              puts "#{Time.now} rebuilding - changes detected in #{file}"
+              rebuild
+            end
+          end
+
+          begin
+            sleep 1
+          rescue Interrupt
+            exit 0
+          end
+        end
+      end
+    end
+
+    # Does the actual rebuild of a project
+    def rebuild
+      File.open(@out, 'w') do |out|
+        @files.each do |file|
+          out.write wrap_source file
+        end
+        main = File.basename(@files.first).sub(/\.rb/, '')
+        out.write "opal.require('#{main}');\n"
+      end
+    end
+
+    # Returns the result of the compiled file ready for opal to load
+    #
+    # @return {String}
+    def wrap_source(path)
+      ext_name = File.extname path
+
+      content = case ext_name
+      when '.js'
+        source = File.read path
+        "function(VM, self, __FILE__) { #{source} }"
+
+      when '.rb'
+        source = Opal::RubyParser.new(File.read(path)).parse!.generate_top
+        path = path.sub(/\.rb/, '.js')
+        "function(VM, self, __FILE__) { #{source} }"
+
+      else
+        raise "Bad file type for wrapping. Must be ruby or javascript"
+      end
+
+      "opal.register('#{File.basename path}', #{content});\n"
+    end
+  end
+end
+

data/lib/opal/bundle.rb

@@ -0,0 +1,131 @@
+module Opal
+
+  # The Bundle class is used to bundle a package, and optionally all of its
+  # dependencies and the base opal boot file into a js file ready for browser
+  # deployment. It takes a package, and a set of options, and simply returns a
+  # combined string of the built packages.
+  #
+  # This does not yet support building resources from the packages. Just the
+  # basic package building works.
+  #
+  # The following options are supported:
+  #
+  # - `:dependencies` - An array of additional dependencies to add that may not
+  # be listed in the .gemspec. This is used, for example, to include opalspec
+  # into test builds so that opalspec does not need to be a dependency in all
+  # build environments.
+  # - `:main` - The file to run in the browser. An example may be
+  # 'vienna/autorun'. Note this is not a bin file, and should be a simple lib
+  # file that will be in the load path.
+  # - `:bin` - Alternatively, a bin file listed within a gem that should be
+  # included, and then run within the browser. An example would be
+  # 'vienna/vienna', where the first part is the gem containing the bin file,
+  # which is named the second part.
+  # - `:standalone` - Exclude dependencies listed in the gemspec. This is false
+  # by default so all listed dependencies will be recursively added to the
+  # resulting file. If set to true, the gemspec dependencies will not be
+  # included. This does not affect the `:dependencies` option, which are
+  # included seperately to these dependencies.
+  # - `:to` - Usually this process will just return a string, but by passing a
+  # `:to` option, the result will be written to the file specified by the given
+  # name. This only works for simple bundling where no resources are needed.
+  class Bundle
+
+    # Ensure we keep a unique set of packages - we dont want duplications
+    attr_reader :handled_packages
+
+    # Queue of packages waiting to be built
+    attr_reader :package_queue
+
+    # The {Gem} instance to build with a set of optional options.
+    #
+    # @param [Gem] package The package to build
+    # @param {Hash} opts Build options
+    def initialize(package, opts = {})
+      @package = package
+      @options = opts
+
+      @handled_packages = []
+      @package_queue = []
+    end
+
+    # Actually build the bundle. Returns the result, for now, as a string.
+    #
+    # @return {String} bundled packages
+    def build
+      result = []
+      pkg = nil
+
+      @package_queue << @package
+      @handled_packages << @package.name
+
+      unless @options[:standalone]
+        add_dependency('core', @package)
+      end
+
+      while pkg = @package_queue.pop
+        puts pkg
+        # if this is our initial package and we are standalone, make sure we
+        # pass that option into build package
+        if pkg == @package && @options[:standalone]
+          puts "standalone #{pkg}"
+          result << build_package(pkg, true)
+        else
+          result << build_package(pkg)
+        end
+      end
+
+      unless @options[:standalone]
+        result.unshift opal_boot_content
+      end
+
+      if @options[:to]
+        File.open(@options[:to], 'w+') { |out| out.write result.join("\n") }
+      end
+
+      result.join "\n"
+    end
+
+    # Boot content for opal. This bootloader takes all the gems in the browser
+    # context and manages them. Opal self-loads in the bootloader.
+    #
+    # @return [String]
+    def opal_boot_content
+      path = File.expand_path File.join(__FILE__, '..', '..', '..', 'lib', 'opal.js')
+      File.read path
+    end
+
+    # Builds a single package. This will build the package, discover its
+    # dependencies, and then add them to the queue of packages to build. This
+    # method will then return the built package as a string.
+    #
+    # @param {Package} package The package to build
+    # @param {Boolean} standalone Whether to exclude gem dependencies.
+    # @return {String} Built package
+    def build_package(package, standalone = false)
+      # Work through each dependency and work out if we need it
+      unless standalone
+        package.dependencies.each do |dep|
+          add_dependency dep, package
+        end
+      end
+
+      package.to_bundle
+    end
+
+    def add_dependency(dep, package)
+
+        unless @handled_packages.include? dep
+          @handled_packages << dep
+
+          loc = package.find_dependency(dep)
+          raise "Cannot find dependency '#{dep}' for #{package}" unless loc
+
+          pkg = Gem.new loc
+          @package_queue << pkg
+        end
+    end
+
+  end
+end
+

data/lib/opal/command.rb

@@ -0,0 +1,11 @@
+module Opal
+  module Command
+
+    def self.ruby_repl
+      require 'opal/context'
+      ctx = Opal::Context.new
+      ctx.start_repl
+    end
+  end
+end
+

data/lib/opal/context.rb

@@ -0,0 +1,69 @@
+# This file should only be required as needed. This file relies on v8,
+# therubyracer. As this is not an essential feature of opal, this file
+# will be loaded as needed, and when it is, an error is just thrown if
+# the required gems are not installed.
+begin
+  require 'v8'
+rescue LoadError => e
+  abort "therubyracer is required for running javascript. Install it with `gem install therubyracer`"
+end
+
+require 'opal/context/loader'
+require 'opal/context/console'
+require 'opal/context/file_system'
+
+module Opal
+  class Context < V8::Context
+
+    def initialize(opts = {})
+      super opts
+      setup_context
+    end
+
+    # Setup the context. This basically loads opal.js into our context, and
+    # replace the loader etc with our custom loader for a Ruby environment. The
+    # default "browser" loader cannot access files from disk.
+    def setup_context
+      self['console'] = Console.new
+      load opal_js_path
+
+      opal = self['opal']
+      opal['loader'] = Loader.new opal, self
+      # opal['fs'] = FileSystem.new opal, self
+
+      eval "opal.require('core');", "(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')
+    end
+
+    # Start normal js repl
+    def start_repl
+      require 'readline'
+
+      loop do
+        line = Readline.readline '>> ', true
+        puts "=> #{eval_ruby line, '(opal)'}"
+      end
+    end
+
+    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
+        # puts code
+        self['$opal_irb_result'] = eval code, line
+        # self['$code'].to_s + "ww"
+        eval "$opal_irb_result.$m.inspect($opal_irb_result);"
+      rescue => e
+        puts e
+        puts("\t" + e.backtrace.join("\n\t"))
+      end
+    end
+  end
+
+end
+

data/lib/opal/context/console.rb

@@ -0,0 +1,12 @@
+
+module Opal
+
+  class Console
+
+    def log(*str)
+      puts str.join("\n")
+      nil
+    end
+  end
+end
+

data/lib/opal/context/file_system.rb

@@ -0,0 +1,19 @@
+
+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
+  end
+end
+

data/lib/opal/context/loader.rb

@@ -0,0 +1,117 @@
+
+module Opal
+  # Custom loader class, which an instance is set on the vienna.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,
+  # dynamic package lookup will take place, but for now we just manually loop
+  # through gems/packages in this gems' dir, and the cwd dir (in ./vendor/) and
+  # add each of their lib/ dirs). Unil we add a custom package manager, this
+  # will make it the easiest way of managing packages for vienna.
+  class Loader
+
+    # Load paths. This is an array of all load paths
+    attr_reader :paths
+
+    # The vienna instance for the object
+    attr_reader :vienna
+
+    # @param vienna The js vienna object itself so we can talk to it
+    # @param {Vienna::Context} context The v8 context
+    def initialize(vienna, context)
+      @vienna = vienna
+      @ctx = context
+      @paths = []
+      hardcode_gems
+    end
+
+    # Register all gems - this is currently hardcoded while we don't have a
+    # proper package manager. This needs to be replaced to be more dynamic in
+    # lookup.
+    def hardcode_gems
+      core = File.expand_path(File.join(__FILE__, '..', '..', '..', '..', 'gems'))
+
+      Dir.open(core).each do |entry|
+        try_dir = File.join core, entry
+        if File.directory?(try_dir) && !['.', '..'].include?(entry)
+          add_hardcoded_gem try_dir
+        end
+      end
+    end
+
+    # Add an individual hardcoded gem by its path. We need to check it has a
+    # .gemspec in its dir, then add its lib directory to our path.
+    def add_hardcoded_gem(path)
+      # make sure gem dir has a gemspec
+      gemspec = File.join path, File.basename(path) + '.gemspec'
+      return unless File.exists? gemspec
+      # make sure gem dir has a lib dir
+      libpath = File.join path, 'lib'
+      return unless File.exists? libpath
+      # all is ok, so add to loadpath
+      @paths << libpath
+    end
+
+    # Valid extensions. This should be more dynamic for custom extensions
+    def valid_extensions
+      %w[.rb .js]
+    end
+
+    # Exposed as replacement method.
+    def resolve_module(id, parent)
+      resolved = find_module id, @paths
+      raise "Cannot find module '#{id}'" unless resolved
+      resolved
+    end
+
+    # Resolve the id requested with the given valid paths
+    def find_module(id, paths)
+      extensions = valid_extensions
+
+      @paths.each do |path|
+
+        extensions.each do |ext|
+          candidate = File.join(path, id + ext)
+
+          # if file exists, return it!
+          return candidate if File.exists? candidate
+        end
+      end
+
+      # if we cannot find it, just return nil
+      nil
+    end
+
+    # Returns the contents of the module. This, in ruby, reads from the disk,
+    # but the browser uses either XHR or a cached module reference. The
+    # method name is kept generic to reflect this.
+    #
+    # @param {String} filename The filename to load. This is a full filename,
+    # not just a module id.
+    def module_contents(filename)
+      File.read filename
+    end
+
+    # Special version of module contents that will compile the given ruby code
+    # at the file into javascript first, before returning it. This is exposed
+    # 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)
+      parser = Opal::RubyParser.new File.read(filename)
+      result = parser.parse!.generate_top
+      result
+    end
+
+    # Wraps the content with the given filename. Basically, here we eval
+    # the code inside a function which takes our exports, module,
+    # 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} });"
+      # puts code
+      @ctx.eval code, filename
+    end
+  end
+end
+