talius 0.5

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: c923ee36c973d0f95514ccd29ed7d6b5181e55614c376817ff2c7cdbe4ac8291
+  data.tar.gz: 82037c3e6161cec2b6b7999542c0a112b1ac6de9f2329833de9dbdd3323da6d6
+SHA512:
+  metadata.gz: ea1038d7afd52feff046aab805f225cc72cc05f1a17912b483986ce29c80fb2bab171953837783827ecc32efe890af9d723278100996b2f65f4185f809ceaac2
+  data.tar.gz: ec31c961daf6e5d2f80e456b903fadf2130749fd672e34cf41594fac16c3664b4f28749331d3c2e3917ca9ada5ad86877a8e6565e98831e48838946313398d1c

data/README.md

@@ -0,0 +1,177 @@
+# Talius
+
+Talius is a parser for CSS selectors. It does not parse CSS, just CSS
+selectors.
+
+`Talius.new` accepts a single string as the selector. The `Talius`
+object provides an interface with which to access the properties of that
+selector.
+
+In this example, the selector consists of just `a`, meaning it selects
+`<a>` tags:
+
+<table>
+<tr>
+<td class='right'>
+<pre>1
+2
+3
+4
+</pre>
+</td>
+<td>
+<pre>
+raw = 'a'
+selector = Talius.new(raw)
+rule = selector.rules[0]
+rule.tags # => {"a"=>{"name"=>"a"}}
+</pre>
+</td>
+</tr>
+</table>
+
+Line 1 creates the raw CSS selector like you might find in a CSS file. Line 2
+creates a `Talius` object.
+
+Each Talius has one or more rules. In this example the object will have one
+rule. Line 3 gets that rule. Each rule has a hash of tag names in the `tags`
+property. Line 4 displays that hash. See below for more about the `tags` hash.
+
+The following sections will describe how Talius provides information about
+different elements of a selector. Talius is in its infancy, so there are
+some important aspects of CSS selectors that it doesn't support. Those aspects
+are detailed below.
+
+## Tags
+
+If a selector contains a tag name, that information will be put into the
+`tags` hash of the rule. Consider this example.
+
+```ruby
+raw = 'a'
+selector = Talius.new(raw)
+rule = selector.rules[0]
+rule.tags # => {"a"=>{"name"=>"a"}}
+rule.tags['a'].class     # => Talius::Node::Tag
+rule.tags['a'].name      # => "a"
+rule.tags['a'].namespace # => nil
+```
+
+That selector consists of just a single tag name, so the `selector` object has
+just one rule. That rule has a property called `tags`, which is a hash of the
+tags in the rule. The key for each hash element is the name of the tag. The
+value of the element is a `Talius::Node::Tag` object. That object has two
+properties, `name` and `namespace`.
+
+To indicate the namespace for the tag, put the namespace, followed by `|`,
+followed by the name of the tag. For example, the following code has a selector
+for tags in the `mml` namespace with the name `a`. The keys in the `tags` hash
+are formatted in the same way.
+
+```ruby
+raw = 'mml|a'
+selector = Talius.new(raw)
+rule = selector.rules[0]
+rule.tags # => {"mml|a"=>{"name"=>"a", "namespace"=>"mml"}}
+rule.tags['mml|a'].class     # => Talius::Node::Tag
+rule.tags['mml|a'].name      # => "a"
+rule.tags['mml|a'].namespace # => "mml"
+```
+
+## Multiple rules
+
+For multiple rules for a selector, separate the rules with a comma. For example,
+the following code parses a selector with two rules, one for the `section` tag
+and one for the `div` tag.
+
+```ruby
+raw = 'section, div'
+selector = Talius.new(raw)
+selector.rules.length # => 2
+selector.rules # => [{"tags"=>{"section"=>{"name"=>"section"}}}, {"tags"=>{"div"=>{"name"=>"div"}}}]
+```
+
+## IDs
+
+If any ID descriptions are given, those IDs can be found in the rule's `ids`
+hash. The keys are the names of the IDs, the values are always `true`.
+
+```ruby
+raw = '#overview'
+selector = Talius.new(raw)
+rule = selector.rules[0]
+rule.ids # => {"overview"=>true}
+```
+
+## Classes
+
+Classes are available in the `classes` property of the rule. `classes` is a
+simple hash in which the value of each class is true.
+
+```ruby
+raw = 'section.overview.current'
+selector = Talius.new(raw)
+rule = selector.rules[0]
+rule.classes # => {"overview"=>true, "current"=>true}
+```
+
+## Attributes
+
+Attribute rules are provided in the rule's `atts` hash. The hash consists of the
+key of each attribute and a `Talius::Node::Att` object.
+
+In this simple example, the selector looks for tags with an `rel` attribute.
+
+```ruby
+raw = '[rel]'
+selector = Talius.new(raw)
+rule = selector.rules[0]
+att = rule.atts['rel']
+att.class # => Talius::Node::Att
+att.name  # => rel
+```
+
+If you assign a value to the attribute, that value will be in `value` property.
+
+```ruby
+raw = '[rel=license]'
+selector = Talius.new(raw)
+rule = selector.rules[0]
+att = rule.atts['rel']
+att.name  # => href
+att.value # => license
+```
+
+Attribute namespaces are indicated in the same way as with tags. You can access
+the namespace with the `namespace` property.
+
+```ruby
+raw = '[mml|rel]'
+selector = Talius.new(raw)
+rule = selector.rules[0]
+att = rule.atts['mml|rel']
+att.name      # => rel
+att.namespace # => mml
+```
+
+## Install
+
+``
+gem install talius
+``
+
+## Author
+
+Mike O'Sullivan
+mike@idocs.com
+
+## Name
+
+"Talius" doesn't mean anything in particular. It just sounded like a good name
+and it was available on rubygems.rb.
+
+## History
+
+| version | date         | notes                         |
+|---------|--------------|-------------------------------|
+| 0.5     | May 29, 2020 | Initial upload.               |

data/lib/talius.rb

@@ -0,0 +1,736 @@
+require 'lx'
+
+#===============================================================================
+# Talius
+#
+
+# A +Talius+ object represents a full CSS selector.
+class Talius
+	# version '0.5'
+	VERSION = '0.5'
+	
+	
+	# An array of rule objects.
+	attr_reader :rules
+	
+	#---------------------------------------------------------------------------
+	# initialize
+	#
+	
+	# Initialize a new Talius object. Takes a raw CSS selector string as the
+	# single param.
+	#
+	#  raw = 'a[href]'
+	#  selector = Talius.new(raw)
+	def initialize(p_raw)
+		@raw = p_raw
+		@rules = []
+		@slashes = {}
+		@quotes = {}
+		@norm = nil
+		
+		# normalize selector string
+		unslash()
+		unquote()
+		@norm.lx.collapse!
+		
+		# split into rules
+		@norm.split(/\s*,\s*/mu).each do |rule_str|
+			@rules.push Talius::Rule.new(self, rule_str)
+		end
+	end
+	#
+	# initialize
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# raw
+	#
+	
+	# The original string used to the create the selector object.
+	#
+	#  raw = 'a[href]'
+	#  selector = Talius.new(raw)
+	#  selector.raw # => "a[href]"
+	attr_reader :raw
+	
+	#
+	# raw
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# denormalize
+	#
+	
+	# Used by Talius::Rule to rebuild a string that has placeholders in it. This
+	# method is not useful for any purpose beyond that.
+	def denormalize(raw)
+		return reslash(requote(raw))
+	end
+	#
+	# denormalize
+	#---------------------------------------------------------------------------
+	
+	
+	# private
+	private
+	
+	
+	#---------------------------------------------------------------------------
+	# requote
+	#
+	def requote(raw)
+		return @quotes[raw] || raw
+	end
+	#
+	# requote
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# reslash
+	#
+	def reslash(rv)
+		# $tm.hrm
+		
+		# loop through slashed strings
+		@slashes.each do |pattern, val|
+			rv = rv.sub(/#{pattern}/mu, val)
+		end
+		
+		# return
+		return rv
+	end
+	#
+	# reslash
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# unquote
+	#
+	def unquote()
+		rv = []
+		
+		# split into slashed and unslashed strings
+		@norm.split(/("[^"]*")/mu).each do |token|
+			if token.match(/\A".*"\z/mu)
+				content = token
+				content = content.sub(/\A"/mu, '')
+				content = content.sub(/"\z/mu, '')
+				ph = LX.randstr()
+				@quotes[ph] = content
+				rv.push ph
+			else
+				rv.push token
+			end
+		end
+		
+		# return new string
+		@norm = rv.join('')
+	end
+	#
+	# unquote
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# unslash
+	#
+	def unslash()
+		rv = []
+		
+		# split into slashed and unslashed strings
+		@raw.split(/(\\.)/mu).each do |token|
+			if token.match(/\A\\.\z/mu)
+				ph = LX.randstr()
+				@slashes[ph] = token[1]
+				rv.push ph
+			else
+				rv.push token
+			end
+		end
+		
+		# return new string
+		@norm = rv.join('')
+	end
+	#
+	# unslash
+	#---------------------------------------------------------------------------
+end
+#
+# Talius
+#===============================================================================
+
+
+#===============================================================================
+# Talius::Rule
+#
+
+# Talius::Rule object represents one set of directives, e.g. tags, classes, etc.
+class Talius::Rule
+	#---------------------------------------------------------------------------
+	# special characters
+	#
+	@@NESTING_CHARS = %w{> + ~ s}
+	@@NESTING_RX = @@NESTING_CHARS.map{|el| '\\' + el}.join('')
+	@@SUBRULE_CHARS = %w{. [ ] : #}
+	@@SUBRULE_RX = @@SUBRULE_CHARS.map{|el| '\\' + el}.join('')
+	@@META_RX = @@NESTING_RX + @@SUBRULE_RX
+	#
+	# special characters
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# initialize
+	# Lexical parsing experts will probably recoil in horror at how I parse a
+	# selector rule. Whatever.
+	#
+	
+	# Initializes a Talius::Rule object. The first param is the Talius object
+	# with which the rule will be associated. The second param is the raw string
+	# that describes the rule.
+	#
+	#  raw = 'section, div'
+	#  selector = Talius.new(raw)
+	#  selector.rules[0] # => {"tags"=>{"section"=>{"name"=>"section"}}}
+	def initialize(p_selector, raw)
+		@selector = p_selector
+		@classes = {}
+		@tags = {}
+		@ids = {}
+		@pelements = {}
+		@pclasses = {}
+		@atts = {}
+		
+		# remove spaces before and after parens
+		raw = raw.gsub(/\s*([\(\)])\s*/mu, '\1')
+		
+		# split into subrules
+		pieces = raw.split(/(\[[^\[\]]*\])|(\:\:[^#{@@META_RX}]+)|([#{@@NESTING_RX}])|([#{@@META_RX}][^#{@@META_RX}]*)/mu)
+		pieces = pieces.grep(/./mu)
+		
+		# build subrules
+		pieces.each do |piece|
+			# I haven't yet implemented nested rules, so at this point we should
+			# not have any pieces that consist of just spaces
+			if @@NESTING_CHARS.include?(piece)
+				raise 'not-yet-implemented-nested-elements: ' + piece
+			end
+			
+			# if piece consists of a single meta character, that's invalid
+			if @@SUBRULE_CHARS.include?(piece)
+				raise 'meta-character-without-value: ' + piece
+			end
+			
+			# class
+			if piece.match(/\A\..+/mu)
+				@classes[piece.sub(/\A\./mu, '')] = true
+			
+			# pseudo element ::
+			elsif piece.match(/\A\:\:/mu)
+				pe = piece.sub(/\A\:\:/mu, '')
+				pseudo @pelements, pe
+				
+			# pseudo class :
+			elsif piece.match(/\A\:/mu)
+				pc = piece.sub(/\A\:/mu, '')
+				pseudo @pclasses, pc
+				
+			# attribute
+			elsif piece.match(/\A\[.*\]\z/mu)
+				full = piece
+				full = full.sub(/\A\s*\[\s*/mu, '')
+				full = full.sub(/\s*\]\s*\z/mu, '')
+				nv = full.split(/\s*\=\s*/mu, 2)
+				
+				if nv[0]
+					att = Talius::Node::Att.new(@selector.denormalize(nv[0]))
+					@atts[att.full_name] = att
+					
+					if nv[1]
+						att.value = @selector.denormalize(nv[1])
+					end
+				end
+			
+			# id
+			elsif piece.match(/\A\#/mu)
+				id = piece
+				id = id.sub(/\A\#/mu, '')
+				@ids[id] = true
+			
+			# else tag
+			else
+				tag = Talius::Node::Tag.new(@selector.denormalize(piece))
+				@tags[tag.full_name] = tag
+			end
+		end
+	end
+	#
+	# initialize
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# selector
+	#
+	
+	# The +Talius+ object that this rule is associated with.
+	attr_reader :selector
+	
+	#
+	# selector
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# classes
+	#
+	
+	# A hash of the classes described in the selector. The hash keys are the
+	# names of the classes. The values are always true.
+	#
+	#  raw = 'section.ready.overview'
+	#  selector = Talius.new(raw)
+	#  selector.rules[0].classes # => {"ready"=>true, "overview"=>true}
+	attr_reader :classes
+	
+	#
+	# classes
+	#---------------------------------------------------------------------------
+	
+
+	#---------------------------------------------------------------------------
+	# tags
+	#
+	
+	# A hash of the tags described in the selector. The hash keys are the names
+	# if the tags. The values are Talius::Node::Tag objects. Currently, Talius
+	# can only parse a single tag from a selector rule, so for now this hash
+	# will always have a single element.
+	#
+	#  raw = 'section'
+	#  selector = Talius.new(raw)
+	#  selector.rules[0].tags # => {"section"=>{"name"=>"section"}}
+	attr_reader :tags
+	
+	#
+	# tags
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# ids
+	#
+	
+	# A hash of elements defined by ID. The hash keys are the id's, the
+	# values are always true
+	#
+	#  raw = '#overview'
+	#  selector = Talius.new(raw)
+	#  rule = selector.rules[0]
+	#  rule.ids # => {"overview"=>true}
+	
+	attr_reader :ids
+	
+	#
+	# ids
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# pelements
+	#
+	
+	# A hash of pseudo-elements such as +::first-line+. The hash keys are the
+	# names of the pseudo-elements. The values are either the value in the
+	# parens after the name of the pseudo-element, or, if there is no such
+	# value, +nil+.
+	#
+	#  raw = 'section::first-line'
+	#  selector = Talius.new(raw)
+	#  selector.rules[0].pelements # => {"first-line"=>nil}
+	#
+	#  raw = 'section::nth-line(9)'
+	#  selector = Talius.new(raw)
+	#  selector.rules[0].pelements # => {"nth-line"=>"9"}
+	
+	attr_reader :pelements
+	
+	#
+	# pelements
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# pclasses
+	#
+	
+	# A hash of pseudo-classes such as +:visited+. The hash keys are the
+	# names of the pseudo-elements. The values are either the value in the
+	# parens after the name of the pseudo-element, or, if there is no such
+	# value, +nil+.
+	#
+	#  raw = 'a:visited'
+	#  selector = Talius.new(raw)
+	#  selector.rules[0].pclasses # => {"visited"=>nil}
+	#
+	#  raw = 'ul:nth-child(9)'
+	#  selector = Talius.new(raw)
+	#  selector.rules[0].pclasses # => {"nth-child"=>"9"}
+	
+	attr_reader :pclasses
+	
+	#
+	# pclasses
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# atts
+	#
+	
+	# Hash of attributes. The hash keys are the names of the attributes. The
+	# values are Talius::Node::Att objects.
+	#
+	#  raw = 'a[href][rel=parent]'
+	#  selector = Talius.new(raw)
+	#  selector.rules[0].atts # => {"href"=>{"name"=>"href"}, "rel"=>{"name"=>"rel", "value"=>"parent"}}
+	
+	attr_reader :atts
+	
+	#
+	# atts
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# to_h
+	#
+	
+	# Returns a hash representation of the rule.
+	def to_h
+		# $tm.hrm
+		rv = {}
+		
+		# tags
+		if @tags.any?
+			rv['tags'] = {}.tap do |tags|
+				@tags.each do |key, node|
+					tags[node.full_name] = node.to_h
+				end
+			end
+		end
+		
+		# ids
+		if @ids.any?
+			rv['ids'] = {}.tap do |ids|
+				@ids.each do |key, val|
+					ids[key] = val
+				end
+			end
+		end
+		
+		# atts
+		if @atts.any?
+			rv['atts'] = {}.tap do |atts|
+				@atts.each do |key, node|
+					atts[node.full_name] = node.to_h
+				end
+			end
+		end
+		
+		# classes
+		if @classes.any?
+			rv['classes'] = {}.tap do |classes|
+				@classes.each do |key, val|
+					classes[key] = val
+				end
+			end
+		end
+		
+		# pclasses
+		if @pclasses.any?
+			rv['pclasses'] = {}.tap do |pclasses|
+				@pclasses.each do |key, val|
+					pclasses[key] = val
+				end
+			end
+		end
+		
+		# pelements
+		if @pelements.any?
+			rv['pelements'] = {}.tap do |pelements|
+				@pelements.each do |key, val|
+					pelements[key] = val
+				end
+			end
+		end
+		
+		# return
+		return rv
+	end
+	#
+	# to_h
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# inspect
+	#
+	
+	# Returns a stringification of the results of to_h.
+	def inspect
+		return to_h.to_s
+	end
+	#
+	# inspect
+	#---------------------------------------------------------------------------
+	
+	
+	# private
+	private
+	
+	
+	#---------------------------------------------------------------------------
+	# pseudo
+	#
+	def pseudo(hsh, raw)
+		# get value in parens
+		if raw.match(/\(/mu)
+			val = raw
+			raw = raw.sub(/\(.*/mu, '')
+			val = val.sub(/\A.*\(/mu, '')
+			val = val.sub(/\)\z/mu, '')
+			hsh[@selector.denormalize(raw).downcase] = @selector.denormalize(val)
+		else
+			hsh[@selector.denormalize(raw).downcase] = nil
+		end
+	end
+	#
+	# pseudo
+	#---------------------------------------------------------------------------
+end
+#
+# Talius::Rule
+#===============================================================================
+
+
+#===============================================================================
+# Talius::Node
+#
+
+# Base class for Talius::Node::Tag and Talius::Node::Att.
+class Talius::Node
+	#---------------------------------------------------------------------------
+	# initialize
+	#
+	
+	# Initializes a new node. Accepts the string from the selector. Generally,
+	# you won't have to instantiate a Talius::Node object yourself.
+	def initialize(raw)
+		tokens = raw.split('|', 2)
+		
+		# if one element
+		if tokens.length == 1
+			@namespace = nil
+			@name = tokens[0]
+		elsif tokens.length == 2
+			@namespace = tokens[0]
+			@name = tokens[1]
+		else
+			raise 'node-syntax-error: ' + raw.to_s
+		end
+	end
+	#
+	# initialize
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# The node's namespace. If a namespace is not explicitly given in the
+	# selector string then this property is nil.
+	#
+	#  raw = 'section, mml|dev'
+	#  selector = Talius.new(raw)
+	#  selector.rules[0].tags['section'].namespace # => nil
+	#  selector.rules[1].tags['mml|dev'].namespace # => "mml"
+	attr_reader :namespace
+	#
+	# namespace
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# name
+	#
+	
+	# The name of the tag or attribute. Does not include the namespace.
+	#
+	#  raw = 'section, mml|dev'
+	#  selector = Talius.new(raw)
+	#  selector.rules[0].tags['section'].name # => "section"
+	#  selector.rules[1].tags['mml|dev'].name # => "dev"
+	attr_reader :name
+	#
+	# name
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# full_name
+	#
+	
+	# Returns the namespace (if there is one) and the name of the node. If there
+	# is a namespace then the namespace is followed by |.
+	#
+	#  raw = 'section, mml|dev'
+	#  selector = Talius.new(raw)
+	#  selector.rules[0].tags['section'].fullname # => "section"
+	#  selector.rules[1].tags['mml|dev'].fullname # => "mml|dev"
+	def full_name
+		if @namespace
+			return @namespace + '|' + @name
+		else
+			return @name
+		end
+	end
+	#
+	# full_name
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# to_s
+	#
+	
+	# Returns the results of +full_name+.
+	def to_s
+		return full_name
+	end
+	#
+	# to_s
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# to_h
+	#
+	
+	# Returns a hash of the name and namespace (if there is a namespace).
+	#
+	#  raw = 'section, mml|dev'
+	#  selector = Talius.new(raw)
+	#  selector.rules[0].tags['section'].to_h # => {"name"=>"section"}
+	#  selector.rules[1].tags['mml|dev'].to_h # => {"name"=>"dev", "namespace"=>"mml"}
+	def to_h
+		rv = {}
+		rv['name'] = @name
+		
+		# namespace
+		if @namespace
+			rv['namespace'] = @namespace
+		end
+		
+		return rv
+	end
+	#
+	# to_h
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# inspect
+	#
+	
+	# Returns the stringification of the hash returned by +to_h+.
+	#  raw = 'section, mml|dev'
+	#  selector = Talius.new(raw)
+	#  selector.rules[0].tags['section'].inspect # => {"name"=>"section"}
+	#  selector.rules[1].tags['mml|dev'].inspect # => {"name"=>"dev", "namespace"=>"mml"}
+	def inspect
+		return to_h.inspect
+	end
+	#
+	# inspect
+	#---------------------------------------------------------------------------
+end
+#
+# Talius::Node
+#===============================================================================
+
+
+#===============================================================================
+# Talius::Node::Tag
+#
+
+# This class inherits from Talius::Node and adds nothing to it.
+class Talius::Node::Tag < Talius::Node
+end
+#
+# Talius::Node::Tag
+#===============================================================================
+
+
+#===============================================================================
+# Talius::Node::Att
+#
+
+# This class inherits from Talius::Node and adds the value property.
+class Talius::Node::Att < Talius::Node
+	#---------------------------------------------------------------------------
+	# initialize
+	#
+	def initialize(*opts)
+		super(*opts)
+		@value = nil
+	end
+	#
+	# initialize
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# value
+	#
+	
+	# The value of the attribute rule, if there is one.
+	#
+	#  raw = 'a[href][rel=parent]'
+	#  selector = Talius.new(raw)
+	#  rule = selector.rules[0]
+	#  rule.atts['href'].value # => nil
+	#  rule.atts['rel'].value  # => "parent"
+	
+	attr_accessor :value
+	
+	#
+	# value
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# to_h
+	#
+	
+	# Returns a hash representation of the obect.
+	def to_h
+		rv = super()
+		
+		# value
+		if @value
+			rv['value'] = @value
+		end
+		
+		return rv
+	end
+	#
+	# to_h
+	#---------------------------------------------------------------------------
+end
+#
+# Talius::Node::Att
+#===============================================================================

metadata

@@ -0,0 +1,59 @@
+--- !ruby/object:Gem::Specification
+name: talius
+version: !ruby/object:Gem::Version
+  version: '0.5'
+platform: ruby
+authors:
+- Mike O'Sullivan
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2020-05-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: lx.rb
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+description: CSS selector parser
+email: mike@idocs.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/talius.rb
+homepage: https://rubygems.org/gems/talius
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.6
+signing_key: 
+specification_version: 4
+summary: CSS selector parser
+test_files: []