readlines 1.4 → 1.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 33f599f5caad0c54a6425e6a8ef6568abaca3e7959ef4f140ea74b36df2501dc
-  data.tar.gz: 7bdda0e94575f39f7f6265727e027cb5137141658128292480a135fe9caa9348
+  metadata.gz: 573d78464068c0e851233a9618a588a95eb90faac37369a57bf60b9f304157be
+  data.tar.gz: d717ea49cbb087b333480feb9d842d43a72e2f7da4b82fd4987f27ab83291959
 SHA512:
-  metadata.gz: '09a0fe676df53bafedb30a50c80874b1e17480c99869307c092dc10df1fb2825ed6a6c216956003dc23dea71e0535fc2ef5389af59bdbf4b53d3511f967e1df3'
-  data.tar.gz: 8b07912f735e48d9f81d8566a189e7687d8fc0f54e7fa61687597ff14a523c732e7de8bb9637c34e9e019b725d3470f93e56c609461c92a93b2677e847f4448d
+  metadata.gz: 49315052d03f5102941ff900893e045268522e7d661c6edb1e0d6426cb53bd3b4b8d2a902b9eb6afd5e807b38e32f7fa6cb46adbbe3c8607359c7d5809a841e5
+  data.tar.gz: 191227637e442aa45f2fdd4dc23e239be88ff354a0c24fddf7e3cf38e4d8f38b735f77b9277975186bade948c85952d8f28690d683209907937043b831134bab

data/README.md

@@ -5,346 +5,274 @@ 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'
 ```
 
-Create an instance of the `Read` class, providing the path to the file you want to work with:
+Create an instance of the `Read` 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 = Read.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:
-```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
-```
+### Examples
+
+#### 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)
+# Count lines containing a specific keyword
+count = read.line_count(count: 'example')
 puts count
+
+# 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
 ```
+
+#### Search Operations
 ```ruby
-# Replace specific patterns in the file with replacement text
-pattern = /example/
-replacement = 'new_example'
-updated_content = read.replace(pattern, replacement)
-puts updated_content
+# Search for a specific value and show line numbers
+result = read.search_about('example', show_lines: true)
+puts result
+
+# Search for multiple patterns and count occurrences
+patterns = [/example/, /test/]
+result = read.search_multiple_patterns(patterns)
+puts result
+
+# Check if a pattern exists
+pattern_exists = read.pattern_exists?(/example/)
+puts pattern_exists
+
+# Search for a pattern within a range of lines
+matched_lines = read.search_in_range(5, 10, /example/)
+puts matched_lines
+
+# Logical pattern search (AND/OR operators)
+and_results = read.search_logical_patterns([/example/, /test/], 'AND')
+puts and_results
+or_results = read.search_logical_patterns([/example/, /test/], 'OR')
+puts or_results
 ```
+
+#### 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
+
+# Delete unwanted characters
+updated_content = read.delete_unwanted_characters('!@#$%^')
+puts updated_content
+
+# Delete duplicate lines
+unique_content = read.delete_duplicate_lines
+puts unique_content
+
+# Delete specific columns in a CSV file
+updated_csv = read.delete_csv_columns([1, 3])
+puts updated_csv
+
+# Filter lines based on criteria
+# Replace lines starting with "hello" with "hi"
+read.filter("hello", :start, :replace, "hi")
+read.filter("world", :body, :replace, "guys")
+read.filter("123", :end, :replace, "456")
+
+# Delete lines containing "unwanted_text" from start or end or anywhere using `:start` or `:end` or `:body`
+read.filter("unwanted_text", :start, :delete)
+read.filter("unwanted_text", :body, :delete)
+read.filter("unwanted_text", :end, :delete)
 ```
+
+#### File Splitting and Merging
 ```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
+# Split the file into 3 parts
+read.split_file(3)
 
-line_number = 3
-line_characters = read.character_count(line_specific: line_number)
-puts line_characters
+# Split by size (in bytes)
+read.split_file_by_size(1024) # 1 KB
+
+# Split by delimiter
+read.split_by_delimiter('---')
+
+# Split by a pattern
+read.split_by_pattern(/Chapter \d+/)
+
+# Merge multiple files
+merged_file = read.merge_files(['/path/to/file1.txt', '/path/to/file2.txt'])
+puts merged_file
+
+# Merge files with a separator
+merged_file_with_separator = read.merge_files(['/file1.txt', '/file2.txt'], separator: '---')
+puts merged_file_with_separator
 ```
+
+#### Encoding and Format Conversion
 ```ruby
-# Count the number of words in the file or in a specific line
-total_words = read.word_count
-puts total_words
+# Convert encoding
+read.convert_encoding('UTF-8', 'ISO-8859-1')
 
-line_number = 3
-line_words = read.word_count(line_specific: line_number)
-puts line_words
+# Convert file format to CSV
+converted_csv = read.convert_to_format('csv')
+puts converted_csv
 ```
+
+#### Extracting and Validating Content
 ```ruby
-# Extract specific patterns from the file
+# Extract specific patterns (e.g., email addresses)
 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
+
+# Validate content with 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
-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)
-puts updated_csv
-```
-```ruby
-# Check for spelling errors in the file using a dictionary
+
+# Check for spelling errors using a dictionary
 dictionary = ['example', 'pattern', 'file']
 misspelled_words = read.check_spelling(dictionary)
 puts misspelled_words
 ```
+
+#### File Size and Statistics
 ```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
+# Get 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_size_mb = read.file_size(unit: :megabytes)
 puts file_size_mb
-
 file_size_gb = read.file_size(unit: :gigabytes)
 puts file_size_gb
+
+# Get statistics about the file
+file_stats = read.file_statistics
+puts file_stats
+```
+
+#### Encryption and Decryption
+```ruby
+# Encrypt content using a key
+encrypted_content = read.encrypt_content(5)
+puts encrypted_content
+
+# Decrypt the content using the same key
+decrypted_content = read.decrypt_content(5, '/path/to/encrypted_file.txt')
+puts decrypted_content
+```
+
+#### Reverse and Additional Operations
+```ruby
+# Reverse the order of file contents
+reversed_content = read.reverse_content
+puts reversed_content
 ```
 
 ## Error Handling
 
-The Readlines library provides custom error classes to handle specific exceptions:
+The Readlines library provides custom error classes for handling specific exceptions:
 
-- `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.
+- **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.
 
 These error classes help in handling and debugging exceptions that may occur while using the library.
 
 ## Contributing
 
-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).
+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
 
-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.
-
-## Contact
-
-If you have any questions, suggestions, or feedback regarding the Readlines library, please feel free to contact the maintainer:
-
-- Name: Maven
-- GitHub: [Maven's GitHub](https://github.com/abo5)
-
-We appreciate your interest in the Readlines library and look forward to your contributions and feedback!
-
-
-
-# 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.4'
+  version: '1.6'
 platform: ruby
 authors:
 - Maven
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2024-10-29 00:00:00.000000000 Z
+date: 2024-11-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json
@@ -84,14 +84,13 @@ 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:
-- qppn@hotmail.com
+email: 
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
 - README.md
-- lib/read.rb
+- lib/readlines.rb
 - lib/readlines/read.rb
 - lib/readlines/readlines/check.rb
 - lib/readlines/readlines/content.rb
@@ -100,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