rebundler 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 202f3a3cebed796e24330e45c80ec05cfb1cff61c19b032dc6abf7b5743413e0
-  data.tar.gz: cbe1e6738646b51a0d472ed9ee814f5826cdcf990ef95efc922532593101a363
+  metadata.gz: b98128fc72f25553bf3989f1cda39f09d0b38553185bbb9bd6e92a3fe4646cc8
+  data.tar.gz: 580694dd7a91592f95f1c32173e625f1a17c6c7dfc9bfc1c708bc565e422f4fa
 SHA512:
-  metadata.gz: 8a5f1efa74df81a6713ab98ca15e7dd8f0a03338475558eb21ed76e5550f8d627f17023c7d54f04537b6967c571b59562115efc54d26000b1e822fa014ea2fbd
-  data.tar.gz: d737b0d7b18c28b322cb874bb1530da1eeff03d1103eb5164cdf2370e95220e17196429b6809dc9055f06d275cb8f2b71c65a786a2bde75a54583d422781a278
+  metadata.gz: c83d1b995968f668a96b656036c9ba19f646bf3af2ee32611867ba820894acdfbead0b9662e60f1db3d08e1a8cef8476283cf3be855aefed921b7bf00e15d5d9
+  data.tar.gz: a4f681d93564b7111de675f8b576f62b3837fe0f2704f75cfa96d4a0ff7a0b106e726c09a26e7a8b8744a44f2ba24200a95be42249a8987f991583c1bf98c257

data/README.md

@@ -1,6 +1,6 @@
 # Rebundler
 
-Rebundler automatically reorders and annotes your Gemfile.
+Rebundler automatically reorders and annotates your Gemfile.
 
 ## Why would you want that?
 

data/exe/rebundle

@@ -3,7 +3,9 @@
 
 require_relative "../lib/rebundler"
 
-file = ARGV[0] || (Dir.pwd + "/Gemfile")
+# Parse command line arguments
+ci_mode = ARGV.include?("--ci")
+file = ARGV.reject { |arg| arg.start_with?("--") }[0] || (Dir.pwd + "/Gemfile")
 
 puts "Reordering and annotating Gemfile..."
 
@@ -12,7 +14,26 @@ begin
   # having to hit rubygems.org
   Bundler.setup
   parser = Rebundler::Parser.new(file)
-  File.write(file, parser.write!)
+  new_content = parser.parse_and_write!
+
+  if ci_mode
+    # In CI mode, compare the new content with the existing file
+    current_content = File.read(file)
+
+    if new_content == current_content
+      puts "✓ Gemfile is already properly formatted"
+      exit 0
+    else
+      puts "✗ Gemfile is not properly formatted"
+      puts "Run 'rebundle' to fix formatting issues"
+      exit 1
+    end
+  else
+    # In normal mode, write the new content to the file
+    File.write(file, new_content)
+    puts "✓ Gemfile has been reordered and annotated"
+  end
 rescue StandardError => e
   puts "Error parsing Gemfile: #{e.message}"
+  exit 1
 end

data/lib/bundler/rebundle.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "bundler"
+require "tempfile"
 
 module Bundler
   class Rebundle < Bundler::Plugin::API
@@ -25,7 +26,15 @@ module Bundler
         Bundler.setup
 
         parser = ::Rebundler::Parser.new(file)
-        File.write(file, parser.write!)
+        content = parser.parse_and_write!
+
+        # Use atomic write to prevent corruption if write fails
+        Tempfile.create("Gemfile", Bundler.root.to_s) do |tmp|
+          tmp.write(content)
+          tmp.flush
+          tmp.close
+          FileUtils.mv(tmp.path, file)
+        end
       rescue StandardError => e
         Bundler.ui.error "Error parsing Gemfile: #{e.message}"
         raise Bundler::PluginError, e

data/lib/rebundler/gem_fetcher.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Rebundler
+  class GemFetcher
+    class << self
+      def parse_gem(node)
+        return unless node.type == :call_node && SORTABLE_NODES.include?(node.name)
+
+        gem_name = node.arguments.child_nodes[0].content
+
+        find_gem(gem_name).merge(node:)
+      end
+
+      private
+
+      def find_gem(name)
+        summary = find_loaded_gem_summary(name) || find_external_gem_summary(name)
+
+        { name:, summary: }
+      end
+
+      def find_loaded_gem_summary(name)
+        gem = Gem::Specification.find_by_name(name)
+
+        gem.summary
+      rescue Gem::MissingSpecError
+        nil
+      end
+
+      def find_external_gem_summary(name)
+        spec = Gem::SpecFetcher.fetcher.spec_for_dependency Gem::Dependency.new(name)
+
+        return unless spec
+        # SpecFetcher returns [[], []] when gem exists but has no versions available
+        return if spec == [[], []]
+
+        spec.first.first.first.summary
+      end
+    end
+  end
+end

data/lib/rebundler/gem_set.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Rebundler
+  class GemSet
+    include Comparable
+
+    attr_reader :name, :node, :plugins, :gems, :default
+
+    def initialize(name: nil, node: nil, default: false)
+      @name = name
+      @node = node
+      @default = default
+
+      @plugins = []
+      @gems = []
+    end
+
+    def <=>(other)
+      return nil unless other.is_a?(GemSet)
+
+      # Default first, then sort by name
+      [default ? 0 : 1, name] <=> [other.default ? 0 : 1, other.name]
+    end
+
+    def ==(other)
+      other.is_a?(GemSet) && other.name == name
+    end
+  end
+end

data/lib/rebundler/parser.rb

@@ -4,157 +4,41 @@ require "prism"
 
 module Rebundler
   class Parser
-    SORTABLE_NODES = %i[plugin gem].freeze
-    BLOCK_NODES = %i[gemspec git group path platforms ruby source].freeze
-
-    attr_reader :file, :before, :sets, :frozen_string_literal
+    attr_reader :file, :preamble_nodes, :gem_sets, :frozen_string_literal
 
     def initialize(file)
       @file = file
       @frozen_string_literal = false
-      @before = []
-      @sets = [
-        { node: nil, plugin: [], gem: [] } # all gems outside a specific block (group, source, etc) will end up here
-      ]
+      @preamble_nodes = []
+      @gem_sets = [GemSet.new(default: true)] # all gems outside a specific block (group, source, etc) will end up here
     end
 
-    def write!
-      parse!
-
-      buffer = []
-
-      buffer << "# frozen_string_literal: true" if frozen_string_literal
-
-      before.each do |node|
-        buffer << node_to_s(node)
+    def build_set(name:, node: nil)
+      GemSet.new(name:, node:).tap do |set|
+        @gem_sets << set
       end
-
-      sets.sort_by { node_to_s(_1[:node]) || "" }.each do |set|
-        set_node = set[:node]
-        set_buffer = []
-
-        set_buffer << [node_to_s(set_node), set_node.block.opening].compact.join(" ") if set_node
-
-        set_buffer << SORTABLE_NODES.map do |node_type|
-          nodes = set[node_type].sort_by { _1[:name] }
-
-          nodes.map do |gem|
-            line = +""
-            line << "  " if set_node
-            line << node_to_s(gem[:node])
-            line << " # #{gem[:summary]}" if gem[:summary]
-
-            line
-          end.join("\n")
-        end.reject(&:empty?).join("\n\n")
-
-        set_buffer << set_node.block.closing if set_node&.block
-
-        buffer << set_buffer.join("\n")
-      end
-
-      buffer.reject(&:empty?).join("\n\n") + "\n"
     end
 
-    private
-
     def parse!
+      return if @parsed
+
       parsed = Prism.parse(File.read(file))
 
       @frozen_string_literal = parsed.magic_comments.map(&:key).include?("frozen_string_literal")
 
-      parsed.value.compact_child_nodes[0].compact_child_nodes.each do |node|
-        case node.type
-        when :call_node
-          case node.name
-          when *SORTABLE_NODES
-            @sets[0][node.name] << parse_gem(node)
-          when *BLOCK_NODES
-            if node.block
-              children = node.block.body.compact_child_nodes
-
-              set = { node:, plugin: [], gem: [] }
-
-              children.each do |child_node|
-                parsed_node = parse_gem(child_node)
-
-                set[child_node.name] << parsed_node if parsed_node
-              end
+      visitor = Visitor.new(self)
+      parsed.value.accept(visitor)
 
-              @sets << set
-            else
-              @before << node
-            end
-          end
-        end
-      end
-    end
-
-    def find_gem(name)
-      summary = find_loaded_gem_summary(name) || find_external_gem_summary(name)
-
-      { name:, summary: }
-    end
-
-    def find_loaded_gem_summary(name)
-      gem = Gem::Specification.find_by_name(name)
-
-      gem.summary
-    rescue Gem::MissingSpecError
-      nil
+      @parsed = true
     end
 
-    def find_external_gem_summary(name)
-      spec = Gem::SpecFetcher.fetcher.spec_for_dependency Gem::Dependency.new(name)
-
-      return unless spec
-      return if spec == [[], []]
-
-      spec.first.first.first.summary
-    end
-
-    def node_to_s(node)
-      return if node.nil?
-
-      case node.type
-      when :call_node
-        [node.name, node_to_s(node.arguments)].compact.join(" ")
-      when :keyword_hash_node
-        node.elements.map do |element|
-          key = node_to_s(element.key)
-          value = node_to_s(element.value)
-
-          "#{key} #{value}"
-        end
-      when :symbol_node
-        "#{node.opening}#{node.value}#{node.closing}"
-      when :string_node
-        "#{node.opening}#{node.content}#{node.closing}"
-      when :array_node
-        separator = node.opening == "[" ? ", " : " "
-
-        node.opening + node.elements.map do |element|
-          node_to_s(element)
-        end.join(separator) + node.closing
-      when :true_node
-        "true"
-      when :false_node
-        "false"
-      when :arguments_node
-        return if node.child_nodes.empty?
-
-        node.child_nodes.map { node_to_s(_1) }.join(", ")
-      else
-        raise NotImplementedError, "Unknown node type: #{node.type}"
-      end
+    def parse_and_write!
+      parse!
+      Writer.new(self).write!
     end
 
-    def parse_gem(node)
-      return unless node.type == :call_node && SORTABLE_NODES.include?(node.name)
-
-      gem_name = node.arguments.child_nodes[0].content
-
-      find_gem(gem_name).merge(node:)
+    def find_or_build_set(name:, node: nil)
+      gem_sets.find { |set| set.name == name } || build_set(name:, node:)
     end
   end
 end

data/lib/rebundler/serializer.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Rebundler
+  class Serializer
+    def self.node_to_s(node)
+      return if node.nil?
+
+      case node.type
+      when :call_node
+        [node.name, node_to_s(node.arguments)].compact.join(" ")
+      when :keyword_hash_node
+        node.elements.map do |element|
+          key = node_to_s(element.key)
+          value = node_to_s(element.value)
+
+          "#{key} #{value}"
+        end
+      when :symbol_node
+        "#{node.opening}#{node.value}#{node.closing}"
+      when :string_node
+        "#{node.opening}#{node.content}#{node.closing}"
+      when :array_node
+        separator = node.opening == "[" ? ", " : " "
+
+        node.opening + node.elements.map do |element|
+          node_to_s(element)
+        end.join(separator) + node.closing
+      when :true_node
+        "true"
+      when :false_node
+        "false"
+      when :arguments_node
+        return if node.child_nodes.empty?
+
+        node.child_nodes.map { |child| node_to_s(child) }.join(", ")
+      else
+        raise Rebundler::Error, "Unsupported node type: #{node.type}"
+      end
+    end
+  end
+end

data/lib/rebundler/version.rb

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

data/lib/rebundler/visitor.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Rebundler
+  class Visitor < Prism::Visitor
+    def initialize(parser)
+      super()
+      @parser = parser
+      @current_set = @parser.gem_sets.find(&:default)
+    end
+
+    def visit_call_node(node)
+      case node.name
+      when :plugin
+        parsed_gem = GemFetcher.parse_gem(node)
+        @current_set.plugins << parsed_gem if parsed_gem
+      when :gem
+        parsed_gem = GemFetcher.parse_gem(node)
+        @current_set.gems << parsed_gem if parsed_gem
+      when *BLOCK_NODES
+        if node.block
+          name = Serializer.node_to_s(node)
+
+          previous_set = @current_set
+          @current_set = @parser.find_or_build_set(name:, node:)
+          node.block.body&.accept(self)
+          @current_set = previous_set
+        else
+          @parser.preamble_nodes << node
+        end
+      end
+    end
+  end
+end

data/lib/rebundler/writer.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Rebundler
+  class Writer
+    def initialize(parser)
+      @parser = parser
+    end
+
+    def write!
+      buffer = []
+
+      buffer << "# frozen_string_literal: true" if frozen_string_literal
+
+      preamble_nodes.each do |node|
+        buffer << Serializer.node_to_s(node)
+      end
+
+      gem_sets.sort.each do |set|
+        set_buffer = []
+
+        set_buffer << [Serializer.node_to_s(set.node), set.node.block.opening].compact.join(" ") if set.node
+
+        set_buffer << [set.plugins, set.gems].map do |nodes|
+          sorted = nodes.sort_by { |node| node[:name].tr("-_", "").downcase }
+
+          sorted.map do |gem|
+            line = +""
+            line << "  " if set.node
+            line << Serializer.node_to_s(gem[:node])
+            line << " # #{gem[:summary]}" if gem[:summary]
+
+            line
+          end.join("\n")
+        end.reject(&:empty?).join("\n\n")
+
+        set_buffer << set.node.block.closing if set.node&.block
+
+        buffer << set_buffer.join("\n")
+      end
+
+      buffer.reject(&:empty?).join("\n\n") + "\n"
+    end
+
+    private
+
+    def preamble_nodes
+      @parser.preamble_nodes
+    end
+
+    def gem_sets
+      @parser.gem_sets
+    end
+
+    def frozen_string_literal
+      @parser.frozen_string_literal
+    end
+  end
+end

data/lib/rebundler.rb

@@ -1,11 +1,13 @@
 # frozen_string_literal: true
 
-require_relative "rebundler/version"
-require_relative "rebundler/parser"
-
-require_relative "bundler/rebundle"
+require "zeitwerk"
+loader = Zeitwerk::Loader.for_gem
+loader.ignore("#{__dir__}/bundler")
+loader.setup
 
 module Rebundler
   class Error < StandardError; end
-  # Your code goes here...
+
+  SORTABLE_NODES = %i[plugin gem].freeze
+  BLOCK_NODES = %i[gemspec git group path platforms ruby source].freeze
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rebundler
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - Dennis Paagman
@@ -25,8 +25,13 @@ files:
 - lib/bundler/rebundle.rb
 - lib/rebundler.rb
 - lib/rebundler/Rakefile
+- lib/rebundler/gem_fetcher.rb
+- lib/rebundler/gem_set.rb
 - lib/rebundler/parser.rb
+- lib/rebundler/serializer.rb
 - lib/rebundler/version.rb
+- lib/rebundler/visitor.rb
+- lib/rebundler/writer.rb
 - plugins.rb
 homepage: https://github.com/dennispaagman/rebundler
 licenses:
@@ -50,7 +55,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.7
+rubygems_version: 3.6.9
 specification_version: 4
 summary: Rebundler makes your Gemfile look good.
 test_files: []