opal 0.3.2 → 0.3.6

data/{gems/ospec/lib → lib}/ospec/runner/options.rb

@@ -16,10 +16,8 @@ module Spec
       end
 
       def formatters
-        # puts "formatters: #{@formatters.inspect}"
         return @formatters if @formatters
-        # puts "still down here.."
-        if RUBY_PLATFORM == "browser"
+        if RUBY_ENGINE == "opal-browser"
           @formatters ||= [Spec::Runner::Formatter::HtmlFormatter.new(self)]
         else
           @formatters ||= [Spec::Runner::Formatter::TerminalFormatter.new(self)]

data/{gems/ospec/lib → lib}/ospec/runner/reporter.rb

@@ -14,10 +14,7 @@ module Spec
 
       def start(number_of_examples)
         @start_time = 0
-        puts "formatters isss:"
-        # `console.log(#{formatters})`
         formatters.each do |f|
-          # puts "in hereeee"
           f.start number_of_examples
         end
       end
@@ -40,17 +37,11 @@ module Spec
       end
 
       def example_finished(example, error)
-        puts "== example finished"
         if error.nil?
-          puts "no error"
           example_passed example
         elsif Spec::Example::ExamplePendingError === error
-          puts "pengin error"
           example_pending example, error.message
         else
-          puts "failed"
-          `console.log(error)`
-          `console.log(error.message)`
           example_failed example, error
         end
       end

data/lib/racc/parser.rb

@@ -0,0 +1,165 @@
+# Opal port of racc/parser.rb.
+#
+# This is the runtime for racc generated parsers inside opal. It is a port
+# of racc/parser.rb from ruby stdlib but with optimizations to make it run
+# faster on opal, which is ecspecially important in the browser. This
+# implementation also has a pure js routine for extra speeds gains which is
+# used in preference to the ruby implementation.
+#
+# Original license:
+#
+# $originalId: parser.rb,v 1.8 2006/07/06 11:42:07 aamine Exp $
+#
+# Copyright (c) 1999-2006 Minero Aoki
+#
+# This program is free software.
+# You can distribute/modify this program under the same terms of ruby.
+#
+# As a special exception, when this code is copied by Racc
+# into a Racc output file, you may use that output file
+# without restriction.
+module Racc
+
+  class Parser
+
+    def _racc_setup
+      Racc_arg
+    end
+
+    def do_parse
+      _racc_do_parse_rb _racc_setup, false
+    end
+
+    def _racc_do_parse_rb(arg, in_debug)
+      action_table   = arg[0]
+      action_check   = arg[1]
+      action_default = arg[2]
+      action_pointer = arg[3]
+
+      goto_table     = arg[4]
+      goto_check     = arg[5]
+      goto_default   = arg[6]
+      goto_pointer   = arg[7]
+
+      nt_base        = arg[8]
+      reduce_table   = arg[9]
+      token_table    = arg[10]
+      shift_n        = arg[11]
+      reduce_n       = arg[12]
+
+      use_result     = arg[13]
+
+      # racc sys vars
+      racc_state     = [0]
+      racc_tstack    = []
+      racc_vstack    = []
+
+      racc_t         = nil
+      racc_tok       = nil
+      racc_val       = nil
+      racc_read_next = true
+
+      racc_user_yyerror = false
+      racc_error_status = 0
+
+      token = nil; act = nil; i = nil; nerr = nil; custate = nil
+
+      while true
+        i = action_pointer[racc_state[-1]]
+
+        if i
+          if racc_read_next
+            if racc_t != 0 # not EOF
+              token = next_token
+
+              racc_tok = token[0]
+              racc_val = token[1]
+
+              if racc_tok == false # EOF
+                racc_t = 0
+              else
+                racc_t = token_table[racc_tok]
+                racc_t = 1 unless racc_t
+                # racc_t ||= 1
+              end
+
+              racc_read_next = false
+            end
+          end
+
+          i += racc_t
+
+          if (i < 0) || (act = action_table[i]).nil? || (action_check[i] != racc_state[-1])
+            act = action_default[racc_state[-1]]
+          end
+
+        else
+          act = action_default[racc_state[-1]]
+        end
+
+        if act > 0 && act < shift_n
+          if racc_error_status > 0
+            if racc_t != 1
+              racc_error_status -= 1
+            end
+          end
+
+          racc_vstack.push racc_val
+          curstate = act
+          racc_state << act
+          racc_read_next = true
+
+        elsif act < 0 && act > -reduce_n
+          reduce_i   = act * -3
+          reduce_len = reduce_table[reduce_i]
+          reduce_to  = reduce_table[reduce_i + 1]
+          method_id  = reduce_table[reduce_i + 2]
+
+          tmp_v = racc_vstack.last reduce_len
+
+          racc_state.pop reduce_len
+          racc_vstack.pop reduce_len
+          racc_tstack.pop reduce_len
+
+          if use_result
+            reduce_call_result = self.__send__ method_id, tmp_v, nil, tmp_v[0]
+            racc_vstack.push reduce_call_result
+          else
+            raise "not using result??"
+          end
+
+          racc_tstack.push reduce_to
+
+          k1 = reduce_to - nt_base
+
+          if (reduce_i = goto_pointer[k1]) != nil
+            reduce_i += racc_state[-1]
+
+            if (reduce_i >= 0) && ((curstate = goto_table[reduce_i]) != nil) && (goto_check[reduce_i] == k1)
+              racc_state.push curstate
+            else
+              racc_state.push goto_default[k1]
+            end
+
+          else
+            racc_state.push goto_default[k1]
+          end
+
+        elsif act == shift_n
+          # action
+          return racc_vstack[0]
+
+        elsif act == -reduce_n
+          # reduce
+          raise "Opal Syntax Error: unexpected '#{racc_tok.inspect}'"
+
+        else
+          raise "Rac: unknown action: #{act}"
+        end
+
+        # raise "and finished loop"
+      end
+    end # _racc_do_parse_rb
+  end
+end
+

data/lib/strscan.rb

@@ -0,0 +1,52 @@
+class StringScanner
+
+  def initialize(str)
+    `self._str = str;
+     self._at = 0;
+     self._matched = "";
+     self._working_string = str;`
+     nil
+  end
+
+  def scan(reg)
+    `reg = new RegExp('^' + reg.toString().substr(1, reg.toString().length - 2));
+    var res = reg.exec(self._working_string);
+
+    if (res == null) {
+      self.matched = "";
+      return Qfalse;
+    }
+    else if (typeof res == 'object') {
+      self._at += res[0].length;
+      self._working_string = self._working_string.substr(res[0].length);
+      self._matched = res[0];
+      return res[0];
+    }
+    else if (typeof res == 'string') {
+      self._at += res.length;
+      self._working_string = self._working_string.substr(res.length);
+      return res;
+    }
+    else {
+      return Qfalse;
+    }`
+  end
+
+  def check(reg)
+    `reg = new RegExp('^' + reg.toString().substr(1, reg.toString().length - 2));
+    return reg.exec(self._working_string) ? Qtrue : Qfalse;`
+  end
+
+  def peek(len)
+    `return self._working_string.substr(0, len);`
+  end
+
+  def eos?
+    `return self._working_string.length == 0 ? Qtrue : Qfalse;`
+  end
+
+  def matched
+    `return self._matched;`
+  end
+end
+

data/{lib → opal_lib}/opal.rb

@@ -1,9 +1,11 @@
 require 'rubygems'
+require 'thor'
 
 module Opal
 
 end
 
+require 'opal/version'
 require 'opal/ruby/parser'
 
 require 'opal/gem'

data/opal_lib/opal/build_methods.rb

@@ -0,0 +1,51 @@
+module Opal
+
+  module BuildMethods
+
+    # 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.register('#{relative_path}', #{content});\n"
+    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
+
+      case ext
+      when '.js'
+        "function($rb, self, __FILE__) { #{src} }"
+
+      when '.rb'
+        src = Opal::RubyParser.new(src).parse!.generate_top
+        "function($rb, self, __FILE__) { #{src} }"
+
+      else
+        raise "Bad file type for wrapping. Must be ruby or javascript"
+      end
+    end
+  end
+end
+

data/opal_lib/opal/builder.rb

@@ -0,0 +1,164 @@
+require 'fileutils'
+require 'opal/build_methods'
+
+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
+    include BuildMethods
+
+    OPAL_PATH = File.expand_path(File.join('..', '..', '..'), __FILE__)
+
+    STDLIB_PATH = File.join OPAL_PATH, 'lib'
+
+    RUNTIME_PATH = File.join OPAL_PATH, 'runtime'
+
+    def build_runtime
+      code = ''
+
+      %w[pre runtime init class module fs loader debug post].each do |f|
+        code += File.read(File.join RUNTIME_PATH, f + '.js')
+      end
+
+      code
+    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 = build_runtime
+      code += build_stdlib('core.rb', 'core/*.rb')
+      code += "opal.require('core');"
+
+      code
+    end
+
+    # Builds the opal parser and dev.rb file, and returns as a string.
+    def build_parser
+      code = ''
+
+      %w[opal/ruby/nodes opal/ruby/parser opal/ruby/ruby_parser].each do |src|
+        full = File.join OPAL_PATH, 'opal_lib', src + '.rb'
+        compiled = compile_source full
+        code += "opal.register('#{src}.rb', #{compiled});"
+      end
+
+      code += build_stdlib 'racc/parser.rb', 'strscan.rb', 'dev.rb'
+      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)
+      code = []
+      Dir.chdir(STDLIB_PATH) do
+        Dir.[](*files).each do |lib|
+          full_path = File.join STDLIB_PATH, lib
+          code << wrap_source(full_path, lib)
+        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?
+
+      main = options[:main]
+
+      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
+      end
+
+      main = options[:main]
+
+      unless options[:out]
+        options[:out] = main.sub /\.rb$/, '.js'
+      end
+
+      FileUtils.mkdir_p File.dirname(options[:out])
+
+      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
+      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"
+        end
+
+        # out.write @post if @post
+      end
+    end
+  end
+end
+