fled 0.0.1

data/lib/dtc/utils/exec.rb

@@ -0,0 +1,134 @@
+
+require 'shellwords'
+require 'open3'
+
+module DTC
+  module Utils
+    # Execute a program with popen3, pipe data to-from a proc in an async loop
+    #
+    #     i = 10
+    #     Exec.run("cat",
+    #       :input => "Initial input\n",
+    #       :select_timeout => 1,
+    #       :autoclose_stdin => false
+    #       ) do |process, sout, serr, writer|
+    #       if writer && (i -= 1) > 0 && i % 2 == 0
+    #         puts "Writing"
+    #         writer.call("Hello async world!\n", lambda { |*args| puts "Write complete" })
+    #       elsif writer && i <= 0
+    #         puts "Closing stdin"
+    #         writer.call(nil, lambda { |*args| puts "Close complete" })
+    #       end
+    #       puts "Got #{sout.inspect}" if sout != ""
+    #     end
+    class Exec
+      class << self
+        def sys *opts
+          system(opts.flatten.map {|e| Shellwords::shellescape(e.to_s)}.join(" "))
+          raise "External command error" unless $?.success?
+        end
+        def sys_in cwd, *opts
+          Dir.chdir cwd { sys(*opts) }
+        end
+        def rsys *opts
+          res = `#{opts.map {|e| Shellwords::shellescape(e.to_s)}.join(" ")}`
+          $?.success? ? res : nil
+        end
+        def rsys_in cwd, *opts
+          Dir.chdir cwd { rsys(*opts) }
+        end
+        def git *opts
+          sys(*(%w[git] + opts))
+        end
+        def git_in cwd, *opts
+          Dir.chdir(cwd) { git(*opts) }
+        end
+        def rgit *opts
+          rsys(*(%w[git] + opts))
+        end
+        def rgit_in cwd, *opts
+          Dir.chdir(cwd) { return rgit(*opts) }
+        end
+      end
+
+      def initialize *cmd
+        options = cmd.last.is_a?(Hash) ? cmd.pop() : {}
+        @input = options.delete(:input)
+        @autoclose_stdin = options.delete(:autoclose_stdin) { true }
+        @cmd = cmd + options.delete(:cmd) { [] }
+        @select_timeout = options.delete(:select_timeout) { 5 }
+        @running = false
+        @ran = false
+      end
+      attr_accessor :input
+      attr_accessor :cmd
+      attr_reader :ran, :running, :exec_time, :stdout, :stderr
+      def run # :yields: exec, new_stdout, new_stderr, write_proc
+        @start_time = Time.new
+        @stdout = ""
+        @stderr = ""
+        @running = true
+        stdin, stdout, stderr = Open3::popen3(*@cmd)
+        begin
+          stdout_read, stderr_read = "", ""
+          MiniSelect.run(@select_timeout) do |select|
+            writing = 0
+            write_proc = lambda do |*args|
+              text, callback = *args
+              if text.nil?
+                write_proc = nil
+                select.close(stdin) do |miniselect, event, file, error|
+                  callback.call(miniselect, event, file, error) if callback
+                end
+              else
+                writing += 1
+                select.write(stdin, text) do |miniselect, event, file, error|
+                  if event == :error || event == :close
+                    writing = 0
+                    write_proc = nil
+                  else
+                    writing -= 1
+                  end
+                  callback.call(miniselect, event, file, error) if callback
+                end
+              end
+            end
+            select.add_read(stdout) do |miniselect, event, file, data_string|
+              if data_string
+                @stdout << data_string
+                stdout_read << data_string
+              end
+            end
+            select.add_read(stderr) do |miniselect, event, file, data_string|
+              if data_string
+                @stderr << data_string
+                stderr_read << data_string
+              end
+            end
+            select.every_beat do |miniselect|
+              yield(self, stdout_read, stderr_read, write_proc) if block_given?
+              if write_proc && writing == 0 && @autoclose_stdin
+                select.close(stdin)
+                write_proc = nil
+              end
+              stdout_read, stderr_read = "", ""
+            end
+            write_proc.call(@input) if @input
+          end
+          if stdout_read != "" || stderr_read != ""
+            yield(self, stdout_read, stderr_read, nil) if block_given?
+          end
+        ensure
+          [stdin, stdout, stderr].each { |f| f.close() if f && !f.closed? }
+          @running = false
+          @ran = true
+        end
+        @exec_time = Time.new - @start_time
+      end
+      # <code>self.new(&block).run(*args)</code>
+      def self.run *args, &block
+        self.new(*args).run(&block)
+      end
+    end
+  end
+end

data/lib/dtc/utils/file_visitor.rb

@@ -0,0 +1,78 @@
+module DTC
+  module Utils
+    class FileVisitor
+      def depth ; @folders.nil? ? 0 : @folders.count ; end
+      def current_path *args ; File.join(@folders + args) ; end
+      attr_accessor :next_visitor
+      def enter_folder dir
+        return false unless next_visitor ? next_visitor.enter_folder(dir) : true
+        (@folders ||= []) << dir
+        true
+      end
+      def visit_file name, full_path
+        next_visitor.visit_file(name, full_path) if next_visitor
+      end
+      def leave_folder
+        next_visitor.leave_folder if next_visitor
+        @folders.pop
+      end
+      def self.browse path, visitor, max_depth = -1
+        dir = Dir.new(path)
+        return unless visitor.enter_folder path
+        dir.each do |f|
+          full_path = File.join(path, f)
+          next if f == "." || f == ".."
+          if File.directory? full_path
+            self.browse(full_path, visitor, max_depth - 1) unless max_depth == 0
+          else
+            visitor.visit_file f, full_path
+          end
+        end
+        visitor.leave_folder
+      end
+    end
+    class FilteringFileVisitor < FileVisitor
+      def initialize listener, options = {}
+        @excluded = compile_regexp(options[:excluded])
+        @excluded_files = compile_regexp(options[:excluded_files])
+        @excluded_directories = compile_regexp(options[:excluded_directories])
+        @included = compile_regexp(options[:included])
+        @included_files = compile_regexp(options[:included_files])
+        @included_directories = compile_regexp(options[:included_directories])
+        @recurse = options[:max_depth] || -1
+        self.next_visitor = listener
+      end
+      def enter_folder dir
+        return false unless include?(File.basename(dir), false)
+        if (result = super) && !descend?(dir)
+          leave_folder
+          return false
+        end
+        result
+      end
+      def visit_file name, full_path
+        return false unless include?(name, true)
+        super
+      end
+      protected
+      def compile_regexp(rx_list)
+        return nil if rx_list.nil? || rx_list.reject { |e| e.length == 0 }.empty?
+        Regexp.union(*rx_list.map { |e| /#{e}/i })
+      end
+      def descend?(name)
+        @recurse == -1 || @recurse >= (depth - 1)
+      end
+      def include?(name, is_file)
+        can_include = (@included.nil? || @included.match(name)) &&
+          ((is_file && (@included_files.nil? || @included_files.match(name))) ||
+           (!is_file && (@included_directories.nil? || @included_directories.match(name))))
+        if can_include
+          can_include = (@excluded.nil? || !@excluded.match(name)) &&
+            ((is_file && (@excluded_files.nil? || !@excluded_files.match(name))) ||
+             (!is_file && (@excluded_directories.nil? || !@excluded_directories.match(name))))
+        end
+        can_include
+      end
+    end
+  end
+end

data/lib/dtc/utils/interactive_edit.rb

@@ -0,0 +1,81 @@
+require 'yaml'
+require 'tempfile'
+require 'shellwords'
+begin
+  require 'platform'
+rescue LoadError
+end
+
+module DTC::Utils
+  # Copied from gem utility_belt (and modified, so get your own copy http://utilitybelt.rubyforge.org)
+  # Giles Bowkett, Greg Brown, and several audience members from Giles' Ruby East presentation.
+  class InteractiveEditor
+    DEBIAN_SENSIBLE_EDITOR = "/usr/bin/sensible-editor"
+    MACOSX_OPEN_CMD        = ["open", "--wait-apps", "-e"]
+    WIN_START_CMD          = ["start", "-w"]
+    XDG_OPEN               = "/usr/bin/xdg-open"
+    def self.sensible_editor
+      return Shellwords::split(ENV["VISUAL"]) if ENV["VISUAL"]
+      return Shellwords::split(ENV["EDITOR"]) if ENV["EDITOR"]
+      if defined?(Platform)
+        return WIN_START_CMD if Platform::IMPL == :mswin
+        return MACOSX_OPEN_CMD if Platform::IMPL == :macosx
+        if Platform::IMPL == :linux
+          if File.executable?(XDG_OPEN)
+            return XDG_OPEN
+          end
+          if File.executable?(DEBIAN_SENSIBLE_EDITOR)
+            return DEBIAN_SENSIBLE_EDITOR
+          end
+        end
+      end
+      raise "Could not determine what editor to use.  Please specify (or use platform gem)."
+    end
+    attr_accessor :editor
+    def initialize(editor = InteractiveEditor.sensible_editor, extension = ".yaml")
+      @editor = @editor == "mate" ? ["mate", "-w"] : editor
+      @extension = extension
+      @file = nil
+    end
+    def filename
+      @file ? @file.path : nil
+    end
+    def edit_file_interactively(filename)
+      Exec.sys(@editor, filename)
+    end
+    def edit_interactively(content)
+      unless @file
+        @file = Tempfile.new(["#{File.basename(__FILE__, File.extname(__FILE__))}-edit", @extension])
+        @file << content
+        @file.close
+      end
+      edit_file_interactively(@file.path)
+      IO::read(@file.path)
+      rescue Exception => error
+        @file.unlink
+        @file = nil
+        puts error
+    end
+    def self.edit_file(filename, editor = InteractiveEditor.sensible_editor)
+      editor = InteractiveEditor.new editor
+      editor.edit_file_interactively(filename)
+      rescue Exception => error
+        puts "# !!!" + error.inspect
+        raise
+        return nil
+    end
+    def self.edit(content, extension = ".yaml", editor = InteractiveEditor.sensible_editor)
+      InteractiveEditor.new(editor, extension).edit_interactively(content)
+    end
+    def self.edit_in_yaml(object, editor = InteractiveEditor.sensible_editor)
+      input = "# Just empty and save this document to abort !\n" + object.to_yaml
+      editor = InteractiveEditor.new editor
+      res = editor.edit_interactively(input)
+      YAML::load(res)
+      rescue Exception => error
+        puts "# !!!" + error.inspect
+        raise
+        return nil
+    end
+  end
+end

data/lib/dtc/utils/mini_select.rb

@@ -0,0 +1,177 @@
+module DTC
+  module Utils
+    # Small select(2) implementation
+    class MiniSelect
+      BUFSIZE = 4096
+      def initialize &block # :yields: miniselect
+        @want_read = {}
+        @want_write = {}
+        @want_close = {}
+        @shutdown = false
+        @stop_when_empty = true
+        yield self if block_given?
+      end
+      attr_reader :shutdown
+      # Default: True. Stops as soon as there are no more watched fds.
+      attr_accessor :stop_when_empty
+      # Shutdown the loop after this step
+      def stop
+        @shutdown = :requested_by_stop
+      end
+      # True if no items will be read or written (which also terminates the loop)
+      def empty?
+        @want_read.empty? && @want_write.empty?
+      end
+      # Add a file to monitor for reading.
+      # When read events occur, provided block is yielded with event <code>:read</code>,
+      # upon close it is yielded with event <code>:close</code>
+      def add_read fd, &cb # :yields: miniselect, event, file, data_string
+        @want_read[fd] = cb
+      end
+      # Write to specified fd in a non-blocking manner
+      #
+      # When write is completed, provided block is yielded with event <code>:done</code>,
+      # upon close it is yielded with event <code>:close</code>
+      def write fd, data, &cb # :yields: miniselect, event, file
+        raise "Cannot write, FD is closed" if fd.closed?
+        raise "Cannot write, FD is marked to close when finished" if @want_close[fd]
+        (@want_write[fd] ||= []) << [data, cb]
+      end
+      # Provided block is called at every select(2) timeout or operation
+      def every_beat &block # :yields: miniselect
+        (@block ||= []) << block
+      end
+      # Provided block is called at every select(2) timeout
+      def every_timeout &block # :yields: miniselect
+        (@timeouts ||= []) << block
+      end
+      # Provided block is called at every read/write error
+      def every_error &block # :yields: miniselect, fd, error
+        (@error_handlers ||= []) << block
+      end
+      # Close the specified file, calling all callbacks as required, closing the
+      # descriptor, and removing them from the miniselect
+      def close_now fd, error = nil
+        event_id = error ? :error : :close
+        Array(@want_read.delete(fd)).each { |cb| cb.call(self, event_id, fd, error) if cb }
+        Array(@want_write.delete(fd)).each { |data, cb| cb.call(self, event_id, fd, error) if cb }
+        Array(@want_close.delete(fd)).each { |cb| cb.call(self, event_id, fd, error) }
+        fd.close unless fd.closed?
+        if error && @error_handlers
+          Array(@error_handlers).each { |cb| cb.call(self, fd, error) }
+        end
+      end
+      # Write to specified fd in a non-blocking manner
+      #
+      # When write is completed, the file is closed and the provided
+      # block is yielded with event <code>:close</code>.
+      def close fd, &cb # :yields: miniselect, event, file
+        return if fd.closed?
+        @want_close[fd] = cb
+        if Array(@want_read[fd]).empty? && Array(@want_write[fd]).empty?
+          close_now fd
+        end
+      end
+      # Run the select loop, return when it terminates
+      def run timeout = 5
+        while !@shutdown && run_select(timeout)
+          Array(@block).each { |cb| cb.call(self) } if @block
+        end
+      end
+      # <code>self.new(&block).run(*args)</code>
+      def self.run *args, &block
+        self.new(&block).run(*args)
+      end
+
+      protected
+
+      # Read data from fd without blocking, close on error
+      # 
+      # return [is_fd_active, data_read]
+      def read_fd_nonblock fd
+        res = ""
+        can_goon = true
+        error = nil
+        while fd
+          begin
+            buf = fd.read_nonblock(BUFSIZE)
+            res << buf if buf
+            redo if buf && buf.length == BUFSIZE
+          rescue Errno::EAGAIN
+            break
+          rescue EOFError => e
+            can_goon = false
+            break
+          rescue SystemCallError => e
+            can_goon = false
+            error = e
+            break
+          end
+        end
+        @want_read[fd].call(self, :read, fd, res) if res != ""
+        close_now(fd, error) unless can_goon
+        [can_goon, res]
+      end
+      # Write data to fd in a non blocking way, close on error
+      # 
+      # return [is_fd_active, unwritten_data]
+      def write_fd_nonblock fd, data, cb
+        len = 0
+        can_goon = true
+        error = nil
+        if fd
+          begin
+            wlen = fd.write_nonblock(data)
+            len += wlen if wlen
+          rescue Errno::EAGAIN
+          rescue SystemCallError => e
+            error = e
+            can_goon = false
+          end
+        end
+        complete = len == data.length
+        if complete
+          pdata, cb = @want_write[fd].shift
+          cb.call(self, :done, fd) if cb
+        elsif len > 0
+          @want_write[fd].first[0] = data[len..-1]
+        end
+        close_now(fd, error) unless can_goon
+        [can_goon, can_goon && complete]
+      end
+      # run one call to select, and resulting fd operations
+      def run_select timeout
+        if @stop_when_empty && empty?
+          @shutdown = :no_active_fd
+          return false
+        end
+        result = select(@want_read.keys, @want_write.keys,
+          (@want_read.keys + @want_write.keys + @want_close.keys).uniq, timeout)
+        if !result
+          Array(@timeouts).each { |cb| cb.call(self) } if @timeouts
+          return true
+        end
+        r, w, e = *result
+        r.each do |readable|
+          can_retry, data = read_fd_nonblock(readable)
+        end
+        w.each do |writable|
+          queue = @want_write[writable]
+          while !queue.empty?
+            can_retry, is_write_complete = write_fd_nonblock(writable, *queue.first)
+            break unless can_retry && is_write_complete
+          end
+          if queue.empty?
+            @want_write.delete(writable)
+            close_now writable if @want_close[writable]
+          end
+        end
+        e.each do |erroredified|
+          puts "#{erroredified} error"
+          close erroredified
+        end
+        true
+      end
+    end
+  end
+end

data/lib/dtc/utils.rb

@@ -0,0 +1,9 @@
+module DTC
+  module Utils
+    autoload :Exec, 'dtc/utils/exec'
+    autoload :InteractiveEditor, 'dtc/utils/interactive_edit'
+    autoload :MiniSelect, 'dtc/utils/mini_select'
+    autoload :DSLDSL, 'dtc/utils/dsldsl'
+    autoload :FileVisitor, 'dtc/utils/file_visitor'
+  end
+end