fled 0.0.2 → 0.0.3

data/bin/fled

@@ -14,13 +14,62 @@ class App
   DEFAULT_SKIP_FOLDERS = ['.svn', '_svn', '.git', 'CVS', '.hg']
   DEFAULT_SKIP_FILES_RX = ['^\..*', '.*~$']
   DEFAULT_SKIP_FILES = [".DS_Store", "Thumbs.db", "Temporary Items"]
-  
+  DEFAULT_OPTIONS_PATH = "~/.fled.yaml"
+  DEFAULT_OPTIONS = {
+    :max_depth => -1,
+    :interactive => true,
+    :verbose => false,
+    :diff_command => %w[diff -uda],
+    :excluded_files =>
+      DEFAULT_SKIP_FILES_RX +
+      DEFAULT_SKIP_FILES.map { |e| '\A' + Regexp.escape(e) + '\z' },
+    :excluded_directories =>
+      DEFAULT_SKIP_FOLDERS_RX +
+      DEFAULT_SKIP_FOLDERS.map { |e| '\A' + Regexp.escape(e) + '\z' },
+  }
+  OPTIONS_THAT_AFFECT_SCANNING = [
+    :max_depth,
+    :excluded, :excluded_directories, :excluded_files,
+    :included, :included_directories, :included_files,
+  ]
+  OPTIONS_THAT_CANT_CHANGE_DURING_INTERACTIVE_RUN = [ :interactive ]
+  EXIT_REASONS = {
+    :nothing_to_list => ["No files/folders found", 1],
+    :nothing_edited => ["No changes", 2],
+    :user_abort => ["User abort", 126],
+    :invalid_options => ["Error parsing arguments", 127, :print_usage],
+  }
+  MAIN_MENU_OPTIONS = {
+    :reconfigure => "Re-sca(n)",
+    :edit_listing => "(E)dit listing",
+    :abort => "(A)bort",
+  }
+  MAIN_MENU_OPTIONS_WITH_OPERATIONS = {
+    :diff => "(D)iff",
+    :edit_script => "Edit (s)cript",
+    :print_preview => "(P)review script",
+    :quit => "Print and (q)uit",
+    :revert_listing => "(R)evert",
+  }
+  MAIN_MENU_OPTIONS_AFTER_SCRIPT_EDIT = {
+    :quit => "Print edited script and (q)uit",
+    :edit_script => "(E)dit script",
+    :revert_script => "(R)evert script and edit",
+    :return => "(D)iscard edited script",
+    :abort => "(A)bort",
+  }
+  CONFIRM_MENU_OPTIONS_FOR_RESCAN = {
+    :yes => "(Y)es, loose any edits and uids and rescan",
+    :no => "(N)o, cancel",
+  }
   attr_reader :options
 
   def initialize(arguments = ARGV)
     @arguments = arguments.dup
     @options = {}
     @options[:verbose] = false
+    @edited_listing = nil
+    @operations = []
   end
 
   def run
@@ -30,49 +79,211 @@ class App
         exit 0
       end
       output_version if @options[:verbose]
-      $stderr.puts "Starting on path #{@base_path} at #{DateTime.now}" if @options[:verbose]
-      builder = FlEd::ListingBuilder.new()
-      filter = DTC::Utils::FilteringFileVisitor.new builder, @options
-      DTC::Utils::FileVisitor.browse @base_path, filter
-      content = builder.listing.to_s
-      if content == ""
-        $stderr.puts "No files/folders found"
-        exit 1
-      end
-      result = DTC::Utils::InteractiveEditor::edit(content, ".yaml")
-      if result.nil? || result.strip == "" || result == content
-        $stderr.puts "No changes - aborting" ; exit 2
-      end
-      target_listing = FlEd::FileListing.parse(result)
-      ops = target_listing.operations_from!(builder.listing)
-      if ops.empty?
-        $stderr.puts "No changes - aborting" ; exit 2
-      end
-      ops = [[:pushd, @base_path]] + ops + [[:popd]] unless @options[:no_pushd]
-      puts FlEd::operation_list_to_bash(ops).join("\n")
-      $stderr.puts "\nFinished at #{DateTime.now}" if @options[:verbose]
+      update_listing!
+      edit_listing!
+      if @options[:interactive]
+        interactive_main_menu
+      else
+        die! :nothing_edited if operations.empty?
+        print_script
+      end
     else
       output_usage
     end
   rescue SystemExit => e
     raise
-  rescue Exception => e
-    puts e
-    output_usage
-    exit 127
+  rescue OptionParser::ParseError => e
+    die! :invalid_options, e.to_s
   end
+
   protected
+    def update_listing!
+      @listing = scan_path_into_listing(@base_path)
+      @listing_text = @listing.to_s
+      @edited_listing = nil
+      @operations = []
+    end
+
+    def update_operations! edited_listing = @edited_listing
+      @operations = ops_for_edited_listing(@listing, @listing_text, edited_listing)
+    end
+
+    def edit_listing!
+      edited_listing = DTC::Utils::InteractiveEditor::edit(@edited_listing || @listing_text, ".yaml", @options[:editor])
+      @edited_listing = edited_listing unless edited_listing.to_s.strip == ""
+      update_operations! edited_listing
+      interactive_print_status
+    end
+
+    def print_script operations = @operations, preview = false
+      indentation = preview ? "    " : ""
+      script = operations.is_a?(String) ? operations : script_for_operations(operations, indentation)
+      if preview
+        status script
+      else
+        print_output script
+      end
+    end
+
+    def send_interactive_command command, *args
+      __send__("interactive_#{command}".to_sym, *args)
+    end
+
+    def interactive_abort
+      die! :user_abort
+    end
+
+    def interactive_quit script = @operations
+      print_script script, false
+      exit 0
+    end
+
+    def interactive_print_preview
+      print_script(@operations, true)
+    end
+
+    def interactive_print_status
+      if @operations.empty?
+        status :nothing_edited
+      else
+        status "#{@operations.count} operation#{@operations.count != 1 ? 's' : ''}"
+        counted_operations = { :fail => "error", :warn => "warning" }
+        if @options[:verbose]
+          counted_operations = counted_operations.merge(
+            :moved => "move",
+            :renamed => "rename",
+            :rm => "deleted file",
+            :rmdir => "deleted folder",
+            :mk => "new folder"
+          )
+        end
+        if @operations.any? { |op| counted_operations[op.first] }
+          counted_operations.each_pair do |op_key, label|
+            count = @operations.select { |op| op.first == op_key }.count
+            status " #{count} #{label}#{count != 1 ? "s" : ""}" if count > 0
+          end
+        end
+      end
+    end
+
+    def interactive_diff # => "(D)iff"
+      if @edited_listing.to_s.strip == ""
+        status "No edited listing"
+      else
+        DTC::Utils::InteractiveEditor::with_temp_file "Original", ".yaml", @listing_text do |original|
+        DTC::Utils::InteractiveEditor::with_temp_file "Edited", ".yaml", @edited_listing do |edited|
+          status DTC::Utils::Exec::sys(*(@options[:diff_command] + [original, edited, {
+            :ignore_exit_code => true,
+            :capture_stdout => true
+          }]))
+        end
+        end
+      end
+    end
+
+    def interactive_edit_listing # => "(E)dit listing"
+      edit_listing!
+    end
+
+    def interactive_revert_listing # => "(R)evert listing"
+      @edited_listing = nil
+      @operations = []
+      edit_listing!
+    end
+
+    def interactive_reconfigure
+      new_options = @options.dup
+      OPTIONS_THAT_CANT_CHANGE_DURING_INTERACTIVE_RUN.each { |o| new_options.delete(o) }
+      new_options = DTC::Utils::InteractiveEditor::edit_in_yaml(new_options, @options[:editor])
+      unless new_options.is_a?(Hash)
+        status "Error, configuration must be a hash table, got #{new_options.inspect}" if new_options
+        return
+      end
+      OPTIONS_THAT_CANT_CHANGE_DURING_INTERACTIVE_RUN.each { |o| new_options.delete(o) }
+      if OPTIONS_THAT_AFFECT_SCANNING.any? { |k| new_options[k] != @options[k] }
+        return unless @operations.count == 0 || ask_user(CONFIRM_MENU_OPTIONS_FOR_RESCAN) == :yes
+        @options = @options.merge(new_options)
+        status "Config updated"
+        update_listing!
+        edit_listing!
+      else
+        @options = @options.merge(new_options)
+        update_operations!
+        status "Config updated"
+      end
+    end
+
+    def interactive_main_menu
+      trap "SIGINT" do
+        interactive_abort
+      end
+      while true
+        options = MAIN_MENU_OPTIONS
+        options = options.merge(MAIN_MENU_OPTIONS_WITH_OPERATIONS) unless @operations.empty?
+        cmd = ask_user(options)
+        send_interactive_command cmd
+      end
+    end
+
+    def interactive_edit_script original = script_for_operations(@operations), script = original
+      while true
+        result = DTC::Utils::InteractiveEditor::edit(script, ".sh", @options[:editor])
+        unless result.strip == "" || result == original
+          script = result
+          result = ask_user MAIN_MENU_OPTIONS_AFTER_SCRIPT_EDIT
+          case result
+            when :quit, :abort
+              send_interactive_command result, result
+            when :edit_script
+              redo
+            when :revert_script
+              script = script_for_operations(@operations)
+            when :return
+              return
+          end
+        else
+          info "Empty/unchanged script"
+          return
+        end
+      end
+    end
+
+    def scan_path_into_listing base_path = @base_path
+      info "Scanning path #{@base_path} at #{DateTime.now}"
+      builder = FlEd::FileListingBuilder.new()
+      DTC::Utils::Visitor::Folder::accept builder, base_path, @options
+      info "\nFinished at #{DateTime.now}"
+      listing = builder.listing
+      die! :nothing_to_list if listing.count.zero?
+      listing
+    end
+
+    def ops_for_edited_listing listing = @listing, listing_text = @listing_text, edited_listing = @edited_listing
+      return [] if edited_listing.to_s.strip == "" || edited_listing == listing_text
+      begin
+        target_listing = FlEd::FileListing.parse(edited_listing)
+        ops = target_listing.operations_from!(listing)
+      rescue RuntimeError => e
+        ops = [[:fail, "Error parsing line: #{e.message}"]]
+        info e.inspect
+      end
+      return [] if ops.empty?
+      return ops if ops.count == 1 && ops[0][0] == :fail
+      @options[:no_pushd] ? ops : ([[:pushd, @base_path]] + ops + [[:popd]])
+    end
+
+    def script_for_operations operations, line_prefix = ""
+      line_prefix + FlEd::operation_list_to_bash(operations).join("\n#{line_prefix}")
+    end
 
     def self.default_options
-      ({
-        :max_depth => -1,
-        :excluded_files =>
-          DEFAULT_SKIP_FILES_RX +
-          DEFAULT_SKIP_FILES.map { |e| '\A' + Regexp.escape(e) + '\z' },
-        :excluded_directories =>
-          DEFAULT_SKIP_FOLDERS_RX +
-          DEFAULT_SKIP_FOLDERS.map { |e| '\A' + Regexp.escape(e) + '\z' },
-      })
+      base = DEFAULT_OPTIONS || {}
+      if File.readable?(default_options_filename = File.expand_path(DEFAULT_OPTIONS_PATH))
+        data = File.open(default_options_filename) { |file| YAML.load(file) }
+        base = base.merge(data || {})
+      end
+      base[:editor] = DTC::Utils::InteractiveEditor::sensible_editor unless base[:editor]
+      base
     end
 
     def parsed_options?
@@ -102,10 +313,12 @@ class App
 
         opts.separator ""
         opts.separator "General"
+        opts.on('-u', '--[no-]interactive', "Offer to continue editing the listing")    { |v| options[:interactive] = v }
         opts.on_tail('-l', '--load PATH.YAML', "Merge in the specified yaml files options")    { |file|
           File.open(file) { |file| options = options.merge(YAML.load(file)) }
         }
-        opts.on_tail('--options', "Show options as interpreted and exit without doing anything")    { options[:output_options] = true }
+        opts.on_tail('--options', "Show options as interpreted and exit without doing anything",
+          "Example: #{$0} --options > #{File.expand_path(DEFAULT_OPTIONS_PATH)}")    { options[:output_options] = true }
         opts.on('-v', '--verbose', "Display more information about what the tool is doing...")    { options[:verbose] = true }
         opts.on_tail('--version', "Show version of this tool")    { output_version ; exit 0 }
         opts.on_tail('-h', '--help', "Show this help message")       { output_help ; exit 0 }
@@ -117,36 +330,111 @@ class App
       true
     end
     
-    def output_options out = $stdout
+    def output_options
       opts = @options.dup
       opts.delete(:output_options)
-      out.puts opts.to_yaml
+      print_output opts.to_yaml
     end
     
     def output_help
       output_version
-      $stderr.puts ""
-      $stderr.puts "  Disclaimer: The author is not responsible for anything related"
-      $stderr.puts "    to this tool. This is quite powerful and slight mistakes can"
-      $stderr.puts "    lead to loss of data or worse. The author recommends you not"
-      $stderr.puts "    use this."
-      $stderr.puts ""
-      $stderr.puts "  Operation:"
-      $stderr.puts "    - Generate list of files and folder"
-      $stderr.puts "    - Open in your favorite ($EDITOR) text editor"
-      $stderr.puts "    - You edit file names in the editor, then save and close"
-      $stderr.puts "    - The file list is reloaded and compared to the original"
-      $stderr.puts "    - A shell script to re-organise the files/folders is printed"
-      $stderr.puts ""
+      status DTC::Utils::Text::lines_without_indent <<-HELP_TEXT
+      
+        Disclaimer: The author is not responsible for anything related
+          to this tool. This is quite powerful and slight mistakes can
+          lead to loss of data or worse. The author recommends you not
+          use this.
+      
+        Operation:
+          - Generate list of files and folder
+          - Open in your favorite ($EDITOR) text editor
+          - You edit file names in the editor, then save and close
+          - The file list is reloaded and compared to the original
+          - A shell script to re-organise the files/folders is printed
+      
+      HELP_TEXT
       output_usage
     end
     
     def output_usage
-      $stderr.puts @optionparser
+      status @optionparser
     end
 
     def output_version
-      $stderr.puts "#{File.basename(__FILE__)} version #{FlEd::VERSION}"
+      status "#{File.basename(__FILE__)} version #{FlEd::VERSION}"
+    end
+
+    def print_prompt options
+      status_raw "=> #{options.values.join(", ")} ? "
+    end
+
+    def print_prompt_error options, error
+      status "  ! #{error}"
+      print_prompt options
+    end
+
+    def ask_user options = {}
+      keys = {}
+      options.each_pair { |k, v|
+        keys[v =~ /\((.)\)/ && $1.downcase] = k
+      }
+      print_prompt options
+      until keys[(response_key = readline.downcase.strip)]
+        if response_key == ""
+          message = "please enter one of: #{keys.keys.sort.map(&:inspect).join(", ")}"
+        else
+          message = "didn't understand #{response_key.inspect}"
+        end
+        print_prompt_error options, message
+      end
+      keys[response_key]
+    end
+
+    def readline
+      result = $stdin.readline.chomp
+      @on_incomplete_line = false
+      result
+    end
+
+    def status_raw message
+      $stderr.print message
+      $stderr.flush
+      @on_incomplete_line = !(message.length > 0 && message[-1..-1] == "\n")
+    end
+
+    def print_output message
+      if @on_incomplete_line
+        $stderr.puts ""
+        @on_incomplete_line = false
+      end
+      $stdout.puts message
+    end
+
+    def status message
+      if @on_incomplete_line
+        $stderr.puts ""
+        @on_incomplete_line = false
+      end
+      message = EXIT_REASONS[message][0] if message.is_a?(Symbol)
+      $stderr.puts message
+    end
+
+    def info message
+      status message if @options[:verbose]
+    end
+
+    def die! reason, suffix_text = nil
+      exit_code = 1
+      print_usage = false
+      if (message = EXIT_REASONS[reason])
+        print_usage = message[2] if message[2]
+        exit_code = message[1] if message[1]
+        reason = message[0]
+      end
+      reason = "#{reason}: #{suffix_text}" if suffix_text
+      status reason
+      output_usage if print_usage
+      exit exit_code
     end
 end
 App.new.run

data/lib/dtc/utils/exec.rb

@@ -24,8 +24,19 @@ module DTC
     class Exec
       class << self
         def sys *opts
-          system(opts.flatten.map {|e| Shellwords::shellescape(e.to_s)}.join(" "))
-          raise "External command error" unless $?.success?
+          options = {}
+          if opts.last.is_a?(Hash)
+            options = opts.pop
+          end
+          arguments = Shellwords.join(opts.flatten.map(&:to_s).to_a)
+          if options[:capture_stdout]
+            result = `#{arguments}`
+          else
+            system(arguments)
+            result = $?.exitstatus
+          end
+          raise "External command error: #{arguments}" unless options[:ignore_exit_code] || $?.success?
+          result
         end
         def sys_in cwd, *opts
           Dir.chdir cwd { sys(*opts) }

data/lib/dtc/utils/interactive_edit.rb

@@ -43,6 +43,16 @@ module DTC::Utils
     def edit_file_interactively(filename)
       Exec.sys(@editor, filename)
     end
+    def self.with_temp_file base_name, extension, content, &block # :yields: temp_filename
+      file = Tempfile.new([base_name, extension])
+      begin
+        file << content
+        file.close
+        yield file.path
+      ensure
+        file.unlink
+      end
+    end
     def edit_interactively(content)
       unless @file
         @file = Tempfile.new(["#{File.basename(__FILE__, File.extname(__FILE__))}-edit", @extension])

data/lib/dtc/utils/meta.rb

@@ -0,0 +1,47 @@
+
+module DTC
+  module Utils
+    module Meta
+      # Undefines all methods except those
+      # provided as arguments, or if empty,
+      # `class`.
+      #
+      # To undefine even class, specify as
+      # argument: `:no_really_i_dont_even_want_class`
+      def blank_class *exceptions
+        exceptions = exceptions.flatten.map(&:to_sym)
+        exceptions = [:class] if exceptions.empty? && exceptions != [:no_really_i_dont_even_want_class]
+        instance_methods.each { |meth| undef_method(meth) unless meth =~ /\A__/ || meth == :object_id || exceptions.index(meth.to_sym) }
+      end
+      # Replaces provided instance methods,
+      # specified by name or regexp, with
+      # a call that provides the original
+      # method as an argument.
+      #
+      # To define a pass-through method, use:
+      #     class Test
+      #       extend DTC::Utils::Meta
+      #       def test
+      #       end
+      #       advise :test do |original, *args, &blk|
+      #         original.call(*args, &blk)
+      #       end
+      #     end
+      def advise *method_names, &block
+        method_names = method_names.map { |e| e.is_a?(Regexp) ? instance_methods.select { |m| m =~ e } : e }
+        method_names.flatten.each { |e| advise_method(e.to_sym, &block) }
+      end
+      protected
+      def advise_method method_name, &block
+        method_name = method_name.to_sym
+        method = self.instance_method(method_name)
+        define_method(method_name) do |*a, &b|
+          original = lambda { |*args, &sub|
+            method.bind(self).call(*args, &sub)
+          }
+          block.call(original, *a, &b)
+        end
+      end
+    end
+  end
+end

data/lib/dtc/utils/text/html.rb

@@ -0,0 +1,107 @@
+require 'cgi'
+
+module DTC
+  module Utils
+    module Text
+      module HTML
+        class Writer < DTC::Utils::Text::LineWriter
+          def enter sym, *args
+            attrs = args.last.is_a?(Hash) ? args.pop : {}
+            no_indent = attrs && attrs.delete(:no_indent) {
+              ! NOINDENT_TAGS.index(sym.to_s.downcase).nil?
+            }
+            push DTC::Utils::Text::HTML::tag(sym, :open, attrs)
+            (@stack ||= []) << sym.to_s.split(".").first
+            push_indent("  " + (current_indent || []).join(""))
+            if no_indent
+              unindented *args
+            else
+              text *args
+            end
+            true
+          end
+          def leave
+            pop_indent
+            push(DTC::Utils::Text::HTML::tag(@stack.pop.to_sym, :close))
+          end
+          def add sym, *args
+            if self.respond_to?(sym)
+              self.__send__(sym, *args)
+            else
+              attrs = args.last.is_a?(Hash) ? args.pop : {}
+              if attrs && attrs.delete(:no_indent) {
+                  ! NOINDENT_TAGS.index(sym.to_s.downcase).nil?
+                }
+                push(DTC::Utils::Text::HTML::tag(sym, :open, attrs))
+                unindented *args
+                push(DTC::Utils::Text::HTML::tag(sym, :close, attrs))
+              else
+                push(DTC::Utils::Text::HTML::tag(sym, args, attrs))
+              end
+            end
+          end
+          def text *str
+            push(*str.flatten.map { |s| CGI::escapeHTML(s) })
+          end
+          def unindented *str
+            push_indent("") { text *str }
+          end
+        end
+        def self.attributes attrs = {}
+          unless attrs.nil? || attrs.empty?
+            " " + (
+              attrs.map do |k, v|
+                key = (
+                  ATTRIBUTE_ALIASES[k] ||
+                  ATTRIBUTE_ALIASES[k.to_s] ||
+                  k
+                ).to_s
+                if v == true
+                  CGI::escapeHTML(key)
+                elsif !v
+                  nil
+                else
+                  "#{CGI::escapeHTML(key)}='#{CGI::escapeHTML(v.is_a?(Array) ? v.join(" ") : v.to_s)}'"
+                end
+              end).select {|e| e} .join(" ")
+          else
+            ""
+          end
+        end
+        ATTRIBUTE_ALIASES = ({})
+        SHORTFORM_TAGS = %w[area base basefont br col frame hr img input link meta param]
+        NOINDENT_TAGS = %w[pre textarea]
+        def self.tag sym, content = :open_close, attrs = {}
+          tag = sym.to_s.split(".")
+          nature = :open_close
+          content = content.join("") if content.is_a?(Array)
+          if content.is_a?(Symbol)
+            nature = content unless content == :full
+          elsif !content.nil? && content.strip != ""
+            nature = :full
+          else
+            nature = SHORTFORM_TAGS.index(tag.first.downcase) ? :short : :open_close
+          end
+          tag_header = tag_name = tag.first.to_s
+          unless (nature = nature.to_sym) == :close
+            if tag.count > 1
+              attrs ||= {}
+              classes = attrs[:class] || []
+              classes = classes.split(/\s+/) if classes.is_a?(String)
+              classes += tag.drop(1).to_a
+              attrs[:class] = classes.uniq
+            end
+            tag_header += attributes(attrs) unless nature == :close
+          end
+          natures = ({:open => %w[< >], :close => ['</', '>'], :short => ['<', ' />'], :open_close => ['<', "></#{tag_name}>"]})
+          if nature == :full
+            natures[:open].join(tag_header) + content + natures[:close].join(tag_name)
+          else
+            raise RuntimeError, "Unknown tag nature #{nature.inspect}, should be one of #{natures.keys.to_a.inspect}" unless natures[nature]
+            natures[nature].join(tag_header)
+          end
+        end
+      end
+    end
+  end
+end