opal 0.3.6 → 0.3.9

data/opal_lib/opal/command.rb

@@ -1,68 +0,0 @@
-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/opal_lib/opal/context.rb

@@ -1,81 +0,0 @@
-# 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
-
-    RUNTIME_PATH = File.expand_path File.join('..', '..', '..', 'runtime.js'), __FILE__
-
-    def initialize(opts = {})
-      super opts
-      @builder = Opal::Builder.new
-      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
-      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['platform']['engine'] = 'opal-gem'
-
-      # eval "opal.require('core');", "(opal)"
-      require_file 'core'
-    end
-
-    # 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
-
-    # 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
-    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 = "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.$rbMM ? $opal_irb_result.$m.inspect($opal_irb_result) : '(Object doesnt support #inspect)'"
-      rescue => e
-        puts e
-        puts("\t" + e.backtrace.join("\n\t"))
-      end
-    end
-  end
-
-end
-

data/opal_lib/opal/context/console.rb

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

data/opal_lib/opal/context/file_system.rb

@@ -1,34 +0,0 @@
-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/opal_lib/opal/context/loader.rb

@@ -1,135 +0,0 @@
-
-module Opal
-  # 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,
-  # 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 = []
-
-      # core lib/std lib
-      @paths << File.expand_path(File.join('..', '..', '..', '..', 'lib'), __FILE__)
-
-      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
-      return nil
-      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_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_lib(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
-
-        # 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
-      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 file_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_file_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($rb, self, __FILE__) { #{content} });"
-      # puts code
-      @ctx.eval code, filename
-    end
-  end
-end
-

data/opal_lib/opal/gem.rb

@@ -1,84 +0,0 @@
-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/opal_lib/opal/rake/builder_task.rb

@@ -1,44 +0,0 @@
-require 'rake'
-require 'rake/tasklib'
-
-module Opal
-  module Rake
-
-    class BuilderTask < ::Rake::TaskLib
-
-      attr_accessor :files
-
-      attr_accessor :out
-
-      attr_accessor :main
-
-      attr_accessor :watch
-
-      def initialize(name = :opal)
-        @name    = name
-        @files   = []
-        @out     = nil
-        @main    = nil
-        @watch   = false
-
-        yield self if block_given?
-        define_rake_task
-      end
-
-      def define_rake_task
-        desc "Build opal files"
-        task(@name) do
-          options = {}
-          options[:files] = @files
-          options[:out]   = @out if @out
-          options[:main]  = @main if @main
-          options[:watch] = @watch
-
-          builder = Opal::Builder.new
-          builder.build options
-        end
-      end
-    end
-  end
-end
-