2016-02-01 15:43:26 +03:00
|
|
|
# frozen_string_literal: true
|
2007-11-10 10:48:56 +03:00
|
|
|
##
|
2009-06-10 01:38:59 +04:00
|
|
|
# The Version class processes string versions into comparable
|
|
|
|
# values. A version string should normally be a series of numbers
|
|
|
|
# separated by periods. Each part (digits separated by periods) is
|
|
|
|
# considered its own number, and these are used for sorting. So for
|
|
|
|
# instance, 3.10 sorts higher than 3.2 because ten is greater than
|
|
|
|
# two.
|
|
|
|
#
|
|
|
|
# If any part contains letters (currently only a-z are supported) then
|
|
|
|
# that version is considered prerelease. Versions with a prerelease
|
2011-01-19 03:08:49 +03:00
|
|
|
# part in the Nth part sort less than versions with N-1
|
|
|
|
# parts. Prerelease parts are sorted alphabetically using the normal
|
|
|
|
# Ruby string sorting rules. If a prerelease part contains both
|
|
|
|
# letters and numbers, it will be broken into multiple parts to
|
|
|
|
# provide expected sort behavior (1.0.a10 becomes 1.0.a.10, and is
|
|
|
|
# greater than 1.0.a9).
|
2009-06-10 01:38:59 +04:00
|
|
|
#
|
|
|
|
# Prereleases sort between real releases (newest to oldest):
|
|
|
|
#
|
|
|
|
# 1. 1.0
|
2011-01-19 03:08:49 +03:00
|
|
|
# 2. 1.0.b1
|
|
|
|
# 3. 1.0.a.2
|
2009-06-10 01:38:59 +04:00
|
|
|
# 4. 0.9
|
2010-02-22 05:52:35 +03:00
|
|
|
#
|
2014-02-04 04:48:31 +04:00
|
|
|
# If you want to specify a version restriction that includes both prereleases
|
|
|
|
# and regular releases of the 1.x series this is the best way:
|
|
|
|
#
|
|
|
|
# s.add_dependency 'example', '>= 1.0.0.a', '< 2.0.0'
|
|
|
|
#
|
2010-02-22 05:52:35 +03:00
|
|
|
# == How Software Changes
|
|
|
|
#
|
|
|
|
# Users expect to be able to specify a version constraint that gives them
|
|
|
|
# some reasonable expectation that new versions of a library will work with
|
|
|
|
# their software if the version constraint is true, and not work with their
|
|
|
|
# software if the version constraint is false. In other words, the perfect
|
|
|
|
# system will accept all compatible versions of the library and reject all
|
|
|
|
# incompatible versions.
|
|
|
|
#
|
|
|
|
# Libraries change in 3 ways (well, more than 3, but stay focused here!).
|
|
|
|
#
|
|
|
|
# 1. The change may be an implementation detail only and have no effect on
|
|
|
|
# the client software.
|
|
|
|
# 2. The change may add new features, but do so in a way that client software
|
|
|
|
# written to an earlier version is still compatible.
|
|
|
|
# 3. The change may change the public interface of the library in such a way
|
|
|
|
# that old software is no longer compatible.
|
|
|
|
#
|
|
|
|
# Some examples are appropriate at this point. Suppose I have a Stack class
|
|
|
|
# that supports a <tt>push</tt> and a <tt>pop</tt> method.
|
|
|
|
#
|
|
|
|
# === Examples of Category 1 changes:
|
|
|
|
#
|
|
|
|
# * Switch from an array based implementation to a linked-list based
|
|
|
|
# implementation.
|
|
|
|
# * Provide an automatic (and transparent) backing store for large stacks.
|
|
|
|
#
|
|
|
|
# === Examples of Category 2 changes might be:
|
|
|
|
#
|
|
|
|
# * Add a <tt>depth</tt> method to return the current depth of the stack.
|
|
|
|
# * Add a <tt>top</tt> method that returns the current top of stack (without
|
|
|
|
# changing the stack).
|
|
|
|
# * Change <tt>push</tt> so that it returns the item pushed (previously it
|
|
|
|
# had no usable return value).
|
|
|
|
#
|
|
|
|
# === Examples of Category 3 changes might be:
|
|
|
|
#
|
|
|
|
# * Changes <tt>pop</tt> so that it no longer returns a value (you must use
|
|
|
|
# <tt>top</tt> to get the top of the stack).
|
|
|
|
# * Rename the methods to <tt>push_item</tt> and <tt>pop_item</tt>.
|
|
|
|
#
|
|
|
|
# == RubyGems Rational Versioning
|
|
|
|
#
|
|
|
|
# * Versions shall be represented by three non-negative integers, separated
|
|
|
|
# by periods (e.g. 3.1.4). The first integers is the "major" version
|
|
|
|
# number, the second integer is the "minor" version number, and the third
|
|
|
|
# integer is the "build" number.
|
|
|
|
#
|
|
|
|
# * A category 1 change (implementation detail) will increment the build
|
|
|
|
# number.
|
|
|
|
#
|
|
|
|
# * A category 2 change (backwards compatible) will increment the minor
|
|
|
|
# version number and reset the build number.
|
|
|
|
#
|
|
|
|
# * A category 3 change (incompatible) will increment the major build number
|
|
|
|
# and reset the minor and build numbers.
|
|
|
|
#
|
|
|
|
# * Any "public" release of a gem should have a different version. Normally
|
|
|
|
# that means incrementing the build number. This means a developer can
|
2014-01-20 08:57:31 +04:00
|
|
|
# generate builds all day long, but as soon as they make a public release,
|
|
|
|
# the version must be updated.
|
2010-02-22 05:52:35 +03:00
|
|
|
#
|
|
|
|
# === Examples
|
|
|
|
#
|
|
|
|
# Let's work through a project lifecycle using our Stack example from above.
|
|
|
|
#
|
|
|
|
# Version 0.0.1:: The initial Stack class is release.
|
|
|
|
# Version 0.0.2:: Switched to a linked=list implementation because it is
|
|
|
|
# cooler.
|
|
|
|
# Version 0.1.0:: Added a <tt>depth</tt> method.
|
|
|
|
# Version 1.0.0:: Added <tt>top</tt> and made <tt>pop</tt> return nil
|
|
|
|
# (<tt>pop</tt> used to return the old top item).
|
|
|
|
# Version 1.1.0:: <tt>push</tt> now returns the value pushed (it used it
|
|
|
|
# return nil).
|
|
|
|
# Version 1.1.1:: Fixed a bug in the linked list implementation.
|
|
|
|
# Version 1.1.2:: Fixed a bug introduced in the last fix.
|
|
|
|
#
|
2014-01-20 08:57:31 +04:00
|
|
|
# Client A needs a stack with basic push/pop capability. They write to the
|
|
|
|
# original interface (no <tt>top</tt>), so their version constraint looks like:
|
2010-02-22 05:52:35 +03:00
|
|
|
#
|
2015-12-11 05:53:09 +03:00
|
|
|
# gem 'stack', '>= 0.0'
|
2010-02-22 05:52:35 +03:00
|
|
|
#
|
|
|
|
# Essentially, any version is OK with Client A. An incompatible change to
|
2014-01-20 08:57:31 +04:00
|
|
|
# the library will cause them grief, but they are willing to take the chance
|
|
|
|
# (we call Client A optimistic).
|
2010-02-22 05:52:35 +03:00
|
|
|
#
|
2014-01-20 08:57:31 +04:00
|
|
|
# Client B is just like Client A except for two things: (1) They use the
|
|
|
|
# <tt>depth</tt> method and (2) they are worried about future
|
|
|
|
# incompatibilities, so they write their version constraint like this:
|
2010-02-22 05:52:35 +03:00
|
|
|
#
|
|
|
|
# gem 'stack', '~> 0.1'
|
|
|
|
#
|
|
|
|
# The <tt>depth</tt> method was introduced in version 0.1.0, so that version
|
|
|
|
# or anything later is fine, as long as the version stays below version 1.0
|
|
|
|
# where incompatibilities are introduced. We call Client B pessimistic
|
2014-01-20 08:57:31 +04:00
|
|
|
# because they are worried about incompatible future changes (it is OK to be
|
2010-02-22 05:52:35 +03:00
|
|
|
# pessimistic!).
|
|
|
|
#
|
|
|
|
# == Preventing Version Catastrophe:
|
|
|
|
#
|
|
|
|
# From: http://blog.zenspider.com/2008/10/rubygems-howto-preventing-cata.html
|
|
|
|
#
|
|
|
|
# Let's say you're depending on the fnord gem version 2.y.z. If you
|
|
|
|
# specify your dependency as ">= 2.0.0" then, you're good, right? What
|
|
|
|
# happens if fnord 3.0 comes out and it isn't backwards compatible
|
|
|
|
# with 2.y.z? Your stuff will break as a result of using ">=". The
|
2012-11-29 10:52:18 +04:00
|
|
|
# better route is to specify your dependency with an "approximate" version
|
|
|
|
# specifier ("~>"). They're a tad confusing, so here is how the dependency
|
2010-02-22 05:52:35 +03:00
|
|
|
# specifiers work:
|
|
|
|
#
|
|
|
|
# Specification From ... To (exclusive)
|
|
|
|
# ">= 3.0" 3.0 ... ∞
|
|
|
|
# "~> 3.0" 3.0 ... 4.0
|
|
|
|
# "~> 3.0.0" 3.0.0 ... 3.1
|
|
|
|
# "~> 3.5" 3.5 ... 4.0
|
|
|
|
# "~> 3.5.0" 3.5.0 ... 3.6
|
2014-09-14 07:30:02 +04:00
|
|
|
# "~> 3" 3.0 ... 4.0
|
|
|
|
#
|
|
|
|
# For the last example, single-digit versions are automatically extended with
|
|
|
|
# a zero to give a sensible result.
|
2008-06-18 02:04:18 +04:00
|
|
|
|
2007-11-10 10:48:56 +03:00
|
|
|
class Gem::Version
|
2011-01-19 03:08:49 +03:00
|
|
|
autoload :Requirement, 'rubygems/requirement'
|
|
|
|
|
2007-11-10 10:48:56 +03:00
|
|
|
include Comparable
|
|
|
|
|
2013-09-14 12:59:02 +04:00
|
|
|
VERSION_PATTERN = '[0-9]+(?>\.[0-9a-zA-Z]+)*(-[0-9A-Za-z-]+(\.[0-9A-Za-z-]+)*)?' # :nodoc:
|
2013-09-25 04:53:19 +04:00
|
|
|
ANCHORED_VERSION_PATTERN = /\A\s*(#{VERSION_PATTERN})?\s*\z/ # :nodoc:
|
2010-02-22 05:52:35 +03:00
|
|
|
|
|
|
|
##
|
|
|
|
# A string representation of this Version.
|
2007-11-10 10:48:56 +03:00
|
|
|
|
2013-09-14 12:59:02 +04:00
|
|
|
def version
|
|
|
|
@version.dup
|
|
|
|
end
|
|
|
|
|
2010-02-22 05:52:35 +03:00
|
|
|
alias to_s version
|
2007-11-10 10:48:56 +03:00
|
|
|
|
2010-02-22 05:52:35 +03:00
|
|
|
##
|
|
|
|
# True if the +version+ string matches RubyGems' requirements.
|
2009-06-10 01:38:59 +04:00
|
|
|
|
2010-02-22 05:52:35 +03:00
|
|
|
def self.correct? version
|
2017-10-08 04:32:18 +03:00
|
|
|
!!(version.to_s =~ ANCHORED_VERSION_PATTERN)
|
2007-11-10 10:48:56 +03:00
|
|
|
end
|
|
|
|
|
|
|
|
##
|
2010-02-22 05:52:35 +03:00
|
|
|
# Factory method to create a Version object. Input may be a Version
|
|
|
|
# or a String. Intended to simplify client code.
|
2007-11-10 10:48:56 +03:00
|
|
|
#
|
|
|
|
# ver1 = Version.create('1.3.17') # -> (Version object)
|
|
|
|
# ver2 = Version.create(ver1) # -> (ver1)
|
|
|
|
# ver3 = Version.create(nil) # -> nil
|
2008-06-18 02:04:18 +04:00
|
|
|
|
2010-02-22 05:52:35 +03:00
|
|
|
def self.create input
|
2013-10-16 04:14:16 +04:00
|
|
|
if self === input then # check yourself before you wreck yourself
|
2007-11-10 10:48:56 +03:00
|
|
|
input
|
|
|
|
elsif input.nil? then
|
|
|
|
nil
|
|
|
|
else
|
|
|
|
new input
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2013-09-14 12:59:02 +04:00
|
|
|
@@all = {}
|
|
|
|
|
2013-10-20 05:33:19 +04:00
|
|
|
def self.new version # :nodoc:
|
2014-09-14 07:30:02 +04:00
|
|
|
return super unless Gem::Version == self
|
2014-02-06 02:18:25 +04:00
|
|
|
|
2013-09-14 12:59:02 +04:00
|
|
|
@@all[version] ||= super
|
|
|
|
end
|
|
|
|
|
2007-11-10 10:48:56 +03:00
|
|
|
##
|
2008-06-18 02:04:18 +04:00
|
|
|
# Constructs a Version from the +version+ string. A version string is a
|
2009-06-10 01:38:59 +04:00
|
|
|
# series of digits or ASCII letters separated by dots.
|
2008-06-18 02:04:18 +04:00
|
|
|
|
2010-02-22 05:52:35 +03:00
|
|
|
def initialize version
|
2017-01-24 05:38:57 +03:00
|
|
|
unless self.class.correct?(version)
|
|
|
|
raise ArgumentError, "Malformed version number string #{version}"
|
|
|
|
end
|
|
|
|
|
|
|
|
# If version is an empty string convert it to 0
|
|
|
|
version = 0 if version =~ /\A\s*\Z/
|
2007-11-10 10:48:56 +03:00
|
|
|
|
2013-09-14 12:59:02 +04:00
|
|
|
@version = version.to_s.strip.gsub("-",".pre.")
|
|
|
|
@segments = nil
|
2007-11-10 10:48:56 +03:00
|
|
|
end
|
|
|
|
|
2009-06-10 01:38:59 +04:00
|
|
|
##
|
2010-02-22 05:52:35 +03:00
|
|
|
# Return a new version object where the next to the last revision
|
|
|
|
# number is one greater (e.g., 5.3.1 => 5.4).
|
|
|
|
#
|
2011-01-19 03:08:49 +03:00
|
|
|
# Pre-release (alpha) parts, e.g, 5.3.1.b.2 => 5.4, are ignored.
|
2009-06-10 01:38:59 +04:00
|
|
|
|
2010-02-22 05:52:35 +03:00
|
|
|
def bump
|
2015-02-27 16:00:45 +03:00
|
|
|
@bump ||= begin
|
2016-03-04 03:29:40 +03:00
|
|
|
segments = self.segments
|
2015-02-27 16:00:45 +03:00
|
|
|
segments.pop while segments.any? { |s| String === s }
|
|
|
|
segments.pop if segments.size > 1
|
|
|
|
|
|
|
|
segments[-1] = segments[-1].succ
|
|
|
|
self.class.new segments.join(".")
|
|
|
|
end
|
2007-11-10 10:48:56 +03:00
|
|
|
end
|
|
|
|
|
2009-06-10 01:38:59 +04:00
|
|
|
##
|
2010-02-22 05:52:35 +03:00
|
|
|
# A Version is only eql? to another version if it's specified to the
|
|
|
|
# same precision. Version "1.0" is not the same as version "1".
|
2009-06-10 01:38:59 +04:00
|
|
|
|
2010-02-22 05:52:35 +03:00
|
|
|
def eql? other
|
2015-07-02 00:50:14 +03:00
|
|
|
self.class === other and @version == other._version
|
2007-11-10 10:48:56 +03:00
|
|
|
end
|
|
|
|
|
2010-02-22 05:52:35 +03:00
|
|
|
def hash # :nodoc:
|
2017-10-08 04:32:18 +03:00
|
|
|
canonical_segments.hash
|
2009-06-10 01:38:59 +04:00
|
|
|
end
|
|
|
|
|
2012-04-18 04:58:47 +04:00
|
|
|
def init_with coder # :nodoc:
|
|
|
|
yaml_initialize coder.tag, coder.map
|
|
|
|
end
|
|
|
|
|
2010-02-22 05:52:35 +03:00
|
|
|
def inspect # :nodoc:
|
|
|
|
"#<#{self.class} #{version.inspect}>"
|
2007-11-10 10:48:56 +03:00
|
|
|
end
|
|
|
|
|
|
|
|
##
|
2010-02-22 05:52:35 +03:00
|
|
|
# Dump only the raw version string, not the complete object. It's a
|
|
|
|
# string for backwards (RubyGems 1.3.5 and earlier) compatibility.
|
2009-06-10 01:38:59 +04:00
|
|
|
|
2010-02-22 05:52:35 +03:00
|
|
|
def marshal_dump
|
|
|
|
[version]
|
2007-11-10 10:48:56 +03:00
|
|
|
end
|
|
|
|
|
2010-02-22 05:52:35 +03:00
|
|
|
##
|
|
|
|
# Load custom marshal format. It's a string for backwards (RubyGems
|
|
|
|
# 1.3.5 and earlier) compatibility.
|
2007-11-10 10:48:56 +03:00
|
|
|
|
2010-02-22 05:52:35 +03:00
|
|
|
def marshal_load array
|
|
|
|
initialize array[0]
|
2007-11-10 10:48:56 +03:00
|
|
|
end
|
2010-04-22 12:24:42 +04:00
|
|
|
|
2013-10-20 05:33:19 +04:00
|
|
|
def yaml_initialize(tag, map) # :nodoc:
|
2012-04-18 04:04:12 +04:00
|
|
|
@version = map['version']
|
|
|
|
@segments = nil
|
|
|
|
@hash = nil
|
|
|
|
end
|
|
|
|
|
2013-10-20 05:33:19 +04:00
|
|
|
def to_yaml_properties # :nodoc:
|
2012-11-29 10:52:18 +04:00
|
|
|
["@version"]
|
|
|
|
end
|
|
|
|
|
2013-10-20 05:33:19 +04:00
|
|
|
def encode_with coder # :nodoc:
|
2012-11-29 10:52:18 +04:00
|
|
|
coder.add 'version', @version
|
|
|
|
end
|
|
|
|
|
2009-06-10 01:38:59 +04:00
|
|
|
##
|
2010-02-22 05:52:35 +03:00
|
|
|
# A version is considered a prerelease if it contains a letter.
|
2009-06-10 01:38:59 +04:00
|
|
|
|
|
|
|
def prerelease?
|
2016-02-01 15:43:26 +03:00
|
|
|
unless instance_variable_defined? :@prerelease
|
|
|
|
@prerelease = !!(@version =~ /[a-zA-Z]/)
|
|
|
|
end
|
|
|
|
@prerelease
|
2009-06-10 01:38:59 +04:00
|
|
|
end
|
|
|
|
|
2010-02-22 05:52:35 +03:00
|
|
|
def pretty_print q # :nodoc:
|
|
|
|
q.text "Gem::Version.new(#{version.inspect})"
|
2007-11-10 10:48:56 +03:00
|
|
|
end
|
2010-04-22 12:24:42 +04:00
|
|
|
|
2007-11-10 10:48:56 +03:00
|
|
|
##
|
2010-02-22 05:52:35 +03:00
|
|
|
# The release for this version (e.g. 1.2.0.a -> 1.2.0).
|
|
|
|
# Non-prerelease versions return themselves.
|
2008-06-18 02:04:18 +04:00
|
|
|
|
2010-02-22 05:52:35 +03:00
|
|
|
def release
|
2015-02-27 16:00:45 +03:00
|
|
|
@release ||= if prerelease?
|
2016-03-04 03:29:40 +03:00
|
|
|
segments = self.segments
|
2015-02-27 16:00:45 +03:00
|
|
|
segments.pop while segments.any? { |s| String === s }
|
|
|
|
self.class.new segments.join('.')
|
|
|
|
else
|
|
|
|
self
|
|
|
|
end
|
2007-11-10 10:48:56 +03:00
|
|
|
end
|
|
|
|
|
2010-02-22 05:52:35 +03:00
|
|
|
def segments # :nodoc:
|
2016-03-04 03:29:40 +03:00
|
|
|
_segments.dup
|
2007-11-10 10:48:56 +03:00
|
|
|
end
|
|
|
|
|
2009-06-10 01:38:59 +04:00
|
|
|
##
|
2010-02-22 05:52:35 +03:00
|
|
|
# A recommended version for use with a ~> Requirement.
|
2009-06-10 01:38:59 +04:00
|
|
|
|
2012-11-29 10:52:18 +04:00
|
|
|
def approximate_recommendation
|
2016-03-04 03:29:40 +03:00
|
|
|
segments = self.segments
|
2007-11-10 10:48:56 +03:00
|
|
|
|
2010-02-22 05:52:35 +03:00
|
|
|
segments.pop while segments.any? { |s| String === s }
|
|
|
|
segments.pop while segments.size > 2
|
|
|
|
segments.push 0 while segments.size < 2
|
2009-06-10 01:38:59 +04:00
|
|
|
|
2010-02-22 05:52:35 +03:00
|
|
|
"~> #{segments.join(".")}"
|
2007-12-20 11:39:12 +03:00
|
|
|
end
|
|
|
|
|
2010-02-22 05:52:35 +03:00
|
|
|
##
|
2011-01-19 03:08:49 +03:00
|
|
|
# Compares this version with +other+ returning -1, 0, or 1 if the
|
|
|
|
# other version is larger, the same, or smaller than this
|
|
|
|
# one. Attempts to compare to something that's not a
|
|
|
|
# <tt>Gem::Version</tt> return +nil+.
|
2007-11-10 10:48:56 +03:00
|
|
|
|
2010-02-22 05:52:35 +03:00
|
|
|
def <=> other
|
2011-01-19 03:08:49 +03:00
|
|
|
return unless Gem::Version === other
|
2017-10-08 04:32:18 +03:00
|
|
|
return 0 if @version == other._version || canonical_segments == other.canonical_segments
|
2007-11-10 10:48:56 +03:00
|
|
|
|
2016-03-04 03:29:40 +03:00
|
|
|
lhsegments = _segments
|
|
|
|
rhsegments = other._segments
|
2011-01-19 03:08:49 +03:00
|
|
|
|
|
|
|
lhsize = lhsegments.size
|
|
|
|
rhsize = rhsegments.size
|
2010-02-22 05:52:35 +03:00
|
|
|
limit = (lhsize > rhsize ? lhsize : rhsize) - 1
|
2007-11-10 10:48:56 +03:00
|
|
|
|
2011-01-19 03:08:49 +03:00
|
|
|
i = 0
|
|
|
|
|
|
|
|
while i <= limit
|
|
|
|
lhs, rhs = lhsegments[i] || 0, rhsegments[i] || 0
|
|
|
|
i += 1
|
|
|
|
|
|
|
|
next if lhs == rhs
|
|
|
|
return -1 if String === lhs && Numeric === rhs
|
|
|
|
return 1 if Numeric === lhs && String === rhs
|
2007-11-10 10:48:56 +03:00
|
|
|
|
2011-01-19 03:08:49 +03:00
|
|
|
return lhs <=> rhs
|
2010-02-22 05:52:35 +03:00
|
|
|
end
|
2007-11-10 10:48:56 +03:00
|
|
|
|
2010-02-22 05:52:35 +03:00
|
|
|
return 0
|
|
|
|
end
|
2015-07-02 00:50:14 +03:00
|
|
|
|
2017-10-08 04:32:18 +03:00
|
|
|
def canonical_segments
|
|
|
|
@canonical_segments ||=
|
|
|
|
_split_segments.map! do |segments|
|
|
|
|
segments.reverse_each.drop_while {|s| s == 0 }.reverse
|
|
|
|
end.reduce(&:concat)
|
|
|
|
end
|
|
|
|
|
2015-07-02 00:50:14 +03:00
|
|
|
protected
|
|
|
|
|
|
|
|
def _version
|
|
|
|
@version
|
|
|
|
end
|
2016-03-04 03:29:40 +03:00
|
|
|
|
|
|
|
def _segments
|
|
|
|
# segments is lazy so it can pick up version values that come from
|
|
|
|
# old marshaled versions, which don't go through marshal_load.
|
|
|
|
# since this version object is cached in @@all, its @segments should be frozen
|
|
|
|
|
|
|
|
@segments ||= @version.scan(/[0-9]+|[a-z]+/i).map do |s|
|
|
|
|
/^\d+$/ =~ s ? s.to_i : s
|
|
|
|
end.freeze
|
|
|
|
end
|
2017-10-08 04:32:18 +03:00
|
|
|
|
|
|
|
def _split_segments
|
|
|
|
string_start = _segments.index {|s| s.is_a?(String) }
|
|
|
|
string_segments = segments
|
|
|
|
numeric_segments = string_segments.slice!(0, string_start || string_segments.size)
|
|
|
|
return numeric_segments, string_segments
|
|
|
|
end
|
2007-11-10 10:48:56 +03:00
|
|
|
end
|