opal 0.8.1 → 0.9.0.beta1

data/benchmarks/operators.rb

@@ -1,11 +0,0 @@
-require "benchmark"
-
-time = Benchmark.measure do
-  a = 0
-  100000.times do
-    a = a + 1
-  end
-  puts a
-end
-
-puts time

data/benchmarks/prova.js.rb

@@ -1,13 +0,0 @@
-# 'asdf' =~ /(a)./
-#
-# p $'
-# p $1
-# p $2
-# `console.log(2, $opal.gvars['1'])`
-# b = $1
-# `console.log(1, b)`
-# nil
-
-puts [*1..3].to_s
-puts [*(1..3)].to_s
-puts [*Object.new].to_s

data/docs/libraries.md

@@ -1,36 +0,0 @@
-# Using external libraries in your Opal app
-
-As described in the getting started docs, opal uses a load path which works
-with sprockets to create a set of locations which opal can require files
-from. If you want to add a directory to this load path, you can add it to
-either the global environment, or a sprockets instance.
-
-### Global Environment
-
-In the `Opal` module, a property `paths` is used to hold the load paths which
-`Opal` uses to require files from. You can add a directory to this:
-
-```ruby
-Opal.append_path '../my_lib'
-```
-
-Now, any ruby files in this directory can be discovered.
-
-### Sprockets instances
-
-`Opal::Environment` is a subclass of the sprockets environment class which
-can have instance specific paths added to it. This class will inherit all
-global paths, but you can also add your instance paths as:
-
-```ruby
-env = Opal::Environment.new
-env.append_path '../my_lib'
-```
-
-## with Opal::Builder
-
-_WIP_
-
-## With opal-sprockets
-
-_WIP_

data/lib/mspec/opal/new.html.erb

@@ -1 +0,0 @@
-

data/lib/mspec/opal/rake_task.rb

@@ -1,248 +0,0 @@
-require 'opal'
-require 'rack'
-require 'webrick'
-require 'mspec/opal/special_calls'
-
-module MSpec
-  module Opal
-    DEFAULT_BASEDIR = 'spec'
-
-    require 'rake'
-    require 'rake/tasklib'
-    class RakeTask < ::Rake::TaskLib
-      include ::Rake::DSL if defined?(::Rake::DSL)
-
-      def initialize(name, &task_block)
-        namespace name do
-          desc 'Run MSpec::Opal code examples' unless ::Rake.application.last_comment
-          task :default do
-            puts 'Starting MSpec Runner...'
-            runner = Runner.new(&task_block)
-            runner.run
-          end
-
-          desc 'Build specs to build/specs.js and build/specs.min.js'
-          task :build do
-            require 'opal/util'
-            path = './build/specs.js'
-            min_path = './build/specs.min.js'
-            Environment.new.build_specs(path)
-            min = ::Opal::Util.uglify File.read(path)
-            File.open(min_path, 'w') { |f| f << min_path }
-          end
-        end
-
-        task name => "#{name}:default"
-      end
-    end
-
-    class Runner
-      def initialize &block
-        @app = Rack::Builder.new do
-          ::Opal::Processor.arity_check_enabled = true
-          ::Opal::Processor.dynamic_require_severity = :error
-
-          use Rack::ShowExceptions
-          use Rack::ShowStatus
-          use MSpec::Opal::Index
-          run MSpec::Opal::Environment.new
-        end
-
-        @port = 9999
-      end
-
-      attr_reader :app, :server
-      attr_accessor :port
-
-      def passed?
-        @passed
-      end
-
-      def run
-        start_server
-        start_phantomjs
-
-        exit 1 unless passed?
-      rescue => e
-        puts e.message
-      ensure
-        stop_server if server
-      end
-
-      def stop_server
-        server.kill
-      end
-
-      require 'opal/util'
-      class PhantomJS < ::Opal::Util::Command
-        require 'shellwords'
-
-        def initialize(runner, url)
-          runner = runner.shellescape
-          url    = url.shellescape
-          super 'phantomjs', "#{runner} #{url}", '. Please install PhantomJS'
-        end
-
-        def run
-          system "#{command} #{options}"
-        end
-      end
-
-      def start_phantomjs
-        runner  = File.expand_path('../sprockets.js', __FILE__).shellescape
-        url     = "http://localhost:#{port}/".shellescape
-        command = PhantomJS.new(runner, url)
-        @passed = command.run
-      end
-
-      def start_server
-        @server = Thread.new { Rack::Server.start(:app => app, :Port => port) }
-      end
-    end
-
-    class Environment < ::Sprockets::Environment
-      attr_reader :basedir, :pattern
-
-      def initialize(basedir = nil, pattern = nil)
-        @pattern = pattern
-        @basedir = basedir = File.expand_path(basedir || DEFAULT_BASEDIR)
-
-        ::Opal.append_path basedir
-        ::Opal.use_gem 'mspec'
-
-        stubs.each do |asset|
-          ::Opal::Processor.stub_file asset
-        end
-
-        ENV['OPAL_SPEC'] ||= files_to_run(pattern).join(',')
-
-        super()
-
-        ::Opal.paths.each { |p| append_path p }
-      end
-
-      def stubs
-        # missing stdlib
-        stubs = %w[fileutils iconv yaml]
-
-        # use x-strings which generate bad javascript
-        stubs << "mspec/helpers/tmp"
-        stubs << "mspec/helpers/environment"
-        stubs << "mspec/guards/block_device"
-        stubs << "mspec/guards/endian"
-
-        stubs
-      end
-
-      def specs
-        @specs ||= self['mspec/opal/main'] || raise("Cannot find mspec/opal/main inside #{paths.inspect}")
-      end
-
-      def build_min file = "#{basedir}/build/specs.min.js"
-        require 'opal/util'
-        build ::Opal::Util.uglify(specs.to_s), file
-      end
-
-      def files
-        @files ||= []
-      end
-
-      def add_files specs, tag = ''
-        tag = "[#{tag}] "
-        puts "#{tag}Adding #{specs.size} spec files..."
-        specs = specs.flatten.map do |path|
-          dirname = File.join([basedir, path])
-          if File.directory? dirname
-            rubyspec_paths_in_dir(dirname, path)
-          else
-            path
-          end
-        end.flatten
-        files.concat specs
-      end
-
-      def paths_from_glob pattern
-        Dir.glob(File.expand_path(pattern)).map do |s|
-          s.sub(/\A#{basedir}\//, '').sub(/\.rb\z/, '')
-        end
-      end
-
-      def rubyspec_paths_in_dir(dirname, path)
-        Dir.entries(dirname).select do |spec|
-          spec.end_with? '.rb'
-        end.map do |spec|
-          File.join path, spec
-        end
-      end
-
-      def rubyspec_white_list
-        File.read("#{basedir}/rubyspecs").split("\n").reject do |line|
-          line.sub(/#.*/, '').strip.empty? ||
-            (line.start_with?('!') && rubyspec_black_list.push(line.sub('!', '') + '.rb'))
-        end
-      end
-
-      def rubyspec_black_list
-        @rubyspec_black_list ||= []
-      end
-
-      def files_to_run(pattern=nil)
-        # add any filters in spec/filters of specs we dont want to run
-        add_files paths_from_glob("#{basedir}/filters/**/*.rb"), :filters
-
-        if pattern
-          # add custom opal specs from spec/
-          add_files paths_from_glob(pattern) & rubyspec_white_list, :rubyspec_custom
-          add_files paths_from_glob(pattern).grep(/(?!spec\/(corelib|stdlib)\/)/), :other_custom
-
-        else
-          # add opal specific specs
-          add_files paths_from_glob("#{basedir}/opal/**/*_spec.rb"),       :shared
-          add_files paths_from_glob("#{basedir}/lib/lexer_spec.rb"),       :lexer
-          add_files paths_from_glob("#{basedir}/lib/parser/**/*_spec.rb"), :parser
-
-          # add any rubyspecs we want to run (defined in spec/rubyspecs)
-          add_files rubyspec_white_list, :rubyspecs
-        end
-
-        files - rubyspec_black_list
-      end
-
-      def build_specs file = "#{basedir}/build/specs.js"
-        code = specs.to_s
-        FileUtils.mkdir_p File.dirname(file)
-        puts "Building #{file}..."
-        File.open(file, 'w+') { |o| o << code }
-      end
-    end
-
-    class Index
-      HTML = <<-HTML
-      <!DOCTYPE html>
-      <html>
-        <head>
-          <meta charset="UTF-8" />
-          <title>Opal Specs</title>
-        </head>
-        <body>
-          <script src="/mspec/opal/main.js"></script>
-          <script>Opal.load('mspec/opal/main');</script>
-        </body>
-      </html>
-      HTML
-
-      def initialize(app)
-        @app = app
-      end
-
-      def call(env)
-        if %w[/ /index.html].include? env['PATH_INFO']
-          [200, { 'Content-Type' => 'text/html' }, [HTML]]
-        else
-          @app.call env
-        end
-      end
-    end
-
-  end
-end

data/opal/corelib/match_data.rb

@@ -1,128 +0,0 @@
-class MatchData
-  attr_reader :post_match, :pre_match, :regexp, :string
-
-  def initialize(regexp, match_groups)
-    $~          = self
-    @regexp     = regexp
-    @begin      = `match_groups.index`
-    @string     = `match_groups.input`
-    @pre_match  = `match_groups.input.slice(0, match_groups.index)`
-    @post_match = `match_groups.input.slice(match_groups.index + match_groups[0].length)`
-    @matches    = []
-
-    %x{
-      for (var i = 0, length = match_groups.length; i < length; i++) {
-        var group = match_groups[i];
-
-        if (group == null) {
-          #@matches.push(nil);
-        }
-        else {
-          #@matches.push(group);
-        }
-      }
-    }
-  end
-
-  def [](*args)
-    @matches[*args]
-  end
-
-  def offset(n)
-    %x{
-      if (n !== 0) {
-        #{raise ArgumentError, 'MatchData#offset only supports 0th element'}
-      }
-      return [self.begin, self.begin + self.matches[n].length];
-    }
-  end
-
-  def ==(other)
-    return false unless MatchData === other
-
-    `self.string == other.string` &&
-    `self.regexp.toString() == other.regexp.toString()` &&
-    `self.pre_match == other.pre_match` &&
-    `self.post_match == other.post_match` &&
-    `self.begin == other.begin`
-  end
-
-  alias eql? ==
-
-  def begin(n)
-    %x{
-      if (n !== 0) {
-        #{raise ArgumentError, 'MatchData#begin only supports 0th element'}
-      }
-      return self.begin;
-    }
-  end
-
-  def end(n)
-    %x{
-      if (n !== 0) {
-        #{raise ArgumentError, 'MatchData#end only supports 0th element'}
-      }
-      return self.begin + self.matches[n].length;
-    }
-  end
-
-  def captures
-    `#@matches.slice(1)`
-  end
-
-  def inspect
-    %x{
-      var str = "#<MatchData " + #{`#@matches[0]`.inspect};
-
-      for (var i = 1, length = #@matches.length; i < length; i++) {
-        str += " " + i + ":" + #{`#@matches[i]`.inspect};
-      }
-
-      return str + ">";
-    }
-  end
-
-  def length
-    `#@matches.length`
-  end
-
-  alias size length
-
-  def to_a
-    @matches
-  end
-
-  def to_s
-    `#@matches[0]`
-  end
-
-  def values_at(*args)
-    %x{
-      var i, a, index, values = [];
-
-      for (i = 0; i < args.length; i++) {
-
-        if (args[i].$$is_range) {
-          a = #{`args[i]`.to_a};
-          a.unshift(i, 1);
-          Array.prototype.splice.apply(args, a);
-        }
-
-        index = #{Opal.coerce_to!(`args[i]`, Integer, :to_int)};
-
-        if (index < 0) {
-          index += #@matches.length;
-          if (index < 0) {
-            values.push(nil);
-            continue;
-          }
-        }
-
-        values.push(#@matches[index]);
-      }
-
-      return values;
-    }
-  end
-end

data/spec/filters/bugs/math.rb

@@ -1,95 +0,0 @@
-opal_filter "Math" do
-  fails "Math.erf returns a float"
-  fails "Math.erf returns the error function of the argument"
-  fails "Math.erf raises a TypeError if the argument cannot be coerced with Float()"
-  fails "Math.erf returns NaN given NaN"
-  fails "Math.erf raises a TypeError if the argument is nil"
-  fails "Math.erf accepts any argument that can be coerced with Float()"
-  fails "Math#erf is accessible as a private instance method"
-
-  fails "Math.erfc returns the complementary error function of the argument"
-
-  fails "Math.frexp returns the normalized fraction and exponent"
-  fails "Math.frexp raises a TypeError if the argument cannot be coerced with Float()"
-  fails "Math.frexp returns NaN given NaN"
-  fails "Math.frexp raises a TypeError if the argument is nil"
-  fails "Math.frexp accepts any argument that can be coerced with Float()"
-  fails "Math#frexp is accessible as a private instance method"
-
-  fails "Math.erfc returns a float"
-  fails "Math.erfc returns the complimentary error function of the argument"
-  fails "Math.erfc raises a TypeError if the argument cannot be coerced with Float()"
-  fails "Math.erfc returns NaN given NaN"
-  fails "Math.erfc raises a TypeError if the argument is nil"
-  fails "Math.erfc accepts any argument that can be coerced with Float()"
-  fails "Math#erfc is accessible as a private instance method"
-
-  fails "Math.ldexp returns a float"
-  fails "Math.ldexp returns the argument multiplied by 2**n"
-  fails "Math.ldexp raises a TypeError if the first argument cannot be coerced with Float()"
-  fails "Math.ldexp returns NaN given NaN"
-  fails "Math.ldexp raises RangeError if NaN is given as the second arg"
-  fails "Math.ldexp raises a TypeError if the second argument cannot be coerced with Integer()"
-  fails "Math.ldexp raises a TypeError if the first argument is nil"
-  fails "Math.ldexp raises a TypeError if the second argument is nil"
-  fails "Math.ldexp accepts any first argument that can be coerced with Float()"
-  fails "Math.ldexp accepts any second argument that can be coerced with Integer()"
-  fails "Math#ldexp is accessible as a private instance method"
-
-  fails "Math.cbrt returns a float"
-  fails "Math.cbrt returns the cubic root of the argument"
-  fails "Math.cbrt raises a TypeError if the argument cannot be coerced with Float()"
-  fails "Math.cbrt raises a TypeError if the argument is nil"
-  fails "Math.cbrt accepts any argument that can be coerced with Float()"
-
-  fails "Math.gamma returns +infinity given 0"
-  fails "Math.gamma returns -infinity given -0.0"
-  fails "Math.gamma returns Math.sqrt(Math::PI) given 0.5"
-  fails "Math.gamma returns exactly 1! given 2"
-  fails "Math.gamma returns exactly 2! given 3"
-  fails "Math.gamma returns exactly 3! given 4"
-  fails "Math.gamma returns exactly 4! given 5"
-  fails "Math.gamma returns exactly 5! given 6"
-  fails "Math.gamma returns exactly 6! given 7"
-  fails "Math.gamma returns exactly 7! given 8"
-  fails "Math.gamma returns exactly 8! given 9"
-  fails "Math.gamma returns exactly 9! given 10"
-  fails "Math.gamma returns exactly 10! given 11"
-  fails "Math.gamma returns exactly 11! given 12"
-  fails "Math.gamma returns exactly 12! given 13"
-  fails "Math.gamma returns exactly 13! given 14"
-  fails "Math.gamma returns exactly 14! given 15"
-  fails "Math.gamma returns exactly 15! given 16"
-  fails "Math.gamma returns exactly 16! given 17"
-  fails "Math.gamma returns exactly 17! given 18"
-  fails "Math.gamma returns exactly 18! given 19"
-  fails "Math.gamma returns exactly 19! given 20"
-  fails "Math.gamma returns exactly 20! given 21"
-  fails "Math.gamma returns exactly 21! given 22"
-  fails "Math.gamma returns exactly 22! given 23"
-  fails "Math.gamma returns approximately 23! given 24"
-  fails "Math.gamma returns approximately 24! given 25"
-  fails "Math.gamma returns approximately 25! given 26"
-  fails "Math.gamma returns approximately 26! given 27"
-  fails "Math.gamma returns approximately 27! given 28"
-  fails "Math.gamma returns approximately 28! given 29"
-  fails "Math.gamma returns approximately 29! given 30"
-  fails "Math.gamma returns good numerical approximation for gamma(3.2)"
-  fails "Math.gamma returns good numerical approximation for gamma(-2.15)"
-  fails "Math.gamma returns good numerical approximation for gamma(0.00001)"
-  fails "Math.gamma returns good numerical approximation for gamma(-0.00001)"
-  fails "Math.gamma raises Math::DomainError given -1"
-  fails "Math.gamma returns +infinity given +infinity"
-  fails "Math.gamma raises Math::DomainError given negative infinity"
-  fails "Math.gamma returns NaN given NaN"
-
-  fails "Math.lgamma returns [Infinity, 1] when passed 0"
-  fails "Math.lgamma returns [Infinity, 1] when passed -1"
-  fails "Math.lgamma returns [log(sqrt(PI)), 1] when passed 0.5"
-  fails "Math.lgamma returns [log(2/3*PI, 1] when passed 6.0"
-  fails "Math.lgamma returns an approximate value when passed -0.5"
-  fails "Math.lgamma returns an approximate value when passed -1.5"
-  fails "Math.lgamma raises Math::DomainError when passed -Infinity"
-  fails "Math.lgamma returns [Infinity, 1] when passed Infinity"
-  fails "Math.lgamma returns [NaN, 1] when passed NaN"
-end