readlines 1.5 → 1.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1b5fb4edb74d65584c625105a679e4a9d7523bdd5437ef733932c46b888723b5
-  data.tar.gz: 9608ee45bc3e1f89f684f37edd1c69ef9d901918d09a0b5bc404aca13aafcfc4
+  metadata.gz: '01780b8ba53d712f49e869f05f707205cd2cc6206fe004a05c89b6adba755f8e'
+  data.tar.gz: 9af6c1d19859490a0727bc0e4e7a4e51810f0acc8d49c003ebdb7dc29b44fc41
 SHA512:
-  metadata.gz: 4c5df729b5497190c5aa8ad6fb880d96fdd50e6f17cd94f3cee9380cf7b420808f4855603387880a854a76ae0420dde7bddf1d26a682383a4d1b578b810dfe19
-  data.tar.gz: 1ec0f06aa5b3851f15bbf65b888888e38672cf3ab3dde593564f0a55f589c99e687ad25194f8c8275a855c98132ef4b07e91aa1fbea73a37adebfb8836433258
+  metadata.gz: 05b2d6972fcd9f373d730d37678c0ab726fc9d8e3a07c37d1b9864832b3d6657bf5ceb46a786ea24de0c7e67904861b559d32ae8b3ff163af9ad96319a0c7564
+  data.tar.gz: 637d2e9a9dca27799fa10504ce4c570095e6e773e07c9c3d90388f747ebc313650b8f1b8ac74c093d351e5e64228d0e06c13a44f9fc38dc2f8d4337e6e7a9631

data/README.md

@@ -5,346 +5,197 @@ Readlines is a powerful and versatile Ruby library for file manipulation and pro
 
 ## Features
 
-- Read the entire file content or specific parts of it.
-- Search for specific values in the file and display matching line numbers.
-- Count the number of lines in the file based on a keyword or delimiter.
-- Replace specific patterns in the file with replacement text.
-- Remove empty lines from the file.
-- Sort the lines of the file alphabetically.
-- Split the file into a specified number of parts.
-- Merge multiple files into a single file.
-- Convert the encoding of the file from one encoding to another.
-- Replace special characters in the file with a replacement string.
-- Remove unwanted characters from the file.
-- Split the file by a specified size.
-- Convert the file to a specified format (txt, csv, json).
-- Search for multiple patterns in the file and count occurrences of each pattern.
-- Replace multiple patterns in the file in a single operation.
-- Split the file based on a specified delimiter.
-- Merge multiple files into a single file with a specified separator between each file's content.
-- Check if a specific pattern exists in the file.
-- Delete specific lines from the file with the option to remove resulting empty lines.
-- Reverse the order of the file contents.
-- Search for a pattern within a specified range of lines.
-- Count the number of characters in the file or in a specific line.
-- Count the number of words in the file or in a specific line.
-- Extract specific patterns from the file.
-- Convert the file contents into an array of lines.
-- Validate the file contents against a set of rules.
-- Remove duplicate lines from the file.
-- Get statistics about the file (number of lines, characters, words).
-- Search for logical patterns in the file using AND and OR operators.
-- Split the file based on a specified pattern.
-- Delete specific columns from a CSV file.
-- Replace a specific value in a CSV column.
-- Check for spelling errors in the file using a dictionary.
-- Encrypt the file contents using a key.
-- Decrypt the encrypted file contents using a key.
-- Get the file size in different units (bytes, kilobytes, megabytes, gigabytes).
+- **File Reading**: Read the entire file content or specific parts.
+- **Search Operations**: Search for values and display matching line numbers.
+- **Line Counting**: Count lines based on keywords or delimiters.
+- **Pattern Replacement**: Replace specific patterns or multiple patterns at once.
+- **Delete Empty Lines**: Remove empty lines.
+- **Alphabetical Sorting**: Sort lines alphabetically.
+- **File Splitting**: Split files into parts or by size.
+- **File Merging**: Merge multiple files with a separator.
+- **Encoding Conversion**: Convert file encoding.
+- **Character Replacement**: Replace special characters or unwanted characters.
+- **Format Conversion**: Convert the file to txt, csv, or json.
+- **Multiple Pattern Search**: Search and count multiple patterns.
+- **Delimiter-Based Splitting**: Split files by delimiter or pattern.
+- **Pattern Checking**: Check if patterns exist.
+- **Delete Specific Lines**: Delete lines, specific columns in CSV, and duplicates.
+- **Reverse Content**: Reverse the file’s content.
+- **Range-Based Search**: Search within a specific line range.
+- **Character and Word Counting**: Count characters or words.
+- **Pattern Extraction**: Extract specific patterns.
+- **Content Validation**: Validate against custom rules.
+- **Logical Pattern Search**: AND/OR based pattern search.
+- **Spelling Check**: Detect spelling errors with a dictionary.
+- **Encryption/Decryption**: Encrypt and decrypt content.
+- **File Size Calculation**: Display size in bytes, KB, MB, or GB.
+- **Filter Operation**: Delete or replace lines based on matching criteria (`:start`, `:body`, or `:end`).
 
 ## Installation
 
-To use the Readlines library in your Ruby project, you can install it via RubyGems. Run the following command:
+To use the Readlines library in your Ruby project, install it via RubyGems:
 
-```
+```bash
 gem install readlines
 ```
 
-Alternatively, you can add the following line to your project's Gemfile:
+Or add it to your Gemfile:
 
 ```ruby
 gem 'readlines'
 ```
 
-Then, run `bundle install` to install the library and its dependencies.
+Run `bundle install` to install the library and its dependencies.
 
 ## Usage
 
-To start using the Readlines library, require it in your Ruby script:
+Start by requiring `readlines` in your Ruby script:
 
 ```ruby
-require 'readlines'
+require 'readlines/read'
 ```
 
-Create an instance of the `Read` class, providing the path to the file you want to work with:
+Create an instance of the `Readlines::ReadDuc` class with the filename (or full path):
 
 ```ruby
-file_path = '/path/to/your/file.txt'
-read = Read.new(file_path)
+file_name = 'file.txt'
+read = Readlines::ReadDuc.new(file_name)
 ```
 
-Now you can use the various methods provided by the library to manipulate and process the file contents. Here are some examples:
+### Examples
+
+#### Search for a specific word and count occurrences
+
 ```ruby
-# imagen you have file inside of it data like this and you want count all data of names how manually no you can use this method and that will count for you body 😁
-# ++++++++++++++++++++++++++++++++++++
-# name : 'john'
-# phone : '+1 332-332-3322'
-#++++++++++++++++++++++++++++++++++++
-read = Read.new(file_path, count: 'name', split: '++++++++++++++++++++++++++++++++++++')
-puts read.line_count
+# Search for the word "example" in the file
+read = Readlines::ReadDuc.new('data.txt')
+results = read.search_about('example', show_lines: true)
+
+# Display the number of occurrences
+puts "Number of occurrences: #{results.count}"
 ```
+
+#### Basic Operations
+
 ```ruby
 # Read the entire file content
 content = read.read_lines
 puts content
 ```
+
+#### Counting Operations
+
 ```ruby
-# Search for a specific value in the file and display matching line numbers
-value = 'example'
-result = read.search_about(value, show_lines: true)
-puts result
-```
-```ruby
-# Count the number of lines in the file based on a keyword or delimiter
-keyword = 'example'
-delimiter = '---'
-count = read.line_count(count: keyword, split: delimiter)
-puts count
-```
-```ruby
-# Replace specific patterns in the file with replacement text
-pattern = /example/
-replacement = 'new_example'
-updated_content = read.replace(pattern, replacement)
-puts updated_content
+# Count characters in the file or a specific line
+total_characters = read.character_count
+puts total_characters
+line_characters = read.character_count(line_specific: 3)
+puts line_characters
+
+# Count words in the file or a specific line
+total_words = read.word_count
+puts total_words
+line_words = read.word_count(line_specific: 3)
+puts line_words
 ```
+
+#### Replacement Operations
+
 ```ruby
-# Remove empty lines from the file
-updated_content = read.remove_empty_lines
+# Replace specific patterns in the file
+updated_content = read.replace(/example/, 'new_example')
 puts updated_content
-```
-```ruby
-# Sort the lines of the file alphabetically
-sorted_content = read.sort_alphabetically
-puts sorted_content
-```
-```ruby
-# Split the file into a specified number of parts
-num_parts = 3
-read.split_file(num_parts)
-```
-```ruby
-# Merge multiple files into a single file
-file_paths = ['/path/to/file1.txt', '/path/to/file2.txt']
-merged_file = read.merge_files(file_paths)
-puts merged_file
-```
-```ruby
-# Convert the encoding of the file from one encoding to another
-from_encoding = 'UTF-8'
-to_encoding = 'ISO-8859-1'
-read.convert_encoding(from_encoding, to_encoding)
-```
-```ruby
-# Replace special characters in the file with a replacement string
-replacement = '_'
-updated_content = read.replace_special_characters(replacement)
+
+# Replace multiple patterns at once
+pattern_replacement = {/example/ => 'new_example', /test/ => 'new_test'}
+updated_content = read.replace_multiple_patterns(pattern_replacement)
 puts updated_content
-```
-```ruby
-# Remove unwanted characters from the file
-unwanted_chars = '!@#$%^&*()'
-updated_content = read.remove_unwanted_characters(unwanted_chars)
+
+# Replace characters in a CSV column
+updated_csv = read.replace_csv_value(2, 'old_value', 'new_value')
+puts updated_csv
+
+# Replace special characters with a specified replacement string
+updated_content = read.replace_special_characters('_')
 puts updated_content
 ```
+
+#### Deletion Operations
+
 ```ruby
-# Split the file by a specified size
-part_size = 1024 # 1 KB
-read.split_file_by_size(part_size)
-```
-```ruby
-# Convert the file to a specified format
-format = 'csv'
-converted_file = read.convert_to_format(format)
-puts converted_file
-```
-```ruby
-# Search for multiple patterns in the file and count occurrences of each pattern
-patterns = [/example/, /pattern/]
-result = read.search_multiple_patterns(patterns)
-puts result
-```
-```ruby
-# Replace multiple patterns in the file in a single operation
-pattern_replacement_hash = {/example/ => 'new_example', /pattern/ => 'new_pattern'}
-updated_content = read.replace_multiple_patterns(pattern_replacement_hash)
+# Delete empty lines from the file
+updated_content = read.delete_empty_lines
 puts updated_content
-```
-```ruby
-# Split the file based on a specified delimiter
-delimiter = '---'
-read.split_by_delimiter(delimiter)
-```
-```ruby
-# Merge multiple files into a single file with a specified separator between each file's content
-file_paths = ['/path/to/file1.txt', '/path/to/file2.txt']
-separator = '---'
-merged_file = read.merge_files(file_paths, separator: separator)
-puts merged_file
-```
-```ruby
-# Check if a specific pattern exists in the file
-pattern = /example/
-exists = read.pattern_exists?(pattern)
-puts exists
-```
-```ruby
-# Delete specific lines from the file with the option to remove resulting empty lines
-line_numbers = [2, 4, 6]
-updated_content = read.delete_lines(line_numbers, delete_space: true)
+
+# Delete specific lines with the option to remove empty lines
+updated_content = read.delete_lines([2, 4, 6], delete_space: true)
 puts updated_content
-```
-```ruby
-# Reverse the order of the file contents
-reversed_content = read.reverse_content
-puts reversed_content
-```
-```ruby
-# Search for a pattern within a specified range of lines
-start_line = 5
-end_line = 10
-pattern = /example/
-matched_lines = read.search_in_range(start_line, end_line, pattern)
-puts matched_lines
-```
-```ruby
-# Count the number of characters in the file or in a specific line
-total_characters = read.character_count
-puts total_characters
 
-line_number = 3
-line_characters = read.character_count(line_specific: line_number)
-puts line_characters
-```
-```ruby
-# Count the number of words in the file or in a specific line
-total_words = read.word_count
-puts total_words
+# Delete unwanted characters
+updated_content = read.delete_unwanted_characters('!@#$%^')
+puts updated_content
 
-line_number = 3
-line_words = read.word_count(line_specific: line_number)
-puts line_words
-```
-```ruby
-# Extract specific patterns from the file
-patterns = [/email:\s*\S+/, /phone:\s*\S+/]
-extracted_data = read.extract_patterns(patterns)
-puts extracted_data
-```
-```ruby
-# Convert the file contents into an array of lines
-lines_array = read.convert_to_array
-puts lines_array
-```
-```ruby
-# Validate the file contents against a set of rules
-rules = [/^[A-Z]/, /\b\d{3}-\d{3}-\d{4}\b/]
-is_valid = read.validate_content(rules)
-puts is_valid
-```
-```ruby
-# Remove duplicate lines from the file
+# Delete duplicate lines
 unique_content = read.delete_duplicate_lines
 puts unique_content
-```
-```ruby
-# Get statistics about the file
-stats = read.file_statistics
-puts stats
-```
-```ruby
-# Search for logical patterns in the file using AND and OR operators
-patterns = [/example/, /pattern/]
-and_matched_lines = read.search_logical_patterns(patterns, 'AND')
-puts and_matched_lines
-```
-```ruby
-or_matched_lines = read.search_logical_patterns(patterns, 'OR')
-puts or_matched_lines
-```
-```ruby
-# Split the file based on a specified pattern
-pattern = /Chapter \d+:/
-read.split_by_pattern(pattern)
-```
-```ruby
-# Delete specific columns from a CSV file
-column_indices = [1, 3]
-updated_csv = read.delete_csv_columns(column_indices)
-puts updated_csv
-```
-```ruby
-# Replace a specific value in a CSV column
-column_index = 2
-old_value = 'old_value'
-new_value = 'new_value'
-updated_csv = read.replace_csv_value(column_index, old_value, new_value)
+
+# Delete specific columns in a CSV file
+updated_csv = read.delete_csv_columns([1, 3])
 puts updated_csv
 ```
-```ruby
-# Check for spelling errors in the file using a dictionary
-dictionary = ['example', 'pattern', 'file']
-misspelled_words = read.check_spelling(dictionary)
-puts misspelled_words
-```
-```ruby
-# Encrypt the file contents using a key
-key = 5
-encrypted_file = read.encrypt_content(key)
-puts encrypted_file
-```
-```ruby
-# Decrypt the encrypted file contents using a key
-encrypted_file_path = '/path/to/encrypted_file.txt'
-decrypted_file = read.decrypt_content(key, encrypted_file_path)
-puts decrypted_file
-```
-```ruby
-# Get the file size in different units
-file_size_bytes = read.file_size
-puts file_size_bytes
 
-file_size_kb = read.file_size(unit: :kilobytes)
-puts file_size_kb
+#### File Splitting and Merging
 
-file_size_mb = read.file_size(unit: :megabytes)
-puts file_size_mb
+```ruby
+# Split the file into 3 parts
+read.split_file(3)
 
-file_size_gb = read.file_size(unit: :gigabytes)
-puts file_size_gb
-```
+# Split by size (in bytes)
+read.split_file_by_size(1024) # 1 KB
 
-## Error Handling
+# Split by delimiter
+read.split_by_delimiter('---')
 
-The Readlines library provides custom error classes to handle specific exceptions:
+# Split by a pattern
+read.split_by_pattern(/Chapter \d+/)
 
-- `Readlines::Error`: General error class for all exceptions in the library.
-- `Readlines::NotFoundError`: Raised when a file is not found.
-- `Readlines::MissingFilePathError`: Raised when a file path is missing or empty.
-- `Readlines::InvalidUnitError`: Raised when an invalid unit is provided for file size conversion.
+# Merge multiple files
+merged_file = read.merge_files(['/path/to/file1.txt', '/path/to/file2.txt'])
+puts merged_file
 
-These error classes help in handling and debugging exceptions that may occur while using the library.
+# Merge files with a separator
+merged_file_with_separator = read.merge_files(['/file1.txt', '/file2.txt'], separator: '---')
+puts merged_file_with_separator
+```
 
-## Contributing
+#### Encoding and Format Conversion
 
-Contributions to the Readlines library are welcome! If you find any bugs, have suggestions for improvements, or want to add new features, please open an issue or submit a pull request on the [GitHub repository](https://github.com/abo5/readlines).
+```ruby
+# Convert encoding
+read.convert_encoding('UTF-8', 'ISO-8859-1')
 
-When contributing, please ensure that your code follows the existing coding style and includes appropriate tests.
+# Convert file format to CSV
+converted_csv = read.convert_to_format('csv')
+puts converted_csv
+```
 
-## License
+#### Error Handling
 
-The Readlines library is open-source and released under the [MIT License](https://opensource.org/licenses/MIT). You are free to use, modify, and distribute the library in accordance with the terms of the license.
+The Readlines library provides custom error classes for handling specific exceptions:
 
-## Contact
+- **Readlines::Error**: General error class for all exceptions.
+- **Readlines::NotFoundError**: Raised when the file is not found.
+- **Readlines::MissingFilePathError**: Raised when a file path is missing or empty.
+- **Readlines::InvalidUnitError**: Raised for invalid file size units.
 
-If you have any questions, suggestions, or feedback regarding the Readlines library, please feel free to contact the maintainer:
+These error classes help in handling and debugging exceptions that may occur while using the library.
 
-- Name: Maven
-- GitHub: [Maven's GitHub](https://github.com/abo5)
+## Contributing
 
-We appreciate your interest in the Readlines library and look forward to your contributions and feedback!
+Contributions are welcome! If you find bugs, have suggestions, or want to add features, please open an issue or submit a pull request on the [GitHub repository](https://github.com/abo5/readlines).
 
+When contributing, please ensure that your code follows the existing coding style and includes appropriate tests.
 
+## License
 
-# readlines
-# readlines
+The Readlines library is open-source and released under the [MIT License](https://opensource.org/licenses/MIT).

data/lib/readlines/read.rb

@@ -13,6 +13,7 @@ require_relative 'readlines/replace'
 require_relative 'readlines/search'
 require_relative 'readlines/sort'
 require_relative 'readlines/split'
+require_relative 'readlines/filter'
 require 'fileutils'
 require 'json'
 
@@ -24,6 +25,7 @@ module Readlines
     include Readlines::Search
     include Readlines::Replace
     include Readlines::File
+    include Readlines::Filter
     include Readlines::Merge
     include Readlines::Info
     include Readlines::Pattern
@@ -33,12 +35,17 @@ module Readlines
     attr_reader :file_path
 
     def initialize(file_path, count: nil, split: nil)
+      file_path = ::File.join(Dir.pwd, file_path) unless ::File.absolute_path?(file_path)
+  
+      raise Readlines::Error::MissingFilePathError, 'File not found at provided path' unless ::File.exist?(file_path)
       raise Readlines::Error::MissingFilePathError, 'You should provide a file path, e.g., "/path/to/file.txt"' if file_path.nil? || file_path.empty?
-
+    
+    
       @file_path = file_path
       @count_keyword = count
       @split_delimiter = split
     end
+    
 
     include Readlines::Count
     include Readlines::Delete
@@ -46,12 +53,14 @@ module Readlines
     include Readlines::Search
     include Readlines::Replace
     include Readlines::File
+    include Readlines::Filter
     include Readlines::Merge
     include Readlines::Info
     include Readlines::Pattern
     include Readlines::Sort
     include Readlines::Split
     include Readlines::Content
+    include Readlines::Filter
 
     # Count operations
     def line_count
@@ -220,6 +229,20 @@ module Readlines
       raise Readlines::Error::NotFoundError, "File not found: #{@file_path}" unless ::File.exist?(@file_path)
       file_statistics_now()
     end
+    
+    ## Replace and Delete lines from the file
+    def filter(value, query, operation, replacement = nil)
+      raise Readlines::Error::NotFoundError, "File not found: #{@file_path}" unless ::File.exist?(@file_path)
+
+      processed_lines = []
+      ::File.foreach(@file_path) do |line|
+        result = apply_filter(line, value, query, operation, replacement)
+        processed_lines << result if result 
+      end
+
+      ::File.write(@file_path, processed_lines.join)
+      processed_lines
+    end
 
     # Pattern operations
     def pattern_exists?(pattern)
@@ -260,4 +283,13 @@ module Readlines
       decrypt_content_now(key, encrypted_file_path)
     end
   end
-end
+
+  def filter(file_path, value, query, operation, replacement = nil)
+    processed_lines = []
+    File.foreach(file_path) do |line|
+      result = filter(line, value, query, operation, replacement)
+      processed_lines << result if result # Only add if result is not nil (for delete operation)
+    end
+    processed_lines
+  end
+end

data/lib/readlines/readlines/error.rb

@@ -2,12 +2,34 @@
 
 module Readlines
   module Error
-    class Error < StandardError; end
+    class BaseError < StandardError
+      def initialize(message = "An error occurred in Readlines")
+        super
+      end
+    end
 
-    class NotFoundError < Error; end
+    class NotFoundError < BaseError
+      def initialize(message = "File not found.")
+        super
+      end
+    end
 
-    class MissingFilePathError < Error; end
+    class MissingFilePathError < BaseError
+      def initialize(message = "File path is missing.")
+        super
+      end
+    end
 
-    class InvalidUnitError < StandardError; end
+    class InvalidUnitError < BaseError
+      def initialize(message = "Invalid unit provided.")
+        super
+      end
+    end
+
+    class ArgumentError < BaseError
+      def initialize(message = "Invalid argument provided.")
+        super
+      end
+    end
   end
-end
+end

data/lib/readlines/readlines/filter.rb

@@ -0,0 +1,46 @@
+# readlines/lib/readlines/readlines/filter.rb
+# Replace and Delete lines from the file
+require_relative 'delete'
+require_relative 'replace'
+
+module Readlines
+    module Filter
+      def apply_filter(line, value, query, operation, replacement = nil)
+        case query
+        when :start
+          matched = line.strip.start_with?(value.to_s)
+        when :body
+          matched = line.include?(value.to_s)
+        when :end
+          matched = line.strip.end_with?(value.to_s)
+        else
+          raise Readlines::Error::ArgumentError, "Invalid query type. Use :start, :body, or :end."
+        end
+  
+        if matched
+          case operation
+          when :delete
+            return nil
+          when :replace
+            raise Readlines::Error::ArgumentError, "Replacement value is required for replace operation." if replacement.nil?
+  
+            pattern = case query
+            when :start
+                /^#{Regexp.quote(value.to_s)}/
+            when :body
+                /#{Regexp.quote(value.to_s)}/
+            when :end
+                /#{Regexp.quote(value.to_s)}$/
+            end
+  
+            return line.gsub(pattern, replacement)
+          else
+            raise Readlines::Error::ArgumentError, "Invalid operation type. Use :delete or :replace."
+          end
+        else
+          line
+        end
+      end
+    end
+  end
+  

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: readlines
 version: !ruby/object:Gem::Version
-  version: '1.5'
+  version: '1.7'
 platform: ruby
 authors:
 - Maven
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-10-29 00:00:00.000000000 Z
+date: 2025-01-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json
@@ -84,7 +84,7 @@ description: Readlines is a Ruby library offering advanced tools for reading, wr
   and manipulating text files. It supports searching, replacing, sorting, splitting,
   merging, handling CSVs, encryption, and more. Perfect for developers needing efficient
   and complex file operations.
-email: 
+email:
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -99,6 +99,7 @@ files:
 - lib/readlines/readlines/delete.rb
 - lib/readlines/readlines/error.rb
 - lib/readlines/readlines/file.rb
+- lib/readlines/readlines/filter.rb
 - lib/readlines/readlines/info.rb
 - lib/readlines/readlines/merge.rb
 - lib/readlines/readlines/pattern.rb
@@ -111,7 +112,7 @@ homepage: https://github.com/Abo5/readlines
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -127,7 +128,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubygems_version: 3.3.3
-signing_key: 
+signing_key:
 specification_version: 4
 summary: A Ruby library for advanced text file manipulation and processing.
 test_files: []