revtree 0.1.3 → 0.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fdd5916237e12c049db40a28dfc46aae0d49a9da26d7f92dcce2f9c16ec1bfc5
-  data.tar.gz: f8666a0a6d4684ea29b88dd603104e3affbff010e13991bc929e1f578b6ed6de
+  metadata.gz: 38695028f770cc56588f3101b95f6dfdde959306928750c41ee7b04694b25f93
+  data.tar.gz: 4b240bf3d9601e5cbb73592ccaa4b95de20a1164ce8a0506642c394a1d5959c0
 SHA512:
-  metadata.gz: 8386219887c05bee8f4fe64c3b981a6772ccda56dcfe750115565aaf906d601019524ed5024a16ea97167e8630a4c88a6fc7d67b63c492f29b05d9832140cc7f
-  data.tar.gz: f9a11c1f1e9fcc91564a6bb4d07f3ae373913c31c732c1edaef963c9b531754ae7ce592a2db6a3582e66fd2ca6767895b602a0840590bebcdbf6fb55f3564bbb
+  metadata.gz: 1b2db6f9de82d4b0b5adb8ea1fb0f562eec56e5242c97fddefde0240d6f0cbab0ade2f6baff811d579a139c85865d462ff27f94aed24de834d88975cb98277fd
+  data.tar.gz: 71c0386cd9c5d64e1881c47e6ab7ac83c5e5e03ceba87ff16c4fc63be1ef07795ac5cc8629ace349cc9315db8c3e955f21a21f488dfce61c0b0e6dbf607b8461

data/README.md

@@ -1,5 +1,10 @@
 # RevTree
 
+[![GitHub Tag](https://img.shields.io/github/v/tag/juliankahlert/revtree)](https://github.com/juliankahlert/revtree)
+[![Gem Version](https://img.shields.io/gem/v/revtree)](https://rubygems.org/gems/revtree)
+[![Codacy Badge](https://app.codacy.com/project/badge/Grade/ac169e80b46b4d78a1a3e8e15be24c2f)](https://app.codacy.com/gh/juliankahlert/revtree/dashboard?utm_source=gh&utm_medium=referral&utm_content=&utm_campaign=Badge_grade)
+[![Codacy Badge](https://app.codacy.com/project/badge/Coverage/ac169e80b46b4d78a1a3e8e15be24c2f)](https://app.codacy.com/gh/juliankahlert/revtree/dashboard?utm_source=gh&utm_medium=referral&utm_content=&utm_campaign=Badge_coverage)
+
 ## Introduction
 
 `RevTree` is a Ruby library for tracking and comparing directory structures.
@@ -20,16 +25,19 @@ It also provides methods to print and serialize the tree structure, as well as t
 ## Install
 
 The supported tools are:
+
 - gitpack
 - make
 - gem
 
 ### gitpack
+
 ```sh
 gitpack add juliankahlert/revtree
 ```
 
 ### make
+
 ```sh
 git clone https://github.com/juliankahlert/revtree.git
 cd revtree
@@ -37,11 +45,12 @@ sudo make install
 ```
 
 ### gem (local)
+
 ```sh
 git clone https://github.com/juliankahlert/revtree.git
 cd revtree
 gem build revtree.gemspec
-sudo gem install --local revtree-0.1.3.gem
+sudo gem install --local revtree-0.1.5.gem
 ```
 
 ## API Documentation
@@ -49,52 +58,52 @@ sudo gem install --local revtree-0.1.3.gem
 ### `RevTree.new(path, whitelist = nil)`
 
 - **Parameters**:
-  - `path` (String): The path to the file or directory.
-  - `whitelist` (Array<String>): List of patterns to include in the tree.
+  - `path` (`String`): The path to the file or directory.
+  - `whitelist` (`Array<String>`): List of patterns to include in the tree.
 
 ### `#print_tree(indent = 0)`
 
 - **Parameters**:
-  - `indent` (Integer): Number of spaces to indent each level of the tree.
+  - `indent` (`Integer`): Number of spaces to indent each level of the tree.
 
 ### `#to_h`
 
-- **Returns**: A Hash representation of the RevTree object.
+- **Returns**: A `Hash` representation of the `RevTree` object.
 
 ### `#to_json`
 
-- **Returns**: A JSON representation of the RevTree object.
+- **Returns**: A `JSON` representation of the `RevTree` object.
 
 ### `#for_each(status_whitelist, &block)`
 
 - **Parameters**:
-  - `status_whitelist` (Array<Symbol>): List of statuses to include (e.g., `[:added, :removed]`).
-  - `&block` (Proc): A block to execute for each file matching the given statuses.
+  - `status_whitelist` (`Array<Symbol>`): List of statuses to include (e.g., `[:added, :removed]`).
+  - `&block` (`Proc`): A block to execute for each file matching the given statuses.
 - **Behavior**: Iterates over files in the tree, executing the block for each file whose status matches one of the statuses in the whitelist.
 
 ### `#watch(status_whitelist = [:modified, :added, :removed], &block)`
 
 - **Parameters**:
-  - `status_whitelist` (Array<Symbol>): List of statuses to watch (e.g., `[:added, :removed]`).
-  - `&block` (Proc): A block to execute when a file matching the given statuses is changed.
+  - `status_whitelist` (`Array<Symbol>`): List of statuses to watch (e.g., `[:added, :removed]`).
+  - `&block` (`Proc`): A block to execute when a file matching the given statuses is changed.
 
 ### `#with_interval(interval)`
 
 - **Parameters**:
-  - `interval` (Integer): Interval (in seconds) between checks for changes.
+  - `interval` (`Integer`): Interval (in seconds) between checks for changes.
 - **Returns**: The `RevTree` instance, enabling method chaining.
 
 ### `RevTree.from_h(h)`
 
 - **Parameters**:
-  - `h` (Hash): A hash representation of a RevTree object.
-- **Returns**: A RevTree object.
+  - `h` (`Hash`): A `Hash` representation of a `RevTree` object.
+- **Returns**: A `RevTree` object.
 
 ### `RevTree.from_json(json_str)`
 
 - **Parameters**:
-  - `json_str` (String): A JSON string representing a RevTree object.
-- **Returns**: A RevTree object.
+  - `json_str` (`String`): A `JSON` string representing a `RevTree` object.
+- **Returns**: A `RevTree` object.
 
 ## Example Usage
 

data/lib/revtree.rb

@@ -51,11 +51,15 @@ class RevTree
   #
   # @param path [String, Pathname] the path to the file or directory
   # @param whitelist [Array<String>, nil] a list of file patterns to include (optional)
-  def initialize(path, whitelist = nil)
+  def initialize(path, whitelist = ['*'])
     @path = Pathname.new(path)
     @name = @path.basename.to_s
-    @whitelist = whitelist || []
+    @whitelist = whitelist
     @status = :unmodified
+    @type = :folder
+    @children = []
+    @interval = 5
+    @rev = ''
 
     if @path.directory?
       init_dir
@@ -69,8 +73,8 @@ class RevTree
   # @param indent [Integer] the indentation level (default: 0)
   # @return [void]
   def print_tree(indent = 0)
-    status_str = @status ? " (status: #{@status})" : ''
-    puts "#{'  ' * indent}#{@type == :folder ? '[Folder]' : '[File]'} #{@name} (rev: #{@rev})#{status_str}"
+    indent_prefix = '  ' * indent
+    puts "#{indent_prefix}#{type_to_str()} #{@name} (rev: #{@rev}) #{status_to_str()}"
     @children.each { |child| child.print_tree(indent + 1) }
   end
 
@@ -96,10 +100,12 @@ class RevTree
 
   # Reconstructs a `RevTree` object from a hash.
   #
-  # @param h [Hash] the hash to deserialize
+  # @param hash [Hash] the hash to deserialize
   # @return [RevTree] the reconstructed `RevTree` object
-  def self.from_h(h)
-    new_tree(h[:name], h[:type].to_sym, h[:rev], h[:children], h[:status])
+  def self.from_h(hash)
+    hash[:status] = hash[:status].to_sym
+    hash[:type] = hash[:type].to_sym
+    new_tree(hash)
   end
 
   # Reconstructs a `RevTree` object from a JSON string.
@@ -123,7 +129,7 @@ class RevTree
   def for_each(status_whitelist = [:unmodified, :modified, :added, :removed], &block)
     return unless block_given?
 
-    RevTree.traverse_tree(self, status_whitelist, @path, &block)
+    RevTree.traverse_tree(self, status_whitelist, @path, nil, &block)
   end
 
   # Watches the tree for changes
@@ -138,23 +144,12 @@ class RevTree
   # @return [void]
   def watch(status_whitelist = [:modified, :added, :removed], &block)
     current_tree = self
-    @interval ||= 5
+    setup_traps
 
-    Signal.trap('INT') { exit }
-    Signal.trap('TERM') { exit }
     loop do
       sleep @interval
 
-      new_tree = RevTree.new(@path, @whitelist)
-      diff_tree = RevTree.compare(current_tree, new_tree)
-
-      next if diff_tree.nil?
-
-      diff_tree.for_each(status_whitelist) do |node, full_path|
-        block.call(node, full_path)
-      end
-
-      current_tree = new_tree
+      current_tree = refresh_tree(current_tree, status_whitelist, block)
     end
   end
 
@@ -169,6 +164,45 @@ class RevTree
 
   private
 
+  # Refreshes the tree by comparing the current tree with a new version and executing a block
+  # for each file that matches the given statuses.
+  #
+  # @param current_tree [RevTree] the current RevTree instance
+  # @param status_whitelist [Array<Symbol>] the list of statuses to match (e.g., :added, :modified, :removed)
+  # @param block [Proc] the block to execute for each file matching the statuses
+  # @return [RevTree] the updated RevTree with changes
+  def refresh_tree(current_tree, status_whitelist, block)
+    new_tree = RevTree.new(@path, @whitelist)
+    diff_tree = RevTree.compare(current_tree, new_tree)
+    return current_tree unless diff_tree
+
+    diff_tree.for_each(status_whitelist, &block)
+
+    new_tree
+  end
+
+  # Setup traps.
+  #
+  # @return [void]
+  def setup_traps
+    Signal.trap('INT') { exit }
+    Signal.trap('TERM') { exit }
+  end
+
+  # Stringify the type for pretty-printing.
+  #
+  # @return [String] the type string
+  def type_to_str
+    @type == :folder ? '[Folder]' : '[File]'
+  end
+
+  # Stringify the status for pretty-printing.
+  #
+  # @return [String] the status string
+  def status_to_str
+    @status ? "(status: #{@status})" : ''
+  end
+
   # Calculates the MD5 hash for the file.
   #
   # @return [String] the MD5 hash of the file
@@ -187,10 +221,9 @@ class RevTree
   #
   # @return [void]
   def init_dir
-    @type = :folder
     @children = @path.children
-      .select { |c| include_in_tree?(c) }
-      .map { |c| RevTree.new(c, @whitelist) }
+      .select { |child| include_in_tree?(child) }
+      .map { |child| RevTree.new(child, @whitelist) }
     @rev = calculate_directory_rev
   end
 
@@ -199,43 +232,61 @@ class RevTree
   # @return [void]
   def init_file
     @type = :file
-    @children = []
     @rev = calculate_file_rev
   end
 
+  # Apply attributes from a `Hash` to a `RevTree`.
+  #
+  # @param revtree [RevTree] the tree node to be modified
+  # @param attr_hash [Hash] the hash containing the attributes
+  # @return [void]
+  def self.apply_attributes(revtree, attr_hash)
+    revtree.instance_variable_set(:@name, attr_hash[:name])
+    revtree.instance_variable_set(:@type, attr_hash[:type])
+    revtree.instance_variable_set(:@rev, attr_hash[:rev])
+    revtree.instance_variable_set(:@status, attr_hash[:status])
+    revtree.instance_variable_set(:@children, attr_hash[:children])
+  end
+
+  # Recurse into child nodes to deserialize `RevTree`.
+  #
+  # @param hash [Hash] the hash to deserialize
+  # @return [void]
+  def self.new_tree_recurse_children(hash)
+    children = hash[:children] || []
+    hash[:children] = children.map { |child| from_h(child) }
+  end
+
   # Rebuilds a `RevTree` from its serialized components.
   #
-  # @param name [String] the name of the node
-  # @param type [Symbol] the type of the node (:folder or :file)
-  # @param rev [String] the revision hash of the node
-  # @param children [Array<Hash>] the child nodes (if any)
-  # @param status [Symbol] the status of the node (:unmodified, :modified, etc.)
+  # @param hash [Hash] the hash to deserialize
   # @return [RevTree] the reconstructed tree
-  def self.new_tree(name, type, rev, children, status = :unmodified)
+  def self.new_tree(hash)
     tree = allocate
-    tree.instance_variable_set(:@name, name)
-    tree.instance_variable_set(:@type, type.to_sym)
-    tree.instance_variable_set(:@rev, rev)
-    tree.instance_variable_set(:@status, status.to_sym)
-    if type == :folder && children
-      tree.instance_variable_set(:@children, children.map { |c| from_h(c) })
-    else
-      tree.instance_variable_set(:@children, [])
-    end
+    new_tree_recurse_children(hash)
+    apply_attributes(tree, hash)
     tree
   end
 
+  # Determines whether a path is a dot directory.
+  #
+  # @param path [Pathname] the path to the file or directory
+  # @return [Boolean] `true` if path is a dot directory, `false` otherwise
+  def self.path_is_dot_dir?(path)
+    path.directory? && path.basename.to_s.start_with?('.')
+  end
+
   # Determines whether a file or directory should be included in the tree.
   #
   # @param path [Pathname] the path to the file or directory
   # @return [Boolean] `true` if the path should be included, `false` otherwise
   def include_in_tree?(path)
-    return false if path.directory? && path.basename.to_s.start_with?('.')
+    return false if RevTree.path_is_dot_dir?(path)
 
     return true if path.directory?
     return true if @whitelist.empty?
 
-    @whitelist.any? { |p| File.fnmatch?(p, path.basename.to_s) }
+    @whitelist.any? { |pattern| File.fnmatch?(pattern, path.basename.to_s) }
   end
 
   # Compares two `RevTree` nodes (old and new) and returns a tree with appropriate status.
@@ -244,16 +295,13 @@ class RevTree
   # @param new [RevTree, nil] the new version of the tree
   # @return [RevTree, nil] the resulting tree with status updates or `nil`
   def self.compare(old, new)
-    return nil if old.nil? && new.nil?
+    return nil unless old || new
 
-    return handle_addition(new) if old.nil?
-    return handle_removal(old) if new.nil?
+    return handle_addition(new) unless old
+    return handle_removal(old) unless new
 
-    if old.rev != new.rev
-      return handle_modification(old, new)
-    else
-      return handle_unmodified(old, new)
-    end
+    status = old.rev != new.rev ? :modified : :unmodified
+    handle_modification(old, new, status)
   end
 
   # Handles the addition of a new node.
@@ -280,13 +328,14 @@ class RevTree
   #
   # @param old [RevTree] the old node
   # @param new [RevTree] the new node
+  # @param status [Symbol] the status to apply (:modified or :unmodified)
   # @return [RevTree] the node with the status set to `:modified`
-  def self.handle_modification(old, new)
+  def self.handle_modification(old, new, status)
     if old.type == :folder && new.type == :folder
-      compare_folders(old, new, :modified)
+      compare_folders(old, new, status)
     else
       with_status = new.dup
-      with_status.instance_variable_set(:@status, :modified)
+      with_status.instance_variable_set(:@status, status)
       with_status
     end
   end
@@ -300,7 +349,9 @@ class RevTree
   def self.compare_folders(old, new, status)
     combined_children = merge_children(old.children, new.children)
     with_status = new.dup
-    merged = combined_children.map { |o, n| compare(o, n) }
+    merged = combined_children.map do |old_child, new_child|
+      compare(old_child, new_child)
+    end
 
     folder_status = merged.any? { |child| child.status == :modified } ? :modified : status
 
@@ -309,53 +360,42 @@ class RevTree
     with_status
   end
 
-  # Handles the unmodified status of a node.
-  #
-  # @param old [RevTree] the old node
-  # @param new [RevTree] the new node
-  # @return [RevTree] the node with the status set to `:unmodified`
-  def self.handle_unmodified(old, new)
-    if old.type == :folder && new.type == :folder
-      compare_folders(old, new, :unmodified)
-    else
-      with_status = new.dup
-      with_status.instance_variable_set(:@status, :unmodified)
-      with_status
-    end
-  end
-
   # Merges the children of two nodes.
   #
-  # @param old_children [Array<RevTree>] the children of the old node
-  # @param new_children [Array<RevTree>] the children of the new node
   # @return [Array<Array<RevTree, RevTree>>] an array of paired old and new children
   def self.merge_children(old_children, new_children)
     all_names = (old_children.map(&:name) + new_children.map(&:name)).uniq
-    all_names.map do |name|
-      old_child = old_children.find { |child| child.name == name }
-      new_child = new_children.find { |child| child.name == name }
-      [old_child, new_child]
-    end
+    all_names.map { |name| find_child_pair(name, old_children, new_children) }
+  end
+
+  # @param old_children [Array<RevTree>] the children of the old node
+  # @param new_children [Array<RevTree>] the children of the new node
+  def self.find_child_pair(name, old_children, new_children)
+    old_child = old_children.find { |old| old.name == name }
+    new_child = new_children.find { |new| new.name == name }
+    [old_child, new_child]
   end
 
   # Traverses the tree and executes a block for each file matching the provided status whitelist.
   #
   # @param node [RevTree] the current node being traversed
   # @param status_whitelist [Array<Symbol>] the list of statuses to match
+  # @param root [Pathname] the root path
   # @param current_path [Pathname] the current path
   # @yield [node, full_path] the block to be executed for each matching file
   # @yieldparam node [RevTree] the current node being traversed
   # @yieldparam full_path [String] the full path of the current node
   # @return [void]
-  def self.traverse_tree(node, status_whitelist, current_path, &block)
+  def self.traverse_tree(node, status_whitelist, root, current_path, &block)
+    current_path = current_path.to_s
+    full_path = current_path == '' ? root : File.join(current_path, node.name.to_s)
+
     if node.type == :file && status_whitelist.include?(node.status)
-      block.call(node, File.expand_path(current_path.to_s))
+      block.call(node, File.expand_path(current_path))
     end
 
-    full_path = File.join(current_path.to_s, node.name.to_s)
-
     node.children.each do |child|
-      traverse_tree(child, status_whitelist, full_path, &block)
+      traverse_tree(child, status_whitelist, root, full_path, &block)
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: revtree
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.1.5
 platform: ruby
 authors:
 - Julian Kahlert
@@ -10,6 +10,66 @@ bindir: bin
 cert_chain: []
 date: 2024-09-07 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: simplecov-simplecov-cobertura
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.1'
+- !ruby/object:Gem::Dependency
+  name: simplecov-console
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.9.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.9.1
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.22'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.22.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.22'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.22.0
 - !ruby/object:Gem::Dependency
   name: yard
   requirement: !ruby/object:Gem::Requirement
@@ -66,7 +126,7 @@ licenses:
 - MIT
 metadata:
   homepage_uri: https://juliankahlert.github.io/revtree/
-  documentation_uri: https://www.rubydoc.info/gems/revtree/0.1.3
+  documentation_uri: https://www.rubydoc.info/gems/revtree/0.1.5
   source_code_uri: https://github.com/juliankahlert/revtree
 post_install_message: 
 rdoc_options: []