మూడవ పార్టీ ప్యాకేజీలను ఉపయోగించడం ప్రాజెక్ట్ అభివృద్ధిని వేగవంతం చేస్తుంది. కొన్నిసార్లు, మీరు అదనపు లక్షణాలను జోడించాల్సి ఉంటుంది లేదా క్లిష్టమైన బగ్‌ను పరిష్కరించాల్సి ఉంటుంది. కంపోజర్ ఇన్‌స్టాల్ చేసిన PHP ప్యాకేజీలను ఎలా ప్యాచ్ చేయాలో ఇక్కడ ఉంది.

ప్యాకేజీని ఎప్పుడు పాచ్ చేయాలి

మొదట ప్రాజెక్ట్‌లో ప్యాచ్‌ను సృష్టించడం సముచితమో కాదో పరిశీలించండి. ఒక పాచ్ ఎల్లప్పుడూ చిన్న మార్పుగా ఉండాలి. మీరు క్రొత్త పొడిగించిన లక్షణాలను జోడించాల్సిన అవసరం ఉంటే, మీరు ప్యాకేజీపై సమస్యను తెరవాలి లేదా మీరే ఫోర్క్ చేయాలి. ప్యాకేజీ అభివృద్ధి చెందుతున్నప్పుడు ఇది విభేదాలను నివారించడానికి సహాయపడుతుంది.

మీకు అవసరమైన మార్పు మీ ప్రాజెక్ట్‌కు నిజంగా నిర్దిష్టంగా ఉందా అనే దాని గురించి మీరు జాగ్రత్తగా ఆలోచించాలి. డిపెండెన్సీ పాచెస్ సాధారణంగా కోడ్ యొక్క కొన్ని పంక్తులను మాత్రమే ప్రభావితం చేస్తాయి. వారు దోషాలను మరియు సమస్యలను పరిష్కరిస్తారు, అది మిమ్మల్ని ప్యాకేజీని ఉపయోగించకుండా నిరోధిస్తుంది. చాలా పాచెస్ స్వభావం తక్కువగా ఉంటాయి. ప్యాకేజీ బేస్ కోడ్‌లోని మూలం వద్ద దిద్దుబాట్ల ద్వారా వాటిని తరువాత మార్చాలి.

అంతిమంగా, మీరు మీ ఉద్దేశాలను కొలవాలి. మీరు ప్యాకేజీతో తక్షణ సమస్యను పరిష్కరిస్తున్నారా లేదా మీ కోడ్ బేస్ తో సమలేఖనం చేయడానికి ప్యాకేజీ యొక్క కార్యాచరణను విస్తరిస్తున్నారా? తరువాతి సందర్భంలో, మీరు ప్యాకేజీకి తోడ్పడటం లేదా మీ ప్రాజెక్ట్‌లో ఫస్ట్-క్లాస్ పౌరులుగా ఉన్న అదనపు తరగతులు మరియు లక్షణాలతో సహా పరిగణించాలి.

కంపోజర్ ప్యాచ్ సృష్టిస్తోంది

ప్యాచ్ కాల్ చేసిన తర్వాత, మీరు మీ ప్రాజెక్ట్‌ను సిద్ధం చేయడం ప్రారంభించవచ్చు. స్వరకర్తకు అంతర్నిర్మిత ప్యాచ్ మద్దతు లేదు, కాబట్టి మేము జనాదరణను ఉపయోగిస్తాము simplify/vendor-patches జోడించడానికి ప్రాజెక్ట్. ఇది ఒక స్పష్టమైన ఇంటర్ఫేస్ను అందిస్తుంది cweagans/composer-patches క్రొత్త పాచెస్ సృష్టించడానికి మీకు సహాయపడటానికి.

composer require --dev symplify/vendor-patches

ప్యాచ్ కోసం మీకు అవసరమైన ప్యాకేజీ మీ ప్రాజెక్ట్‌లో ఇన్‌స్టాల్ చేయబడిందని నిర్ధారించుకోండి:

composer require example/broken-package

అప్పుడు, కోడ్ ఎడిటర్‌లో సమస్య ఫైల్‌ను తెరవండి. మీరు దానిని ఫైల్ లోపల కనుగొంటారు vendor డైరెక్టరీ. మా ఉదాహరణలో, మేము సవరించాలి vendor/example/broken-package/src/Broken.php:

<?php
 
class Broken {
    public function __construct(string|int $foo) {
        if (is_string($foo)) {
            echo "Valid value!";
        }
    }
}
 
?>

ది Broken తరగతి PHP 8 విలీన రకాలను ఉపయోగించి తీగలను మరియు పూర్ణాంకాలను రెండింటినీ అంగీకరించాలి. దురదృష్టవశాత్తు, మూలాన్ని చూస్తే అది వాస్తవానికి తీగలను మాత్రమే అంగీకరిస్తుందని చూపిస్తుంది.

మా కల్పిత ఉదాహరణలో, ప్యాకేజీ నిర్వహణ సమస్యను గుర్తించింది కాని ఇంకా క్రొత్త సంస్కరణను సృష్టించలేదు. ఈలోగా, సమస్యను పరిష్కరిద్దాం.

దెబ్బతిన్న, మార్పులేని ఫైల్‌ను కాపీ చేసి, ఫైల్‌ను జోడించండి .old ప్రత్యయం:

cp vendor/example/broken-project/src/Broken.php vendor/example/broken-project/src/Broken.php.old

మీరు ఫైల్‌ను సవరించలేదని నిర్ధారించుకోండి .old ఫైల్!

అప్పుడు, ఫైల్ను సవరించండి అసలైనది ఫైల్ కాబట్టి ఇది మీ కోడ్ బేస్ లో సరిగ్గా పనిచేస్తుంది. స్థలంలో సవరణ సమయంలో, మార్పులు వెంటనే అమలులోకి వస్తాయి. మీ కోడ్ బేస్ ఇప్పుడు .హించిన విధంగా ప్రవర్తిస్తుందని ధృవీకరించండి.

<?php
 
class Broken {
    public function __construct(string|int $foo) {
        if (is_string($foo)) {
            echo "Valid value!";
        }
        else if (is_int($foo)) {
            echo "Also valid!";
        }
    }
}
 
?>

ప్యాచ్ ఫైల్ను సృష్టిస్తోంది

ఇప్పుడు మీరు ఫైల్ను ఉపయోగించవచ్చు symplify/vendor-patches పరిష్కారానికి ప్యాచ్ ఫైల్‌ను సృష్టించే ప్రాజెక్ట్. ప్యాకేజీ ఒక ఫైల్ను అందిస్తుంది vendor-patches మీ ఫైల్‌ను స్వయంచాలకంగా స్కాన్ చేసే బైనరీ vendor చేసిన మార్పులను కనుగొనడానికి డైరెక్టరీ.

vendor/bin/vendor-patches generate

ఆదేశాన్ని అమలు చేయడం మీ కోసం తేడాను సృష్టిస్తుంది. ఇది సేవ్ చేయబడుతుంది patches మీ ప్రాజెక్ట్ యొక్క మూలంలో డైరెక్టరీ. ఫైల్‌ను పోల్చడం ద్వారా తేడా లెక్కించబడుతుంది .php ఉంది .php.old మీరు సృష్టించిన ఫైల్.

ఏదైనా కొత్త పాచెస్ జోడించబడిందో తెలుసుకోవడానికి మీరు ఆదేశాన్ని తిరిగి విడుదల చేయవచ్చు. ప్రతి సవరించిన ఫైల్ ఫైల్‌లో దాని స్వంత ప్యాచ్‌ను పొందుతుంది patches డైరెక్టరీ.

ఆటోమేటిక్ పాచింగ్

మీ లోపల composer.json ఫైల్, క్రొత్త విభాగం జోడించబడిందని మీరు చూస్తారు:

{
    "extra": {
        "patches": {
            "example/broken-package": [
                "patches/example-broken-package-src-broken-php.patch"
            ]
        }
    }
}

ది patches ఆబ్జెక్ట్ మ్యాప్స్ ప్యాకేజీ పేర్లను ప్యాచ్ ఫైళ్ళ శ్రేణికి ఇన్‌స్టాల్ చేసింది. మీరు దీన్ని చేసిన ప్రతిసారీ ఈ పాచెస్ స్వయంచాలకంగా వర్తించబడతాయి composer install.

ఇన్‌స్టాలేషన్ స్క్రిప్ట్ ద్వారా నమోదు చేయబడింది simplify/vendor-patches. ప్రతి డిపెండెన్సీ యొక్క సంస్థాపన తర్వాత ఇది ప్రారంభించబడుతుంది. ప్యాకేజీ కోసం ఏదైనా పాచెస్ నిర్వచించబడిందా అని స్క్రిప్ట్ తనిఖీ చేస్తుంది. అది కనుగొన్నదంతా స్వయంచాలకంగా వర్తిస్తుంది.

మీరు ఫైల్‌లోని పంక్తులను చూస్తారు composer install పాచెస్ వర్తించినప్పుడు అవుట్పుట్ సూచిస్తుంది. లోపం నివేదించబడితే, మీరు ఉపయోగించవచ్చు composer install --verbose ప్యాచ్ ఎందుకు తొలగించబడిందనే దానిపై మరింత సమాచారం పొందడానికి. ఇది తరచుగా మీరు పరిష్కరించిన సమస్యను పరిష్కరించే ప్యాకేజీ నవీకరణ వల్ల మీ ప్యాచ్ ఫైల్ పునరావృతమవుతుంది.

పాచ్ తొలగింపు

పాచ్ నుండి దాని పంక్తిని తొలగించడం ద్వారా మీరు తాత్కాలికంగా తొలగించవచ్చు composer.json. మీరు ఉన్నప్పుడు ప్యాచ్‌ను వర్తింపచేయడం ఇది ఆగిపోతుంది composer install.

మీ ప్రాజెక్ట్ నుండి పాచ్‌ను శాశ్వతంగా తొలగించడానికి, దాన్ని తీసివేయండి composer.json లైన్. అప్పుడు మీరు ఫైల్‌ను తీసివేయవచ్చు .patch మీ ప్రాజెక్ట్ నుండి ఫైళ్ళు patches డైరెక్టరీ.

మీరు స్థానికంగా వర్తింపజేసిన ప్యాచ్‌ను తిరిగి వెళ్లాలనుకుంటే, ప్యాచ్‌ను తొలగించడానికి లేదా నిలిపివేయడానికి పై దశలను అనుసరించడం సులభం. అప్పుడు మీరు ఫైల్ నుండి ప్యాకేజీని తీసివేయవచ్చు vendor డైరెక్టరీ మరియు రన్ composer install శుభ్రమైన స్లేట్‌కు తిరిగి రావడానికి.