spade-packager 0.1.0

data/packages/web-file/lib/errors.js

@@ -0,0 +1,32 @@
+// ==========================================================================
+// Project:   Web File
+// Copyright: ©2010 Strobe Inc. All rights reserved.
+// License:   Licened under MIT license (see __preamble__.js)
+// ==========================================================================
+
+var messages = [
+null,
+'File Not Found',
+'Security Error',
+'Operation aborted',
+'File not readable',
+'Encoding Error'
+];
+
+var FileError = function(code) {
+  this.code = code;
+  this.message = messages[code];
+};
+
+FileError.prototype = new Error();
+FileError.prototype.constructor = FileError;
+FileError.prototype.toString = function() { return this.message; };
+
+FileError.NOT_FOUND_ERR = 1;
+FileError.SECURITY_ERR  = 2;
+FileError.ABORT_ERR     = 3;
+FileError.NOT_READABLE_ERR = 4;
+FileError.ENCODING_ERR  = 5;
+
+exports.FileError     = FileError;
+exports.FileException = FileError;

data/packages/web-file/lib/file-reader.js

@@ -0,0 +1,10 @@
+// ==========================================================================
+// Project:   Web Typed Array
+// Copyright: ©2010 Strobe Inc. All rights reserved.
+// License:   Licened under MIT license (see __preamble__.js)
+// ==========================================================================
+
+var nat = require('./ruby/file_reader');
+
+exports.FileReader = nat.FileReader;
+exports.FileReaderSync = nat.FileReaderSync;

data/packages/web-file/lib/file-system.js

@@ -0,0 +1,234 @@
+// ==========================================================================
+// Project:   Web Typed Array
+// Copyright: ©2010 Strobe Inc. All rights reserved.
+// License:   Licened under MIT license (see __preamble__.js)
+// ==========================================================================
+
+/**
+  On platforms that support it, the FileSystem API provides a way for you 
+  to access and navigate files on disk.  FileSystem instances may be provided
+  by the system that limits the visible scope of files.
+  
+  To get the default file system look for the global fileSystem object.  
+*/
+
+var nat = require('./ruby/file_system');
+var FileSystem;
+
+// ..........................................................
+// STAT Object
+// 
+var Stat = function(nstat) {
+  this._nstat = nstat;
+};
+
+Stat.prototype = {
+  constructor: Stat,
+
+  get size() { return this._nstat.size; },
+  get blockSize() { return this._nstat.blksize; },
+  get blocks() { return this._nstat.blocks; },
+  get mode() { return this._nstat.mode; },
+
+  get uid() { return this._nstat.uid; },
+  get gid() { return this._nstat.uid; },
+
+  get device() { return this._nstat.dev; },
+  get inode() { return this._nstat.ino; },
+
+  get mtime() { return this._nstat.mtime; },
+  get ctime() { return this._nstat.ctime; },
+  get atime() { return this._nstat.atime; },
+
+  get isDirectory() { return this._nstat['directory?']; },
+  get isFile() { return this._nstat['file?']; },
+  get isSymlink() { return this._nstat['symlink?']; },
+  get isReadable() { return this._nstat['readable?']; },
+  get isWritable() { return this._nstat['writable?']; },
+  get isExecutable() { return this._nstat['executable?']; },
+  get isSticky() { return this._nstat['sticky?']; }
+  
+};
+
+// ..........................................................
+// FileSystem
+// 
+
+function readOnlyError() {
+  throw new Error("FileSystem is read only");
+}
+
+// We want this to be secure.  hence the reason we do it this way.
+FileSystem = function() {
+  throw "Invalid constructor";
+};
+
+function createFileSystem(root, cwd, readOnly) {
+
+  readOnly = !!readOnly;
+  
+  // create one off instance
+  fs = function() {};
+  fs.prototype = FileSystem.prototype;
+  fs = new fs();
+
+  fs.SEPARATOR = nat.SEPARATOR;
+
+  
+  // Takes an absolute path, removes the root prefix
+  function denorm(path) {
+    return root==='/' ? path : path.slice(root.length);
+  }
+  
+  // make prefixed
+  function norm(path) {
+    if(path[0] === fs.SEPARATOR) {
+      return nat.expand_path(nat.join_path(root, path));
+    } else {
+      return nat.expand_path(path, cwd);
+    }
+  }
+    
+  fs.__defineGetter__('cwd', function() { return denorm(cwd); });
+  fs.__defineSetter__('cwd', function(v) { 
+    cwd = norm(v); 
+    return denorm(cwd); 
+  });
+  
+  // fs.cwd  = function(path) {
+  //   if (path !== undefined) cwd = norm(path);
+  //   return denorm(cwd);
+  // };
+  
+  fs.stat = function(path) {
+    return new Stat(nat.stat(norm(path)));
+  };
+  
+  fs.open = function(path, opts) {
+    if (!opts) opts = {};
+    if (!('readable' in opts)) opts.readable = true;
+    if (!('writable' in opts) || readOnly) opts.writable = !readOnly;
+    if (!('executable' in opts)) opts.executable = false;
+    if (!('append' in opts)) opts.append = false;
+    if (!('modify' in opts) || opts.append) opts.modify = false;
+    return nat.open(norm(path), opts);
+  };
+  
+  fs.exists = function(path) {
+    return nat.exists(norm(path));
+  };
+  
+  fs.chroot = function(path, readOnly) {
+    path = path===undefined ? cwd : norm(path);
+    return createFileSystem(path, path, readOnly);
+  };
+  
+  
+  // ..........................................................
+  // PATH OPS
+  // 
+  
+  fs.join = function() {
+    return nat.join_path(Array.prototype.slice.call(arguments));
+  };
+    
+  fs.split = function(path) {
+    return nat.split_path(path);
+  };
+    
+  fs.dirname = function(path) {
+    return nat.dirname(path);
+  };
+  
+  fs.basename = function(path, ext) {
+    return nat.basename(path, ext);
+  };
+  
+  fs.ext = function(path) {
+    return nat.extname(path);
+  };
+  
+  fs.expand = function(path, base) {
+    return nat.expand_path(path, base);
+  };
+  
+  fs.glob = function(path) {
+    return nat.glob(norm(path)).map(function(x) { return denorm(x); });
+  };
+  
+  // ..........................................................
+  // WRITABLE OPS
+  // 
+  
+  fs.mkdir = function(path, mode) {
+    if (readOnly) readOnlyError();
+    nat.mkdir(norm(path), mode);
+    return this;
+  };
+  
+  fs.mkdirs = function(path, mode) {
+    if (readOnly) readOnlyError();
+    nat.mkdir_p(norm(path), mode);
+    return this;
+  };
+  fs.mkdir_p = fs.mkdirs;
+  
+  fs.move = function(src, dst) {
+    if (readOnly) readOnlyError();
+    if (src && src.map) src = src.map(function(s) { return norm(s); });
+    else src = norm(src);
+
+    nat.mv(src, norm(dst));
+    return this;
+  };
+  fs.mv = fs.move;
+
+  fs.copy = function(src, dst, opts) {
+    if (readOnly) readOnlyError();
+
+    if (src && src.map) src = src.map(function(s) { return norm(s); });
+    else src = norm(src);
+    
+    if (!opts) opts = {};
+    if (opts.recursive) nat.cp_r(src, norm(dst));
+    else nat.cp(src, norm(dst));
+
+    return this;
+  };
+  fs.cp = fs.copy;
+
+  fs.remove = function(src, opts) {
+    if (readOnly) readOnlyError();
+
+    if (src && src.map) src = src.map(function(s) { return norm(s); });
+    else src = norm(src);
+    
+    if (!opts) opts = {};
+    if (opts.force) nat.rm_rf(src);
+    else if (opts.recursive) nat.rm_r(src);
+    else nat.rm(src)
+
+    return this;
+  };
+  fs.rm = fs.remove;
+
+  fs.link = function(src, dst, opts) {
+    if (readOnly) readOnlyError();
+
+    if (src && src.map) src = src.map(function(s) { return norm(s); });
+    else src = norm(src);
+
+    if (!opts) opts = {};
+    if (opts.symbolic) nat.ln_s(src, norm(dst));
+    else nat.ln(src, norm(dst));
+
+    return this;
+  };  
+  fs.ln = fs.link;
+
+  return fs;
+  
+}
+
+exports.FileSystem = FileSystem;
+exports.fileSystem = createFileSystem('/', nat.cwd, false);

data/packages/web-file/lib/file-writer.js

@@ -0,0 +1,10 @@
+// ==========================================================================
+// Project:   File API
+// Copyright: ©2010 Strobe Inc. All rights reserved.
+// License:   Licened under MIT license (see __preamble__.js)
+// ==========================================================================
+
+var nat = require('./ruby/file_writer');
+
+exports.FileWriter = nat.FileWriter;
+exports.FileWriterSync = nat.FileWriterSync;

data/packages/web-file/lib/file.js

@@ -0,0 +1,9 @@
+// ==========================================================================
+// Project:   Web Typed Array
+// Copyright: ©2010 Strobe Inc. All rights reserved.
+// License:   Licened under MIT license (see __preamble__.js)
+// ==========================================================================
+
+var nat = require('./ruby/file');
+exports.Blob = nat.Blob;
+exports.File = nat.File;

data/packages/web-file/lib/main.js

@@ -0,0 +1,34 @@
+// ==========================================================================
+// Project:   Web Typed Array
+// Copyright: ©2010 Strobe Inc. All rights reserved.
+// License:   Licened under MIT license (see __preamble__.js)
+// ==========================================================================
+/*globals ENV File Blob FileReader FileReaderSync FileSystem fileSystem FileWriter FileWriterSync */
+
+if (!require('./platform').isSupported) {
+  throw new Error('File API is not supported on this platform');
+}
+
+var exp;
+
+// browser either supports it or doesn't.
+if (ENV.SPADE_PLATFORM.ENGINE !== 'browser') {
+  exp = require('./file');
+  Blob = exp.Blob;
+  File = exp.File;
+  
+  exp = require('./file-reader');
+  FileReader = exp.FileReader;
+  FileReaderSync = exp.FileReaderSync;
+
+  exp = require('./file-writer');
+  FileWriter = exp.FileWriter;
+  FileWriterSync = exp.FileWriterSync;
+  
+  exp = require('./file-system');
+  FileSystem = exp.FileSystem;
+  fileSystem = exp.fileSystem;
+}
+
+
+

data/packages/web-file/lib/platform.js

@@ -0,0 +1,25 @@
+// ==========================================================================
+// Project:   Web Typed Array
+// Copyright: ©2010 Strobe Inc. All rights reserved.
+// License:   Licened under MIT license (see __preamble__.js)
+// ==========================================================================
+/*globals ENV File */
+
+var supported = false, fs = false;
+
+switch(ENV.SPADE_PLATFORM.ENGINE) {
+  case 'browser':
+    supported = 'undefined' !== typeof File;
+    break;
+  
+  case 'spade':
+    supported = true;
+    fs = true;
+    break;
+}
+
+exports.isSupported = supported;
+exports.hasFileSystem = fs; // if true then you can nav filesystem
+
+
+

data/packages/web-file/lib/ruby/file.rb

@@ -0,0 +1,252 @@
+# ==========================================================================
+# Project:   File
+# Copyright: ©2010 Strobe Inc. All rights reserved.
+# License:   Licened under MIT license (see LICENSE)
+# ==========================================================================
+
+require 'fileutils'
+
+module WebFile
+  class FileExports < Spade::Runtime::Exports
+    
+    class Blob
+      
+      def size
+        0
+      end
+
+      attr_reader :type
+
+      def readable
+        false
+      end
+
+      def writable
+        false
+      end
+      
+      def executable
+        false
+      end
+      
+      # If true, then writing to the file will not clear the contents.
+      def appends
+        false
+      end
+      
+      def initialize 
+        throw self.class.context['Error'].new("Illegal constructor")
+      end
+      
+      def slice(offset, length, contentType=nil)
+        offset = size if offset > size
+        length = self.size-offset if offset+length > size
+        offset += @offset unless @offset.nil?
+        self.dup.setup_slice(offset, length, contentType || @type)
+      end
+
+      protected 
+      
+      def dup
+        self.class.new
+      end
+      
+      def setup_slice(offset, length, contentType=nil)
+        @offset = offset
+        @length = length
+        @type = contentType unless contentType.nil?
+        self
+      end
+        
+    end
+    
+    class File < Blob
+      
+      attr_reader :name, :lastModifiedDate      
+      
+    end
+      
+  end
+  
+  class RealFile < FileExports::File
+    
+    def initialize(path, ctx, perms=nil, offset=nil, length=nil, type=nil)
+      @path   = path
+      @ctx    = ctx
+      @offset = offset.nil? ? 0 : offset
+      @length = length
+      @type   = type
+      
+      if perms.instance_of? V8::Object
+        @perms = {}
+        perms.each { |key, value|  @perms[key.to_sym] = value }
+      else
+        @perms = perms || {}
+      end
+
+      @perms_checked = false
+    end
+
+    #############################################'
+    ## FILE PROPERTIES
+    ##
+    
+    def name
+      @name ||= ::File.basename(@path)
+    end
+    
+    def lastModifiedDate
+      @ctx['Date'].new(::File.mtime(@path))
+    end
+    
+    def size 
+      total_size = ::File.size(@path) - @offset
+      @length.nil? || total_size<@length ? total_size : @length
+    end
+    
+    def type
+      require 'rack/mime'
+      @type ||= Rack::Mime.mime_type(::File.extname(@path))
+    end
+    
+
+    #############################################'
+    ## PERMISSIONS
+    ##
+
+    def readable
+      check_perms if !@perms_checked
+      @perms[:readable] && exists
+    end
+    
+    def writable
+      check_perms if !@perms_checked
+      @perms[:writable]
+    end
+    
+    def appends
+      check_perms if !@perms_checked
+      @perms[:append]
+    end
+    
+    def modifies
+      check_perms if !@perms_checked
+      @perms[:modify]
+    end
+    
+    def executable
+      check_perms if !@perms_checked
+      @perms[:executable] 
+    end
+    
+    def exists
+      File.exists? @path
+    end
+    
+    
+    protected 
+    
+    def dup
+      self.class.new(@path, @ctx, @perms, @offset, @length, @type)
+    end
+    
+    # restrict file permissions to actual permissions on disk\
+    def check_perms
+      @perms_checked = true
+      @perms = {} if @perms.nil?
+      
+      if File.directory?(@path)
+        @perms[:readable] = @perms[:writable] = @perms[:executable] = false
+      else
+
+        path = @path
+        path = File.dirname(path) while(path!='/' && !File.exists?(path))
+
+        st = File.stat path
+        @perms[:readable] &&= st.readable?
+        @perms[:writable] &&= st.writable?
+        @perms[:executable] &&= (path == @path) ? st.executable? : false
+      end
+      
+      @perms[:append] &&= @perms[:writable]
+      @perms[:modify]  &&= @perms[:writable] && !@perms[:append]
+      
+      # can only append if offset puts us at the start. i.e. slicing 
+      # disables append
+      if @perms[:append] && @offset>0
+        @perms[:append] = false
+        @perms[:modify] = true
+      end
+      
+    end
+        
+    def read_sync(kind, encoding=nil)
+      
+      throw "File #{name} is not readable" unless readable
+      
+      case kind
+      when :buffer
+        @ctx.require 'web-typed-array'
+        
+        buf = WebTypedArray::ArrayBufferExports::ArrayBuffer.new(size)
+        str = IO.read(@path, size, @offset||0)
+        buf.instance_eval do
+          @buf = str
+        end
+        
+        buf
+        
+      when :text
+        if encoding && encoding != 'utf8' && encoding != 'ascii'
+          throw "only utf8 and ascii encoding currently supported"
+        end
+        IO.read(@path, size, @offset||0)
+        # TODO: handle encoding
+
+      else
+        throw "do not (yet) know how to read #{kind}"
+      end
+    end
+
+    def write_sync(kind, data, encoding=nil)
+      
+      throw "File #{name} is not writable" unless writable
+      
+      case kind
+
+      when :buffer
+        str = data.buf
+        FileUtils.mkdir_p File.dirname(@path)
+        File.open(@path, appends || modifies ? 'a' : 'w') do |fd|
+          
+          # write in filler if needed
+          fd.seek @offset||0 unless appends
+
+          # constrain only if this file has been sliced.
+          str = str[0...size] if !@length.nil? && size < str.size
+          fd.write(str)
+        end        
+        
+      when :text
+        FileUtils.mkdir_p File.dirname(@path)
+        File.open(@path, appends || modifies ? 'a' : 'w') do |fd|
+          fd.seek @offset unless appends
+          
+          # constrain only if this file has been sliced.
+          data = data[0...size] if !@length.nil? && size < data.size
+          fd.write(data)
+        end      
+        
+          
+
+      else
+        throw "do not (yet) know how to write #{kind}"
+      end
+    end
+    
+    
+  end
+  
+end
+
+Spade.exports WebFile::FileExports