claiss 1.1.2 → 1.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b196fd14a391ce3804f055af6109513aa11d3b9555a31bcd0cdfcd99aebf4e3d
-  data.tar.gz: 7dd699a7ea98feeb55c974a726ff0d40a8b239d960e21bd3ebc6d994883c29cf
+  metadata.gz: 0717123d37af9bf85c7fb958ec88949a9a4b9275eb703e8e38dd7940705e59d0
+  data.tar.gz: ac451a336575e5832c26532db241cce0fe8a74eaf01a43ae2fff294b666e1461
 SHA512:
-  metadata.gz: 3886071f8e207af613f1e9da94e29fc72f6d95e7f3ca3e79e2e9e3f19b72b2f37c59c3375625feed9440329d07387d1fb1dea7cf4f4f1a98a16c8d3ce5307748
-  data.tar.gz: 44cafb7662557876102c52385966d4712b1cd58448c77bc5228ff60ed18263072682055eb64a438cdd3cce8f59b59fb58f506380f3f7048570d14c6c49651680
+  metadata.gz: d753b2af4c9ce85474b0a1bb66d35d0b0ae5e6aa1601dcd81484571155beae2daae314a545122b39f6928e5c97aadd4c60d7221a29fb8563d5feb7b578c8665a
+  data.tar.gz: bc58050fe555a8b8af015dc5efa50716168b642dfb4fe3b682edc8847aefdacefef5d0b3bef581169750ab2efcedded9c66880aec29683cce77a179d16e11d9f

data/README.md

@@ -1,6 +1,6 @@
 # CLAISS CLI Refactor Application Toolbox
 
-**CLAISS** is a Ruby-based CLI application and toolbox designed to manage CLAISS Refactored applications and deployments. Please note that some features may have limited compatibility depending on the environment. 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
 
@@ -21,53 +21,97 @@ The `refactor` command allows you to rename and replace text terms within files
 Basic usage:
 
 ```sh
-$ claiss refactor ./project/ ./my_changes.json
+$ 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)
+
+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 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.
 
-Example `my_changes.json`:
+The JSON file should be placed in the `~/.claiss/` directory by default.
+
+Example `~/.claiss/my_project.json`:
 
 ```json
 {
-    "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"
+    "old_term": "new_term",
+    "OldClassName": "NewClassName",
+    "OLD_CONSTANT": "NEW_CONSTANT"
 }
 ```
 
-To apply the changes using the dictionary file:
+#### New Features and Improvements
 
-```sh
-$ claiss refactor ./project/ ./my_changes.json
-```
+1. **Progress Bar**: The refactoring process now displays a progress bar, giving you a visual indication of the operation's status.
 
-**Important:** After refactoring, any empty directories left behind will be automatically removed to keep your project structure clean.
+2. **Parallel Processing**: Large projects are now processed using parallel execution, significantly improving performance on multi-core systems.
+
+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 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 ./project/
+$ claiss fix_ruby_permissions [path]
+```
+
+- `[path]`: Path to the Ruby project (optional, default: current directory)
+
+Example:
+
+```sh
+$ claiss fix_ruby_permissions
+$ claiss fix_ruby_permissions path/to/ruby/project
 ```
 
 **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 are continuously 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
 
@@ -79,4 +123,4 @@ This gem is available as open source under the terms of the [MIT License](https:
 
 ## Author
 
-Júlio Papel
+Júlio Papel

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.2"
+    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,84 +27,159 @@ 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)
-
-      process_files(origin_path, dict)
-      remove_empty_directories(origin_path)
-
-      puts "Done! Files have been refactored in place."
+      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
 
     private
 
-    def load_dictionary(json_file)
-      if json_file
-        JSON.parse(File.read(json_file))
-      else
-        interactive_dictionary
+    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
 
-    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_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
-      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)
-        next if file_name.include?(".git/") || file_name.include?("node_modules/") # Ignore .git and node_modules folders
-        process_file(file_name, dict)
+    def load_dictionary(json_file)
+      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 process_file(file_name, dict)
-      text = File.read(file_name)
-
-      dict.each do |search, replace|
-        text.gsub!(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
+    end
 
-      new_file_name = file_name.dup
-
+    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|
-        new_file_name.gsub!(search, replace)
+        if text.gsub!(/#{Regexp.escape(search)}/, replace)
+          text_changed = true
+        end
       end
-
-      # Create the directory for the new file if it doesn't exist
+    
+      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
 
-      # Write the changes to the new file name
-      File.write(new_file_name, text)
-
-      # If the filename has changed, delete the original file
-      unless new_file_name == file_name
-        File.delete(file_name) # Delete the original file
-        puts "File renamed from #{file_name} to #{new_file_name}, OK"
-      else
-        puts "File: #{file_name}, OK"
+    def replace_in_path(path, dict)
+      dict.reduce(path) do |s, (search, replace)|
+        s.gsub(/#{Regexp.escape(search)}/, replace)
       end
     end
 
-    def remove_empty_directories(origin_path)
-      Dir.glob(File.join(origin_path, '**', '*'), File::FNM_DOTMATCH).reverse_each do |dir_name|
+    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 dir_name.include?(".git/") || dir_name.include?("node_modules/") # Ignore .git and node_modules folders
+        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}"
@@ -101,13 +188,65 @@ module CLAISS
     end
   end
 
+  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|
@@ -123,31 +262,27 @@ module CLAISS
       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)
-      current_permissions = File.stat(file).mode
-
-      if current_permissions & 0o100 != 0 # Check if the owner has execute permission
-        File.chmod(0755, file) # Maintain execution permission for owner, group, and others
-      elsif current_permissions & 0o010 != 0 # Check if the group has execute permission
-        File.chmod(0755, file) # Maintain execution permission for group and others
-      elsif current_permissions & 0o001 != 0 # Check if others have execute permission
-        File.chmod(0755, file) # Maintain execution permission for others
+      if File.extname(file) == '.rb' || file.include?('/bin/')
+        File.chmod(0755, file)
       else
-        File.chmod(0644, file) # Otherwise, apply standard read/write permissions
+        File.chmod(0644, file)
       end
     end
   end
-
 end
 
 require_relative "claiss/version"
 require_relative "claiss/commands"
-require_relative "claiss/cli"
+require_relative "claiss/cli"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: claiss
 version: !ruby/object:Gem::Version
-  version: 1.1.2
+  version: 1.1.3
 platform: ruby
 authors:
 - Júlio Papel
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-08-09 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
@@ -89,8 +117,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.3
-signing_key: 
+rubygems_version: 3.1.2
+signing_key:
 specification_version: 4
 summary: CLAISS AI CLI application Toolbox
 test_files: []