Elixir 1.7

Version




elixir

Version

आवश्यकताओं के विरुद्ध संस्करण को पार्स करने और मिलान करने के लिए कार्य।

एक संस्करण एक विशिष्ट प्रारूप में एक स्ट्रिंग है या Version.parse/1 माध्यम से पार्स करने के बाद उत्पन्न एक Version

Version पार्सिंग और आवश्यकताएं सेमी वीर 2.0 स्कीमा का अनुसरण करती हैं

संस्करण

संक्षेप में, एक संस्करण को तीन संख्याओं द्वारा दर्शाया गया है:

MAJOR.MINOR.PATCH

पूर्व-रिलीज़ को जोड़कर समर्थित किया जाता है -[0-9A-Za-z-\.]

"1.0.0-alpha.3"

बिल्ड जानकारी को जोड़कर +[0-9A-Za-z-\.] जोड़ा जा सकता है:

"1.0.0-alpha.3+20130417140000"

struct

संस्करण को Version संरचना द्वारा दर्शाया गया है और सेमीवीयर के अनुसार फ़ील्ड का नाम दिया गया है :major :minor :patch :pre , और :build

आवश्यकताएँ

आवश्यकताएँ आपको यह निर्दिष्ट करने की अनुमति देती हैं कि दिए गए निर्भरता के कौन से संस्करण आपके खिलाफ काम करने के इच्छुक हैं। आवश्यकताएँ आम संचालकों जैसे >= , <= , > , == , और मित्रों का समर्थन करती हैं जो एक अपेक्षा के अनुसार काम करते हैं:

# Only version 2.0.0
"== 2.0.0"

# Anything later than 2.0.0
"> 2.0.0"

आवश्यकताएँ भी and जटिल परिस्थितियों के लिए समर्थन and / or :

# 2.0.0 and later until 2.1.0
">= 2.0.0 and < 2.1.0"

चूँकि उपरोक्त उदाहरण एक ऐसी सामान्य आवश्यकता है, इसे इस प्रकार व्यक्त किया जा सकता है:

"~> 2.0.0"

~> इसके ऊपरी बाउंड के पूर्व-रिलीज़ संस्करण कभी शामिल नहीं होंगे। इसका उपयोग केवल प्रमुख संस्करण भाग पर ऊपरी बाउंड सेट करने के लिए भी किया जा सकता है। ~> आवश्यकताओं और उनके संबंधित अनुवाद के लिए नीचे दी गई तालिका देखें।

~> अनुवाद
~> 2.0.0 >= 2.0.0 and < 2.1.0
~> 2.1.2 >= 2.1.2 and < 2.2.0
~> 2.1.3-dev >= 2.1.3-dev and < 2.2.0
~> 2.0 >= 2.0.0 and < 3.0.0
~> 2.1 >= 2.1.0 and < 3.0.0

जब allow_pre: false सेट किया जाता है, तो आवश्यकता तब तक प्री-रिलीज़ संस्करण से मेल नहीं खाएगी जब तक कि ऑपर एक प्री-रिलीज़ संस्करण नहीं है। डिफ़ॉल्ट हमेशा पूर्व-रिलीज़ की अनुमति देता है लेकिन ध्यान दें कि हेक्स में :allow_pre को false सेट किया गया false । उदाहरण के लिए नीचे दी गई तालिका देखें।

आवश्यकता संस्करण :allow_pre माचिस
~> 2.0 2.1.0 - true
~> 2.0 3.0.0 - false
~> 2.0.0 2.0.1 - true
~> 2.0.0 2.1.0 - false
~> 2.1.2 2.1.3-dev true true
~> 2.1.2 2.1.3-dev false false
~> 2.1-dev 2.2.0-dev false true
~> 2.1.2-dev 2.1.3-dev false true
>= 2.1.0 2.2.0-dev false false
>= 2.1.0-dev 2.2.3-dev true true

सारांश

प्रकार

build()
major()
matchable()
minor()
patch()
pre()
requirement()
t()
version()

कार्य

तुलना करें (संस्करण 1, संस्करण 2)

दो संस्करणों की तुलना करता है

compile_requirement(req)

तेजी से मिलान के लिए :ets.match_spec_compile/1 इसके आंतरिक प्रतिनिधित्व के लिए एक आवश्यकता को :ets.match_spec_compile/1

मिलान। (संस्करण, आवश्यकता, opts \\ [])

यदि दिया गया संस्करण विनिर्देश से मेल खाता है, तो जाँच करता है

parse!(string)

एक संस्करण में एक संस्करण स्ट्रिंग पार्स करता है

parse(string)

एक Version संरचना में एक संस्करण स्ट्रिंग पार्स करता है

parse_requirement(string)

एक संस्करण की आवश्यकता स्ट्रिंग को एक Version.Requirement संरचना में देता है

प्रकार

निर्माण ()

build() :: String.t() | nil

प्रमुख ()

major() :: String.t() | non_neg_integer()

तुलनीय ()

matchable() ::
  {major :: major(), minor :: minor(), patch :: patch(), pre :: pre()}

नाबालिग ()

minor() :: non_neg_integer() | nil

पैच ()

patch() :: non_neg_integer() | nil

पूर्व ()

pre() :: [String.t() | non_neg_integer()]

आवश्यकता()

requirement() :: String.t() | Version.Requirement.t()

टी ()

t() :: %Version{
  build: build(),
  major: major(),
  minor: minor(),
  patch: patch(),
  pre: pre()
}

संस्करण ()

version() :: String.t() | t()

कार्य

तुलना करें (संस्करण 1, संस्करण 2)

compare(version(), version()) :: :gt | :eq | :lt

दो संस्करणों की तुलना करता है।

रिटर्न :gt यदि पहला संस्करण दूसरे से अधिक है, और :lt इसके विपरीत के लिए :lt । यदि दो संस्करण समान हैं :eq वापस आ गया है।

पूर्व-रिलीज़ उनके संबंधित रिलीज़ संस्करणों की तुलना में कड़ाई से कम हैं।

यदि वे अल्फ़ान्यूमेरिक हैं, और संख्यात्मक रूप से पैच खंडों की तुलना लक्सिकोग्राफिक रूप से की जाती है।

बिल्ड सेगमेंट को नजरअंदाज किया जाता है: यदि दो संस्करण केवल उनके बिल्ड सेगमेंट में भिन्न होते हैं तो उन्हें समान माना जाता है।

एक Version.InvalidVersionError उठाता है। InvalidVersionError अपवाद यदि दिए गए दो संस्करणों में से कोई भी पार्स करने योग्य नहीं है। यदि पहले से ही पार्स संस्करण दिया गया है तो यह फ़ंक्शन नहीं बढ़ाएगा।

उदाहरण

iex> Version.compare("2.0.1-alpha1", "2.0.0")
:gt

iex> Version.compare("1.0.0-beta", "1.0.0-rc1")
:lt

iex> Version.compare("1.0.0-10", "1.0.0-2")
:gt

iex> Version.compare("2.0.1+build0", "2.0.1")
:eq

iex> Version.compare("invalid", "2.0.1")
** (Version.InvalidVersionError) invalid version: "invalid"

compile_requirement (अनुरोध)

compile_requirement(Version.Requirement.t()) :: Version.Requirement.t()

तेजी से मिलान के लिए :ets.match_spec_compile/1 इसके आंतरिक प्रतिनिधित्व के लिए एक आवश्यकता को :ets.match_spec_compile/1

आंतरिक प्रतिनिधित्व अपारदर्शी है और इसे बाहरी गुणों में परिवर्तित नहीं किया जा सकता है और फिर इसके गुणों को खोए बिना फिर से वापस किया जा सकता है (जिसका अर्थ है कि इसे दूसरे नोड पर एक प्रक्रिया में नहीं भेजा जा सकता है और अभी भी एक वैध संकलित मिलान_स्पेक बना रहेगा, न ही इसे डिस्क पर संग्रहीत किया जा सकता है) ।

मिलान। (संस्करण, आवश्यकता, opts \\ [])

match?(version(), requirement(), keyword()) :: boolean()

यदि दिया गया संस्करण विनिर्देश से मेल खाता है, तो जाँच करता है।

यदि version requirement , तो true , अन्यथा false है। यदि version पार्स करने योग्य नहीं है, तो एक Version.InvalidVersionError उठाता है। InvalidRequirementError यदि version पार्सबल नहीं है, तो एक Version.InvalidVersionError । InvalidVersionError अपवाद नहीं है। यदि पहले से ही पार्स किया गया संस्करण और आवश्यकता हो तो यह फ़ंक्शन नहीं बढ़ाएगा।

विकल्प

  • :allow_pre (बूलियन) - जब false , पूर्व-रिलीज़ संस्करण मेल नहीं :allow_pre , जब तक कि ऑपरेंड रिलीज़-पूर्व संस्करण नहीं है। उदाहरण के लिए ऊपर दी गई तालिका देखें। true अवहेलना।

उदाहरण

iex> Version.match?("2.0.0", "> 1.0.0")
true

iex> Version.match?("2.0.0", "== 1.0.0")
false

iex> Version.match?("foo", "== 1.0.0")
** (Version.InvalidVersionError) invalid version: "foo"

iex> Version.match?("2.0.0", "== == 1.0.0")
** (Version.InvalidRequirementError) invalid requirement: "== == 1.0.0"

पार्स! (स्ट्रिंग)

parse!(String.t()) :: t() | no_return()

एक संस्करण में एक संस्करण स्ट्रिंग पार्स करता है।

यदि string एक अमान्य संस्करण है, तो एक InvalidVersionError को उठाया जाता है।

उदाहरण

iex> Version.parse!("2.0.1-alpha1")
#Version<2.0.1-alpha1>

iex> Version.parse!("2.0-alpha1")
** (Version.InvalidVersionError) invalid version: "2.0-alpha1"

पार्स (स्ट्रिंग)

parse(String.t()) :: {:ok, t()} | :error

एक Version संरचना में एक संस्करण स्ट्रिंग पार्स करता है।

उदाहरण

iex> {:ok, version} = Version.parse("2.0.1-alpha1")
iex> version
#Version<2.0.1-alpha1>

iex> Version.parse("2.0-alpha1")
:error

parse_requirement (स्ट्रिंग)

parse_requirement(String.t()) :: {:ok, Version.Requirement.t()} | :error

एक संस्करण की आवश्यकता स्ट्रिंग को एक Version.Requirement संरचना में देता है।

उदाहरण

iex> {:ok, requirement} = Version.parse_requirement("== 2.0.1")
iex> requirement
#Version.Requirement<== 2.0.1>

iex> Version.parse_requirement("== == 2.0.1")
:error