dle 0.1.0

data/lib/dle.rb

@@ -0,0 +1,24 @@
+require "pathname"
+require "yaml"
+require "find"
+require "optparse"
+require "securerandom"
+
+require "pry"
+require "active_support/core_ext/object/blank"
+require "active_support/core_ext/object/try"
+
+require "banana/logger"
+require "dle/version"
+require "dle/helpers"
+require "dle/dl_file"
+require "dle/filesystem/destructive"
+require "dle/filesystem/softnode"
+require "dle/filesystem/node"
+require "dle/filesystem"
+require "dle/application/dispatch"
+require "dle/application"
+
+module Dle
+  ROOT = Pathname.new(File.expand_path("../..", __FILE__))
+end

data/lib/dle/application.rb

@@ -0,0 +1,96 @@
+module Dle
+  # Logger Singleton
+  MAIN_THREAD = ::Thread.main
+  def MAIN_THREAD.app_logger
+    MAIN_THREAD[:app_logger] ||= Banana::Logger.new
+  end
+
+  class Application
+    attr_reader :opts
+    include Dispatch
+
+    # =========
+    # = Setup =
+    # =========
+    def self.dispatch *a
+      new(*a) do |app|
+        app.parse_params
+        app.log "core ready"
+        app.dispatch
+      end
+    end
+
+    def initialize env, argv
+      @env, @argv = env, argv
+      @editor = which_editor
+      @opts = {
+        dispatch: :index,
+        dotfiles: false,
+        check_for_updates: true,
+        review: true,
+        simulate: false,
+      }
+      yield(self)
+    end
+
+    def parse_params
+      @optparse = OptionParser.new do |opts|
+        opts.banner = "Usage: dle [options] base_directory"
+
+        opts.on("-d", "--dotfiles", "Include dotfiles (unix invisible)") { @opts[:dotfiles] = true }
+        opts.on("-r", "--skip-review", "Skip review changes before applying") { @opts[:review] = false }
+        opts.on("-s", "--simulate", "Don't apply changes, show commands instead") { @opts[:simulate] = true ; @opts[:review] = false }
+        opts.on("-f", "--file DLFILE", "Use input file (be careful)") {|f| @opts[:input_file] = f }
+        opts.on("-m", "--monochrome", "Don't colorize output") { logger.colorize = false }
+        opts.on("-h", "--help", "Shows this help") { @opts[:dispatch] = :help }
+        opts.on("-v", "--version", "Shows version and other info") { @opts[:dispatch] = :info }
+        opts.on("-z", "Do not check for updates on GitHub (with -v/--version)") { @opts[:check_for_updates] = false }
+      end
+
+      begin
+        @optparse.parse!(@argv)
+      rescue OptionParser::ParseError => e
+        abort(e.message)
+        dispatch(:help)
+        exit 1
+      end
+    end
+
+    def which_editor
+      ENV["DLE_EDITOR"].presence ||
+      ENV["EDITOR"].presence ||
+      `which nano`.presence.try(:strip) ||
+      `which vim`.presence.try(:strip) ||
+      `which vi`.presence.try(:strip)
+    end
+
+    def open_editor file
+      system "#{@editor} #{file}"
+    end
+
+
+    # ==========
+    # = Logger =
+    # ==========
+    [:log, :warn, :abort, :debug].each do |meth|
+      define_method meth, ->(*a, &b) { Thread.main.app_logger.send(meth, *a, &b) }
+    end
+
+    def logger
+      Thread.main.app_logger
+    end
+
+    # Shortcut for logger.colorize
+    def c str, color = :yellow
+      logger.colorize? ? logger.colorize(str, color) : str
+    end
+
+    def ask question
+      logger.log_with_print(false) do
+        log c("#{question} ", :blue)
+        STDOUT.flush
+        STDIN.gets.chomp
+      end
+    end
+  end
+end

data/lib/dle/application/dispatch.rb

@@ -0,0 +1,151 @@
+module Dle
+  class Application
+    module Dispatch
+      def dispatch action = (@opts[:dispatch] || :help)
+        case action
+          when :version, :info then dispatch_info
+          else
+            if respond_to?("dispatch_#{action}")
+              send("dispatch_#{action}")
+            else
+              abort("unknown action #{action}", 1)
+            end
+        end
+      end
+
+      def dispatch_help
+        @optparse.to_s.split("\n").each(&method(:log))
+        log ""
+        log "To set your favorite editor set the env variable #{c "DLE_EDITOR", :magenta}"
+        log "Note that you need a blocking call (e.g. subl -w, mate -w)"
+        log "Your current editor is: #{c @editor || "none", :magenta}"
+      end
+
+      def dispatch_info
+        logger.log_without_timestr do
+          log ""
+          log "     Your version: #{your_version = Gem::Version.new(Dle::VERSION)}"
+
+          # get current version
+          logger.log_with_print do
+            log "  Current version: "
+            if @opts[:check_for_updates]
+              require "net/http"
+              log c("checking...", :blue)
+
+              begin
+                current_version = Gem::Version.new Net::HTTP.get_response(URI.parse(Dle::UPDATE_URL)).body.strip
+
+                if current_version > your_version
+                  status = c("#{current_version} (consider update)", :red)
+                elsif current_version < your_version
+                  status = c("#{current_version} (ahead, beta)", :green)
+                else
+                  status = c("#{current_version} (up2date)", :green)
+                end
+              rescue
+                status = c("failed (#{$!.message})", :red)
+              end
+
+              logger.raw "#{"\b" * 11}#{" " * 11}#{"\b" * 11}", :print # reset cursor
+              log status
+            else
+              log c("check disabled", :red)
+            end
+          end
+          log "  Selected editor: #{c @editor || "none", :magenta}"
+
+          # more info
+          log ""
+          log "  DLE DirectoryListEdit is brought to you by #{c "bmonkeys.net", :green}"
+          log "  Contribute @ #{c "github.com/2called-chaos/dle", :cyan}"
+          log "  Eat bananas every day!"
+          log ""
+        end
+      end
+
+      def dispatch_index
+        # require base directory
+        base_dir = ARGV[0].present? ? File.expand_path(ARGV[0].to_s) : ARGV[0].to_s
+        if !FileTest.directory?(base_dir)
+          if base_dir.present?
+            abort c(ARGV[0].to_s, :magenta) << c(" is not a valid directory!", :red)
+          else
+            dispatch(:help)
+            abort "Please provide a base directory.", 1
+          end
+        end
+
+        # index filesystem
+        log("index #{c base_dir, :magenta}")
+        @fs = Filesystem.new(base_dir, dotfiles: @opts[:dotfiles])
+        abort("Base directory is empty or not readable", 1) if @fs.index.empty?
+
+        file = "#{Dir.tmpdir}/#{SecureRandom.urlsafe_base64}"
+        begin
+          # read input file or open editor
+          if @opts[:input_file]
+            ifile = File.expand_path(@opts[:input_file])
+            if FileTest.file?(ifile) && FileTest.readable?(ifile)
+              @dlfile = DlFile.parse(ifile)
+            else
+              abort "Input file not readable: " << c(ifile, :magenta)
+            end
+          else
+            FileUtils.mkdir_p(File.dirname(file)) if !FileTest.exist?(File.dirname(file))
+            if !FileTest.exist?(file) || File.read(file).strip.empty?
+              File.open(file, "w") {|f| f.write @fs.to_dlfile }
+            end
+            log "open list for editing..."
+            open_editor(file)
+            @dlfile = DlFile.parse(file)
+          end
+
+          # delta changes
+          @delta = @fs.delta(@dlfile)
+
+          # no changes
+          if @delta.all?{|_, v| v.empty? }
+            abort c("No changes, nothing to do..."), 0
+          end
+
+          # review
+          if @opts[:review]
+            @delta.each do |action, snodes|
+              logger.ensure_prefix c("[#{action}]\t", :magenta) do
+                snodes.each do |snode|
+                  if [:chown, :chmod].include?(action)
+                    log(c("#{snode.node.relative_path} ", :blue) << c(snode.is, :red) << c(" » ") << c(snode.should, :green))
+                  elsif [:cp, :mv].include?(action)
+                    log(c(snode.is, :red) << c(" » ") << c(snode.should, :green))
+                  else
+                    log(c(snode.is, :red) << " (#{snode.snode.mode})")
+                  end
+                end
+              end
+            end
+
+            answer = ask("Do you want to apply these changes? [yes/no/edit]")
+            while !["y", "yes", "n", "no", "e", "edit"].include?(answer.downcase)
+              answer = ask("Please be explicit, yes/no/edit:")
+            end
+            raise "retry" if ["e", "edit"].include?(answer.downcase)
+            abort("Aborted, nothing changed", 0) if !["y", "yes"].include?(answer.downcase)
+          end
+        rescue
+          $!.message == "retry" ? retry : raise
+        end
+
+        # apply changes
+        log "#{@opts[:simulate] ? "Simulating" : "Applying"} changes..."
+        @delta.each do |action, snodes|
+          logger.ensure_prefix c("[apply-#{action}]\t", :magenta) do
+            snodes.each do |snode|
+              Filesystem::Destructive.new(self, action, @fs, snode).perform
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dle/dl_file.rb

@@ -0,0 +1,111 @@
+module Dle
+  class DlFile
+    def self.generate fs
+      Generator.new(fs).render
+    end
+
+    def self.parse file
+      Parser.new(file).parse
+    end
+
+    class Parser
+      def initialize file
+        @file = file
+      end
+
+      def parse
+        {}.tap do |fs|
+          return fs unless File.readable?(@file)
+          File.readlines(@file).each do |l|
+            next if l.start_with?("#")
+            if l.strip.start_with?("<HD-BASE>")
+              fs[:HD_BASE] = l.strip.gsub("<HD-BASE>", "").gsub("</HD-BASE>", "")
+            elsif l.strip.start_with?()
+              fs[:HD_DOTFILES] = l.strip.gsub("<HD-DOTFILES>", "").gsub("</HD-DOTFILES>", "") == "true"
+            elsif l.count("|") >= 4
+              # parse line
+              chunks = l.split("|")
+              data = {}.tap do |r|
+                r[:inode] = chunks.shift.strip
+                r[:mode] = chunks.shift.strip
+                r[:uid], r[:gid] = chunks.shift.split(":").map(&:strip)
+                chunks.shift # ignore size
+                r[:relative_path] = chunks.join("|").strip
+                r[:path] = [fs[:HD_BASE], r[:relative_path]].join("/")
+              end
+
+              # skip headers
+              next if data[:inode].downcase == "in"
+              next if data[:mode].downcase == "mode"
+              next if data[:uid].downcase == "owner"
+              next if data[:relative_path].downcase == "file"
+
+              # map node
+              if fs.key? data[:inode]
+                Thread.main.app_logger.warn "inode #{data[:inode]} already mapped, ignore..."
+              else
+                fs[data[:inode]] = Filesystem::Softnode.new(data)
+              end
+            end
+          end
+          Thread.main.app_logger.warn("DLFILE has no HD-BASE, deltaFS will fail!") unless fs[:HD_BASE].present?
+        end
+      end
+    end
+
+    class Generator
+      include Helpers
+
+      def initialize fs
+        @fs = fs
+      end
+
+      def render
+        # inode, mode, own/grp, size, file
+        table = [[], [], [], [], []]
+        @fs.index.each do |rpath, node|
+          table[0] << node.inode
+          table[1] << node.mode
+          table[2] << node.owngrp
+          table[3] << human_filesize(node.size)
+          table[4] << node.relative_path
+        end
+
+        ([
+          %{#},
+          %{# - If you remove a line we just don't care!},
+          %{# - If you add a line we just don't care!},
+          %{# - If you change a path we will "mkdir -p" the destination and move the file/dir},
+          %{# - If you change the owner we will "chown" the file/dir},
+          %{# - If you change the mode we will "chmod" the file/dir},
+          %{# - If you change the mode to "cp" and modify the path we will copy instead of moving/renaming},
+          %{# - If you change the mode to "del" we will "rm" the file},
+          %{# - If you change the mode to "delr" we will "rm" the file or directory},
+          %{# - If you change the mode to "delf" or "delrf" we will "rm -f" the file or directory},
+          %{# - We will apply changes in this order (inside-out):},
+          %{#     - Ownership},
+          %{#     - Permissions},
+          %{#     - Rename/Move},
+          %{#     - Copy},
+          %{#     - Delete},
+          %{#},
+          %{# Gotchas:},
+          %{#   - If you have "folder/subfolder/file" and want to rename "subfolder" to "dubfolder"},
+          %{#     do it only in the specific node, don't change the path of "file"!},
+          %{#   - If you want to copy a directory, only copy the directory node, not a file inside it.},
+          %{#     Folders will be copied recursively.},
+          %{#   - The script works with file IDs (IN column). That allows you to remove files in renamed},
+          %{#     folders without adjusting paths. This is not a gotcha, it's a hint :)},
+          %{#   - Note that indexing is quite fast but applying changes on a base directory with a lot},
+          %{#     of files and directories may be slow since we fully reindex after each operation.},
+          %{#     Maybe the mapping will keep track of changes in later updates so that this isn't necessary},
+          %{# --------------------------------------------------},
+          %{},
+          %{<HD-BASE>#{@fs.base_dir}</HD-BASE>},
+          %{<HD-DOTFILES>#{@fs.opts[:dotfiles]}</HD-DOTFILES>},
+          %{},
+        ] + render_table(table, ["IN", "Mode", "Owner", "Size", "File"])).map(&:strip).join("\n")
+      end
+    end
+  end
+end

data/lib/dle/filesystem.rb

@@ -0,0 +1,109 @@
+module Dle
+  class Filesystem
+    attr_reader :base_dir, :index, :opts
+
+    # ==========
+    # = Logger =
+    # ==========
+    [:log, :warn, :abort, :debug].each do |meth|
+      define_method meth, ->(*a, &b) { Thread.main.app_logger.send(meth, *a, &b) }
+    end
+
+    def logger
+      Thread.main.app_logger
+    end
+
+    # Shortcut for logger.colorize
+    def c str, color = :yellow
+      logger.colorize? ? logger.colorize(str, color) : str
+    end
+
+    # ---------
+
+    def initialize base_dir, opts = {}
+      raise ArgumentError, "#{base_dir} is not a directory" unless FileTest.directory?(base_dir)
+      @base_dir = File.expand_path(base_dir).freeze
+      @opts = { dotfiles: true }.merge(opts)
+      reindex!
+    end
+
+    def reindex!
+      @index = {}
+      index!
+    end
+
+    def index!
+      Find.find(@base_dir) do |path|
+        if File.basename(path)[0] == ?. && !@opts[:dotfiles]
+          Find.prune
+        else
+          index_node(path)
+        end
+      end
+    end
+
+    def relative_path path
+      if path.start_with?(@base_dir)
+        p = path[(@base_dir.length+1)..-1]
+        p.presence || "."
+      else
+        path
+      end
+    end
+
+    def to_dlfile
+      DlFile.generate(self)
+    end
+
+    def delta dlfile
+      abort "cannot delta DLFILE without HD_BASE", 1 unless dlfile[:HD_BASE].present?
+
+      # WARNING: The order of this result hash is important as it defines the order we process things!
+      {chown: [], chmod: [], mv: [], cp: [], rm: []}.tap do |r|
+        logger.ensure_prefix c("[dFS]\t", :magenta) do
+          log "HD-BASE is " << c(dlfile[:HD_BASE], :magenta)
+          dlfile.each do |ino, snode|
+            next if ino == :HD_BASE || ino == :HD_DOTFILES
+            node = @index[ino]
+            unless node
+              warn("INODE " << c(ino, :magenta) << c(" not found, ignore...", :red))
+              next
+            end
+
+            # flagged for removal
+            if %w[del delr delf delrf].include?(snode.mode)
+              r[:rm] << Softnode.new(node: node, snode: snode, is: node.relative_path)
+              next
+            end
+
+            # mode changed
+            if "#{snode.mode}".present? && "#{snode.mode}" != "cp" && "#{node.mode}" != "#{snode.mode}"
+              r[:chmod] << Softnode.new(node: node, snode: snode, is: node.mode, should: snode.mode)
+            end
+
+            # uid/gid changed
+            if "#{node.owngrp}" != "#{snode.uid}:#{snode.gid}"
+              r[:chown] << Softnode.new(node: node, snode: snode, is: node.owngrp, should: "#{snode.uid}:#{snode.gid}")
+            end
+
+            # path changed
+            if "#{node.relative_path}" != "#{snode.relative_path}"
+              r[snode.mode == "cp" ? :cp : :mv] << Softnode.new(node: node, snode: snode, is: node.relative_path, should: snode.relative_path)
+            end
+          end
+        end
+
+        # sort results to perform actions inside-out
+        r.each do |k, v|
+          r[k] = v.sort_by{|snode| snode.node.relative_path.length }.reverse
+        end
+      end
+    end
+
+  protected
+
+    def index_node path
+      Node.new(self, path).tap{|node| @index[node.inode] = node }
+    end
+  end
+end