fled 0.0.2 → 0.0.3

data/lib/fled/file_listing.rb

@@ -1,9 +1,13 @@
 module FlEd
+  # In memory tree structure for storing
+  # a file-system
   class FileListing
     def initialize
       @objects_by_id = {}
       @objects = []
+      @errors = []
     end
+    attr_accessor :errors
     RELATION_KEYS = [:parent]
     def dup
       result = self.class.new
@@ -54,7 +58,7 @@ module FlEd
       previous_indent = nil
       previous = nil
       stack = []
-      listing.split("\n").each do |line|
+      listing.split("\n").each_with_index do |line, line_number|
         next if line.strip.empty?
         raise RuntimeError, "Unparsable line #{line.inspect}" unless line =~ /^((?: )*)(.*?)(?::(\d+))?\r?$/
         indent = $1
@@ -62,7 +66,15 @@ module FlEd
         if (dir = name[-1..-1] == "/")
           name = name[0..-2]
         end
-        current = objects.add($3, :name => name, :line => "#{$1}#{$2}")
+        current = nil
+        begin
+          current = objects.add($3, :name => name, :line => "#{$1}#{$2}")
+        rescue Exception => e
+          (objects.errors ||= []) << [:fail,
+            :duplicate_uid, {:name => name, :line_number => line_number + 1}
+          ]
+        end
+        next unless current
         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
@@ -72,6 +84,7 @@ module FlEd
             stack.pop
           end
         end
+        current[:line_number] = line_number + 1
         current[:parent] = stack.last if stack.count > 0
         previous = current
         previous_indent = indent
@@ -80,8 +93,21 @@ module FlEd
     end
   end
   class FileListing # Shell operation list builder
+    # Generate a list of operations that
+    # would transform the `source_listing`
+    # into the receiver.
+    #
+    # Result is an array with each entry of
+    # the format:
+    #
+    # - `[:fail, reason_symbol, target]`
+    # - `[:warn, reason_symbol, target]`
+    # - `[:mk, [path components]]`
+    # - `[:moved, [source path components], [dest path components]]`
+    # - `[:renamed, [source path components], new name]`
+    # - `[:rm, [path components], source_object]`
     def operations_from! source_listing
-      errors = []
+      op_errors = []
       operations = []
       pending_renames = []
       running_source = source_listing.dup
@@ -100,7 +126,7 @@ module FlEd
           source = running_source[target[:uid]]
           if !(target[:source] = source)
             target[:error] = true
-            errors += [[:fail, :no_such_uid, target]]
+            op_errors += [[:fail, :no_such_uid, target]]
             next
           end
           next if target[:name] == ""
@@ -148,7 +174,8 @@ module FlEd
         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]]
+          op_errors += [[:warn, :would_overwrite, target,
+            running_source.path_of(target[:parent]).map { |o| o[:name] } + [new_name]]]
         else
           operations << [:renamed,
             running_source.path_of(target).map { |o| o[:name] },
@@ -159,10 +186,11 @@ module FlEd
       end
       self.depth_first do |target, path|
         if target[:name] == ""
-          operations << [:rm, running_source.path_of(target[:source]).map { |o| o[:name] }, target[:source]]
+          operation = target[:source][:dir] ? :rmdir : :rm
+          operations << [operation, running_source.path_of(target[:source]).map { |o| o[:name] }, target[:source]]
         end
       end
-      errors + operations
+      errors + op_errors + operations
     end
     def has_child? parent, child
       while child = child[:parent]
@@ -207,59 +235,4 @@ module FlEd
       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/file_listing_builder.rb

@@ -0,0 +1,43 @@
+module FlEd
+  class FileListingBuilder
+    attr_accessor :listing
+    def initialize listing = FileListing.new
+      @listing = listing
+      @folders = []
+    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 => "#{"  " * depth}#{name}#{dir ? "/" : ""}"
+      )
+      object[:dir] = true if dir
+      object
+    end
+    def depth ; @folders.count ; end
+    def full_path *args ; File.join((@folders || []) + args) ; end
+    def enter dir
+      if depth.zero?
+        @object_stack = []
+      else
+        @object_stack.push add_object(dir, true)
+      end
+      @folders << dir
+      true
+    end
+    def add name, full_path
+      add_object full_path, false
+    end
+    def leave
+      @object_stack.pop
+      @folders.pop
+    end
+    protected
+    def next_uid
+      @listing.count
+    end
+  end
+end

data/lib/fled.rb

@@ -3,9 +3,12 @@ require 'shellwords'
 
 module FlEd
   require 'fled/file_listing'
+  require 'fled/file_listing_builder'
 
-  VERSION = '0.0.2'
+  VERSION = '0.0.3'
 
+  # Convert file listing operation list
+  # to bash-script friendly script
   def self.operation_list_to_bash ops
     ops = ops.map do |op|
       case op.first
@@ -15,18 +18,28 @@ module FlEd
         [: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])]
+      when :rm, :rmdir
+        [op.first , File.join(op[1])]
       else
         op
       end
     end
     warnings, operations = *ops.partition { |e| e.first == :warn }
+    errors, operations = *operations.partition { |e| e.first == :fail }
     result = []
+    unless errors.empty?
+      result += ["# Error:"]
+      errors.each do |error|
+        line = error[2][:line_number]
+        result += ["#  - line #{line}: #{error[1]}"]
+      end
+      result += ['', 'exit 1 # There are errors to check first !', '']
+    end
     unless warnings.empty?
-      result = ["# Warning:"]
+      result += ["# Warning:"]
       warnings.each do |warning|
-        result += ["#  - #{warning[1]}: #{File.join(warning[2][:source][:path], warning[3])}"]
+        line = warning[2][:line_number]
+        result += ["#  - line #{line}: #{warning[1]}: #{File.join(warning[3])}"]
       end
       result += ['', 'exit 1 # There are warnings to check first !', '']
     end

data/tests/helper.rb

@@ -2,45 +2,33 @@
 $:.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
+class TestListingBuilder < FlEd::FileListingBuilder
   def next_uid
     @uid
   end
-  def enter_folder dir, uid = nil
+  def enter dir, uid = nil
     @uid = uid
-    super dir
+    super dir.to_s
   end
-  def visit_file name, uid
+  def add name, uid
     @uid = uid
-    super name, current_path(name)
+    super name, full_path(name.to_s)
   end
 end
 
 class TestFS
   def initialize &block
-    @root = DTC::Utils::DSLDSL::DSLHashWriter.write_static_tree_dsl(&block)
+    @root = DTC::Utils::Visitor::DSL::accept(DTC::Utils::Visitor::HashBuilder, &block).root
   end
   def receive visitor, root = @root
     root.each_pair do |name, val|
-      next if name == :options
+      next if name.nil?
       if val.is_a?(Array)
-        visitor.visit_file name, val[0]
+        visitor.add name, val[0]
       elsif val.is_a?(Hash)
-        if visitor.enter_folder(name, val[:options][0])
+        if visitor.enter(name, val[nil][0])
           receive(visitor, val)
-          visitor.leave_folder
+          visitor.leave
         end
       else
         raise RuntimeError, "Unknown value #{val.inspect}"
@@ -49,9 +37,9 @@ class TestFS
   end
   def new_builder
     builder = TestListingBuilder.new
-    builder.enter_folder("$")
+    builder.enter("$")
     receive builder
-    builder.leave_folder
+    builder.leave
     builder
   end
   def new_listing
@@ -71,8 +59,8 @@ class TestFS
         [: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])]
+      when :rm, :rmdir
+        [op.first, File.join(op[1])]
       else
         op
       end

data/tests/readme.rb

@@ -4,75 +4,124 @@ else
   require File.join(File.dirname(__FILE__), 'helper')
 end
 
-class MarkdownDumbWriter
-  def initialize
-    @result = []
+class MarkdownDumbLineWriter < DTC::Utils::Text::LineWriter
+  def nl ; push_raw "" ; end
+  def text *str
+    push DTC::Utils::Text.lines_without_indent(split_lines(*str))
   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
+  def para *str
+    enter_mode nil
+    text *str
   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 }
+    enter_mode :title
+    push_raw "#{"#" * depth} #{str}"
+    para *args unless args.empty?
   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]) || "") }
+  # h1-5
+  5.times do |i|
+    define_method "h#{i + 1}".to_sym do |str, *a|
+      title str, i + 1, *a
+    end
   end
-  def text str ; self << reindent(str, "") ; end
-  def em str ; text "*#{str}*" ; end
-  def li str ;
-    ensure_clear "-"
-    self << reindent(str, "- ")
-    nl
+  def html *str ;
+    enter_mode :html
+    push_raw *str
   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")
+  def strong str ; para "**#{str}**" ; end
+  def em str ; para "*#{str}*" ; end
+  ({
+    :li => "- ",
+    :pre => "    ",
+    :quote => "> ",
+  }).each_pair do |method, indentation|
+    define_method method do |*str, &blk|
+      enter_mode method
+      push_indent(indentation) {
+        push_unindented_and_yield str, &blk
+      }
     end
   end
-  def result ; @result.join("\n") ; end
+  protected
+  def enter_mode mode
+    nl if lines.last != "" && @mode != mode
+    @mode = mode
+  end
+  def split_lines *lines
+    result = lines.flatten.map { |l| DTC::Utils::Text::lines(l) }.flatten
+    result.shift while result.first == ""
+    result.pop while (result.last || "").strip == ""
+    result
+  end
+  def push_unindented_and_yield lines
+    push(DTC::Utils::Text.lines_without_indent(split_lines(lines))) if lines
+    yield if block_given?
+  end
+end
+
+class MarkdownDumbLineWriter
+  include DTC::Utils::Visitor::AcceptAsFlatMethodCalls
 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)
+class MarkdownAndHTMLVisitor < DTC::Utils::Visitor::Switcher
+  def initialize
+    @writer = MarkdownDumbLineWriter.new
+    super @writer
+  end
+  def to_s
+    @writer.to_s
+  end
+  protected
+  def visitor_for_subtree sym, *args
+    if @visitor_stack.count == 1 && sym == :html
+      DTC::Utils::Text::HTML::Writer.new
+    else
+      nil
     end
-    writer.result
+  end
+  def visitor_left_subtree visitor, *args
+    add :html, visitor.to_s
   end
 end
 
-readme = ExampleDSLWriter.run do
+def readme &blk
+  puts DTC::Utils::Visitor::DSL::accept(MarkdownAndHTMLVisitor, &blk).to_s
+end
+
+readme do
+  def show_example listing, example, operations
+    html {
+      table {
+        tr {
+          th { em "Original listing" }
+          th { em "Edited listing" }
+        }
+        tr {
+          td { pre listing }
+          td { pre(DTC::Utils::Text.lines_without_indent example) }
+        }
+        tr {
+          th(:colspan => 2) { em "Generates the script:" }
+        }
+        tr {
+          td(:colspan => 2) {
+            if operations.empty?
+              em "No operation"
+            else
+              ul {
+                operations.each { |op| li { code op } }
+              }
+            end
+          }
+        }
+      }
+    }
+  end
+  def run_example fs, example
+    ops = fs.commands_if_edited_as(example)
+    show_example fs.new_listing.to_s, example, ops
+  end
+
   h1 "FlEd", '`fled` lets you organise your files and folders in your favourite editor'
 
   h2 "Introduction", <<-MD
@@ -118,8 +167,8 @@ readme = ExampleDSLWriter.run do
     ["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
+      para t
+      pre c
   end
 
   h2 "Listing Format"
@@ -133,29 +182,30 @@ readme = ExampleDSLWriter.run do
     }
   end
 
-  code fs.new_listing.to_s
+  pre fs.new_listing.to_s
 
-  text <<-MD
-    Each line of the listing is in the format *`[indentation]`* *`[name]`* `:`*`[uid]`*
+  para <<-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 *name* has a `/` appended if it is a directory.
     - 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.
+      change between runs. It is valid only for the current run. Spaces before the *uid* are only cosmetic.
   MD
 
   h2 "Operations"
 
   h3 "Creating a new folder", 'Add a new line (therefore with no uid):'
-  show_example fs, <<-EXAMPLE
+  run_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
+  para 'Change the indentation and/or line order to change the parent of a file or folder:'
+  run_example fs, <<-EXAMPLE
     folder/          :0
       folder_two/    :2
         file_one       :1
@@ -164,17 +214,16 @@ readme = ExampleDSLWriter.run do
   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
+  para 'Edit the name while preserving the uid to rename the item'
+  run_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
+  run_example fs, <<-EXAMPLE
     folder_renamed/  :0
       :1
       :2
@@ -182,31 +231,29 @@ readme = ExampleDSLWriter.run do
   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
+  para 'If a line (and all child-lines) is removed from the listing, it will have no operation.'
+  run_example fs, <<-EXAMPLE
     folder/          :0
   EXAMPLE
-  nl
-  nl
-  text '*Note that removing a folder without removing its children will move its children:*'
+  para '*Note that removing a folder without removing its children will move its children:*'
 
-  show_example fs, <<-EXAMPLE
+  run_example fs, <<-EXAMPLE
     folder/          :0
       file_one       :1
       file_three   :3
   EXAMPLE
 
   nl
-  text "If an indent is forgotten:"
+  para "If an indent is forgotten:"
 
-  show_example fs, <<-EXAMPLE
+  run_example fs, <<-EXAMPLE
     folder/          :0
       file_one       :1
         file_three   :3
   EXAMPLE
 
   h3 "All together"
-  show_example fs, <<-EXAMPLE
+  run_example fs, <<-EXAMPLE
     folder_new/          :0
       new_folder/
         first    :1
@@ -224,13 +271,14 @@ readme = ExampleDSLWriter.run do
       file_two(2)
     }
   end
-  code fs.new_listing.to_s
-  text "When applying"
-  show_example fs, <<-EXAMPLE
+  pre fs.new_listing.to_s
+  para "When applying"
+  run_example fs, <<-EXAMPLE
     folder/        :0
       file_two   :1
       file_one   :2
   EXAMPLE
+  para '*Swapping file names may not work in cases where the generated intermediary file exists but was not included in the listing*'
 
   h3 "Tree swapping"
   fs = TestFS.new do
@@ -242,9 +290,9 @@ readme = ExampleDSLWriter.run do
       }
     }
   end
-  code fs.new_listing.to_s
-  text "When applying"
-  show_example fs, <<-EXAMPLE
+  pre fs.new_listing.to_s
+  para "When applying"
+  run_example fs, <<-EXAMPLE
     sub_sub_folder/  :2
       sub_folder/        :1
         folder/              :0
@@ -260,9 +308,16 @@ readme = ExampleDSLWriter.run do
       'Fix: Moving files under files now moves up to parent folder of destination',
       'Meta: Travis-CI integration',
     ],
+    'v0.0.3' => [
+      'New: Interactive mode with `-u`',
+      'New: Error and warning reporting with line numbers',
+      'New: Default configuration file at `~/.fled.yaml`',
+      'New: Editor and diff tool are configurable from configuration files',
+      'Meta: Refactoring of code',
+    ],
   }).sort { |a, b| b[0] <=> a[0] }.each do |version, changes|
     em "Version #{version}"
-    changes.each { |change| li change }
+    li *changes
   end
 
   h2 "Disclaimer", <<-MD
@@ -276,4 +331,3 @@ readme = ExampleDSLWriter.run do
   h2 "Licence", "[GPLv3](http://www.gnu.org/licenses/gpl-3.0.html)"
 
 end
-puts readme