The existing evaluate function requires lots of research, configuration and additional imports to use, while the poor souls that have to process XMLs usually just need to be able to execute simple XPath expressions. The evaluate_absolute_xpath function only needs a Document and an XPath &str to work and it returns a Value in wrappers ready to accomodate various possible errors.

In addition, this extends the expression::Errorstruct with an InvalidXPath variant so that potential XPath-related parser::ParseErr errors can be handled. It is not perfect; instead of a String I would prefer to relay ParseErr, but it would break the ExpressionError's Hash property - deriving Hash would fail due to Token having an f64 variant.

The last modification in the integration.rs file is just a deletion of an unused trait import (Expression).

Hi. Maybe the functionality is already there and I'm missing something, but essentially I was parsing this XML:

<?xml version="1.0" encoding="UTF-8"?>
<metadata xmlns="http://musicbrainz.org/ns/mmd-2.0#">
<area id="a1411661-be21-4290-8dc1-50f3d8e3ea67" type-id="6fd8f29a-3d0a-32fc-980d-ea697b69da78" type="City">
    <name>Honolulu</name>
    <sort-name>Honolulu</sort-name>
</area>
</metadata>

and I had some issues selecting elements due to the namespace. After I saw the test and #108 I've figured out I can use a Context with

context.set_namespace("mb", "http://musicbrainz.org/ns/mmd-2.0#");

and then use mb: for all elements in my XPath queries. e.g. //mb:area/mb:name/text(). However this is a bit cumbersome, so I wanted to ask if functionality to specify a default namespace which would be used for unqualified selectors in XPath queries is desirable? Or would this break the XPath spec somehow?

(I might implement this functionality, I just wanted to ask in advance for some thoughts so I don't end up coding for nothing. ^^)

Hello,

I have an error when I try to evaluate a namespaced xpath:

$ cargo run
   Compiling quick-error v1.1.0
   Compiling typed-arena v1.2.0
   Compiling peresil v0.3.0
   Compiling sxd-document v0.2.0
   Compiling sxd-xpath v0.4.0 (https://github.com/shepmaster/sxd-xpath.git#16b17d77)
   Compiling rust v0.1.0 (file:///home/sanpi/test/rust)
    Finished debug [unoptimized + debuginfo] target(s) in 8.74 secs
     Running `target/debug/rust`
thread 'main' panicked at 'No namespace for prefix', /buildslave/rust-buildbot/slave/stable-dist-rustc-linux/build/src/libcore/option.rs:715
note: Run with `RUST_BACKTRACE=1` for a backtrace.

extern crate sxd_document;
extern crate sxd_xpath;

fn main() {
    let package = ::sxd_document::parser::parse(r#"
<d:multistatus xmlns:d="DAV:" xmlns:cs="http://calendarserver.org/ns/">
    <d:response>
        <d:href>/</d:href>
        <d:propstat>
            <d:prop>
                <d:current-user-principal>
                    <d:href>/principals/users/johndoe/</d:href>
                </d:current-user-principal>
            </d:prop>
            <d:status>HTTP/1.1 200 OK</d:status>
        </d:propstat>
    </d:response>
</d:multistatus>"#).unwrap();

    let document = package.as_document();

    ::sxd_xpath::evaluate_xpath(&document, "/d:multistatus")
        .unwrap();
}

Why?

The MIT license requires reproducing countless copies of the same copyright header with different names in the copyright field, for every MIT library in use. The Apache license does not have this drawback, and has protections from patent trolls and an explicit contribution licensing clause. However, the Apache license is incompatible with GPLv2. This is why Rust is dual-licensed as MIT/Apache (the "primary" license being Apache, MIT only for GPLv2 compat), and doing so would be wise for this project. This also makes this crate suitable for inclusion in the Rust standard distribution and other project using dual MIT/Apache.

How?

To do this, get explicit approval from each contributor of copyrightable work (as not all contributions qualify for copyright) and then add the following to your README:

## License

Licensed under either of
 * Apache License, Version 2.0 ([LICENSE-APACHE](LICENSE-APACHE) or http://www.apache.org/licenses/LICENSE-2.0)
 * MIT license ([LICENSE-MIT](LICENSE-MIT) or http://opensource.org/licenses/MIT)
at your option.

### Contribution

Unless you explicitly state otherwise, any contribution intentionally submitted
for inclusion in the work by you shall be dual licensed as above, without any
additional terms or conditions.

and in your license headers, use the following boilerplate (based on that used in Rust):

// Copyright (c) 2015 t developers
// Licensed under the Apache License, Version 2.0
// <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT
// license <LICENSE-MIT or http://opensource.org/licenses/MIT>,
// at your option. All files in the project carrying such
// notice may not be copied, modified, or distributed except
// according to those terms.

And don't forget to update the license metadata in your Cargo.toml!

Contributor checkoff

• [x] @shepmaster
• [x] @carols10cents
• [x] @flying-sheep
• [x] @Boddlnagg
• [x] @vky
• [x] @messense
• [x] @ljedrz

This is unfortunate because now there's a private type in the public Expression trait that I can't implement From<expression::Error> for.

Update: It kind of works if you chain multiple into calls together. Still kind of bad if you wanted to use try! or the question mark operator, as that's completely impossible with the current situation.

I have an XSLT script that uses the node-set function defined by EXSLT. It works in Firefox, which has some EXSLT support. Depending on how hard this would be to implement (node-set shouldn't be too hard), I think having it in this Rust library would be great!

the expression crate is private

pub trait Expression: Debug {
    fn evaluate<'a, 'd>(&self, context: &sxd_xpath::EvaluationContext<'a, 'd>)
        -> Result<sxd_xpath::Value<'d>, sxd_xpath::expression::Error>;
}

so if i’m not missing something, this crate is actually unusable for its main purpose: evaluating XPath expressions :laughing:

Hi, i am new to rust and wanted to build a small project that included reading xml changing a value writing it back and i really love this lib, seems to be the easiest xml lib in the rust world, awesome work.

So, i got the point with reading and writing a document but i do not get how to i can get a node via xpath, change its value and then write this back

was checking the tests but could not really find a example

Hi

I tried sxd-xpath and I noticed it doesn't seem to support xml declarations.

The code is based on the syntax used for the crate's tests:

extern crate sxd_xpath;
extern crate sxd_document;

use std::collections::HashMap;
use sxd_document::Package;
use sxd_document::dom::Document;
use sxd_document::parser::Parser;
use sxd_xpath::{Value,Functions,Variables,Namespaces,Factory,EvaluationContext,Expression};


fn main() {
    let x = r#"
<?xml version="1.0" encoding="UTF-8"?>

<bookstore>

<book>
  <title lang="en">Harry Potter</title>
  <price>29.99</price>
</book>

<book>
  <title lang="en">Learning XML</title>
  <price>39.95</price>
</book>

</bookstore>"#;
let package = parse(x);
let doc = package.as_document();
let result = evaluate(&doc, "string(/*/book[1]/title/@lang)");
println!("{:?}", &result);
}

fn parse(xml: &str) -> Package {
    Parser::new().parse(xml).unwrap()
}

fn evaluate<'d>(package: &'d Document<'d>, xpath: &str) -> Value<'d> {
    let setup = Setup::new();
    setup.evaluate(package, xpath)
}

struct Setup<'d> {
    functions: Functions,
    variables: Variables<'d>,
    namespaces: Namespaces,
    factory: Factory,
}

impl<'d> Setup<'d> {
    fn new() -> Setup<'d> {
        let mut fns = HashMap::new();
        sxd_xpath::function::register_core_functions(&mut fns);
        Setup {
            functions: fns,
            variables: HashMap::new(),
            namespaces: HashMap::new(),
            factory: Factory::new(),
        }
    }

    fn evaluate(&self, doc: &'d Document<'d>, xpath: &str) -> Value<'d> {
        let root = doc.root();
        let context = EvaluationContext::new(
            root,
            &self.functions,
            &self.variables,
            &self.namespaces,
        );

        let xpath = self.factory.build(xpath).unwrap().unwrap();
        xpath.evaluate(&context).ok().unwrap()
    }
}

When I run it:

thread '<main>' panicked at 'called `Result::unwrap()` on an `Err` value: (3, [InvalidProcessingInstructionTarget])', /Users/rustbuild/src/rust-buildbot/slave/stable-dist-rustc-mac/build/src/libcore/result.rs:729

Everything works as expected if I remove the XML declaration (<?xml version="1.0" encoding="UTF-8"?>) from the xml string.

I don't know if there is already a nice way to avoid this error, as the documentation is a bit scarce. I would like to help out with a PR but I just started playing with the lib so I am not familiar at all with the design.

Right now, we store a Nodeset as a collection of Node objects. However, all the nodes should belong to the same document, so it's possible we could split up the node and store the common information just once.

For example after using evaluate_xpath(&document, &path) to produce a Nodeset to iterate over, how would you then run a subsequent XPath query to drill down further using a relative XPath?

Hi, I tried to compile and pass all the tests, but one failing test caught my eye:

---- test::string_of_negative_zero_is_zero stdout ----
thread 'test::string_of_negative_zero_is_zero' panicked at 'assertion failed: `(left == right)`
  left: `"0"`,
 right: `"-0"`', src/lib.rs:545:9

It reminds me of the signed zero in IEEE 754, which indicates the sign of a zero, regardless of the fact that 0.0 == -0.0. Therefore, a direct to_string() will make the test fail if the test case constructs -0.0 deliberately.

This patch passes the test by additionally judging whether the number to be returned equals zero. Since 0.0 == -0.0, both should be treated as 0.0 when printing.

It's is a tiny patch and only takes perhaps less than a minute to check and comment. The library is great, I find it handy. Thanks, and have a nice day / night : )

All,

I'm trying to use sxd-xpath (v0.4), in a static XML file with namespaces defined. I was wondering if it would be possible to create a basic example that shows how to find elements within a given namespace.

• Mike D.

One of the great benefits of Rust is that many runtime errors can be avoided due to the strict type system. With XPath, that's pretty much gone as only syntax errors are caught when doing a build().

In my application, I define many new variables and functions. I read in patterns from files and execute them against data the program (library) is called with. Just as with code, the patterns are prone to various forms of "typos" such as misspelled variable names and function names, or passing in the wrong number of arguments. A version of build() that accepted a context could verify that the path is valid against variables and functions defined in the given context so that the initialization phase (the equivalent of compiling the patterns) would catch these mistakes early on.

With the current method of defining context, testing that an xpath query function call has the proper number of arguments is not possible, but adding another "stricter" method of function definition would allow for that. It could even add types to the arguments so that the build phase could verify them. As with Rust, this would allow the user-defined function implementation to avoid having to do runtime argument count and type checks in many situations.

As it stands, sxd-xpath is the most full-featured and currently maintained XPath library in Rust.

The XPath 2.0 lists the following goals:

Support related XML standards Improve ease of use Improve interoperability Improve i18n support Maintain backward compatibility

A major use of XPath in the real world is web scraping and parsing. Although the XPath specs don't address it, I think it should be a major goal of this library.

Thus, that means:

1. supporting basic HTML requirements like <!doctype html>, fully supporting self-closing tags, etc
2. possibly abstracting out our DOM using traits that could be implemented by other parsing libraries like html5ever (#73). This would allow us to use the full power of the Rust ecosystem, and rely on highly-used and maintained libraries, some of which have more powerful features like quirks mode and more advanced error reporting

Ok so im trying to parse MARC 21 XML reccords. And I might mention I do this to learn rust, and MARC wich both are quite complicated.

However Ive got tvo examples one that work and one where I change this:

    <record
            xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
            xsi:schemaLocation="http://www.loc.gov/MARC21/slim http://www.loc.gov/standards/marcxml/schema/MARC21slim.xsd"
            xmlns="http://www.loc.gov/MARC21/slim">    

to simply

The later works and the first one just return empty :

Example1:

fn do_something_with_metadata() {

    let package = parser::parse(r#"<?xml version="1.0" encoding="UTF-8"?>
    <record
            xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
            xsi:schemaLocation="http://www.loc.gov/MARC21/slim http://www.loc.gov/standards/marcxml/schema/MARC21slim.xsd"
            xmlns="http://www.loc.gov/MARC21/slim">    


      <leader>00446nim a22001813  45  </leader>
      <controlfield tag="001">11469144</controlfield>
      <controlfield tag="003">SE-LIBR</controlfield>
      <controlfield tag="005">20171005164357.0</controlfield>
      <controlfield tag="007">sd|||||||||||||||||||||</controlfield>
      <controlfield tag="008">091027s2001    xx |||_j_|||||_|| _|swe||</controlfield>
      <datafield tag="035" ind1=" " ind2=" ">
        <subfield code="a">(LibraSE)24008</subfield>
      </datafield>
      <datafield tag="084" ind1=" " ind2=" ">
        <subfield code="a">Yq</subfield>
      </datafield>
      <datafield tag="245" ind1="1" ind2="0">
        <subfield code="a">Astrid Lindgrens favoriter: CD 1 Sånger</subfield>
      </datafield>
      <datafield tag="260" ind1=" " ind2=" ">
        <subfield code="a">Stockholm :</subfield>
        <subfield code="b">Bonnier Music,</subfield>
        <subfield code="c">2001</subfield>
      </datafield>
      <datafield tag="300" ind1=" " ind2=" ">
        <subfield code="a">1 CD</subfield>
      </datafield>
      <datafield tag="653" ind1=" " ind2=" ">
        <subfield code="a">CD-bok</subfield>
      </datafield>
      <datafield tag="653" ind1=" " ind2=" ">
        <subfield code="a">Barn och ungdom</subfield>
      </datafield>
      <datafield tag="852" ind1=" " ind2=" ">
        <subfield code="h">Hcf/LC</subfield>
        <subfield code="l">AST</subfield>
      </datafield>
      <datafield tag="942" ind1=" " ind2=" ">
        <subfield code="c">BARN LJUD</subfield>
      </datafield>
      <datafield tag="999" ind1=" " ind2=" ">
        <subfield code="c">9782</subfield>
        <subfield code="d">9782</subfield>
      </datafield>
    </record>"#).expect("failed to parse XML");
    let document = package.as_document();
    let value = evaluate_xpath(&document, "/record/leader").expect("XPath evaluation failed");

    println!("Found: {}({:?})", value.string(),value);

}

Output:

Found: (Nodeset(Nodeset { nodes: {} }))
Found: (Nodeset(Nodeset { nodes: {} }))
Found: (Nodeset(Nodeset { nodes: {} }))
Found: (Nodeset(Nodeset { nodes: {} }))
Found: (Nodeset(Nodeset { nodes: {} }))

Example2:

fn do_something_with_metadata() {

    let package = parser::parse(r#"<?xml version="1.0" encoding="UTF-8"?>
    <record>

      <leader>00446nim a22001813  45  </leader>
      <controlfield tag="001">11469144</controlfield>
      <controlfield tag="003">SE-LIBR</controlfield>
      <controlfield tag="005">20171005164357.0</controlfield>
      <controlfield tag="007">sd|||||||||||||||||||||</controlfield>
      <controlfield tag="008">091027s2001    xx |||_j_|||||_|| _|swe||</controlfield>
      <datafield tag="035" ind1=" " ind2=" ">
        <subfield code="a">(LibraSE)24008</subfield>
      </datafield>
      <datafield tag="084" ind1=" " ind2=" ">
        <subfield code="a">Yq</subfield>
      </datafield>
      <datafield tag="245" ind1="1" ind2="0">
        <subfield code="a">Astrid Lindgrens favoriter: CD 1 Sånger</subfield>
      </datafield>
      <datafield tag="260" ind1=" " ind2=" ">
        <subfield code="a">Stockholm :</subfield>
        <subfield code="b">Bonnier Music,</subfield>
        <subfield code="c">2001</subfield>
      </datafield>
      <datafield tag="300" ind1=" " ind2=" ">
        <subfield code="a">1 CD</subfield>
      </datafield>
      <datafield tag="653" ind1=" " ind2=" ">
        <subfield code="a">CD-bok</subfield>
      </datafield>
      <datafield tag="653" ind1=" " ind2=" ">
        <subfield code="a">Barn och ungdom</subfield>
      </datafield>
      <datafield tag="852" ind1=" " ind2=" ">
        <subfield code="h">Hcf/LC</subfield>
        <subfield code="l">AST</subfield>
      </datafield>
      <datafield tag="942" ind1=" " ind2=" ">
        <subfield code="c">BARN LJUD</subfield>
      </datafield>
      <datafield tag="999" ind1=" " ind2=" ">
        <subfield code="c">9782</subfield>
        <subfield code="d">9782</subfield>
      </datafield>
    </record>"#).expect("failed to parse XML");
    let document = package.as_document();
    let value = evaluate_xpath(&document, "/record/leader").expect("XPath evaluation failed");

    println!("Found: {}({:?})", value.string(),value);

}

Returns:

Found: 00446nim a22001813  45  (Nodeset(Nodeset { nodes: {Element(Element { name: QName { namespace_uri: None, local_part: "leader" } })} }))
Found: 00446nim a22001813  45  (Nodeset(Nodeset { nodes: {Element(Element { name: QName { namespace_uri: None, local_part: "leader" } })} }))
Found: 00446nim a22001813  45  (Nodeset(Nodeset { nodes: {Element(Element { name: QName { namespace_uri: None, local_part: "leader" } })} }))
Found: 00446nim a22001813  45  (Nodeset(Nodeset { nodes: {Element(Element { name: QName { namespace_uri: None, local_part: "leader" } })} }))
Found: 00446nim a22001813  45  (Nodeset(Nodeset { nodes: {Element(Element { name: QName { namespace_uri: None, local_part: "leader" } })} }))

Im not sure why it dont lake the part of record, it just dont :)

Kind regards /Jacob