commonthread-fluffy 0.0.3 → 0.1.0

data/.gitignore

@@ -4,3 +4,4 @@ coverage
 rdoc
 pkg
 *.gem
+demo*

data/VERSION

@@ -1 +1 @@
-0.0.3
+0.1.0

data/fluffy.gemspec

@@ -2,11 +2,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{fluffy}
-  s.version = "0.0.3"
+  s.version = "0.1.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Ben Wyrosdick"]
-  s.date = %q{2009-07-17}
+  s.date = %q{2009-07-24}
   s.email = %q{ben.wyrosdick@gmail.com}
   s.extra_rdoc_files = [
     "LICENSE",
@@ -33,7 +33,7 @@ Gem::Specification.new do |s|
   s.rdoc_options = ["--charset=UTF-8"]
   s.require_paths = ["lib"]
   s.rubygems_version = %q{1.3.4}
-  s.summary = %q{TODO}
+  s.summary = %q{Makes writing to S3 tranparent using File}
   s.test_files = [
     "test/fluffy_test.rb",
      "test/test_helper.rb"

data/lib/fluffy.rb

@@ -2,92 +2,312 @@ require File.join(File.dirname(__FILE__), 'fluffy/s3_path')
 require File.join(File.dirname(__FILE__), 'fluffy/s3_io')
 
 require 'right_aws'
+require 'fileutils'
+require 'pathname'
 
-File.instance_eval do
-  @@s3_paths = []
+RealFile = File
+#RealFileUtils = FileUtils
+RealDir = Dir
+#RealFileUtils::Dir = RealDir
+#RealFileUtils::File = RealFile
 
-  def register_s3(file_path, access_key_id, secret_access_key, bucket, start_path = '')
-    File.s3_paths << Fluffy::S3Path.new(File.expand_path(file_path), access_key_id, secret_access_key, bucket, start_path)
-  end
+module Fluffy
+  #module FileUtils
+  #  extend self
 
-  def s3_paths
-    return @@s3_paths
-  end
+  #  def mkdir_p(path)
+  #    RealFileUtils.mkdir_p(path)
+  #  end
+
+  #  def rm(path)
+  #    RealFileUtils.rm(path)
+  #  end
+
+  #  def rm_r(path)
+  #    RealFileUtils.rm_r(path)
+  #  end
+
+  #  def rm_rf(path)
+  #    RealFileUtils.rm_rf(path)
+  #  end
+
+  #  def ln_s(target, path)
+  #    raise Errno::EEXIST, path if File.exists?(path)
+  #    RealFileUtils.ln_s(target, path)
+  #  end
+
+  #  def cp(src, dest)
+  #    RealFileUtils.cp(src, dest)
+  #    #dst_file = FileSystem.find(dest)
+  #    #src_file = FileSystem.find(src)
+
+  #    #if !src_file
+  #    #  raise Errno::ENOENT, src
+  #    #end
+
+  #    #if File.directory? src_file
+  #    #  raise Errno::EISDIR, src
+  #    #end
+
+  #    #if dst_file and File.directory?(dst_file)
+  #    #  FileSystem.add(File.join(dest, src), src_file.entry.clone(dst_file))
+  #    #else
+  #    #  FileSystem.delete(dest)
+  #    #  FileSystem.add(dest, src_file.entry.clone)
+  #    #end
+  #  end
+
+  #  def cp_r(src, dest)
+  #    RealFileUtils.cp_r(src, dest)
+  #    ## This error sucks, but it conforms to the original Ruby
+  #    ## method.
+  #    #raise "unknown file type: #{src}" unless dir = FileSystem.find(src)
+
+  #    #new_dir = FileSystem.find(dest)
+
+  #    #if new_dir && !File.directory?(dest)
+  #    #  raise Errno::EEXIST, dest
+  #    #end
+
+  #    #if !new_dir && !FileSystem.find(dest+'/../')
+  #    #  raise Errno::ENOENT, dest
+  #    #end
+
+  #    ## This last bit is a total abuse and should be thought hard
+  #    ## about and cleaned up.
+  #    #if new_dir
+  #    #  if src[-2..-1] == '/.'
+  #    #    dir.values.each{|f| new_dir[f.name] = f.clone(new_dir) }
+  #    #  else
+  #    #    new_dir[dir.name] = dir.entry.clone(new_dir)
+  #    #  end
+  #    #else
+  #    #  FileSystem.add(dest, dir.entry.clone)
+  #    #end
+  #  end
+
+  #  def mv(src, dest)
+  #    RealFileUtils.mv(src, dest)
+  #    #if target = FileSystem.find(src)
+  #    #  FileSystem.add(dest, target.entry.clone)
+  #    #  FileSystem.delete(src)
+  #    #else
+  #    #  raise Errno::ENOENT, src
+  #    #end
+  #  end
+
+  #  def chown(user, group, list, options={})
+  #    RealFileUtils.chown(user, group, list, options)
+  #    #list = Array(list)
+  #    #list.each do |f|
+  #    #  unless File.exists?(f)
+  #    #    raise Errno::ENOENT, f
+  #    #  end
+  #    #end
+  #    #list
+  #  end
+
+  #  def chown_R(user, group, list, options={})
+  #    RealFileUtils.chown_R(user, group, list, options={})
+  #    #chown(user, group, list, options={})
+  #  end
+
+  #  def touch(list, options={})
+  #    RealFileUtils.touch(list, options)
+  #    #Array(list).each do |f|
+  #    #  directory = File.dirname(f)
+  #    #  # FIXME this explicit check for '.' shouldn't need to happen
+  #    #  if File.exists?(directory) || directory == '.'
+  #    #    FileSystem.add(f, MockFile.new)
+  #    #  else
+  #    #    raise Errno::ENOENT, f
+  #    #  end
+  #    #end
+  #  end
+
+  #  def cd(dir)
+  #    RealFileUtils.cd(dir)
+  #  end
+  #  alias_method :chdir, :cd
 
-  alias :original_open :open
+  #  def method_missing(meth, *args, &block)
+  #    RealFileUtils.send(meth, *args, &block)
+  #  end
+  #end
 
-  def open(filename, mode = 'r', &block)
-    Fluffy.cloud_runner(self, :open, filename) do |s3_path, key|
-      s3io = Fluffy::S3Io.new(s3_path, key, mode)
+  class File
+    PATH_SEPARATOR = '/'
 
-      if block_given?
-        yield(s3io)
-        s3io.close
+    @@s3_paths = []
+
+    def self.register_s3(file_path, access_key_id, secret_access_key, bucket, start_path = '')
+      File.s3_paths << Fluffy::S3Path.new(File.expand_path(file_path), access_key_id, secret_access_key, bucket, start_path)
+    end
+
+    def self.s3_paths
+      return @@s3_paths
+    end
+
+    def self.join(*parts)
+      RealFile.join(parts)
+    end
+
+    def self.exist?(path)
+      Fluffy.cloud_runner(RealFile, :exist?, path) do |s3_path, key|
+        s3_path.bucket.key(key).exists?
       end
+    end
 
-      return s3io
+    def self.const_missing(name)
+      RealFile.const_get(name)
+    end
+
+    class << self
+      alias_method :exists?, :exist?
     end
-  end
 
-  alias :original_exists? :exists?
+    def self.directory?(path)
+      Fluffy.cloud_runner(RealFile, :directory?, path) do |s3_path, key|
+        #FIXME Look for a directory
+      end
+    end
 
-  def exists?(filename)
-    Fluffy.cloud_runner(self, :exists?, filename) do |s3_path, key|
-      s3_path.bucket.key(key).exists?
+    def self.symlink?(path)
+      RealFile.symlink?(path)
     end
-  end
 
-  def exist?(filename)
-    exists?(filename)
-  end
-  
-  def file?(filename)
-    exists?(filename)
-  end
+    def self.file?(path)
+      RealFile.file?(path)
+    end
 
-  alias :original_unlink :unlink
+    def self.expand_path(*args)
+      RealFile.expand_path(*args)
+    end
 
-  def unlink(*filepaths)
-    filepaths.each do |filename|
-      Fluffy.cloud_runner(self, :unlink, filename) do |s3_path, key|
-        s3_path.bucket.key(key).delete
+    def self.basename(*args)
+      RealFile.basename(*args)
+    end
+
+    def self.dirname(path)
+      RealFile.dirname(path)
+    end
+
+    def self.readlink(path)
+      RealFile.readlink(path)
+    end
+
+    def self.open(path, mode='r', &block)
+      Fluffy.cloud_runner(RealFile, :open, path, block) do |s3_path, key|
+        s3io = Fluffy::S3Io.new(s3_path, key, mode)
+
+        if block_given?
+          block_val = yield(s3io)
+          s3io.close
+          return block_val
+        end
+
+        return s3io
       end
     end
-  end
-end
 
-Dir.instance_eval do
-  alias :original_unlink :unlink
+    def self.read(path)
+      open(path).read
+    end
 
-  def unlink(dirpath)
-    Fluffy.cloud_runner(self, :unlink, dirpath) do |s3_path, key|
-      s3_path.bucket.key(key).delete
+    def self.readlines(path)
+      open(path).readlines
     end
-  end
 
-  def rmdir(dirpath)
-    unlink(dirpath)
+    def self.unlink(*filepaths)
+      filepaths.each do |filename|
+        Fluffy.cloud_runner(RealFile, :unlink, filename) do |s3_path, key|
+          s3_path.bucket.key(key).delete
+        end
+      end
+    end
+
+    def self.new(path, mode = nil)
+      Fluffy.cloud_runner(RealFile, :new, path) do |s3_path, key|
+        open(path, mode)
+      end
+    end
+
+    def self.chmod(mode, *files)
+      #FIXME: Make it work
+    end
+
+    def self.method_missing(meth, *args, &block)
+      RealFile.send(meth, *args, &block)
+    end
   end
 
-  def delete(dirpath)
-    unlink(dirpath)
+  class Dir
+    def self.glob(pattern)
+      RealDir.glob(pattern)
+      #if pattern[-1,1] == '*'
+      #  blk = proc { |entry| entry.to_s }
+      #else
+      #  blk = proc { |entry| entry[1].parent.to_s }
+      #end
+      #(FileSystem.find(pattern) || []).map(&blk).uniq.sort
+    end
+
+    def self.[](pattern)
+      glob(pattern)
+    end
+
+    def self.entries(path)
+      RealDir.entries(path)
+    end
+
+    def self.chdir(dir, &blk)
+      RealDir.chdir(dir, blk)
+    end
+
+    def self.unlink(dirpath)
+      Fluffy.cloud_runner(self, :unlink, dirpath) do |s3_path, key|
+        s3_path.bucket.key(key).delete
+      end
+    end
+
+    class << self
+      alias_method :rmdir, :unlink
+      alias_method :delete, :unlink
+    end
+
+    def self.method_missing(meth, *args, &block)
+      RealDir.send(meth, *args, &block)
+    end
   end
-end
 
-module Fluffy
-  def self.cloud_runner(klass, method_name, filename, &block)
+  def self.cloud_runner(klass, method_name, filename, method_block=nil, &block)
     expanded_filename = File.expand_path(filename)
     if s3_path = File.s3_paths.find {|path| expanded_filename =~ /^#{path.file_path}/}
       starting_position = s3_path.file_path.length + 1
-      raise 'You must specify a key' unless expanded_filename.length > starting_position
-      key = expanded_filename[starting_position .. -1]
-      yield(s3_path, File.join(s3_path.start_path, key).gsub(/^\W/, ''))
+      if expanded_filename.length > starting_position
+        key = expanded_filename[starting_position .. -1]
+        yield(s3_path, File.join(s3_path.start_path, key).gsub(/^\W/, ''))
+      elsif method_name == :directory?
+        return true
+      else
+        raise 'You must specify a key'
+      end
     else
-      klass.send("original_#{method_name}", filename)
+      klass.send(method_name, filename, &method_block)
     end
   end
 end
 
+Object.class_eval do
+  remove_const(:Dir)
+  remove_const(:File)
+  #remove_const(:FileUtils)
+end
+
+#FileUtils = Fluffy::FileUtils
+File = Fluffy::File
+Dir = Fluffy::Dir
+
 ## File
 #
 # lchmod

data/lib/fluffy/s3_io.rb

@@ -57,13 +57,15 @@ module Fluffy
       return data
     end
 
-    def print(string = nil)
+    def write(string = nil)
       string ||= $_
       string << $\ if $\
       self.data[self.pos, string.length] = string
       self.pos += string.length
       return nil
     end
+    alias_method :print, :write
+    alias_method :<<, :write
 
     def puts(*strings)
       strings.each do |string|
@@ -96,6 +98,7 @@ module Fluffy
 
     def flush
       self.key.put(self.data)
+      self
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: commonthread-fluffy
 version: !ruby/object:Gem::Version 
-  version: 0.0.3
+  version: 0.1.0
 platform: ruby
 authors: 
 - Ben Wyrosdick
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-07-17 00:00:00 -07:00
+date: 2009-07-24 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
@@ -63,7 +63,7 @@ rubyforge_project:
 rubygems_version: 1.2.0
 signing_key: 
 specification_version: 3
-summary: TODO
+summary: Makes writing to S3 tranparent using File
 test_files: 
 - test/fluffy_test.rb
 - test/test_helper.rb