fled 0.0.1

data/README.md

@@ -0,0 +1,230 @@
+
+# FlEd
+
+`fled` lets you organise your files and folders in your favourite editor
+
+## Disclaimer
+
+Warning: This is a very dangerous tool. The author recommends you do not
+  use it. The author cannot be held responsible in any case.
+
+## Introduction
+
+`fled` enumerates a folder and its files, and generates a text listing.
+You can then edit that listing in your favourite editor, and save changes.
+`fled` then reloads those changes, and prints a shell script that would move
+your files and folders around as-per your edits.
+
+**You should review that shell script very carefully before running it.**
+
+### Philosophy
+
+`fled` only generates text, it does not perform any operation directly.
+
+The design optimises for making the edits very simple. The consequence of
+this is that very small edits can have large consequences, which makes
+this a **very dangerous** tool. But so is `rm` and the rest of the shell anyway...
+
+### Caveats
+
+`fled` is only aware of files it scanned. It will not warn for overwrites,
+nor use temporary files in those cases, etc.
+
+`fled`'s editing model is rather complex and fuzzy. While there are some test
+cases defined, any help is much appreciated.
+
+You should be scared when using `fled`.
+
+### Examples
+
+Print help text and option list
+
+    fled --help
+
+Edit current folder
+
+    fled
+
+Edit all files directly in `path` folder
+
+    fled -a path -d 0
+
+Save default options
+
+    fled --options > fled.config.yaml
+
+Edit current folder using options
+
+    fled --load fled.config.yaml
+
+Add options to a command (`mkdir`, `mv`, `rm` or `rmdir`)
+
+    fled | sed 's/^mv/mv -i/'
+
+## Listing Format
+
+    folder/                 :0
+      file_one              :1
+      folder_two/           :2
+        file_three          :3
+
+Each line of the listing is in the format *`[indentation]`* *`[name]`* `:`*`[uid]`*
+
+- The *indentation* must consist of only spaces, and is used to indicate the parent folder
+- The *name* must not use colons (`:`). If it is cleared, it is assumed the file/folder is to be deleted
+- The *uid* is used by FlEd to recognise the original of the edited line. Do not assume a *uid* does not
+  change between runs. It is valid only once.
+
+## Operations
+### Creating a new folder
+
+Add a new line (therefore with no uid):
+
+    folder/         :0
+      new_folder
+      folder_two/   :2
+
+Generates:
+
+    mkdir folder/new_folder
+
+### Moving
+
+Change the indentation and/or line order to change the parent of a file or folder:
+
+    folder/          :0
+      folder_two/    :2
+        file_one       :1
+        file_three   :3
+
+Generates:
+
+    mv folder/file_one folder/folder_two/file_one
+
+*Moving an item below itself or its children is not recommended, as the listing may not be exhaustive*
+
+### Renaming
+
+Edit the name while preserving the uid to rename the item
+
+    folder_renamed/  :0
+      file_one       :1
+      folder_two/    :2
+        file_changed :3
+
+Generates:
+
+    mv folder folder_renamed
+    mv folder_renamed/folder_two/file_three folder_renamed/folder_two/file_changed
+
+*Swapping file names may not work in cases where the generated intermediary file exists but was not included in the listing*
+
+### Deleting
+
+Clear a name but leave the uid to delete that item
+
+    folder_renamed/  :0
+      :1
+      :2
+      :3
+
+Generates:
+
+    mv folder folder_renamed
+    rm folder_renamed/folder_two/file_three
+    rm folder_renamed/file_one
+    rmdir folder_renamed/folder_two
+
+### No-op
+
+If a line (and all child-lines) is removed from the listing, it will have no operation.
+
+    folder/          :0
+
+Generates:
+*No operation*
+
+*Note that removing a folder without removing its children will move its children:*
+
+    folder/          :0
+      file_one       :1
+      file_three   :3
+
+Generates:
+
+    mv folder/folder_two/file_three folder/file_three
+
+
+If an indent is forgotten:
+
+    folder/          :0
+      file_one       :1
+        file_three   :3
+
+Generates:
+
+    mv folder/folder_two/file_three folder/file_one/file_three
+
+### All together
+
+    folder_new/          :0
+      new_folder/
+        first    :1
+        second   :3
+      :2
+
+Generates:
+
+    mv folder folder_new
+    mkdir folder_new/new_folder
+    mv folder_new/file_one folder_new/new_folder/first
+    mv folder_new/folder_two/file_three folder_new/new_folder/second
+    rmdir folder_new/folder_two
+
+## Edge cases
+
+These sort-of work, but are still rather experimental
+
+### Swapping files
+
+    folder/             :0
+      file_one          :1
+      file_two          :2
+
+When applying
+
+    folder/        :0
+      file_two   :1
+      file_one   :2
+
+Generates:
+
+    mv folder/file_two folder/file_one.tmp
+    mv folder/file_one folder/file_two
+    mv folder/file_one.tmp folder/file_one
+
+### Tree swapping
+
+    folder/                      :0
+      sub_folder/                :1
+        sub_sub_folder/          :2
+          file.txt               :3
+
+When applying
+
+    sub_sub_folder/  :2
+      sub_folder/        :1
+        folder/              :0
+          file.txt       :3
+
+Generates:
+
+    mv folder/sub_folder/sub_sub_folder sub_sub_folder
+    mv folder/sub_folder sub_sub_folder/sub_folder
+    mv folder sub_sub_folder/sub_folder/folder
+    mv sub_sub_folder/file.txt sub_sub_folder/sub_folder/folder/file.txt
+
+## Contributors
+
+- [Eric Doughty-Papassideris](http://github.com/ddlsmurf)
+

data/bin/fled

@@ -0,0 +1,152 @@
+#!/usr/bin/env ruby
+require 'yaml'
+require 'optparse'
+require 'shellwords'
+begin
+  require 'fled'
+rescue LoadError => e
+  $:.unshift File.join(File.dirname(__FILE__),'../lib')
+  require 'fled'
+end
+
+class App
+  DEFAULT_SKIP_FOLDERS_RX = ['^\..*', '.*\.app$']
+  DEFAULT_SKIP_FOLDERS = ['.svn', '_svn', '.git', 'CVS', '.hg']
+  DEFAULT_SKIP_FILES_RX = ['^\..*', '.*~$']
+  DEFAULT_SKIP_FILES = [".DS_Store", "Thumbs.db", "Temporary Items"]
+  
+  attr_reader :options
+
+  def initialize(arguments = ARGV)
+    @arguments = arguments.dup
+    @options = {}
+    @options[:verbose] = false
+  end
+
+  def run
+    if parsed_options?
+      if options[:output_options]
+        output_options
+        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]
+    else
+      output_usage
+    end
+  rescue SystemExit => e
+    raise
+  rescue Exception => e
+    puts e
+    output_usage
+    exit 127
+  end
+  protected
+
+    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' },
+      })
+    end
+
+    def parsed_options?
+      options = {}
+      @optionparser = OptionParser.new do |opts|
+        opts.banner = "Usage: #{$0} [options] [base_path]"
+        opts.separator ""
+        opts.separator "Selection"
+
+        opts.on('-i', '--include RX', String, "Only include files and folders that match any such regexp") { |rx| (options[:included] ||= []) << rx }
+        opts.on('--include-dirs RX', String, "Only include folders that match any such regexp") { |rx| (options[:included_directories] ||= []) << rx }
+        opts.on('--include-files RX', String, "Only include files that match any such regexp") { |rx| (options[:included_files] ||= []) << rx }
+        opts.on('-x', '--exclude RX', String, "Exclude files and folders that match any such regexp") { |rx| (options[:excluded] ||= []) << rx }
+        opts.on('--exclude-dirs RX', String, "Exclude folders that match any such regexp") { |rx| (options[:excluded_directories] ||= []) << rx }
+        opts.on('--exclude-files RX', String, "Exclude files that match any such regexp") { |rx| (options[:excluded_files] ||= []) << rx }
+        opts.on('-a', '--no-exclude', "Empties all the lists of exclusions") do
+          options[:excluded] = []
+          options[:excluded_files] = []
+          options[:excluded_directories] = []
+        end
+        opts.on('-r', '--recursive', "Scan directories recursively") { options[:max_depth] ||= -1 }
+        opts.on("-d", "--depth N", Integer, "Set maximum recursion to N subfolders. (0=no recursion)") { |n| options[:max_depth] = n.to_i }
+
+        opts.separator ""
+        opts.separator "Script"
+        opts.on('--no-pushd', "Do not include pushd/popd pair in script")    { options[:no_pushd] = true }
+
+        opts.separator ""
+        opts.separator "General"
+        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('-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 }
+      end
+      @optionparser.parse!(@arguments)
+      @base_path = File.expand_path(@arguments.first || options[:base_path] || ".")
+      raise RuntimeError, "No more than one argument should be present" if @arguments.count > 1
+      @options = self.class.default_options.merge(options)
+      true
+    end
+    
+    def output_options out = $stdout
+      opts = @options.dup
+      opts.delete(:output_options)
+      out.puts 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 ""
+      output_usage
+    end
+    
+    def output_usage
+      $stderr.puts @optionparser
+    end
+
+    def output_version
+      $stderr.puts "#{File.basename(__FILE__)} version #{VERSION}"
+    end
+end
+App.new.run

data/lib/dtc/utils/dsldsl.rb

@@ -0,0 +1,259 @@
+module DTC
+  module Utils
+    module DSLDSL
+      class DSLVisitor
+        # very approximate visitor =)
+        def enter key, *args ;  end
+        def leave ; end
+        def add key, *args ; end
+        def visit_dsl &blk
+          builder = self.class.delegate_klass.new(self)
+          self.class.context_klass.new(builder).__instance_exec(&blk)
+          builder.flush
+        end
+        protected
+        def self.delegate_klass ; StaticTreeDSLDelegate ; end
+        def self.context_klass ; StaticTreeDSLContextBlank ; end
+      end
+
+      class DSLArrayWriter < DSLVisitor
+        attr_reader :stack
+        def initialize
+          @stack = [[]]
+        end
+        def enter sym, *args
+          @stack.push [[sym, *args]]
+        end
+        def leave
+          @stack.pop
+        end
+        def add sym, *args
+          @stack.last << [sym, *args]
+        end
+        def each &blk
+          return enum_for(:each) unless block_given?
+          each_call_of @stack.first, &blk
+        end
+        protected
+        def each_call_of parent, &block
+          parent.each do |item|
+            if item.first.is_a?(Symbol)
+              yield item
+            else
+              each_call_of item, &block
+            end
+          end
+        end
+      end
+
+      class DSLHashWriter < DSLVisitor
+        def initialize target
+          @stack = [target]
+        end
+        def enter key, *args
+          container = add_container(key, *args)
+          @stack.push(container) if container
+          container
+        end
+        def leave
+          @stack.pop
+        end
+        def add key, *args
+          add_key key, args
+        end
+        def self.write_static_tree_dsl target = {}, &blk
+          visitor = self.new(result = target)
+          visitor.visit_dsl(&blk)
+          result
+        end
+        def add_container key, *args
+          container = {}
+          container[:options] = args unless args.empty?
+          add_key key, container
+        end
+        def add_key key, val
+          container = @stack.last
+          key = key.to_s
+          raise RuntimeError, "Key #{key.inspect} already defined" if container[key]
+          container[key] = val
+          val
+        end
+      end
+
+      class StaticTreeDSLDelegate
+        def initialize visitor, prefix = nil
+          @visitor = visitor
+          @prefix = prefix
+          @pending_prefix = nil
+          @called = false
+        end
+        def prefix sym
+          @called = true
+          flush
+          @pending_prefix = self.class.new(@visitor, with_prefix(sym))
+        end
+        def flush
+          if @pending_prefix
+            @pending_prefix.add_unless_called
+            @pending_prefix = nil
+          end
+        end
+        def add sym, *args
+          @called = true
+          @visitor.add(with_prefix(sym), *args)
+        end
+        def enter sym, *args
+          flush
+          @called = true
+          @visitor.enter(with_prefix(sym), *args)
+        end
+        def leave
+          flush
+          @visitor.leave
+        end
+        protected
+        def with_prefix sym
+          @prefix ? (sym ? "#{@prefix}.#{sym}".to_sym : @prefix) : sym
+        end
+        def add_unless_called
+          flush
+          @visitor.add(@prefix) unless @called
+        end
+      end
+
+      class StaticTreeDSLContextBlank
+        alias_method :__instance_exec, :instance_exec
+        alias_method :__class, :class
+        instance_methods.each { |meth| undef_method(meth) unless meth =~ /\A__/ || meth == :object_id }
+        def initialize delegate, unprefixed = delegate
+          @delegate = delegate
+          @unprefixed = unprefixed
+        end
+        def method_missing(meth, *args, &block)
+          if block
+            @delegate.enter meth, *args
+            __class.new(@unprefixed, @unprefixed).__instance_exec(&block)
+            @unprefixed.flush
+            @delegate.leave
+          else
+            if args.empty?
+              return __class.new(@delegate.prefix(meth), @unprefixed)
+            else
+              @delegate.add(meth, *args)
+            end
+          end
+          self
+        end
+      end
+
+      if __FILE__ == $0
+
+        class DebugStaticTreeDSLDelegate < StaticTreeDSLDelegate
+          def prefix sym
+            p [:prefix, sym, @prefix]
+            super
+          end
+          def flush
+            p [:flush, @prefix] if @pending_prefix
+            super
+          end
+          def add sym, *args
+            p [:add, sym, @prefix]
+            super
+          end
+          def enter sym, *args
+            p [:enter, sym, @prefix]
+            super
+          end
+          def leave
+            p [:leave, @prefix]
+            super
+          end
+          def add_unless_called
+            p [:flush_self, @prefix] unless @called
+            super
+          end
+        end
+
+        class DebugDSLHashWriter < DSLHashWriter
+          def enter sym, *args
+            p [:wenter, sym]
+            super
+          end
+          def leave
+            p [:wleave]
+            super
+          end
+          def add sym, *args
+            p [:wadd, sym, args]
+            super
+          end
+          def self.delegate_klass ; DebugStaticTreeDSLDelegate ; end
+        end
+
+        module Examples
+          module Simple
+            result = DSLHashWriter.write_static_tree_dsl do
+              fichier "value"
+              fichier2.txt "one", "two"
+            end
+            result # => {"fichier"=>["value"], "fichier2.txt"=>["one", "two"]}
+
+            result = DSLHashWriter.write_static_tree_dsl do
+              dossier {
+                sous.dossier "valeur" do
+                  file.txt
+                end
+              }
+            end
+            result # => {"dossier"=>{"sous.dossier"=>{:options=>["valeur"], "file.txt"=>[]}}}
+
+            result = DSLHashWriter.write_static_tree_dsl do
+              %w[hdpi mdpi ldpi].each do |resolution|
+                image.__send__(resolution.to_sym).png
+              end
+            end
+            result # => {"image.ldpi.png"=>[], "image.hdpi.png"=>[], "image.mdpi.png"=>[]}
+
+            result = DSLHashWriter.write_static_tree_dsl do
+              user {
+                name :string
+                email :string
+                address(:json) {
+                  line :string
+                  country
+                }
+              }
+            end
+            result # => {"user"=>{"address"=>{"country"=>[], "line"=>[:string], :options=>[:json]}, "name"=>[:string], "email"=>[:string]}}
+
+            result = DSLHashWriter.write_static_tree_dsl do
+              def base_file
+                yes.this.is.base
+              end
+              base_file.txt
+              base_file.png
+            end
+            result # => {"yes.this.is.base.png"=>[], "yes.this.is.base.txt"=>[]}
+          end
+          module CustomBuilder
+            class EscapableStaticTreeDSLContextBlank < StaticTreeDSLContextBlank
+              def method_missing(meth, *args, &block)
+                meth = args.shift if meth == :raw
+                super(meth, *args, &block)
+              end
+            end
+            class EscapableDSLHashWriter < DSLHashWriter
+              def self.context_klass ; EscapableStaticTreeDSLContextBlank ; end
+            end
+            result = EscapableDSLHashWriter.write_static_tree_dsl do
+              3.times { |i| raw(i).png }
+              image.raw("%!") { file }
+            end
+            result # => {"0.png"=>[], "1.png"=>[], "image.%!"=>{"file"=>[]}, "2.png"=>[]}
+          end
+        end
+      end
+    end
+  end
+end