em-fs 0.0.1

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+spec/data

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

data/.rvmrc

@@ -0,0 +1 @@
+rvm use --create --install 1.9.3@em-fs

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in em_file_utils.gemspec
+gemspec

data/Guardfile

@@ -0,0 +1,19 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+guard 'rspec', :version => 2 do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+
+  # Rails example
+  watch(%r{^app/(.+)\.rb$})                           { |m| "spec/#{m[1]}_spec.rb" }
+  watch(%r{^app/(.*)(\.erb|\.haml)$})                 { |m| "spec/#{m[1]}#{m[2]}_spec.rb" }
+  watch(%r{^app/controllers/(.+)_(controller)\.rb$})  { |m| ["spec/routing/#{m[1]}_routing_spec.rb", "spec/#{m[2]}s/#{m[1]}_#{m[2]}_spec.rb", "spec/acceptance/#{m[1]}_spec.rb"] }
+  watch(%r{^spec/support/(.+)\.rb$})                  { "spec" }
+  watch('config/routes.rb')                           { "spec/routing" }
+  watch('app/controllers/application_controller.rb')  { "spec/controllers" }
+  # Capybara request specs
+  watch(%r{^app/views/(.+)/.*\.(erb|haml)$})          { |m| "spec/requests/#{m[1]}_spec.rb" }
+end
+

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Arthur Leonard Andersen
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,75 @@
+# EM::FS
+
+`EM::FS` provides a simple interface to gain simple filesystem access
+in eventmachine via `EM::SystemCommand`.
+
+`EM::FileUtils` attempts to mimic the behavoir of the filesystem API
+of the Ruby stdlib. In the background it invokes linux/unix system
+commands - like `rsync`, `mkdir` etc. - via the `em-systemcommand`
+gem.
+
+Furthermore `EM::Dir` and `EM::File` provide abstractions to crawl
+directory structures via `find` command without blocking the reactor.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'em-fs'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install em-fs
+
+## Usage
+
+### `EM::FS` using `rsync` and `find`
+
+To invoke bare commands you can either use `EM::SystemCommand`
+directly or the methods `EM::FS.rsync` and `EM::FS.find`.
+
+### `EM::FileUtils` for simple filesystem operations
+
+The `FileUtils` methods from the Ruby Standard Library may block the
+eventmachine reactor. That´s why `em-fs` uses `EM::SystemCommand` to
+provide a similar non-blocking feature set.
+
+    EM.run do
+      EM::FileUtils.cp 'some_file', 'some_copy' do |on|
+        on.exit do |status|
+          puts 'Copied!'
+        end
+      end
+    end
+
+For a full list of methods, have a look at the documentation.
+
+### Abstraction via `EM::Dir` and `EM::File`
+
+`EM::Dir[]` returns a `EM::Dir::Glob` object, containing the
+information for the `find` command. On this object you can invoke
+multiple methods to see the resulting filesystem objects:
+
+    EM::Dir['./**/*.*'].each do |stat|
+      puts "Some stat: #{stat.inspect}"
+    end
+    
+    EM::Dir['./**/*.lisp'].each_entry do |entry|
+      puts "Some entry: #{entry}"
+    end
+    
+    EM::Dir['./**/*.rb'].each_path do |path|
+      puts "Some path: #{path}"
+    end
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"

data/em-fs.gemspec

@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/em-fs/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Arthur Leonard Andersen"]
+  gem.email         = ["leoc.git@gmail.com"]
+  gem.description   = %q{`em-fs` provides libraries to access file system commands through an API similar to the Ruby file API for eventmachine.}
+  gem.summary       = %q{Invoke filesystem calls without blocking.}
+  gem.homepage      = "http://github.com/leoc/em-fs"
+
+  gem.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  gem.files         = `git ls-files`.split("\n")
+  gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  gem.name          = "em-fs"
+  gem.require_paths = ["lib"]
+  gem.version       = EventMachine::FS::VERSION
+
+  gem.add_development_dependency 'rake'
+  gem.add_development_dependency 'rspec'
+  gem.add_development_dependency 'guard'
+  gem.add_development_dependency 'guard-rspec'
+
+  gem.add_dependency 'eventmachine'
+  gem.add_dependency 'em-systemcommand'
+
+end

data/lib/em-fs/core_ext.rb

@@ -0,0 +1,15 @@
+class Hash
+  def extractable_options?
+    instance_of?(Hash)
+  end
+end
+
+class Array
+  def extract_options!
+    if last.is_a?(Hash) && last.extractable_options?
+      pop
+    else
+      {}
+    end
+  end
+end

data/lib/em-fs/dir/glob.rb

@@ -0,0 +1,7 @@
+module EventMachine
+  class Dir
+    class Glob
+
+    end
+  end
+end

data/lib/em-fs/dir.rb

@@ -0,0 +1,14 @@
+require 'em-fs/dir/glob'
+
+module EventMachine
+  class Dir
+    class << self
+
+      def glob pattern
+        EM::Dir::Glob.new pattern
+      end
+      alias :[] :glob
+
+    end
+  end
+end

data/lib/em-fs/file/stat.rb

@@ -0,0 +1,200 @@
+module EventMachine
+  class File
+    class Stat
+
+      STAT_REGEX = /(\d+) (\d+) (\d+) (\d+) (\h+) '([\w\/ ]+)' (\d+) (\d+) (\d+) '(.+)' '(.+)' (\d+) (\d+) (\h+) (\h+) (\d+) (\d+) (\d+) (\d+) (\d+)/.freeze
+      STAT_FORMAT = "%a %b %B %d %f '%F' %g %h %i '%m' '%n' %o %s %t %T %u %W %X %Y %Z"
+
+      # Types
+      S_IFBLK   = 0b00000001 # block device
+      S_IFCHR   = 0b00000010 # character device
+      S_IFDIR   = 0b00000100 # directory
+      S_IFIFO   = 0b00001000 # FIFO/pipe
+      S_IFLNK   = 0b00010000 # symlink
+      S_IFREG   = 0b00100000 # regular file
+      S_IFSOCK  = 0b01000000 # socket
+      S_UNKNOWN = 0b10000000 # unknown
+
+      # Mode Flags
+      S_IRUSR   = 0b100000000
+      S_IWUSR   = 0b010000000
+      S_IXUSR   = 0b001000000
+      S_IRGRP   = 0b000100000
+      S_IWGRP   = 0b000010000
+      S_IXGRP   = 0b000001000
+      S_IROTH   = 0b000000100
+      S_IWOTH   = 0b000000010
+      S_IXOTH   = 0b000000001
+
+      class << self
+
+        ##
+        # Parses a given string for file stat information.
+        #
+        # @param [String] string The String to be parsed.
+        # @return [EM::File::Stat] The file stat object.
+        def parse str
+          if m = str.match(STAT_REGEX)
+            ftype = case m[6]
+                    when 'block device' then S_IFBLK
+                    when 'character device' then S_IFCHR
+                    when 'directory' then S_IFDIR
+                    when 'FIFO/pipe' then S_IFIFO
+                    when 'symlink' then S_IFLNK
+                    when 'regular file' then S_IFREG
+                    when 'socket' then S_IFSOCK
+                    else
+                      S_UNKNOWN
+                    end
+            EM::File::Stat.new path:  m[11],
+                               mountpoint: m[10],
+                               atime: Time.at(Integer(m[18], 10)),
+                               blksize: Integer(m[3], 10),
+                               blocks: Integer(m[2], 10),
+                               ctime: Time.at(Integer(m[20], 10)),
+                               dev: Integer(m[4], 10),
+                               dev_major: Integer(m[14], 8),
+                               dev_minor: Integer(m[15], 8),
+                               ftype: ftype,
+                               gid: Integer(m[7], 10),
+                               ino: Integer(m[9], 10),
+                               mode: Integer(m[1], 8),
+                               mtime: Time.at(Integer(m[19], 10)),
+                               nlink: Integer(m[8], 10),
+                               size: Integer(m[13], 10),
+                               uid: Integer(m[16], 10)
+          else
+            raise "Unable to parse stat string: #{str}"
+          end
+        end
+      end
+
+      attr_reader :path, :mountpoint, :atime, :blksize, :blocks, :ctime,
+                  :dev, :dev_major, :dev_minor, :ftype, :gid, :ino, :mtime,
+                  :nlink, :size, :uid
+
+      def initialize val = {}
+        @path       = val[:path]
+        @mountpoint = val[:mountpoint]
+        @atime      = val[:atime]
+        @blksize    = val[:blksize]
+        @blocks     = val[:blocks]
+        @ctime      = val[:ctime]
+        @dev        = val[:dev]
+        @dev_major  = val[:dev_major]
+        @dev_minor  = val[:dev_minor]
+        @ftype      = val[:ftype]
+        @gid        = val[:gid]
+        @ino        = val[:ino]
+        @mode       = val[:mode]
+        @mtime      = val[:mtime]
+        @nlink      = val[:nlink]
+        @size       = val[:size]
+        @uid        = val[:uid]
+      end
+
+      def blockdev?
+        ftype^S_IFBLK == 0
+      end
+
+      def chardev?
+        ftype^S_IFCHR == 0
+      end
+
+      def directory?
+        ftype^S_IFDIR == 0
+      end
+
+      def executable?
+        return true if Process::UID.rid == 0
+        return @mode & S_IXUSR != 0 if rowned?
+        return @mode & S_IXGRP != 0 if rgrpowned?
+        @mode & S_IXOTH != 0
+      end
+
+      def executable_real?
+        return true if Process::UID.rid == 0
+        return @mode & S_IXUSR != 0 if rowned?
+        return @mode & S_IXGRP != 0 if rgrpowned?
+        @mode & S_IXOTH != 0
+      end
+
+      def file?
+        ftype^S_IFREG == 0
+      end
+
+      def grpowned?
+        gid == Process::GID.eid
+      end
+
+      def rgrpowned?
+        gid == Process::GID.rid
+      end
+
+      def mode
+        @mode.to_s(8)
+      end
+
+      def owned?
+        uid == Process::UID.eid
+      end
+
+      def rowned?
+        uid == Process::UID.rid
+      end
+
+      def pipe?
+        ftype^S_IFIFO == 0
+      end
+
+      def readable?
+        return true if Process::UID.eid == 0
+        return @mode & S_IRUSR != 0 if owned?
+        return @mode & S_IRGRP != 0 if grpowned?
+        @mode & S_IROTH != 0
+      end
+
+      def readable_real?
+        return true if Process::UID.rid == 0
+        return @mode & S_IRUSR != 0 if rowned?
+        return @mode & S_IRGRP != 0 if rgrpowned?
+        @mode & S_IROTH != 0
+      end
+
+      def socket?
+        ftype^S_IFSOCK == 0
+      end
+
+      def symlink?
+        ftype^S_IFLNK == 0
+      end
+
+      def world_readable?
+        @mode if @mode & S_IROTH == S_IROTH
+      end
+
+      def world_writable?
+        @mode if @mode & S_IWOTH == S_IWOTH
+      end
+
+      def writable?
+        return true if Process::UID.rid == 0
+        return @mode & S_IWUSR != 0 if owned?
+        return @mode & S_IWGRP != 0 if grpowned?
+        @mode & S_IWOTH != 0
+      end
+
+      def writable_real?
+        return true if Process::UID.rid == 0
+        return @mode & S_IWUSR != 0 if rowned?
+        return @mode & S_IWGRP != 0 if rgrpowned?
+        @mode & S_IWOTH != 0
+      end
+
+      def zero?
+        @size == 0
+      end
+
+    end
+  end
+end

data/lib/em-fs/file.rb

@@ -0,0 +1,21 @@
+require 'em-fs/file/stat'
+
+module EventMachine
+  class File
+
+    class << self
+
+      def stat path, &block
+        EM::SystemCommand.execute 'stat', [:format, EM::File::Stat::STAT_FORMAT], path do |on|
+          on.success do |ps|
+            block.call EM::File::Stat.parse ps.stdout.output
+          end
+          on.failure do |ps|
+            raise "EM::File::stat failed. Output:\n#{ps.stderr.output}"
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/em-fs/fileutils.rb

@@ -0,0 +1,149 @@
+module EventMachine
+  class FileUtils
+    class << self
+      ##
+      # Make directories.
+      def mkdir *dirs, &block
+        options = { parents: false }.merge dirs.extract_options!
+        cmd = EM::SystemCommand.new 'mkdir', &block
+        cmd << :p if options[:parents]
+        cmd << dirs
+        cmd.execute
+      end
+
+      ##
+      # Make directories with parents.
+      def mkdir_p *dirs, &block
+        options = {}.merge dirs.extract_options!
+        mkdir *dirs, options.merge(parents: true), &block
+      end
+
+      ##
+      # Remove the directories if they are empty.
+      def rmdir *dirs, &block
+        options = { parents: false }.merge dirs.extract_options!
+        cmd = EM::SystemCommand.new 'rmdir'
+        cmd << :p if options[:parents]
+        cmd << dirs
+        cmd.execute &block
+      end
+
+      ##
+      # Create link in file system.
+      def ln src, dest, options = {}, &block
+        options = { symbolic: false, force: false }.merge options
+        cmd = EM::SystemCommand.new 'ln'
+        cmd << :s if options[:symbolic]
+        cmd << :f if options[:force]
+        cmd << src << dest
+        cmd.execute &block
+      end
+
+      ##
+      # Create symbolic link.
+      def ln_s src, dest, options = {}, &block
+        ln src, dest, options.merge(symbolic: true), &block
+      end
+
+      ##
+      # Force symbolic link creation.
+      def ln_sf src, dest, options = {}, &block
+        ln src, dest, options.merge(symbolic: true, force: true), &block
+      end
+
+      ##
+      # Copy files.
+      def cp *args, &block
+        options = { recursive: false }.merge args.extract_options!
+        unless args.length >= 2
+          raise 'Too few arguments. Need source and destination at least.'
+        end
+
+        cmd = EM::SystemCommand.new 'cp'
+        cmd << :r if options[:recursive]
+        cmd << args
+        cmd.execute &block
+      end
+
+      ##
+      # Recursively copy files.
+      def cp_r *args, &block
+        options = { recursive: false }.merge args.extract_options!
+        cp *args, options.merge(recursive: true), &block
+      end
+
+      ##
+      # Move files or directories.
+      def mv *args, &block
+        options = { recursive: false }.merge args.extract_options!
+        unless args.length >= 2
+          raise 'Too few arguments. Need source and destination at least.'
+        end
+
+        cmd = EM::SystemCommand.new 'mv'
+        cmd << args
+        cmd.execute &block
+      end
+
+      ##
+      # Remove files or directories.
+      def rm *args, &block
+        options = { recursive: false, force: false }.merge args.extract_options!
+        cmd = EM::SystemCommand.new 'rm'
+        cmd << '-r' if options[:recursive]
+        cmd << '-f' if options[:force]
+        cmd << args
+        cmd.execute &block
+      end
+
+      def rm_r target, options = {}, &block
+        rm target, options.merge(recursive: true), &block
+      end
+
+      def rm_rf target, options = {}, &block
+        rm target, options.merge(recursive: true, force: true), &block
+      end
+
+      def install *args, &block
+        options = { mode: '755' }.merge args.extract_options!
+        cmd = EM::SystemCommand.new 'install'
+        cmd.add '--mode', options[:mode] if options[:mode]
+        cmd << args
+        cmd.execute &block
+      end
+
+      def chmod mode, *dest, &block
+        options = { recursive: false }.merge dest.extract_options!
+        cmd = EM::SystemCommand.new 'chmod'
+        cmd << :R if options[:recursive]
+        cmd << mode << dest
+        cmd.execute &block
+      end
+
+      def chmod_R mode, *dest, &block
+        options = { recursive: false }.merge dest.extract_options!
+        chmod mode, *dest, options.merge(recursive: true), &block
+      end
+
+      def chown user, group, *dest, &block
+        options = { recursive: false }.merge dest.extract_options!
+        cmd = EM::SystemCommand.new 'chown'
+        cmd << :R if options[:recursive]
+        cmd << "#{user.to_s}:#{group.to_s}" << dest
+        cmd.execute &block
+      end
+
+      def chown_R user, group, *dest, &block
+        options = { recursive: false }.merge dest.extract_options!
+        chown user, group, dest, options.merge(recursive: true), &block
+      end
+
+      def touch *dest, &block
+        options = {}.merge dest.extract_options!
+        cmd = EM::SystemCommand.new 'touch'
+        cmd << dest
+        cmd.execute &block
+      end
+    end
+  end
+end

data/lib/em-fs/fs/command.rb

@@ -0,0 +1,58 @@
+# -*- coding: utf-8 -*-
+module EventMachine
+  class FS
+    class Command < EM::SystemCommand
+
+      PROGRESS_REGEXP = /([A-Za-z0-9\.\-\/]+)\n[ ]+(\d+)/.freeze
+
+      ##
+      # Invokes `#execute` of super-class and adds a progress matcher.
+      def execute &block
+        super &block
+
+        stdout.match PROGRESS_REGEXP, match: :last, in: :output do |file, bytes|
+          receive_progress file, bytes.to_i
+        end
+
+        self
+      end
+
+      ##
+      # Is called when ever a `EM::FilesystemCommand` stdout updates the line
+      # is matched the `EM::FilesystemCommand::PROGRESS_REGEXP`.
+      #
+      # Calls all defined callbacks for progress events.
+      #
+      # @param [String] file The file that´s been updated.
+      # @param [Integer] bytes The bytes moved or copied.
+      def receive_progress file, bytes
+        progress_callbacks.each do |cb|
+          cb.call file, bytes
+        end
+      end
+
+      ##
+      # Defines a progress callback.
+      #
+      # @yield The block to be stored as callback for progress events.
+      # @yieldparam [String] file The file that´s been updated.
+      # @yieldparam [Integer] bytes The bytes moved or copied.
+      def progress &block
+        progress_callbacks << block
+      end
+
+      ##
+      # The callbacks for progress events.
+      #
+      # @return [Array] The array of callbacks for progress events.
+      private
+      def progress_callbacks
+        @progress_callbacks ||= []
+      end
+
+      def progress_regexp
+        @progress_regexp ||= /([A-Za-z0-9\.\-\/]+)\n[ ]+(\d+)/.freeze
+      end
+    end
+  end
+end

data/lib/em-fs/fs/rsync_command.rb

@@ -0,0 +1,11 @@
+module EventMachine
+  class FS
+    class RsyncCommand < EM::FS::Command
+
+      def initialize
+        super 'rsync'
+      end
+
+    end
+  end
+end

data/lib/em-fs/fs.rb

@@ -0,0 +1,25 @@
+require 'em-fs/fs/command'
+require 'em-fs/fs/rsync_command'
+
+module EventMachine
+  class FS
+    class << self
+
+      def rsync *args, &block
+        options = { }.merge args.extract_options!
+        cmd = EM::FS::RsyncCommand.new
+        cmd << :progress
+        cmd << args
+        cmd.execute &block
+      end
+
+      def find *args, &block
+        options = { }.merge args.extract_options!
+        cmd = EM::SystemCommand.new 'find'
+        cmd << args
+        cmd.execute &block
+      end
+
+    end
+  end
+end