isort 0.1.5 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6c121d3b6fba0a8fcf8a644eb26ebce0e35b11452cb1a3a644dfbee265a6bd1d
-  data.tar.gz: a80ae99d0f3d627407f7ccdd377365d10412ef9ade8b196b839285cee916a935
+  metadata.gz: b0b54367ec2e05c1827acb9d80bdc606634b858a98530ccf7c05d0e196269918
+  data.tar.gz: 4a7ab81c94061b440edd1f63cfc7569376278c4df39aab331bc84f70c2508ec5
 SHA512:
-  metadata.gz: 4a92208a0dfd4b76459832abb07ee6878976adfd8c40f8dd249bd330c1d2717e046bd4427a1078a43ff113c3d6adf82b994f3b4dcdf30471f1b1d17a1e54d3d1
-  data.tar.gz: 5ca8c19a71ed5c79135ed98b8f0ca74fe74a7b0ccb22d1de67d93e8fb75192d5f2f69957ab776a231989064a45b966ec2fb9f6a3cea02791acd5740939680635
+  metadata.gz: ada7d48c391b8a3e168a8ec8e3bbfb8579312a605789499f1a89188b5f5bd8af45e308ac1d8663c6f4b0c8b743a0c6d1e9b3c18e6072abb94c887cef14b72d66
+  data.tar.gz: a1f3ad1c5d95b411dd3292a8c452357f6e81472ace0d686fcd30cfe792a83b7b1dc79d3ef01d6b1bfc0a337fb6edd0057e60560bc769029018c3b7f0e4d1edf9

data/CHANGELOG.md

@@ -1,5 +1,40 @@
 ## [Released]
 
+## [0.2.0] - 2026-01-03
+
+Major rewrite with robust new architecture
+
+### Added
+- Complete architecture rewrite with modular components:
+  - `Parser` class for line classification
+  - `ImportStatement` class for import metadata
+  - `ImportBlock` class for contiguous import groups
+  - `FileProcessor` class for file orchestration
+- Comprehensive duplicate import removal
+- Proper handling of shebang and magic comments
+- Support for all six import types: require, require_relative, include, extend, autoload, using
+- Inline comment preservation
+- Leading comment preservation (comments stay with their imports when sorted)
+- Idempotent sorting (running multiple times produces same result)
+- Proper encoding validation (UTF-8)
+- Heredoc preservation
+- Conditional import structure preservation
+- Nested import sorting (inside classes/modules)
+- Mixed quote style support
+- Parenthesized require support
+- 69 comprehensive unit tests covering edge cases
+
+### Changed
+- Imports are now grouped by type with blank lines between groups
+- Multiple consecutive blank lines are normalized to single blank lines
+- Better error messages for invalid files
+
+### Fixed
+- Comment handling no longer causes unexpected reordering
+- Encoding errors are now properly detected and reported
+- Files with no imports are left untouched
+- Non-import code no longer breaks import sorting
+
 ## [0.1.3] - 2024-12-28
 
 - Initial release
@@ -17,3 +52,12 @@
 
 ### Added
 - Import sorting functionality support for a whole directory
+
+## [0.1.5] - 2024-12-29
+
+- Third release
+
+### Added
+- Preserve comments associated with imports
+- Add new line between different groups sorted
+- Don't do anything if no imports are found in a file

data/README.md

@@ -1,44 +1,290 @@
-# Isort
+# isort
 
-A Ruby gem that automatically sorts and organizes your import statements in Ruby files.
+A Ruby gem that automatically sorts and organizes import statements in Ruby files. Inspired by Python's [isort](https://pycqa.github.io/isort/), it brings the same powerful import organization to Ruby projects.
+
+[![Gem Version](https://badge.fury.io/rb/isort.svg)](https://rubygems.org/gems/isort)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+## Features
+
+- **Section-based grouping**: Automatically groups imports into stdlib, third-party, first-party, and local sections
+- **Alphabetical sorting**: Sorts imports alphabetically within each section
+- **Comment preservation**: Keeps inline and leading comments attached to their imports
+- **Skip directives**: Skip individual imports or entire files from sorting
+- **Safety modes**: Check, diff, and atomic modes to prevent unwanted changes
+- **Duplicate removal**: Automatically removes duplicate imports
+- **Idempotent**: Running multiple times produces the same result
+- **Directory support**: Process single files or entire directories recursively
 
 ## Installation
 
+Add to your Gemfile:
+
+```ruby
+gem 'isort'
+```
+
+Or install directly:
+
 ```bash
 gem install isort
 ```
 
+## Quick Start
+
+```bash
+# Sort imports in a file
+isort path/to/file.rb
+
+# Sort all Ruby files in a directory
+isort path/to/directory
+
+# Check if files need sorting (dry-run)
+isort --check path/to/file.rb
+
+# Show diff without modifying
+isort --diff path/to/file.rb
+```
+
 ## Usage
 
-### Command Line
+### Command Line Interface
+
+```bash
+isort [options] [file_or_directory]
+```
+
+#### Basic Options
+
+| Option | Description |
+|--------|-------------|
+| `-f, --file=FILE` | Sort a specific file |
+| `-d, --directory=DIR` | Sort all Ruby files in directory recursively |
+
+#### Safety Options
+
+| Option | Description |
+|--------|-------------|
+| `-c, --check` | Check if files need sorting without modifying. Returns exit code 1 if changes needed. |
+| `--diff` | Show unified diff of changes without modifying files |
+| `--atomic` | Validate Ruby syntax before and after sorting. Won't save if it would introduce syntax errors. |
+
+#### Output Options
+
+| Option | Description |
+|--------|-------------|
+| `-q, --quiet` | Suppress all output except errors |
+| `--verbose` | Show detailed output |
+| `-h, --help` | Show help message |
+| `-v, --version` | Show version |
+
+### Examples
 
 ```bash
-isort --file path/to/your/file.rb
-or
-isort -f path/to/your/file.rb
+# Sort a single file
+isort app/models/user.rb
+
+# Sort with verbose output
+isort --verbose lib/
+
+# Check if files are sorted (useful in CI)
+isort --check app/
+
+# Preview changes without applying
+isort --diff app/models/user.rb
+
+# Safe mode - validates syntax before saving
+isort --atomic lib/complex_file.rb
 ```
 
-### In Ruby Code
+### Ruby API
 
 ```ruby
 require 'isort'
 
-sorter = Isort::FileSorter.new('path/to/your/file.rb')
+# Sort imports in a file
+sorter = Isort::FileSorter.new('path/to/file.rb')
+changed = sorter.sort_and_format_imports  # Returns true if file was modified
+
+# Check mode (dry-run)
+sorter = Isort::FileSorter.new('path/to/file.rb', check: true)
+needs_sorting = sorter.check  # Returns true if file needs sorting
+
+# Diff mode
+sorter = Isort::FileSorter.new('path/to/file.rb', diff: true)
+diff_output = sorter.diff  # Returns diff string or nil
+
+# Atomic mode (validates syntax)
+sorter = Isort::FileSorter.new('path/to/file.rb', atomic: true)
 sorter.sort_and_format_imports
 ```
 
-## Features
+## Import Sections
+
+isort organizes imports into four sections, separated by blank lines:
+
+| Section | Order | Import Types |
+|---------|-------|--------------|
+| **stdlib** | 1 | `require` statements for Ruby standard library (json, yaml, csv, etc.) |
+| **thirdparty** | 2 | `require` statements for external gems |
+| **firstparty** | 3 | `include`, `extend`, `autoload`, `using` statements |
+| **localfolder** | 4 | `require_relative` statements |
+
+### Before
+
+```ruby
+require_relative 'helper'
+require 'yaml'
+extend ActiveSupport::Concern
+require 'json'
+include Enumerable
+require_relative 'version'
+require 'csv'
+```
+
+### After
+
+```ruby
+require 'csv'
+require 'json'
+require 'yaml'
+
+include Enumerable
+
+extend ActiveSupport::Concern
+
+require_relative 'helper'
+require_relative 'version'
+```
+
+## Skip Directives
+
+### Skip Individual Imports
+
+Add `# isort:skip` to keep an import in its original position:
+
+```ruby
+require 'must_load_first' # isort:skip
+require 'csv'
+require 'json'
+```
+
+The `must_load_first` import will remain at the top, while others are sorted below it.
+
+### Skip Entire Files
+
+Add `# isort:skip_file` anywhere in the first 50 lines:
+
+```ruby
+# frozen_string_literal: true
+# isort:skip_file
+
+require 'special_loader'
+require 'another_special'
+# This file won't be modified by isort
+```
+
+## Supported Import Types
+
+isort recognizes and sorts the following Ruby import statements:
+
+| Statement | Example |
+|-----------|---------|
+| `require` | `require 'json'` |
+| `require_relative` | `require_relative 'helper'` |
+| `include` | `include Enumerable` |
+| `extend` | `extend ActiveSupport::Concern` |
+| `autoload` | `autoload :MyClass, 'my_class'` |
+| `using` | `using MyRefinement` |
+
+## CI/CD Integration
+
+Use the `--check` flag in your CI pipeline to ensure imports are sorted:
+
+```yaml
+# GitHub Actions example
+- name: Check import sorting
+  run: |
+    gem install isort
+    isort --check app/ lib/
+```
+
+```bash
+# Exit codes
+# 0 = All files are sorted correctly
+# 1 = Files need sorting or errors occurred
+```
+
+## Safety Features
+
+### Atomic Mode
+
+The `--atomic` flag validates Ruby syntax before and after sorting:
+
+```bash
+isort --atomic file.rb
+```
+
+- Skips files that already have syntax errors
+- Won't save changes if sorting would introduce syntax errors
+- Provides clear error messages
+
+### Preserves Code Structure
 
-- Sorts require statements alphabetically
-- Groups imports by type (require, require_relative, include, extend)
-- Preserves code structure and spacing
-- Maintains conditional requires
-- Respects nested class and module definitions
+isort only modifies import statements and:
+
+- Preserves shebang lines (`#!/usr/bin/env ruby`)
+- Preserves magic comments (`# frozen_string_literal: true`)
+- Preserves inline comments on imports
+- Preserves leading comments above imports
+- Maintains proper indentation
+- Handles encoding correctly
+
+## Development
+
+```bash
+# Clone the repository
+git clone https://github.com/abhinvv1/isort.git
+cd isort
+
+# Install dependencies
+bundle install
+
+# Run tests
+bundle exec rspec
+
+# Test locally without installing
+bundle exec ruby -Ilib -e "require 'isort'; Isort::CLI.start" -- path/to/file.rb
+```
 
 ## Contributing
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/abhinvv1/isort.
 
+1. Fork the repository
+2. Create your feature branch (`git checkout -b feature/my-feature`)
+3. Commit your changes (`git commit -am 'Add my feature'`)
+4. Push to the branch (`git push origin feature/my-feature`)
+5. Create a Pull Request
+
 ## License
 
-The gem is available as open source under the terms of the MIT License.
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+## Changelog
+
+### v0.2.0
+
+- Complete reimplementation with robust architecture
+- Section-based import grouping (stdlib, thirdparty, firstparty, localfolder)
+- Added `--check` flag for dry-run mode
+- Added `--diff` flag to preview changes
+- Added `--atomic` flag for syntax validation
+- Added skip directives (`# isort:skip` and `# isort:skip_file`)
+- Automatic duplicate removal
+- Improved comment handling
+- Better detection of imports vs strings containing import keywords
+
+### v0.1.x
+
+- Initial release with basic import sorting

data/lib/isort/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Isort
-  VERSION = "0.1.5"
+  VERSION = "0.2.0"
 end

data/lib/isort.rb

@@ -1,136 +1,287 @@
-require 'optparse'
+# frozen_string_literal: true
+
+require "optparse"
+
 require_relative "isort/version"
+require_relative "isort/parser"
+require_relative "isort/import_statement"
+require_relative "isort/import_block"
+require_relative "isort/file_processor"
+require_relative "isort/syntax_validator"
+require_relative "isort/wrap_modes"
 
 module Isort
   class Error < StandardError; end
 
-  class FileSorter
+  # Raised when the input file already has syntax errors
+  class ExistingSyntaxErrors < Error
     def initialize(file_path)
-      @file_path = file_path
+      super("#{file_path} has existing syntax errors - skipping")
     end
+  end
 
-    def sort_imports
-      # Read the file content
-      lines = File.readlines(@file_path, chomp: true).map { |line| line.gsub("\r", "") }
-
-      # Separate import-related lines and other content
-      imports = lines.select { |line| line =~ /^\s*(require|require_relative|include)\s/ }
-      non_imports = lines.reject { |line| line =~ /^\s*(require|require_relative|include)\s/ }
+  # Raised when isort would introduce syntax errors
+  class IntroducedSyntaxErrors < Error
+    def initialize(file_path)
+      super("isort would introduce syntax errors in #{file_path} - not saving")
+    end
+  end
 
-      # Sort the import lines alphabetically
-      sorted_imports = imports.sort
+  # Raised when file contains skip directive
+  class FileSkipped < Error
+    def initialize(file_path, reason = "skip directive")
+      super("#{file_path} skipped due to #{reason}")
+    end
+  end
 
-      # Combine sorted imports with other lines
-      sorted_content = (sorted_imports + non_imports).join
+  # FileSorter provides the public API for sorting imports in a Ruby file
+  class FileSorter
+    attr_reader :file_path
 
-      # Write the sorted content back to the file
-      File.write(@file_path, sorted_content)
+    def initialize(file_path, options = {})
+      @file_path = file_path
+      @options = {
+        check: false,
+        diff: false,
+        atomic: false,
+        quiet: false
+      }.merge(options)
+      @processor = FileProcessor.new(file_path, @options)
     end
 
+    # Sort and format imports in the file
+    # Returns true if changes were made (or would be made in check mode)
     def sort_and_format_imports
-      # Read the file content
-      lines = File.readlines(@file_path)
-
-      # Separate and group lines
-      requires = extract_lines_with_comments(lines, /^require\s/)
-      require_relatives = extract_lines_with_comments(lines, /^require_relative\s/)
-      includes = extract_lines_with_comments(lines, /^include\s/)
-      extends = extract_lines_with_comments(lines, /^extend\s/)
-      autoloads = extract_lines_with_comments(lines, /^autoload\s/)
-      usings = extract_lines_with_comments(lines, /^using\s/)
-      others = lines.reject { |line| [requires, require_relatives, includes, extends, autoloads, usings].flatten.include?(line) }
-
-      # Format and sort each group
-      formatted_imports = []
-      formatted_imports << format_group("require", requires)
-      formatted_imports << format_group("require_relative", require_relatives)
-      formatted_imports << format_group("include", includes)
-      formatted_imports << format_group("extend", extends)
-      formatted_imports << format_group("autoload", autoloads)
-      formatted_imports << format_group("using", usings)
-
-      return if [requires, require_relatives, includes, extends, autoloads, usings].all?(&:empty?)
-
-      # Combine formatted imports with the rest of the file
-      sorted_content = "#{formatted_imports.reject(&:empty?).join("\n")}\n#{others.join}".strip
-
-      # Add a trailing newline only if imports exist
-      sorted_content = "#{sorted_content.rstrip}\n" if !formatted_imports.empty? && !sorted_content.empty?
-
-      # Write the sorted content back to the file only if imports exist
-      File.write(@file_path, sorted_content) unless formatted_imports.empty? && sorted_content.empty?
+      @processor.process
+    rescue Errno::ENOENT
+      raise
+    rescue ExistingSyntaxErrors, IntroducedSyntaxErrors, FileSkipped
+      raise
+    rescue StandardError => e
+      puts "An error occurred: #{e.message}" unless @options[:quiet]
+      raise
     end
 
-    private
-
-    def extract_lines(lines, regex)
-      lines.select { |line| line =~ regex }
+    # Check if file would change (dry-run)
+    def check
+      @processor.check
     end
 
-    def extract_lines_with_comments(lines, regex)
-      grouped_lines = []
-      buffer = []
-
-      lines.each do |line|
-        if line.strip.start_with?("#") || line.strip.empty?
-          # If the line is a comment or blank, add it to the buffer
-          buffer << line
-        elsif line =~ regex
-          # If it's an import line matching the regex, attach the buffer as comments
-          grouped_lines << (buffer + [line])
-          buffer = [] # Reset buffer
-        else
-          # If it's a non-matching line, reset the buffer
-          buffer = []
-        end
-      end
-
-      grouped_lines
+    # Get diff of changes without applying
+    def diff
+      @processor.diff
     end
 
-    def format_group(type, grouped_lines)
-      return [] if grouped_lines.empty?
-
-      # Flatten and sort each group by the import line
-      grouped_lines
-        .sort_by { |lines| lines.last.strip } # Sort by the actual import statement
-        .map { |lines| lines.join }          # Combine comments with the import
-        .map(&:strip)                        # Remove trailing newlines
-        .join("\n")                          # Join all imports in the group with newlines
-        .concat("\n")                        # Add a newline between groups
+    # Legacy method for backward compatibility
+    # @deprecated Use sort_and_format_imports instead
+    def sort_imports
+      sort_and_format_imports
     end
-
   end
 
+  # CLI handles command-line interface for the isort gem
   class CLI
     def self.start
-      options = {}
-      OptionParser.new do |opts|
-        opts.banner = "Usage: sort [options]"
+      options = {
+        check: false,
+        diff: false,
+        atomic: false,
+        quiet: false,
+        verbose: false
+      }
+
+      parser = OptionParser.new do |opts|
+        opts.banner = "Usage: isort [options] [file_or_directory]"
+        opts.separator ""
+        opts.separator "Options:"
 
-        opts.on("-fFILE", "--file=FILE", "File to sort") do |file|
+        opts.on("-f", "--file=FILE", "File to sort") do |file|
           options[:file] = file
         end
-        opts.on("-dDIRECTORY", "--directory=DIRECTORY", "Specify a directory to sort") do |dir|
+
+        opts.on("-d", "--directory=DIRECTORY", "Directory to sort (recursive)") do |dir|
           options[:directory] = dir
         end
-      end.parse!
+
+        opts.separator ""
+        opts.separator "Safety options:"
+
+        opts.on("-c", "--check", "--check-only",
+                "Check if files need sorting without modifying them.",
+                "Returns exit code 0 if sorted, 1 if changes needed.") do
+          options[:check] = true
+        end
+
+        opts.on("--diff", "Show diff of changes without modifying files.") do
+          options[:diff] = true
+        end
+
+        opts.on("--atomic", "Validate Ruby syntax before and after sorting.",
+                "Won't save if it would introduce syntax errors.") do
+          options[:atomic] = true
+        end
+
+        opts.separator ""
+        opts.separator "Output options:"
+
+        opts.on("-q", "--quiet", "Suppress all output except errors.") do
+          options[:quiet] = true
+        end
+
+        opts.on("--verbose", "Show detailed output.") do
+          options[:verbose] = true
+        end
+
+        opts.separator ""
+        opts.separator "Information:"
+
+        opts.on("-h", "--help", "Show this help message.") do
+          puts opts
+          exit
+        end
+
+        opts.on("-v", "--version", "Show version.") do
+          puts "isort #{Isort::VERSION}"
+          exit
+        end
+      end
+
+      # Parse arguments
+      parser.parse!
+
+      # Handle positional arguments
+      if ARGV.any? && !options[:file] && !options[:directory]
+        target = ARGV.first
+        if File.directory?(target)
+          options[:directory] = target
+        elsif File.file?(target)
+          options[:file] = target
+        else
+          puts "Error: #{target} is not a valid file or directory"
+          exit 1
+        end
+      end
 
       if options[:file]
-        sorter = FileSorter.new(options[:file])
-        sorter.sort_and_format_imports
-        puts "Imports sorted in #{options[:file]}"
+        exit_code = process_file(options[:file], options)
+        exit exit_code
       elsif options[:directory]
-        count = 0
-        Dir.glob("#{options[:directory]}/**/*.rb").each do |file|
-          count += 1
-          sorter = FileSorter.new(file)
-          sorter.sort_and_format_imports
-        end
-        puts "Sorted imports in #{count} files in directory: #{options[:directory]}"
+        exit_code = process_directory(options[:directory], options)
+        exit exit_code
+      else
+        puts parser
+        exit 1
+      end
+    end
+
+    def self.process_file(file, options)
+      unless File.exist?(file)
+        puts "Error: File not found: #{file}" unless options[:quiet]
+        return 1
+      end
+
+      processor = FileProcessor.new(file, options)
+
+      if options[:check]
+        return handle_check(file, processor, options)
+      elsif options[:diff]
+        return handle_diff(file, processor, options)
+      else
+        return handle_sort(file, processor, options)
+      end
+    rescue ExistingSyntaxErrors => e
+      puts "ERROR: #{e.message}" unless options[:quiet]
+      return 1
+    rescue IntroducedSyntaxErrors => e
+      puts "ERROR: #{e.message}" unless options[:quiet]
+      return 1
+    rescue FileSkipped => e
+      puts e.message if options[:verbose]
+      return 0
+    rescue StandardError => e
+      puts "Error processing #{file}: #{e.message}" unless options[:quiet]
+      return 1
+    end
+
+    def self.handle_check(file, processor, options)
+      would_change = processor.check
+      if would_change
+        puts "#{file} - imports are not sorted" unless options[:quiet]
+        1
+      else
+        puts "#{file} - imports are sorted" if options[:verbose]
+        0
+      end
+    end
+
+    def self.handle_diff(file, processor, options)
+      diff_output = processor.diff
+      if diff_output && !diff_output.empty?
+        puts diff_output
+        1
       else
-        puts "Please specify a file using -f or --file"
+        puts "#{file} - no changes" if options[:verbose]
+        0
       end
     end
+
+    def self.handle_sort(file, processor, options)
+      changed = processor.process
+      if changed
+        puts "Imports sorted in #{file}" unless options[:quiet]
+      else
+        puts "#{file} - no changes needed" if options[:verbose]
+      end
+      0
+    end
+
+    def self.process_directory(dir, options)
+      unless Dir.exist?(dir)
+        puts "Error: Directory not found: #{dir}" unless options[:quiet]
+        return 1
+      end
+
+      files = Dir.glob("#{dir}/**/*.rb")
+      if files.empty?
+        puts "No Ruby files found in #{dir}" unless options[:quiet]
+        return 0
+      end
+
+      total = 0
+      changed = 0
+      errors = 0
+      error_messages = []
+
+      files.each do |file|
+        result = process_file(file, options.merge(quiet: true))
+        total += 1
+        if result == 0
+          changed += 1 if options[:check] || options[:diff]
+        else
+          errors += 1
+        end
+      rescue StandardError => e
+        errors += 1
+        error_messages << "#{file}: #{e.message}"
+      end
+
+      unless options[:quiet]
+        if options[:check]
+          unsorted = total - changed
+          puts "Checked #{total} files: #{changed} sorted, #{unsorted} need sorting"
+        elsif options[:diff]
+          puts "Checked #{total} files: #{total - changed} would change"
+        else
+          puts "Sorted imports in #{total} files in directory: #{dir}"
+        end
+
+        if error_messages.any?
+          puts "\nErrors encountered:"
+          error_messages.each { |err| puts "  - #{err}" }
+        end
+      end
+
+      errors > 0 || (options[:check] && changed < total) ? 1 : 0
+    end
   end
 end

data/sig/isort/file_sorter.rbs

@@ -7,5 +7,13 @@ module Isort
     def sort_directory: -> untyped
 
     def sort_imports: -> untyped
+
+    private
+
+    def extract_lines: -> untyped
+
+    def extract_lines_with_comments: -> untyped
+
+    def format_group: -> untyped
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: isort
 version: !ruby/object:Gem::Version
-  version: 0.1.5
+  version: 0.2.0
 platform: ruby
 authors:
 - abhinvv1
-autorequire:
+autorequire: 
 bindir: exe
 cert_chain: []
-date: 2024-12-29 00:00:00.000000000 Z
+date: 2026-01-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: optparse
@@ -66,11 +66,13 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.0'
-description: Isort automatically sorts and organizes your Ruby imports, including
-  require, require_relative, include, using, and extend statements.Has the ability
-  to group different types of imports together. It can process single files or entire
-  directories directly throughcommand-line interface, and preserve the code comments
-  and inline documentation
+description: 'isort automatically sorts and organizes import statements in Ruby files.
+  It groups imports into sections (stdlib, third-party, first-party, local), sorts
+  alphabetically within each section, removes duplicates, and preserves comments.
+  Supports require, require_relative, include, extend, autoload, and using statements.
+  Features include: check mode for CI integration, diff preview, atomic mode with
+  syntax validation, skip directives for fine-grained control, and recursive directory
+  processing. Inspired by Python''s isort.'
 email:
 - abhinav.p@browserstack.com
 executables:
@@ -97,7 +99,7 @@ metadata:
   homepage_uri: https://github.com/abhinvv1/isort
   source_code_uri: https://github.com/abhinvv1/isort
   changelog_uri: https://github.com/abhinvv1/isort
-post_install_message:
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -112,8 +114,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.11
-signing_key:
+rubygems_version: 3.0.9
+signing_key: 
 specification_version: 4
-summary: A Ruby gem for sorting and organizing import statements
+summary: Automatic import sorting for Ruby - sort require, include, extend and more
 test_files: []