opal 0.10.0 → 0.11.0

data/opal/corelib/file.rb

@@ -4,230 +4,139 @@ class File < IO
   PATH_SEPARATOR = ':'
   # Assuming case insenstive filesystem
   FNM_SYSCASE = 0
+  windows_root_rx = /^[a-zA-Z]:(?:\\|\/)/
 
   class << self
     def expand_path(path, basedir = nil)
-      path = [basedir, path].compact.join(SEPARATOR)
-      parts = path.split(SEPARATOR)
+      sep = SEPARATOR
+      sep_chars = `$sep_chars()`
       new_parts = []
-      parts[0] = Dir.home if parts.first == '~'
-      parts[0] = Dir.pwd if parts.first == '.'
 
-      parts.each do |part|
-        if part == '..'
-          new_parts.pop
-        else
-          new_parts << part
-        end
+      if `path[0] === '~' || (basedir && basedir[0] === '~')`
+        home = Dir.home
+        raise(ArgumentError, "couldn't find HOME environment -- expanding `~'") unless home
+        raise(ArgumentError, "non-absolute home") unless home.start_with?(sep)
+
+        home            += sep
+        home_path_regexp = /^\~(?:#{sep}|$)/
+        path             = path.sub(home_path_regexp, home)
+        basedir          = basedir.sub(home_path_regexp, home) if basedir
       end
-      new_parts.join(SEPARATOR)
-    end
-    alias realpath expand_path
 
-    %x{
-      function chompdirsep(path) {
-        var last;
+      basedir     = Dir.pwd unless basedir
+      path_abs    = `path.substr(0, sep.length) === sep || windows_root_rx.test(path)`
+      basedir_abs = `basedir.substr(0, sep.length) === sep || windows_root_rx.test(basedir)`
+
+      if path_abs
+        parts       = path.split(/[#{sep_chars}]/)
+        leading_sep = `windows_root_rx.test(path) ? '' : #{path.sub(/^([#{sep_chars}]+).*$/, '\1')}`
+        abs         = true
+      else
+        parts       = basedir.split(/[#{sep_chars}]/) + path.split(/[#{sep_chars}]/)
+        leading_sep = `windows_root_rx.test(basedir) ? '' : #{basedir.sub(/^([#{sep_chars}]+).*$/, '\1')}`
+        abs         = basedir_abs
+      end
 
-        while (path.length > 0) {
-          if (isDirSep(path)) {
-            last = path;
-            path = path.substring(1, path.length);
-            while (path.length > 0 && isDirSep(path)) {
-              path = inc(path);
-            }
-            if (path.length == 0) {
-              return last;
-            }
+      %x{
+        var part;
+        for (var i = 0, ii = parts.length; i < ii; i++) {
+          part = parts[i];
+
+          if (
+            (part === nil) ||
+            (part === ''  && ((new_parts.length === 0) || abs)) ||
+            (part === '.' && ((new_parts.length === 0) || abs))
+          ) {
+            continue;
           }
-          else {
-            path = inc(path);
+          if (part === '..') {
+            new_parts.pop();
+          } else {
+            new_parts.push(part);
           }
         }
-        return path;
-      }
-
-      function inc(a) {
-        return a.substring(1, a.length);
-      }
 
-      function skipprefix(path) {
-        return path;
+        if (!abs && parts[0] !== '.') {
+          #{new_parts.unshift '.'}
+        }
       }
 
-      function lastSeparator(path) {
-        var tmp, last;
-
-        while (path.length > 0) {
-          if (isDirSep(path)) {
-            tmp = path;
-            path = inc(path);
+      new_path = new_parts.join(sep)
+      new_path = leading_sep+new_path if abs
+      new_path
+    end
+    alias realpath expand_path
 
-            while (path.length > 0 && isDirSep(path)) {
-              path = inc(path);
-            }
-            if (!path) {
-              break;
-            }
-            last = tmp;
-          }
-          else {
-            path = inc(path);
-          }
+    %x{
+      // Coerce a given path to a path string using #to_path and #to_str
+      function $coerce_to_path(path) {
+        if (#{Opal.truthy?(`path`.respond_to?(:to_path))}) {
+          path = path.$to_path();
         }
 
-        return last;
-      }
-
-      function isDirSep(sep) {
-        return sep.charAt(0) === #{SEPARATOR};
-      }
+        path = #{Opal.coerce_to!(`path`, String, :to_str)};
 
-      function skipRoot(path) {
-        while (path.length > 0 && isDirSep(path)) {
-          path = inc(path);
-        }
         return path;
       }
 
-      function pointerSubtract(a, b) {
-        if (a.length == 0) {
-          return b.length;
-        }
-        return b.indexOf(a);
-      }
-
-      function handleSuffix(n, f, p, suffix, name, origName) {
-        var suffixMatch;
-
-        if (n >= 0) {
-          if (suffix === nil) {
-            f = n;
-          }
-          else {
-            suffixMatch = suffix === '.*' ? '\\.\\w+' : suffix.replace(/\?/g, '\\?');
-            suffixMatch = new RegExp(suffixMatch + #{Separator} + '*$').exec(p);
-            if (suffixMatch) {
-              f = suffixMatch.index;
-            }
-            else {
-              f = n;
-            }
-          }
-
-          if (f === origName.length) {
-            return name;
-          }
+      // Return a RegExp compatible char class
+      function $sep_chars() {
+        if (#{ALT_SEPARATOR} === nil) {
+          return Opal.escape_regexp(#{SEPARATOR});
+        } else {
+          return Opal.escape_regexp(#{SEPARATOR+ALT_SEPARATOR});
         }
-
-        return p.substring(0, f);
       }
     }
 
     def dirname(path)
+      sep_chars = `$sep_chars()`
+      path = `$coerce_to_path(path)`
       %x{
-        if (path === nil) {
-          #{raise TypeError, 'no implicit conversion of nil into String'}
-        }
-        if (#{path.respond_to?(:to_path)}) {
-          path = #{path.to_path};
-        }
-        if (!path.$$is_string) {
-          #{raise TypeError, "no implicit conversion of #{path.class} into String"}
-        }
-
-        var root, p;
+        var absolute = path.match(new RegExp(#{"^[#{sep_chars}]"}));
 
-        root = skipRoot(path);
+        path = path.replace(new RegExp(#{"[#{sep_chars}]+$"}), ''); // remove trailing separators
+        path = path.replace(new RegExp(#{"[^#{sep_chars}]+$"}), ''); // remove trailing basename
+        path = path.replace(new RegExp(#{"[#{sep_chars}]+$"}), ''); // remove final trailing separators
 
-        // if (root > name + 1) in the C code
-        if (root.length == 0) {
-          path = path.substring(path.length - 1, path.length);
-        }
-        else if (root.length - path.length < 0) {
-          path = path.substring(path.indexOf(root)-1, path.length);
+        if (path === '') {
+          return absolute ? '/' : '.';
         }
 
-        p = lastSeparator(root);
-        if (!p) {
-          p = root;
-        }
-        if (p === path) {
-          return '.';
-        }
-        return path.substring(0, path.length - p.length);
+        return path;
       }
     end
 
     def basename(name, suffix=nil)
+      sep_chars = `$sep_chars()`
+      name = `$coerce_to_path(name)`
       %x{
-        var p, q, e, f = 0, n = -1, tmp, pointerMath, origName;
-
-        if (name === nil) {
-          #{raise TypeError, 'no implicit conversion of nil into String'}
-        }
-        if (#{name.respond_to?(:to_path)}) {
-          name = #{name.to_path};
-        }
-        if (!name.$$is_string) {
-          #{raise TypeError, "no implicit conversion of #{name.class} into String"}
-        }
-        if (suffix !== nil && !suffix.$$is_string) {
-          #{raise TypeError, "no implicit conversion of #{suffix.class} into String"}
-        }
-
         if (name.length == 0) {
           return name;
         }
 
-        origName = name;
-        name = skipprefix(name);
-
-        while (isDirSep(name)) {
-          tmp = name;
-          name = inc(name);
-        }
-
-        if (!name) {
-          p = tmp;
-          f = 1;
+        if (suffix !== nil) {
+          suffix = #{Opal.coerce_to!(suffix, String, :to_str)}
+        } else {
+          suffix = null;
         }
-        else {
-          if (!(p = lastSeparator(name))) {
-            p = name;
-          }
-          else {
-            while (isDirSep(p)) {
-              p = inc(p);
-            }
-          }
-
-          n = pointerSubtract(chompdirsep(p), p);
 
-          for (q = p; pointerSubtract(q, p) < n && q.charAt(0) === '.'; q = inc(q)) {
-          }
-
-          for (e = null; pointerSubtract(q, p) < n; q = inc(q)) {
-            if (q.charAt(0) === '.') {
-              e = q;
-            }
-          }
+        name = name.replace(new RegExp(#{"(.)[#{sep_chars}]*$"}), '$1');
+        name = name.replace(new RegExp(#{"^(?:.*[#{sep_chars}])?([^#{sep_chars}]+)$"}), '$1');
 
-          if (e) {
-            f = pointerSubtract(e, p);
-          }
-          else {
-            f = n;
-          }
+        if (suffix === ".*") {
+          name = name.replace(/\.[^\.]+$/, '');
+        } else if(suffix !== null) {
+          suffix = Opal.escape_regexp(suffix);
+          name = name.replace(new RegExp(#{"#{suffix}$"}), '');
         }
 
-        return handleSuffix(n, f, p, suffix, name, origName);
+        return name;
       }
     end
 
     def extname(path)
-      raise TypeError, 'no implicit conversion of nil into String' if path.nil?
-      path = path.to_path if path.respond_to?(:to_path)
-      raise TypeError, "no implicit conversion of #{path.class} into String" unless path.is_a?(String)
+      `path = $coerce_to_path(path);`
       filename = basename(path)
       return '' if filename.empty?
       last_dot_idx = filename[1..-1].rindex('.')
@@ -255,7 +164,36 @@ class File < IO
     end
 
     def join(*paths)
-      paths.join(SEPARATOR).gsub(%r{#{SEPARATOR}+}, SEPARATOR)
+      if paths.length == 0
+        return ''
+      end
+      result = ''
+      paths = paths.flatten.each_with_index.map do |item, index|
+        if index == 0 && item.empty?
+          SEPARATOR
+        elsif paths.length == index + 1 && item.empty?
+          SEPARATOR
+        else
+          item
+        end
+      end
+      paths = paths.reject { |path| path.empty? }
+      paths.each_with_index do |item, index|
+        next_item = paths[index + 1]
+        if next_item.nil?
+          result = "#{result}#{item}"
+        else
+          if item.end_with?(SEPARATOR) && next_item.start_with?(SEPARATOR)
+            item = item.sub(%r{#{SEPARATOR}+$}, '')
+          end
+          if item.end_with?(SEPARATOR) || next_item.start_with?(SEPARATOR)
+            result = "#{result}#{item}"
+          else
+            result = "#{result}#{item}#{SEPARATOR}"
+          end
+        end
+      end
+      result
     end
 
     def split(path)

data/opal/corelib/hash.rb

@@ -1,5 +1,13 @@
 require 'corelib/enumerable'
 
+# ---
+# Internal properties:
+#
+# - $$map         [JS::Object<String => hash-bucket>] the hash table for ordinary keys
+# - $$smap        [JS::Object<String => hash-bucket>] the hash table for string keys
+# - $$keys        [Array<hash-bucket>] the list of all keys
+# - $$proc        [Proc,null,nil] the default proc used for missing keys
+# - hash-bucket   [JS::Object] an element of a linked list that holds hash values, keys are `{key:,key_hash:,value:,next:}`
 class Hash
   include Enumerable
 
@@ -117,6 +125,53 @@ class Hash
     }
   end
 
+  def >=(other)
+    other = Opal.coerce_to!(other, Hash, :to_hash)
+
+    %x{
+      if (self.$$keys.length < other.$$keys.length) {
+        return false
+      }
+    }
+
+    result = true
+
+    other.each do |other_key, other_val|
+      val = fetch(other_key, `null`)
+
+      %x{
+        if (val == null || val !== other_val) {
+          result = false;
+          return;
+        }
+      }
+    end
+
+    result
+  end
+
+  def >(other)
+    other = Opal.coerce_to!(other, Hash, :to_hash)
+
+    %x{
+      if (self.$$keys.length <= other.$$keys.length) {
+        return false
+      }
+    }
+
+    self >= other
+  end
+
+  def <(other)
+    other = Opal.coerce_to!(other, Hash, :to_hash)
+    other > self
+  end
+
+  def <=(other)
+    other = Opal.coerce_to!(other, Hash, :to_hash)
+    other >= self
+  end
+
   def [](key)
     %x{
       var value = Opal.hash_get(self, key);
@@ -174,6 +229,84 @@ class Hash
     }
   end
 
+  def compact
+    %x{
+      var hash = Opal.hash();
+
+      for (var i = 0, keys = self.$$keys, length = keys.length, key, value, obj; i < length; i++) {
+        key = keys[i];
+
+        if (key.$$is_string) {
+          value = self.$$smap[key];
+        } else {
+          value = key.value;
+          key = key.key;
+        }
+
+        if (value !== nil) {
+          Opal.hash_put(hash, key, value);
+        }
+      }
+
+      return hash;
+    }
+  end
+
+  def compact!
+    %x{
+      var changes_were_made = false;
+
+      for (var i = 0, keys = self.$$keys, length = keys.length, key, value, obj; i < length; i++) {
+        key = keys[i];
+
+        if (key.$$is_string) {
+          value = self.$$smap[key];
+        } else {
+          value = key.value;
+          key = key.key;
+        }
+
+        if (value === nil) {
+          if (Opal.hash_delete(self, key) !== undefined) {
+            changes_were_made = true;
+            length--;
+            i--;
+          }
+        }
+      }
+
+      return changes_were_made ? self : nil;
+    }
+  end
+
+  def compare_by_identity
+    %x{
+      var i, ii, key, keys = self.$$keys, identity_hash;
+
+      if (self.$$by_identity) return self;
+      if (self.$$keys.length === 0) {
+        self.$$by_identity = true
+        return self;
+      }
+
+      identity_hash = #{ {}.compare_by_identity };
+      for(i = 0, ii = keys.length; i < ii; i++) {
+        key = keys[i];
+        if (!key.$$is_string) key = key.key;
+        Opal.hash_put(identity_hash, key, Opal.hash_get(self, key));
+      }
+
+      self.$$by_identity = true;
+      self.$$map = identity_hash.$$map;
+      self.$$smap = identity_hash.$$smap;
+      return self;
+    }
+  end
+
+  def compare_by_identity?
+    `self.$$by_identity === true`
+  end
+
   def default(key = undefined)
     %x{
       if (key !== undefined && self.$$proc !== nil && self.$$proc !== undefined) {
@@ -204,12 +337,14 @@ class Hash
     }
   end
 
-  def default_proc=(proc)
+  def default_proc=(default_proc)
     %x{
+      var proc = default_proc;
+
       if (proc !== nil) {
-        proc = #{Opal.coerce_to!(proc, Proc, :to_proc)};
+        proc = #{Opal.coerce_to!(`proc`, Proc, :to_proc)};
 
-        if (#{proc.lambda?} && #{proc.arity.abs} !== 2) {
+        if (#{`proc`.lambda?} && #{`proc`.arity.abs} !== 2) {
           #{raise TypeError, 'default_proc takes two arguments'};
         }
       }
@@ -217,7 +352,7 @@ class Hash
       self.$$none = nil;
       self.$$proc = proc;
 
-      return proc;
+      return default_proc;
     }
   end
 
@@ -267,6 +402,22 @@ class Hash
 
   alias dup clone
 
+  def dig(key, *keys)
+    item = self[key]
+
+    %x{
+      if (item === nil || keys.length === 0) {
+        return item;
+      }
+    }
+
+    unless item.respond_to?(:dig)
+      raise TypeError, "#{item.class} does not have #dig method"
+    end
+
+    item.dig(*keys)
+  end
+
   def each(&block)
     return enum_for(:each){self.size} unless block
 
@@ -344,6 +495,10 @@ class Hash
     raise KeyError, "key not found: #{key.inspect}"
   end
 
+  def fetch_values(*keys, &block)
+    keys.map { |key| fetch(key, &block) }
+  end
+
   def flatten(level = 1)
     level = Opal.coerce_to!(level, Integer, :to_int)
 
@@ -406,19 +561,17 @@ class Hash
 
       try {
         if (top) {
-          Opal.hash_ids = {};
+          Opal.hash_ids = Object.create(null);
         }
 
-        if (Opal.hash_ids.hasOwnProperty(hash_id)) {
+        if (Opal[hash_id]) {
           return 'self';
         }
 
         for (key in Opal.hash_ids) {
-          if (Opal.hash_ids.hasOwnProperty(key)) {
-            item = Opal.hash_ids[key];
-            if (#{eql?(`item`)}) {
-              return 'self';
-            }
+          item = Opal.hash_ids[key];
+          if (#{eql?(`item`)}) {
+            return 'self';
           }
         }
 
@@ -438,7 +591,7 @@ class Hash
 
       } finally {
         if (top) {
-          delete Opal.hash_ids;
+          Opal.hash_ids = undefined;
         }
       }
     }
@@ -614,7 +767,7 @@ class Hash
 
   def merge!(other, &block)
     %x{
-      if (!#{Hash === other}) {
+      if (!other.$$is_hash) {
         other = #{Opal.coerce_to!(other, Hash, :to_hash)};
       }
 
@@ -895,8 +1048,68 @@ class Hash
     self
   end
 
+  def to_proc
+    proc do |key = undefined|
+      %x{
+        if (key == null) {
+          #{raise ArgumentError, "no key given"}
+        }
+      }
+
+      self[key]
+    end
+  end
+
   alias to_s inspect
 
+  def transform_values(&block)
+    return enum_for(:transform_values){self.size} unless block
+
+    %x{
+      var result = Opal.hash();
+
+      for (var i = 0, keys = self.$$keys, length = keys.length, key, value; i < length; i++) {
+        key = keys[i];
+
+        if (key.$$is_string) {
+          value = self.$$smap[key];
+        } else {
+          value = key.value;
+          key = key.key;
+        }
+
+        value = Opal.yield1(block, value);
+
+        Opal.hash_put(result, key, value);
+      }
+
+      return result;
+    }
+  end
+
+  def transform_values!(&block)
+    return enum_for(:transform_values!){self.size} unless block
+
+    %x{
+      for (var i = 0, keys = self.$$keys, length = keys.length, key, value; i < length; i++) {
+        key = keys[i];
+
+        if (key.$$is_string) {
+          value = self.$$smap[key];
+        } else {
+          value = key.value;
+          key = key.key;
+        }
+
+        value = Opal.yield1(block, value);
+
+        Opal.hash_put(self, key, value);
+      }
+
+      return self;
+    }
+  end
+
   alias update merge!
 
   alias value? has_value?