opal-wedge 0.9.0.dev

data/stdlib/opal-source-maps.rb

@@ -0,0 +1,2 @@
+require 'source_map'
+require 'opal/source_map'

data/stdlib/ostruct.rb

@@ -0,0 +1,69 @@
+class OpenStruct
+  def initialize(hash = nil)
+    @table = {}
+
+    hash.each_pair {|key, value|
+      @table[key.to_sym] = value
+    } if hash
+  end
+
+  def [](name)
+    @table[name.to_sym]
+  end
+
+  def []=(name, value)
+    @table[name.to_sym] = value
+  end
+
+  def method_missing(name, *args)
+    if name.end_with? '='
+      @table[name[0 .. -2].to_sym] = args[0]
+    else
+      @table[name.to_sym]
+    end
+  end
+
+  def each_pair
+    return enum_for :each_pair unless block_given?
+
+    @table.each_pair {|pair|
+      yield pair
+    }
+  end
+
+  def ==(other)
+    return false unless other.is_a?(OpenStruct)
+
+    @table == other.instance_variable_get(:@table)
+  end
+
+  def ===(other)
+    return false unless other.is_a?(OpenStruct)
+
+    @table === other.instance_variable_get(:@table)
+  end
+
+  def eql?(other)
+    return false unless other.is_a?(OpenStruct)
+
+    @table.eql? other.instance_variable_get(:@table)
+  end
+
+  def to_h
+    @table.dup
+  end
+
+  def to_n
+    @table.to_n
+  end
+
+  def hash
+    @table.hash
+  end
+
+  def inspect
+    "#<#{self.class}: #{each_pair.map {|name, value|
+      "#{name}=#{self[name].inspect}"
+    }.join(" ")}>"
+  end
+end

data/stdlib/pathname.rb

@@ -0,0 +1,55 @@
+class Pathname
+  def initialize(path)
+    raise ArgumentError if path == "\0"
+    @path = path
+  end
+
+  attr_reader :path
+
+  def == other
+    other.path == @path
+  end
+
+  def absolute?
+    @path.start_with? '/'
+  end
+
+  def relative?
+    !absolute?
+  end
+
+  def root?
+    @path == '/'
+  end
+
+  def parent
+    new_path = @path.sub(%r{/([^/]+/?$)}, '')
+    new_path = absolute? ? '/' : '.' if new_path == ''
+    Pathname.new(new_path)
+  end
+
+  def sub(*args)
+    Pathname.new(@path.sub(*args))
+  end
+
+  def cleanpath
+    `return Opal.normalize_loadable_path(#@path)`
+  end
+
+  def to_path
+    @path
+  end
+
+  def hash
+    @path
+  end
+
+  alias :to_str :to_path
+  alias :to_s :to_path
+end
+
+module Kernel
+  def Pathname(path)
+    Pathname.new(path)
+  end
+end

data/stdlib/phantomjs.rb

@@ -0,0 +1,3 @@
+`Opal.exit = function(status) { callPhantom(['exit', status]); };`
+STDOUT.write_proc = `function(str){callPhantom(['stdout', str])}`
+STDERR.write_proc = `function(str){callPhantom(['stderr', str])}`

data/stdlib/pp.rb

@@ -0,0 +1,35 @@
+module Kernel
+  def pretty_inspect
+    inspect
+  end
+
+  def pp(*objs)
+    objs.each {|obj|
+      PP.pp(obj)
+    }
+    objs.size <= 1 ? objs.first : objs
+  end
+  module_function :pp
+end
+
+class PP
+  class << self
+    if `(typeof(console) === "undefined" || typeof(console.log) === "undefined")`
+      def pp(obj, out=$stdout, width=79)
+        p(*args)
+      end
+    else
+      def pp(obj, out=`console`, width=79)
+        if `#{out} === console`
+          `console.log(obj)`
+        elsif String === out
+          out + obj.inspect + "\n"
+        else
+          out << obj.inspect + "\n"
+        end
+      end
+    end
+
+    alias :singleline_pp :pp
+  end
+end

data/stdlib/promise.rb

@@ -0,0 +1,427 @@
+# {Promise} is used to help structure asynchronous code.
+#
+# It is available in the Opal standard library, and can be required in any Opal
+# application:
+#
+#     require 'promise'
+#
+# ## Basic Usage
+#
+# Promises are created and returned as objects with the assumption that they
+# will eventually be resolved or rejected, but never both. A {Promise} has
+# a {#then} and {#fail} method (or one of their aliases) that can be used to
+# register a block that gets called once resolved or rejected.
+#
+#     promise = Promise.new
+#
+#     promise.then {
+#       puts "resolved!"
+#     }.fail {
+#       puts "rejected!"
+#     }
+#
+#     # some time later
+#     promise.resolve
+#
+#     # => "resolved!"
+#
+# It is important to remember that a promise can only be resolved or rejected
+# once, so the block will only ever be called once (or not at all).
+#
+# ## Resolving Promises
+#
+# To resolve a promise, means to inform the {Promise} that it has succeeded
+# or evaluated to a useful value. {#resolve} can be passed a value which is
+# then passed into the block handler:
+#
+#     def get_json
+#       promise = Promise.new
+#
+#       HTTP.get("some_url") do |req|
+#         promise.resolve req.json
+#       end
+#
+#       promise
+#     end
+#
+#     get_json.then do |json|
+#       puts "got some JSON from server"
+#     end
+#
+# ## Rejecting Promises
+#
+# Promises are also designed to handle error cases, or situations where an
+# outcome is not as expected. Taking the previous example, we can also pass
+# a value to a {#reject} call, which passes that object to the registered
+# {#fail} handler:
+#
+#     def get_json
+#       promise = Promise.new
+#
+#       HTTP.get("some_url") do |req|
+#         if req.ok?
+#           promise.resolve req.json
+#         else
+#           promise.reject req
+#         end
+#
+#       promise
+#     end
+#
+#     get_json.then {
+#       # ...
+#     }.fail { |req|
+#       puts "it went wrong: #{req.message}"
+#     }
+#
+# ## Chaining Promises
+#
+# Promises become even more useful when chained together. Each {#then} or
+# {#fail} call returns a new {Promise} which can be used to chain more and more
+# handlers together.
+#
+#     promise.then { wait_for_something }.then { do_something_else }
+#
+# Rejections are propagated through the entire chain, so a "catch all" handler
+# can be attached at the end of the tail:
+#
+#     promise.then { ... }.then { ... }.fail { ... }
+#
+# ## Composing Promises
+#
+# {Promise.when} can be used to wait for more than one promise to resolve (or
+# reject). Using the previous example, we could request two different json
+# requests and wait for both to finish:
+#
+#     Promise.when(get_json, get_json2).then |first, second|
+#       puts "got two json payloads: #{first}, #{second}"
+#     end
+#
+class Promise
+  def self.value(value)
+    new.resolve(value)
+  end
+
+  def self.error(value)
+    new.reject(value)
+  end
+
+  def self.when(*promises)
+    When.new(promises)
+  end
+
+  attr_reader :error, :prev, :next
+
+  def initialize(action = {})
+    @action = action
+
+    @realized  = false
+    @exception = false
+    @value     = nil
+    @error     = nil
+    @delayed   = false
+
+    @prev = nil
+    @next = nil
+  end
+
+  def value
+    if Promise === @value
+      @value.value
+    else
+      @value
+    end
+  end
+
+  def act?
+    @action.has_key?(:success) || @action.has_key?(:always)
+  end
+
+  def action
+    @action.keys
+  end
+
+  def exception?
+    @exception
+  end
+
+  def realized?
+    !!@realized
+  end
+
+  def resolved?
+    @realized == :resolve
+  end
+
+  def rejected?
+    @realized == :reject
+  end
+
+  def ^(promise)
+    promise << self
+    self    >> promise
+
+    promise
+  end
+
+  def <<(promise)
+    @prev = promise
+
+    self
+  end
+
+  def >>(promise)
+    @next = promise
+
+    if exception?
+      promise.reject(@delayed[0])
+    elsif resolved?
+      promise.resolve(@delayed ? @delayed[0] : value)
+    elsif rejected?
+      if !@action.has_key?(:failure) || Promise === (@delayed ? @delayed[0] : @error)
+        promise.reject(@delayed ? @delayed[0] : error)
+      elsif promise.action.include?(:always)
+        promise.reject(@delayed ? @delayed[0] : error)
+      end
+    end
+
+    self
+  end
+
+  def resolve(value = nil)
+    if realized?
+      raise ArgumentError, 'the promise has already been realized'
+    end
+
+    if Promise === value
+      return (value << @prev) ^ self
+    end
+
+    begin
+      if block = @action[:success] || @action[:always]
+        value = block.call(value)
+      end
+
+      resolve!(value)
+    rescue Exception => e
+      exception!(e)
+    end
+
+    self
+  end
+
+  def resolve!(value)
+    @realized = :resolve
+    @value    = value
+
+    if @next
+      @next.resolve(value)
+    else
+      @delayed = [value]
+    end
+  end
+
+  def reject(value = nil)
+    if realized?
+      raise ArgumentError, 'the promise has already been realized'
+    end
+
+    if Promise === value
+      return (value << @prev) ^ self
+    end
+
+    begin
+      if block = @action[:failure] || @action[:always]
+        value = block.call(value)
+      end
+
+      if @action.has_key?(:always)
+        resolve!(value)
+      else
+        reject!(value)
+      end
+    rescue Exception => e
+      exception!(e)
+    end
+
+    self
+  end
+
+  def reject!(value)
+    @realized = :reject
+    @error    = value
+
+    if @next
+      @next.reject(value)
+    else
+      @delayed = [value]
+    end
+  end
+
+  def exception!(error)
+    @exception = true
+
+    reject!(error)
+  end
+
+  def then(&block)
+    if @next
+      raise ArgumentError, 'a promise has already been chained'
+    end
+
+    self ^ Promise.new(success: block)
+  end
+
+  alias do then
+
+  def fail(&block)
+    if @next
+      raise ArgumentError, 'a promise has already been chained'
+    end
+
+    self ^ Promise.new(failure: block)
+  end
+
+  alias rescue fail
+  alias catch fail
+
+  def always(&block)
+    if @next
+      raise ArgumentError, 'a promise has already been chained'
+    end
+
+    self ^ Promise.new(always: block)
+  end
+
+  alias finally always
+  alias ensure always
+
+  def trace(depth = nil, &block)
+    if @next
+      raise ArgumentError, 'a promise has already been chained'
+    end
+
+    self ^ Trace.new(depth, block)
+  end
+
+  def inspect
+    result = "#<#{self.class}(#{object_id})"
+
+    if @next
+      result += " >> #{@next.inspect}"
+    end
+
+    if realized?
+      result += ": #{(@value || @error).inspect}>"
+    else
+      result += ">"
+    end
+
+    result
+  end
+
+  class Trace < self
+    def self.it(promise)
+      current = []
+
+      if promise.act? || promise.prev.nil?
+        current.push(promise.value)
+      end
+
+      if prev = promise.prev
+        current.concat(it(prev))
+      else
+        current
+      end
+    end
+
+    def initialize(depth, block)
+      @depth = depth
+
+      super success: -> {
+        trace = Trace.it(self).reverse
+        trace.pop
+
+        if depth && depth <= trace.length
+          trace.shift(trace.length - depth)
+        end
+
+        block.call(*trace)
+      }
+    end
+  end
+
+  class When < self
+    def initialize(promises = [])
+      super()
+
+      @wait = []
+
+      promises.each {|promise|
+        wait promise
+      }
+    end
+
+    def each(&block)
+      raise ArgumentError, 'no block given' unless block
+
+      self.then {|values|
+        values.each(&block)
+      }
+    end
+
+    def collect(&block)
+      raise ArgumentError, 'no block given' unless block
+
+      self.then {|values|
+        When.new(values.map(&block))
+      }
+    end
+
+    def inject(*args, &block)
+      self.then {|values|
+        values.reduce(*args, &block)
+      }
+    end
+
+    alias map collect
+
+    alias reduce inject
+
+    def wait(promise)
+      unless Promise === promise
+        promise = Promise.value(promise)
+      end
+
+      if promise.act?
+        promise = promise.then
+      end
+
+      @wait << promise
+
+      promise.always {
+        try if @next
+      }
+
+      self
+    end
+
+    alias and wait
+
+    def >>(*)
+      super.tap {
+        try
+      }
+    end
+
+    def try
+      if @wait.all?(&:realized?)
+        if promise = @wait.find(&:rejected?)
+          reject(promise.error)
+        else
+          resolve(@wait.map(&:value))
+        end
+      end
+    end
+  end
+end