YAML ઝેન માટે 10 પગલાં

આપણે બધા જવાબીબલને પ્રેમ કરીએ છીએ, પરંતુ જવાબી YAML છે. રૂપરેખાંકન ફાઇલો માટે ઘણા ફોર્મેટ્સ છે: મૂલ્યોની સૂચિ, પરિમાણ-મૂલ્ય જોડીઓ, INI ફાઇલો, YAML, JSON, XML અને અન્ય ઘણી. જો કે, તે બધામાંથી ઘણા કારણોસર, YAML ઘણીવાર ખાસ કરીને મુશ્કેલ માનવામાં આવે છે. ખાસ કરીને, વંશવેલો મૂલ્યો સાથે કામ કરવા માટે તેની તાજગીભરી લઘુત્તમતા અને પ્રભાવશાળી ક્ષમતાઓ હોવા છતાં, YAML વાક્યરચના તેના પાયથોન જેવા ઇન્ડેન્ટેશનના અભિગમથી હેરાન કરી શકે છે.

જો YAML તમને નારાજ કરે, તો તમે કરી શકો છો-અને તમારે કરવું જોઈએ! - તમારી નિરાશાને સ્વીકાર્ય સ્તર સુધી ઘટાડવા અને YAML સાથે પ્રેમમાં પડવા માટે નીચેના 10 પગલાં લો. આ સૂચિને અનુકૂળ હોવાથી, અમારી દસ ટીપ્સને શરૂઆતથી ક્રમાંકિત કરવામાં આવશે, અમે ધ્યાન અને આધ્યાત્મિક પ્રેક્ટિસને ઇચ્છાથી ઉમેરીશું 😉

0. તમારા સંપાદકને કાર્ય કરો

તમારી પાસે કયા ટેક્સ્ટ એડિટર છે તેનાથી કોઈ ફરક પડતો નથી, YAML સાથે કામ કરવા માટે કદાચ ઓછામાં ઓછું એક પ્લગઇન છે. જો તમારી પાસે નથી, તો તેને તરત જ શોધો અને ઇન્સ્ટોલ કરો. તમે YAML ને સંપાદિત કરવા માટે દરેક વખતે શોધવામાં અને સેટઅપ કરવામાં વિતાવેલો સમય ઘણી વખત ચૂકવશે.

ઉદાહરણ તરીકે, સંપાદક એટમ ડિફૉલ્ટ રૂપે YAML ને સપોર્ટ કરે છે, પરંતુ GNU Emacs માટે તમારે વધારાના પેકેજો ઇન્સ્ટોલ કરવા પડશે, ઉદાહરણ તરીકે, yaml-મોડ.

YAML મોડ અને ડિસ્પ્લે સ્પેસમાં Emacs.

જો તમારા મનપસંદ સંપાદક પાસે YAML મોડ નથી, તો સેટિંગ્સ સાથે કામ કરીને કેટલીક સમસ્યાઓ હલ કરી શકાય છે. ઉદાહરણ તરીકે, સ્ટાન્ડર્ડ જીનોમ ટેક્સ્ટ એડિટર Gedit પાસે YAML મોડ નથી, પરંતુ મૂળભૂત રીતે તે YAML સિન્ટેક્સને હાઇલાઇટ કરે છે અને તમને ઇન્ડેન્ટેશન સાથે કામને ગોઠવવા માટે પરવાનગી આપે છે:

Gedit માં ઇન્ડેન્ટ સેટ કરી રહ્યા છીએ.

એક પ્લગઇન ડ્રોસ્પેસ Gedit માટે, જગ્યાઓ બિંદુઓ તરીકે દર્શાવે છે, ઇન્ડેન્ટેશન સ્તરો સાથે અસ્પષ્ટતાને દૂર કરે છે.

બીજા શબ્દોમાં કહીએ તો, તમારા મનપસંદ સંપાદક વિશે શીખવામાં સમય પસાર કરો. YAML સાથે કામ કરવા માટે તે અથવા તેનો વિકાસ સમુદાય શું ઓફર કરે છે તે શોધો અને તે તકોનો ઉપયોગ કરો. તમે ચોક્કસપણે તેનો અફસોસ કરશો નહીં.

1. લિંટરનો ઉપયોગ કરો

આદર્શ રીતે, પ્રોગ્રામિંગ ભાષાઓ અને માર્કઅપ ભાષાઓ અનુમાનિત વાક્યરચનાનો ઉપયોગ કરે છે. કોમ્પ્યુટર અનુમાનિતતામાં સારા છે, તેથી જ ખ્યાલ આવે છે લિન્ટેરા. જો તેના અસ્તિત્વના 40 વર્ષોમાં તે તમારાથી પસાર થઈ ગયું છે અને તમે હજી પણ YAML લિંટરનો ઉપયોગ કરતા નથી, તો પછી યામલિન્ટને અજમાવવાનો સમય છે.

સ્થાપિત કરો યામલિન્ટ તમે પ્રમાણભૂત Linux પેકેજ મેનેજરનો ઉપયોગ કરી શકો છો. ઉદાહરણ તરીકે, માં Red Hat Enterprise Linux 8 અથવા Fedora તે આ જેમ કરવામાં આવે છે:

$ sudo dnf install yamllint

પછી તમે ખાલી yamllint ચલાવો, તેને તપાસવા માટે YAML ફાઇલ પસાર કરો. જો તમે લીંટરમાં ભૂલ સાથે ફાઇલ પસાર કરો છો તો તે આના જેવું દેખાય છે:

$ yamllint errorprone.yaml
errorprone.yaml
23:10     error    syntax error: mapping values are not allowed here
23:11     error    trailing spaces  (trailing-spaces)

ડાબી બાજુની સંખ્યાઓ સમય નથી, પરંતુ ભૂલના કોઓર્ડિનેટ્સ છે: પંક્તિ અને કૉલમ નંબર. ભૂલનું વર્ણન તમને કંઈપણ કહેશે નહીં, પરંતુ તમે બરાબર જાણો છો કે તે ક્યાં છે. કોડમાં ફક્ત આ સ્થાનને જુઓ, અને સંભવતઃ બધું સ્પષ્ટ થઈ જશે.

જ્યારે yamllint ને ફાઈલમાં કોઈ ભૂલો મળતી નથી, ત્યારે સ્ક્રીન પર કંઈપણ છાપવામાં આવતું નથી. જો આવી મૌન તમને ડરાવે છે અને તમને થોડો વધુ પ્રતિસાદ જોઈએ છે, તો પછી તમે ડબલ એમ્પરસેન્ડ (&&) દ્વારા કન્ડિશનલ ઇકો કમાન્ડ સાથે લિંટર ચલાવી શકો છો, જેમ કે:

$ yamllint perfect.yaml && echo "OK"
OK

POSIX માં, ડબલ એમ્પરસેન્ડ ફાયર થાય છે જો અને માત્ર જો પહેલાનો આદેશ 0 પરત કરે છે. અને yamllint માત્ર મળેલી ભૂલોની સંખ્યા પરત કરે છે, જેના કારણે આ સંપૂર્ણ શરતી રચના કાર્ય કરે છે.

2. Python માં લખો, YAML માં નહીં

જો YAML ખરેખર તમને ગુસ્સે કરે છે, તો ફક્ત તેમાં લખશો નહીં, શાબ્દિક રીતે. એવું બને છે કે YAML એ એકમાત્ર ફોર્મેટ છે જે એપ્લિકેશન સમજે છે. પરંતુ આ કિસ્સામાં પણ, YAML ફાઇલ બનાવવી જરૂરી નથી. તમને જે ગમે છે તેના પર લખો અને પછી કન્વર્ટ કરો. ઉદાહરણ તરીકે, પાયથોન માટે એક મહાન પુસ્તકાલય છે પ્યામલ અને બે રૂપાંતરણ પદ્ધતિઓ: સ્વ-રૂપાંતર અને સ્ક્રિપ્ટ્સ દ્વારા રૂપાંતર.

સ્વ-રૂપાંતર

આ કિસ્સામાં, ડેટા ફાઇલ એ પાયથોન સ્ક્રિપ્ટ પણ છે જે YAML જનરેટ કરે છે. આ પદ્ધતિ નાના ડેટા સેટ્સ માટે શ્રેષ્ઠ અનુરૂપ છે. તમે ફક્ત JSON ડેટાને પાયથોન વેરીએબલમાં લખો, તેને આયાત નિર્દેશ સાથે પ્રસ્તાવના આપો, અને આઉટપુટને અમલમાં મૂકવા માટે ફાઇલના અંતે ત્રણ લીટીઓ ઉમેરો.

#!/usr/bin/python3	
import yaml 

d={
"glossary": {
  "title": "example glossary",
  "GlossDiv": {
	"title": "S",
	"GlossList": {
	  "GlossEntry": {
		"ID": "SGML",
		"SortAs": "SGML",
		"GlossTerm": "Standard Generalized Markup Language",
		"Acronym": "SGML",
		"Abbrev": "ISO 8879:1986",
		"GlossDef": {
		  "para": "A meta-markup language, used to create markup languages such as DocBook.",
		  "GlossSeeAlso": ["GML", "XML"]
		  },
		"GlossSee": "markup"
		}
	  }
	}
  }
}

f=open('output.yaml','w')
f.write(yaml.dump(d))
f.close

હવે આપણે આ ફાઇલને Python માં ચલાવીએ છીએ અને output.yaml ફાઇલ મેળવીએ છીએ:

$ python3 ./example.json
$ cat output.yaml
glossary:
  GlossDiv:
	GlossList:
	  GlossEntry:
		Abbrev: ISO 8879:1986
		Acronym: SGML
		GlossDef:
		  GlossSeeAlso: [GML, XML]
		  para: A meta-markup language, used to create markup languages such as DocBook.
		GlossSee: markup
		GlossTerm: Standard Generalized Markup Language
		ID: SGML
		SortAs: SGML
	title: S
  title: example glossary

આ સંપૂર્ણ રીતે માન્ય YAML છે, પરંતુ yamllint તમને ચેતવણી આપશે કે તે - થી શરૂ થતું નથી. ઠીક છે, આને સરળતાથી જાતે સુધારી શકાય છે અથવા પાયથોન સ્ક્રિપ્ટમાં થોડો ફેરફાર કરી શકાય છે.

સ્ક્રિપ્ટો દ્વારા રૂપાંતરણ

આ કિસ્સામાં, અમે પ્રથમ JSON માં લખીએ છીએ, અને પછી કન્વર્ટરને અલગ પાયથોન સ્ક્રિપ્ટ તરીકે ચલાવીએ છીએ, જે YAML ને આઉટપુટ તરીકે ઉત્પન્ન કરે છે. અગાઉની પદ્ધતિની તુલનામાં, આ પદ્ધતિ વધુ સારી રીતે માપવામાં આવે છે, કારણ કે રૂપાંતરણ ડેટાથી અલગ છે.

પ્રથમ, ચાલો JSON ફાઈલ example.json બનાવીએ, ઉદાહરણ તરીકે, તમે તેમાંથી લઈ શકો છો json.org:

{
	"glossary": {
	  "title": "example glossary",
	  "GlossDiv": {
		"title": "S",
		"GlossList": {
		  "GlossEntry": {
			"ID": "SGML",
			"SortAs": "SGML",
			"GlossTerm": "Standard Generalized Markup Language",
			"Acronym": "SGML",
			"Abbrev": "ISO 8879:1986",
			"GlossDef": {
			  "para": "A meta-markup language, used to create markup languages such as DocBook.",
			  "GlossSeeAlso": ["GML", "XML"]
			  },
			"GlossSee": "markup"
			}
		  }
		}
	  }
	}

પછી આપણે એક સરળ કન્વર્ટર સ્ક્રિપ્ટ બનાવીશું અને તેને json2yaml.py નામ હેઠળ સાચવીશું. આ સ્ક્રિપ્ટ બંને YAML અને JSON Python મોડ્યુલોને આયાત કરે છે, અને વપરાશકર્તા-નિર્દિષ્ટ JSON ફાઇલ લોડ કરે છે, રૂપાંતરણ કરે છે અને output.yaml ફાઇલમાં ડેટા લખે છે.

#!/usr/bin/python3
import yaml
import sys
import json

OUT=open('output.yaml','w')
IN=open(sys.argv[1], 'r')

JSON = json.load(IN)
IN.close()
yaml.dump(JSON, OUT)
OUT.close()

આ સ્ક્રિપ્ટને સિસ્ટમ પાથમાં સાચવો અને તેને જરૂર મુજબ ચલાવો:

$ ~/bin/json2yaml.py example.json

3. ઘણું અને વારંવાર પાર્સ કરો

કેટલીકવાર સમસ્યાને અલગ ખૂણાથી જોવાનું ઉપયોગી છે. જો તમને YAML માં તમારા ડેટા વચ્ચેના સંબંધોનું પ્રતિનિધિત્વ કરવામાં મુશ્કેલી આવી રહી હોય, તો તમે તેને અસ્થાયી રૂપે કંઈક વધુ પરિચિતમાં પરિવર્તિત કરી શકો છો.

ઉદાહરણ તરીકે, જો તમે શબ્દકોશ યાદીઓ અથવા JSON સાથે કામ કરવા માટે આરામદાયક છો, તો તમે ઇન્ટરેક્ટિવ પાયથોન શેલમાં ફક્ત બે આદેશો સાથે YAML ને JSON માં કન્વર્ટ કરી શકો છો. ચાલો કહીએ કે તમારી પાસે YAML ફાઇલ mydata.yaml છે, તો તે આના જેવું દેખાશે:

$ python3
>>> f=open('mydata.yaml','r')
>>> yaml.load(f)
{'document': 34843, 'date': datetime.date(2019, 5, 23), 'bill-to': {'given': 'Seth', 'family': 'Kenlon', 'address': {'street': '51b Mornington Roadn', 'city': 'Brooklyn', 'state': 'Wellington', 'postal': 6021, 'country': 'NZ'}}, 'words': 938, 'comments': 'Good article. Could be better.'}

તમે આ વિષય પર અન્ય ઘણા ઉદાહરણો શોધી શકો છો. વધુમાં, ત્યાં ઘણા ઑનલાઇન કન્વર્ટર અને સ્થાનિક પાર્સર્સ ઉપલબ્ધ છે. તેથી જ્યારે તમને તેમાં માત્ર એક અગમ્ય ગૂંચવાડો દેખાય ત્યારે ડેટાને ફરીથી ફોર્મેટ કરવામાં અચકાશો નહીં.

4. સ્પેક્સ વાંચો

લાંબા વિરામ પછી YAML પર પાછા ફરવું, તે મુલાકાત લેવા માટે ઉપયોગી છે yaml.org અને સ્પષ્ટીકરણો (સ્પેક્સ) ફરીથી વાંચો. જો તમને YAML સાથે મુશ્કેલીઓ છે, પરંતુ તમે સ્પષ્ટીકરણની આસપાસ મેળવ્યું નથી, તો આ પરિસ્થિતિને સુધારવાનો સમય છે. સ્પેક્સ લખવા માટે આશ્ચર્યજનક રીતે સરળ છે, અને વાક્યરચના આવશ્યકતાઓ મોટી સંખ્યામાં ઉદાહરણો સાથે સચિત્ર છે પ્રકરણ 6.

5. સ્યુડો-રૂપરેખાઓ

પુસ્તક અથવા લેખ લખતી વખતે, ઓછામાં ઓછા વિષયવસ્તુના કોષ્ટકના રૂપમાં, પ્રથમ પ્રારંભિક રૂપરેખાનું સ્કેચ કરવું હંમેશા ઉપયોગી છે. તે YAML સાથે સમાન છે. મોટે ભાગે, તમને YAML ફાઇલમાં કયા ડેટાને લખવાની જરૂર છે તેનો ખ્યાલ છે, પરંતુ તમે તેને એકબીજા સાથે કેવી રીતે કનેક્ટ કરવું તે ખરેખર સમજી શકતા નથી. તેથી, YAML ને શિલ્પ કરતા પહેલા, સ્યુડો-કોન્ફિગરે દોરો.

સ્યુડો-કોન્ફિગ સ્યુડો-કોડ જેવું જ છે, જ્યાં તમારે બંધારણ અથવા ઇન્ડેન્ટેશન, માતાપિતા-બાળક સંબંધો, વારસો અને માળખા વિશે ચિંતા કરવાની જરૂર નથી. તે અહીં સમાન છે: તમે ડેટાના પુનરાવૃત્તિઓ દોરો છો કારણ કે તે તમારા માથામાં ઉદ્ભવે છે.

સ્યુડો-કોન્ફિગ લિસ્ટિંગ પ્રોગ્રામર્સ (માર્ટિન અને તાબિથા) અને તેમની કુશળતા (પ્રોગ્રામિંગ ભાષાઓ: પાયથોન, પર્લ, પાસ્કલ અને લિસ્પ, ફોર્ટ્રેન, એર્લાંગ, અનુક્રમે).

કાગળના ટુકડા પર સ્યુડો-રૂપરેખા દોર્યા પછી, તેનું કાળજીપૂર્વક વિશ્લેષણ કરો અને, જો બધું વ્યવસ્થિત હોય, તો તેને માન્ય YAML ફાઇલના રૂપમાં ફોર્મેટ કરો.

6. ટૅબ્સ વિ. સ્પેસ દ્વિધા

તમારે મૂંઝવણનો ઉકેલ લાવવો પડશે "ટેબ્સ કે સ્પેસ?". વૈશ્વિક અર્થમાં નહીં, પરંતુ ફક્ત તમારી સંસ્થાના સ્તરે અથવા ઓછામાં ઓછા એક પ્રોજેક્ટ પર. sed સ્ક્રિપ્ટ સાથે પોસ્ટ-પ્રોસેસિંગનો ઉપયોગ કરવામાં આવે છે, પ્રોગ્રામરોના મશીનો પર ટેક્સ્ટ એડિટર્સ સેટ કરવા અથવા બરતરફીની ધમકી હેઠળ લિન્ટરની સૂચનાઓનું સખત પાલન કરવાની રસીદો લેવાથી કોઈ ફરક પડતો નથી, પરંતુ તમારી ટીમના તમામ સભ્યો જેઓ એક YAML સાથે સંબંધિત રીતે અથવા અન્ય રીતે માત્ર જગ્યાઓનો ઉપયોગ કરવો જોઈએ (YAML સ્પષ્ટીકરણ દ્વારા જરૂરી છે).

કોઈપણ સામાન્ય ટેક્સ્ટ એડિટરમાં, તમે ચોક્કસ સંખ્યામાં જગ્યાઓ પર સ્વતઃ-સાચો ટેબ્સને ગોઠવી શકો છો, જેથી મુખ્ય અનુયાયીઓનો બળવો ટૅબ તમારે ડરવાની જરૂર નથી.

જેમ કે દરેક YAML નફરત કરનાર સારી રીતે જાણે છે, તમે સ્ક્રીન પર ટૅબ અને સ્પેસ વચ્ચેનો તફાવત જોઈ શકતા નથી. અને જ્યારે કોઈ વસ્તુ દેખાતી નથી, ત્યારે તે સામાન્ય રીતે છેલ્લી વસ્તુ છે જે લોકો યાદ રાખે છે, તેઓ અન્ય તમામ સંભવિત સમસ્યાઓને ઉકેલ્યા, તપાસ્યા અને દૂર કર્યા પછી. ટેબ્યુલેશન કર્વ અથવા સ્પેસના બ્લોકની શોધમાં વિતાવેલો એક કલાક ફક્ત ચીસો પાડે છે કે તમારે એક અથવા બીજાના ઉપયોગ માટે તાકીદે નીતિ બનાવવાની જરૂર છે, અને પછી તેના પાલન માટે પ્રબલિત કોંક્રિટ ચેકનો અમલ કરો (ઉદાહરણ તરીકે, દ્વારા લીંટર દ્વારા તેને દબાણ કરવા માટે ગિટ હૂક).

7. ઓછું તે વધુ (અથવા વધુ ઓછું)

કેટલાક લોકો YAML માં લખવાનું પસંદ કરે છે કારણ કે તે બંધારણ પર ભાર મૂકે છે. તે જ સમયે, તેઓ ડેટાના બ્લોક્સને પ્રકાશિત કરવા માટે સક્રિયપણે ઇન્ડેન્ટેશનનો ઉપયોગ કરે છે. સ્પષ્ટ સીમાંકકોનો ઉપયોગ કરતી માર્કઅપ ભાષાઓનું અનુકરણ કરવા માટે આ એક પ્રકારનું કૌભાંડ છે.

અહીંથી આવી રચનાનું ઉદાહરણ છે જવાબી દસ્તાવેજીકરણ:

# Employee records
-  martin:
        name: Martin D'vloper
        job: Developer
        skills:
            - python
            - perl
            - pascal
-  tabitha:
        name: Tabitha Bitumen
        job: Developer
        skills:
            - lisp
            - fortran
            - erlang

કેટલાક માટે, આ વિકલ્પ તેમને તેમના માથામાં YAML માળખું ગોઠવવામાં મદદ કરે છે; અન્ય લોકો માટે, તેનાથી વિપરીત, તે તેમને ઘણી બધી બિનજરૂરી, તેમના મતે, ઇન્ડેન્ટ્સથી બળતરા કરે છે.

પરંતુ જો તમે YAML દસ્તાવેજના માલિક છો અને તેની જાળવણી માટે જવાબદાર છો, તો પછી તમે અને માત્ર તમે ઇન્ડેન્ટેશનનો ઉપયોગ કેવી રીતે કરવો તે વ્યાખ્યાયિત કરવું આવશ્યક છે. જો તમે મોટા પેડિંગથી નારાજ છો, તો YAML સ્પષ્ટીકરણ અનુસાર તેને શક્ય તેટલું ન્યૂનતમ રાખો. ઉદાહરણ તરીકે, જવાબી દસ્તાવેજોમાંથી ઉપરોક્ત ફાઇલને કોઈપણ નુકશાન વિના આ રીતે ફરીથી લખી શકાય છે:

---
- martin:
   name: Martin D'vloper
   job: Developer
   skills:
   - python
   - perl
   - pascal
- tabitha:
   name: Tabitha Bitumen
   job: Developer
   skills:
   - lisp
   - fortran
   - erlang

8. ખાલી જગ્યાઓનો ઉપયોગ કરો

જો તમે YAML ફાઇલ ભરતી વખતે એ જ ભૂલોનું સતત પુનરાવર્તન કરો છો, તો ટિપ્પણી તરીકે તેમાં ટેમ્પલેટ દાખલ કરવાનો અર્થ છે. પછી આગલી વખતે તમે ખાલી આ નમૂનાની નકલ કરી શકો છો અને ત્યાં વાસ્તવિક ડેટા દાખલ કરી શકો છો, ઉદાહરણ તરીકે:

---
# - <common name>:
#   name: Given Surname
#   job: JOB
#   skills:
#   - LANG
- martin:
  name: Martin D'vloper
  job: Developer
  skills:
  - python
  - perl
  - pascal
- tabitha:
  name: Tabitha Bitumen
  job: Developer
  skills:
  - lisp
  - fortran
  - erlang

9. કંઈક અલગ વાપરો

જો ઍપ્લિકેશન તમારા પર કોઈ ગૂંચવણ ધરાવતું નથી, તો તે YAML ને અલગ ફોર્મેટમાં બદલવા યોગ્ય હોઈ શકે છે. સમય જતાં, રૂપરેખાંકન ફાઇલો પોતાને આગળ વધારી શકે છે અને પછી તેને લુઆ અથવા પાયથોનમાં સરળ સ્ક્રિપ્ટમાં રૂપાંતરિત કરવું વધુ સારું છે.

YAML એ એક મહાન વસ્તુ છે જે ઘણા લોકો તેના લઘુત્તમવાદ અને સરળતા માટે પસંદ કરે છે, પરંતુ તે તમારા શસ્ત્રાગારના એકમાત્ર સાધનથી દૂર છે. તેથી ક્યારેક તમે તેને ના પાડી શકો છો. YAML માટે પાર્સિંગ લાઇબ્રેરીઓ શોધવાનું સરળ છે, તેથી જો તમે સરળ સ્થળાંતર વિકલ્પો પ્રદાન કરો છો, તો તમારા વપરાશકર્તાઓ પ્રમાણમાં પીડારહિત રીતે આ નિષ્ફળતામાંથી બચી જશે.

જો તમે YAML વિના કરી શકતા નથી, તો આ 10 ટિપ્સ લો અને YAML ના તમારા અણગમાને એકવાર અને બધા માટે દૂર કરો!

સોર્સ: www.habr.com