emerge 0.2.2 → 0.4.0

data/lib/reaper/ast_parser.rb

@@ -1,6 +1,6 @@
 require 'tree_sitter'
 
-module Emerge
+module EmergeCLI
   module Reaper
     # Parses the AST of a given file using Tree Sitter and allows us to find usages or delete types.
     # This does have a lot of limitations since it only looks at a single file at a time,
@@ -8,7 +8,7 @@ module Emerge
     class AstParser
       DECLARATION_NODE_TYPES = {
         'swift' => %i[class_declaration protocol_declaration],
-        'kotlin' => %i[class_declaration protocol_declaration interface_declaration],
+        'kotlin' => %i[class_declaration protocol_declaration interface_declaration object_declaration],
         'java' => %i[class_declaration protocol_declaration interface_declaration]
       }.freeze
 
@@ -76,6 +76,7 @@ module Emerge
         lines_to_remove = []
 
         while (node = nodes_to_process.shift)
+          Logger.debug "Processing node: #{node.type} #{node_text(node)}"
           if declaration_node_types.include?(node.type)
             type_identifier_node = find_type_identifier(node)
             if type_identifier_node && fully_qualified_type_name(type_identifier_node) == type_name
@@ -95,6 +96,7 @@ module Emerge
 
         lines = file_contents.split("\n")
         lines_to_remove.each do |range|
+          Logger.debug "Removing lines #{range[:start]} to #{range[:end]}"
           (range[:start]..range[:end]).each { |i| lines[i] = nil }
 
           # Remove extra newline after class declaration, but only if it's blank
@@ -107,7 +109,11 @@ module Emerge
         new_tree = @parser.parse_string(nil, modified_source)
 
         return nil if only_comments_and_imports?(TreeSitter::TreeCursor.new(new_tree.root_node))
-        modified_source
+
+        # Preserve original newline state
+        had_final_newline = file_contents.end_with?("\n")
+        modified_source = modified_source.rstrip
+        had_final_newline ? "#{modified_source}\n" : modified_source
       end
 
       # Finds all usages of a given type in a file.
@@ -138,9 +144,42 @@ module Emerge
         usages
       end
 
+      def delete_usage(file_contents:, type_name:)
+        @current_file_contents = file_contents
+        tree = @parser.parse_string(nil, file_contents)
+        cursor = TreeSitter::TreeCursor.new(tree.root_node)
+        nodes_to_process = [cursor.current_node]
+        nodes_to_remove = []
+
+        Logger.debug "Starting to scan for usages of #{type_name}"
+
+        while (node = nodes_to_process.shift)
+          identifier_type = identifier_node_types.include?(node.type)
+          if identifier_type && node_text(node) == type_name
+            Logger.debug "Found usage of #{type_name} in node type: #{node.type}"
+            removable_node = find_removable_parent(node)
+            if removable_node
+              Logger.debug "Will remove parent node of type: #{removable_node.type}"
+              Logger.debug "Node text to remove: #{node_text(removable_node)}"
+              nodes_to_remove << removable_node
+            else
+              Logger.debug 'No suitable parent node found for removal'
+            end
+          end
+
+          node.each { |child| nodes_to_process.push(child) }
+        end
+
+        return file_contents if nodes_to_remove.empty?
+
+        Logger.debug "Found #{nodes_to_remove.length} nodes to remove"
+        remove_nodes_from_content(file_contents, nodes_to_remove)
+      end
+
       private
 
       def remove_node(node, lines_to_remove)
+        Logger.debug "Removing node: #{node.type}"
         start_position = node.start_point.row
         end_position = node.end_point.row
         lines_to_remove << { start: start_position, end: end_position }
@@ -188,6 +227,7 @@ module Emerge
           parent = find_parent_type_declaration(parent)
         end
 
+        Logger.debug "Fully qualified type name: #{class_name}"
         class_name
       end
 
@@ -229,6 +269,151 @@ module Emerge
         end_byte = node.end_byte
         @current_file_contents[start_byte...end_byte]
       end
+
+      def find_removable_parent(node)
+        current = node
+        Logger.debug "Finding removable parent for node type: #{node.type}"
+
+        while current && !current.null?
+          Logger.debug "Checking parent node type: #{current.type}"
+          case current.type
+          when :variable_declaration, # var foo: DeletedType
+               :parameter, # func example(param: DeletedType)
+               :type_annotation, # : DeletedType
+               :argument, # functionCall(param: DeletedType)
+               :import_declaration # import DeletedType
+            Logger.debug "Found removable parent node of type: #{current.type}"
+            return current
+          when :navigation_expression # NetworkDebugger.printStats
+            result = handle_navigation_expression(current)
+            return result if result
+          when :class_declaration, :function_declaration, :method_declaration
+            Logger.debug "Reached structural element, stopping at: #{current.type}"
+            break
+          end
+          current = current.parent
+        end
+
+        Logger.debug 'No better parent found, returning original node'
+        node
+      end
+
+      def handle_navigation_expression(navigation_node)
+        # If this navigation expression is part of a call, remove the entire call
+        parent_call = navigation_node.parent
+        return nil unless parent_call && parent_call.type == :call_expression
+
+        Logger.debug 'Found call expression containing navigation expression'
+        # Check if this call is the only statement in an if condition
+        if_statement = find_parent_if_statement(parent_call)
+        if if_statement && contains_single_statement?(if_statement)
+          Logger.debug 'Found if statement with single call, removing entire if block'
+          return if_statement
+        end
+        parent_call
+      end
+
+      def find_parent_if_statement(node)
+        current = node
+        Logger.debug "Looking for parent if statement starting from node type: #{node.type}"
+        while current && !current.null?
+          Logger.debug "  Checking node type: #{current.type}"
+          if current.type == :if_statement
+            Logger.debug '  Found parent if statement'
+            return current
+          end
+          current = current.parent
+        end
+        Logger.debug '  No parent if statement found'
+        nil
+      end
+
+      def contains_single_statement?(if_statement)
+        Logger.debug 'Checking if statement for single statement'
+        # Find the block/body of the if statement - try different field names based on language
+        block = if_statement.child_by_field_name('consequence') ||
+                if_statement.child_by_field_name('body') ||
+                if_statement.find { |child| child.type == :statements }
+
+        unless block
+          Logger.debug '  No block found in if statement. Node structure:'
+          Logger.debug "  If statement type: #{if_statement.type}"
+          Logger.debug '  Children types:'
+          if_statement.each do |child|
+            Logger.debug "    - #{child.type} (text: #{node_text(child)[0..50]}...)"
+          end
+          return false
+        end
+
+        Logger.debug "  Found block of type: #{block.type}"
+
+        relevant_children = block.reject do |child|
+          %i[comment line_break whitespace].include?(child.type)
+        end
+
+        Logger.debug "  Found #{relevant_children.length} significant children in if block"
+        relevant_children.each do |child|
+          Logger.debug "    Child type: #{child.type}, text: #{node_text(child)[0..50]}..."
+        end
+
+        relevant_children.length == 1
+      end
+
+      def remove_nodes_from_content(content, nodes)
+        # Sort nodes by their position in reverse order to avoid offset issues
+        nodes.sort_by! { |n| -n.start_byte }
+
+        # Check if original file had final newline
+        had_final_newline = content.end_with?("\n")
+
+        # Remove each node and clean up surrounding blank lines
+        modified_contents = content.dup
+        nodes.each do |node|
+          modified_contents = remove_single_node(modified_contents, node)
+        end
+
+        # Restore the original newline state at the end of the file
+        modified_contents.chomp!
+        had_final_newline ? "#{modified_contents}\n" : modified_contents
+      end
+
+      def remove_single_node(content, node)
+        had_final_newline = content.end_with?("\n")
+
+        # Remove the node's content
+        start_byte = node.start_byte
+        end_byte = node.end_byte
+        Logger.debug "Removing text: #{content[start_byte...end_byte]}"
+        content[start_byte...end_byte] = ''
+
+        # Clean up any blank lines created by the removal
+        content = cleanup_blank_lines(content, node.start_point.row, node.end_point.row)
+
+        had_final_newline ? "#{content}\n" : content
+      end
+
+      def cleanup_blank_lines(content, start_line, end_line)
+        lines = content.split("\n")
+
+        # Check for consecutive blank lines around the removed content
+        lines[start_line - 1] = nil if consecutive_blank_lines?(lines, start_line, end_line)
+
+        # Remove any blank lines left in the removed node's place
+        (start_line..end_line).each do |i|
+          lines[i] = nil if lines[i]&.match?(/^\s*$/)
+        end
+
+        lines.compact.join("\n")
+      end
+
+      def consecutive_blank_lines?(lines, start_line, end_line)
+        return false unless start_line > 0 && end_line + 1 < lines.length
+
+        prev_line = lines[start_line - 1]
+        next_line = lines[end_line + 1]
+
+        prev_line&.match?(/^\s*$/) && next_line&.match?(/^\s*$/)
+      end
     end
   end
 end

data/lib/reaper/code_deleter.rb

@@ -0,0 +1,263 @@
+require 'xcodeproj'
+
+module EmergeCLI
+  module Reaper
+    class CodeDeleter
+      def initialize(project_root:, platform:, profiler:, skip_delete_usages: false)
+        @project_root = File.expand_path(project_root)
+        @platform = platform
+        @profiler = profiler
+        @skip_delete_usages = skip_delete_usages
+        Logger.debug "Initialized CodeDeleter with project root: #{@project_root}, platform: #{@platform}"
+      end
+
+      def delete_types(types)
+        Logger.debug "Project root: #{@project_root}"
+
+        types.each do |class_info|
+          Logger.info "Deleting #{class_info['class_name']}"
+
+          type_name = parse_type_name(class_info['class_name'])
+          Logger.debug "Parsed type name: #{type_name}"
+
+          # Remove line number from path if present
+          paths = class_info['paths']&.map { |path| path.sub(/:\d+$/, '') }
+          found_usages = @profiler.measure('find_type_in_project') do
+            find_type_in_project(type_name)
+          end
+
+          if paths.nil? || paths.empty?
+            Logger.info "No paths provided for #{type_name}, using found usages instead..."
+            paths = found_usages
+                    .select { |usage| usage[:usages].any? { |u| u[:usage_type] == 'declaration' } }
+                    .map { |usage| usage[:path] }
+            if paths.empty?
+              Logger.warn "Could not find any files containing #{type_name}"
+              next
+            end
+            Logger.info "Found #{type_name} in: #{paths.join(', ')}"
+          end
+
+          # First pass: Delete declarations
+          paths.each do |path|
+            Logger.debug "Processing path: #{path}"
+            @profiler.measure('delete_type_from_file') do
+              delete_type_from_file(path, type_name)
+            end
+          end
+
+          # Second pass: Delete remaining usages (unless skipped)
+          if @skip_delete_usages
+            Logger.info 'Skipping delete usages'
+          else
+            identifier_usages = found_usages.select do |usage|
+              usage[:usages].any? { |u| u[:usage_type] == 'identifier' }
+            end
+            identifier_usage_paths = identifier_usages.map { |usage| usage[:path] }.uniq
+            if identifier_usage_paths.empty?
+              Logger.info 'No identifier usages found, skipping delete usages'
+            else
+              identifier_usage_paths.each do |path|
+                Logger.debug "Processing usages in path: #{path}"
+                @profiler.measure('delete_usages_from_file') do
+                  delete_usages_from_file(path, type_name)
+                end
+              end
+            end
+          end
+        end
+      end
+
+      private
+
+      def parse_type_name(type_name)
+        # Remove first module prefix for Swift types if present
+        if @platform == 'ios' && type_name.include?('.')
+          type_name.split('.')[1..].join('.')
+        # For Android, strip package name and just use the class name
+        elsif @platform == 'android' && type_name.include?('.')
+          # rubocop:disable Layout/LineLength
+          # Handle cases like "com.emergetools.hackernews.data.remote.ItemResponse $NullResponse (HackerNewsBaseClient.kt)"
+          # rubocop:enable Layout/LineLength
+          has_nested_class = type_name.include?('$')
+          parts = type_name.split
+          if parts.length == 0
+            type_name
+          elsif has_nested_class && parts.length > 1
+            base_name = parts[0].split('.').last
+            nested_class = parts[1].match(/\$(.+)/).captures.first
+            "#{base_name}.#{nested_class}"
+          else
+            parts[0].split('.').last
+          end
+        else
+          type_name
+        end
+      end
+
+      def delete_type_from_file(path, type_name)
+        full_path = resolve_file_path(path)
+        return unless full_path
+
+        Logger.debug "Processing file: #{full_path}"
+        begin
+          original_contents = @profiler.measure('read_file') { File.read(full_path) }
+          parser = make_parser_for_file(full_path)
+          modified_contents = @profiler.measure('parse_and_delete_type') do
+            parser.delete_type(
+              file_contents: original_contents,
+              type_name: type_name
+            )
+          end
+
+          if modified_contents.nil?
+            @profiler.measure('delete_file') do
+              File.delete(full_path)
+            end
+            if parser.language == 'swift'
+              @profiler.measure('delete_type_from_xcode_project') do
+                delete_type_from_xcode_project(full_path)
+              end
+            end
+            Logger.info "Deleted file #{full_path} as it only contained #{type_name}"
+          elsif modified_contents != original_contents
+            @profiler.measure('write_file') do
+              File.write(full_path, modified_contents)
+            end
+            Logger.info "Successfully deleted #{type_name} from #{full_path}"
+          else
+            Logger.warn "No changes made to #{full_path} for #{type_name}"
+          end
+        rescue StandardError => e
+          Logger.error "Failed to delete #{type_name} from #{full_path}: #{e.message}"
+          Logger.error e.backtrace.join("\n")
+        end
+      end
+
+      def delete_type_from_xcode_project(file_path)
+        xcodeproj_path = Dir.glob(File.join(@project_root, '**/*.xcodeproj')).first
+        if xcodeproj_path.nil?
+          Logger.warn "No Xcode project found in #{@project_root}"
+          return
+        end
+
+        begin
+          project = Xcodeproj::Project.open(xcodeproj_path)
+          relative_path = Pathname.new(file_path).relative_path_from(Pathname.new(@project_root)).to_s
+
+          file_ref = project.files.find { |f| f.real_path.to_s.end_with?(relative_path) }
+          if file_ref
+            file_ref.remove_from_project
+            project.save
+            Logger.info "Removed #{relative_path} from Xcode project"
+          else
+            Logger.warn "Could not find #{relative_path} in Xcode project"
+          end
+        rescue StandardError => e
+          Logger.error "Failed to update Xcode project: #{e.message}"
+          Logger.error e.backtrace.join("\n")
+        end
+      end
+
+      def find_type_in_project(type_name)
+        found_usages = []
+        source_patterns = case @platform&.downcase
+                          when 'ios'
+                            { 'swift' => '**/*.swift' }
+                          when 'android'
+                            {
+                              'kotlin' => '**/*.kt',
+                              'java' => '**/*.java'
+                            }
+                          else
+                            raise "Unsupported platform: #{@platform}"
+                          end
+
+        source_patterns.each do |language, pattern|
+          Dir.glob(File.join(@project_root, pattern)).reject { |path| path.include?('/build/') }.each do |file_path|
+            Logger.debug "Scanning #{file_path} for #{type_name}"
+            contents = File.read(file_path)
+            parser = make_parser_for_file(file_path)
+            usages = parser.find_usages(file_contents: contents, type_name: type_name)
+
+            if usages.any?
+              Logger.debug "✅ Found #{type_name} in #{file_path}"
+              relative_path = Pathname.new(file_path).relative_path_from(Pathname.new(@project_root)).to_s
+              found_usages << {
+                path: relative_path,
+                usages: usages,
+                language: language
+              }
+            end
+          rescue StandardError => e
+            Logger.warn "Error scanning #{file_path}: #{e.message}"
+          end
+        end
+
+        found_usages
+      end
+
+      def delete_usages_from_file(path, type_name)
+        full_path = resolve_file_path(path)
+        return unless full_path
+
+        begin
+          original_contents = File.read(full_path)
+          parser = make_parser_for_file(full_path)
+          Logger.debug "Deleting usages of #{type_name} from #{full_path}"
+          modified_contents = parser.delete_usage(
+            file_contents: original_contents,
+            type_name: type_name
+          )
+
+          if modified_contents != original_contents
+            File.write(full_path, modified_contents)
+            Logger.info "Successfully removed usages of #{type_name} from #{full_path}"
+          end
+        rescue StandardError => e
+          Logger.error "Failed to delete usages of #{type_name} from #{full_path}: #{e.message}"
+          Logger.error e.backtrace.join("\n")
+        end
+      end
+
+      def resolve_file_path(path)
+        # If path starts with /, treat it as relative to project root
+        if path.start_with?('/')
+          path = path[1..] # Remove leading slash
+          full_path = File.join(@project_root, path)
+          return full_path if File.exist?(full_path)
+        end
+
+        # Try direct path first
+        full_path = File.join(@project_root, path)
+        return full_path if File.exist?(full_path)
+
+        # If not found, search recursively
+        Logger.debug "File not found at #{full_path}, searching in project..."
+        matching_files = Dir.glob(File.join(@project_root, '**', path))
+                            .reject { |p| p.include?('/build/') }
+
+        if matching_files.empty?
+          Logger.warn "Could not find #{path} in project"
+          return nil
+        elsif matching_files.length > 1
+          Logger.warn "Found multiple matches for #{path}: #{matching_files.join(', ')}"
+          Logger.warn "Using first match: #{matching_files.first}"
+        end
+
+        matching_files.first
+      end
+
+      def make_parser_for_file(file_path)
+        language = case File.extname(file_path)
+                   when '.swift' then 'swift'
+                   when '.kt' then 'kotlin'
+                   when '.java' then 'java'
+                   else
+                     raise "Unsupported file type for #{file_path}"
+                   end
+        AstParser.new(language)
+      end
+    end
+  end
+end

data/lib/utils/git.rb

@@ -59,9 +59,21 @@ module EmergeCLI
     end
 
     def self.previous_sha
+      command = 'git rev-list --count HEAD'
+      Logger.debug command
+      count_stdout, _, count_status = Open3.capture3(command)
+
+      if !count_status.success? || count_stdout.strip.to_i <= 1
+        Logger.error 'Detected shallow clone while trying to get the previous commit. ' \
+                     'Please clone with full history using: git clone --no-single-branch ' \
+                     'or configure CI with fetch-depth: 0'
+        return nil
+      end
+
       command = 'git rev-parse HEAD^'
       Logger.debug command
-      stdout, _, status = Open3.capture3(command)
+      stdout, stderr, status = Open3.capture3(command)
+      Logger.error "Failed to get previous SHA: #{stdout}, #{stderr}" if !status.success?
       stdout.strip if status.success?
     end