isort 0.2.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b0b54367ec2e05c1827acb9d80bdc606634b858a98530ccf7c05d0e196269918
-  data.tar.gz: 4a7ab81c94061b440edd1f63cfc7569376278c4df39aab331bc84f70c2508ec5
+  metadata.gz: a833de16ba9dbfd28c133288adf5a2a2ad107e1e5932db200d479b412165d133
+  data.tar.gz: 5b36d59223838c1c3518b3cb8f2f3c25171e3a296f3b3bb3f9504c58c75e18ca
 SHA512:
-  metadata.gz: ada7d48c391b8a3e168a8ec8e3bbfb8579312a605789499f1a89188b5f5bd8af45e308ac1d8663c6f4b0c8b743a0c6d1e9b3c18e6072abb94c887cef14b72d66
-  data.tar.gz: a1f3ad1c5d95b411dd3292a8c452357f6e81472ace0d686fcd30cfe792a83b7b1dc79d3ef01d6b1bfc0a337fb6edd0057e60560bc769029018c3b7f0e4d1edf9
+  metadata.gz: 486aa5493eaad1646391877546e68934a1a80d0a81ab45a45284460035938875d94ce09a81cf5750bbb4f088dfdfcf9c8ff3eb0ed60a0a9955a5a80290775698
+  data.tar.gz: b24356a0840dfc7e414df6594c10503e1ae583d005c54771b50bf32676d2f4a6f133fe991c4340a3598c7adcec01507a6ebf79cdd79fbf07b9af08f6e8d9ffe8

data/lib/isort/file_processor.rb

@@ -0,0 +1,426 @@
+# frozen_string_literal: true
+
+require_relative "parser"
+require_relative "import_block"
+require_relative "import_statement"
+require_relative "syntax_validator"
+
+module Isort
+  # Main orchestrator for processing Ruby files
+  # Finds import blocks, sorts them, and reconstructs the file
+  class FileProcessor
+    SKIP_FILE_PATTERN = /^#\s*isort:\s*skip_file\b/i.freeze
+    SKIP_LINE_PATTERN = /#\s*isort:\s*skip\b/i.freeze
+
+    def initialize(file_path, options = {})
+      @file_path = file_path
+      @options = {
+        check: false,
+        diff: false,
+        atomic: false,
+        quiet: false,
+        verbose: false
+      }.merge(options)
+      @parser = Parser.new
+    end
+
+    # Process the file - returns true if changes were made
+    def process
+      original_content = read_file_content
+      return false if original_content.nil? || original_content.empty?
+
+      # Check for skip_file directive
+      check_skip_file_directive!(original_content)
+
+      # Atomic mode: validate original syntax first
+      if @options[:atomic]
+        validate_original_syntax!(original_content)
+      end
+
+      lines = parse_lines(original_content)
+      return false if lines.empty?
+
+      # Find all import blocks in the file
+      blocks_with_positions = find_import_blocks(lines)
+      return false if blocks_with_positions.empty?
+
+      # Sort each block
+      blocks_with_positions.each do |block_info|
+        block_info[:block].sort_and_dedupe!
+      end
+
+      # Reconstruct the file with sorted blocks
+      new_content = reconstruct_file(lines, blocks_with_positions)
+
+      # No changes needed
+      return false if new_content == original_content
+
+      # Atomic mode: validate new syntax before writing
+      if @options[:atomic]
+        validate_new_syntax!(new_content)
+      end
+
+      # Write the file
+      write_file(new_content)
+      true
+    rescue ArgumentError => e
+      # Handle encoding errors from strip/other string operations
+      if e.message.include?("invalid byte sequence")
+        raise Encoding::CompatibilityError, "Invalid encoding in #{@file_path}: #{e.message}"
+      end
+      raise
+    end
+
+    # Check if file would change (dry-run mode for --check)
+    # Returns true if file would be modified, false otherwise
+    def check
+      original_content = read_file_content
+      return false if original_content.nil? || original_content.empty?
+
+      # Check for skip_file directive
+      begin
+        check_skip_file_directive!(original_content)
+      rescue FileSkipped
+        return false
+      end
+
+      lines = parse_lines(original_content)
+      return false if lines.empty?
+
+      blocks_with_positions = find_import_blocks(lines)
+      return false if blocks_with_positions.empty?
+
+      # Sort each block (on a copy)
+      blocks_with_positions.each do |block_info|
+        block_info[:block].sort_and_dedupe!
+      end
+
+      new_content = reconstruct_file(lines, blocks_with_positions)
+      new_content != original_content
+    end
+
+    # Get diff of changes without applying (for --diff mode)
+    # Returns diff string or nil if no changes
+    def diff
+      original_content = read_file_content
+      return nil if original_content.nil? || original_content.empty?
+
+      # Check for skip_file directive
+      begin
+        check_skip_file_directive!(original_content)
+      rescue FileSkipped
+        return nil
+      end
+
+      lines = parse_lines(original_content)
+      return nil if lines.empty?
+
+      blocks_with_positions = find_import_blocks(lines)
+      return nil if blocks_with_positions.empty?
+
+      # Sort each block (on a copy)
+      blocks_with_positions.each do |block_info|
+        block_info[:block].sort_and_dedupe!
+      end
+
+      new_content = reconstruct_file(lines, blocks_with_positions)
+      return nil if new_content == original_content
+
+      generate_diff(original_content, new_content)
+    end
+
+    private
+
+    def read_file_content
+      content = File.read(@file_path, encoding: "UTF-8")
+
+      unless content.valid_encoding?
+        raise Encoding::CompatibilityError, "Invalid encoding in #{@file_path}: contains invalid UTF-8 bytes"
+      end
+
+      # Normalize line endings
+      content.gsub("\r\n", "\n").gsub("\r", "\n")
+    rescue Encoding::InvalidByteSequenceError, Encoding::UndefinedConversionError => e
+      raise Encoding::CompatibilityError, "Invalid encoding in #{@file_path}: #{e.message}"
+    end
+
+    def parse_lines(content)
+      content.lines(chomp: false).map { |line| line }
+    end
+
+    def check_skip_file_directive!(content)
+      # Check first 50 lines for skip_file directive
+      content.lines.first(50).each do |line|
+        if line.match?(SKIP_FILE_PATTERN)
+          raise FileSkipped.new(@file_path, "isort:skip_file directive")
+        end
+      end
+    end
+
+    def validate_original_syntax!(content)
+      unless SyntaxValidator.valid?(content)
+        raise ExistingSyntaxErrors.new(@file_path)
+      end
+    end
+
+    def validate_new_syntax!(content)
+      unless SyntaxValidator.valid?(content)
+        raise IntroducedSyntaxErrors.new(@file_path)
+      end
+    end
+
+    def generate_diff(original, modified)
+      require "tempfile"
+
+      original_file = Tempfile.new(["original", ".rb"])
+      modified_file = Tempfile.new(["modified", ".rb"])
+
+      begin
+        original_file.write(original)
+        original_file.flush
+        modified_file.write(modified)
+        modified_file.flush
+
+        # Use unified diff format
+        diff_output = `diff -u "#{original_file.path}" "#{modified_file.path}" 2>/dev/null`
+
+        # Replace temp file paths with actual file path in diff header
+        diff_output = diff_output.gsub(original_file.path, "#{@file_path} (original)")
+        diff_output = diff_output.gsub(modified_file.path, "#{@file_path} (sorted)")
+
+        diff_output.empty? ? nil : diff_output
+      ensure
+        original_file.close
+        original_file.unlink
+        modified_file.close
+        modified_file.unlink
+      end
+    end
+
+    def write_file(content)
+      File.write(@file_path, content)
+    end
+
+    # Find all import blocks in the file
+    # Returns array of { block: ImportBlock, start_line: Int, end_line: Int }
+    def find_import_blocks(lines)
+      blocks = []
+      current_block = nil
+      pending_comments = []
+      pending_blanks = []
+      in_multiline_string = false
+      heredoc_delimiter = nil
+
+      lines.each_with_index do |line, index|
+        line_num = index + 1
+
+        # Handle potential encoding issues in line processing
+        begin
+          stripped = line.to_s.strip
+        rescue ArgumentError
+          # If we can't process the line, treat it as code
+          finalize_block(current_block, blocks, index, pending_blanks)
+          current_block = nil
+          pending_comments = []
+          pending_blanks = []
+          next
+        end
+
+        indentation = @parser.extract_indentation(line)
+
+        # Track heredoc state
+        if heredoc_delimiter
+          heredoc_delimiter = nil if stripped == heredoc_delimiter
+          next
+        end
+
+        # Check for heredoc start
+        if (heredoc_match = line.match(/<<[-~]?['"]?(\w+)['"]?/))
+          heredoc_delimiter = heredoc_match[1]
+        end
+
+        # Skip multiline strings (basic detection)
+        if in_multiline_string
+          in_multiline_string = false if stripped.end_with?('"""') || stripped.end_with?("'''")
+          next
+        end
+
+        if stripped.start_with?('"""') || stripped.start_with?("'''")
+          in_multiline_string = true unless stripped.count(stripped[0..2]) >= 2
+          next
+        end
+
+        line_type = @parser.classify_line(line, line_number: line_num)
+
+        case line_type
+        when :shebang, :magic_comment
+          # These stay in place, finalize any current block
+          finalize_block(current_block, blocks, index - 1, pending_blanks)
+          current_block = nil
+          pending_comments = []
+          pending_blanks = []
+
+        when :comment
+          # Accumulate comments - they might belong to the next import
+          # But only if there's no blank line separating them
+          if pending_blanks.empty?
+            pending_comments << line
+          else
+            # There was a blank line before this comment, so previous comments
+            # are "floating" and don't belong to imports - clear them
+            pending_comments = [line]
+            pending_blanks = []
+          end
+
+        when :blank
+          if current_block && !current_block.empty?
+            # Track blank lines - more than 1 consecutive ends the block
+            pending_blanks << line
+            if pending_blanks.size > 1
+              # End current block (don't include the blank lines in the block)
+              # The blank lines will remain between blocks in reconstruction
+              finalize_block(current_block, blocks, index - pending_blanks.size, [])
+              current_block = nil
+              pending_comments = []
+              # DON'T carry over pending_blanks - they stay as separators between blocks
+              pending_blanks = []
+            end
+          else
+            # Not in a block - blank line separates any pending comments from next import
+            if pending_comments.any?
+              # Comments followed by blank line are "floating" - don't attach to next import
+              pending_comments = []
+            end
+            pending_blanks << line
+          end
+
+        when :require, :require_relative, :include, :extend, :autoload, :using
+          # Reset pending blanks when we see an import (they're part of the block)
+          if current_block && !pending_blanks.empty?
+            # Single blank line between imports is OK, attach to import's comments
+            pending_comments = pending_blanks + pending_comments
+            pending_blanks = []
+          end
+
+          # This is an import line!
+          if current_block.nil?
+            current_block = ImportBlock.new(indentation: indentation)
+            # The block starts at the first pending comment or this line
+            if pending_comments.any? || pending_blanks.any?
+              current_block.start_line = index - pending_comments.size - pending_blanks.size
+              current_block.leading_content = pending_blanks.dup
+            else
+              current_block.start_line = index
+            end
+          end
+
+          # Handle indentation change - might be a new block
+          if current_block.indentation != indentation && !current_block.empty?
+            # Different indentation, finalize current block and start new one
+            finalize_block(current_block, blocks, index - 1 - pending_comments.size, [])
+
+            current_block = ImportBlock.new(indentation: indentation)
+            if pending_comments.any? || pending_blanks.any?
+              current_block.start_line = index - pending_comments.size - pending_blanks.size
+              current_block.leading_content = pending_blanks.dup
+            else
+              current_block.start_line = index
+            end
+          end
+
+          # Create the import statement with its leading comments
+          statement = ImportStatement.new(
+            raw_line: line,
+            type: line_type,
+            leading_comments: pending_comments.dup,
+            indentation: indentation
+          )
+          current_block.add_statement(statement)
+
+          pending_comments = []
+          pending_blanks = []
+          current_block.end_line = index
+
+        when :code
+          # Non-import code - finalize any current block
+          finalize_block(current_block, blocks, index - 1, pending_blanks)
+          current_block = nil
+          pending_comments = []
+          pending_blanks = []
+        end
+      end
+
+      # Finalize any remaining block at end of file
+      # Include trailing comments if they exist
+      if current_block && !current_block.empty?
+        # Add any trailing comments to the last statement
+        if pending_comments.any?
+          # These are orphan comments at end - don't include in block range
+          current_block.end_line = lines.size - 1 - pending_blanks.size - pending_comments.size
+        else
+          current_block.end_line = lines.size - 1 - pending_blanks.size
+        end
+        blocks << { block: current_block, start_line: current_block.start_line, end_line: current_block.end_line }
+      end
+
+      blocks
+    end
+
+    def finalize_block(block, blocks, end_index, pending_blanks)
+      return unless block && !block.empty?
+
+      block.end_line = [end_index - pending_blanks.size, block.start_line].max
+      blocks << { block: block, start_line: block.start_line, end_line: block.end_line }
+    end
+
+    # Reconstruct the file with sorted import blocks
+    def reconstruct_file(original_lines, blocks_with_positions)
+      return original_lines.join if blocks_with_positions.empty?
+
+      result = []
+      last_end = -1
+
+      # Sort blocks by start position
+      sorted_blocks = blocks_with_positions.sort_by { |b| b[:start_line] }
+
+      sorted_blocks.each_with_index do |block_info, block_index|
+        start_line = block_info[:start_line]
+        end_line = block_info[:end_line]
+        block = block_info[:block]
+
+        # Add lines before this block (from last_end+1 to start_line-1)
+        if start_line > last_end + 1
+          lines_between = (last_end + 1...start_line).map { |i| original_lines[i] }.compact
+
+          # If lines between consecutive import blocks are only blank lines,
+          # normalize to a single blank line
+          if block_index > 0 && lines_between.all? { |l| l.strip.empty? }
+            # Add single blank line if there were any blanks
+            result << "\n" unless lines_between.empty?
+          else
+            # Add all lines as-is
+            lines_between.each { |line| result << line }
+          end
+        end
+
+        # Add the sorted block
+        sorted_lines = block.to_lines
+        result.concat(sorted_lines)
+
+        last_end = end_line
+      end
+
+      # Add remaining lines after the last block
+      if last_end < original_lines.size - 1
+        ((last_end + 1)...original_lines.size).each do |i|
+          result << original_lines[i] if original_lines[i]
+        end
+      end
+
+      # Join and ensure trailing newline
+      content = result.join
+      content = "#{content.rstrip}\n" unless content.empty?
+      content
+    end
+  end
+end

data/lib/isort/import_block.rb

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+require_relative "import_statement"
+
+module Isort
+  # Represents a contiguous block of import statements
+  # Handles sorting, deduplication, and reconstruction
+  class ImportBlock
+    attr_reader :statements, :indentation
+    attr_accessor :start_line, :end_line, :leading_content, :trailing_blank_lines
+
+    def initialize(indentation: "")
+      @statements = []
+      @start_line = nil
+      @end_line = nil
+      @indentation = indentation
+      @leading_content = [] # Comments/blanks before first import in block
+      @trailing_blank_lines = 0
+    end
+
+    def add_statement(statement)
+      @statements << statement
+    end
+
+    def empty?
+      @statements.empty?
+    end
+
+    def size
+      @statements.size
+    end
+
+    # Sort statements by type then alphabetically, and remove duplicates
+    # Imports with isort:skip directive stay in their original position
+    def sort_and_dedupe!
+      return if @statements.empty?
+
+      # Separate skipped and sortable statements
+      skipped_with_positions = []
+      sortable = []
+
+      @statements.each_with_index do |stmt, index|
+        if stmt.skip_sorting?
+          skipped_with_positions << { statement: stmt, position: index }
+        else
+          sortable << stmt
+        end
+      end
+
+      # Sort only the sortable statements
+      sortable.sort!
+
+      # Remove duplicates from sortable (keep first occurrence with its comments)
+      seen = {}
+      sortable = sortable.reject do |stmt|
+        key = stmt.normalized_key
+        if seen[key]
+          true # Remove this duplicate
+        else
+          seen[key] = true
+          false # Keep this one
+        end
+      end
+
+      # If no skipped statements, just use the sorted list
+      if skipped_with_positions.empty?
+        @statements = sortable
+        return self
+      end
+
+      # Re-insert skipped statements at their original relative positions
+      # We need to calculate where each skipped statement should go
+      # in the new sorted list based on its original position ratio
+      result = sortable.dup
+
+      # Sort skipped statements by their original position
+      skipped_with_positions.sort_by! { |s| s[:position] }
+
+      # Insert each skipped statement
+      skipped_with_positions.each_with_index do |skipped_info, skip_idx|
+        original_pos = skipped_info[:position]
+        original_count = @statements.size
+
+        # Calculate the relative position in the new array
+        if original_count <= 1
+          insert_pos = skip_idx
+        else
+          # Scale the position to the new array size
+          ratio = original_pos.to_f / (original_count - 1)
+          new_max = result.size + skip_idx
+          insert_pos = (ratio * new_max).round
+        end
+
+        # Clamp to valid range
+        insert_pos = [[insert_pos, 0].max, result.size].min
+
+        result.insert(insert_pos, skipped_info[:statement])
+      end
+
+      @statements = result
+      self
+    end
+
+    # Convert the sorted block back to lines
+    def to_lines
+      return [] if @statements.empty?
+
+      result = []
+
+      # Add any leading content (comments before first import)
+      result.concat(@leading_content) unless @leading_content.empty?
+
+      # Group statements by section and type for proper spacing
+      current_section = nil
+      current_type = nil
+
+      @statements.each do |stmt|
+        # Filter out blank lines from the statement's leading comments
+        # (we'll add our own spacing between groups)
+        non_blank_comments = stmt.leading_comments.reject { |c| c.strip.empty? }
+
+        # Add blank line between different sections (highest priority separator)
+        if current_section && current_section != stmt.section && !result.empty?
+          # Add blank line between sections (unless last line is already blank)
+          unless result.last&.strip&.empty?
+            result << "#{@indentation}\n"
+          end
+        # Add blank line between different import types within the same section
+        elsif current_type && current_type != stmt.type && current_section == stmt.section && !result.empty?
+          # Only add blank line if last line isn't already blank
+          unless result.last&.strip&.empty?
+            result << "#{@indentation}\n"
+          end
+        elsif current_type && current_type == stmt.type && non_blank_comments.any?
+          # Same type but has comments - might need blank line before the comment
+          # Only add if last line isn't blank
+          unless result.last&.strip&.empty?
+            result << "#{@indentation}\n" if stmt.leading_comments.any? { |c| c.strip.empty? }
+          end
+        end
+
+        # Add non-blank leading comments
+        non_blank_comments.each do |line|
+          result << line
+        end
+
+        # Add the import line itself
+        result << stmt.raw_line
+
+        current_section = stmt.section
+        current_type = stmt.type
+      end
+
+      result
+    end
+
+    # Calculate how many original lines this block spans
+    def original_line_count
+      return 0 if @start_line.nil? || @end_line.nil?
+
+      @end_line - @start_line + 1
+    end
+  end
+end