lapidario 0.2alpha.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 721c005dc4e70e80f45c56f387ee66f6c8bbccecf06ca06349aa0ae362efd40f
+  data.tar.gz: 46f65d04260e78be7455b87545fecd6bcafb25b84aec9b4124a7808e84e0452e
+SHA512:
+  metadata.gz: c3ed33e86fded4875b8f3765b1a60954b3f9aca7ef1d81093e87f5895f2749e53e5f664daf0c2801a3b53d0d517001942d819d6f1d37a57fad1659812134f901
+  data.tar.gz: d5fa0f607b5db55ffc32817e2f84dcb25202ca681cb4da94f74e87f4c2da52c0cf0604e0096abb867201b5331cbd4c012fd423037b611e916507581fd821a31b

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,17 @@
+AllCops:
+  TargetRubyVersion: 2.6
+
+Style/StringLiterals:
+  Enabled: true
+  EnforcedStyle: double_quotes
+
+Style/StringLiteralsInInterpolation:
+  Enabled: true
+  EnforcedStyle: double_quotes
+
+Layout/LineLength:
+  Max: 120
+
+AllCops:
+  Exclude:
+    - 'spec/**/*'

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## [Unreleased]
+
+## [0.1.0] - 2023-11-28
+
+- Initial release

data/Gemfile

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in lapidario.gemspec
+gemspec
+
+group :development, :test do
+  gem "pry", "~> 0.14", require: true
+
+  gem "rake", "~> 13.0"
+
+  gem "rspec", "~> 3.0"
+
+  gem "rubocop", "~> 1.21"
+end

data/Gemfile.lock

@@ -0,0 +1,68 @@
+PATH
+  remote: .
+  specs:
+    lapidario (0.1.0alpha)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    ast (2.4.2)
+    coderay (1.1.3)
+    diff-lcs (1.5.0)
+    json (2.6.3)
+    language_server-protocol (3.17.0.3)
+    method_source (1.0.0)
+    parallel (1.23.0)
+    parser (3.2.2.4)
+      ast (~> 2.4.1)
+      racc
+    pry (0.14.2)
+      coderay (~> 1.1)
+      method_source (~> 1.0)
+    racc (1.7.3)
+    rainbow (3.1.1)
+    rake (13.1.0)
+    regexp_parser (2.8.2)
+    rexml (3.2.6)
+    rspec (3.12.0)
+      rspec-core (~> 3.12.0)
+      rspec-expectations (~> 3.12.0)
+      rspec-mocks (~> 3.12.0)
+    rspec-core (3.12.2)
+      rspec-support (~> 3.12.0)
+    rspec-expectations (3.12.3)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.12.0)
+    rspec-mocks (3.12.6)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.12.0)
+    rspec-support (3.12.1)
+    rubocop (1.57.2)
+      json (~> 2.3)
+      language_server-protocol (>= 3.17.0)
+      parallel (~> 1.10)
+      parser (>= 3.2.2.4)
+      rainbow (>= 2.2.2, < 4.0)
+      regexp_parser (>= 1.8, < 3.0)
+      rexml (>= 3.2.5, < 4.0)
+      rubocop-ast (>= 1.28.1, < 2.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (>= 2.4.0, < 3.0)
+    rubocop-ast (1.30.0)
+      parser (>= 3.2.1.0)
+    ruby-progressbar (1.13.0)
+    unicode-display_width (2.5.0)
+
+PLATFORMS
+  x86_64-darwin-22
+
+DEPENDENCIES
+  bundler (~> 2)
+  lapidario!
+  pry (~> 0.14)
+  rake (~> 13.0)
+  rspec (~> 3.0)
+  rubocop (~> 1.21)
+
+BUNDLED WITH
+   2.4.10

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2023 octehren
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,41 @@
+# Lapidario
+
+TODO: Delete this and the text below, and describe your gem
+
+Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/lapidario`. To experiment with that code, run `bin/console` for an interactive prompt.
+
+## TO DO:
+- [ ] Backup system: keep `Gemfile.original` stashed persistently
+- [ ] Add option to ignore Gemfile lines with `# LOCK` commented on their right
+- [ ] Normalize git gems with rubygems from Gemfile.lock
+- [ ] Normalize gems from other sources with rubygems from Gemfile.lock
+
+## Installation
+
+TODO: Replace `UPDATE_WITH_YOUR_GEM_NAME_PRIOR_TO_RELEASE_TO_RUBYGEMS_ORG` with your gem name right after releasing it to RubyGems.org. Please do not do it earlier due to security reasons. Alternatively, replace this section with instructions to install your gem from git if you don't plan to release to RubyGems.org.
+
+Install the gem and add to the application's Gemfile by executing:
+
+    $ bundle add UPDATE_WITH_YOUR_GEM_NAME_PRIOR_TO_RELEASE_TO_RUBYGEMS_ORG
+
+If bundler is not being used to manage dependencies, install the gem by executing:
+
+    $ gem install UPDATE_WITH_YOUR_GEM_NAME_PRIOR_TO_RELEASE_TO_RUBYGEMS_ORG
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/lapidario.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+task default: %i[spec rubocop]

data/bin/console

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "lapidario"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/lapidario

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative "../lib/cli"
+
+Lapidario::CLI.start(ARGV)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lapidario.gemspec

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative "lib/lapidario/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "lapidario"
+  spec.version = Lapidario::VERSION
+  spec.authors = ["octehren"]
+  spec.email = ["ehren.dev.mail@gmail.com"]
+
+  spec.summary = "Auxiliary for bulk updates of gems in a project."
+  spec.description = "Lapidario is a Gemfile and Gemfile.lock static analyzer that helps with bulk updates of gems in a project. As of version 0.1, run it in a directory with both a Gemfile and Gemfile.lock to hard-code the locked versions in Gemfile.lock to the Gemfile."
+  spec.homepage = "https://example.com"
+  spec.license = "MIT"
+  spec.required_ruby_version = ">= 2.6.0"
+
+  spec.metadata["allowed_push_host"] = "https://rubygems.org"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://example.com"
+  spec.metadata["changelog_uri"] = "https://example.com" # Put your gem's CHANGELOG.md URL here.
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(__dir__) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (File.expand_path(f) == __FILE__) || f.start_with?(*%w[test/ spec/ features/ .git .circleci appveyor])
+    end
+  end
+  # spec.bindir = "exe"
+  spec.require_paths = ["lib", "bin"]
+  spec.executables = ["lapidario"]
+
+
+  # Uncomment to register a new dependency of your gem
+  # spec.add_dependency "example-gem", "~> 1.0"
+  spec.add_development_dependency "bundler", "~> 2"
+  spec.add_development_dependency "rspec", "~> 3.12"
+
+  # For more information and examples about making a new gem, check out our
+  # guide at: https://bundler.io/guides/creating_gem.html
+end

data/lib/cli.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+require "optparse"
+require_relative "lapidario"
+
+module Lapidario
+  module CLI
+    def self.start(_cmd_args)
+      puts "cmd args: #{_cmd_args}"
+      project_path_hash = { project_path: './' }
+      info_instances = Lapidario.get_gemfile_and_lockfile_info(project_path_hash)
+      gemfile_info = info_instances[0]
+      lockfile_info = info_instances[1]
+      original_gemfile_lines = gemfile_info.original_gemfile
+      new_gemfile_info = Lapidario.hardcode_lockfile_versions_into_gemfile_info(gemfile_info, lockfile_info)
+      new_gemfile = Lapidario.build_new_gemfile(new_gemfile_info, original_gemfile_lines)
+      puts "New gemfile created:"
+      puts new_gemfile
+      puts "In case it does not look right, check for Gemfile.original in the same directory."
+    end
+  end
+end

data/lib/gemfile_info.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require_relative "helper"
+
+module Lapidario
+  class GemfileInfo
+    attr_accessor :gemfile_lines_info
+    attr_reader :original_gemfile
+
+    def initialize(gemfile_as_strings)
+      @original_gemfile = gemfile_as_strings
+      # array of hashes:
+      # { line_number: int; name: string; prepended_spaces: int;
+      # current_version: string; version_sign: string; extra_info: string}
+      @gemfile_lines_info = Lapidario::GemfileInfo.extract_gemfile_lines_info(gemfile_as_strings)
+    end
+
+    def self.get_gem_name(gem_name_item)
+      gem_name_item.sub("gem ", "").gsub("'", "").gsub('"', "")
+    end
+
+    # detects version field, removes it from array and returns it
+    def self.pop_version_field!(gemfile_line_items)
+      version_index = 0
+      version_number_and_sign = []
+      gemfile_line_items
+        .map { |item| item.gsub('"', "").gsub("'", "").gsub(" ", "") } # can be something like [" '~> 6.3'"]
+        .each_with_index do |item, index|
+          next unless Lapidario::Helper.version_fragment? item
+
+          version_number_and_sign = item
+          version_index = index
+          break # will break at first index, so if there is an upper range index later this won't affect results
+        end
+
+      return [] if version_number_and_sign.empty?
+
+      version_number = version_number_and_sign.gsub(/(~>|>=|<=|>|<)/, "")
+      version_sign = version_number_and_sign.gsub(/[^~>=<]/, "")
+
+      gemfile_line_items.delete_at(version_index)
+      [version_number, version_sign]
+    end
+
+    def self.gem_info(gemfile_line, line_index = -9999)
+      gem_info = { line_index: line_index, name: "", prepended_spaces: 0, current_version: "", version_sign: "", extra_info: "" }
+      # count prepended spaces to reuse on gemfile rebuild
+      gem_info[:prepended_spaces] = gemfile_line.match(/\A\s*/)[0].size
+      # splits on coma, removes prepended whitespaces if any
+      gemfile_line_items = gemfile_line.sub(/\A\s*/, '').split(",")
+      # first element will always be gem name, so return and remove it with shift; remove all spaces in edge case that gem has trailing spaces
+      gem_info[:name] = Lapidario::GemfileInfo.get_gem_name(gemfile_line_items.shift).gsub(' ','')
+      # second might not be the version number, so find the version, store it separetly and remove it from the rest of the line
+      version_number_and_sign = Lapidario::GemfileInfo.pop_version_field!(gemfile_line_items)
+      # to_s will make a nil value an empty string
+      gem_info[:current_version] = version_number_and_sign[0].to_s
+      gem_info[:version_sign] = version_number_and_sign[1].to_s
+      # in case version is ranged, run pop_version_field! again, just removing the field and appending it to the beginning of extra info, immediately after lower range.
+      version_upper_range = Lapidario::GemfileInfo.pop_version_field!(gemfile_line_items)
+      unless version_upper_range.empty?
+        gemfile_line_items.unshift("'#{version_upper_range[1]} #{version_upper_range[0]}'")
+      end
+      # all that's left is extra_info
+      gem_info[:extra_info] = gemfile_line_items.compact.join(", ").split(",").join(", ").gsub(/\s+/, " ").strip
+      gem_info
+    end
+
+    def self.extract_gemfile_lines_info(gemfile_as_strings)
+      gemfile_lines = []
+      gemfile_as_strings.each_with_index do |line, index|
+        gemfile_lines << Lapidario::GemfileInfo.gem_info(line, index) if Lapidario::Helper.gem_line? line
+      end
+      gemfile_lines
+    end
+
+    # gi = gem_info
+    def self.build_gemfile_line(gi)
+      line = "#{' ' * gi[:prepended_spaces].to_i}gem '#{gi[:name]}'"
+      if gi[:current_version]
+        version_fragment = "#{gi[:current_version]}"
+        version_fragment = "#{gi[:version_sign]} " + version_fragment if gi[:version_sign]
+        line = line + ", '#{version_fragment}'"
+      end
+      line = line + ", #{gi[:extra_info]}" if gi[:extra_info] && !gi[:extra_info].empty?
+      line
+    end
+  end
+end

data/lib/helper.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module Lapidario
+  module Helper
+    # regex to match the version fragment in a Gemfile, such as '~> 0.21', '1.2', '>= 10.2.1', '1.2alpha' etc;
+    @@GEM_VERSION_FRAGMENT = /^\s*([<>]=?|~>)?\s*[0-9a-zA-Z\s.]+\s*$/
+    @@DETECT_GEMFILE_IN_PATH = /\/Gemfile/
+    @@DETECT_LOCKFILE_IN_PATH = /\/Gemfile\.lock/
+
+    def self.version_fragment?(line_section)
+      line_section.match? @@GEM_VERSION_FRAGMENT
+    end
+
+    def self.gem_line?(gemfile_line)
+      gemfile_line.match?(/^\s*gem\s+["']([^"']+)["']/)
+    end
+
+    # formats based on depth; ex: version_fragment = '3.12.4' with depth 2 returns 3.12
+    def self.format_version_based_on_depth(version_fragment, depth = 2)
+      raise Lapidario::Error, "Tried to format #{version_fragment} with inadequate depth '#{depth}'." unless depth >= 1 && depth <= 3
+      version_fragment.split(".").slice(0, depth).join(".")
+    end
+
+    def self.format_path(filepath, for_lockfile = false)
+      # path can be ./project/, ./project or ./project/Gemfile, but never ./project/Gemfile/
+      appendage = ""
+      appendage = "/" unless (filepath =~ /\/$/ or filepath =~ @@DETECT_GEMFILE_IN_PATH) # checks if path finishes on '/' or if it contains Gemfile (also valid for lockfile)
+      unless for_lockfile
+        appendage = appendage + "Gemfile" unless filepath =~ @@DETECT_GEMFILE_IN_PATH
+      else
+        appendage = appendage + "Gemfile.lock" unless filepath =~ @@DETECT_LOCKFILE_IN_PATH
+      end
+      filepath + appendage
+    end
+
+    def self.save_file(save_path, content)
+      File.write(save_path, content)
+    end
+
+    def self.get_file_as_array_of_lines(filepath)
+      begin
+        File.read(filepath).split("\n")
+      rescue => e
+        raise Lapidario::Error, "#{e.message}\n\nDouble-check the path provided for the Gemfile or Gemfile.lock\nProvided path:\n#{filepath}"
+      end
+    end
+
+    # Lockfile-focused helpers
+    def self.slice_up_to_next_empty_line(initial_index, lines_array)
+      final_index = -1
+      (initial_index...lines_array.size).each do |i|
+        final_index = i if lines_array[i].empty?
+      end
+      raise Lapidario::Error, "Gemfile.lock should have an empty line as the last line in the file." if final_index < 0
+      lines_array.slice(initial_index, final_index)
+    end
+
+    # a primary gem line will always begin with 4 whitespaces.
+    def self.lockfile_primary_gem_line?(line)
+      # \A: Asserts the start of the string.
+      # \x20: represents a whitespace character; whitespace is char 32 in ascii, 20 is 32 in hex
+      # {4}: Indicates exactly 4 occurrences of the preceding character (whitespace in this case).
+      line.match?(/\A\x20{4}[A-Za-z0-9]/)
+    end
+  end
+end

data/lib/lapidario/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Lapidario
+  VERSION = "0.2alpha.0"
+end

data/lib/lapidario.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+require_relative "lapidario/version"
+require_relative "helper"
+require_relative "lockfile_info"
+require_relative "gemfile_info"
+
+module Lapidario
+  class Error < StandardError; end
+
+  ######################
+  ## shared processes ## ex: steps for specific processes, used more than once
+  ######################
+
+  # first step: build gemfile and lockfile info instances
+  # input: project_path_hash; has either :project_path key or both :gemfile_path and :lockfile_path; returns GemfileInfo and LockfileInfo instances
+  def self.get_gemfile_and_lockfile_info(project_path_hash)
+    project_path = project_path_hash[:project_path]
+    if (project_path && !project_path.empty?)
+      gemfile_path, lockfile_path = Lapidario::Helper.format_path(project_path, false), Lapidario::Helper.format_path(project_path, true)
+    elsif !(project_path_hash[:gemfile_path] && !project_path_hash[:gemfile_path].empty?) && !(project_path_hash[:lockfile_path] && !project_path_hash[:lockfile_path].empty?)
+      raise Lapidario::Error, "Double-check input for project path."
+    else
+      gemfile_path, lockfile_path = Lapidario::Helper.format_path(project_path_hash[:gemfile_path], false), Lapidario::Helper.format_path(project_path_hash[:lockfile_path], true)
+    end
+    
+    gemfile_info = Lapidario::GemfileInfo.new(Lapidario::Helper.get_file_as_array_of_lines(gemfile_path))
+    lockfile_info = Lapidario::LockfileInfo.new(Lapidario::Helper.get_file_as_array_of_lines(lockfile_path))
+    [gemfile_info, lockfile_info]
+  end
+
+  # semi-final step: build new temporary gemfile, replacing changed lines in the original; intermediary object will be altered by one of the methods at the bottom of the page
+  def self.build_new_gemfile(new_gemfile_info, original_gemfile_lines)
+    new_gemfile = original_gemfile_lines.clone
+    new_gemfile_info.each do |info_item|
+      new_line = Lapidario::GemfileInfo.build_gemfile_line(info_item)
+      new_gemfile[info_item[:line_index]] = new_line
+    end
+    new_gemfile
+  end
+
+  # final step: save new, backup old
+  def self.save_gemfiles(save_path, new_gemfile, original_gemfile)
+    # save original gemfile as backup
+    original_save_path = Lapidario::Helper.format_path(save_path) + ".original"
+    Lapidario::Helper.save_file(original_save_path, original_gemfile.join("\n"))
+    # overwrite current Gemfile with new content
+    new_save_path = Lapidario::Helper.format_path(save_path)
+    Lapidario::Helper.save_file(new_save_path, new_gemfile.join("\n"))
+  end
+
+  ######################
+  # specific processes # ex: specific functionality achieved through composition of shared processes
+  ######################
+
+  # loops through lockfile info, collecting versions
+  # hard-codes these versions on gemfile, as they might differ from the lockfile's
+  # will use '~>' as default sign and 2 as default depth
+  def self.hardcode_lockfile_versions_into_gemfile_info(gemfile_info, lockfile_info, default_sign = '~>', default_depth = 2)
+    new_gemfile_info = gemfile_info.gemfile_lines_info.clone
+    lockfile_primary_gems = lockfile_info.primary_gems
+    # replace versions in gemfile with ones on lockfile
+    new_gemfile_info.each do |gem_info|
+      lock_version = lockfile_primary_gems[gem_info[:name]]
+      if lock_version
+        gem_info[:current_version] = lock_version
+        gem_info[:current_version] = Lapidario::Helper.format_version_based_on_depth(lock_version, default_depth) if default_depth
+        gem_info[:version_sign] = default_sign if default_sign && !default_sign.empty?
+      end
+    end
+    new_gemfile_info
+  end
+end

data/lib/lockfile_info.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require_relative "helper"
+
+module Lapidario
+  class LockfileInfo
+    attr_accessor :primary_gems
+    
+    def initialize(gemfile_lock_as_strings)
+      @git_gems = []
+      @rubygems_gems = Lapidario::LockfileInfo.get_rubygems_from_gemfile_lock(gemfile_lock_as_strings)
+      # joins gem names and versions from git/rubygems/other sources in a single format
+      @primary_gems = @rubygems_gems
+    end
+
+    def puts_versionless_rubygems_info
+      versionless_gems = []
+      @rubygems_gems.each do |gem, version|
+        versionless_gems << [gem, version] if version.nil? || version.empty?
+      end
+      print "#{versionless_gems.join("\n")}\nThere are #{versionless_gems.size} gems without specified version, names are listed above."
+    end
+
+    def git_gems?
+      puts "TODO"
+    end
+
+    # gets gems installed from rubygems; in the future check also for other remote sources
+    def self.get_rubygems_from_gemfile_lock(gemfile_lock_as_strings)
+      gem_section = []
+      gem_names_and_versions = {}
+      gemfile_lock_as_strings.each_with_index do |line, index|
+        gem_section = Helper.slice_up_to_next_empty_line(index, gemfile_lock_as_strings) if line == "GEM"
+      end
+
+      if gem_section.empty?
+        raise "#{gemfile_lock_as_strings.join("\n")}\n\nEND OF OUTPUT\nA line consisting of a single 'GEM' string with no further chars wasn't found. See output above."
+      end
+
+      gem_section.each do |line|
+        next unless Lapidario::Helper.lockfile_primary_gem_line? line
+
+        gem_name_and_version = line.clone.strip.split(" ")
+        name = gem_name_and_version[0]
+        version = gem_name_and_version[1]
+        gem_names_and_versions[name] = version ? version.gsub(/[()]/, "") : ""
+      end
+      gem_names_and_versions
+    end
+  end
+end

data/sig/lapidario.rbs

@@ -0,0 +1,4 @@
+module Lapidario
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -0,0 +1,99 @@
+--- !ruby/object:Gem::Specification
+name: lapidario
+version: !ruby/object:Gem::Version
+  version: 0.2alpha.0
+platform: ruby
+authors:
+- octehren
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2023-12-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
+description: Lapidario is a Gemfile and Gemfile.lock static analyzer that helps with
+  bulk updates of gems in a project. As of version 0.1, run it in a directory with
+  both a Gemfile and Gemfile.lock to hard-code the locked versions in Gemfile.lock
+  to the Gemfile.
+email:
+- ehren.dev.mail@gmail.com
+executables:
+- lapidario
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- ".rubocop.yml"
+- CHANGELOG.md
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/lapidario
+- bin/setup
+- lapidario.gemspec
+- lib/cli.rb
+- lib/gemfile_info.rb
+- lib/helper.rb
+- lib/lapidario.rb
+- lib/lapidario/version.rb
+- lib/lockfile_info.rb
+- sig/lapidario.rbs
+homepage: https://example.com
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://example.com
+  source_code_uri: https://example.com
+  changelog_uri: https://example.com
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+- bin
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.6.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">"
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubygems_version: 3.4.10
+signing_key:
+specification_version: 4
+summary: Auxiliary for bulk updates of gems in a project.
+test_files: []