isort 0.2.0 → 0.2.1

data/lib/isort/import_statement.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+require_relative "section"
+
+module Isort
+  # Represents a single import statement with all its metadata
+  # This includes the raw line, type, sort key, and associated comments
+  class ImportStatement
+    IMPORT_TYPES = %i[require require_relative include extend autoload using].freeze
+    TYPE_ORDER = {
+      require: 0,
+      require_relative: 1,
+      include: 2,
+      extend: 3,
+      autoload: 4,
+      using: 5
+    }.freeze
+
+    SKIP_PATTERN = /#\s*isort:\s*skip\b/i.freeze
+
+    attr_reader :type, :raw_line, :sort_key, :leading_comments, :indentation
+    attr_reader :skip_sorting, :section
+
+    def initialize(raw_line:, type:, leading_comments: [], indentation: "")
+      @raw_line = raw_line
+      @type = type
+      @leading_comments = leading_comments
+      @indentation = indentation
+      @sort_key = extract_sort_key
+      @skip_sorting = has_skip_directive?
+      @section = Section.classify(self)
+    end
+
+    # Check if this import has an isort:skip directive
+    def has_skip_directive?
+      @raw_line.match?(SKIP_PATTERN)
+    end
+
+    alias skip_sorting? skip_sorting
+
+    # Returns the full representation including leading comments
+    def to_s
+      lines = []
+      lines.concat(@leading_comments) unless @leading_comments.empty?
+      lines << @raw_line
+      lines.join
+    end
+
+    # Returns lines as an array (for reconstruction)
+    def to_lines
+      result = @leading_comments.dup
+      result << @raw_line
+      result
+    end
+
+    # For deduplication - normalized import path/module
+    def normalized_key
+      @normalized_key ||= begin
+        stripped = @raw_line.strip
+        # Extract the actual import value for comparison
+        case @type
+        when :require, :require_relative
+          # Extract path from require 'path' or require "path"
+          if (match = stripped.match(/^(?:require|require_relative)\s+['"]([^'"]+)['"]/))
+            "#{@type}:#{match[1]}"
+          else
+            "#{@type}:#{stripped}"
+          end
+        when :include, :extend, :using
+          # Extract module name
+          if (match = stripped.match(/^(?:include|extend|using)\s+(\S+)/))
+            "#{@type}:#{match[1]}"
+          else
+            "#{@type}:#{stripped}"
+          end
+        when :autoload
+          # Extract constant and path
+          if (match = stripped.match(/^autoload\s+:?(\w+)/))
+            "#{@type}:#{match[1]}"
+          else
+            "#{@type}:#{stripped}"
+          end
+        else
+          "#{@type}:#{stripped}"
+        end
+      end
+    end
+
+    # Compare for sorting - first by section, then by type order, then alphabetically
+    def <=>(other)
+      # First compare by section (stdlib, thirdparty, firstparty, localfolder)
+      section_comparison = Section.order(@section) <=> Section.order(other.section)
+      return section_comparison unless section_comparison.zero?
+
+      # Then by type within section
+      type_comparison = TYPE_ORDER[@type] <=> TYPE_ORDER[other.type]
+      return type_comparison unless type_comparison.zero?
+
+      # Finally alphabetically
+      @sort_key <=> other.sort_key
+    end
+
+    private
+
+    def extract_sort_key
+      stripped = @raw_line.strip
+      # Remove the keyword and extract the sortable part
+      case @type
+      when :require
+        stripped.sub(/^require\s+/, "")
+      when :require_relative
+        stripped.sub(/^require_relative\s+/, "")
+      when :include
+        stripped.sub(/^include\s+/, "")
+      when :extend
+        stripped.sub(/^extend\s+/, "")
+      when :autoload
+        stripped.sub(/^autoload\s+/, "")
+      when :using
+        stripped.sub(/^using\s+/, "")
+      else
+        stripped
+      end
+    end
+  end
+end

data/lib/isort/parser.rb

@@ -0,0 +1,173 @@
+# frozen_string_literal: true
+
+module Isort
+  # Parses Ruby source lines and classifies them by type
+  # This is the core component for understanding file structure
+  class Parser
+    # Line types that can be returned
+    LINE_TYPES = %i[
+      shebang
+      magic_comment
+      require
+      require_relative
+      include
+      extend
+      autoload
+      using
+      comment
+      blank
+      code
+    ].freeze
+
+    IMPORT_TYPES = %i[require require_relative include extend autoload using].freeze
+
+    # Magic comment patterns (encoding, frozen_string_literal, etc.)
+    MAGIC_COMMENT_PATTERN = /^#\s*(?:encoding|coding|frozen_string_literal|warn_indent|shareable_constant_value):/i
+
+    # Skip directive patterns
+    SKIP_LINE_PATTERN = /#\s*isort:\s*skip\b/i.freeze
+    SKIP_FILE_PATTERN = /^#\s*isort:\s*skip_file\b/i.freeze
+
+    def initialize
+      @line_number = 0
+    end
+
+    # Classify a single line and return its type
+    def classify_line(line, line_number: nil)
+      @line_number = line_number if line_number
+      stripped = line.to_s.strip
+
+      return :blank if stripped.empty?
+      return classify_comment(line, stripped) if stripped.start_with?("#")
+
+      classify_code(stripped)
+    end
+
+    # Check if a line type is an import
+    def import_type?(type)
+      IMPORT_TYPES.include?(type)
+    end
+
+    # Extract the indentation from a line
+    def extract_indentation(line)
+      match = line.to_s.match(/^(\s*)/)
+      match ? match[1] : ""
+    end
+
+    # Check if line is a shebang (must be line 1)
+    def shebang?(line, line_number)
+      line_number == 1 && line.to_s.strip.start_with?("#!")
+    end
+
+    # Check if line has an isort:skip directive
+    def has_skip_directive?(line)
+      line.to_s.match?(SKIP_LINE_PATTERN) && !line.to_s.match?(SKIP_FILE_PATTERN)
+    end
+
+    # Check if line has an isort:skip_file directive
+    def has_skip_file_directive?(line)
+      line.to_s.match?(SKIP_FILE_PATTERN)
+    end
+
+    private
+
+    def classify_comment(line, stripped)
+      # Check for shebang on first line
+      return :shebang if @line_number == 1 && stripped.start_with?("#!")
+
+      # Check for magic comments (only valid at top of file, but we classify anyway)
+      return :magic_comment if stripped.match?(MAGIC_COMMENT_PATTERN)
+
+      :comment
+    end
+
+    def classify_code(stripped)
+      # Skip lines that are primarily string literals containing import keywords
+      # e.g., puts "require 'json'" or error_msg = 'include Module'
+      return :code if string_containing_import_keyword?(stripped)
+
+      # Order matters - check more specific patterns first
+
+      # require_relative must come before require
+      return :require_relative if require_relative_line?(stripped)
+      return :require if require_line?(stripped)
+      return :include if include_line?(stripped)
+      return :extend if extend_line?(stripped)
+      return :autoload if autoload_line?(stripped)
+      return :using if using_line?(stripped)
+
+      :code
+    end
+
+    # Detect if a line is primarily a string that happens to contain import keywords
+    # This prevents false positives like: puts "require 'json'" or x = "include Foo"
+    def string_containing_import_keyword?(stripped)
+      # If line starts with a string assignment or method call with string arg
+      # and the import keyword appears inside quotes, it's not a real import
+
+      # Pattern: variable = "...require..." or variable = '...require...'
+      return true if stripped.match?(/^\w+\s*=\s*['"].*(?:require|require_relative|include|extend|autoload|using).*['"]/)
+
+      # Pattern: method_call "...require..." or method_call '...require...'
+      # e.g., puts "require 'json'"
+      return true if stripped.match?(/^\w+\s+['"].*(?:require|require_relative|include|extend|autoload|using).*['"]/)
+
+      # Pattern: method_call("...require...") - method with parens and string arg
+      return true if stripped.match?(/^\w+\(["'].*(?:require|require_relative|include|extend|autoload|using).*["']\)/)
+
+      # Check if import keyword appears after an opening quote (inside a string)
+      # This catches cases like: desc "require the json gem"
+      if stripped.include?('"') || stripped.include?("'")
+        # Find position of first quote and import keyword
+        first_quote_pos = [stripped.index('"'), stripped.index("'")].compact.min
+        import_keywords = %w[require require_relative include extend autoload using]
+
+        import_keywords.each do |keyword|
+          keyword_pos = stripped.index(keyword)
+          next unless keyword_pos
+
+          # If keyword appears after a quote, it might be inside a string
+          # But we need to ensure it's not at the start (real import)
+          if first_quote_pos && keyword_pos > first_quote_pos && keyword_pos > 0
+            return true
+          end
+        end
+      end
+
+      false
+    end
+
+    def require_line?(stripped)
+      # Match: require 'foo' or require "foo" or require('foo')
+      # But NOT: require_relative
+      stripped.match?(/^require\s+['"]/) || stripped.match?(/^require\(['"]/)
+    end
+
+    def require_relative_line?(stripped)
+      # Match: require_relative 'foo' or require_relative "foo"
+      stripped.match?(/^require_relative\s+['"]/) || stripped.match?(/^require_relative\(['"]/)
+    end
+
+    def include_line?(stripped)
+      # Match: include ModuleName or include(ModuleName)
+      # But NOT: included, includes, include?
+      stripped.match?(/^include\s+[A-Z]/) || stripped.match?(/^include\([A-Z]/)
+    end
+
+    def extend_line?(stripped)
+      # Match: extend ModuleName
+      # But NOT: extended, extends
+      stripped.match?(/^extend\s+[A-Z]/) || stripped.match?(/^extend\([A-Z]/)
+    end
+
+    def autoload_line?(stripped)
+      # Match: autoload :Constant, 'path' or autoload(:Constant, 'path')
+      stripped.match?(/^autoload\s+:/) || stripped.match?(/^autoload\(:/)
+    end
+
+    def using_line?(stripped)
+      # Match: using ModuleName
+      stripped.match?(/^using\s+[A-Z]/) || stripped.match?(/^using\([A-Z]/)
+    end
+  end
+end

data/lib/isort/section.rb

@@ -0,0 +1,197 @@
+# frozen_string_literal: true
+
+require "set"
+
+module Isort
+  # Categorizes imports into sections based on their source
+  # - STDLIB: Ruby standard library
+  # - THIRDPARTY: Gems/external packages
+  # - FIRSTPARTY: Project's own modules
+  # - LOCALFOLDER: Relative imports
+  class Section
+    SECTIONS = %i[stdlib thirdparty firstparty localfolder].freeze
+
+    SECTION_ORDER = {
+      stdlib: 0,
+      thirdparty: 1,
+      firstparty: 2,
+      localfolder: 3
+    }.freeze
+
+    # Ruby standard library modules (partial list of common ones)
+    # This list covers the most commonly used stdlib modules
+    STDLIB_MODULES = Set.new(%w[
+      abbrev
+      base64
+      benchmark
+      bigdecimal
+      cgi
+      csv
+      date
+      delegate
+      digest
+      drb
+      english
+      erb
+      etc
+      fcntl
+      fiddle
+      fileutils
+      find
+      forwardable
+      getoptlong
+      io/console
+      io/nonblock
+      io/wait
+      ipaddr
+      irb
+      json
+      logger
+      matrix
+      minitest
+      monitor
+      mutex_m
+      net/ftp
+      net/http
+      net/https
+      net/imap
+      net/pop
+      net/smtp
+      nkf
+      objspace
+      observer
+      open-uri
+      open3
+      openssl
+      optparse
+      ostruct
+      pathname
+      pp
+      prettyprint
+      prime
+      pstore
+      psych
+      racc
+      rake
+      rdoc
+      readline
+      resolv
+      ripper
+      rss
+      securerandom
+      set
+      shellwords
+      singleton
+      socket
+      stringio
+      strscan
+      syslog
+      tempfile
+      time
+      timeout
+      tmpdir
+      tracer
+      tsort
+      un
+      uri
+      weakref
+      webrick
+      yaml
+      zlib
+    ]).freeze
+
+    class << self
+      # Classify an import statement into a section
+      def classify(statement)
+        case statement.type
+        when :require
+          classify_require(statement)
+        when :require_relative
+          :localfolder
+        when :include, :extend, :using
+          classify_module(statement)
+        when :autoload
+          :firstparty  # autoload is typically project-specific
+        else
+          :thirdparty
+        end
+      end
+
+      # Get the section order for sorting
+      def order(section)
+        SECTION_ORDER[section] || 999
+      end
+
+      private
+
+      def classify_require(statement)
+        # Extract the require path
+        stripped = statement.raw_line.strip
+        path = nil
+
+        if (match = stripped.match(/^require\s+['"]([^'"]+)['"]/))
+          path = match[1]
+        elsif (match = stripped.match(/^require\(['"]([^'"]+)['"]\)/))
+          path = match[1]
+        end
+
+        return :thirdparty unless path
+
+        # Check if it's a stdlib module
+        if stdlib_module?(path)
+          :stdlib
+        else
+          :thirdparty
+        end
+      end
+
+      def classify_module(statement)
+        # Include, extend, using are typically project-specific
+        # unless they're from well-known gems
+        stripped = statement.raw_line.strip
+
+        # Extract module name
+        module_name = nil
+        if (match = stripped.match(/^(?:include|extend|using)\s+(\S+)/))
+          module_name = match[1]
+        end
+
+        return :firstparty unless module_name
+
+        # Check for known stdlib modules
+        if stdlib_constant?(module_name)
+          :stdlib
+        else
+          :firstparty
+        end
+      end
+
+      def stdlib_module?(path)
+        # Remove file extension if present
+        base_path = path.sub(/\.rb$/, "")
+
+        # Check direct match
+        return true if STDLIB_MODULES.include?(base_path)
+
+        # Check prefix (e.g., 'net/http' for 'net/http/response')
+        STDLIB_MODULES.any? do |mod|
+          base_path.start_with?("#{mod}/") || base_path == mod
+        end
+      end
+
+      def stdlib_constant?(name)
+        # Common Ruby stdlib constants
+        stdlib_constants = %w[
+          Comparable
+          Enumerable
+          Forwardable
+          Observable
+          Singleton
+          MonitorMixin
+          Mutex_m
+        ]
+        stdlib_constants.any? { |c| name.start_with?(c) }
+      end
+    end
+  end
+end

data/lib/isort/syntax_validator.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Isort
+  # Validates Ruby syntax using the built-in parser
+  # Used by --atomic mode to ensure sorting doesn't introduce syntax errors
+  class SyntaxValidator
+    class << self
+      # Check if Ruby code has valid syntax
+      # Returns true if valid, false otherwise
+      def valid?(code)
+        check_syntax(code).nil?
+      end
+
+      # Check syntax and return error message if invalid, nil if valid
+      def check_syntax(code)
+        # Use Ruby's built-in syntax check
+        catch(:valid) do
+          eval("BEGIN { throw :valid }; #{code}", nil, "(syntax_check)", 0)
+        end
+        nil
+      rescue SyntaxError => e
+        e.message
+      rescue StandardError
+        # Other errors during eval don't indicate syntax errors
+        nil
+      end
+
+      # Check if a file has valid Ruby syntax
+      def valid_file?(file_path)
+        return false unless File.exist?(file_path)
+
+        content = File.read(file_path, encoding: "UTF-8")
+        valid?(content)
+      rescue Errno::ENOENT, Encoding::InvalidByteSequenceError
+        false
+      end
+
+      # Use Ruby's built-in -c flag for more accurate syntax checking
+      # This is safer than eval-based checking
+      def valid_with_ruby_c?(code)
+        require "open3"
+        require "tempfile"
+
+        Tempfile.create(["syntax_check", ".rb"]) do |f|
+          f.write(code)
+          f.flush
+
+          stdout, stderr, status = Open3.capture3("ruby", "-c", f.path)
+          status.success?
+        end
+      rescue StandardError
+        # If we can't run ruby -c, fall back to eval-based check
+        valid?(code)
+      end
+
+      # Check syntax using ruby -c (more reliable but slower)
+      # Returns nil if valid, error message if invalid
+      def check_syntax_with_ruby_c(code)
+        require "open3"
+        require "tempfile"
+
+        Tempfile.create(["syntax_check", ".rb"]) do |f|
+          f.write(code)
+          f.flush
+
+          stdout, stderr, status = Open3.capture3("ruby", "-c", f.path)
+          status.success? ? nil : stderr.strip
+        end
+      rescue StandardError => e
+        # If we can't run ruby -c, fall back to eval-based check
+        check_syntax(code)
+      end
+    end
+  end
+end

data/lib/isort/version.rb

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