bundler 1.11.1 → 2.2.6

data/lib/bundler/lockfile_generator.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module Bundler
+  class LockfileGenerator
+    attr_reader :definition
+    attr_reader :out
+
+    # @private
+    def initialize(definition)
+      @definition = definition
+      @out = String.new
+    end
+
+    def self.generate(definition)
+      new(definition).generate!
+    end
+
+    def generate!
+      add_sources
+      add_platforms
+      add_dependencies
+      add_locked_ruby_version
+      add_bundled_with
+
+      out
+    end
+
+    private
+
+    def add_sources
+      definition.send(:sources).lock_sources.each_with_index do |source, idx|
+        out << "\n" unless idx.zero?
+
+        # Add the source header
+        out << source.to_lock
+
+        # Find all specs for this source
+        specs = definition.resolve.select {|s| source.can_lock?(s) }
+        add_specs(specs)
+      end
+    end
+
+    def add_specs(specs)
+      # This needs to be sorted by full name so that
+      # gems with the same name, but different platform
+      # are ordered consistently
+      specs.sort_by(&:full_name).each do |spec|
+        next if spec.name == "bundler".freeze
+        out << spec.to_lock
+      end
+    end
+
+    def add_platforms
+      add_section("PLATFORMS", definition.platforms)
+    end
+
+    def add_dependencies
+      out << "\nDEPENDENCIES\n"
+
+      handled = []
+      definition.dependencies.sort_by(&:to_s).each do |dep|
+        next if handled.include?(dep.name)
+        out << dep.to_lock
+        handled << dep.name
+      end
+    end
+
+    def add_locked_ruby_version
+      return unless locked_ruby_version = definition.locked_ruby_version
+      add_section("RUBY VERSION", locked_ruby_version.to_s)
+    end
+
+    def add_bundled_with
+      add_section("BUNDLED WITH", definition.locked_bundler_version.to_s)
+    end
+
+    def add_section(name, value)
+      out << "\n#{name}\n"
+      case value
+      when Array
+        value.map(&:to_s).sort.each do |val|
+          out << "  #{val}\n"
+        end
+      when Hash
+        value.to_a.sort_by {|k, _| k.to_s }.each do |key, val|
+          out << "  #{key}: #{val}\n"
+        end
+      when String
+        out << "   #{value}\n"
+      else
+        raise ArgumentError, "#{value.inspect} can't be serialized in a lockfile"
+      end
+    end
+  end
+end

data/lib/bundler/lockfile_parser.rb

@@ -1,5 +1,6 @@
-require "strscan"
+# frozen_string_literal: true
 
+#--
 # Some versions of the Bundler 1.1 RC series introduced corrupted
 # lockfiles. There were two major problems:
 #
@@ -12,22 +13,54 @@ require "strscan"
 
 module Bundler
   class LockfileParser
-    attr_reader :sources, :dependencies, :specs, :platforms, :bundler_version
-
-    BUNDLED      = "BUNDLED WITH"
-    DEPENDENCIES = "DEPENDENCIES"
-    PLATFORMS    = "PLATFORMS"
-    GIT          = "GIT"
-    GEM          = "GEM"
-    PATH         = "PATH"
-    SPECS        = "  specs:"
-    OPTIONS      = /^  ([a-z]+): (.*)$/i
-    SOURCE       = [GIT, GEM, PATH]
+    attr_reader :sources, :dependencies, :specs, :platforms, :bundler_version, :ruby_version
+
+    BUNDLED      = "BUNDLED WITH".freeze
+    DEPENDENCIES = "DEPENDENCIES".freeze
+    PLATFORMS    = "PLATFORMS".freeze
+    RUBY         = "RUBY VERSION".freeze
+    GIT          = "GIT".freeze
+    GEM          = "GEM".freeze
+    PATH         = "PATH".freeze
+    PLUGIN       = "PLUGIN SOURCE".freeze
+    SPECS        = "  specs:".freeze
+    OPTIONS      = /^  ([a-z]+): (.*)$/i.freeze
+    SOURCE       = [GIT, GEM, PATH, PLUGIN].freeze
+
+    SECTIONS_BY_VERSION_INTRODUCED = {
+      Gem::Version.create("1.0") => [DEPENDENCIES, PLATFORMS, GIT, GEM, PATH].freeze,
+      Gem::Version.create("1.10") => [BUNDLED].freeze,
+      Gem::Version.create("1.12") => [RUBY].freeze,
+      Gem::Version.create("1.13") => [PLUGIN].freeze,
+    }.freeze
+
+    KNOWN_SECTIONS = SECTIONS_BY_VERSION_INTRODUCED.values.flatten.freeze
+
+    ENVIRONMENT_VERSION_SECTIONS = [BUNDLED, RUBY].freeze
+
+    def self.sections_in_lockfile(lockfile_contents)
+      lockfile_contents.scan(/^\w[\w ]*$/).uniq
+    end
+
+    def self.unknown_sections_in_lockfile(lockfile_contents)
+      sections_in_lockfile(lockfile_contents) - KNOWN_SECTIONS
+    end
+
+    def self.sections_to_ignore(base_version = nil)
+      base_version &&= base_version.release
+      base_version ||= Gem::Version.create("1.0".dup)
+      attributes = []
+      SECTIONS_BY_VERSION_INTRODUCED.each do |version, introduced|
+        next if version <= base_version
+        attributes += introduced
+      end
+      attributes
+    end
 
     def initialize(lockfile)
       @platforms    = []
       @sources      = []
-      @dependencies = []
+      @dependencies = {}
       @state        = nil
       @specs        = {}
 
@@ -46,6 +79,8 @@ module Bundler
           @state = :dependency
         elsif line == PLATFORMS
           @state = :platform
+        elsif line == RUBY
+          @state = :ruby
         elsif line == BUNDLED
           @state = :bundled_with
         elsif line =~ /^[^\s]/
@@ -54,8 +89,8 @@ module Bundler
           send("parse_#{@state}", line)
         end
       end
-      @sources << @rubygems_aggregate
-      @specs = @specs.values
+      @sources << @rubygems_aggregate unless Bundler.feature_flag.disable_multisource?
+      @specs = @specs.values.sort_by(&:identifier)
       warn_for_outdated_bundler_version
     rescue ArgumentError => e
       Bundler.ui.debug(e)
@@ -67,33 +102,24 @@ module Bundler
       return unless bundler_version
       prerelease_text = bundler_version.prerelease? ? " --pre" : ""
       current_version = Gem::Version.create(Bundler::VERSION)
-      case current_version.segments.first <=> bundler_version.segments.first
-      when -1
-        raise LockfileError, "You must use Bundler #{bundler_version.segments.first} or greater with this lockfile."
-      when 0
-        if current_version < bundler_version
-          Bundler.ui.warn "Warning: the running version of Bundler is older " \
-               "than the version that created the lockfile. We suggest you " \
-               "upgrade to the latest version of Bundler by running `gem " \
-               "install bundler#{prerelease_text}`.\n"
-        end
-      end
+      return unless current_version < bundler_version
+      Bundler.ui.warn "Warning: the running version of Bundler (#{current_version}) is older " \
+           "than the version that created the lockfile (#{bundler_version}). We suggest you to " \
+           "upgrade to the version that created the lockfile by running `gem install " \
+           "bundler:#{bundler_version}#{prerelease_text}`.\n"
     end
 
-  private
+    private
 
     TYPES = {
-      GIT  => Bundler::Source::Git,
-      GEM  => Bundler::Source::Rubygems,
-      PATH => Bundler::Source::Path,
-    }
+      GIT    => Bundler::Source::Git,
+      GEM    => Bundler::Source::Rubygems,
+      PATH   => Bundler::Source::Path,
+      PLUGIN => Bundler::Plugin,
+    }.freeze
 
     def parse_source(line)
       case line
-      when GIT, GEM, PATH
-        @current_source = nil
-        @opts = {}
-        @type = line
       when SPECS
         case @type
         when PATH
@@ -108,10 +134,19 @@ module Bundler
             @sources << @current_source
           end
         when GEM
-          Array(@opts["remote"]).each do |url|
-            @rubygems_aggregate.add_remote(url)
+          if Bundler.feature_flag.disable_multisource?
+            @opts["remotes"] = @opts.delete("remote")
+            @current_source = TYPES[@type].from_lock(@opts)
+            @sources << @current_source
+          else
+            Array(@opts["remote"]).each do |url|
+              @rubygems_aggregate.add_remote(url)
+            end
+            @current_source = @rubygems_aggregate
           end
-          @current_source = @rubygems_aggregate
+        when PLUGIN
+          @current_source = Plugin.source_from_lock(@opts)
+          @sources << @current_source
         end
       when OPTIONS
         value = $2
@@ -126,57 +161,71 @@ module Bundler
         else
           @opts[key] = value
         end
+      when *SOURCE
+        @current_source = nil
+        @opts = {}
+        @type = line
       else
         parse_spec(line)
       end
     end
 
-    NAME_VERSION = '(?! )(.*?)(?: \(([^-]*)(?:-(.*))?\))?'
-    NAME_VERSION_2 = /^ {2}#{NAME_VERSION}(!)?$/
-    NAME_VERSION_4 = /^ {4}#{NAME_VERSION}$/
-    NAME_VERSION_6 = /^ {6}#{NAME_VERSION}$/
+    space = / /
+    NAME_VERSION = /
+      ^(#{space}{2}|#{space}{4}|#{space}{6})(?!#{space}) # Exactly 2, 4, or 6 spaces at the start of the line
+      (.*?)                                              # Name
+      (?:#{space}\(([^-]*)                               # Space, followed by version
+      (?:-(.*))?\))?                                     # Optional platform
+      (!)?                                               # Optional pinned marker
+      $                                                  # Line end
+    /xo.freeze
 
     def parse_dependency(line)
-      if line =~ NAME_VERSION_2
-        name = $1
-        version = $2
-        pinned = $4
-        version = version.split(",").map(&:strip) if version
-
-        dep = Bundler::Dependency.new(name, version)
-
-        if pinned && dep.name != "bundler"
-          spec = @specs.find {|_, v| v.name == dep.name }
-          dep.source = spec.last.source if spec
-
-          # Path sources need to know what the default name / version
-          # to use in the case that there are no gemspecs present. A fake
-          # gemspec is created based on the version set on the dependency
-          # TODO: Use the version from the spec instead of from the dependency
-          if version && version.size == 1 && version.first =~ /^\s*= (.+)\s*$/ && dep.source.is_a?(Bundler::Source::Path)
-            dep.source.name    = name
-            dep.source.version = $1
-          end
+      return unless line =~ NAME_VERSION
+      spaces = $1
+      return unless spaces.size == 2
+      name = $2
+      version = $3
+      pinned = $5
+
+      version = version.split(",").map(&:strip) if version
+
+      dep = Bundler::Dependency.new(name, version)
+
+      if pinned && dep.name != "bundler"
+        spec = @specs.find {|_, v| v.name == dep.name }
+        dep.source = spec.last.source if spec
+
+        # Path sources need to know what the default name / version
+        # to use in the case that there are no gemspecs present. A fake
+        # gemspec is created based on the version set on the dependency
+        # TODO: Use the version from the spec instead of from the dependency
+        if version && version.size == 1 && version.first =~ /^\s*= (.+)\s*$/ && dep.source.is_a?(Bundler::Source::Path)
+          dep.source.name    = name
+          dep.source.version = $1
         end
-
-        @dependencies << dep
       end
+
+      @dependencies[dep.name] = dep
     end
 
     def parse_spec(line)
-      if line =~ NAME_VERSION_4
-        name = $1
-        version = Gem::Version.new($2)
-        platform = $3 ? Gem::Platform.new($3) : Gem::Platform::RUBY
+      return unless line =~ NAME_VERSION
+      spaces = $1
+      name = $2
+      version = $3
+      platform = $4
+
+      if spaces.size == 4
+        version = Gem::Version.new(version)
+        platform = platform ? Gem::Platform.new(platform) : Gem::Platform::RUBY
         @current_spec = LazySpecification.new(name, version, platform)
         @current_spec.source = @current_source
 
         # Avoid introducing multiple copies of the same spec (caused by
         # duplicate GIT sections)
         @specs[@current_spec.identifier] ||= @current_spec
-      elsif line =~ NAME_VERSION_6
-        name = $1
-        version = $2
+      elsif spaces.size == 6
         version = version.split(",").map(&:strip) if version
         dep = Gem::Dependency.new(name, version)
         @current_spec.dependencies << dep
@@ -189,9 +238,12 @@ module Bundler
 
     def parse_bundled_with(line)
       line = line.strip
-      if Gem::Version.correct?(line)
-        @bundler_version = Gem::Version.create(line)
-      end
+      return unless Gem::Version.correct?(line)
+      @bundler_version = Gem::Version.create(line)
+    end
+
+    def parse_ruby(line)
+      @ruby_version = line.strip
     end
   end
 end

data/lib/bundler/man/bundle-add.1

@@ -0,0 +1,66 @@
+.\" generated with Ronn/v0.7.3
+.\" http://github.com/rtomayko/ronn/tree/0.7.3
+.
+.TH "BUNDLE\-ADD" "1" "November 2020" "" ""
+.
+.SH "NAME"
+\fBbundle\-add\fR \- Add gem to the Gemfile and run bundle install
+.
+.SH "SYNOPSIS"
+\fBbundle add\fR \fIGEM_NAME\fR [\-\-group=GROUP] [\-\-version=VERSION] [\-\-source=SOURCE] [\-\-git=GIT] [\-\-branch=BRANCH] [\-\-skip\-install] [\-\-strict] [\-\-optimistic]
+.
+.SH "DESCRIPTION"
+Adds the named gem to the Gemfile and run \fBbundle install\fR\. \fBbundle install\fR can be avoided by using the flag \fB\-\-skip\-install\fR\.
+.
+.P
+Example:
+.
+.P
+bundle add rails
+.
+.P
+bundle add rails \-\-version "< 3\.0, > 1\.1"
+.
+.P
+bundle add rails \-\-version "~> 5\.0\.0" \-\-source "https://gems\.example\.com" \-\-group "development"
+.
+.P
+bundle add rails \-\-skip\-install
+.
+.P
+bundle add rails \-\-group "development, test"
+.
+.SH "OPTIONS"
+.
+.TP
+\fB\-\-version\fR, \fB\-v\fR
+Specify version requirements(s) for the added gem\.
+.
+.TP
+\fB\-\-group\fR, \fB\-g\fR
+Specify the group(s) for the added gem\. Multiple groups should be separated by commas\.
+.
+.TP
+\fB\-\-source\fR, , \fB\-s\fR
+Specify the source for the added gem\.
+.
+.TP
+\fB\-\-git\fR
+Specify the git source for the added gem\.
+.
+.TP
+\fB\-\-branch\fR
+Specify the git branch for the added gem\.
+.
+.TP
+\fB\-\-skip\-install\fR
+Adds the gem to the Gemfile but does not install it\.
+.
+.TP
+\fB\-\-optimistic\fR
+Adds optimistic declaration of version
+.
+.TP
+\fB\-\-strict\fR
+Adds strict declaration of version
+

data/lib/bundler/man/bundle-add.1.ronn

@@ -0,0 +1,46 @@
+bundle-add(1) -- Add gem to the Gemfile and run bundle install
+================================================================
+
+## SYNOPSIS
+
+`bundle add` <GEM_NAME> [--group=GROUP] [--version=VERSION] [--source=SOURCE] [--git=GIT] [--branch=BRANCH] [--skip-install] [--strict] [--optimistic]
+
+## DESCRIPTION
+Adds the named gem to the Gemfile and run `bundle install`. `bundle install` can be avoided by using the flag `--skip-install`.
+
+Example:
+
+bundle add rails
+
+bundle add rails --version "< 3.0, > 1.1"
+
+bundle add rails --version "~> 5.0.0" --source "https://gems.example.com" --group "development"
+
+bundle add rails --skip-install
+
+bundle add rails --group "development, test"
+
+## OPTIONS
+* `--version`, `-v`:
+  Specify version requirements(s) for the added gem.
+
+* `--group`, `-g`:
+  Specify the group(s) for the added gem. Multiple groups should be separated by commas.
+
+* `--source`, , `-s`:
+  Specify the source for the added gem.
+
+* `--git`:
+  Specify the git source for the added gem.
+
+* `--branch`:
+  Specify the git branch for the added gem.
+
+* `--skip-install`:
+  Adds the gem to the Gemfile but does not install it.
+
+* `--optimistic`:
+  Adds optimistic declaration of version
+
+* `--strict`:
+  Adds strict declaration of version