opal-file 0.1.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4cdaf48c60594a394f17039dd51c54f6f84e3311
-  data.tar.gz: 4935595496fbe84a04aff2b1955ce29f5a2608d6
+  metadata.gz: b7e6065ecbca73e83f6eedfe6be90d7bdbf17f3c
+  data.tar.gz: d0295aee4b30ce3608cd7b13e8dba7cc65f9858c
 SHA512:
-  metadata.gz: 4e6da2e9346f5ee018e1a8482456acf0f09abdf9327cbe4c9bccb4af670532b88dd9f48ecc0e3d64718420b2a401220583cbacd09c6efb6aa7388876117ed1d6
-  data.tar.gz: d12a6a647a146f9ebdbba4e0f3fdc19b149d037492fa7abac6c76cb9862ebfd62ccf397b8a2b8f85e0d8be6fa258914fb46ae6dcc3d2851cec920a46dc101bcd
+  metadata.gz: caf7dbb1c3daf3086b8c33d73b95808293e92c1ddabb179231ee8eec326ea0bfe4702225219a4ae28a94970964c2dad5b71b72e1f4cfa5d0067f3286ae8a2c0d
+  data.tar.gz: 41b1823fdb3d1d9ab710222a4ee0ee8e52362f6345da844a353d69f36a0566242480065760798d369292a281ea43f22a566a78d608cf29c8db06b2ef015d179c

data/README.md

@@ -6,13 +6,12 @@ native File.read, File.write etc... for Opal
 
 Opal's File class does not have methods for file IO but this module provides them.
 
-### Limitation
+This provides...
 
-This provides only methods listed below.
-
-- read
-- write
-- unlink
+- `File` (partial; no #open and #new)
+- `File::Stat` (partial)
+- `FileTest` (partial)
+- `Errno::EXXX`
 
 Pull requests are welcome!
 

data/lib/opal-errno.rb

@@ -0,0 +1,137 @@
+if RUBY_ENGINE == "opal"
+  module Errno
+    class EPERM   < SystemCallError; Errno =  1; end
+    class ENOENT  < SystemCallError; Errno =  2; end
+    class ESRCH   < SystemCallError; Errno =  3; end
+    class EINTR   < SystemCallError; Errno =  4; end
+    class EIO     < SystemCallError; Errno =  5; end
+    class ENXIO   < SystemCallError; Errno =  6; end
+    class E2BIG   < SystemCallError; Errno =  7; end
+    class ENOEXEC < SystemCallError; Errno =  8; end
+    class EBADF   < SystemCallError; Errno =  9; end
+    class ECHILD  < SystemCallError; Errno = 10; end
+    class EAGAIN  < SystemCallError; Errno = 11; end
+    class ENOMEM  < SystemCallError; Errno = 12; end
+    class EACCES  < SystemCallError; Errno = 13; end
+    class EFAULT  < SystemCallError; Errno = 14; end
+    class ENOTBLK < SystemCallError; Errno = 15; end
+    class EBUSY   < SystemCallError; Errno = 16; end
+    class EEXIST  < SystemCallError; Errno = 17; end
+    class EXDEV   < SystemCallError; Errno = 18; end
+    class ENODEV  < SystemCallError; Errno = 19; end
+    class ENOTDIR < SystemCallError; Errno = 20; end
+    class EISDIR  < SystemCallError; Errno = 21; end
+    class EINVAL  < SystemCallError; Errno = 22; end
+    class ENFILE  < SystemCallError; Errno = 23; end
+    class EMFILE  < SystemCallError; Errno = 24; end
+    class ENOTTY  < SystemCallError; Errno = 25; end
+    class ETXTBSY < SystemCallError; Errno = 26; end
+    class EFBIG   < SystemCallError; Errno = 27; end
+    class ENOSPC  < SystemCallError; Errno = 28; end
+    class ESPIPE  < SystemCallError; Errno = 29; end
+    class EROFS   < SystemCallError; Errno = 30; end
+    class EMLINK  < SystemCallError; Errno = 31; end
+    class EPIPE   < SystemCallError; Errno = 32; end
+    class EDOM    < SystemCallError; Errno = 33; end
+    class ERANGE  < SystemCallError; Errno = 34; end
+    class EDEADLK      < SystemCallError; Errno = 35; end
+    class ENAMETOOLONG < SystemCallError; Errno = 36; end
+    class ENOLCK       < SystemCallError; Errno = 37; end
+    class ENOSYS       < SystemCallError; Errno = 38; end
+    class ENOTEMPTY    < SystemCallError; Errno = 39; end
+    class ELOOP        < SystemCallError; Errno = 40; end
+    class EWOULDBLOCK  < SystemCallError; Errno = EAGAIN::Errno; end
+    class ENOMSG       < SystemCallError; Errno = 42; end
+    class EIDRM        < SystemCallError; Errno = 43; end
+    class ECHRNG       < SystemCallError; Errno = 44; end
+    class EL2NSYNC     < SystemCallError; Errno = 45; end
+    class EL3HLT       < SystemCallError; Errno = 46; end
+    class EL3RST       < SystemCallError; Errno = 47; end
+    class ELNRNG       < SystemCallError; Errno = 48; end
+    class EUNATCH      < SystemCallError; Errno = 49; end
+    class ENOCSI       < SystemCallError; Errno = 50; end
+    class EL2HLT       < SystemCallError; Errno = 51; end
+    class EBADE        < SystemCallError; Errno = 52; end
+    class EBADR        < SystemCallError; Errno = 53; end
+    class EXFULL       < SystemCallError; Errno = 54; end
+    class ENOANO       < SystemCallError; Errno = 55; end
+    class EBADRQC      < SystemCallError; Errno = 56; end
+    class EBADSLT      < SystemCallError; Errno = 57; end
+    class EDEADLOCK    < SystemCallError; Errno = EDEADLK::Errno; end
+    class EBFONT          < SystemCallError; Errno = 59 ; end
+    class ENOSTR          < SystemCallError; Errno = 60 ; end
+    class ENODATA         < SystemCallError; Errno = 61 ; end
+    class ETIME           < SystemCallError; Errno = 62 ; end
+    class ENOSR           < SystemCallError; Errno = 63 ; end
+    class ENONET          < SystemCallError; Errno = 64 ; end
+    class ENOPKG          < SystemCallError; Errno = 65 ; end
+    class EREMOTE         < SystemCallError; Errno = 66 ; end
+    class ENOLINK         < SystemCallError; Errno = 67 ; end
+    class EADV            < SystemCallError; Errno = 68 ; end
+    class ESRMNT          < SystemCallError; Errno = 69 ; end
+    class ECOMM           < SystemCallError; Errno = 70 ; end
+    class EPROTO          < SystemCallError; Errno = 71 ; end
+    class EMULTIHOP       < SystemCallError; Errno = 72 ; end
+    class EDOTDOT         < SystemCallError; Errno = 73 ; end
+    class EBADMSG         < SystemCallError; Errno = 74 ; end
+    class EOVERFLOW       < SystemCallError; Errno = 75 ; end
+    class ENOTUNIQ        < SystemCallError; Errno = 76 ; end
+    class EBADFD          < SystemCallError; Errno = 77 ; end
+    class EREMCHG         < SystemCallError; Errno = 78 ; end
+    class ELIBACC         < SystemCallError; Errno = 79 ; end
+    class ELIBBAD         < SystemCallError; Errno = 80 ; end
+    class ELIBSCN         < SystemCallError; Errno = 81 ; end
+    class ELIBMAX         < SystemCallError; Errno = 82 ; end
+    class ELIBEXEC        < SystemCallError; Errno = 83 ; end
+    class EILSEQ          < SystemCallError; Errno = 84 ; end
+    class ERESTART        < SystemCallError; Errno = 85 ; end
+    class ESTRPIPE        < SystemCallError; Errno = 86 ; end
+    class EUSERS          < SystemCallError; Errno = 87 ; end
+    class ENOTSOCK        < SystemCallError; Errno = 88 ; end
+    class EDESTADDRREQ    < SystemCallError; Errno = 89 ; end
+    class EMSGSIZE        < SystemCallError; Errno = 90 ; end
+    class EPROTOTYPE      < SystemCallError; Errno = 91 ; end
+    class ENOPROTOOPT     < SystemCallError; Errno = 92 ; end
+    class EPROTONOSUPPORT < SystemCallError; Errno = 93 ; end
+    class ESOCKTNOSUPPORT < SystemCallError; Errno = 94 ; end
+    class EOPNOTSUPP      < SystemCallError; Errno = 95 ; end
+    class EPFNOSUPPORT    < SystemCallError; Errno = 96 ; end
+    class EAFNOSUPPORT    < SystemCallError; Errno = 97 ; end
+    class EADDRINUSE      < SystemCallError; Errno = 98 ; end
+    class EADDRNOTAVAIL   < SystemCallError; Errno = 99 ; end
+    class ENETDOWN        < SystemCallError; Errno = 100; end
+    class ENETUNREACH     < SystemCallError; Errno = 101; end
+    class ENETRESET       < SystemCallError; Errno = 102; end
+    class ECONNABORTED    < SystemCallError; Errno = 103; end
+    class ECONNRESET      < SystemCallError; Errno = 104; end
+    class ENOBUFS         < SystemCallError; Errno = 105; end
+    class EISCONN         < SystemCallError; Errno = 106; end
+    class ENOTCONN        < SystemCallError; Errno = 107; end
+    class ESHUTDOWN       < SystemCallError; Errno = 108; end
+    class ETOOMANYREFS    < SystemCallError; Errno = 109; end
+    class ETIMEDOUT       < SystemCallError; Errno = 110; end
+    class ECONNREFUSED    < SystemCallError; Errno = 111; end
+    class EHOSTDOWN       < SystemCallError; Errno = 112; end
+    class EHOSTUNREACH    < SystemCallError; Errno = 113; end
+    class EALREADY        < SystemCallError; Errno = 114; end
+    class EINPROGRESS     < SystemCallError; Errno = 115; end
+    class ESTALE          < SystemCallError; Errno = 116; end
+    class EUCLEAN         < SystemCallError; Errno = 117; end
+    class ENOTNAM         < SystemCallError; Errno = 118; end
+    class ENAVAIL         < SystemCallError; Errno = 119; end
+    class EISNAM          < SystemCallError; Errno = 120; end
+    class EREMOTEIO       < SystemCallError; Errno = 121; end
+    class EDQUOT          < SystemCallError; Errno = 122; end
+    class ENOMEDIUM       < SystemCallError; Errno = 123; end
+    class EMEDIUMTYPE     < SystemCallError; Errno = 124; end
+    class ECANCELED       < SystemCallError; Errno = 125; end
+    class ENOKEY          < SystemCallError; Errno = 126; end
+    class EKEYEXPIRED     < SystemCallError; Errno = 127; end
+    class EKEYREVOKED     < SystemCallError; Errno = 128; end
+    class EKEYREJECTED    < SystemCallError; Errno = 129; end
+    class EOWNERDEAD      < SystemCallError; Errno = 130; end
+    class ENOTRECOVERABLE < SystemCallError; Errno = 131; end
+    class ERFKILL         < SystemCallError; Errno = 132; end
+    class EHWPOISON       < SystemCallError; Errno = 133; end
+  end
+end

data/lib/opal-file.rb

@@ -5,29 +5,174 @@ end
 
 require "opal-file/version"
 
+require "opal-file_test"
+require "opal-file/stat"
+
 if RUBY_ENGINE == "opal"
   require "native"
 
   class File
     class << self
-      def read(filename, options)
-        _fs.JS.readFileSync(filename, { encoding: "utf8" }.to_n)
+      def method_missing(name, *args)
+        FileTest.public_send(name, *args)
       end
 
-      def write(filename, content)
-        _fs.JS.writeFileSync(filename, content.to_s)
+      def atime(filename)
+        File::Stat.new(filename).atime
+      end
+
+      def birthtime(filename)
+        File::Stat.new(filename).birthtime
+      end
+
+      def chmod(mode, *filename)
+        handle_errno do
+          filename.each do |f|
+            fs.JS.chmodSync(f, mode)
+          end
+        end
+      end
+
+      def chown(owner, group, *filename)
+        handle_errno do
+          filename.each do |f|
+            fs.JS.chownSync(f, owner, group)
+          end
+        end
       end
 
       def unlink(*filename)
-        filename.each do |f|
-          _fs.JS.unlinkSync(f.to_s)
+        handle_errno do
+          filename.each do |f|
+            fs.JS.unlinkSync(f.to_s)
+          end
+        end
+      end
+
+      alias delete unlink
+
+      # overwrites Opal corelib/file method
+      def directory?(filename)
+        FileTest.directory?(filename)
+      end
+
+      # overwrites Opal corelib/file method
+      def exist?(filename)
+        FileTest.exist?(filename)
+      end
+
+      # overwrites Opal corelib/file method
+      def exists?(filename)
+        FileTest.exists?(filename)
+      end
+
+      def fnmatch?(pattern, path, flags = 0)
+        raise NotImplementedError
+      end
+
+      alias fnmatch fnmatch?
+
+      def ftype(filename)
+        File.lstat(filename).ftype
+      end
+
+      def lchmod(mode, *filename)
+        handle_errno do
+          filename.each do |f|
+            fs.JS.lchmodSync(f, mode)
+          end
         end
       end
 
+      def lchown(owner, group, *filename)
+        handle_errno do
+          filename.each do |f|
+            fs.JS.lchownSync(f, owner, group)
+          end
+        end
+      end
+
+      def link(old, new)
+        handle_errno do
+          fs.JS.linkSync(old, new)
+        end
+      end
+
+      def lstat(filename)
+        File::Stat.from_lstat(filename)
+      end
+
+      def mkfifo(file_name, mode = 0666)
+        raise NotImplementedError
+      end
+
+      def path(filename)
+        # TODO: fd
+        filename
+      end
+
+      def readlink(filename)
+        handle_errno do
+          fs.JS.readlinkSync(filename)
+        end
+      end
+
+      # TODO: not raise
+      alias realdirpath realpath
+
+      def rename(from, to)
+        handle_errno do
+          fs.JS.renameSync(from, to)
+        end
+      end
+
+      def stat(filename)
+        File::Stat.new(filename)
+      end
+
+      def symlink(old, new)
+        handle_errno do
+          fs.JS.symlinkSync(old, new)
+        end
+      end
+
+      def truncate(path, length)
+        handle_errno do
+          fs.JS.truncateSync(path, length)
+        end
+      end
+
+      def umask(umask = nil)
+        raise NotImplementedError
+      end
+
+      def utime(atime, mtime, *filename)
+        handle_errno do
+          filename.each do |f|
+            fs.JS.utimesSync(f, atime.to_i, mtime.to_i) # TODO: s ? ms ?
+          end
+        end
+      end
+
+      # IO
+
+      def read(filename, options)
+        fs.JS.readFileSync(filename, { encoding: "utf8" }.to_n)
+      end
+
+      def write(filename, content)
+        fs.JS.writeFileSync(filename, content.to_s)
+      end
+
       private
 
-        def _fs
-          @_fs ||= `require("fs")`
+        def fs
+          @fs ||= `require("fs")`
+        end
+
+        def handle_errno
+          e = nil
+          `try { return #{yield} } catch (#{e}) { #{raise Class.const_get("Errno::#{e.JS[:code]}")} }`
         end
     end
   end

data/lib/opal-file/stat.rb

@@ -0,0 +1,214 @@
+require "opal-errno"
+
+if RUBY_ENGINE == "opal"
+  require "corelib/error"
+  require "native"
+
+  class File
+    class Stat
+      class << self
+        def from_lstat(path)
+          File::Stat.new(File::Stat.lstat_sync(path))
+        end
+
+        def stat_sync(file)
+          e = nil
+          `try { return require("fs").statSync(file) } catch(#{e}) { #{raise Class.const_get("Errno::#{e.JS[:code]}")} }`
+        end
+
+        def lstat_sync(file)
+          e = nil
+          `try { return require("fs").lstatSync(file) } catch (#{e}) { #{raise Class.const_get("Errno::#{e.JS[:code]}")} }`
+        end
+      end
+
+      def initialize(path)
+        if `typeof path === "string"`
+          @stat = File::Stat.stat_sync(path)
+          raise Class.const_get("Errno::#{@stat}") if `typeof this.stat === "string"`
+        else
+          @stat = path
+        end
+      end
+
+      def atime
+        ms_to_time @stat.JS[:atimeMs]
+      end
+
+      def birthtime
+        ms_to_time @stat.JS[:birthtimeMs]
+      end
+
+      def blksize
+        @stat.JS[:blksize]
+      end
+
+      def blockdev?
+        @stat.JS.isBlockDevice()
+      end
+
+      def blocks
+        @stat.JS[:blocks]
+      end
+
+      def chardev?
+        @stat.JS.isCharacterDevice()
+      end
+
+      def ctime
+        ms_to_time @stat.JS[:ctimeMs]
+      end
+
+      def dev
+        @stat.JS[:dev]
+      end
+
+      def dev_major
+        raise NotImplementedError
+      end
+
+      def dev_minor
+        raise NotImplementedError
+      end
+
+      def directory?
+        @stat.JS.isDirectory()
+      end
+
+      def executable?
+        raise NotImplementedError
+      end
+
+      def executable_real?
+        raise NotImplementedError
+      end
+
+      def file?
+        @stat.JS.isFile()
+      end
+
+      def ftype
+        if file? then "file"
+        elsif directory? then "directory"
+        elsif chardev? then "characterSpecial"
+        elsif blockdev? then "blockSpecial"
+        elsif pipe? then "fifo"
+        elsif symlink? then "link"
+        elsif socket? then "socket"
+        else "unknown"
+        end
+      end
+
+      def gid
+        @stat.JS[:gid]
+      end
+
+      def grpowned?
+        raise NotImplementedError
+      end
+
+      def ino
+        @stat.JS[:ino]
+      end
+
+      def mode
+        @stat.JS[:mode]
+      end
+
+      def mtime
+        ms_to_time @stat.JS[:mtimeMs]
+      end
+
+      def nlink
+        @stat.JS[:nlink]
+      end
+
+      def owned?
+        raise NotImplementedError
+      end
+
+      def pipe?
+        @stat.JS.isFIFO()
+      end
+
+      def rdev
+        @stat.JS[:rdev]
+      end
+
+      def rdev_major
+        raise NotImplementedError
+      end
+
+      def rdev_minor
+        raise NotImplementedError
+      end
+
+      def readable?
+        raise NotImplementedError
+      end
+
+      def readable_real?
+        raise NotImplementedError
+      end
+
+      def setgid?
+        raise NotImplementedError
+      end
+
+      def setuid?
+        raise NotImplementedError
+      end
+
+      def size
+        @stat.JS[:size]
+      end
+
+      def size?
+        _size = size
+        _size == 0 ? nil : _size
+      end
+
+      def socket?
+        @stat.JS.isSocket()
+      end
+
+      def sticky?
+        mode & 0001000;
+      end
+
+      def symlink?
+        @stat.JS.isSymbolicLink()
+      end
+
+      def uid
+        @stat.JS[:uid]
+      end
+
+      def world_readable?
+        raise NotImplementedError
+      end
+
+      def world_writable?
+        raise NotImplementedError
+      end
+
+      def writable?
+        raise NotImplementedError
+      end
+
+      def writable_real?
+        raise NotImplementedError
+      end
+
+      def zero?
+        size == 0
+      end
+
+      private
+
+        def ms_to_time(ms)
+          Time.at((ms / 1000).to_i, (ms % 1000) * 1000)
+        end
+    end
+  end
+end

data/lib/opal-file/version.rb

@@ -1,3 +1,3 @@
-module OpalFile
-  VERSION = "0.1.0"
-end
+module OpalFile
+  VERSION = "1.0.0"
+end

data/lib/opal-file_test.rb

@@ -0,0 +1,39 @@
+require "opal-file/stat"
+
+if RUBY_ENGINE == "opal"
+  require "native"
+
+  module FileTest
+    class << self
+      def method_missing(name, file)
+        File.lstat(file).public_send(name)
+      rescue SystemCallError
+        false
+      end
+
+      def empty?(file)
+        zero?(file)
+      end
+
+      def exist?(file)
+        `require("fs")`.existsSync(file)
+      end
+
+      alias exists? exist?
+
+      def identical?(file1, file2)
+        raise NotImplementedError
+      end
+
+      def size(file)
+        File.lstat(file).size
+      end
+
+      def size?(file)
+        size(file)
+      rescue SystemCallError
+        nil
+      end
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: opal-file
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 1.0.0
 platform: ruby
 authors:
 - Narazaka
@@ -65,8 +65,11 @@ files:
 - Rakefile
 - bin/console
 - bin/setup
+- lib/opal-errno.rb
 - lib/opal-file.rb
+- lib/opal-file/stat.rb
 - lib/opal-file/version.rb
+- lib/opal-file_test.rb
 - lib/opal/file.rb
 - opal-file.gemspec
 homepage: https://github.com/Narazaka/opal-file