opal-cj 0.7.0.beta1

data/stdlib/nodejs.rb

@@ -0,0 +1,5 @@
+require 'nodejs/runtime'
+require 'nodejs/file'
+require 'nodejs/dir'
+require 'nodejs/io'
+require 'nodejs/process'

data/stdlib/nodejs/dir.rb

@@ -0,0 +1,13 @@
+class Dir
+  @__glob__ = NodeJS.require :glob
+  `var __glob__ = #{@__glob__}`
+
+  def self.[] glob
+    `__glob__.sync(#{glob})`
+  end
+
+  def pwd
+    `process.cwd()`
+  end
+  alias getwd pwd
+end

data/stdlib/nodejs/file.rb

@@ -0,0 +1,98 @@
+class File < IO
+  include ::IO::Writable
+  include ::IO::Readable
+
+  @__fs__ = NodeJS.require :fs
+  @__path__ = NodeJS.require :path
+  `var __fs__ = #{@__fs__}`
+  `var __path__ = #{@__path__}`
+
+  def self.read path
+    `__fs__.readFileSync(#{path}).toString()`
+  end
+
+  def self.exist? path
+    `__fs__.existsSync(#{path})`
+  end
+
+  def self.realpath(pathname, dir_string = nil, cache = nil, &block)
+    pathname = join(dir_string, pathname) if dir_string
+    if block_given?
+      `
+      __fs__.realpath(#{pathname}, #{cache}, function(error, realpath){
+        if (error) #{raise error.message}
+        else #{block.call(`realpath`)}
+      })
+      `
+    else
+      `__fs__.realpathSync(#{pathname}, #{cache})`
+    end
+  end
+
+  def self.basename(path, ext = undefined)
+    `__path__.basename(#{path}, #{ext})`
+  end
+
+  def self.dirname(path)
+    `__path__.dirname(#{path})`
+  end
+
+  def self.join(*paths)
+    `__path__.join.apply(__path__, #{paths})`
+  end
+
+  def self.directory? path
+    return nil unless exist? path
+    `!!__fs__.lstatSync(path).isDirectory()`
+  end
+
+  def self.file? path
+    return nil unless exist? path
+    `!!__fs__.lstatSync(path).isFile()`
+  end
+
+  def self.size path
+    return nil unless exist? path
+    `__fs__.lstatSync(path).size`
+  end
+
+  def self.open path, flags
+    file = new(path, flags)
+    if block_given?
+      begin
+        yield(file)
+      ensure
+        file.close
+      end
+    else
+      file
+    end
+  end
+
+
+
+
+  # Instance Methods
+
+  def initialize(path, flags)
+    flags = flags.gsub(/b/, '')
+    @path = path
+    @flags = flags
+    @fd = `__fs__.openSync(path, flags)`
+  end
+
+  attr_reader :path
+
+  def write string
+    `__fs__.writeSync(#{@fd}, #{string}, null, #{string}.length)`
+  end
+
+  def flush
+    `__fs__.fsyncSync(#@fd)`
+  end
+
+  def close
+    `__fs__.closeSync(#{@fd})`
+  end
+end
+

data/stdlib/nodejs/fileutils.rb

@@ -0,0 +1,26 @@
+module FileUtils
+  extend self
+  `var __fs__ = #{File}.__fs__`
+
+  def mkdir_p path
+    return true if File.directory? path
+    `__fs__.mkdirSync(#{path})`
+  end
+
+  def cp source, target
+    target = File.join(target, File.basename(source)) if File.directory? target
+    `__fs__.writeFileSync(target, __fs__.readFileSync(source));`
+  end
+
+  def rm path
+    `__fs__.unlinkSync(path)`
+  end
+
+  def mv source, target
+    target = File.join(target, File.basename(source)) if File.directory? target
+    `__fs__.renameSync(source, target)`
+  end
+
+  alias mkpath mkdir_p
+  alias makedirs mkdir_p
+end

data/stdlib/nodejs/io.rb

@@ -0,0 +1,2 @@
+$stdout.write_proc = -> (string) {`process.stdout.write(#{string})`}
+$stderr.write_proc = -> (string) {`process.stderr.write(string)`}

data/stdlib/nodejs/irb.rb

@@ -0,0 +1,45 @@
+require 'native'
+
+NodeRepl = Native(`OpalNode.node_require('repl')`)
+
+def NodeRepl.start opations = {}
+  Native::Object.new(`#@native.start(#{opations.to_n})`)
+end
+
+line = 1
+prompt_interrupted = false
+
+prompt = ->(_self) {
+  tip = prompt_interrupted ? '*' : '>'
+  "irb(#{_self.to_s}):#{line.to_s.rjust(3, '0')}#{tip} "
+}
+
+$repl = NodeRepl.start prompt: prompt.call(self),
+                       useGlobal: true, ignoreUndefined: true,
+                       eval: -> (cmd, context, filename, callback) {
+  line += 1
+
+  cmd = cmd[1...-1].chomp
+
+  if cmd.empty?
+    prompt_interrupted = true
+    $repl.prompt = prompt.call(self)
+
+    callback.call('')
+    next
+  end
+
+  prompt_interrupted = false
+  $repl.prompt = prompt.call(self)
+
+  begin
+    result = `OpalNode.run(cmd, filename)`
+    result = nil if `#{result} == nil`
+    callback.call('=> '+result.inspect)
+  rescue => e
+    callback.call(e.backtrace.join("\n"))
+  end
+}
+
+# Add a newline before exiting
+$repl.on :exit, -> { puts }

data/stdlib/nodejs/process.rb

@@ -0,0 +1,16 @@
+module Kernel
+  def exit
+    `process.exit()`
+  end
+end
+
+ARGV = `process.argv.slice(2)`
+
+ENV = Object.new
+def ENV.[]= name, value
+  `process.env[#{name.to_s}] = #{value.to_s}`
+end
+
+def ENV.[] name
+  `process.env[#{name}] || nil`
+end

data/stdlib/nodejs/require.rb

@@ -0,0 +1,32 @@
+require 'opal-parser'
+
+module Kernel
+  def __prepare_require__(path)
+    name = `$opal.normalize_loadable_path(#{path})`
+    full_path = name.end_with?('.rb') ? name : name+'.rb'
+
+    if `!$opal.modules[#{name}]`
+      ruby = File.read(full_path)
+      compiler = Opal::Compiler.new(ruby, requirable: true, file: name)
+      js = compiler.compile
+      compiler.requires.each do |sub_path|
+        __prepare_require__(sub_path)
+      end
+      `eval(#{js})`
+    end
+
+    name
+  rescue => e
+    raise [path, name, full_path].inspect+e.message
+  end
+
+  def require path
+    name = __prepare_require__(path)
+    `$opal.require(#{name})`
+  end
+
+  def load path
+    name = __prepare_require__(path)
+    `$opal.load(#{name})`
+  end
+end

data/stdlib/nodejs/rubygems.rb

@@ -0,0 +1,68 @@
+require 'json'
+
+module Gem
+  class Install
+    def initialize(name, version)
+      @name = name
+      @version = version
+    end
+
+    def version
+      @version ||= latest_version(name)
+    end
+
+    def latest_version(name)
+      command = curl("https://rubygems.org/api/v1/versions/#{name}.json")
+      versions = JSON.parse system(command)
+      versions.first['number']
+    end
+
+    def full_name
+      "#{name}-#{version}"
+    end
+
+    def gem_home
+      ENV['HOME']+'/.opal-node/opal-gems/#{RUBY_ENGINE_VERSION}'
+    end
+
+    def gems_dir
+      File.join(gem_home, :gems)
+    end
+
+    def specs_dir
+      File.join(gem_home, :specs)
+    end
+
+    def perform
+      gem_dir = File.join(gems_dir, full_name)
+      spec_dir = File.join(specs_dir, full_name+'.yml')
+      system "mkdir -p #{gem_dir} #{spec_dir}"
+
+      Dir.chdir gem_dir do
+        system curl("https://rubygems.org/downloads/#{name}-#{version}.gem") + '| tar -xv'
+        system "gunzip metadata.gz --stdout > #{specs_dir}/#{full_name}.yml"
+        system "gunzip data.tar.gz"
+        system "tar -xvf data.tar"
+      end
+    end
+
+    def curl url
+      "curl -L #{url}"
+    end
+  end
+end
+
+command = ARGV.shift
+case command
+when 'install'
+  name = ARGV.shift
+  if ARGV.include? '-v'
+    version = ARGV[ ARGV.index('-v')+1 ]
+  else
+    version = nil
+  end
+  install = Gem::Install.new(name, version)
+  install.perform
+else
+  raise NotImplementedError, "sorry, the #{command.inspect} is not implemented."
+end

data/stdlib/nodejs/runtime.rb

@@ -0,0 +1,25 @@
+%x{
+// Generated by CoffeeScript 1.6.3
+(function() {
+  var OpalNode, extensions, fs, parser, parserFile, source, sourceFile, vm, __path__;
+  fs = require('fs');
+  __path__ = require('path');
+  vm = require('vm');
+  // vm.runInThisContext(parser, parserFile);
+  OpalNode = (function() {
+    function OpalNode() {}
+    OpalNode.node_require = require;
+    return OpalNode;
+  })();
+
+  global.OpalNode = OpalNode;
+
+}).call(this);
+}
+
+module NodeJS
+  def self.require name
+    `OpalNode.node_require(#{name})`
+  end
+end
+

data/stdlib/nodejs/yaml.rb

@@ -0,0 +1,11 @@
+require 'native'
+
+module YAML
+  `var __yaml__ = OpalNode.node_require('js-yaml')`
+
+  def self.load_path path
+    loaded = `__yaml__.yaml.safeLoad(#{File.__fs__}.readFileSync(#{path}, 'utf8'))`
+    loaded = Hash.new(loaded) if native?(loaded)
+    loaded
+  end
+end

data/stdlib/observer.rb

@@ -0,0 +1,202 @@
+#
+# Implementation of the _Observer_ object-oriented design pattern.  The
+# following documentation is copied, with modifications, from "Programming
+# Ruby", by Hunt and Thomas; http://www.ruby-doc.org/docs/ProgrammingRuby/html/lib_patterns.html.
+#
+# See Observable for more info.
+
+# The Observer pattern (also known as publish/subscribe) provides a simple
+# mechanism for one object to inform a set of interested third-party objects
+# when its state changes.
+#
+# == Mechanism
+#
+# The notifying class mixes in the +Observable+
+# module, which provides the methods for managing the associated observer
+# objects.
+#
+# The observers must implement a method called +update+ to receive
+# notifications.
+#
+# The observable object must:
+# * assert that it has +#changed+
+# * call +#notify_observers+
+#
+# === Example
+#
+# The following example demonstrates this nicely.  A +Ticker+, when run,
+# continually receives the stock +Price+ for its <tt>@symbol</tt>.  A +Warner+
+# is a general observer of the price, and two warners are demonstrated, a
+# +WarnLow+ and a +WarnHigh+, which print a warning if the price is below or
+# above their set limits, respectively.
+#
+# The +update+ callback allows the warners to run without being explicitly
+# called.  The system is set up with the +Ticker+ and several observers, and the
+# observers do their duty without the top-level code having to interfere.
+#
+# Note that the contract between publisher and subscriber (observable and
+# observer) is not declared or enforced.  The +Ticker+ publishes a time and a
+# price, and the warners receive that.  But if you don't ensure that your
+# contracts are correct, nothing else can warn you.
+#
+#   require "observer"
+#
+#   class Ticker          ### Periodically fetch a stock price.
+#     include Observable
+#
+#     def initialize(symbol)
+#       @symbol = symbol
+#     end
+#
+#     def run
+#       lastPrice = nil
+#       loop do
+#         price = Price.fetch(@symbol)
+#         print "Current price: #{price}\n"
+#         if price != lastPrice
+#           changed                 # notify observers
+#           lastPrice = price
+#           notify_observers(Time.now, price)
+#         end
+#         sleep 1
+#       end
+#     end
+#   end
+#
+#   class Price           ### A mock class to fetch a stock price (60 - 140).
+#     def Price.fetch(symbol)
+#       60 + rand(80)
+#     end
+#   end
+#
+#   class Warner          ### An abstract observer of Ticker objects.
+#     def initialize(ticker, limit)
+#       @limit = limit
+#       ticker.add_observer(self)
+#     end
+#   end
+#
+#   class WarnLow < Warner
+#     def update(time, price)       # callback for observer
+#       if price < @limit
+#         print "--- #{time.to_s}: Price below #@limit: #{price}\n"
+#       end
+#     end
+#   end
+#
+#   class WarnHigh < Warner
+#     def update(time, price)       # callback for observer
+#       if price > @limit
+#         print "+++ #{time.to_s}: Price above #@limit: #{price}\n"
+#       end
+#     end
+#   end
+#
+#   ticker = Ticker.new("MSFT")
+#   WarnLow.new(ticker, 80)
+#   WarnHigh.new(ticker, 120)
+#   ticker.run
+#
+# Produces:
+#
+#   Current price: 83
+#   Current price: 75
+#   --- Sun Jun 09 00:10:25 CDT 2002: Price below 80: 75
+#   Current price: 90
+#   Current price: 134
+#   +++ Sun Jun 09 00:10:25 CDT 2002: Price above 120: 134
+#   Current price: 134
+#   Current price: 112
+#   Current price: 79
+#   --- Sun Jun 09 00:10:25 CDT 2002: Price below 80: 79
+module Observable
+
+  #
+  # Add +observer+ as an observer on this object. so that it will receive
+  # notifications.
+  #
+  # +observer+:: the object that will be notified of changes.
+  # +func+:: Symbol naming the method that will be called when this Observable
+  #          has changes.
+  #
+  #          This method must return true for +observer.respond_to?+ and will
+  #          receive <tt>*arg</tt> when #notify_observers is called, where
+  #          <tt>*arg</tt> is the value passed to #notify_observers by this
+  #          Observable
+  def add_observer(observer, func=:update)
+    @observer_peers = {} unless defined? @observer_peers
+    unless observer.respond_to? func
+      raise NoMethodError, "observer does not respond to `#{func.to_s}'"
+    end
+    @observer_peers[observer] = func
+  end
+
+  #
+  # Remove +observer+ as an observer on this object so that it will no longer
+  # receive notifications.
+  #
+  # +observer+:: An observer of this Observable
+  def delete_observer(observer)
+    @observer_peers.delete observer if defined? @observer_peers
+  end
+
+  #
+  # Remove all observers associated with this object.
+  #
+  def delete_observers
+    @observer_peers.clear if defined? @observer_peers
+  end
+
+  #
+  # Return the number of observers associated with this object.
+  #
+  def count_observers
+    if defined? @observer_peers
+      @observer_peers.size
+    else
+      0
+    end
+  end
+
+  #
+  # Set the changed state of this object.  Notifications will be sent only if
+  # the changed +state+ is +true+.
+  #
+  # +state+:: Boolean indicating the changed state of this Observable.
+  #
+  def changed(state=true)
+    @observer_state = state
+  end
+
+  #
+  # Returns true if this object's state has been changed since the last
+  # #notify_observers call.
+  #
+  def changed?
+    if defined? @observer_state and @observer_state
+      true
+    else
+      false
+    end
+  end
+
+  #
+  # Notify observers of a change in state *if* this object's changed state is
+  # +true+.
+  #
+  # This will invoke the method named in #add_observer, passing <tt>*arg</tt>.
+  # The changed state is then set to +false+.
+  #
+  # <tt>*arg</tt>:: Any arguments to pass to the observers.
+  def notify_observers(*arg)
+    if defined? @observer_state and @observer_state
+      if defined? @observer_peers
+        @observer_peers.each do |k, v|
+          k.send v, *arg
+        end
+      end
+      @observer_state = false
+    end
+  end
+
+end