fusefs 0.7.0

data/sample/hello.rb

@@ -0,0 +1,27 @@
+require "rubygems"
+require 'fusefs'
+
+class HelloDir
+  def contents(path)
+    ['hello.txt']
+  end
+  
+  def file?(path)
+    path == '/hello.txt'
+  end
+  
+  def read_file(path)
+    "Hello, World!\n"
+  end
+
+  def size(path)
+    read_file(path).size
+  end
+end
+
+hellodir = HelloDir.new
+FuseFS.set_root( hellodir )
+
+# Mount under a directory given on the command line.
+FuseFS.mount_under ARGV.shift
+FuseFS.run

data/sample/openurifs.rb

@@ -0,0 +1,53 @@
+# openurifs.rb
+#
+
+require "rubygems"
+require 'fusefs'
+include FuseFS
+
+require 'open-uri'
+
+class OpenUriFS < FuseFS::FuseDir
+  def contents(path)
+    # The 'readme' file
+    []
+  end
+  def directory?(path)
+    uri = scan_path(path)
+    fn = uri.pop
+    return true if fn =~ /\.(com|org|net|us|de|jp|ru|uk|biz|info)$/
+    return true if fn =~ /^\d+\.\d+\.\d+\.\d+$/
+    ! (fn =~ /\./) # Does the last item doesn't contain a '.' ?
+  end
+  def file?(path)
+    !directory?(path)
+  end
+  def read_file(path)
+    proto, rest = split_path(path)
+    uri = "#{proto}://#{rest}"
+    open(uri).read
+  end
+end
+
+if (File.basename($0) == File.basename(__FILE__))
+  if (ARGV.size != 1)
+    puts "Usage: #{$0} <directory>"
+    exit
+  end
+
+  dirname = ARGV.shift
+
+  unless File.directory?(dirname)
+    puts "Usage: #{dirname} is not a directory."
+    exit
+  end
+
+  root = OpenUriFS.new
+
+  # Set the root FuseFS
+  FuseFS.set_root(root)
+
+  FuseFS.mount_under(dirname)
+
+  FuseFS.run # This doesn't return until we're unmounted.
+end

data/sample/railsfs.rb

@@ -0,0 +1,77 @@
+#!/usr/bin/env ruby
+#
+# RailsFS, as written by _why_the_lucky_stiff
+#
+# Full instructions:
+#   http://redhanded.hobix.com/inspect/railsfsAfterACoupleMinutesOfToolingWithFuseWhoa.html
+#
+=begin
+Instructions cut and paste from _why's blog:
+
+Save the railfs.rb script as script/filesys in your Rails app. (If you'd
+rather not cut-and-paste the above, it's here.)
+
+Now, run mkdir ~/railsmnt. Then, script/filesys ~/railsmnt. The rules are as
+follows:
+
+    * ls ~/railsmnt will give you a list of tables.
+    * ls ~/railsmnt/table will list IDs from the table.
+    * cat ~/railsmnt/table/id will display a record in YAML.
+    * vim ~/railsmnt/table/id to edit the record in YAML!
+
+=end
+
+require "rubygems"
+require 'fusefs'
+require File.dirname(__FILE__) + '/../config/environment'
+
+class RailsFS < FuseFS::FuseDir
+    def initialize
+        @classes = {}
+        require 'find'
+        Find.find( File.join(RAILS_ROOT, 'app/models') ) do |model| 
+            if /(\w+)\.rb$/ =~ model
+                model = $1
+                ( @classes[model] = Kernel::const_get( Inflector.classify( model ) ) ).
+                    find :first rescue @classes.delete( model )
+            end
+        end
+    end
+    def directory? path
+        tname, key = scan_path path
+        table = @classes[tname]
+        if table.nil?; false  # /table
+        elsif key;     false  # /table/id
+        else; true end
+    end
+    def file? path
+        tname, key = scan_path path
+        table = @classes[tname]
+        key and table and table.find( key )
+    end
+    def can_delete?; true end
+    def can_write? path; file? path end
+    def contents path
+        tname, key = scan_path path
+        table = @classes[tname]
+        if tname.nil?; @classes.keys.sort  # /
+        else; table.find( :all ).map { |o| o.id.to_s } end  # /table
+    end
+    def write_to path, body
+        obj = YAML::load( body )
+        obj.save
+    end
+    def read_file path
+        tname, key = scan_path path
+        table = @classes[tname]
+        YAML::dump( table.find( key ) )
+    end
+end
+
+if (File.basename($0) == File.basename(__FILE__))
+    root = RailsFS.new
+    FuseFS.set_root(root)
+    FuseFS.mount_under(ARGV[0])
+    FuseFS.run # This doesn't return until we're unmounted.
+end
+

data/sample/sqlfs.rb

@@ -0,0 +1,134 @@
+# sqlfs.rb
+#
+# The SQL-db proof of concept for FuseFS
+#
+# Author: Greg Millam
+
+require "rubygems"
+require 'fusefs'
+
+require 'mysql'
+
+class SqlFS < FuseFS::FuseDir
+  class DBTable
+    attr_accessor :name, :key, :fields
+  end
+  def initialize(host,user,pass,db)
+    @sql = Mysql.connect(host,user,pass,db)
+    @tables = Hash.new(nil)
+
+    tables = @sql.query('show tables')
+
+    tables.each do |i,|
+      table = DBTable.new
+      table.name = i
+      table.fields = {}
+      res = @sql.query("describe #{i}")
+      res.each do |field,type,null,key,default,extra|
+        table.fields[field] = type
+        if (key =~ /pri/i)
+          table.key = field
+        end
+      end
+      @tables[i] = table if table.key
+    end
+  end
+  def directory?(path)
+    tname, key, field = scan_path(path)
+    table = @tables[tname]
+    case
+    when tname.nil?
+      true # This means "/"
+    when table.nil?
+      false
+    when field
+      false # Always a file
+    when key
+      res = @sql.query("SELECT #{table.key}, 1 FROM #{table.name} WHERE #{table.key} = '#{Mysql.escape_string(key)}'")
+      res.num_rows > 0 # If there was a result, it exists.
+    else
+      true # It's just a table.
+    end
+  end
+  def file?(path)
+    tname, key, field = scan_path(path)
+    table = @tables[tname]
+    case
+    when field.nil?
+      false # Only field entries are files.
+    when table.nil?
+      false
+    when ! @tables[tname].fields.include?(field)
+      false # Invalid field.
+    when field
+      res = @sql.query("SELECT #{table.key}, 1 FROM #{table.name} WHERE #{table.key} = '#{Mysql.escape_string(key)}'")
+      res.num_rows > 0
+    end
+  end
+  def can_delete?(path)
+    # This helps editors, but we don't really use it.
+    true
+  end
+  def can_write?(path)
+    # Since this is basically only for editing files,
+    # we just call file?
+    file?(path)
+  end
+  def contents(path)
+    # since this is only called when directory? is true,
+    # We'll assume valid entries.
+    tname, key, field = scan_path(path)
+    table = @tables[tname]
+    case
+    when tname.nil?
+      @tables.keys.sort # Just the tables.
+    when key
+      table.fields.keys.sort
+    else
+      # I limit to 200 so 'ls' doesn't hang all the time :D
+      res = @sql.query("SELECT #{table.key}, 1 FROM #{table.name} ORDER BY #{table.key} LIMIT 100")
+      ret = []
+      res.each do |val,one|
+        ret << val if val.size > 0
+      end
+      ret
+    end
+  end
+  def write_to(path,body)
+    # Since this is only called after can_write?(), we assume
+    # Valid fields.
+    tname, key, field = scan_path(path)
+    table = @tables[tname]
+    res = @sql.query("UPDATE #{table.name} SET #{field} = '#{Mysql.escape_string(body)}' WHERE #{table.key} = '#{key}'")
+  end
+  def read_file(path)
+    # Again, as this is only called after file?, assume valid fields.
+    tname, key, field = scan_path(path)
+    table = @tables[tname]
+    res = @sql.query("SELECT #{field} FROM #{table.name} WHERE #{table.key} = '#{key}'")
+    res.fetch_row[0]
+  end
+end
+
+if (File.basename($0) == File.basename(__FILE__))
+  if ARGV.size != 5
+    puts "Usage: #{$0} <directory> <host> <user> <pass> <db>"
+    exit
+  end
+
+  dirname, host, user, pass, db = ARGV
+
+  if (! File.directory?(dirname))
+    puts "#{dirname} is not a directory"
+  end
+
+  root = SqlFS.new(host,user,pass,db)
+
+  # Set the root FuseFS
+  FuseFS.set_root(root)
+
+  # root.contents("/quotes")
+
+  FuseFS.mount_under(dirname)
+  FuseFS.run # This doesn't return until we're unmounted.
+end

data/sample/yamlfs.rb

@@ -0,0 +1,168 @@
+# yamlfs.rb
+#
+
+require "rubygems"
+require 'fusefs'
+include FuseFS
+
+require 'yaml'
+
+class YAMLFS < FuseFS::FuseDir
+  def initialize(filename)
+    @filename = filename
+    begin
+      @fs = YAML.load(IO.read(filename))
+    rescue Exception
+      @fs = Hash.new()
+    end
+  end
+  def save
+    File.open(@filename,'w') do |fout|
+      fout.puts(YAML.dump(@fs))
+    end
+  end
+  def contents(path)
+    items = scan_path(path)
+    node = items.inject(@fs) do |node,item|
+      item ? node[item] : node
+    end
+    node.keys.sort
+  end
+  def directory?(path)
+    items = scan_path(path)
+    node = items.inject(@fs) do |node,item|
+      item ? node[item] : node
+    end
+    node.is_a?(Hash)
+  end
+  def file?(path)
+    items = scan_path(path)
+    node = items.inject(@fs) do |node,item|
+      item ? node[item] : node
+    end
+    node.is_a?(String)
+  end
+  def touch(path)
+    puts "#{path} has been pushed like a button!"
+  end
+
+  # File reading
+  def read_file(path)
+    items = scan_path(path)
+    node = items.inject(@fs) do |node,item|
+      item ? node[item] : node
+    end
+    node.to_s
+  end
+  
+  def size(path)
+    read_file(path).size
+  end
+
+  # File writing
+  def can_write?(path)
+    items = scan_path(path)
+    name = items.pop # Last is the filename.
+    node = items.inject(@fs) do |node,item|
+      item ? node[item] : node
+    end
+    node.is_a?(Hash)
+  rescue Exception => er
+    puts "Error! #{er}"
+  end
+  def write_to(path,body)
+    items = scan_path(path)
+    name = items.pop # Last is the filename.
+    node = items.inject(@fs) do |node,item|
+      item ? node[item] : node
+    end
+    node[name] = body
+    self.save
+  rescue Exception => er
+    puts "Error! #{er}"
+  end
+
+  # Delete a file
+  def can_delete?(path)
+    items = scan_path(path)
+    node = items.inject(@fs) do |node,item|
+      item ? node[item] : node
+    end
+    node.is_a?(String)
+  rescue Exception => er
+    puts "Error! #{er}"
+  end
+  def delete(path)
+    items = scan_path(path)
+    name = items.pop # Last is the filename.
+    node = items.inject(@fs) do |node,item|
+      item ? node[item] : node
+    end
+    node.delete(name)
+    self.save
+  rescue Exception => er
+    puts "Error! #{er}"
+  end
+
+  # mkdirs
+  def can_mkdir?(path)
+    items = scan_path(path)
+    name = items.pop # Last is the filename.
+    node = items.inject(@fs) do |node,item|
+      item ? node[item] : node
+    end
+    node.is_a?(Hash)
+  rescue Exception => er
+    puts "Error! #{er}"
+  end
+  def mkdir(path)
+    items = scan_path(path)
+    name = items.pop # Last is the filename.
+    node = items.inject(@fs) do |node,item|
+      item ? node[item] : node
+    end
+    node[name] = Hash.new
+    self.save
+  end
+
+  # rmdir
+  def can_rmdir?(path)
+    items = scan_path(path)
+    node = items.inject(@fs) do |node,item|
+      item ? node[item] : node
+    end
+    node.is_a?(Hash) && node.empty?
+  end
+  def rmdir(path)
+    items = scan_path(path)
+    name = items.pop # Last is the filename.
+    node = items.inject(@fs) do |node,item|
+      item ? node[item] : node
+    end
+    node.delete(name)
+    self.save
+  end
+end
+
+if (File.basename($0) == File.basename(__FILE__))
+  if (ARGV.size < 2)
+    puts "Usage: #{$0} <directory> <yamlfile> <options>"
+    exit
+  end
+
+  dirname, yamlfile = ARGV.shift, ARGV.shift
+
+  unless File.directory?(dirname)
+    puts "Usage: #{dirname} is not a directory."
+    exit
+  end
+
+  root = YAMLFS.new(yamlfile)
+
+  # Set the root FuseFS
+  FuseFS.set_root(root)
+
+  FuseFS.mount_under(dirname, *ARGV)
+
+  FuseFS.run # This doesn't return until we're unmounted.
+end