right_data 0.5.20 → 0.5.21

data/lib/FileSystemTree.rb

@@ -0,0 +1,172 @@
+require 'escape'
+module RightData
+  class FileSystemTree
+    
+    attr_reader :relativePath
+    attr_reader :parent
+
+    attr_reader :ignore_children
+    attr_reader :duplicate_children
+    attr_accessor :duplicates
+    attr_accessor :ignorable
+    
+    def initialize path, args
+      if args[:parent]
+        @relativePath = File.basename(path)
+        @parent = args[:parent]
+      else
+        @relativePath = path
+        @parent = nil
+      end
+      @ignorable = false
+      @duplicates = [] # for this node
+      @duplicate_children = 0 # counts for children
+      @ignore_children    = 0
+      self
+    end
+
+    # TODO: Do this for LEAVES instead of files. Include empty dirs.
+    def files
+      return 0 if leaf? && File.directory?(fullPath)
+      return 1 if leaf?
+      return children.map {|n| n.files}.inject {|sum, n| sum + n } 
+    end
+    def ignore_files
+      return 0 if leaf? && File.directory?(fullPath)
+      return ignorable? ? 1 : 0 if leaf?
+      return children.map {|n| n.ignore_files}.inject {|sum, n| sum + n } 
+    end
+    def duplicate_files
+      return 0 if leaf? && File.directory?(fullPath)
+      return duplicate? ? 1 : 0 if leaf?
+      return children.map {|n| n.duplicate_files}.inject {|sum, n| sum + n } 
+    end
+
+
+    def basename; @relativePath; end
+    
+    def self.rootItem
+      @rootItem ||= self.new '/', :parent => nil
+    end
+    
+    def children
+      unless @children
+         if File.directory?(fullPath) and File.readable?(fullPath)
+           @children = Dir.entries(fullPath).select { |path|
+              path != '.' and path != '..'
+           }.map { |path|
+              FileSystemTree.new path, :parent => self
+           }
+         else
+           @children = nil
+         end
+      end
+      @children
+    end
+    
+    def path; fullPath; end
+    def fullPath
+      @parent ? File.join(@parent.fullPath, @relativePath) : @relativePath
+    end
+    
+    def childAtIndex n
+      children[n]
+    end
+    
+    def numberOfChildren
+      children == nil ? -1 : children.size
+    end
+
+    def children?; !children.nil? && !children.empty?; end
+
+    def duplicate?
+      if leaf?
+        !duplicates.empty?
+      else # Dup if all ignored / dup children
+        ((@ignore_children + @duplicate_children) == numberOfChildren)
+      end
+    end
+
+    def ignorable?; ignorable; end
+
+    def increment_ignorable_children
+      @ignore_children += 1
+      update_duplicate_ignorable_status
+    end
+
+    def update_duplicate_ignorable_status
+      parent.increment_duplicate_children if((@ignore_children + @duplicate_children) == numberOfChildren)
+    end
+
+    def increment_duplicate_children
+      @duplicate_children += 1
+      update_duplicate_ignorable_status
+    end
+
+    def leaf?; !children?; end
+
+    def traverse(&block) # Allow proc to decide if we traverse
+      if block.call(self) && children?
+        children.each { |c| c.traverse(&block) }
+      end
+    end
+
+    def other_children
+      children.size - ignore_children - duplicate_children
+    end
+
+    def to_param; to_s; end
+    def to_s
+      "<Tree :path => #{self.path}, :files => #{self.files}>" 
+    end
+
+    def put_for_shell(pre,path,comment)
+      if(pre.empty?)
+        puts Escape.shell_command([path, "# #{comment}"])
+      else
+        puts Escape.shell_command([pre.split(" "), path, "# #{comment}"].flatten)
+      end
+    end
+
+    # Inspect the nodes:
+    def report(pre="")
+      pre += " " if !pre.empty?
+      self.traverse do |n|
+        # Is this a leaf (e.g. a file)?
+        if n.leaf?
+          if(File.directory?(n.path))
+            # Prune empty dirs!
+            put_for_shell(pre,n.path,"Empty dir") # Remove the dups/igns!
+            #puts "#{pre}'#{n.path.gsub(/'/,"\\\\'")}' # Empty dir"
+          else 
+            msg = nil
+            msg = " dup(#{n.duplicates.count})" if n.duplicate?
+            msg = " ign" if n.ignorable?
+            if msg
+              put_for_shell(pre,n.path,msg) # Remove the dups/igns!
+              # puts "#{pre}'#{n.path.gsub(/'/,"\\\\'")}' #{msg}" # Remove the dups/igns!
+            else
+              puts "# #{n.path} unique"
+            end
+          end
+          false # Don't traverse deeper!
+        else
+          if n.duplicate_children + n.ignore_children == n.children.size
+            put_for_shell(pre,n.path,"#{n.duplicate_children} dups / #{n.ignore_children} ignores")
+            # puts "#{pre}'#{n.path.gsub(/'/,"\\\\'")}' # #{n.duplicate_children} dups / #{n.ignore_children} ignores"
+            false # Don't traverse deeper!
+          elsif n.children.size == 0
+            put_for_shell(pre,n.path," Empty")
+            # puts "#{pre}'#{n.path.gsub(/'/,"\\\\'")}' # Empty... "
+            false
+          else
+            puts "# #{n.path} # Not #{n.duplicate_children} dup/ #{n.ignore_children} ign / #{n.other_children} other "
+            true
+          end
+        end
+      end
+      puts "# #{self.ignore_files} ignores, #{self.duplicate_files} dups of #{self.files} files"
+    end
+    
+  end
+end

data/lib/main.rb

@@ -286,6 +286,37 @@ module RightData
     # prunable_files
   end
 
+  # This is a weak check! Also does nothing to check one svn in another.
+  def svn?(path)
+    File.directory?(File.join(path, ".svn"))
+  end
+  def git?(path)
+    File.directory?(File.join(path, ".git"))
+  end
+  def self.scan_for_repos(prune, &block)
+    tree = FileSystemTree.new(prune, :parent => nil)
+    repos = {}
+    # Mark the nodes:
+    tree.traverse do |n|
+      if File.directory?(n.path)
+        if svn?(n.path)
+          cd_cmd = Escape.shell_command(["cd",n.path])
+          status = `#{cd_cmd}; svn status`
+          info   = `#{cd_cmd}; svn info`
+          repos[n.path] = { :kind => "svn", :status => status, :info => info }
+        end
+        if git?(n.path)
+          cd_cmd = Escape.shell_command(["cd",n.path])
+          status = `#{cd_cmd}; git status`
+          info   = `#{cd_cmd}; git show`
+          repos[n.path] = { :kind => "git", :status => status, :info => info }
+        end
+        !repos[n.path] # recurse only if we DID NOT find a repo
+      end
+    end
+    return repos
+  end
+
   # each_set_of_duplicates(dirs) do |f|
   #  puts "Duplicates: #{f.join(", ")}"
   #end

data/lib/right_data.rb

@@ -2,14 +2,25 @@ require 'main'
 
 module RightData
   def self.hello; "Hi!"; end
+
+  # Run this in a directory (prunable) that is suspected of containing duplicate files that
+  # already exist in master. E.g. check a discovered backup drive and whether anything on it is valid
   def self.prune_report(master,prunable)
     tree = RightData::scan_for_prunable(master,prunable) 
     tree.report('rm -rf'); nil
   end
 
+  # Run this in a directory that is suspected of containing self-duplicate files.
+  # Compare to: fdupes -r -n prunable
   def self.dup_report(prunable)
     RightData::scan_for_dup(prunable)
   end
+
+  # Run this on a directory that is suspected of containing unchecked in GIT or SVN repos.
+  # Get back a list of all repos, versions and whether any files are unchecked in.
+  def self.repo_report(search_dir)
+    tree = RightData::scan_for_repos(search_dir) 
+  end
 end
 # Usage:
 # Prune any files from prunable that are already in master:

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: right_data
 version: !ruby/object:Gem::Version 
-  hash: 35
+  hash: 33
   prerelease: false
   segments: 
   - 0
   - 5
-  - 20
-  version: 0.5.20
+  - 21
+  version: 0.5.21
 platform: ruby
 authors: 
 - Jonathan Siegel
@@ -57,6 +57,7 @@ extra_rdoc_files:
 - README.rdoc
 files: 
 - lib/FileSystemItem.rb
+- lib/FileSystemTree.rb
 - lib/main.rb
 - lib/right_data.rb
 - LICENSE