fled 0.0.1

data/lib/fled/file_listing.rb

@@ -0,0 +1,260 @@
+module FlEd
+  class FileListing
+    def initialize
+      @objects_by_id = {}
+      @objects = []
+    end
+    RELATION_KEYS = [:parent]
+    def dup
+      result = self.class.new
+      each do |object|
+        result.add object[:uid], object.dup
+      end
+      result.each do |object|
+        RELATION_KEYS.each do |relation|
+          next unless foreign = object[relation]
+          unless foreign[:uid]
+            raise RuntimeError, "Cannot duplicate anonymous object and maintain #{relation.inspect} referential"
+          end
+          unless (object[relation] = result[foreign[:uid]])
+            raise RuntimeError, "Cannot duplicate object in #{relation.inspect} referential, no duplicate found in target (?!)"
+          end
+        end
+      end
+      result
+    end
+    def each &block ; @objects.each(&block) ; end
+    def count ; @objects.count ; end
+    def add uid, object = {}
+      if uid
+        uid = uid.to_s
+        raise RuntimeError, "UID #{uid.inspect} already declared" if @objects_by_id[uid]
+        @objects_by_id[uid] = object
+        object[:uid] = uid
+      end
+      @objects << object
+      object
+    end
+    def [](uid)
+      if uid.is_a?(String)
+        @objects_by_id[uid]
+      else
+        @objects[uid]
+      end
+    end
+  end
+  class FileListing # to and from text format
+    def to_s
+      return "" if @objects.empty?
+      max_width = @objects.map { |o| o[:line] }.map(&:length).max + 10
+      @objects.map { |e| "#{e[:line].ljust(max_width)}:#{e[:uid]}" }.join("\n")
+    end
+    def self.parse listing
+      objects = self.new
+      previous_indent = nil
+      previous = nil
+      stack = []
+      listing.split("\n").each do |line|
+        next if line.strip.empty?
+        raise RuntimeError, "Unparsable line #{line.inspect}" unless line =~ /^((?: )*)(.*?)(?::(\d+))?\r?$/
+        indent = $1
+        name = $2.strip
+        if (dir = name[-1..-1] == "/")
+          name = name[0..-2]
+        end
+        current = objects.add($3, :name => name, :line => "#{$1}#{$2}")
+        current[:dir] = true if dir
+        next if name.strip == "" # Ignore indent when there is no name - element will be deleted, parent isnt used
+        if previous_indent && previous_indent != indent
+          if previous_indent.length < indent.length
+            stack.push(previous)
+          else
+            stack.pop
+          end
+        end
+        current[:parent] = stack.last if stack.count > 0
+        previous = current
+        previous_indent = indent
+      end
+      objects
+    end
+  end
+  class FileListing # Shell operation list builder
+    def operations_from! source_listing
+      errors = []
+      operations = []
+      pending_renames = []
+      running_source = source_listing.dup
+      self.breadth_first do |target, path|
+        next if path.any? { |o| o[:error] }
+        if target[:name] != "" && !target[:uid]
+          operations << [:mk, self.path_of(target).map { |o| o[:name] }]
+          fake_source = {:name => target[:name]}
+          fake_source[:parent] = running_source[path.last[:source][:uid]] unless path.empty?
+          target_uid = "new_#{running_source.count}"
+          target_uid += "_" while @objects_by_id[target_uid] || running_source[target_uid]
+          target[:uid] = target_uid
+          @objects_by_id[target_uid] = target
+          target[:source] = running_source.add(target_uid, fake_source)
+        else
+          source = running_source[target[:uid]]
+          if !(target[:source] = source)
+            target[:error] = true
+            errors += [[:fail, :no_such_uid, target]]
+            next
+          end
+          next if target[:name] == ""
+          if (target[:parent] || {})[:uid] != (source[:parent] ||{})[:uid]
+            existing_names = running_source.children_of((target[:parent] || {})[:uid]).map { |o| o[:name] }
+            new_name = target[:name]
+            new_name += ".tmp" while existing_names.any? { |n| n.casecmp(new_name) == 0 }
+            if new_name != target[:name]
+              pending_renames << [:renamed, target, target[:name]]
+            end
+            source_path = running_source.path_of(source).map { |o| o[:name] }
+            target[:name] = source[:name] = new_name
+            operations << [:moved,
+              source_path,
+              self.path_of(target).map { |o| o[:name] }
+            ]
+            if target[:parent]
+              source[:parent] = running_source[target[:parent][:uid]]
+            else
+              source.delete(:parent)
+            end
+          elsif target[:name] != source[:name]
+            source_path = running_source.path_of(source).map { |o| o[:name] }
+            existing_names = running_source.children_of((target[:parent] || {})[:uid]).map { |o| o[:name] }
+            new_name = target[:name]
+            new_name += ".tmp" while existing_names.any? { |n| n.casecmp(new_name) == 0 }
+            if new_name != target[:name]
+              pending_renames << [:renamed, target, target[:name]]
+            end
+            target[:name] = source[:name] = new_name
+            operations << [:renamed,
+              source_path,
+              target[:name]
+            ]
+          end
+        end
+      end
+      pending_renames.each do |op|
+        target = op[1]
+        new_name = op[2]
+        existing_names = running_source.children_of((target[:parent] || {})[:uid]).map { |o| o[:name] }
+        if existing_names.any? { |n| n.casecmp(new_name) == 0 }
+          errors += [[:warn, :would_overwrite, target, new_name]]
+        else
+          operations << [:renamed,
+            running_source.path_of(target).map { |o| o[:name] },
+            new_name
+          ]
+          target[:name] = target[:source][:name] = new_name
+        end
+      end
+      self.depth_first do |target, path|
+        if target[:name] == ""
+          operations << [:rm, running_source.path_of(target[:source]).map { |o| o[:name] }, target[:source]]
+        end
+      end
+      errors + operations
+    end
+    def has_child? parent, child
+      while child = child[:parent]
+        return true if child[:uid] == parent[:uid]
+      end
+      false
+    end
+    def path_name_of object
+      File.join(path_of(object).map { |o| o[:name] })
+    end
+    def path_of object
+      res = []
+      while object
+        res.unshift object
+        object = object[:parent]
+      end
+      res
+    end
+    def children_of parent, &blk
+      unless !parent || parent.is_a?(Hash)
+        parent_object = self[parent]
+        raise RuntimeError, "No parent #{parent.inspect} found" unless parent_object
+        parent = parent_object
+      end
+      @objects.
+      select { |e| (e[:parent].nil? && parent.nil?) || (e[:parent] == parent)  }.
+      sort { |a, b| a[:name] <=> b[:name] }.
+      each(&blk)
+    end
+    def depth_first parent = nil, path = [], &block
+      children_of parent do |child|
+        depth_first(child, path + [child], &block)
+        yield child, path
+      end
+    end
+    def breadth_first parent = nil, path = [], &block
+      to_browse = []
+      children_of parent do |child|
+        yield child, path
+        to_browse += [child]
+      end
+      to_browse.each { |child| breadth_first child, path + [child], &block }
+    end
+  end
+  class ListingBuilder < DTC::Utils::FileVisitor
+    attr_accessor :listing
+    def initialize listing = FileListing.new
+      @listing = listing
+    end
+    def add_object path, dir
+      uid = next_uid
+      name = File.basename(path)
+      object = @listing.add(uid,
+        :path => path,
+        :name => File.basename(path),
+        :parent => @object_stack.last,
+        :line => "#{"  " * self.depth}#{name}#{dir ? "/" : ""}"
+      )
+      object[:dir] = true if dir
+      object
+    end
+    def enter_folder dir
+      depth = self.depth
+      if self.depth == 0
+        @object_stack = []
+      else
+        @object_stack.push add_object(dir, true)
+      end
+      super
+    end
+    def visit_file name, full_path
+      add_object full_path, false
+      super
+    end
+    def leave_folder
+      @object_stack.pop
+      super
+    end
+    protected
+    def next_uid
+      @listing.count
+    end
+    def source_path source
+      res = []
+      while source
+        res.unshift target[:name]
+        target = target[:parent]
+      end
+      File.join(res)
+    end
+    def target_path target
+      res = []
+      while target
+        res.unshift target[:name]
+        target = target[:parent]
+      end
+      File.join(res)
+    end
+  end
+end

data/lib/fled.rb

@@ -0,0 +1,38 @@
+require 'dtc/utils'
+require 'shellwords'
+
+module FlEd
+  require 'fled/file_listing'
+
+  VERSION = '0.0.1'
+
+  def self.operation_list_to_bash ops
+    ops = ops.map do |op|
+      case op.first
+      when :mk
+        [:mkdir, File.join(op[1])]
+      when :moved
+        [:mv, File.join(op[1]), File.join(op[2])]
+      when :renamed
+        [:mv, File.join(op[1]), File.join((op[1].empty? ? [] : op[1][0..-2]) + [op[2]])]
+      when :rm
+        [op[2][:dir] ? :rmdir : :rm , File.join(op[1])]
+      else
+        op
+      end
+    end
+    warnings, operations = *ops.partition { |e| e.first == :warn }
+    result = []
+    unless warnings.empty?
+      result = ["# Warning:"]
+      warnings.each do |warning|
+        result += ["#  - #{warning[1]}: #{File.join(warning[2][:source][:path], warning[3])}"]
+      end
+      result += ['', 'exit 1 # There are warnings to check first !', '']
+    end
+    result += operations.map do |op|
+      "#{Shellwords.join(op.map(&:to_s))}"
+    end
+    result
+  end
+end

data/tests/helper.rb

@@ -0,0 +1,90 @@
+#!/usr/bin/env ruby
+$:.unshift File.join(File.dirname(__FILE__),'../lib')
+require 'fled'
+
+class PrintingFileVisitor < DTC::Utils::FileVisitor
+  def enter_folder dir
+    depth = self.depth
+    puts ("  " * depth) + (depth > 0 ? File.basename(dir) : dir)
+    super
+  end
+  def visit_file name, full_path
+    puts ("  " * depth) + name
+    super
+  end
+end
+
+class TestListingBuilder < FlEd::ListingBuilder
+  def next_uid
+    @uid
+  end
+  def enter_folder dir, uid = nil
+    @uid = uid
+    super dir
+  end
+  def visit_file name, uid
+    @uid = uid
+    super name, current_path(name)
+  end
+end
+
+class TestFS
+  def initialize &block
+    @root = DTC::Utils::DSLDSL::DSLHashWriter.write_static_tree_dsl(&block)
+  end
+  def receive visitor, root = @root
+    root.each_pair do |name, val|
+      next if name == :options
+      if val.is_a?(Array)
+        visitor.visit_file name, val[0]
+      elsif val.is_a?(Hash)
+        if visitor.enter_folder(name, val[:options][0])
+          receive(visitor, val)
+          visitor.leave_folder
+        end
+      else
+        raise RuntimeError, "Unknown value #{val.inspect}"
+      end
+    end
+  end
+  def new_builder
+    builder = TestListingBuilder.new
+    builder.enter_folder("$")
+    receive builder
+    builder.leave_folder
+    builder
+  end
+  def new_listing
+    new_builder.listing
+  end
+  def operation_list_if_edited_as edited_text
+    listing = new_listing
+    parsed = FlEd::FileListing.parse(edited_text)
+    parsed.operations_from!(listing)
+  end
+  def operations_if_edited_as edited_text
+    operation_list_if_edited_as(edited_text).map do |op|
+      case op.first
+      when :mk
+        [:mkdir, File.join(op[1])]
+      when :moved
+        [:mv, File.join(op[1]), File.join(op[2])]
+      when :renamed
+        [:mv, File.join(op[1]), File.join((op[1].empty? ? [] : op[1][0..-2]) + [op[2]])]
+      when :rm
+        [op[2][:dir] ? :rmdir : :rm , File.join(op[1])]
+      else
+        op
+      end
+    end
+  end
+  def commands_if_edited_as edited_text
+    FlEd::operation_list_to_bash(operation_list_if_edited_as(edited_text))
+  end
+end
+
+if __FILE__==$0
+  Dir[File.join(File.dirname(__FILE__),'./test_*.rb')].each do |test_file|
+    require test_file
+  end
+end

data/tests/readme.rb

@@ -0,0 +1,256 @@
+if Kernel.respond_to?(:require_relative)
+  require_relative "helper"
+else
+  require File.join(File.dirname(__FILE__), 'helper')
+end
+
+class MarkdownDumbWriter
+  def initialize
+    @result = []
+  end
+  def ensure_clear exception = nil
+    unless @result.last == ""
+      @result << ""
+    else
+      if exception && @result.length > 1 &&
+         (@result[-2] || "")[0..exception.length - 1] == exception
+        @result.pop
+      end
+    end
+  end
+  def << str ; @result += str.is_a?(Array) ? str : [str] ; end
+  def nl ; @result += [""] ; end
+  def title str, depth = 2, *args
+    ensure_clear "#"
+    self << "#{"#" * depth} #{str}"
+    nl
+    args.each { |a| text a }
+  end
+  def h1 str, *a ; title str, 1, *a ; end
+  def h2 str, *a ; title str, 2, *a ; end
+  def h3 str, *a ; title str, 3, *a ; end
+  def code str, indent = "    "
+    ensure_clear
+    self << reindent(str, indent)
+    nl
+  end
+  def reindent str, indent = ""
+    lines = str.split(/\r?\n/).map
+    lines.shift if lines.first.empty?
+    min_spaces = lines.map { |l| l =~ /^( +)/ ? $1.length : nil }.select{ |e| e }.min || 0
+    lines.map { |l| indent + ((min_spaces == 0 ? l : l[min_spaces..-1]) || "") }
+  end
+  def text str ; self << reindent(str, "") ; end
+  def em str ; text "*#{str}*" ; end
+  def li str ;
+    ensure_clear "-"
+    self << reindent(str, "- ")
+    nl
+  end
+  def show_example fs, example
+    code example
+    ops = fs.commands_if_edited_as(example)
+    text "Generates:"
+    if ops.empty?
+      em "No operation"
+    else
+      code ops.join("\n")
+    end
+  end
+  def result ; @result.join("\n") ; end
+end
+
+class ExampleDSLWriter < DTC::Utils::DSLDSL::DSLArrayWriter
+  def self.run &blk
+    visitor = self.new()
+    visitor.visit_dsl(&blk)
+    writer = MarkdownDumbWriter.new
+    visitor.each do |method, *args|
+      writer.__send__(method, *args)
+    end
+    writer.result
+  end
+end
+
+readme = ExampleDSLWriter.run do
+  h1 "FlEd", '`fled` lets you organise your files and folders in your favourite editor'
+
+  h2 "Disclaimer", <<-MD
+      Warning: This is a very dangerous tool. The author recommends you do not
+        use it. The author cannot be held responsible in any case.
+  MD
+
+  h2 "Introduction", <<-MD
+  `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.**
+  
+  MD
+
+  h3 "Philosophy", <<-MD
+    `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...
+  MD
+
+  h3 "Caveats", <<-MD
+    `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`.
+  MD
+
+  h3 "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/'"],
+  ].each do |t, c|
+      text t
+      code c
+  end
+
+  h2 "Listing Format"
+
+  fs = TestFS.new do
+    folder(0) {
+      file_one(1)
+      folder_two(2) {
+        file_three(3)
+      }
+    }
+  end
+
+  code fs.new_listing.to_s
+
+  text <<-MD
+    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.
+  MD
+
+  h2 "Operations"
+
+  h3 "Creating a new folder", 'Add a new line (therefore with no uid):'
+  show_example fs, <<-EXAMPLE
+    folder/         :0
+      new_folder
+      folder_two/   :2
+  EXAMPLE
+
+  h3 "Moving"
+  text 'Change the indentation and/or line order to change the parent of a file or folder:'
+  show_example fs, <<-EXAMPLE
+    folder/          :0
+      folder_two/    :2
+        file_one       :1
+        file_three   :3
+  EXAMPLE
+  em 'Moving an item below itself or its children is not recommended, as the listing may not be exhaustive'
+
+  h3 "Renaming"
+  text 'Edit the name while preserving the uid to rename the item'
+  show_example fs, <<-EXAMPLE
+    folder_renamed/  :0
+      file_one       :1
+      folder_two/    :2
+        file_changed :3
+  EXAMPLE
+  text '*Swapping file names may not work in cases where the generated intermediary file exists but was not included in the listing*'
+
+  h3 "Deleting", 'Clear a name but leave the uid to delete that item'
+  show_example fs, <<-EXAMPLE
+    folder_renamed/  :0
+      :1
+      :2
+      :3
+  EXAMPLE
+
+  h3 "No-op"
+  text 'If a line (and all child-lines) is removed from the listing, it will have no operation.'
+  show_example fs, <<-EXAMPLE
+    folder/          :0
+  EXAMPLE
+  nl
+  nl
+  text '*Note that removing a folder without removing its children will move its children:*'
+
+  show_example fs, <<-EXAMPLE
+    folder/          :0
+      file_one       :1
+      file_three   :3
+  EXAMPLE
+
+  nl
+  text "If an indent is forgotten:"
+
+  show_example fs, <<-EXAMPLE
+    folder/          :0
+      file_one       :1
+        file_three   :3
+  EXAMPLE
+
+  h3 "All together"
+  show_example fs, <<-EXAMPLE
+    folder_new/          :0
+      new_folder/
+        first    :1
+        second   :3
+      :2
+  EXAMPLE
+
+  h2 "Edge cases", "These sort-of work, but are still rather experimental"
+
+  h3 "Swapping files"
+
+  fs = TestFS.new do
+    folder(0) {
+      file_one(1)
+      file_two(2)
+    }
+  end
+  code fs.new_listing.to_s
+  text "When applying"
+  show_example fs, <<-EXAMPLE
+    folder/        :0
+      file_two   :1
+      file_one   :2
+  EXAMPLE
+
+  h3 "Tree swapping"
+  fs = TestFS.new do
+    folder(0) {
+      sub_folder(1) {
+        sub_sub_folder(2) {
+          file.txt(3)
+        }
+      }
+    }
+  end
+  code fs.new_listing.to_s
+  text "When applying"
+  show_example fs, <<-EXAMPLE
+    sub_sub_folder/  :2
+      sub_folder/        :1
+        folder/              :0
+          file.txt       :3
+  EXAMPLE
+
+  h2 "Contributors"
+  li "[Eric Doughty-Papassideris](http://github.com/ddlsmurf)"
+end
+puts readme