claiss 1.1.1 → 1.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4676e0b9c189aef43c1e7fc47b8335e6b06326a7037b8c5c8bc43d546fec9e03
-  data.tar.gz: 1b0aced8f24d95a68a9b3b378d70562020d9c1b0f32be955e5d7b98f291e4fe9
+  metadata.gz: 0717123d37af9bf85c7fb958ec88949a9a4b9275eb703e8e38dd7940705e59d0
+  data.tar.gz: ac451a336575e5832c26532db241cce0fe8a74eaf01a43ae2fff294b666e1461
 SHA512:
-  metadata.gz: daaec06de788e6d5710b17094fcb7948365fdec7099fff35da7a89dfe4aba78bff7ef9b1114836196eddfba7b490bb7d42177248d39778006516b0879c5ef55d
-  data.tar.gz: b8f1c356aa5f6d8b1b94bed86c085b8f6035fa1fd324d945c1879a0cd2de29141c36854b1ca4a13cfc89b9b04f6a3b1107373a21ad0b7a496ba3fdb1ad12c61e
+  metadata.gz: d753b2af4c9ce85474b0a1bb66d35d0b0ae5e6aa1601dcd81484571155beae2daae314a545122b39f6928e5c97aadd4c60d7221a29fb8563d5feb7b578c8665a
+  data.tar.gz: bc58050fe555a8b8af015dc5efa50716168b642dfb4fe3b682edc8847aefdacefef5d0b3bef581169750ab2efcedded9c66880aec29683cce77a179d16e11d9f

data/README.md

@@ -1,56 +1,117 @@
-# CLAISS AI CLI Application Toolbox
+# CLAISS CLI Refactor Application Toolbox
 
-CLAISS is a Ruby CLI application & Toolbox to manage CLAISS AI applications and deployments. Please note that some features may not work in all environments. Use with caution!
+**CLAISS** is a Ruby-based CLI application and toolbox designed to manage CLAISS Refactored applications and deployments. It provides powerful refactoring capabilities with improved performance and safety features. Please note that some features may have limited compatibility depending on the environment. Use with caution!
 
 ## Installation
 
-Install the gem by running the following command in your terminal:
+Install the CLAISS gem by running the following command in your terminal:
 
-Copy
-
-`$ gem install claiss`
+```sh
+$ gem install claiss
+```
 
 ## Usage
 
 ### Refactor
 
-The `refactor` command changes text terms in files within a folder, creating a new "refactored-..." folder with the modified files. Note that this command will change all exact occurrences of the specified terms. For example, "Abc" is treated differently from "AbC " or " ABc" or "abc" or "ABC".
+The `refactor` command allows you to rename and replace text terms within files and filenames in a specified directory. This command will refactor all exact occurrences of specified terms, including filenames. For example, "Abc" is treated differently from "AbC", "ABc", or "abc".
+
+**Note:** The `refactor` command ignores the `.git/` and `node_modules/` directories to avoid modifying critical or third-party files.
 
 Basic usage:
 
-Copy
+```sh
+$ claiss refactor <path> <rules>
+```
+
+- `<path>`: Path to the directory to refactor (required)
+- `<rules>`: Name of the rules file (without .json extension) (required)
+- `--destination`: Destination path for refactored files (optional)
 
-`$ claiss refactor ./project/`
+Examples:
+
+```sh
+$ claiss refactor path/to/project my_project
+$ claiss refactor path/to/project my_project --destination path/to/output
+```
 
 #### Using a JSON Dictionary
 
-You can create a JSON file with a list of terms to refactor. This file should be formatted as a one-level JSON object. The terms are processed in order from top to bottom.
+You can create a JSON file that specifies the terms you want to refactor. This JSON file should be structured as a simple key-value pair object, where each key is the term to be replaced and the value is the replacement term. The terms are processed in the order they appear in the file.
+
+The JSON file should be placed in the `~/.claiss/` directory by default.
 
-Example `myapp.json` file:
+Example `~/.claiss/my_project.json`:
 
-Copy
+```json
+{
+    "old_term": "new_term",
+    "OldClassName": "NewClassName",
+    "OLD_CONSTANT": "NEW_CONSTANT"
+}
+```
 
-`{  "system pro": "system b2b", "System Pro": "System B2b", "System": "Laiss", "system": "laiss", "2010 Moevo Silver": "2023 Júlio Papel", "Jared Moevo": "Júlio Papel", "3dtester@gmail.com": "info@mynewsite.pt", "https://somelivesite.com": "https://api.mynewsite.pt", "This is your Rails project.": "Multi Layered Software Services.", "This is your Rails project for your business.": "A Multi Layered Software Services ready to be deployed for any business.", "MIT-LICENSE": "LICENSE", "https://somesite.com": "https://api.mynewsite.pt" }`
+#### New Features and Improvements
 
-To use this dictionary file:
+1. **Progress Bar**: The refactoring process now displays a progress bar, giving you a visual indication of the operation's status.
 
-Copy
+2. **Parallel Processing**: Large projects are now processed using parallel execution, significantly improving performance on multi-core systems.
 
-`$ claiss refactor ./project/ ./myapp.json`
+3. **Improved Encoding Handling**: The tool now better handles files with different encodings, falling back to binary reading for files with invalid UTF-8 sequences.
+
+4. **Truncated Logging**: Log messages now show truncated file paths for improved readability, especially in projects with deep directory structures.
+
+5. **Automatic Cleanup**: After refactoring, any empty directories left behind are automatically removed to keep your project structure clean.
 
 ### Fix Ruby Permissions
 
-The `fix_ruby_permissions` command adjusts file permissions for a Ruby & Rails project:
+The `fix_ruby_permissions` command adjusts file permissions for a Ruby or Rails project. It ensures that directories have the correct execute permissions and that files retain their appropriate read/write/execute permissions.
+
+```sh
+$ claiss fix_ruby_permissions [path]
+```
+
+- `[path]`: Path to the Ruby project (optional, default: current directory)
 
-Copy
+Example:
 
-`$ claiss fix_ruby_permissions ./refactored-1688375056/`
+```sh
+$ claiss fix_ruby_permissions
+$ claiss fix_ruby_permissions path/to/ruby/project
+```
 
-**Note:** This command uses `chmod` and may not work correctly on systems that support filename spaces and ignore capitals (like some end-user operating systems). For example, a file called 'MyImage copy.svg' may cause errors. In such cases, manually fix the permissions for problematic files and then re-run the command.
+**Note:** This command uses `chmod` and may encounter issues on systems that do not distinguish between uppercase and lowercase filenames or support spaces in filenames (e.g., certain end-user operating systems). If you encounter errors, particularly with filenames like `MyImage copy.svg`, manually fix those file permissions and re-run the command.
+
+### Generate JSON
+
+The `generate_json` command helps create a new JSON file with an empty key-value pair for refactoring:
+
+```sh
+$ claiss generate_json [options]
+```
+
+Options:
+- `--output`: Name of the output JSON file (default: rules)
+- `--path`: Path to save the JSON file (default: ~/.claiss/)
+
+Examples:
+
+```sh
+$ claiss generate_json
+$ claiss generate_json --output my_custom_rules
+$ claiss generate_json --path /custom/path/ --output my_rules
+```
+
+This command generates a new JSON file that can be used as a template for creating refactoring rules.
 
 ## Upcoming Features
 
-We're continually working to improve CLAISS and add new functionalities. Stay tuned for updates!
+We are continuously working to improve CLAISS and add new functionalities. Some planned features include:
+
+1. Enhanced error handling and reporting
+2. Support for more complex refactoring rules
+
+Stay tuned for updates!
 
 ## Contributing
 
@@ -58,7 +119,7 @@ Bug reports and pull requests are welcome on GitHub at [https://github.com/Julio
 
 ## License
 
-The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+This gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
 
 ## Author
 

data/lib/claiss/commands.rb

@@ -1,9 +1,10 @@
 module CLAISS
-    module Commands
-      extend Dry::CLI::Registry
-  
-      register "version", Version, aliases: ["v", "-v", "--version"]
-      register "refactor", Refactor
-      register "fix_ruby_permissions", FixRubyPermissions
-    end
-  end
+  module Commands
+    extend Dry::CLI::Registry
+
+    register "version", CLAISS::Version, aliases: ["v", "-v", "--version"]
+    register "refactor", CLAISS::Refactor
+    register "fix_ruby_permissions", CLAISS::FixRubyPermissions
+    register "generate_json", CLAISS::GenerateJson
+  end
+end

data/lib/claiss/version.rb

@@ -1,3 +1,3 @@
 module CLAISS
-    VERSION = "1.1.1"
-  end
+    VERSION = "1.1.3"
+  end

data/lib/claiss.rb

@@ -1,9 +1,21 @@
-require "bundler/setup"
 require "dry/cli"
-require "fileutils"
+require "bundler/setup"
+require 'pathname'
 require 'json'
+require "fileutils"
+require 'logger'
+require 'parallel'
+require 'ruby-progressbar'
 
+# CLAISS module provides CLI commands for refactoring and managing Ruby projects
 module CLAISS
+  IGNORED_DIRECTORIES = [".git/", "node_modules/"]
+  DEFAULT_JSON_DIR = File.join(Dir.home, '.claiss')
+
+    # Initialize logger
+    LOGGER = Logger.new(STDOUT)
+    LOGGER.level = Logger::INFO  # Set to Logger::DEBUG for more verbose output  
+
   class Error < StandardError; end
 
   class Version < Dry::CLI::Command
@@ -15,90 +27,258 @@ module CLAISS
   end
 
   class Refactor < Dry::CLI::Command
-    desc "Refactors terms and files on directories"
-    argument :path, type: :string, required: true, desc: "Relative path directory"
-    argument :json_file, type: :string, desc: "Provide a JSON file with replacement rules"
-
-    def call(path:, json_file: nil, **)
-      dict = load_dictionary(json_file)
+    desc "Refactor files and filenames"
+  
+    argument :path, type: :string, required: true, desc: "Path to the directory to refactor"
+    argument :rules, type: :string, required: true, desc: "Name of the rules file (without .json extension)"
+    option :destination, type: :string, desc: "Destination path for refactored files"
+  
+    example [
+      "path/to/project autokeras",
+      "path/to/project autokeras --destination path/to/output"
+    ]
+  
+    def call(path:, rules:, destination: nil, **)
       origin_path = File.expand_path(path)
-      destination_path = File.expand_path("./refactored-#{Time.now.to_i}")
+      destination_path = destination ? File.expand_path(destination) : nil
+      
+      json_file = File.join(DEFAULT_JSON_DIR, "#{rules}.json")
+      dict = load_dictionary(json_file)
+  
+      files = get_files_to_process(origin_path)
+      process_files_in_parallel(files, dict, origin_path, destination_path)
+      remove_empty_directories(destination_path || origin_path)
+  
+      puts "Done! Files have been refactored#{destination_path ? ' to the destination' : ' in place'}."
+    end
 
-      dict[origin_path] = destination_path
-      process_files(origin_path, dict)
+    private
 
-      puts "Done! Your project is in the #{destination_path} folder"
+    def get_files_to_process(origin_path)
+      Dir.glob(File.join(origin_path, '**', '*'), File::FNM_DOTMATCH).reject do |file_name|
+        File.directory?(file_name) || IGNORED_DIRECTORIES.any? { |dir| file_name.include?(dir) }
+      end
     end
 
-    private
+    def process_files_in_parallel(files, dict, origin_path, destination_path)
+      progress_bar = ProgressBar.create(
+        total: files.size,
+        format: "%a %b\u{15E7}%i %p%% %t",
+        progress_mark: ' ',
+        remainder_mark: "\u{FF65}"
+      )
+  
+      Parallel.each(files, in_threads: Parallel.processor_count) do |file_name|
+        refactor_file(file_name, dict, origin_path, destination_path)
+        progress_bar.increment
+      end
+    end
 
     def load_dictionary(json_file)
-      if json_file
-        JSON.parse(File.read(json_file))
-      else
-        interactive_dictionary
+      LOGGER.info("Attempting to load dictionary from: #{json_file}")
+      
+      unless File.exist?(json_file)
+        error_message = "JSON file not found: #{json_file}"
+        LOGGER.error(error_message)
+        raise Errno::ENOENT, error_message
+      end
+    
+      begin
+        file_content = File.read(json_file)
+        LOGGER.debug("File content: #{file_content}")
+        
+        parsed_content = JSON.parse(file_content)
+        LOGGER.info("Successfully parsed JSON file")
+        
+        if parsed_content.empty?
+          LOGGER.warn("The loaded dictionary is empty")
+        else
+          LOGGER.info("Loaded dictionary with #{parsed_content.size} key-value pairs")
+        end
+        
+        parsed_content
+      rescue JSON::ParserError => e
+        error_message = "Error parsing JSON file '#{json_file}': #{e.message}"
+        LOGGER.error(error_message)
+        LOGGER.debug("JSON content that failed to parse: #{file_content}")
+        raise JSON::ParserError, error_message
+      rescue StandardError => e
+        error_message = "Unexpected error while loading dictionary from '#{json_file}': #{e.message}"
+        LOGGER.error(error_message)
+        LOGGER.debug(e.backtrace.join("\n"))
+        raise
       end
     end
 
-    def interactive_dictionary
-      dict = {}
-      loop do
-        print "Term to search (or press Enter to finish): "
-        search = STDIN.gets.chomp
-        break if search.empty?
-        print "Term to replace: "
-        replace = STDIN.gets.chomp
-        dict[search] = replace
+    def process_files(origin_path, dict, destination_path)
+      Dir.glob(File.join(origin_path, '**', '*'), File::FNM_DOTMATCH) do |file_name|
+        next if File.directory?(file_name)
+        next if IGNORED_DIRECTORIES.any? { |dir| file_name.include?(dir) }
+        refactor_file(file_name, dict, origin_path, destination_path)
       end
-      dict
     end
 
-    def process_files(origin_path, dict)
-      Dir.glob(File.join(origin_path, "**", "*"), File::FNM_DOTMATCH).each do |file_name|
-        next if File.directory?(file_name)
-        process_file(file_name, dict)
+    def refactor_file(file_name, dict, origin_path, destination_path)
+      begin
+        # First, try to read the file as UTF-8
+        text = File.read(file_name, encoding: 'UTF-8')
+      rescue Encoding::InvalidByteSequenceError
+        # If UTF-8 reading fails, fall back to binary reading and force UTF-8 encoding
+        # This approach helps handle files with mixed or unknown encodings
+        truncated_file_name = File.basename(file_name)
+        LOGGER.warn("Invalid UTF-8 byte sequence in ...#{truncated_file_name}. Falling back to binary reading.")
+        text = File.read(file_name, encoding: 'BINARY')
+        text.force_encoding('UTF-8')
+        # Replace any invalid or undefined characters with empty string
+        text.encode!('UTF-8', invalid: :replace, undef: :replace, replace: '')
+      end
+    
+      text_changed = false
+      dict.each do |search, replace|
+        if text.gsub!(/#{Regexp.escape(search)}/, replace)
+          text_changed = true
+        end
+      end
+    
+      relative_path = Pathname.new(file_name).relative_path_from(Pathname.new(origin_path))
+      new_relative_path = replace_in_path(relative_path.to_s, dict)
+      
+      if destination_path
+        new_file_name = File.join(destination_path, new_relative_path)
+      else
+        new_file_name = File.join(origin_path, new_relative_path)
+      end
+    
+      new_dir = File.dirname(new_file_name)
+      FileUtils.mkdir_p(new_dir) unless File.directory?(new_dir)
+    
+      if text_changed || new_file_name != file_name
+        File.write(new_file_name, text)
+        if destination_path || new_file_name != file_name
+          truncated_old = "...#{File.basename(file_name)}"
+          truncated_new = "...#{File.basename(new_file_name)}"
+          LOGGER.info("File #{destination_path ? 'copied' : 'renamed'} from #{truncated_old} to #{truncated_new}")
+        else
+          truncated_file = "...#{File.basename(file_name)}"
+          LOGGER.info("File contents updated: #{truncated_file}")
+        end
+        File.delete(file_name) if !destination_path && new_file_name != file_name
       end
+    rescue => e
+      truncated_file = "...#{File.basename(file_name)}"
+      LOGGER.error("Error processing file #{truncated_file}: #{e.message}")
+      LOGGER.debug(e.backtrace.join("\n"))
     end
 
-    def process_file(file_name, dict)
-      destination = file_name.gsub(dict.keys.first, dict.values.first)
-      text = File.read(file_name)
+    def replace_in_path(path, dict)
+      dict.reduce(path) do |s, (search, replace)|
+        s.gsub(/#{Regexp.escape(search)}/, replace)
+      end
+    end
 
-      dict.each do |search, replace|
-        destination.gsub!(search, replace)
-        text.gsub!(search, replace)
+    def remove_empty_directories(path)
+      Dir.glob(File.join(path, '**', '*'), File::FNM_DOTMATCH).reverse_each do |dir_name|
+        next unless File.directory?(dir_name)
+        next if IGNORED_DIRECTORIES.any? { |ignored_dir| dir_name.include?(ignored_dir) }
+        if (Dir.entries(dir_name) - %w[. ..]).empty?
+          Dir.rmdir(dir_name)
+          puts "Removed empty directory: #{dir_name}"
+        end
       end
+    end
+  end
 
-      FileUtils.mkdir_p(File.dirname(destination))
-      File.write(destination, text)
-      puts "File: #{destination}, OK"
+  class GenerateJson < Dry::CLI::Command
+    desc "Generate a new JSON file with an empty key-value pair"
+  
+    option :output, type: :string, default: "rules", desc: "Name of the output JSON file (default: rules)"
+    option :path, type: :string, desc: "Path to save the JSON file (default: ~/.claiss/)"
+  
+    example [
+      "",
+      "--output my_custom_rules",
+      "--path /custom/path/ --output my_rules"
+    ]
+  
+    def call(path:, rules:, destination: nil, **)
+      origin_path = File.expand_path(path)
+      destination_path = destination ? File.expand_path(destination) : nil
+      
+      json_file = File.join(DEFAULT_JSON_DIR, "#{rules}.json")
+      
+      begin
+        dict = load_dictionary(json_file)
+      rescue Errno::ENOENT => e
+        puts e.message
+        puts "Please make sure the JSON file exists in the ~/.claiss directory."
+        exit(1)
+      rescue JSON::ParserError => e
+        puts e.message
+        puts "Please check the JSON file for syntax errors."
+        exit(1)
+      rescue StandardError => e
+        puts "An unexpected error occurred: #{e.message}"
+        puts "Please check the log for more details."
+        exit(1)
+      end
+    
+      process_files(origin_path, dict, destination_path)
+      remove_empty_directories(destination_path || origin_path)
+    
+      puts "Done! Files have been refactored#{destination_path ? ' to the destination' : ' in place'}."
+    end
+
+    private
+
+    def ensure_json_extension(filename)
+      return filename if filename.end_with?('.json')
+      "#{filename}.json"
     end
   end
 
   class FixRubyPermissions < Dry::CLI::Command
     desc "Fix permissions for a Ruby project"
-    argument :path, required: true, desc: "The path of your Ruby project"
 
-    def call(path: nil, **)
-      path ||= Dir.getwd
+    argument :path, type: :string, required: false, default: ".", desc: "Path to the Ruby project (default: current directory)"
+
+    example [
+      "",
+      "path/to/ruby/project"
+    ]
+
+    def call(path: ".", **)
       path = File.expand_path(path)
 
       Dir.glob(File.join(path, '**', '*'), File::FNM_DOTMATCH) do |item|
         next if item == '.' || item == '..'
+        next if item.include?("node_modules/") # Ignore node_modules folder
         if File.directory?(item)
           File.chmod(0755, item)
         else
-          File.chmod(0644, item)
+          fix_file_permissions(item)
         end
       end
 
       executable_files = ['bundle', 'rails', 'rake', 'spring']
       executable_files.each do |file|
         file_path = File.join(path, 'bin', file)
-        File.chmod(0755, file_path) if File.exist?(file_path)
+        if File.exist?(file_path)
+          File.chmod(0755, file_path)
+          puts "Made #{file_path} executable"
+        end
       end
 
-      puts "Permissions fixed for #{path}"
+      puts "Permissions fixed for Ruby project at #{path}"
+    end
+
+    private
+
+    def fix_file_permissions(file)
+      if File.extname(file) == '.rb' || file.include?('/bin/')
+        File.chmod(0755, file)
+      else
+        File.chmod(0644, file)
+      end
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: claiss
 version: !ruby/object:Gem::Version
-  version: 1.1.1
+  version: 1.1.3
 platform: ruby
 authors:
 - Júlio Papel
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-06-25 00:00:00.000000000 Z
+date: 2024-11-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dry-cli
@@ -52,6 +52,34 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 2.6.3
+- !ruby/object:Gem::Dependency
+  name: parallel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.26.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.26.3
+- !ruby/object:Gem::Dependency
+  name: ruby-progressbar
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.13.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.13.0
 description: CLI application Toolbox to manage CLAISS AI applications and deployments.
   Some features may not work in all environments. Use with caution!
 email:
@@ -74,7 +102,7 @@ licenses:
 metadata:
   source_code_uri: https://github.com/JulioPapel/claiss.git
   documentation_uri: https://github.com/JulioPapel/claiss/blob/main/readme.md
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -90,7 +118,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubygems_version: 3.1.2
-signing_key: 
+signing_key:
 specification_version: 4
 summary: CLAISS AI CLI application Toolbox
 test_files: []