revtree 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: a7c82aecb58c070a313c7d7e7897c7c038d66dfa35d717fae991eeeb19245f6f
+  data.tar.gz: 6ffc2b90332f026b0cd32c7f6daf7af377e28ced7c679633d6807416d1e9e1ff
+SHA512:
+  metadata.gz: b21ee3950eae8d1c09f2d42124d68653c0c21f1f4c0efe1e582d9444cb4bcc90620cb8778a7ed900aeba9f3beab85ca6cca45dfa596ec3f49f29240b7a33cb13
+  data.tar.gz: 2c0762cb314b65c1c14b8904cef4c18d0d434001193fe84d7f136fe9923de4cfa3bf73bcc253ce295dacb6ecb941479f8f84547fa3760c49006b305c31e720e0

data/README.md

@@ -0,0 +1,116 @@
+# RevTree
+
+## Introduction
+
+`RevTree` is a Ruby library for tracking and comparing directory structures.
+It calculates the MD5 hash for files and directories to determine their revisions and supports detecting changes like additions, removals, and modifications.
+It also provides methods to print and serialize the tree structure, as well as traverse it for specific statuses.
+
+## Features
+
+- **Directory and File Tracking**: Handles both directories and files, including recursive directory structures.
+- **Revision Tracking**: Computes and tracks revisions using MD5 hashes.
+- **Change Detection**: Identifies and marks changes such as additions, deletions, and modifications.
+- **Serialization**: Supports serialization to and from JSON format for easy storage and transfer.
+- **Pretty Printing**: Provides a method to print the directory tree with statuses.
+- **Iterate with `for_each`**: Traverse the tree and apply a block to files matching specific statuses.
+
+## 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
+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.0.gem
+```
+
+## API Documentation
+
+### `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.
+
+### `#print_tree(indent = 0)`
+
+- **Parameters**:
+  - `indent` (Integer): Number of spaces to indent each level of the tree.
+
+### `#to_h`
+
+- **Returns**: A Hash representation of the RevTree object.
+
+### `#to_json`
+
+- **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.
+- **Behavior**: Iterates over files in the tree, executing the block for each file whose status matches one of the statuses in the whitelist.
+
+### `RevTree.from_h(h)`
+
+- **Parameters**:
+  - `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.
+
+## Example Usage
+
+```ruby
+#!/bin/env ruby
+
+require 'revtree'
+
+# Let's simulate two different directory structures to compare
+file_tree_old = RevTree.new('./', ['*.rb', '*.md'])
+file_tree_new = RevTree.new('./', ['*.rb'])
+
+# Compare the two trees
+result_tree = RevTree.compare(file_tree_old, file_tree_new)
+
+# Print the resulting tree with change statuses
+result_tree.print_tree
+
+# Example of using for_each
+result_tree.for_each([:added, :removed]) do |file, full_path|
+  p "File #{file.name} in #{full_path} was added/removed"
+end
+```
+
+## Encouragement for Contribution
+
+Vontributions from the community are welcome!
+If you find any issues or have ideas for new features, please feel free to submit a pull request or open an issue.
+Your input helps make RevTree better for everyone.
+
+## License
+
+RevTree is licensed under the MIT License. See the [LICENSE](LICENSE) file for more details.

data/lib/revtree.rb

@@ -0,0 +1,207 @@
+# lib/revtree.rb
+#
+# MIT License
+#
+# Copyright (c) 2024 Julian Kahlert
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+require 'digest'
+require 'pathname'
+require 'json'
+
+class RevTree
+  attr_reader :children, :type, :name, :rev, :status
+
+  def initialize(path, whitelist = nil)
+    @path = Pathname.new(path)
+    @name = @path.basename.to_s
+    @whitelist = whitelist || []
+    @status = :unmodified
+
+    if @path.directory?
+      init_dir
+    else
+      init_file
+    end
+  end
+
+  def calculate_file_rev
+    Digest::MD5.file(@path).hexdigest
+  end
+
+  def calculate_directory_rev
+    Digest::MD5.hexdigest(@children.map(&:rev).join)
+  end
+
+  def print_tree(indent = 0)
+    status_str = @status ? " (status: #{@status})" : ''
+    puts "#{'  ' * indent}#{@type == :folder ? '[Folder]' : '[File]'} #{@name} (rev: #{@rev})#{status_str}"
+    @children.each { |child| child.print_tree(indent + 1) }
+  end
+
+  # Serialize the RevTree object to JSON
+  def to_h
+    {
+      type: @type,
+      name: @name,
+      rev: @rev,
+      status: @status,
+      children: @children.map(&:to_h),
+    }
+  end
+
+  def to_json(*_args)
+    JSON.pretty_generate(self.to_h)
+  end
+
+  def self.from_h(h)
+    new_tree(h[:name], h[:type].to_sym, h[:rev], h[:children], h[:status])
+  end
+
+  def self.from_json(json_str)
+    data = JSON.parse(json_str, symbolize_names: true)
+    file_tree = from_h(data)
+
+    file_tree
+  end
+
+  def for_each(status_whitelist, &block)
+    return unless block_given?
+
+    RevTree.traverse_tree(self, status_whitelist, @path, &block)
+  end
+
+  private
+
+  def init_dir
+    @type = :folder
+    @children = @path.children
+      .select { |c| include_in_tree?(c) }
+      .map { |c| RevTree.new(c, @whitelist) }
+    @rev = calculate_directory_rev
+  end
+
+  def init_file
+    @type = :file
+    @children = []
+    @rev = calculate_file_rev
+  end
+
+  def self.new_tree(name, type, rev, children, status = :unmodified)
+    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
+    tree
+  end
+
+  def include_in_tree?(path)
+    return false if path.directory? && path.basename.to_s.start_with?('.')
+
+    return true if path.directory?
+    return true if @whitelist.empty?
+
+    @whitelist.any? { |p| File.fnmatch?(p, path.basename.to_s) }
+  end
+
+  def self.compare(old, new)
+    return nil if old.nil? && new.nil?
+
+    return handle_addition(new) if old.nil?
+    return handle_removal(old) if new.nil?
+
+    if old.rev != new.rev
+      return handle_modification(old, new)
+    else
+      return handle_unmodified(old, new)
+    end
+  end
+
+  def self.handle_addition(new)
+    with_status = new.dup
+    with_status.instance_variable_set(:@status, :added)
+    with_status
+  end
+
+  def self.handle_removal(old)
+    with_status = old.dup
+    with_status.instance_variable_set(:@status, :removed)
+    with_status
+  end
+
+  def self.handle_modification(old, new)
+    if old.type == :folder && new.type == :folder
+      compare_folders(old, new, :modified)
+    else
+      with_status = new.dup
+      with_status.instance_variable_set(:@status, :modified)
+      with_status
+    end
+  end
+
+  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) }
+
+    folder_status = merged.any? { |child| child.status == :modified } ? :modified : status
+
+    with_status.instance_variable_set(:@children, merged)
+    with_status.instance_variable_set(:@status, folder_status)
+    with_status
+  end
+
+  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
+
+  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
+  end
+
+  def self.traverse_tree(node, status_whitelist, current_path, &block)
+    if node.type == :file && status_whitelist.include?(node.status)
+      block.call(node, File.expand_path(current_path.to_s))
+    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)
+    end
+  end
+end

metadata

@@ -0,0 +1,66 @@
+--- !ruby/object:Gem::Specification
+name: revtree
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Julian Kahlert
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2024-09-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.4'
+description: RevTree builds a recursive directory tree and compares file revisions.
+  It can mark files and folders as added, removed, modified, or unmodified.
+email:
+- 90937526+juliankahlert@users.noreply.github.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/revtree.rb
+homepage: https://github.com/juliankahlert/revtree
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.2.33
+signing_key: 
+specification_version: 4
+summary: A tool to build and compare file trees with revisions.
+test_files: []