Perform the actual parsing.
 @return [Result] this instance
 @api private
437570
def parse!
      check_absorption!

      @expected.each do |type, *rest|
        case type
        when :list
          parse_list!(*rest)
        else
          parse_type!(type, *rest)
        end
      end

      self
    end
460000
def parse(node)
      node.attributes.each do |key, value|
        case key
        when 'ref'
          @reference = Coordinates.parser_coordinates_range(value.value.to_s)
        when 'si'
          @string_index = value.value.to_i
        when 't'
          @type = value.value.to_s
        end
      end

      @value = node.text unless node.text.empty?
      self
    end
1360618
def parse(args={})
      string_block = args.fetch(:text, nil)
      string_block = sample_string_block if !string_block.present?
      result_hash = {results: count_strings(string_block), text: string_block }
    end
406817
def parse
      parser = Parser.new Nokogiri::XML(xml)
      parser.parse
      parser
    end
738265
def parse(data)
      if !data.respond_to?(:read)
        data = StringIO.new(data || "")
      end

      if data.eof?
        {}
      else
        LibXML::XML::Parser.io(data).parse.to_hash
      end
    end
430938
def parse_options(options={})
      options.each do |key, value|
        key = :"#{key}="
        self.send(key, value) if !value.nil? && self.respond_to?(key)
      end
    end
688185
def parse
      @lines.each do |line|
        if m = line.match(R_ATTRIBUTE)
          @attrs << {:name => m[1].strip, :type => m[2].strip, :desc => m[4].strip}
        elsif m = line.match(R_ATTRIBUTE_NEXT_LINE)
          @attrs[-1][:desc] += " #{m[1].strip}"
        end
      end
    end
1365224
def parse!(*argv)
      super

      if Options[:version] && Bini.version
        puts Bini.version
        # don't exit if RSpec is around, we are in a testing environment.
        exit 0 if !Object.constants.include? :RSpec
      end
    end
678508
def parse(node)
      node.xpath('*').each do |node_children|
        case node_children.name
        when 'Relationship'
          @relationship << Relationship.new(parent: self).parse(node_children)
        end
      end
      self
    end
125038
def parse_string(self):
        
        if self._parse_string is None:
            parse_text = self._element.xpath('parse/text()')
            if len(parse_text) > 0:
                self._parse_string = parse_text[0]
        return self._parse_string
1250640
def parse(scanner, rules, scope = ParserScope.empty)
      if result = child.parse(scanner, rules, scope) {|_| scope = _ }
        yield scope.bind(label => result) if block_given?
        result
      end
    end
384493
def parse(self):
        
        # Create the element tree
        self.tree = self._build_tree(self.html_contents)

        # Get explicits elements to keep and discard
        self.elts_to_keep = self._get_elements_to_keep()
        self.elts_to_discard = self._get_elements_to_discard()

        # Init an empty list of Elements to remove
        self.elts_to_remove = []

        # Check if the root is a match or if there is any matches
        is_root = self._is_keep(self.tree)
        has_descendant = self._has_keep_elt_in_descendants(self.tree)

        if not(is_root or has_descendant):
            return False

        # Parse and clean the ElementTree
        self._parse_element(self.tree, parent_is_keep=is_root)
        self._remove_elements(self.elts_to_remove)

        return True
1115351
def parsed(self):
        
        if not self._parsed:

            self._parsed = json.loads(self.content)

        return self._parsed
113689
def parse_attributes!
      self.attributes = (attributes || []).map do |key_value|
        name, type, index, default = key_value.split(/:/)
        opts = {}
        if default
          opts[:default] = default
        end
        if index
          index_type, constraint = index.split(/,/)
          if constraint == 'not_null'
            opts[:null] = false
          end
        end
        create_attribute(name, type, index_type, opts)
      end
    end
778915
def parse(node)
      node.attributes.each do |key, value|
        case key
        when 'id'
          @id = value.value.to_i
        when 'name'
          @name = value.value
        end
      end
      self
    end
873365
def parse(self):
        

        if self._parsed is not None:
            return self._parsed

        try:
            _, spec, params = self._alternatives[self._choice]
            self._parsed, _ = _parse_build(self._contents, spec=spec, spec_params=params)
        except (ValueError, TypeError) as e:
            args = e.args[1:]
            e.args = (e.args[0] + '\n    while parsing %s' % type_name(self),) + args
            raise e
600846
def parse(node)
      @id = node.attribute('id').value
      @type = node.attribute('type').value
      node.xpath('*').each do |text_field_node_child|
        case text_field_node_child.name
        when 't'
          @text = text_field_node_child.text
        end
      end
      self
    end