Bundler::RubyVersion

 
 # File bundler/ruby_version.rb, line 58
def self.from_string(string)
 new(1ドル, 2ドル, 3ドル, 4ドル) if string =~ PATTERN
end
 

 
 # File bundler/ruby_version.rb, line 12
def initialize(versions, patchlevel, engine, engine_version)
 # The parameters to this method must satisfy the
 # following constraints, which are verified in
 # the DSL:
 #
 # * If an engine is specified, an engine version
 # must also be specified
 # * If an engine version is specified, an engine
 # must also be specified
 # * If the engine is "ruby", the engine version
 # must not be specified, or the engine version
 # specified must match the version.
 @versions = Array(versions).map do |v|
 op, v = Gem::Requirement.parse(v)
 op == "=" ? v.to_s : "#{op} #{v}"
 end
 @gem_version = Gem::Requirement.create(@versions.first).requirements.first.last
 @input_engine = engine && engine.to_s
 @engine = engine && engine.to_s || "ruby"
 @engine_versions = (engine_version && Array(engine_version)) || @versions
 @engine_gem_version = Gem::Requirement.create(@engine_versions.first).requirements.first.last
 @patchlevel = patchlevel
end
 

 
 # File bundler/ruby_version.rb, line 104
def self.system
 ruby_engine = RUBY_ENGINE.dup
 ruby_version = ENV.fetch("BUNDLER_SPEC_RUBY_VERSION") { RUBY_VERSION }.dup
 ruby_engine_version = RUBY_ENGINE_VERSION.dup
 patchlevel = RUBY_PATCHLEVEL.to_s
 @ruby_version ||= RubyVersion.new(ruby_version, patchlevel, ruby_engine, ruby_engine_version)
end
 

 
 # File bundler/ruby_version.rb, line 66
def ==(other)
 versions == other.versions &&
 engine == other.engine &&
 engine_versions == other.engine_versions &&
 patchlevel == other.patchlevel
end
 

 
 # File bundler/ruby_version.rb, line 87
def diff(other)
 raise ArgumentError, "Can only diff with a RubyVersion, not a #{other.class}" unless other.is_a?(RubyVersion)
 if engine != other.engine && @input_engine
 [:engine, engine, other.engine]
 elsif versions.empty? || !matches?(versions, other.gem_version)
 [:version, versions_string(versions), versions_string(other.versions)]
 elsif @input_engine && !matches?(engine_versions, other.engine_gem_version)
 [:engine_version, versions_string(engine_versions), versions_string(other.engine_versions)]
 elsif patchlevel && (!patchlevel.is_a?(String) || !other.patchlevel.is_a?(String) || !matches?(patchlevel, other.patchlevel))
 [:patchlevel, patchlevel, other.patchlevel]
 end
end
 

 
 # File bundler/ruby_version.rb, line 121
def exact?
 return @exact if defined?(@exact)
 @exact = versions.all? {|v| Gem::Requirement.create(v).exact? }
end
 

 
 # File bundler/ruby_version.rb, line 73
def host
 @host ||= [
 RbConfig::CONFIG["host_cpu"],
 RbConfig::CONFIG["host_vendor"],
 RbConfig::CONFIG["host_os"],
 ].join("-")
end
 

 
 # File bundler/ruby_version.rb, line 62
def single_version_string
 to_s(gem_version)
end
 

 
 # File bundler/ruby_version.rb, line 113
def to_gem_version_with_patchlevel
 @gem_version_with_patch ||= begin
 Gem::Version.create("#{@gem_version}.#{@patchlevel}")
 rescue ArgumentError
 @gem_version
 end
end
 

 
 # File bundler/ruby_version.rb, line 38
def to_s(versions = self.versions)
 output = String.new("ruby #{versions_string(versions)}")
 output << "p#{patchlevel}" if patchlevel
 output << " (#{engine} #{versions_string(engine_versions)})" unless engine == "ruby"
 output
end
 

 
 # File bundler/ruby_version.rb, line 100
def versions_string(versions)
 Array(versions).join(", ")
end