gem_sorter 0.1.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d91ddab7a3117bdca0c33158d6b6cb836e1eb75126ef8e101335bc0ddb55daa4
-  data.tar.gz: 0b059c69f84a26e5f55b603777e73a1941b3be1e0bc64f7b247b213ce27fed04
+  metadata.gz: 91f751af186dcb78cb90b9acbf22c086e895dc6b74ad6b202783fe3f6d799a3d
+  data.tar.gz: dc18ef774b7be132570b526e510c95022b0da490b45fd4483d6ec6ae39a0b1aa
 SHA512:
-  metadata.gz: 70d59f3a8cd42b31378ba99433db9e638aca693ad0c4cf83143f12aa4e381bdd6e34c1e6067a56633d0fc20282993bc35e4c0b3c1c36ffeaf8d83514b2927b26
-  data.tar.gz: f64d158253309097b7b5cf9b4421414ea4d69635f27e8e071a67ddc8b084a7f751f47f0973cbbec6e1b0ff9fb71e90f6bb2c3dad8461cb61faa649b189ab1d64
+  metadata.gz: 3c527d936237f42547330dc39c740aaca01788a20a3c6e73024ebcddd11dbbce80d74bdeab5d7c39391d7beca6b23264a20fd25e79a1f44c58bb588164ae7238
+  data.tar.gz: 9a640f1ee3d35cd1aa019cea2b9e0eb7898c3d39d0635334660f527073faeea0d5cf860ce5dfc7c90478d8c5f2361b61dbb083621805f95ae153a7900ef85d26

data/README.md

@@ -1,3 +1,7 @@
+<p align="center">
+  <img src="https://i.imgur.com/WHOyL9W.png" width="150" alt="GemSorter Logo">
+</p>
+
 # GemSorter
 
 GemSorter is a simple gem to sort the contents of your Gemfile alphabetically while preserving comments and group structure. It helps maintain a clean and organized Gemfile.
@@ -7,6 +11,7 @@ GemSorter is a simple gem to sort the contents of your Gemfile alphabetically wh
 * Preserves comments and their association with gems.
 * Maintains group structure in the Gemfile.
 * Optionally creates a backup of the original Gemfile.
+* Update the comments of the gems based on their descriptions.
 
 ## Installation
 Add the gem to your project's `Gemfile`:
@@ -24,15 +29,40 @@ rake gemfile:sort
 
 ### Options
 * `backup`: Pass `true` to create a backup of your Gemfile as `Gemfile.old` before sorting.
+* `update_comments`: Pass `true` to update the comments of the gems based on their descriptions.
+* `update_versions`: Pass `true` to update the versions of the gems based on the lockfile.
 
 Example:
 
 ```bash
-rake gemfile:sort[true]
+rake gemfile:sort[true,true,true]
 ```
+This will sort your Gemfile, create a backup, and update comments and versions.
 
-This will sort your Gemfile and create a backup.
+### Options File
+Create a file in the root of your project called `gem_sorter.yml`
+* `backup`: Pass `true` to create a backup of your Gemfile as `Gemfile.old` before sorting.
+* `update_comments`: Pass `true` to update the comments of the gems based on their descriptions.
+* `update_versions`: Pass `true` to update the versions of the gems based on the lockfile.
+* `ignore_gems`: Pass an array of GEMs you want to ignore versions and comments
+* `ignore_gem_versions`: Pass an array of GEMs you want to ignore versions
+* `ignore_gem_comments`: Pass an array of GEMs you want to ignore comments
 
+Example:
+
+```yaml
+backup: true
+update_comments: true
+update_versions: false
+ignore_gems:
+  - byebug
+  - discard
+ignore_gem_versions:
+  - rspec
+ignore_gem_comments:
+  - otpor
+```
+This will sort your Gemfile, create a backup, and update comments and versions.
 ## Example
 ### Input Gemfile
 ```ruby
@@ -40,12 +70,11 @@ source "https://rubygems.org"
 
 # Framework
 gem "rails"
-# Web server
-gem "puma"
+gem "puma", "~> 5.3"
 
 group :development do
-  gem "pry"
   gem "dotenv-rails"
+  gem "pry"
 end
 ```
 
@@ -53,13 +82,15 @@ end
 ```ruby
 source "https://rubygems.org"
 
-# Web server
-gem "puma"
-# Framework
-gem "rails"
+# A Ruby/Rack web server built for parallelism.
+gem "puma", "~> 5.3"
+# Full-stack web application framework.
+gem "rails", "~> 8.0", ">= 8.0.1"
 
 group :development do
-  gem "dotenv-rails"
+  # Autoload dotenv in Rails.
+  gem 'dotenv-rails', '~> 3.1', '>= 3.1.7'
+  # A runtime developer console and IRB alternative with powerful introspection capabilities.
   gem "pry"
 end
 ```

data/lib/gem_sorter/version.rb

@@ -1,3 +1,3 @@
 module GemSorter
-  VERSION = '0.1.1'
+  VERSION = '0.3.0'
 end

data/lib/gem_sorter.rb

@@ -1,12 +1,16 @@
 # lib/gem_sorter.rb
+require 'net/http'
+require 'cgi'
 
 load File.expand_path('tasks/gem_sorter.rake', __dir__) if defined?(Rake)
 
 module GemSorter
   class Sorter
-    def initialize(filepath)
-      @filepath = filepath
-      @content = File.read(filepath)
+    def initialize(task_config)
+      @config = task_config
+      @filepath = task_config.gemfile_path
+      @content = File.read(task_config.gemfile_path)
+      @versions = nil
     end
 
     def sort
@@ -16,6 +20,9 @@ module GemSorter
 
       source_line, gems = process_main_section(main_section)
 
+      update_gem_summaries(gems) if @config.update_comments
+      update_version_text(gems) if @config.update_versions
+
       sorted_gems = sort_gem_blocks(gems)
 
       result = []
@@ -26,6 +33,8 @@ module GemSorter
 
       group_sections.each do |section|
         group_gems = process_group_section(section)
+        update_gem_summaries(group_gems) if @config.update_comments
+        update_version_text(group_gems) if @config.update_versions
         result << "group#{section.split("\n").first}"
         result.concat(sort_gem_blocks(group_gems).map { |line| "  #{line}" })
         result << 'end'
@@ -37,6 +46,44 @@ module GemSorter
 
     private
 
+    def update_version_text(gems)
+      @versions ||= fetch_versions_from_lockfile("#{@filepath}.lock")
+      gems.each do |gem_block|
+        gem_name = gem_block[:gem_line].match(/gem\s*"([^"]+)"/)[1]
+        next if @config.ignore_gems.include?(gem_name) || @config.ignore_gem_versions.include?(gem_name)
+
+        version = @versions[gem_name]
+        extra_params = extract_params(gem_block[:gem_line])
+        base = version ? "#{fetch_gemfile_text(gem_name, version, gem_block[:gem_line])}" : gem_block[:gem_line]
+        return base if base == gem_block[:gem_line]
+
+        gem_block[:gem_line] = [base, extra_params].select { |value| !value.nil? && !value.empty? }.join(',')
+      end
+    end
+
+    def extract_params(gem_line)
+      return nil unless gem_line =~ /gem\s*"([^"]+)"/
+
+      if gem_line =~ /gem\s*"[^"]*"\s*,\s*(.*)/
+        additional_params = $1.strip
+        return nil if additional_params.empty?
+        params_with_colon = additional_params.scan(/(\w+:\s*[^,]+)/).flatten
+        return params_with_colon.join(', ') unless params_with_colon.empty?
+      end
+      nil
+    end
+
+    def update_gem_summaries(gems)
+      gems.each do |gem_block|
+        gem_name = gem_block[:gem_line].match(/gem\s*"([^"]+)"/)[1]
+        next if @config.ignore_gems.include?(gem_name) || @config.ignore_gem_comments.include?(gem_name)
+
+        if summary = get_summary(gem_name, false)
+          gem_block[:comments] = ["# #{summary}"]
+        end
+      end
+    end
+
     def process_main_section(section)
       lines = section.split("\n").map(&:strip).reject(&:empty?)
       source_line = lines.shift
@@ -83,7 +130,12 @@ module GemSorter
 
     def sort_gem_blocks(gems)
       sorted = gems.sort_by do |gem_block|
-        gem_block[:gem_line].match(/gem\s*"([^"]+)"/)[1].downcase
+        match_data = gem_block[:gem_line].match(/gem\s*['"]([^'"]+)['"]/)
+        if match_data
+          match_data[1].downcase
+        else
+          ''
+        end
       end
 
       result = []
@@ -94,5 +146,69 @@ module GemSorter
 
       result
     end
+
+    def get_summary(gem_name, remote)
+      source = remote ? "-r" : "-l"
+      output = `gem list -d #{source} -e #{gem_name}`
+      if output.include?(gem_name)
+        summary = output.split("\n").last.strip
+        summary
+      else
+        return get_summary(gem_name, true) unless remote
+        nil
+      end
+    rescue StandardError => e
+      nil
+    end
+
+    def fetch_gemfile_text(gem_name, version, original)
+      base_url = "https://rubygems.org/gems/#{gem_name.strip}"
+      url = URI(version ? "#{base_url}/versions/#{version.strip}" : base_url)
+
+      begin
+        response = Net::HTTP.get(url)
+        unless response
+          raise "Error: Could not fetch gem information from RubyGems for #{gem_name} version #{version}."
+        end
+        match = response.match(/<input[^>]*id=["']gemfile_text["'][^>]*value=["']([^"']+)["']/)
+
+        if match
+          CGI.unescapeHTML(match[1])
+        else
+          raise "Error: Could not extract Gemfile text for #{gem_name} version #{version}."
+        end
+
+      rescue => e
+        puts e.message
+
+        original
+      end
+    end
+
+    def fetch_versions_from_lockfile(lockfile_path)
+      return {} unless File.exist?(lockfile_path)
+    
+      versions = {}
+      inside_specs = false
+    
+      File.readlines(lockfile_path).each do |line|
+        line.strip!
+
+        if line == "specs:"
+          inside_specs = true
+          next
+        end
+
+        inside_specs = false if inside_specs && line.empty?
+
+        if inside_specs && line =~ /^([^\s]+)\s\(([^)]+)\)$/
+          gem_name, gem_version = $1, $2
+          gem_version = gem_version.match(/(\d+\.\d+\.\d+)/)[0] if gem_version =~ /(\d+\.\d+\.\d+)/
+          versions[gem_name] = gem_version
+        end
+      end
+      versions
+    end
+
   end
-end
+end

data/lib/task_config.rb

@@ -0,0 +1,94 @@
+require 'yaml'
+
+class GemSorter::TaskConfig
+  attr_reader :backup, :update_comments, :update_versions, :ignore_gems, :gemfile_path
+
+  DEFAULT_CONFIG = {
+    'backup' => false,
+    'update_comments' => false,
+    'update_versions' => false,
+    'gemfile_path' => 'Gemfile',
+    'ignore_gems' => [],
+    'ignore_gem_versions' => [],
+    'ignore_gem_comments' => [],
+  }.freeze
+
+  def initialize(args = nil)
+    @backup = nil
+    @update_comments = nil
+    @update_versions = nil
+    @ignore_gems = nil
+    @ignore_gem_versions = nil
+    @ignore_gem_comments = nil
+    @gemfile_path = nil
+    load_config(args)
+  end
+
+  def backup
+    @backup.nil? ? DEFAULT_CONFIG['backup'] : @backup
+  end
+
+  def update_comments
+    @update_comments.nil? ? DEFAULT_CONFIG['update_comments'] : @update_comments
+  end
+
+  def update_versions
+    @update_versions.nil? ? DEFAULT_CONFIG['update_versions'] : @update_versions
+  end
+
+  def ignore_gems
+    @ignore_gems.nil? ? DEFAULT_CONFIG['ignore_gems'] : @ignore_gems
+  end
+
+  def ignore_gem_versions
+    @ignore_gem_versions.nil? ? DEFAULT_CONFIG['ignore_gem_versions'] : @ignore_gem_versions
+  end
+
+  def ignore_gem_comments
+    @ignore_gem_comments.nil? ? DEFAULT_CONFIG['ignore_gem_comments'] : @ignore_gem_comments
+  end
+
+  def gemfile_path
+    @gemfile_path.nil? ? DEFAULT_CONFIG['gemfile_path'] : @gemfile_path
+  end
+
+  private
+
+  def load_config(args)
+    load_config_from_file
+    load_config_from_args(args)
+  end
+
+  def load_config_from_file
+    if File.exist?(gem_sorter_config_file_path)
+      task_config = YAML.load_file(gem_sorter_config_file_path)
+      @backup = task_config['backup'] if task_config.key?('backup')
+      @update_comments = task_config['update_comments'] if task_config.key?('update_comments')
+      @update_versions = task_config['update_versions'] if task_config.key?('update_versions')
+      @gemfile_path = task_config['gemfile_path'] if task_config.key?('gemfile_path')
+      @ignore_gems = task_config['ignore_gems'] if task_config.key?('ignore_gems')
+      @ignore_gem_versions = task_config['ignore_gem_versions'] if task_config.key?('ignore_gem_versions')
+      @ignore_gem_comments = task_config['ignore_gem_comments'] if task_config.key?('ignore_gem_comments')
+    end
+  end
+
+  def load_config_from_args(args)
+    return unless args
+
+    @backup = parse_boolean(args[:backup]) unless args[:backup].nil?
+    @update_comments = parse_boolean(args[:update_comments]) unless args[:update_comments].nil?
+    @update_versions = parse_boolean(args[:update_versions]) unless args[:update_versions].nil?
+    @gemfile_path = args[:gemfile_path] unless args[:gemfile_path].nil?
+    @ignore_gems = args[:ignore_gems] unless args[:ignore_gems].nil?
+    @ignore_gem_versions = args[:ignore_gem_versions] unless args[:ignore_gem_versions].nil?
+    @ignore_gem_comments = args[:ignore_gem_comments] unless args[:ignore_gem_comments].nil?
+  end
+
+  def parse_boolean(value)
+    value.to_s.downcase == 'true'
+  end
+
+  def gem_sorter_config_file_path
+    'gem_sorter.yml'
+  end
+end

data/lib/tasks/gem_sorter.rake

@@ -1,25 +1,26 @@
 require 'gem_sorter'
+require 'yaml'
+require 'task_config'
 
 namespace :gemfile do
-  desc 'Sort gems in Gemfile alphabetically'
-  task :sort, [:backup] do |_t, args|
-    args.with_defaults(backup: 'false')
-    gemfile_path = 'Gemfile'
-
-    if File.exist?(gemfile_path)
-      if args.backup.downcase == 'true'
-        FileUtils.cp(gemfile_path, "#{gemfile_path}.old")
+  desc 'Sort gems in Gemfile alphabetically. Options: [backup=true|false] [update_comments=true|false] [update_versions=true|false]'
+  task :sort, [:backup, :update_comments, :update_versions] do |_t, args|
+    task_config = GemSorter::TaskConfig.new(args)
+    
+    if File.exist?(task_config.gemfile_path)
+      if task_config.backup
+        FileUtils.cp(task_config.gemfile_path, "#{task_config.gemfile_path}.old")
         puts 'Original Gemfile backed up as Gemfile.old'
       end
 
-      sorter = ::GemSorter::Sorter.new(gemfile_path)
+      sorter = ::GemSorter::Sorter.new(task_config)
       sorted_content = sorter.sort
 
-      File.write(gemfile_path, sorted_content)
+      File.write(task_config.gemfile_path, sorted_content)
 
       puts 'Gemfile sorted successfully!'
     else
       puts 'Error: Gemfile not found in current directory'
     end
   end
-end
+end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: gem_sorter
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.3.0
 platform: ruby
 authors:
 - Renan Garcia
 bindir: bin
 cert_chain: []
-date: 2025-01-02 00:00:00.000000000 Z
+date: 2025-01-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -48,6 +48,7 @@ files:
 - README.md
 - lib/gem_sorter.rb
 - lib/gem_sorter/version.rb
+- lib/task_config.rb
 - lib/tasks/gem_sorter.rake
 homepage: https://github.com/renan-garcia/gem_sorter
 licenses: