Julia 1.0

LibGit2




julia

LibGit2

LibGit2 मॉड्यूल libgit2 , एक पोर्टेबल C लाइब्रेरी के लिए बाइंडिंग प्रदान करता है जो Git संस्करण नियंत्रण प्रणाली के लिए मुख्य कार्यक्षमता को लागू करता है। इन बाइंडिंग का उपयोग वर्तमान में जूलिया के पैकेज मैनेजर को बिजली देने के लिए किया जाता है। यह उम्मीद की जाती है कि इस मॉड्यूल को अंततः एक अलग पैकेज में स्थानांतरित किया जाएगा।

कार्यक्षमता

इस दस्तावेज़ में से कुछ libgit2 API के पूर्व ज्ञान को मानते हैं। यहां संदर्भित कुछ वस्तुओं और तरीकों के बारे में अधिक जानकारी के लिए, अपस्ट्रीम libgit2 एपीआई संदर्भ से परामर्श करें।

LibGit2.Buffer प्रकार

LibGit2.Buffer

Libgit2 से डेटा निर्यात करने के लिए डेटा बफर। git_buf संरचना से मेल खाता है।

LibGit2 से डेटा प्राप्त करते समय, एक विशिष्ट उपयोग ऐसा दिखेगा:

buf_ref = Ref(Buffer())
@check ccall(..., (Ptr{Buffer},), buf_ref)
# operation on buf_ref
free(buf_ref)

विशेष रूप से, ध्यान दें कि LibGit2.free को Ref ऑब्जेक्ट पर बाद में बुलाया जाना चाहिए।

source

LibGit2.CheckoutOptions प्रकार

LibGit2.CheckoutOptions

मिलान git_checkout_options संरचना से होता है।

खेतों का प्रतिनिधित्व करते हैं:

  • version : उपयोग में संरचना का संस्करण, यदि यह बाद में बदलता है। अभी के लिए, हमेशा 1
  • checkout_strategy : यह निर्धारित करें कि टकरावों को कैसे हैंडल किया जाए और क्या चेकआउट / गुम हुई फ़ाइलों को फिर से बनाने के लिए बाध्य किया जाए।
  • disable_filters : यदि नॉनजरो, सीएलआरएफ (यूनिक्स और डॉस के बीच फ़ाइल की नई लाइनों को बदलने के लिए) जैसे फ़िल्टर लागू नहीं करता है।
  • dir_mode : चेकआउट में शामिल किसी भी निर्देशिका के लिए रीड / राइट / एक्सेस मोड। डिफ़ॉल्ट 0755
  • file_mode : चेकआउट में शामिल किसी भी फाइल के लिए रीड / राइट / एक्सेस मोड। बूँद के आधार पर डिफ़ॉल्ट 0755 या 0644
  • file_open_flags : चेकआउट के दौरान किसी भी फाइल को खोलने के लिए उपयोग किए जाने वाले बिटफ्लैग्स।
  • notify_flags : किस तरह के संघर्षों के लिए झंडे को उपयोगकर्ता को सूचित किया जाना चाहिए।
  • notify_cb : चेकआउट संघर्ष होने पर उपयोगकर्ता को सूचित करने के लिए एक वैकल्पिक कॉलबैक फ़ंक्शन। यदि यह फ़ंक्शन गैर-शून्य मान देता है, तो चेकआउट रद्द कर दिया जाएगा।
  • notify_payload : सूचित कॉलबैक फ़ंक्शन के लिए पेलोड।
  • progress_cb : चेकआउट प्रगति प्रदर्शित करने के लिए एक वैकल्पिक कॉलबैक फ़ंक्शन।
  • प्रगति_पेयोड: प्रगति कॉलबैक के लिए पेलोड।
  • paths : यदि रिक्त नहीं है, तो चेकआउट के दौरान खोज करने के लिए कौन से पथ का वर्णन करता है। यदि खाली है, तो रिपॉजिटरी में सभी फाइलों पर चेकआउट होगा।
  • baseline : workdir की अपेक्षित सामग्री, (सूचक से ए) GitTree । HEAD पर पेड़ की स्थिति के लिए चूक।
  • baseline_index : workdir की अपेक्षित सामग्री, (सूचक को) GitIndex । HEAD में सूचकांक की स्थिति के लिए चूक।
  • target_directory : यदि खाली नहीं है, तो workdir बजाय इस निर्देशिका को चेकआउट करें।
  • ancestor_label : संघर्षों के मामले में, सामान्य पूर्वज पक्ष का नाम।
  • our_label : संघर्षों के मामले में, "हमारे" पक्ष का नाम।
  • their_label : संघर्षों के मामले में, "उनके" पक्ष का नाम।
  • perfdata_cb : प्रदर्शन डेटा प्रदर्शित करने के लिए एक वैकल्पिक कॉलबैक फ़ंक्शन।
  • perfdata_payload : प्रदर्शन कॉलबैक के लिए पेलोड।
source

LibGit2.CloneOptions प्रकार

LibGit2.CloneOptions

git_clone_options संरचना से मेल खाता है।

खेतों का प्रतिनिधित्व करते हैं:

  • version : उपयोग में संरचना का संस्करण, यदि यह बाद में बदलता है। अभी के लिए, हमेशा 1
  • checkout_opts : क्लोन के भाग के रूप में रिमोट का चेकआउट करने के लिए विकल्प।
  • fetch_opts : क्लोन के हिस्से के रूप में रिमोट के प्री-चेकआउट लाने के लिए विकल्प।
  • bare : यदि 0 , पूर्ण दूरस्थ रिपॉजिटरी क्लोन करें। यदि गैर-शून्य, एक नंगे क्लोन करते हैं, जिसमें रिपॉजिटरी में स्रोत फ़ाइलों की कोई स्थानीय प्रतिलिपि नहीं है और gitdir और workdir समान हैं।
  • localclone : फ्लैग करें कि क्या स्थानीय ऑब्जेक्ट डेटाबेस को क्लोन करना है या एक localclone करना है। डिफ़ॉल्ट को निर्णय लेने देना है। यह स्थानीय क्लोन के लिए गिट-जागरूक परिवहन का उपयोग नहीं करेगा, लेकिन इसका उपयोग उन URL के लिए करेगा जो फ़ाइल के साथ शुरू होते file://
  • checkout_branch : checkout_branch करने के लिए शाखा का नाम। यदि कोई रिक्त स्ट्रिंग है, तो दूरस्थ की डिफ़ॉल्ट शाखा की जाँच की जाएगी।
  • repository_cb : एक वैकल्पिक कॉलबैक जिसका उपयोग नए रिपॉजिटरी में क्लोन बनाने के लिए किया जाएगा।
  • repository_cb_payload : रिपॉजिटरी कॉलबैक के लिए पेलोड।
  • remote_cb : एक वैकल्पिक कॉलबैक जिसका उपयोग क्लोन बनाने से पहले GitRemote बनाने के लिए किया गया था।
  • remote_cb_payload : दूरस्थ कॉलबैक के लिए पेलोड।
source

LibGit2.DescribeOptions प्रकार

LibGit2.DescribeOptions

git_describe_options संरचना से मेल खाता है।

खेतों का प्रतिनिधित्व करते हैं:

  • version : उपयोग में संरचना का संस्करण, यदि यह बाद में बदलता है। अभी के लिए, हमेशा 1
  • max_candidates_tags : किसी प्रतिबद्ध का वर्णन refs/tags लिए max_candidates_tags refs/tags में इस सबसे हाल के टैगों पर विचार करें। 10 की कमी (ताकि 10 सबसे हाल के टैग की जांच की जा सके कि क्या वे कमिटमेंट का वर्णन करते हैं)।
  • git-describe --tags : क्या refs/tags ( git-describe --tags refs/tags बराबर) या refs/ ( git-describe --tags बराबर) में सभी प्रविष्टियों पर विचार करने के लिए। डिफ़ॉल्ट केवल एनोटेट टैग दिखाना है। यदि Consts.DESCRIBE_TAGS जाता है, तो सभी टैग, एनोटेट या नहीं, पर विचार किया जाएगा। यदि Consts.DESCRIBE_ALL पारित हो जाता है, तो किसी भी रेफरी refs/ रिफ में विचार किया जाएगा।
  • pattern : केवल उन टैगों पर विचार करें जो pattern मेल खाते हैं। ग्लोब विस्तार का समर्थन करता है।
  • only_follow_first_parent : वर्णित वस्तु से मिलान संदर्भ से दूरी का पता लगाने पर, केवल पहले माता-पिता से दूरी पर विचार करें।
  • show_commit_oid_as_fallback : यदि कोई मिलान संदर्भ नहीं मिल सकता है जो एक कमिट का वर्णन करता है, तो एक त्रुटि (डिफ़ॉल्ट व्यवहार) फेंकने के बजाय कमिट का GitHash
source

LibGit2.DescribeFormatOptions प्रकार

LibGit2.DescribeFormatOptions

git_describe_format_options संरचना से मेल खाता है।

खेतों का प्रतिनिधित्व करते हैं:

  • version : उपयोग में संरचना का संस्करण, यदि यह बाद में बदलता है। अभी के लिए, हमेशा 1
  • abbreviated_size : उपयोग करने के लिए संक्षिप्त GitHash के आकार पर निम्न बाध्य, 7 लिए डिफ़ॉल्ट।
  • always_use_long_format : स्ट्रिंग्स के लिए लंबे प्रारूप का उपयोग करने के लिए 1 पर सेट करें, भले ही एक छोटे प्रारूप का उपयोग किया जा सके।
  • dirty_suffix : यदि सेट किया जाता है, तो यह विवरण स्ट्रिंग के अंत में जोड़ा जाएगा यदि workdir गंदा है।
source

LibGit2.DiffDelta प्रकार

LibGit2.DiffDelta

एक प्रविष्टि में परिवर्तन का विवरण। git_diff_delta संरचना से मेल खाता है।

खेतों का प्रतिनिधित्व करते हैं:

  • status : Consts.DELTA_STATUS एक, यह दर्शाता है कि फ़ाइल जोड़ा / संशोधित / हटा दिया गया है या नहीं।
  • flags : प्रत्येक पक्ष पर डेल्टा और वस्तुओं के लिए झंडे। निर्धारित करता है कि फ़ाइल (नों) को द्विआधारी / पाठ के रूप में माना जाए, क्या वे मौजूद अंतर के प्रत्येक पक्ष पर मौजूद हैं, और क्या ऑब्जेक्ट आईडी को सही माना जाता है।
  • similarity : यह इंगित करने के लिए उपयोग किया जाता है कि क्या फ़ाइल का नाम बदला गया है या प्रतिलिपि बनाई गई है।
  • nfiles : डेल्टा में फ़ाइलों की संख्या (उदाहरण के लिए, यदि डेल्टा को सबमॉड्यूल कमिट आईडी पर चलाया गया था, तो इसमें एक से अधिक फ़ाइल हो सकती हैं)।
  • old_file : परिवर्तनों से पहले फ़ाइल (ओं) के बारे में जानकारी युक्त एक DiffFile
  • new_file : परिवर्तनों के बाद फ़ाइल (ओं) के बारे में जानकारी युक्त एक DiffFile
source

LibGit2.DiffFile प्रकार

LibGit2.DiffFile

एक डेल्टा का एक पक्ष का विवरण। git_diff_file संरचना से मेल खाता है।

खेतों का प्रतिनिधित्व करते हैं:

  • id : अंतर में आइटम का GitHash । यदि आइटम अंतर के इस तरफ खाली है (उदाहरण के लिए, यदि वह अंतर फ़ाइल को हटाने का है), तो यह GitHash(0)
  • path : रिपॉजिटरी की वर्किंग डायरेक्टरी के सापेक्ष आइटम के लिए एक NULL टर्मिनेटेड पथ।
  • size : बाइट्स में आइटम का आकार।
  • flags : git_diff_flag_t झंडे का एक संयोजन। इस पूर्णांक का i बिट बिट i फ्लैग सेट करता है।
  • mode : आइटम के लिए stat मोड।
  • id_abbrev : केवल LibGit2 संस्करणों में वर्तमान में 0.25.0 से अधिक या उसके बराबर है। id फ़ील्ड की लंबाई जब string का उपयोग करके परिवर्तित की जाती है। आमतौर पर OID_HEXSZ (40) के बराबर।
source

LibGit2.DiffOptionsStruct प्रकार

LibGit2.DiffOptionsStruct

git_diff_options संरचना से मेल खाता है।

खेतों का प्रतिनिधित्व करते हैं:

  • version : उपयोग में संरचना का संस्करण, यदि यह बाद में बदलता है। अभी के लिए, हमेशा 1
  • flags : झंडे को नियंत्रित करना जो फाइलों को अंतर में दिखाई देगा। DIFF_NORMAL
  • ignore_submodules : ignore_submodules में फ़ाइलों को देखना है या नहीं। SUBMODULE_IGNORE_UNSPECIFIED लिए डिफ़ॉल्ट, जिसका अर्थ है कि SUBMODULE_IGNORE_UNSPECIFIED का कॉन्फ़िगरेशन नियंत्रित करेगा कि यह अंतर में प्रकट होता है या नहीं।
  • pathspec : फ़ाइलों को पथ में शामिल करने के लिए पथ। डिफ़ॉल्ट रिपॉजिटरी में सभी फाइलों का उपयोग करना है।
  • notify_cb : वैकल्पिक कॉलबैक जो फ़ाइल डेल्टस में जोड़े जाने के रूप में परिवर्तन के उपयोगकर्ता को सूचित करेगा।
  • progress_cb : वैकल्पिक कॉलबैक जो प्रगति को प्रदर्शित करेगा। केवल libgit2 संस्करणों पर प्रासंगिक कम से कम 0.24.0 के रूप में नया है।
  • payload : notify_cb और notify_cb को पास करने के लिए पेलोड।
  • context_lines : एक हंक के किनारों को परिभाषित करने के लिए अपरिवर्तित लाइनों की संख्या। यह उन पंक्तियों की संख्या भी है जिन्हें संदर्भ प्रदान करने के लिए हंक से पहले / बाद में दिखाया जाएगा। डिफ़ॉल्ट 3 है।
  • interhunk_lines : दो अलग-अलग हिस्सों के बीच अपरिवर्तित लाइनों की अधिकतम संख्या को जोड़ से पहले अनुमति दी जाएगी। डिफ़ॉल्ट 0 है।
  • id_abbrev : मुद्रित करने के लिए संक्षिप्त GitHash की लंबाई निर्धारित करता है। डिफ़ॉल्ट 7
  • max_size : एक बूँद का अधिकतम फ़ाइल आकार। इस आकार के ऊपर, इसे एक बाइनरी ब्लॉब के रूप में माना जाएगा। डिफ़ॉल्ट 512 एमबी है।
  • old_prefix : वर्चुअल फ़ाइल निर्देशिका जिसमें पुरानी फ़ाइलों को अंतर के एक तरफ रखना है। डिफ़ॉल्ट "a"
  • new_prefix : वर्चुअल फ़ाइल निर्देशिका जिसमें भिन्न के एक तरफ नई फ़ाइलों को रखने के लिए। डिफ़ॉल्ट "b"
source

LibGit2.FetchHead प्रकार

LibGit2.FetchHead

एक भ्रूण के दौरान HEAD के बारे में जानकारी शामिल है, जिसमें ब्रांच का नाम और URL शामिल है, HEAD की ओआईडी, और चाहे भ्रूण HEAD को स्थानीय रूप से मर्ज किया गया हो।

खेतों का प्रतिनिधित्व करते हैं:

  • name : भ्रूण के सिर के स्थानीय संदर्भ डेटाबेस में नाम, उदाहरण के लिए, "refs/heads/master"
  • url : फ़ेच हेड का URL।
  • oid : GitHash सिर की नोक के GitHash
  • ismerge : बूलियन ध्वज यह दर्शाता है कि रिमोट में परिवर्तन अभी तक स्थानीय प्रति में ismerge गया है या नहीं। यदि यह true , तो स्थानीय प्रतिलिपि सुदूर लाने वाले सिर के साथ अद्यतित है।
source

LibGit2.FetchOptions प्रकार

LibGit2.FetchOptions

git_fetch_options संरचना से मेल खाता है।

खेतों का प्रतिनिधित्व करते हैं:

  • version : उपयोग में संरचना का संस्करण, यदि यह बाद में बदलता है। अभी के लिए, हमेशा 1
  • callbacks : दूरस्थ कॉलबैक को लाने के दौरान उपयोग करना।
  • prune : क्या प्रैग्नेंसी के बाद प्रून करना है या नहीं। डिफ़ॉल्ट GitConfig से सेटिंग का उपयोग करना है।
  • update_fetchhead : क्या FetchHead बाद FetchHead को अपडेट करना है या नहीं। डिफ़ॉल्ट अद्यतन करना है, जो सामान्य व्यवहार है।
  • download_tags : रिमोट पर मौजूद टैग डाउनलोड करना है या नहीं। डिफ़ॉल्ट उन वस्तुओं के लिए टैग का अनुरोध करने के लिए है जो सर्वर से वैसे भी डाउनलोड किए जा रहे हैं।
  • proxy_opts : प्रॉक्सी के माध्यम से रिमोट से कनेक्ट करने के विकल्प। ProxyOptions देखें। केवल libgit2 संस्करणों पर वर्तमान में 0.25.0 से अधिक या उसके बराबर है।
  • custom_headers : किसी अतिरिक्त हेडर को लाने के लिए आवश्यक है। केवल libgit2 संस्करणों पर वर्तमान में 0.24.0 से अधिक या उसके बराबर है।
source

LibGit2.GitAnnotated प्रकार

GitAnnotated(repo::GitRepo, commit_id::GitHash)
GitAnnotated(repo::GitRepo, ref::GitReference)
GitAnnotated(repo::GitRepo, fh::FetchHead)
GitAnnotated(repo::GitRepo, comittish::AbstractString)

एक एनोटेट गिट कमिटमेंट यह जानकारी देता है कि इसे कैसे और क्यों देखा गया है, ताकि रिबेज या मर्ज ऑपरेशन में कमिट के संदर्भ में अधिक जानकारी हो। उदाहरण के लिए, विरोधाभासी फ़ाइलों में मर्ज की स्रोत / लक्ष्य शाखाओं के बारे में जानकारी होती है, जो परस्पर विरोधी होती हैं। एक एनोटेट प्रतिबद्ध एक दूरस्थ शाखा की नोक को संदर्भित कर सकता है, उदाहरण के लिए जब एक FetchHead पारित किया जाता है, या एक शाखा प्रमुख को GitReference का उपयोग करके वर्णित किया GitReference

source

LibGit2.GitBlame प्रकार

GitBlame(repo::GitRepo, path::AbstractString; options::BlameOptions=BlameOptions())

path पर फ़ाइल के लिए GitBlame ऑब्जेक्ट का निर्माण करें, repo के इतिहास से GitBlame परिवर्तन जानकारी का उपयोग करते हुए। GitBlame ऑब्जेक्ट रिकॉर्ड करता है कि किसने कब, और कैसे फ़ाइल का हिस्सा बदल दिया। options नियंत्रित करते हैं कि फ़ाइल की सामग्री को कैसे अलग किया जाए और कौन-सी जाँच की जाए - अधिक जानकारी के लिए BlameOptions देखें।

source

LibGit2.GitBlob प्रकार

GitBlob(repo::GitRepo, hash::AbstractGitHash)
GitBlob(repo::GitRepo, spec::AbstractString)

hash / spec द्वारा निर्दिष्ट repo से एक GitBlob ऑब्जेक्ट GitBlob

  • hash एक पूर्ण ( GitHash ) या आंशिक ( GitShortHash ) हैश है।
  • spec एक पाठ विनिर्देश है: पूरी सूची के लिए गिट डॉक्स देखें।
source

LibGit2.GitCommit प्रकार

GitCommit(repo::GitRepo, hash::AbstractGitHash)
GitCommit(repo::GitRepo, spec::AbstractString)

hash / spec द्वारा निर्दिष्ट repo से एक GitCommit ऑब्जेक्ट GitCommit

  • hash एक पूर्ण ( GitHash ) या आंशिक ( GitShortHash ) हैश है।
  • spec एक पाठ विनिर्देश है: पूरी सूची के लिए गिट डॉक्स देखें।
source

LibGit2.GitHash प्रकार

GitHash

शिट -1 हैश के आधार पर एक git ऑब्जेक्ट आइडेंटिफ़ायर। यह एक 20 बाइट स्ट्रिंग (40 हेक्स अंक) है जिसका उपयोग रिपॉजिटरी में एक GitObject पहचान करने के लिए किया जाता है।

source

LibGit2.GitObject प्रकार

GitObject(repo::GitRepo, hash::AbstractGitHash)
GitObject(repo::GitRepo, spec::AbstractString)

निर्दिष्ट वस्तु ( GitCommit , GitBlob , GitTree या GitTag ) को hash / spec द्वारा निर्दिष्ट repo से GitTag

  • hash एक पूर्ण ( GitHash ) या आंशिक ( GitShortHash ) हैश है।
  • spec एक पाठ विनिर्देश है: पूरी सूची के लिए गिट डॉक्स देखें।
source

LibGit2.GitRemote प्रकार

GitRemote(repo::GitRepo, rmt_name::AbstractString, rmt_url::AbstractString) -> GitRemote

इसके नाम और URL का उपयोग करके एक दूरस्थ गिट रिपॉजिटरी देखें। डिफ़ॉल्ट लाने के लिए refspec का उपयोग करता है।

उदाहरण

repo = LibGit2.init(repo_path)
remote = LibGit2.GitRemote(repo, "upstream", repo_url)
source
GitRemote(repo::GitRepo, rmt_name::AbstractString, rmt_url::AbstractString, fetch_spec::AbstractString) -> GitRemote

रिपॉजिटरी के नाम और URL का उपयोग करते हुए एक दूरस्थ गिट रिपॉजिटरी देखें, साथ ही रिमोट से लाने के लिए विनिर्देशों (जैसे कि रिमोट शाखा को कहां से लाएं)।

उदाहरण

repo = LibGit2.init(repo_path)
refspec = "+refs/heads/mybranch:refs/remotes/origin/mybranch"
remote = LibGit2.GitRemote(repo, "upstream", repo_url, refspec)
source

LibGit2.GitRemoteAnon फ़ंक्शन

GitRemoteAnon(repo::GitRepo, url::AbstractString) -> GitRemote

एक दूरस्थ गिट रिपॉजिटरी को केवल इसके URL का उपयोग करके देखें, इसके नाम के लिए नहीं।

उदाहरण

repo = LibGit2.init(repo_path)
remote = LibGit2.GitRemoteAnon(repo, repo_url)
source

LibGit2.GitRepo प्रकार

LibGit2.GitRepo(path::AbstractString)

path एक गिट भंडार खोलें।

source

LibGit2.GitRepoExt फ़ंक्शन

LibGit2.GitRepoExt(path::AbstractString, flags::Cuint = Cuint(Consts.REPOSITORY_OPEN_DEFAULT))

विस्तारित नियंत्रण के साथ path पर गिट रिपॉजिटरी खोलें (उदाहरण के लिए, यदि वर्तमान उपयोगकर्ता को path पढ़ने के लिए एक विशेष पहुंच समूह का सदस्य होना चाहिए)।

source

LibGit2.GitRevWalker प्रकार

GitRevWalker(repo::GitRepo)

GitRevWalker एक git रिपॉजिटरी repo के संशोधन (यानी कमिट) के माध्यम से चलता है । यह रिपॉजिटरी में कमिट्स का एक संग्रह है, और map और count लिए पुनरावृत्ति और कॉल का समर्थन करता है (उदाहरण के लिए, count का उपयोग यह निर्धारित करने के लिए किया जा सकता है कि रिपॉजिटरी में कितने प्रतिशत कमेंट्स एक निश्चित लेखक द्वारा किए गए थे)।

cnt = LibGit2.with(LibGit2.GitRevWalker(repo)) do walker
    count((oid,repo)->(oid == commit_oid1), walker, oid=commit_oid1, by=LibGit2.Consts.SORT_TIME)
end

यहाँ, count एक निश्चित GitHash साथ चलने के साथ GitHash की संख्या का पता GitHash । चूँकि GitHash एक GitHash लिए अद्वितीय है, cnt 1 होगा।

source

LibGit2.GitShortHash प्रकार

GitShortHash(hash::GitHash, len::Integer)

एक छोटा गिट ऑब्जेक्ट आइडेंटिफ़ायर, जिसका उपयोग अद्वितीय होने पर एक गिट ऑब्जेक्ट की पहचान करने के लिए किया जा सकता है, जिसमें hash के प्रारंभिक len हेक्साडेसिमल अंकों (शेष अंकों को अनदेखा किया जाता है) से मिलकर बनता है।

source

LibGit2.GitSignature प्रकार

LibGit2.GitSignature

यह एक जूलिया रैपर है जो एक पॉइंटर के आसपास git_signature ऑब्जेक्ट पर होता है।

source

LibGit2.GitStatus प्रकार

LibGit2.GitStatus(repo::GitRepo; status_opts=StatusOptions())

गिट रिपॉजिटरी repo में प्रत्येक फ़ाइल की स्थिति के बारे में जानकारी एकत्र करें (जैसे फ़ाइल संशोधित, मंचन, आदि)। status_opts का उपयोग विभिन्न विकल्पों को सेट करने के लिए किया जा सकता है, उदाहरण के लिए, status_opts फ़ाइलों को देखना है या नहीं या status_opts को शामिल करना है या नहीं। अधिक जानकारी के लिए StatusOptions देखें।

source

LibGit2.GitTag प्रकार

GitTag(repo::GitRepo, hash::AbstractGitHash)
GitTag(repo::GitRepo, spec::AbstractString)

hash / spec द्वारा निर्दिष्ट repo से एक GitTag ऑब्जेक्ट GitTag

  • hash एक पूर्ण ( GitHash ) या आंशिक ( GitShortHash ) हैश है।
  • spec एक पाठ विनिर्देश है: पूरी सूची के लिए गिट डॉक्स देखें।
source

LibGit2.GitTree प्रकार

GitTree(repo::GitRepo, hash::AbstractGitHash)
GitTree(repo::GitRepo, spec::AbstractString)

hash / spec द्वारा निर्दिष्ट repo से एक GitTree वस्तु GitTree

  • hash एक पूर्ण ( GitHash ) या आंशिक ( GitShortHash ) हैश है।
  • spec एक पाठ विनिर्देश है: पूरी सूची के लिए गिट डॉक्स देखें।
source

LibGit2.IndexEntry प्रकार

LibGit2.IndexEntry

सूचकांक में एक फ़ाइल प्रविष्टि की स्मृति में प्रतिनिधित्व। git_index_entry संरचना से मेल खाता है।

source

LibGit2.IndexTime प्रकार

LibGit2.IndexTime

git_index_time संरचना से मेल खाता है।

source

LibGit2.BlameOptions प्रकार

LibGit2.BlameOptions

git_blame_options संरचना से मेल खाता है।

खेतों का प्रतिनिधित्व करते हैं:

  • version : उपयोग में संरचना का संस्करण, यदि यह बाद में बदलता है। अभी के लिए, हमेशा 1
  • flags : Consts.BLAME_NORMAL या Consts.BLAME_FIRST_PARENT (अन्य दोष झंडे अभी तक libgit2 द्वारा लागू नहीं किए गए हैं)।
  • min_match_characters : अल्फ़ान्यूमेरिक वर्णों की न्यूनतम संख्या जो उस कमिट के साथ जुड़े रहने के लिए एक कमिट में बहुत कुछ बदल जाती है। डिफ़ॉल्ट 20 है। केवल तभी प्रभावी होता है, जब Consts.BLAME_*_COPIES का एक Consts.BLAME_*_COPIES झंडे का उपयोग किया जाता है, जिसे libgit2 अभी तक लागू नहीं करता है।
  • newest_commit : नए कमिट का GitHash जिसमें से बदलावों को देखना है।
  • oldest_commit : सबसे पुराना कमिट का GitHash जिसमें से बदलाव को देखना है।
  • min_line : फ़ाइल की पहली पंक्ति जिसमें से दोष शुरू करना है। डिफ़ॉल्ट 1
  • max_line : फ़ाइल की अंतिम पंक्ति जिसे दोष देना है। डिफ़ॉल्ट 0 , जिसका अर्थ है फ़ाइल की अंतिम पंक्ति।
source

LibGit2.MergeOptions प्रकार

LibGit2.MergeOptions

git_merge_options संरचना से मेल खाता है।

खेतों का प्रतिनिधित्व करते हैं:

  • version : उपयोग में संरचना का संस्करण, यदि यह बाद में बदलता है। अभी के लिए, हमेशा 1
  • flags : मर्ज व्यवहार का वर्णन झंडे के लिए एक enum git_merge_flag_t में परिभाषित किया git_merge_flag_t । इसी जूलिया GIT_MERGE और इसमें मान हैं:
    • MERGE_FIND_RENAMES : यह पता लगाएं कि क्या आम पूर्वज और "हमारा" या "उनका" मर्ज के बीच एक फ़ाइल का नाम बदल दिया गया है। जहां फ़ाइल का नाम बदला गया है वहां विलय की अनुमति देता है।
    • MERGE_FAIL_ON_CONFLICT : यदि इसे हल करने का प्रयास करने के बजाय कोई विरोधाभास पाया जाता है, तो तुरंत बाहर निकलें।
    • MERGE_SKIP_REUC : मर्ज से उत्पन्न सूचकांक पर REUC एक्सटेंशन नहीं लिखें।
    • MERGE_NO_RECURSIVE : यदि मर्ज किए जा रहे हैं, तो कई मर्ज बेस हैं, पहले एक का उपयोग करें, बजाय बेस को मर्ज करने का प्रयास करें।
  • rename_threshold : कैसे समान दो फ़ाइलों को एक दूसरे के नाम बदलने पर विचार करना चाहिए। यह एक पूर्णांक है जो प्रतिशत समानता सेट करता है। डिफ़ॉल्ट 50 है।
  • target_limit : नाम बदलने के लिए देखने के लिए फ़ाइलों की अधिकतम संख्या। डिफ़ॉल्ट 200 है।
  • metric : वैकल्पिक कस्टम फ़ंक्शन का नाम बदलने के लिए दो फ़ाइलों के बीच समानता निर्धारित करने के लिए उपयोग करें।
  • recursion_limit : मर्ज के लिए एक नया वर्चुअल मर्ज बेस बनाने की कोशिश करने के लिए प्रदर्शन करने के लिए आम पूर्वजों के मर्ज की संख्या पर ऊपरी सीमा। डिफ़ॉल्ट कोई सीमा नहीं है। यह फ़ील्ड केवल 0.24.0 की तुलना में नए रूप से libgit2 संस्करणों पर मौजूद है।
  • default_driver : मर्ज ड्राइवर का उपयोग करने के लिए यदि दोनों पक्ष बदल गए हैं। यह फ़ील्ड केवल 0.25.0 से नए रूप में libgit2 संस्करणों पर मौजूद है।
  • file_favor : text ड्राइवर के लिए परस्पर विरोधी फ़ाइल सामग्री को कैसे file_favor
    • MERGE_FILE_FAVOR_NORMAL : यदि मर्ज के दोनों किनारों में एक खंड में परिवर्तन होता है, तो सूचकांक में संघर्ष का एक नोट बनाएं, जो कि git checkout एक मर्ज फ़ाइल बनाने के लिए उपयोग करेगा, जिसे उपयोगकर्ता फिर विरोधों को हल करने के लिए संदर्भित कर सकता है। यह डिफ़ॉल्ट है।
    • MERGE_FILE_FAVOR_OURS : यदि मर्ज के दोनों किनारों पर एक खंड में परिवर्तन होता है, तो इंडेक्स में मर्ज के "हमारा" पक्ष में संस्करण का उपयोग करें।
    • MERGE_FILE_FAVOR_THEIRS : यदि मर्ज के दोनों किनारों पर एक खंड में परिवर्तन होता है, तो इंडेक्स में मर्ज के "उनके" पक्ष में संस्करण का उपयोग करें।
    • MERGE_FILE_FAVOR_UNION : यदि मर्ज के दोनों किनारों में एक खंड में परिवर्तन होता है, तो उस फ़ाइल में दोनों तरफ से प्रत्येक अद्वितीय पंक्ति को शामिल करें जिसे इंडेक्स में डाला गया है।
  • file_flags : फ़ाइलों को मर्ज करने के लिए दिशानिर्देश।
source

LibGit2.ProxyOptions प्रकार

LibGit2.ProxyOptions

प्रॉक्सी के माध्यम से कनेक्ट करने के लिए विकल्प।

git_proxy_options संरचना से मेल खाता है।

खेतों का प्रतिनिधित्व करते हैं:

  • version : उपयोग में संरचना का संस्करण, यदि यह बाद में बदलता है। अभी के लिए, हमेशा 1
  • proxytype : टाइप करने के लिए प्रॉक्सी के प्रकार के लिए एक proxytype git_proxy_t में परिभाषित किया git_proxy_t । इसी जूलिया GIT_PROXY और इसमें मान हैं:
    • PROXY_NONE : प्रॉक्सी के माध्यम से कनेक्शन का प्रयास न करें।
    • PROXY_AUTO : PROXY_AUTO कॉन्फ़िगरेशन से प्रॉक्सी कॉन्फ़िगरेशन का पता लगाने का प्रयास।
    • PROXY_SPECIFIED : इस संरचना के url फ़ील्ड में दिए गए URL का उपयोग करके कनेक्ट करें।
    डिफ़ॉल्ट प्रॉक्सी प्रकार का स्वतः पता लगाना है।
  • url : प्रॉक्सी का URL।
  • credential_cb : एक कॉलबैक फ़ंक्शन के लिए एक पॉइंटर, जिसे कॉल किया जाएगा यदि रिमोट को कनेक्ट करने के लिए प्रमाणीकरण की आवश्यकता होती है।
  • certificate_cb : कॉलबैक फ़ंक्शन के लिए एक संकेतक जो प्रमाणपत्र सत्यापन विफल होने पर कॉल किया जाएगा। यह उपयोगकर्ता को यह तय करने देता है कि उसे कनेक्ट रखना है या नहीं। यदि फ़ंक्शन 1 लौटता है, तो कनेक्ट करने की अनुमति दी जाएगी। यदि यह 0 देता है, तो कनेक्शन की अनुमति नहीं दी जाएगी। त्रुटियों को वापस करने के लिए एक नकारात्मक मूल्य का उपयोग किया जा सकता है।
  • payload : दो कॉलबैक फ़ंक्शन के लिए प्रदान किया जाने वाला पेलोड।

उदाहरण

julia> fo = LibGit2.FetchOptions(
           proxy_opts = LibGit2.ProxyOptions(url = Cstring("https://my_proxy_url.com")))

julia> fetch(remote, "master", options=fo)
source

LibGit2.PushOptions प्रकार

LibGit2.PushOptions

git_push_options संरचना से मेल खाता है।

खेतों का प्रतिनिधित्व करते हैं:

  • version : उपयोग में संरचना का संस्करण, यदि यह बाद में बदलता है। अभी के लिए, हमेशा 1
  • parallelism : यदि कोई पैक फ़ाइल बनाई जानी चाहिए, तो यह चर वर्कर थ्रेड्स की संख्या सेट करता है, जो कि पैकबिल्डर द्वारा प्रायोजित किया जाएगा। यदि 0 , पैकबिल्डर उपयोग करने के लिए थ्रेड्स की संख्या को ऑटो-सेट करेगा। डिफ़ॉल्ट 1
  • callbacks : कॉलबैक (जैसे रिमोट के साथ प्रमाणीकरण के लिए) पुश के लिए उपयोग करना।
  • proxy_opts : केवल तभी प्रासंगिक है जब LibGit2 संस्करण 0.25.0 से अधिक या उसके बराबर हो। रिमोट के साथ संवाद करने के लिए प्रॉक्सी का उपयोग करने के लिए विकल्प सेट करता है। अधिक जानकारी के लिए ProxyOptions देखें।
  • custom_headers : केवल प्रासंगिक अगर LibGit2 संस्करण 0.24.0 से अधिक या इसके बराबर है। पुश ऑपरेशन के लिए आवश्यक अतिरिक्त हेडर।
source

LibGit2.RebaseOperation प्रकार

LibGit2.RebaseOperation

रिबेज़ के दौरान किए जाने वाले एकल निर्देश / ऑपरेशन का वर्णन करता है। git_rebase_operation संरचना से मेल खाता है।

खेतों का प्रतिनिधित्व करते हैं:

  • optype : वर्तमान में प्रदर्शन किए जा रहे optype ऑपरेशन का प्रकार। विकल्प हैं:
    • REBASE_OPERATION_PICK : चेरी-कमिट को सवाल में चुनें।
    • REBASE_OPERATION_REWORD : चेरी को प्रश्न में कमिट करें, लेकिन प्रॉम्प्ट का उपयोग करके इसके संदेश को फिर से लिखें।
    • REBASE_OPERATION_EDIT : चेरी को प्रश्न में चुनें, लेकिन उपयोगकर्ता को कमिट की सामग्री और उसके संदेश को संपादित करने की अनुमति दें।
    • REBASE_OPERATION_SQUASH : पिछली प्रतिबद्ध में प्रश्न में प्रतिबद्ध स्क्वैश। दोनों कमिट्स के प्रतिबद्ध संदेशों को मिला दिया जाएगा।
    • REBASE_OPERATION_FIXUP : पिछली प्रतिबद्ध में प्रश्न में प्रतिबद्ध स्क्वैश। केवल पिछली कमिट के मैसेज का ही इस्तेमाल किया जा सकेगा।
    • REBASE_OPERATION_EXEC : कमिट नहीं करें। एक कमांड चलाएँ और यदि कमांड सफलतापूर्वक बाहर निकलता है तो जारी रखें।
  • id : इस GitHash कदम के दौरान काम किया जा रहा है।
  • exec : यदि REBASE_OPERATION_EXEC का उपयोग किया जाता है, तो इस चरण के दौरान चलने के लिए कमांड (उदाहरण के लिए, प्रत्येक कमिट के बाद टेस्ट सूट चलाना)।
source

LibGit2.RebaseOptions प्रकार

LibGit2.RebaseOptions

git_rebase_options संरचना से मेल खाता है।

खेतों का प्रतिनिधित्व करते हैं:

  • version : उपयोग में संरचना का संस्करण, यदि यह बाद में बदलता है। अभी के लिए, हमेशा 1
  • quiet : रिबेट पर काम करने / करने में मदद करने वाले अन्य गिट क्लाइंट को सूचित करें कि रिबास को "चुपचाप" किया जाना चाहिए। अंतर के लिए प्रयुक्त। डिफ़ॉल्ट 1
  • inmemory : एक इन-मेमोरी inmemory शुरू करें। रीबेस पर काम करने वाले कॉलर्स इसके चरणों से गुजर सकते हैं और कोई भी बदलाव कर सकते हैं, लेकिन HEAD को रिवाइंड नहीं कर सकते और न ही रिपॉजिटरी को अपडेट कर सकते हैं। workdir को संशोधित नहीं किया जाएगा। केवल libgit2 संस्करणों पर वर्तमान में 0.24.0 से अधिक या उसके बराबर है।
  • rewrite_notes_ref : नोटों के संदर्भ का नाम प्रतिबद्ध नोटों को फिर से लिखने के लिए उपयोग करना है rewrite_notes_ref समाप्त हो गया है।
  • merge_opts : मर्ज विकल्प यह नियंत्रित करता है कि पेड़ों को प्रत्येक रिबेस चरण में कैसे merge_opts जाएगा। केवल libgit2 संस्करणों पर वर्तमान में 0.24.0 से अधिक या उसके बराबर है।
  • checkout_opts : रिबास को इनिशियलाइज़ करते समय, इसके माध्यम से कदम बढ़ाते हुए और इसे निरस्त करते हुए फाइल लिखने के लिए चेकआउट विकल्प। अधिक जानकारी के लिए CheckoutOptions देखें।
source

LibGit2.RemoteCallbacks प्रकार

LibGit2.RemoteCallbacks

कॉलबैक सेटिंग्स। git_remote_callbacks संरचना से मेल खाता है।

source

LibGit2.SignatureStruct प्रकार

LibGit2.SignatureStruct

एक एक्शन सिग्नेचर (जैसे कमिटर्स, टैगर्स आदि के लिए)। git_signature संरचना से मेल खाता है।

खेतों का प्रतिनिधित्व करते हैं:

  • name : कमिट या कमिट करने वाले का पूरा नाम।
  • email : वह ईमेल जिस पर कमिटर / लेखक से संपर्क किया जा सकता है।
  • when : एक TimeStruct जब इंगित करता है कि प्रतिबद्ध लेखक / रिपॉजिटरी में प्रतिबद्ध था।
source

LibGit2.StatusEntry प्रकार

LibGit2.StatusEntry

फ़ाइल के बीच अंतर प्रदान करना जैसा कि HEAD और इंडेक्स में मौजूद है, और इंडेक्स और वर्किंग डायरेक्टरी के बीच अंतर प्रदान करता है। git_status_entry संरचना से मेल खाता है।

खेतों का प्रतिनिधित्व करते हैं:

  • status : फ़ाइल के लिए स्थिति ध्वज हैं, यह दर्शाता है कि यह चालू है, या इंडेक्स या वर्क ट्री में किसी तरह से बदल दिया गया है।
  • head_to_index : एक head_to_index एक सूचक जो फ़ाइल के बीच अंतर (ओं) को DiffDelta देता है क्योंकि यह HEAD और सूचकांक में मौजूद है।
  • index_to_workdir : एक index_to_workdir एक सूचक जो फ़ाइल के बीच अंतर (ओं) को workdir करता है क्योंकि यह सूचकांक में और workdir में मौजूद है।
source

LibGit2.StatusOptions प्रकार

LibGit2.StatusOptions

यह नियंत्रित करने के विकल्प कि git_status_foreach_ext() कॉलबैक कैसे जारी करेगा। git_status_opt_t संरचना से मेल खाता है।

खेतों का प्रतिनिधित्व करते हैं:

  • version : उपयोग में संरचना का संस्करण, यदि यह बाद में बदलता है। अभी के लिए, हमेशा 1
  • show : एक झंडा जिसके लिए फाइलों की जांच और किस क्रम में। डिफ़ॉल्ट Consts.STATUS_SHOW_INDEX_AND_WORKDIR
  • flags : एक स्थिति कॉल में इस्तेमाल किसी भी कॉलबैक को नियंत्रित करने के लिए झंडे।
  • pathspec : पथ-मिलान के लिए उपयोग करने के लिए पथों की एक सरणी। पथ-मिलान का व्यवहार show और flags के मूल्यों के आधार पर अलग-अलग होगा।
  • baseline कार्यशील निर्देशिका और सूचकांक की तुलना के लिए उपयोग किया जाने वाला पेड़ है; सिर करने के लिए चूक।
source

LibGit2.StrArrayStruct प्रकार

LibGit2.StrArrayStruct

तार की एक सरणी का एक LibGit2 प्रतिनिधित्व। git_strarray संरचना से मेल खाता है।

LibGit2 से डेटा प्राप्त करते समय, एक विशिष्ट उपयोग ऐसा दिखेगा:

sa_ref = Ref(StrArrayStruct())
@check ccall(..., (Ptr{StrArrayStruct},), sa_ref)
res = convert(Vector{String}, sa_ref[])
free(sa_ref)

विशेष रूप से, ध्यान दें कि LibGit2.free को Ref ऑब्जेक्ट पर बाद में बुलाया जाना चाहिए।

इसके विपरीत, जब LibGit2 के तार के वेक्टर को पास करते हैं, तो आमतौर पर निहित रूपांतरण पर भरोसा करना सबसे सरल होता है:

strs = String[...]
@check ccall(..., (Ptr{StrArrayStruct},), strs)

ध्यान दें कि जूलिया द्वारा डेटा आवंटित किए जाने पर free में कॉल की आवश्यकता नहीं है।

source

LibGit2.TimeStruct प्रकार

LibGit2.TimeStruct

एक हस्ताक्षर में समय। git_time संरचना से मेल खाता है।

source

LibGit2.add! समारोह

add!(repo::GitRepo, files::AbstractString...; flags::Cuint = Consts.INDEX_ADD_DEFAULT)
add!(idx::GitIndex, files::AbstractString...; flags::Cuint = Consts.INDEX_ADD_DEFAULT)

सूचकांक idx (या repo के सूचकांक) के लिए files द्वारा निर्दिष्ट पथ के साथ सभी फ़ाइलों को जोड़ें। यदि फ़ाइल पहले से मौजूद है, तो इंडेक्स प्रविष्टि को अपडेट किया जाएगा। यदि फ़ाइल पहले से मौजूद नहीं है, तो इसे इंडेक्स में नया जोड़ा जाएगा। files में ग्लोब पैटर्न हो सकते हैं जिनका विस्तार किया जाएगा और कोई भी मेल खाने वाली फ़ाइल जोड़ी जाएगी (जब तक कि INDEX_ADD_DISABLE_PATHSPEC_MATCH सेट न हो INDEX_ADD_DISABLE_PATHSPEC_MATCH , नीचे देखें)। यदि किसी फ़ाइल को ( .gitignore या config में) अनदेखा किया गया है, तो उसे जोड़ा नहीं जाएगा, जब तक कि यह पहले से ही सूचकांक में ट्रैक नहीं किया जा रहा है, जिस स्थिति में इसे अपडेट किया जाएगा । कीवर्ड तर्क flags बिट- flags का एक सेट है जो अनदेखा फ़ाइलों के संबंध में व्यवहार को नियंत्रित करता है:

  • Consts.INDEX_ADD_DEFAULT - डिफ़ॉल्ट, ऊपर वर्णित है।
  • Consts.INDEX_ADD_FORCE - मौजूदा अनदेखा नियमों की अवहेलना करें और फ़ाइल के बल के अलावा इंडेक्स पर भी इसे अनदेखा करें।
  • Consts.INDEX_ADD_CHECK_PATHSPEC - का उपयोग उसी समय नहीं किया जा सकता जैसा कि INDEX_ADD_FORCE । जाँच करें कि डिस्क में मौजूद files में से प्रत्येक फ़ाइल अनदेखा सूची में नहीं है। यदि फ़ाइलों में से एक को अनदेखा किया जाता है, तो फ़ंक्शन EINVALIDSPEC
  • Consts.INDEX_ADD_DISABLE_PATHSPEC_MATCH - ग्लोब मैचिंग बंद करें, और केवल उन फाइलों को इंडेक्स में जोड़ें जो files में निर्दिष्ट पथों से बिल्कुल मेल खाती हैं।
source

LibGit2.add_fetch! समारोह

add_fetch!(repo::GitRepo, rmt::GitRemote, fetch_spec::String)

निर्दिष्ट rmt लिए एक भ्रूण रिस्पेक जोड़ें। इस रिस्पेक्ट में किस शाखा (तों) से जानकारी प्राप्त होगी।

उदाहरण

julia> LibGit2.add_fetch!(repo, remote, "upstream");

julia> LibGit2.fetch_refspecs(remote)
String["+refs/heads/*:refs/remotes/upstream/*"]
source

LibGit2.add_push! समारोह

add_push!(repo::GitRepo, rmt::GitRemote, push_spec::String)

निर्दिष्ट rmt लिए एक पुश refspec जोड़ें। इस रीस्पेक में किस शाखा (तों) के बारे में जानकारी दी जाएगी।

उदाहरण

julia> LibGit2.add_push!(repo, remote, "refs/heads/master");

julia> remote = LibGit2.get(LibGit2.GitRemote, repo, branch);

julia> LibGit2.push_refspecs(remote)
String["refs/heads/master"]
ध्यान दें

परिवर्तन को प्रभावी करने के push और काम करने के लिए कॉल करने के लिए कॉल करने के लिए इसकी पुश रीस्पेक को अपडेट करने के बाद आपको GitRemote को फिर से close करना होगा।

source

LibGit2.addblob! समारोह

LibGit2.addblob!(repo::GitRepo, path::AbstractString)

path पर फ़ाइल पढ़ें और इसे repo के ऑब्जेक्ट डेटाबेस में एक ढीली बूँद के रूप में जोड़ता है। परिणामी बूँद के GitHash लौटें।

उदाहरण

hash_str = string(commit_oid)
blob_file = joinpath(repo_path, ".git", "objects", hash_str[1:2], hash_str[3:end])
id = LibGit2.addblob!(repo, blob_file)
source

LibGit2.author फ़ंक्शन

author(c::GitCommit)

Signature के लेखक का Signature लौटाएँ। लेखक वह व्यक्ति है जिसने प्रासंगिक फ़ाइल (s) में परिवर्तन किए हैं। committer भी देखें।

source

LibGit2.authors फ़ंक्शन

authors(repo::GitRepo) -> Vector{Signature}

repo भंडार में आने वाले सभी लेखकों को लौटाएं।

उदाहरण

repo = LibGit2.GitRepo(repo_path)
repo_file = open(joinpath(repo_path, test_file), "a")

println(repo_file, commit_msg)
flush(repo_file)
LibGit2.add!(repo, test_file)
sig = LibGit2.Signature("TEST", "[email protected]", round(time(), 0), 0)
commit_oid1 = LibGit2.commit(repo, "commit1"; author=sig, committer=sig)
println(repo_file, randstring(10))
flush(repo_file)
LibGit2.add!(repo, test_file)
commit_oid2 = LibGit2.commit(repo, "commit2"; author=sig, committer=sig)

# will be a Vector of [sig, sig]
auths = LibGit2.authors(repo)
source

LibGit2.branch फ़ंक्शन

branch(repo::GitRepo)

git branch समतुल्य। वर्तमान HEAD से एक नई शाखा बनाएँ।

source

LibGit2.branch! समारोह

branch!(repo::GitRepo, branch_name::AbstractString, commit::AbstractString=""; kwargs...)

repo रिपॉजिटरी में एक नई गिट शाखा की जाँच करें। commit GitHash , स्ट्रिंग रूप में, जो नई शाखा की शुरुआत होगी। यदि commit एक खाली स्ट्रिंग है, तो वर्तमान HEAD का उपयोग किया जाएगा।

कीवर्ड तर्क हैं:

  • track::AbstractString="" : दूरस्थ शाखा का नाम इस नई शाखा को ट्रैक करना चाहिए, यदि कोई हो। यदि खाली (डिफ़ॉल्ट), कोई दूरस्थ शाखा ट्रैक नहीं की जाएगी।
  • force::Bool=false : अगर true , तो शाखा निर्माण मजबूर हो जाएगा।
  • set_head::Bool=true : यदि true , तो शाखा निर्माण समाप्त होने के बाद शाखा प्रमुख को repo के HEAD के रूप में सेट किया जाएगा।

git checkout [-b|-B] <branch_name> [<commit>] [--track <track>] बराबर git checkout [-b|-B] <branch_name> [<commit>] [--track <track>]

उदाहरण

repo = LibGit2.GitRepo(repo_path)
LibGit2.branch!(repo, "new_branch", set_head=false)
source

LibGit2.checkout! समारोह

checkout!(repo::GitRepo, commit::AbstractString=""; force::Bool=true)

git checkout [-f] --detach <commit> बराबर git checkout [-f] --detach <commit> । Git प्रतिबद्ध commit ( GitHash स्ट्रिंग रूप में) में चेकआउट करें repo । यदि force है true , तो चेकआउट को बाध्य करें और किसी भी वर्तमान परिवर्तन को छोड़ दें। ध्यान दें कि यह वर्तमान HEAD का पता लगाता है।

उदाहरण

repo = LibGit2.init(repo_path)
open(joinpath(LibGit2.path(repo), "file1"), "w") do f
    write(f, "111
")
end
LibGit2.add!(repo, "file1")
commit_oid = LibGit2.commit(repo, "add file1")
open(joinpath(LibGit2.path(repo), "file1"), "w") do f
    write(f, "112
")
end
# would fail without the force=true
# since there are modifications to the file
LibGit2.checkout!(repo, string(commit_oid), force=true)
source

LibGit2.clone समारोह

clone(repo_url::AbstractString, repo_path::AbstractString, clone_opts::CloneOptions)

दूरस्थ रिपॉजिटरी पर क्लोन करें repo_url (जो स्थानीय फाइल सिस्टम पर एक दूरस्थ URL या पथ हो सकता है) repo_path (जो स्थानीय फाइल सिस्टम पर एक पथ होना चाहिए)। क्लोन के लिए विकल्प, जैसे कि नंगे क्लोन करना या न करना, द्वारा निर्धारित हैं CloneOptions

उदाहरण

repo_url = "https://github.com/JuliaLang/Example.jl"
repo = LibGit2.clone(repo_url, "/home/me/projects/Example")
source
clone(repo_url::AbstractString, repo_path::AbstractString; kwargs...)

repo_url स्थानीय फाइलसिस्टम स्थान पर स्थित दूरस्थ रिपॉजिटरी को क्लोन करें repo_path

कीवर्ड तर्क हैं:

  • branch::AbstractString="" : रिमोट की कौन सी शाखा क्लोन करने के लिए, यदि डिफ़ॉल्ट रिपॉजिटरी शाखा (आमतौर पर master ) नहीं।
  • isbare::Bool=false : यदि true , रिमोट को एक नंगे रिपॉजिटरी के रूप में क्लोन किया जाता है, जो repo_path इसके बजाय खुद को गिट डायरेक्टरी बना देगा repo_path/.git । इसका मतलब यह है कि एक कार्यशील पेड़ की जाँच नहीं की जा सकती है। गिट सीएलआई तर्क की भूमिका निभाता है --bare
  • remote_cb::Ptr{Cvoid}=C_NULL : एक कॉलबैक जिसका उपयोग क्लोन बनाने से पहले रिमोट बनाने के लिए किया जाएगा। यदि C_NULL (डिफ़ॉल्ट), रिमोट बनाने के लिए कोई प्रयास नहीं किया जाएगा - यह पहले से मौजूद माना जाएगा।
  • credentials::Creds=nothing : एक निजी भंडार के खिलाफ प्रमाणित करते समय क्रेडेंशियल और / या सेटिंग्स प्रदान करता है।
  • callbacks::Callbacks=Callbacks() : उपयोगकर्ता कॉलबैक और पेलोड प्रदान करता है।

के बराबर है git clone [-b <branch>] [--bare] <repo_url> <repo_path>

उदाहरण

repo_url = "https://github.com/JuliaLang/Example.jl"
repo1 = LibGit2.clone(repo_url, "test_path")
repo2 = LibGit2.clone(repo_url, "test_path", isbare=true)
julia_url = "https://github.com/JuliaLang/julia"
julia_repo = LibGit2.clone(julia_url, "julia_path", branch="release-0.6")
source

LibGit2.commit समारोह

commit(repo::GitRepo, msg::AbstractString; kwargs...) -> GitHash

चारों ओर लहरदार git_commit_create । भंडार में एक प्रतिबद्ध बनाएँ repomsg प्रतिबद्ध संदेश है। नई प्रतिबद्ध का OID लौटाएं।

कीवर्ड तर्क हैं:

  • refname::AbstractString=Consts.HEAD_FILE : यदि NULL नहीं है, तो नई कमेटी को इंगित करने के लिए संदर्भ का नाम। उदाहरण के लिए, "HEAD" वर्तमान शाखा के HEAD को अपडेट करेगा। यदि संदर्भ अभी तक मौजूद नहीं है, तो इसे बनाया जाएगा।
  • author::Signature = Signature(repo) Signature उस व्यक्ति के बारे में एक जानकारी है, जो प्रतिबद्ध है।
  • committer::Signature = Signature(repo) Signature उस व्यक्ति के बारे में एक जानकारी है, जिसने भंडार के लिए प्रतिबद्ध है। जरूरी नहीं कि author उदाहरण के लिए, अगर यह author एक पैच ईमेल committer जो इसे प्रतिबद्ध है।
  • tree_id::GitHash = GitHash() एक कमिट बनाने के लिए उपयोग करने के लिए एक पेड़ है, जो अपने वंश और किसी अन्य इतिहास के साथ संबंध दिखा रहा है। tree से संबंधित होना चाहिए repo
  • parent_ids::Vector{GitHash}=GitHash[] GitHash माता-पिता द्वारा नए के लिए उपयोग किए जाने के लिए कमिट की एक सूची है , और खाली हो सकती है। उदाहरण के लिए, यदि कोई मर्ज कमिट है, तो कमिट में कई माता-पिता हो सकते हैं।
source
LibGit2.commit(rb::GitRebase, sig::GitSignature)

कमिट के रूप में rb उपयोग करके, रिबास को वर्तमान पैच दें sig । अगर कमिट पहले ही लागू किया जा चुका है तो चुप है।

source

LibGit2.committer समारोह

committer(c::GitCommit)

Signature कमेटी के कमिटेटर की वापसी c । कमिटेटर वह व्यक्ति होता है जिसने मूल रूप से लेखक द्वारा किए गए बदलावों को प्रतिबद्ध किया है author , लेकिन author उदाहरण के लिए author पैच को ईमेल करने वाले व्यक्ति के समान ही होने की आवश्यकता नहीं है committer

source

LibGit2.count समारोह

LibGit2.count(f::Function, walker::GitRevWalker; oid::GitHash=GitHash(), by::Cint=Consts.SORT_NONE, rev::Bool=false)

रिपॉजिटरी के इतिहास में हर कमिट पर "वॉक" का उपयोग करते हुए , उन पर लागू होने वाले कमिट की संख्या ज्ञात करें। कीवर्ड तर्क हैं: * : से चलना शुरू करने के लिए प्रतिबद्ध है। डिफ़ॉल्ट का उपयोग करना है और इसलिए HEAD प्रतिबद्ध है और उसके सभी पूर्वजों। * : छँटाई विधि। डिफ़ॉल्ट को सॉर्ट नहीं करना है। अन्य विकल्प टोपोलॉजी ( ), समय में आगे की ओर छांटने के लिए ( , सबसे प्राचीन पहले) या समय में पीछे की ओर छांटने के लिए हैं ( सबसे हाल ही में पहले)। * : सॉर्ट किए गए ऑर्डर को उल्टा करना है (उदाहरण के लिए, यदि टोपोलॉजिकल सॉर्टिंग का उपयोग किया जाता है)। GitRevWalker walker true f oid GitHash push_head! by LibGit2.Consts.SORT_TOPOLOGICAL LibGit2.Consts.SORT_TIME LibGit2.Consts.SORT_REVERSE rev

उदाहरण

cnt = LibGit2.with(LibGit2.GitRevWalker(repo)) do walker
    count((oid, repo)->(oid == commit_oid1), walker, oid=commit_oid1, by=LibGit2.Consts.SORT_TIME)
end

count एक निश्चित के साथ वॉक के साथ कमिट्स की संख्या का पता लगाना GitHash commit_oid1 , उस कमिट से वॉक शुरू करना और उससे समय में आगे बढ़ना। चूंकि GitHash एक कमिटमेंट के लिए अनोखा है, cnt होगा 1

source

LibGit2.counthunks समारोह

counthunks(blame::GitBlame)

एक फ़ाइल के साथ विशिष्ट "हंक" की संख्या लौटाएं। एक हंक में कई लाइनें हो सकती हैं। हंक आमतौर पर एक फ़ाइल का एक टुकड़ा होता है जिसे जोड़ा / बदला / एक साथ हटाया जाता है, उदाहरण के लिए, एक फ़ंक्शन स्रोत फ़ाइल या एक आंतरिक लूप में जोड़ा जाता है जिसे बाद में उस फ़ंक्शन से अनुकूलित किया गया था।

source

LibGit2.create_branch समारोह

LibGit2.create_branch(repo::GitRepo, bname::AbstractString, commit_obj::GitCommit; force::Bool=false)

repo नाम के साथ रिपॉजिटरी में एक नई शाखा बनाएं bname , जो कमिट करने के लिए इशारा करती है commit_obj (जिसका हिस्सा होना है repo )। यदि force है true , bname तो मौजूद मौजूदा शाखा को अधिलेखित कर दें, यदि यह मौजूद है। यदि पहले से मौजूद कोई शाखा force है false और नाम है bname , तो यह फ़ंक्शन एक त्रुटि फेंक देगा।

source

LibGit2.credentials_callback समारोह

credential_callback(...) -> Cint

एक LibGit2 क्रेडेंशियल कॉलबैक फ़ंक्शन जो एक कनेक्शन प्रोटोकॉल को अलग-अलग क्रेडेंशियल अधिग्रहण कार्यक्षमता प्रदान करता है। payload_ptr एक को रोकने के लिए आवश्यक है LibGit2.CredentialPayload वस्तु जो राज्य और सेटिंग्स पर नज़र रखेंगे।

इसमें allowed_types उन LibGit2.Consts.GIT_CREDTYPE मानों का एक बिटमैप है, जो यह निर्दिष्ट करते हैं कि प्रमाणीकरण विधियों का प्रयास किया जाना चाहिए।

क्रेडेंशियल प्रमाणीकरण निम्नलिखित क्रम में किया जाता है (यदि समर्थित हो):

  • एसएसएच एजेंट
  • SSH निजी / सार्वजनिक कुंजी जोड़ी
  • उपयोगकर्ता नाम / पासवर्ड सादा पाठ

यदि कोई उपयोगकर्ता क्रेडेंशियल प्रॉम्प्ट के साथ प्रस्तुत किया जाता है, तो वे टाइप करके ^D नियंत्रण को रोक सकते हैं (कुंजी के साथ नियंत्रण कुंजी को दबाकर d )।

नोट : libgit2 प्रमाणीकरण प्रक्रिया की बारीकियों के कारण , जब प्रमाणीकरण विफल हो जाता है, तो यह फ़ंक्शन बिना किसी संकेत के फिर से कहा जाता है कि प्रमाणीकरण सफल था या नहीं। एक ही दोषपूर्ण क्रेडेंशियल्स का उपयोग करने से बार-बार होने वाले अनंत लूप से बचने के लिए, हम पेलोड का उपयोग करके राज्य का ट्रैक रखेंगे।

अतिरिक्त विवरण के लिए एक सर्वर के खिलाफ प्रमाणित करने पर LibGit2 गाइड देखें ।

source

LibGit2.credentials_cb समारोह

C फ़ंक्शन पॉइंटर के लिए credentials_callback

source

LibGit2.default_signature समारोह

वापसी हस्ताक्षर वस्तु। उपयोग के बाद इसे नि: शुल्क।

source

LibGit2.delete_branch समारोह

LibGit2.delete_branch(branch::GitReference)

द्वारा बताई गई शाखा को हटा दें branch

source

LibGit2.diff_files समारोह

diff_files(repo::GitRepo, branch1::AbstractString, branch2::AbstractString; kwarg...) -> Vector{AbstractString}

दिखाएँ कि कौन सी फाइलें repo शाखाओं branch1 और के बीच गिट रिपॉजिटरी में बदल गई हैं branch2

कीवर्ड तर्क है:

  • filter::Set{Consts.DELTA_STATUS}=Set([Consts.DELTA_ADDED, Consts.DELTA_MODIFIED, Consts.DELTA_DELETED])) , और यह अंतर के लिए विकल्प सेट करता है। डिफ़ॉल्ट रूप से जोड़ी गई फ़ाइलों को दिखाना, संशोधित करना या हटाना है।

केवल उन फ़ाइलों के नाम लौटाएं जो बदल गई हैं, उनकी सामग्री नहीं

उदाहरण

LibGit2.branch!(repo, "branch/a")
LibGit2.branch!(repo, "branch/b")
# add a file to repo
open(joinpath(LibGit2.path(repo),"file"),"w") do f
    write(f, "hello repo
")
end
LibGit2.add!(repo, "file")
LibGit2.commit(repo, "add file")
# returns ["file"]
filt = Set([LibGit2.Consts.DELTA_ADDED])
files = LibGit2.diff_files(repo, "branch/a", "branch/b", filter=filt)
# returns [] because existing files weren't modified
filt = Set([LibGit2.Consts.DELTA_MODIFIED])
files = LibGit2.diff_files(repo, "branch/a", "branch/b", filter=filt)

के बराबर है git diff --name-only --diff-filter=<filter> <branch1> <branch2>

source

LibGit2.entryid समारोह

entryid(te::GitTreeEntry)

GitHash जिस वस्तु को te संदर्भित करता है उस पर लौटें ।

source

LibGit2.entrytype समारोह

entrytype(te::GitTreeEntry)

जिस ऑब्जेक्ट को te संदर्भित करता है उस प्रकार पर लौटें । परिणाम एक प्रकार का होगा जो objtype रिटर्न करता है, उदाहरण के लिए a GitTree या GitBlob

source

LibGit2.fetch समारोह

fetch(rmt::GitRemote, refspecs; options::FetchOptions=FetchOptions(), msg="")

निर्दिष्ट rmt दूरस्थ गिट रिपॉजिटरी से प्राप्त करें , refspecs यह निर्धारित करने के लिए कि किस दूरस्थ शाखा (तों) को लाने के लिए। कीवर्ड तर्क हैं:

  • options : भ्रूण के लिए विकल्पों को निर्धारित करता है, जैसे कि बाद में चुभाना है या नहीं। FetchOptions अधिक जानकारी के लिए देखें ।
  • msg : रिफ्लक्स में डालने का संदेश।
source
fetch(repo::GitRepo; kwargs...)

भंडार के अपस्ट्रीम से अपडेट प्राप्त करता है repo

कीवर्ड तर्क हैं:

  • remote::AbstractString="origin" : कौन सा रिमोट, नाम से निर्दिष्ट, repo से लाने के लिए। यदि यह खाली है, तो अनाम रिमोट का निर्माण करने के लिए URL का उपयोग किया जाएगा।
  • remoteurl::AbstractString="" : का URL remote । यदि निर्दिष्ट नहीं है, तो दिए गए नाम के आधार पर मान लिया जाएगा remote
  • refspecs=AbstractString[] : भ्रूण के गुणों को निर्धारित करता है।
  • credentials=nothing : एक निजी के खिलाफ प्रमाणित करते समय क्रेडेंशियल और / या सेटिंग्स प्रदान करता है remote
  • callbacks=Callbacks() : उपयोगकर्ता कॉलबैक और पेलोड प्रदान करता है।

के बराबर है git fetch [<remoteurl>|<repo>] [<refspecs>]

source

LibGit2.fetchheads समारोह

fetchheads(repo::GitRepo) -> Vector{FetchHead}

सभी के लिए सभी प्रमुखों की सूची लौटाएं repo , प्रत्येक को FetchHead उनके नाम, यूआरएल और मर्ज की स्थिति सहित एक के रूप में दर्शाया गया है ।

उदाहरण

julia> fetch_heads = LibGit2.fetchheads(repo);

julia> fetch_heads[1].name
"refs/heads/master"

julia> fetch_heads[1].ismerge
true

julia> fetch_heads[2].name
"refs/heads/test_branch"

julia> fetch_heads[2].ismerge
false
source

LibGit2.fetch_refspecs समारोह

fetch_refspecs(rmt::GitRemote) -> Vector{String}

निर्दिष्ट के लिए फ़्लेक्स रीस्पेक प्राप्त करें rmt । इन परिवेदनों में किस शाखा (तों) से जानकारी प्राप्त होती है।

उदाहरण

julia> remote = LibGit2.get(LibGit2.GitRemote, repo, "upstream");

julia> LibGit2.add_fetch!(repo, remote, "upstream");

julia> LibGit2.fetch_refspecs(remote)
String["+refs/heads/*:refs/remotes/upstream/*"]
source

LibGit2.fetchhead_foreach_cb समारोह

C फ़ंक्शन पॉइंटर के लिए fetchhead_foreach_callback

source

LibGit2.merge_base समारोह

merge_base(repo::GitRepo, one::AbstractString, two::AbstractString) -> GitHash

प्रतिबद्ध के बीच किसी मर्ज आधार (एक आम पूर्वज) का पता लगाएं, one और twoone और two दोनों स्ट्रिंग रूप में हो सकते हैं। GitHash मर्ज बेस की वापसी ।

source

LibGit2.merge! तरीका

merge!(repo::GitRepo; kwargs...) -> Bool

रिपॉजिटरी पर एक मर्ज मर्ज करें repo , वर्तमान शाखा में इतिहास को बदलने के साथ विलय करता है। true यदि मर्ज सफल हुआ, false तो नहीं लौटें ।

कीवर्ड तर्क हैं:

  • committish::AbstractString="" : नामित प्रतिबद्ध (ओं) को मर्ज करें committish
  • branch::AbstractString="" : ब्रांच branch और उसके सभी कमिट्स को मर्ज करें क्योंकि यह करंट ब्रांच से डाइवर्ट होता है।
  • fastforward::Bool=false : यदि fastforward है true , तो केवल मर्ज करें यदि मर्ज एक तेजी से आगे है (वर्तमान शाखा प्रमुख मर्ज किए जाने के लिए पूर्वजों का पूर्वज है), अन्यथा विलय और वापस आने से इनकार करें false । यह गिट सीएलआई विकल्प के बराबर है --ff-only
  • merge_opts::MergeOptions=MergeOptions() : merge_opts मर्ज के लिए विकल्प निर्दिष्ट करता है, जैसे टकराव के मामले में मर्ज रणनीति।
  • checkout_opts::CheckoutOptions=CheckoutOptions() : checkout_opts चेकआउट चरण के लिए विकल्प निर्दिष्ट करता है।

के बराबर है git merge [--ff-only] [<committish> | <branch>]

ध्यान दें

यदि आप एक निर्दिष्ट करते हैं branch , तो इसे संदर्भ प्रारूप में किया जाना चाहिए, क्योंकि स्ट्रिंग को एक में बदल दिया जाएगा GitReference । उदाहरण के लिए, यदि आप शाखा का विलय करना चाहते हैं, तो आप branch_a कॉल करेंगे merge!(repo, branch="refs/heads/branch_a")

source

LibGit2.merge! तरीका

merge!(repo::GitRepo, anns::Vector{GitAnnotated}; kwargs...) -> Bool

एनोटेट किए गए कमिट्स ( GitAnnotated ऑब्जेक्ट्स के रूप में कैप्चर किए गए) से परिवर्तन anns को रिपॉजिटरी के हेड में मिलाएं repo । कीवर्ड तर्क हैं:

  • merge_opts::MergeOptions = MergeOptions() : मर्ज निष्पादित करने के लिए विकल्प, जिसमें फास्टफ़ॉर्मिंग की अनुमति है या नहीं। MergeOptions अधिक जानकारी के लिए देखें ।
  • checkout_opts::CheckoutOptions = CheckoutOptions() : चेकआउट करने के लिए विकल्प। CheckoutOptions अधिक जानकारी के लिए देखें ।

anns दूरस्थ या स्थानीय शाखा प्रमुखों को संदर्भित कर सकता है। true मर्ज सफल होने पर लौटें , अन्यथा वापस लौटें false (उदाहरण के लिए, यदि कोई मर्ज संभव नहीं है क्योंकि शाखाओं का कोई सामान्य पूर्वज नहीं है)।

उदाहरण

upst_ann = LibGit2.GitAnnotated(repo, "branch/a")

# merge the branch in
LibGit2.merge!(repo, [upst_ann])
source

LibGit2.merge! तरीका

merge!(repo::GitRepo, anns::Vector{GitAnnotated}, fastforward::Bool; kwargs...) -> Bool

एनोटेट किए गए कमिट्स ( GitAnnotated ऑब्जेक्ट्स के रूप में कैप्चर किए गए) से परिवर्तन anns को रिपॉजिटरी के हेड में मिलाएं repo । यदि fastforward है true , तो केवल एक तेज मर्ज की अनुमति है। इस स्थिति में, यदि विरोध होता है, तो मर्ज विफल हो जाएगा। अन्यथा, यदि fastforward है false , तो मर्ज एक विरोधाभास फ़ाइल का उत्पादन कर सकता है जिसे उपयोगकर्ता को हल करने की आवश्यकता होगी।

कीवर्ड तर्क हैं:

  • merge_opts::MergeOptions = MergeOptions() : मर्ज निष्पादित करने के लिए विकल्प, जिसमें फास्टफ़ॉर्मिंग की अनुमति है या नहीं। MergeOptions अधिक जानकारी के लिए देखें ।
  • checkout_opts::CheckoutOptions = CheckoutOptions() : चेकआउट करने के लिए विकल्प। CheckoutOptions अधिक जानकारी के लिए देखें ।

anns दूरस्थ या स्थानीय शाखा प्रमुखों को संदर्भित कर सकता है। true मर्ज सफल होने पर लौटें , अन्यथा वापस लौटें false (उदाहरण के लिए, यदि कोई मर्ज संभव नहीं है क्योंकि शाखाओं का कोई सामान्य पूर्वज नहीं है)।

उदाहरण

upst_ann_1 = LibGit2.GitAnnotated(repo, "branch/a")

# merge the branch in, fastforward
LibGit2.merge!(repo, [upst_ann_1], true)

# merge conflicts!
upst_ann_2 = LibGit2.GitAnnotated(repo, "branch/b")
# merge the branch in, try to fastforward
LibGit2.merge!(repo, [upst_ann_2], true) # will return false
LibGit2.merge!(repo, [upst_ann_2], false) # will return true
source

LibGit2.ffmerge! समारोह

ffmerge!(repo::GitRepo, ann::GitAnnotated)

तेजी से विलय वर्तमान HEAD में बदल जाता है। यह केवल तभी संभव है जब इसके द्वारा संदर्भित कमिट ann को वर्तमान हेड से उतारा जाता है (जैसे कि यदि एक दूरस्थ शाखा से परिवर्तन खींच रहा है जो स्थानीय शाखा टिप से आगे है)

source

LibGit2.fullname समारोह

LibGit2.fullname(ref::GitReference)

प्रतीकात्मक संदर्भ द्वारा इंगित संदर्भ का नाम लौटाएं ref । यदि ref एक प्रतीकात्मक संदर्भ नहीं है, तो एक खाली स्ट्रिंग लौटें।

source

LibGit2.features समारोह

features()

Git की सूची पर लौटें libgit2 समर्थन का वर्तमान संस्करण, जैसे कि HTTPS या SSH का उपयोग करना।

source

LibGit2.filename समारोह

filename(te::GitTreeEntry)

डिस्क पर ऑब्जेक्ट का फ़ाइल नाम लौटाएं जो te संदर्भित करता है।

source

LibGit2.filemode समारोह

filemode(te::GitTreeEntry) -> Cint

डिस्क पर ऑब्जेक्ट का UNIX फाइलमोड लौटाएं जो te एक पूर्णांक के रूप में संदर्भित करता है।

source

LibGit2.gitdir समारोह

LibGit2.gitdir(repo::GitRepo)

"Git" फ़ाइलों का स्थान लौटाएँ repo :

  • सामान्य रिपॉजिटरी के लिए, यह .git फ़ोल्डर का स्थान है ।
  • नंगे भंडार के लिए, यह भंडार का स्थान है।

यह भी देखें workdir , path

source

LibGit2.git_url समारोह

LibGit2.git_url(; kwargs...) -> String

प्रदान किए गए URL घटकों के आधार पर एक स्ट्रिंग बनाएं। जब scheme कीवर्ड प्रदान नहीं किया जाता है, तो उत्पादित URL वैकल्पिक scp- जैसे सिंटैक्स का उपयोग करेगा ।

कीवर्ड

  • scheme::AbstractString="" : URL स्कीम जो प्रयोग किए जाने वाले प्रोटोकॉल की पहचान करती है। HTTP उपयोग के लिए "http", SSH "ssh" आदि का उपयोग करें। जब scheme आउटपुट स्वरूप प्रदान नहीं किया जाता है तो "ssh" होगा, लेकिन scp की तरह सिंटैक्स का उपयोग करके।
  • username::AbstractString="" : यदि उपयोग किया जाता है, तो उपयोगकर्ता नाम आउटपुट में उपयोग किया जाता है।
  • password::AbstractString="" : यदि उपलब्ध हो तो आउटपुट में उपयोग करने के लिए पासवर्ड।
  • host::AbstractString="" : आउटपुट में उपयोग करने के लिए होस्टनाम। एक होस्टनाम निर्दिष्ट करने के लिए आवश्यक है।
  • port::Union{AbstractString,Integer}="" : यदि प्रदान की गई पोर्ट पोर्ट का उपयोग आउटपुट में किया जाए। एससीपी-जैसे सिंटैक्स का उपयोग करते समय निर्दिष्ट नहीं किया जा सकता है।
  • path::AbstractString="" : यदि आउटपुट में उपयोग करने के लिए पथ उपलब्ध कराया गया है।
चेतावनी

URL में पासवर्ड का उपयोग करने से बचें। क्रेडेंशियल ऑब्जेक्ट्स के विपरीत, जूलिया उपयोग के बाद संवेदनशील डेटा को सुरक्षित रूप से शून्य या नष्ट करने में सक्षम नहीं है और पासवर्ड स्मृति में रह सकता है; संभवत: एक असंबद्ध स्मृति द्वारा उजागर किया जाएगा।

उदाहरण

julia> LibGit2.git_url(username="git", host="github.com", path="JuliaLang/julia.git")
"[email protected]:JuliaLang/julia.git"

julia> LibGit2.git_url(scheme="https", host="github.com", path="/JuliaLang/julia.git")
"https://github.com/JuliaLang/julia.git"

julia> LibGit2.git_url(scheme="ssh", username="git", host="github.com", port=2222, path="JuliaLang/julia.git")
"ssh://[email protected]:2222/JuliaLang/julia.git"
source

[email protected]_str मैक्रो

@githash_str -> AbstractGitHash

दिए गए स्ट्रिंग से एक git हैश ऑब्जेक्ट का निर्माण करें, GitShortHash यदि स्ट्रिंग 40 हेक्साडेसिमल अंकों से कम है , तो वापस आ जाएगी , अन्यथा ए GitHash

उदाहरण

julia> LibGit2.githash"d114feb74ce633"
GitShortHash("d114feb74ce633")

julia> LibGit2.githash"d114feb74ce63307afe878a5228ad014e0289a85"
GitHash("d114feb74ce63307afe878a5228ad014e0289a85")
source

LibGit2.head समारोह

LibGit2.head(repo::GitRepo) -> GitReference

GitReference के वर्तमान सिर पर वापस लौटें repo

source
head(pkg::AbstractString) -> String

एक स्ट्रिंग के रूप GitHash में pkg रेपो के वर्तमान हेड को वापस करें ।

source

LibGit2.head! समारोह

LibGit2.head!(repo::GitRepo, ref::GitReference) -> GitReference

repo द्वारा इंगित की गई वस्तु का सिर सेट करें ref

source

LibGit2.head_oid समारोह

LibGit2.head_oid(repo::GitRepo) -> GitHash

Git रिपॉजिटरी के वर्तमान HEAD की ऑब्जेक्ट आईडी लुकअप करें repo

source

LibGit2.headname समारोह

LibGit2.headname(repo::GitRepo)

Git रिपॉजिटरी के वर्तमान HEAD का नाम लुकअप repo । यदि repo वर्तमान में अलग किया गया है, तो उसके द्वारा अलग किए गए HEAD का नाम वापस करें।

source

LibGit2.init समारोह

LibGit2.init(path::AbstractString, bare::Bool=false) -> GitRepo

पर एक नया गिट रिपॉजिटरी खोलें path । अगर bare है false , तो काम करने वाले पेड़ को बनाया जाएगा path/.git । यदि bare है true , तो कोई भी कार्यशील निर्देशिका नहीं बनाई जाएगी।

source

LibGit2.is_ancestor_of समारोह

is_ancestor_of(a::AbstractString, b::AbstractString, repo::GitRepo) -> Bool

लौटें true अगर a , एक GitHash स्ट्रिंग के रूप में, के एक पूर्वज है b , एक GitHash स्ट्रिंग के रूप में।

उदाहरण

julia> repo = LibGit2.GitRepo(repo_path);

julia> LibGit2.add!(repo, test_file1);

julia> commit_oid1 = LibGit2.commit(repo, "commit1");

julia> LibGit2.add!(repo, test_file2);

julia> commit_oid2 = LibGit2.commit(repo, "commit2");

julia> LibGit2.is_ancestor_of(string(commit_oid1), string(commit_oid2), repo)
true
source

LibGit2.isbinary समारोह

isbinary(blob::GitBlob) -> Bool

यदि फ़ाइल बाइनरी है, तो अनुमान लगाने के लिए एक अनुमानी का उपयोग करें: NULL बाइट्स की खोज करना और पहले 8000 बाइट्स के बीच गैर-मुद्रण योग्य वर्णों के लिए मुद्रण योग्य के उचित अनुपात की तलाश करना।

source

LibGit2.iscommit समारोह

iscommit(id::AbstractString, repo::GitRepo) -> Bool

जाँच करें कि क्या प्रतिबद्ध है id (जो GitHash स्ट्रिंग रूप में है) रिपॉजिटरी में है।

उदाहरण

julia> repo = LibGit2.GitRepo(repo_path);

julia> LibGit2.add!(repo, test_file);

julia> commit_oid = LibGit2.commit(repo, "add test_file");

julia> LibGit2.iscommit(string(commit_oid), repo)
true
source

LibGit2.isdiff समारोह

LibGit2.isdiff(repo::GitRepo, treeish::AbstractString, pathspecs::AbstractString=""; cached::Bool=false)

चेक करता है कि क्या treeish कार्यशील ट्री (यदि cached=false ) या इंडेक्स (यदि cached=true ) में निर्दिष्ट ट्री और ट्रैक की गई फ़ाइलों के बीच कोई अंतर है । pathspecs अंतर के लिए विकल्पों के लिए विनिर्देशों हैं।

उदाहरण

repo = LibGit2.GitRepo(repo_path)
LibGit2.isdiff(repo, "HEAD") # should be false
open(joinpath(repo_path, new_file), "a") do f
    println(f, "here's my cool new file")
end
LibGit2.isdiff(repo, "HEAD") # now true

के बराबर है git diff-index <treeish> [-- <pathspecs>]

source

LibGit2.isdirty समारोह

LibGit2.isdirty(repo::GitRepo, pathspecs::AbstractString=""; cached::Bool=false) -> Bool

जांचें कि क्या कार्यशील ट्री (यदि cached=false ) या इंडेक्स (यदि cached=true ) में ट्रैक की गई फ़ाइलों में कोई बदलाव हुआ है । pathspecs अंतर के लिए विकल्पों के लिए विनिर्देशों हैं।

उदाहरण

repo = LibGit2.GitRepo(repo_path)
LibGit2.isdirty(repo) # should be false
open(joinpath(repo_path, new_file), "a") do f
    println(f, "here's my cool new file")
end
LibGit2.isdirty(repo) # now true
LibGit2.isdirty(repo, new_file) # now true

के बराबर है git diff-index HEAD [-- <pathspecs>]

source

LibGit2.isorphan समारोह

LibGit2.isorphan(repo::GitRepo)

जांचें कि क्या वर्तमान शाखा एक "अनाथ" शाखा है, जिसका कोई आवागमन नहीं है। इस शाखा के लिए पहली प्रतिबद्धताओं में कोई माता-पिता नहीं होंगे।

source

LibGit2.isset समारोह

isset(val::Integer, flag::Integer)

परीक्षण करें कि क्या val अनुक्रमित बिट्स flag सेट हैं ( 1 ) या परेशान ( 0 )।

source

LibGit2.iszero समारोह

iszero(id::GitHash) -> Bool

निर्धारित करें कि दिए गए सभी हेक्साडेसिमल अंक GitHash शून्य हैं या नहीं।

source

LibGit2.lookup_branch समारोह

lookup_branch(repo::GitRepo, branch_name::AbstractString, remote::Bool=false) -> Union{GitReference, Nothing}

निर्धारित करें कि क्या निर्दिष्ट शाखा branch_name रिपॉजिटरी में मौजूद है repo । यदि remote है true , तो इसे repo एक दूरस्थ गिट रिपॉजिटरी माना जाता है। अन्यथा, यह स्थानीय फाइल सिस्टम का हिस्सा है।

GitReference यदि मौजूद है, या nothing नहीं तो अनुरोधित शाखा में या तो लौटें ।

source

LibGit2.map समारोह

LibGit2.map(f::Function, walker::GitRevWalker; oid::GitHash=GitHash(), range::AbstractString="", by::Cint=Consts.SORT_NONE, rev::Bool=false)

रिपॉजिटरी के इतिहास में हर कमिट पर "वॉक" का उपयोग करते हुए वॉक में प्रत्येक कमेटी पर लागू करें। कीवर्ड तर्क हैं: * : से चलना शुरू करने के लिए प्रतिबद्ध है। डिफ़ॉल्ट का उपयोग करना है और इसलिए HEAD प्रतिबद्ध है और उसके सभी पूर्वजों। * : प्रारूप में एस की एक सीमा । दोनों के बीच सभी कमिट पर लागू किया जाएगा। * : छँटाई विधि। डिफ़ॉल्ट को सॉर्ट नहीं करना है। अन्य विकल्प टोपोलॉजी ( ), समय में आगे की ओर छांटने के लिए ( , सबसे प्राचीन पहले) या समय में पीछे की ओर क्रमबद्ध करने के लिए हैं ( सबसे हाल ही में सबसे पहले)। * : सॉर्ट किए गए ऑर्डर को उल्टा करना है (उदाहरण के लिए, यदि टोपोलॉजिकल सॉर्टिंग का उपयोग किया जाए)। GitRevWalker walker f oid GitHash push_head! range GitHash oid1..oid2 f by LibGit2.Consts.SORT_TOPOLOGICAL LibGit2.Consts.SORT_TIME LibGit2.Consts.SORT_REVERSE rev

उदाहरण

oids = LibGit2.with(LibGit2.GitRevWalker(repo)) do walker
    LibGit2.map((oid, repo)->string(oid), walker, by=LibGit2.Consts.SORT_TIME)
end

यहाँ, map का उपयोग करके प्रत्येक कमिट पर जाता है GitRevWalker और इसका पता लगाता है GitHash

source

LibGit2.mirror_callback समारोह

दर्पण कॉलबैक फ़ंक्शन

रिमोट संदर्भ के लिए फ़ंक्शन सेट +refs/*:refs/* रिफस्पेस और mirror ध्वज।

source

LibGit2.mirror_cb समारोह

C फ़ंक्शन पॉइंटर के लिए mirror_callback

source

LibGit2.message समारोह

message(c::GitCommit, raw::Bool=false)

प्रतिबद्ध में किए गए परिवर्तनों का वर्णन करते हुए प्रतिबद्ध संदेश लौटाएं c । यदि raw है false , तो थोड़ा "क्लीन अप" संदेश लौटाएं (जिसमें किसी भी प्रमुख newlines को हटा दिया गया है)। यदि raw है true , तो इस तरह के किसी भी नए समाचार को संदेश नहीं लिया गया है।

source

LibGit2.merge_analysis समारोह

merge_analysis(repo::GitRepo, anns::Vector{GitAnnotated}) -> analysis, preference

एनोटेटेड शाखा युक्तियों द्वारा इंगित शाखाओं पर विश्लेषण चलाएं anns और निर्धारित करें कि उन्हें किन परिस्थितियों में विलय किया जा सकता है। उदाहरण के लिए, यदि anns[1] बस का पूर्वज है ann[2] , तो merge_analysis रिपोर्ट करेगा कि एक तेजी से आगे विलय संभव है।

दो आउटपुट लौटाएँ, analysis और preferenceanalysis कई संभावित मूल्य हैं: * MERGE_ANALYSIS_NONE : के तत्वों को मर्ज करना संभव नहीं है anns । * MERGE_ANALYSIS_NORMAL - एक नियमित रूप से मर्ज, जब HEAD और यह बताता है कि उपयोगकर्ता मर्ज करना चाहता है, तो सभी एक सामान्य पूर्वज से विमुख हो गए हैं। इस मामले में परिवर्तनों को हल करना होगा और टकराव हो सकता है। * MERGE_ANALYSIS_UP_TO_DATE - उपयोगकर्ता द्वारा मर्ज किए जाने की इच्छा रखने वाले सभी इनपुट एचईएडी से पहुंच सकते हैं, इसलिए मर्ज करने की आवश्यकता नहीं है। * MERGE_ANALYSIS_FASTFORWARD - इनपुट कमिट HEAD का एक वंशज है और इसलिए किसी मर्ज को निष्पादित करने की आवश्यकता नहीं है - इसके बजाय, उपयोगकर्ता बस इनपुट कमिट (ओं) को जांच सकता है। * MERGE_ANALYSIS_UNBORN - रिपॉजिटरी का HEAD एक ऐसी कमेटी को संदर्भित करता है जो मौजूद नहीं है। विलय करना संभव नहीं है, लेकिन इनपुट कमिट्स की जांच करना संभव हो सकता है। preference कई संभावित मान भी हैं: * MERGE_PREFERENCE_NONE : उपयोगकर्ता की कोई प्राथमिकता नहीं है। * MERGE_PREFERENCE_NO_FASTFORWARD - किसी भी तेज़-फॉरवर्ड मर्ज की अनुमति न दें। * MERGE_PREFERENCE_FASTFORWARD_ONLY - केवल तेज़-अग्रेषित मर्ज और किसी अन्य प्रकार की अनुमति दें (जो संघर्ष का परिचय दे सकता है)। preference भंडार या वैश्विक गिट विन्यास के माध्यम से नियंत्रित किया जा सकता है।

source

LibGit2.name समारोह

LibGit2.name(ref::GitReference)

का पूरा नाम वापस करें ref

source
name(rmt::GitRemote)

उदाहरण के लिए, एक दूरस्थ भंडार का नाम प्राप्त करें "origin" । यदि रिमोट अनाम है (देखें GitRemoteAnon ) तो नाम एक रिक्त स्ट्रिंग होगा ""

उदाहरण

julia> repo_url = "https://github.com/JuliaLang/Example.jl";

julia> repo = LibGit2.clone(cache_repo, "test_directory");

julia> remote = LibGit2.GitRemote(repo, "origin", repo_url);

julia> name(remote)
"origin"
source
LibGit2.name(tag::GitTag)

का नाम tag (जैसे "v0.5" )।

source

LibGit2.need_update समारोह

need_update(repo::GitRepo)

के बराबर है git update-indextrue यदि repo अद्यतन करने की आवश्यकता है, तो वापस लौटें ।

source

LibGit2.objtype समारोह

objtype(obj_type::Consts.OBJECT)

Enum मान के अनुरूप टाइप करें।

source

LibGit2.path समारोह

LibGit2.path(repo::GitRepo)

रिपॉजिटरी के बेस फाइल पाथ को वापस करें repo

  • सामान्य रिपॉजिटरी के लिए, यह आमतौर पर ".गित" निर्देशिका की मूल निर्देशिका होगी (ध्यान दें: यह कार्यशील निर्देशिका से भिन्न हो सकती है, workdir अधिक विवरण के लिए देखें)।
  • नंगे रिपोजिटरी के लिए, यह "गिट" फाइलों का स्थान है।

यह भी देखें gitdir , workdir

source

LibGit2.peel समारोह

peel([T,] ref::GitReference)

ref प्रकार की वस्तु T प्राप्त होने तक पुन: छीलें । यदि कोई T प्रदान नहीं किया गया है, तो तब ref तक छील दिया जाएगा जब तक कि एक वस्तु के अलावा अन्य वस्तु GitTag प्राप्त नहीं की जाती है।

  • एक GitTag वस्तु को संदर्भित किया जाएगा।
  • A GitCommit को छील दिया जाएगा a GitTree
ध्यान दें

केवल एनोटेट किए गए टैग को GitTag ऑब्जेक्ट्स पर छील दिया जा सकता है । लाइटवेट टैग (डिफ़ॉल्ट) वे संदर्भ हैं refs/tags/ जिनके अंतर्गत GitCommit वस्तुओं पर सीधे संकेत दिया जाता है ।

source
peel([T,] obj::GitObject)

obj प्रकार की वस्तु T प्राप्त होने तक पुन: छीलें । यदि कोई T प्रदान नहीं किया गया है, तो obj प्रकार बदलने तक छील दिया जाएगा।

  • एक GitTag वस्तु को संदर्भित किया जाएगा।
  • A GitCommit को छील दिया जाएगा a GitTree
source

LibGit2.posixpath समारोह

LibGit2.posixpath(path)

path POSIX विभाजक का उपयोग करने के लिए पथ स्ट्रिंग मानकीकृत करें ।

source

LibGit2.push समारोह

push(rmt::GitRemote, refspecs; force::Bool=false, options::PushOptions=PushOptions())

पुश करने के लिए कौन सी दूरस्थ शाखा (एस) निर्धारित करने के लिए rmt उपयोग करके, निर्दिष्ट दूरस्थ गिट रिपॉजिटरी में refspecs पुश करें। कीवर्ड तर्क हैं:

  • force : अगर true , एक बल-धक्का होगा, संघर्षों की अवहेलना।
  • options : पुश के लिए विकल्पों को निर्धारित करता है, जैसे कि प्रॉक्सी हेडर का उपयोग करना। PushOptions अधिक जानकारी के लिए देखें ।
ध्यान दें

आप दो अन्य तरीकों से पुश रिस्पेक्ट के बारे में जानकारी जोड़ सकते हैं: रिपॉजिटरी में एक विकल्प सेट करके GitConfig ( push.default कुंजी के रूप में) या कॉल करके add_push! । अन्यथा आपको स्पष्ट रूप से कॉल में एक पुश रीस्पेक निर्दिष्ट करने की आवश्यकता होगी push , ताकि इसका कोई प्रभाव हो, जैसे LibGit2.push(repo, refspecs=["refs/heads/master"]) :।

source
push(repo::GitRepo; kwargs...)

अपस्ट्रीम के अपडेट्स को पुश करता है repo

कीवर्ड तर्क हैं:

  • remote::AbstractString="origin" : अपस्ट्रीम रिमोट का नाम पुश करने के लिए।
  • remoteurl::AbstractString="" : का URL remote
  • refspecs=AbstractString[] : पुश के गुण निर्धारित करता है।
  • force::Bool=false : निर्धारित करता है कि क्या धक्का एक बल धक्का होगा, दूरस्थ शाखा को अधिलेखित करेगा।
  • credentials=nothing : एक निजी के खिलाफ प्रमाणित करते समय क्रेडेंशियल और / या सेटिंग्स प्रदान करता है remote
  • callbacks=Callbacks() : उपयोगकर्ता कॉलबैक और पेलोड प्रदान करता है।

के बराबर है git push [<remoteurl>|<repo>] [<refspecs>]

source

LibGit2.push! तरीका

LibGit2.push!(w::GitRevWalker, cid::GitHash)

कमिट में शुरू करें । इस फ़ंक्शन का उपयोग किसी निश्चित वर्ष के बाद से उस वर्ष के पहले कमिट को पारित करके और फिर परिणाम के रूप में पारित करने के लिए एक फ़ंक्शन करने के लिए किया जा सकता है । GitRevWalker walker cid cid w map

source

LibGit2.push_head! समारोह

LibGit2.push_head!(w::GitRevWalker)

पुश हेड प्रतिबद्ध और उसके पूर्वजों पर । यह सुनिश्चित करता है कि चलने के दौरान HEAD और उसके सभी पूर्वजों का सामना किया जाएगा। GitRevWalker w

source

LibGit2.push_refspecs समारोह

push_refspecs(rmt::GitRemote) -> Vector{String}

निर्दिष्ट के लिए पुश refspecs प्राप्त करें rmt । इन रिस्पेक्ट में किस ब्रांच (तों) के बारे में जानकारी होनी है।

उदाहरण

julia> remote = LibGit2.get(LibGit2.GitRemote, repo, "upstream");

julia> LibGit2.add_push!(repo, remote, "refs/heads/master");

julia> close(remote);

julia> remote = LibGit2.get(LibGit2.GitRemote, repo, "upstream");

julia> LibGit2.push_refspecs(remote)
String["refs/heads/master"]
source

LibGit2.raw समारोह

raw(id::GitHash) -> Vector{UInt8}

GitHash 20 की लंबाई के वेक्टर के रूप में कच्ची बाइट्स प्राप्त करें ।

source

LibGit2.read_tree! समारोह

LibGit2.read_tree!(idx::GitIndex, tree::GitTree)
LibGit2.read_tree!(idx::GitIndex, treehash::AbstractGitHash)

इंडेक्स में पेड़ tree (या treehash स्वामित्व वाले भंडार द्वारा इंगित किया गया पेड़ ) पढ़ें । वर्तमान सूचकांक सामग्री को बदल दिया जाएगा। idx idx

source

LibGit2.rebase! समारोह

LibGit2.rebase!(repo::GitRepo, upstream::AbstractString="", newbase::AbstractString="")

upstream यदि उपलब्ध कराया गया है, या अन्यथा अपस्ट्रीम ट्रैकिंग शाखा से, वर्तमान शाखा का एक स्वचालित मर्ज रिबेस करें । newbase पर रिबेस करने के लिए ब्रांच है। डिफ़ॉल्ट रूप से यह है upstream

इसके कारण कोई विरोध उत्पन्न होती हैं जो स्वचालित रूप से हल नहीं किया जा सकता है, तो रिबेस को रद्द कर देगा, भंडार छोड़ने और उसकी मूल स्थिति में पेड़ से काम कर रहा है, और समारोह एक फेंक देते हैं GitError । यह निम्नलिखित कमांड लाइन कथन के लगभग बराबर है:

git rebase --merge [<upstream>]
if [ -d ".git/rebase-merge" ]; then
    git rebase --abort
fi
source

LibGit2.ref_list समारोह

LibGit2.ref_list(repo::GitRepo) -> Vector{String}

repo रिपॉजिटरी में सभी संदर्भ नामों की सूची प्राप्त करें ।

source

LibGit2.reftype समारोह

LibGit2.reftype(ref::GitReference) -> Cint

Cint इसके प्रकार पर वापस लौटें ref :

  • 0 यदि संदर्भ अमान्य है
  • 1 यदि संदर्भ एक वस्तु आईडी है
  • 2 यदि संदर्भ प्रतीकात्मक है
source

LibGit2.remotes समारोह

LibGit2.remotes(repo::GitRepo)

के रीमोट के नामों के एक वेक्टर पर लौटें repo

source

LibGit2.remove! समारोह

remove!(repo::GitRepo, files::AbstractString...)
remove!(idx::GitIndex, files::AbstractString...)

files अनुक्रमणिका idx (या अनुक्रमणिका repo ) द्वारा निर्दिष्ट पथ वाली सभी फ़ाइलों को निकालें ।

source

LibGit2.reset समारोह

reset(val::Integer, flag::Integer)

val अनुक्रमित के बिट्स को परेशान करें flag , उन्हें वापस लौटाएं 0

source

LibGit2.reset! समारोह

reset!(payload, [config]) -> CredentialPayload

payload प्रारंभिक मानों पर वापस स्थिति को रीसेट करें ताकि इसे क्रेडेंशियल कॉलबैक के भीतर फिर से उपयोग किया जा सके। यदि एक config प्रदान की जाती है तो कॉन्फ़िगरेशन भी अपडेट किया जाएगा।

source

pathspecs लक्ष्य प्रतिबद्ध पेड़ से सूचकांक में, द्वारा निर्धारित कुछ प्रविष्टियों को अद्यतन करता है ।

source

वर्तमान सिर को निर्दिष्ट प्रतिबद्ध ओड में सेट करता है और वैकल्पिक रूप से मिलान करने के लिए सूचकांक और कार्यशील पेड़ को रीसेट करता है।

source

git रीसेट [<committish>] [एक € "] <pathspecs> ...

source
reset!(repo::GitRepo, id::GitHash, mode::Cint=Consts.RESET_MIXED)

repo इसके id द्वारा निर्धारित तीन मोड में से एक का उपयोग करके, अपने राज्य में भंडार को रीसेट करें mode :

  1. Consts.RESET_SOFT - सिर को हिलाओ id
  2. Consts.RESET_MIXED - डिफ़ॉल्ट, HEAD को स्थानांतरित करें id और इंडेक्स को रीसेट करें id
  3. Consts.RESET_HARD - HEAD को स्थानांतरित करें id , सूचकांक को रीसेट करें id और सभी कार्य परिवर्तनों को त्याग दें।

उदाहरण

# fetch changes
LibGit2.fetch(repo)
isfile(joinpath(repo_path, our_file)) # will be false

# fastforward merge the changes
LibGit2.merge!(repo, fastforward=true)

# because there was not any file locally, but there is
# a file remotely, we need to reset the branch
head_oid = LibGit2.head_oid(repo)
new_head = LibGit2.reset!(repo, head_oid, LibGit2.Consts.RESET_HARD)

इस उदाहरण में, दूरस्थ रूप से प्राप्त किए गए किया जा रहा है करता है एक फ़ाइल कहा जाता है our_file कि अपनी अनुक्रमणिका, जिसके कारण हम रीसेट करना होगा में।

के बराबर है git reset [--soft | --mixed | --hard] <id>

उदाहरण

repo = LibGit2.GitRepo(repo_path)
head_oid = LibGit2.head_oid(repo)
open(joinpath(repo_path, "file1"), "w") do f
    write(f, "111
")
end
LibGit2.add!(repo, "file1")
mode = LibGit2.Consts.RESET_HARD
# will discard the changes to file1
# and unstage it
new_head = LibGit2.reset!(repo, head_oid, mode)
source

LibGit2.restore समारोह

restore(s::State, repo::GitRepo)

repo किसी पिछले के लिए एक रिपॉजिटरी लौटें State s , उदाहरण के लिए मर्ज प्रयास से पहले एक शाखा का हेड। फ़ंक्शन s का उपयोग करके उत्पन्न किया जा सकता है snapshot

source

LibGit2.revcount समारोह

LibGit2.revcount(repo::GitRepo, commit1::AbstractString, commit2::AbstractString)

( commit1 और commit2 स्ट्रिंग रूप में OIDs कमिट करें) के बीच संशोधनों की संख्या सूचीबद्ध करें । चूंकि commit1 और commit2 विभिन्न शाखाओं पर हो सकते हैं , क्रमशः revcount "बाएं-दाएं" संशोधन सूची (और गणना) करते हैं, Int एस के एक टपल को वापस करते हैं - क्रमशः बाएं और दाएं की संख्या। एक बाएं (या दाएं) कमिट से तात्पर्य यह है कि एक पेड़ में सममित अंतर के किस पक्ष से प्रतिबद्ध है।

के बराबर है git rev-list --left-right --count <commit1> <commit2>

उदाहरण

repo = LibGit2.GitRepo(repo_path)
repo_file = open(joinpath(repo_path, test_file), "a")
println(repo_file, "hello world")
flush(repo_file)
LibGit2.add!(repo, test_file)
commit_oid1 = LibGit2.commit(repo, "commit 1")
println(repo_file, "hello world again")
flush(repo_file)
LibGit2.add!(repo, test_file)
commit_oid2 = LibGit2.commit(repo, "commit 2")
LibGit2.revcount(repo, string(commit_oid1), string(commit_oid2))

यह लौट आएगा (-1, 0)

source

LibGit2.set_remote_url समारोह

set_remote_url(repo::GitRepo, remote_name, url)
set_remote_url(repo::String, remote_name, url)

सेट दोनों को लाने और धक्का url के लिए remote_name के लिए GitRepo या Git पर स्थित भंडार path । आमतौर पर git repos "origin" दूरस्थ नाम के रूप में उपयोग होता है ।

उदाहरण

repo_path = joinpath(tempdir(), "Example")
repo = LibGit2.init(repo_path)
LibGit2.set_remote_url(repo, "upstream", "https://github.com/JuliaLang/Example.jl")
LibGit2.set_remote_url(repo_path, "upstream2", "https://github.com/JuliaLang/Example2.jl")
source

LibGit2.shortname समारोह

LibGit2.shortname(ref::GitReference)

ref "मानव-पठनीय" के नाम का छोटा संस्करण लौटाएँ ।

julia> repo = LibGit2.GitRepo(path_to_repo);

julia> branch_ref = LibGit2.head(repo);

julia> LibGit2.name(branch_ref)
"refs/heads/master"

julia> LibGit2.shortname(branch_ref)
"master"
source

LibGit2.snapshot समारोह

snapshot(repo::GitRepo) -> State

repo वर्तमान HEAD, इंडेक्स, और किसी भी काम न करने के लिए भंडार के वर्तमान स्थिति का एक स्नैपशॉट लें । स्नैपशॉट स्थिति में रिपॉजिटरी को वापस State करने के restore लिए कॉल के दौरान बाद में आउटपुट का उपयोग किया जा सकता है ।

source

LibGit2.split_cfg_entry समारोह

LibGit2.split_cfg_entry(ce::LibGit2.ConfigEntry) -> Tuple{String,String,String,String}

ConfigEntry निम्नलिखित टुकड़ों तक तोड़ें : अनुभाग, उपधारा, नाम और मूल्य।

उदाहरण

Git कॉन्फ़िगरेशन फ़ाइल युक्त को देखते हुए:

[credential "https://example.com"]
    username = me

ConfigEntry निम्नलिखित दिखाई देगा:

julia> entry
ConfigEntry("credential.https://example.com.username", "me")

julia> LibGit2.split_cfg_entry(entry)
("credential", "https://example.com", "username", "me")

का संदर्भ लें Git config वाक्य रचना प्रलेखन अधिक जानकारी के लिए।

source

LibGit2.status समारोह

LibGit2.status(repo::GitRepo, path::String) -> Union{Cuint, Cvoid}

path Git रिपॉजिटरी में फ़ाइल की स्थिति देखें repo । उदाहरण के लिए, इसका उपयोग यह जांचने के लिए किया जा सकता है कि फ़ाइल path को संशोधित किया गया है या नहीं और इसका मंचन किया जाना चाहिए।

source

LibGit2.stage समारोह

stage(ie::IndexEntry) -> Cint

की चरण संख्या प्राप्त करें ie । चरण संख्या 0 कार्यशील पेड़ की वर्तमान स्थिति का प्रतिनिधित्व करती है, लेकिन अन्य संख्याओं का उपयोग मर्ज संघर्ष की स्थिति में किया जा सकता है। ऐसे मामले में, विभिन्न चरण संख्याओं का IndexEntry वर्णन किस पक्ष (ओं) के संघर्ष की वर्तमान स्थिति से है। स्टेज 0 का प्रयास किया मर्ज से पहले राज्य है, चरण 1 परिवर्तन जो स्थानीय रूप से बनाया गया है, चरणों है 2 और बड़ा अन्य शाखाओं से परिवर्तन (उदाहरण के लिए के लिए कर रहे हैं, एक बहु शाखा के मामले में "ऑक्टोपस" मर्ज, चरणों 2 , 3 और 4 हो सकता है इस्तेमाल किया गया)।

source

LibGit2.tag_create समारोह

LibGit2.tag_create(repo::GitRepo, tag::AbstractString, commit; kwargs...)

एक नया Git टैग बनाएँ tag (उदाहरण के लिए "v0.5" भंडार में) repo , प्रतिबद्ध पर commit

कीवर्ड तर्क हैं:

  • msg::AbstractString="" : टैग के लिए संदेश।
  • force::Bool=false : यदि true , मौजूदा संदर्भों को अधिलेखित कर दिया जाएगा।
  • sig::Signature=Signature(repo) : टैगर के हस्ताक्षर।
source

LibGit2.tag_delete समारोह

LibGit2.tag_delete(repo::GitRepo, tag::AbstractString)

tag रिपॉजिटरी से git टैग निकालें repo

source

LibGit2.tag_list समारोह

LibGit2.tag_list(repo::GitRepo) -> Vector{String}

गिट रिपॉजिटरी में सभी टैग की सूची प्राप्त करें repo

source

LibGit2.target समारोह

LibGit2.target(tag::GitTag)

की GitHash लक्ष्य वस्तु का tag

source

LibGit2.toggle समारोह

toggle(val::Integer, flag::Integer)

के val अनुक्रमित बिट्स को पलटें flag , ताकि अगर थोड़ा सा 0 यह 1 टॉगल के बाद होगा , और इसके विपरीत।

source

LibGit2.transact समारोह

transact(f::Function, repo::GitRepo)

लागू f करने से पहले repo लेने के लिए, गिट रिपॉजिटरी में फ़ंक्शन लागू करें । यदि कोई त्रुटि होती है , तो इसका उपयोग करके स्नैपशॉट स्थिति में वापस आ जाएगा । जो त्रुटि हुई, उसे फिर से हटा दिया जाएगा, लेकिन राज्य की स्थिति भ्रष्ट नहीं होगी। snapshot f f repo restore repo

source

LibGit2.treewalk समारोह

treewalk(f, tree::GitTree, post::Bool=false)

प्रविष्टियों को tree और इसके उप-बाद वाले पोस्ट या पूर्व क्रम में ट्रावर्स करें । Preorder का अर्थ है जड़ पर शुरू करना और फिर बाईं ओर की सबट्री को ट्रेस करना (और उस सबट्री के सबसे बाएं सबट्रेसेस के माध्यम से नीचे की तरफ) और सबट्रीज़ के माध्यम से दाईं ओर बढ़ना। पोस्टऑर्डर का अर्थ है बाईं ओर के सबसे ऊपरी सबरी के नीचे से शुरू होकर, इसके माध्यम से ऊपर की ओर ट्रेस करना, फिर अगले दायें सबट्री (फिर से नीचे की शुरुआत) पर ट्रेस करना और अंत में पेड़ की जड़ पर जाना।

फ़ंक्शन पैरामीटर f में निम्नलिखित हस्ताक्षर होने चाहिए:

(String, GitTreeEntry) -> Cint

एक नकारात्मक मान f ट्री वॉक को रोकता है। सकारात्मक मान का मतलब है कि प्रवेश करता है, तो छोड़ दिया जाएगा post है false

source

LibGit2.upstream समारोह

upstream(ref::GitReference) -> Union{GitReference, Nothing}

निर्धारित करें कि क्या शाखा वाले ref में एक विशिष्ट अपस्ट्रीम शाखा है।

GitReference यदि मौजूद है, nothing तो या तो अपस्ट्रीम शाखा में लौटें या यदि अनुरोधित शाखा में अपस्ट्रीम प्रतिरूप नहीं है।

source

LibGit2.update! समारोह

update!(repo::GitRepo, files::AbstractString...)
update!(idx::GitIndex, files::AbstractString...)

files अनुक्रमणिका idx (या अनुक्रमणिका repo ) द्वारा निर्दिष्ट पथ वाली सभी फ़ाइलों को अपडेट करें । डिस्क पर वर्तमान स्थिति के साथ सूचकांक में प्रत्येक फ़ाइल की स्थिति का मिलान करें, यदि डिस्क पर इसे हटा दिया गया है, या ऑब्जेक्ट डेटाबेस में इसकी प्रविष्टि को अपडेट करने पर इसे हटा दें।

source

LibGit2.url समारोह

url(rmt::GitRemote)

एक दूरस्थ गिट रिपॉजिटरी का भ्रूण URL प्राप्त करें।

उदाहरण

julia> repo_url = "https://github.com/JuliaLang/Example.jl";

julia> repo = LibGit2.init(mktempdir());

julia> remote = LibGit2.GitRemote(repo, "origin", repo_url);

julia> LibGit2.url(remote)
"https://github.com/JuliaLang/Example.jl"
source

LibGit2.version समारोह

version() -> VersionNumber

उपयोग के रूप में libgit2 का संस्करण लौटाएँ, a VersionNumber

source

LibGit2.with समारोह

with(f::Function, obj)

संसाधन प्रबंधन सहायक कार्य। लागू होता है f करने के लिए obj , कॉल करने के लिए सुनिश्चित करने के close पर obj के बाद f सफलतापूर्वक रिटर्न या कोई त्रुटि फेंकता है। यह सुनिश्चित करता है कि आवंटित संसाधनों को जल्द से जल्द अंतिम रूप दिया जाए क्योंकि अब उनकी आवश्यकता नहीं है।

source

LibGit2.with_warn समारोह

with_warn(f::Function, ::Type{T}, args...)

संसाधन प्रबंधन सहायक कार्य। लागू f करने के लिए args , पहले प्रकार का एक उदाहरण के निर्माण T से args । सफलतापूर्वक रिटर्न के close बाद परिणामी वस्तु पर कॉल करना सुनिश्चित करता f है या एक त्रुटि फेंकता है। यह सुनिश्चित करता है कि आवंटित संसाधनों को जल्द से जल्द अंतिम रूप दिया जाए क्योंकि अब उनकी आवश्यकता नहीं है। यदि किसी त्रुटि के द्वारा फेंक दिया जाता है f , तो एक चेतावनी जिसमें त्रुटि दिखाई गई है।

source

LibGit2.workdir समारोह

LibGit2.workdir(repo::GitRepo)

की कार्यशील निर्देशिका का स्थान लौटाएं repo । यह नंगे रिपोजिटरी के लिए एक त्रुटि फेंक देगा।

ध्यान दें

यह आमतौर पर की मूल निर्देशिका होगी gitdir(repo) , लेकिन कुछ मामलों में अलग हो सकती है: उदाहरण के लिए या तो core.worktree कॉन्फ़िगरेशन चर या GIT_WORK_TREE पर्यावरण चर सेट है।

यह भी देखें gitdir , path

source

LibGit2.GitObject तरीका

(::Type{T})(te::GitTreeEntry) where T<:GitObject

उदाहरण के लिए या te इसके वास्तविक प्रकार के रूप में इसे संदर्भित करने के लिए git ऑब्जेक्ट प्राप्त करें और इसे टाइप करें । entrytype GitBlob GitTag

उदाहरण

tree = LibGit2.GitTree(repo, "HEAD^{tree}")
tree_entry = tree[1]
blob = LibGit2.GitBlob(tree_entry)
source

LibGit2.UserPasswordCredential प्रकार

क्रेडेंशियल जो केवल user और password मापदंडों का समर्थन करते हैं

source

LibGit2.SSHCredential प्रकार

एसएसएच क्रेडेंशियल प्रकार

source

LibGit2.isfilled समारोह

isfilled(cred::AbstractCredential) -> Bool

सत्यापित करता है कि प्रमाणीकरण में उपयोग के लिए एक क्रेडेंशियल तैयार है।

source

LibGit2.CachedCredentials प्रकार

पुनः उपयोग के लिए क्रेडेंशियल जानकारी कैश करता है

source

LibGit2.CredentialPayload प्रकार

LibGit2.CredentialPayload

एक ही URL के लिए क्रेडेंशियल कॉलबैक में कई कॉल के बीच की स्थिति को बनाए रखता है। जब भी इसका उपयोग किसी भिन्न URL के साथ किया जाएगा, तो एक CredentialPayload उदाहरण होने की उम्मीद है reset!

source

LibGit2.approve समारोह

approve(payload::CredentialPayload; shred::Bool=true) -> Nothing

payload भविष्य के प्रमाणीकरण में पुन: उपयोग के लिए क्रेडेंशियल स्टोर करें । प्रमाणीकरण सफल होने पर ही बुलाया जाना चाहिए।

shred कीवर्ड नियंत्रण पेलोड क्रेडेंशियल क्षेत्र में संवेदनशील जानकारी को नष्ट कर दिया जाना चाहिए। केवल false परीक्षण के दौरान निर्धारित किया जाना चाहिए ।

source

LibGit2.reject समारोह

reject(payload::CredentialPayload; shred::Bool=true) -> Nothing

payload भविष्य के प्रमाणीकरण में फिर से उपयोग शुरू होने से क्रेडेंशियल को छोड़ दें । केवल तभी बुलाया जाना चाहिए जब प्रमाणीकरण असफल रहा।

shred कीवर्ड नियंत्रण पेलोड क्रेडेंशियल क्षेत्र में संवेदनशील जानकारी को नष्ट कर दिया जाना चाहिए। केवल false परीक्षण के दौरान निर्धारित किया जाना चाहिए ।

source

Original text