सही या बाएं शब्द वाले रूबियों, रेजेक्स वाले चयनकर्ताओं की व्यक्तिगत घोषणाएं प्राप्त करने के लिए एक सीएसएस फ़ाइल को पार्स करें

मुझे व्यक्तिगत पाने के लिए सीएसएस फ़ाइल को पार्स करने की आवश्यकता हैचयनकर्ता जिनके पास अपनी घोषणाओं (ब्लॉक) में दाएं या बाएं शब्द होते हैं। और एक ऐरे या हैश के लिए चयनकर्ताओं और उनके संबंधित घोषणाओं (ब्लॉक) को जोड़ें। उदाहरण के लिए:

.selector-one { /* This selector and its declaration will be added */
.
.
float: right;
.
.
}

#selector-two { /* This selector and its declaration will be added */
.
.
margin-left: 20%;
.
.
}

मैं स्कैन विधि का उपयोग करके इसे लिखने की कोशिश कर रहा हूं, इस तरह:

content.scan(/.*?{.*?(right|left).*?}/)

या

content.scan(/[^}]{[^}](right|left)[^}]}/)

लेकिन उनमें से गैर काम करते हैं।

मुझे इसका उल्लेख करना चाहिए:

  • इससे कोई फर्क नहीं पड़ता कि चयनकर्ता के नाम में बाएं या दाएं शब्द शामिल हैं, हमें बस ब्लॉकों की जांच करने की आवश्यकता है।

  • चयनकर्ताओं का नाम इसके अलावा किसी और चीज़ से शुरू हो सकता है { या }

  • चयनकर्ताओं को समूहीकृत किया जा सकता है, इसलिए हमारे पास ऐसा कुछ हो सकता है:

h1, h2, p {
text-align: right;
color: red;
}

उत्तर:

जवाब के लिए 0 № 1

मैं माणिक नहीं जानता, लेकिन रेगेक्स होना चाहिए:

[{]([^}]*(right|left)[^}]*)[}]

लालची, असंवेदनशील और वैश्विक झंडे के साथ


जवाब के लिए 0 № 2

आपके नमूने के आधार पर, और यदि वे "टी नेस्टेड" हैं।

 #  .(selector-[^{}]*?)s*{([^{}]*:[ ]*(?:right|left)[ ]*;[^{}]*)}

.
( selector- [^{}]*? )       # (1), Selector
s*
{
(                           # (2 start), Block
[^{}]*
: [ ]*
(?: right | left )
[ ]* ;
[^{}]*
)                           # (2 end)
}

आउटपुट:

 **  Grp 0 -  ( pos 0 , len 105 )
.selector-one { /* This block will be added to the array */
.
.
float: right;
.
.
}
**  Grp 1 -  ( pos 1 , len 12 )
selector-one
**  Grp 2 -  ( pos 15 , len 89 )
/* This block will be added to the array */
.
.
float: right;
.
.

----------------------

**  Grp 0 -  ( pos 196 , len 106 )
.selector-three { /* This block will be added to the array */
.
.
float: left;
.
.
}
**  Grp 1 -  ( pos 197 , len 14 )
selector-three
**  Grp 2 -  ( pos 213 , len 88 )
/* This block will be added to the array */
.
.
float: left;
.
.

जवाब के लिए 0 № 3

रूबी "एस slice_before इसके लिए आसान है:

blocks = DATA.each_line
.slice_before(/^./)
.map(&:join)
.select{ |block| block[/b(?:left|right)b/] }
blocks
# => [".selector-one { /* This block will be added to the array */n    .n    .nfloat: right;n    .n    .n}nn",
#     ".selector-three { /* This block will be added to the array */n    .n    .nfloat: left;n    .n    .n}n"]


__END__
.selector-one { /* This block will be added to the array */
.
.
float: right;
.
.
}

.selector-two { /* This block wont be added to the array */
.
.
.
}

.selector-three { /* This block will be added to the array */
.
.
float: left;
.
.
}
  • each_line फ़ाइल में लाइनों पर पुनरावृत्तियों।
  • slice_before परिणामी सरणी के माध्यम से दिखता है, और नियमित अभिव्यक्ति के समय उप-सरणियाँ बनाता है /^./ उस रेखा से मेल खाता है जो इसके साथ शुरू होती है .
  • map(&:join) प्रत्येक उप-सरणी की सामग्री को वापस पाठ स्ट्रिंग में परिवर्तित करता है।
  • select प्रत्येक स्ट्रिंग के अंदर दिखता है और यदि /b(?:left|right)b/ शब्द "बाएं" या "दाएं" से मेल खाता है, फिर स्ट्रिंग को पारित किया जाता है।

जैसे पैटर्न का उपयोग करना महत्वपूर्ण है /b(?:left|right)b/, क्योंकि खोजे जा रहे तार को "बचे हुए" या "उज्ज्वल" जैसे लंबे स्ट्रिंग में एम्बेड किया जा सकता है और आप "t" को एक गलत-सकारात्मक नहीं चाहते हैं।

आपने नहीं देखा होगा __END__ तथा DATA पहले, लेकिन वे इस तरह के परीक्षण कोड के लिए फिर से काम करते हैं। __END__ स्क्रिप्ट के अंत को चिह्नित करता है, और इसके बाद कुछ भी छद्म डेटा फ़ाइल के रूप में माना जा सकता है, जिसके माध्यम से सुलभ है DATA। इसलिए एक फ़ाइल से कोड को पढ़ने पर विचार करें।


जवाब के लिए 0 № 4

आप सीएसएस पार्सर का भी उपयोग कर सकते हैं क्रास और स्कैन करें पार्स पेड़

अब स्पिटबॉलिंग कोड ...

tree = Crass.parse(css)
nodes_with_right_or_left = tree.select do |node|
node[:children] and node[:children].detect do |child|
child[:value] == "right" or child[:value] == "left"
end
end

YMMV :-)


जवाब के लिए 0 № 5

मेरे प्रश्न का उत्तर देने के लिए सभी लोगों का धन्यवाद। दुर्भाग्य से उनमें से समस्या हल हो गई। यहाँ मैंने इसे कैसे लागू किया है:

input.scan(/[^{}]*{[^}]*?(?:WrightW|WleftW)[^}]*}/)

कुंजी यह थी कि स्कैन विधि में कोष्ठक एक कैप्चर समूह बनाते हैं। इसलिए हमें इसका उपयोग करते हुए इसे गैर-कैप्चरिंग समूह में बदलना होगा ?:


संबंधित सवाल
सबसे लोकप्रिय