<?xml version="1.0" encoding="UTF-8"?>
<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns="http://purl.org/rss/1.0/" xmlns:taxo="http://purl.org/rss/1.0/modules/taxonomy/" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:syn="http://purl.org/rss/1.0/modules/syndication/" xmlns:admin="http://webns.net/mvcb/">
  <channel rdf:about="http://blog.gmane.org/gmane.text.yaml.general">
    <title>gmane.text.yaml.general</title>
    <link>http://blog.gmane.org/gmane.text.yaml.general</link>
    <description/>
    <syn:updatePeriod>hourly</syn:updatePeriod>
    <syn:updateFrequency>1</syn:updateFrequency>
    <syn:updateBase>1901-01-01T00:00+00:00</syn:updateBase>
    <items>
      <rdf:Seq>
        <rdf:li rdf:resource="http://comments.gmane.org/gmane.text.yaml.general/3784"/>
        <rdf:li rdf:resource="http://comments.gmane.org/gmane.text.yaml.general/3781"/>
        <rdf:li rdf:resource="http://comments.gmane.org/gmane.text.yaml.general/3778"/>
        <rdf:li rdf:resource="http://comments.gmane.org/gmane.text.yaml.general/3774"/>
        <rdf:li rdf:resource="http://comments.gmane.org/gmane.text.yaml.general/3771"/>
        <rdf:li rdf:resource="http://comments.gmane.org/gmane.text.yaml.general/3767"/>
        <rdf:li rdf:resource="http://comments.gmane.org/gmane.text.yaml.general/3761"/>
        <rdf:li rdf:resource="http://comments.gmane.org/gmane.text.yaml.general/3760"/>
        <rdf:li rdf:resource="http://comments.gmane.org/gmane.text.yaml.general/3759"/>
        <rdf:li rdf:resource="http://comments.gmane.org/gmane.text.yaml.general/3754"/>
        <rdf:li rdf:resource="http://comments.gmane.org/gmane.text.yaml.general/3753"/>
        <rdf:li rdf:resource="http://comments.gmane.org/gmane.text.yaml.general/3748"/>
        <rdf:li rdf:resource="http://comments.gmane.org/gmane.text.yaml.general/3745"/>
        <rdf:li rdf:resource="http://comments.gmane.org/gmane.text.yaml.general/3742"/>
        <rdf:li rdf:resource="http://comments.gmane.org/gmane.text.yaml.general/3741"/>
        <rdf:li rdf:resource="http://comments.gmane.org/gmane.text.yaml.general/3739"/>
        <rdf:li rdf:resource="http://comments.gmane.org/gmane.text.yaml.general/3738"/>
        <rdf:li rdf:resource="http://comments.gmane.org/gmane.text.yaml.general/3736"/>
        <rdf:li rdf:resource="http://comments.gmane.org/gmane.text.yaml.general/3734"/>
        <rdf:li rdf:resource="http://comments.gmane.org/gmane.text.yaml.general/3730"/>
      </rdf:Seq>
    </items>
    <image rdf:resource="http://gmane.org/img/gmane-25t.png"/>
    <textinput rdf:resource=""/>
  </channel>
  <image rdf:about="http://gmane.org/img/gmane-25t.png">
    <title>Gmane</title>
    <url>http://gmane.org/img/gmane-25t.png</url>
    <link>http://gmane.org</link>
  </image>
  <item rdf:about="http://comments.gmane.org/gmane.text.yaml.general/3784">
    <title>Checksums</title>
    <link>http://comments.gmane.org/gmane.text.yaml.general/3784</link>
    <description>&lt;pre&gt;|Is there a better way of passing checksums of streams?
The use case is sending YAML data over a serial connection that occasionally gets errors or dropped characters.

%YAML 1.2
%CRC B8C5938E
---
a: foo
b: bar
c: baz
...
%YAML 1.2
%CRC 498BBC05
---
a: alpha
b: beta
c: gamma
...|


------------------------------------------------------------------------------
Try New Relic Now &amp;amp; We'll Send You this Cool Shirt
New Relic is the only SaaS-based application performance monitoring service 
that delivers powerful full stack analytics. Optimize and monitor your
browser, app, &amp;amp; servers with just a few lines of code. Try New Relic
and get this awesome Nerd Life shirt! http://p.sf.net/sfu/newrelic_d2d_apr
&lt;/pre&gt;</description>
    <dc:creator>I Heart Robotics</dc:creator>
    <dc:date>2013-04-29T14:30:40</dc:date>
  </item>
  <item rdf:about="http://comments.gmane.org/gmane.text.yaml.general/3781">
    <title>PyYAML hangs when reading a large YAML file</title>
    <link>http://comments.gmane.org/gmane.text.yaml.general/3781</link>
    <description>&lt;pre&gt;Hi,

I'm trying to load data from a large YAML file (approx. 300MB).  PyYAML
hangs when I try to load using this code:

    import yaml
    y = yaml.load(open("/tmp/tmp6aJfKz"))

The YAML file itself is valid (it is being output by OpenCV).

Can anyone suggest a way to diagnose this problem?  I can provide the file,
but as I've already mentioned, it's fairly large.

Cheers,
Michael
------------------------------------------------------------------------------
Precog is a next-generation analytics platform capable of advanced
analytics on semi-structured data. The platform includes APIs for building
apps and a phenomenal toolset for data science. Developers can use
our toolset for easy data analysis &amp;amp; visualization. Get a free account!
http://www2.precog.com/precogplatform/slashdotnewsletter_______________________________________________
Yaml-core mailing list
Yaml-core-5NWGOfrQmneRv+LV9MX5uipxlwaOVQ5f&amp;lt; at &amp;gt;public.gmane.org
https://lists.sourceforge.net/lists/listinfo/yaml-core
&lt;/pre&gt;</description>
    <dc:creator>Misha Penkov</dc:creator>
    <dc:date>2013-04-18T11:17:36</dc:date>
  </item>
  <item rdf:about="http://comments.gmane.org/gmane.text.yaml.general/3778">
    <title>Top level block scalar without indentation</title>
    <link>http://comments.gmane.org/gmane.text.yaml.general/3778</link>
    <description>&lt;pre&gt;Hi,

I noticed that LibYAML doesn't parse block scalar without indentation.

  Sample: 1
  ---
  XXX
  YYY
  ZZZ

  Sample: 2
  --- |
  XXX
  YYY
  ZZZ

I expected that these samples would be parsed like this:

  [{"Sample": 1}, "XXX YYY ZZZ"]
  [{"Sample": 2}, "XXX\nYYY\nZZZ\n"]

LibYAML can parse Sample 1 but not Sample 2.

  $ ./run-parser Sample1.yaml
  [1] Parsing 'Sample1.yaml': SUCCESS (11 events)

  $ ./run-parser Sample2.yaml
  [1] Parsing 'Sample2.yaml': FAILURE (10 events)

PyYAML returned error.

  expected '&amp;lt;document start&amp;gt;', but found '&amp;lt;scalar&amp;gt;'


I checked some implementations. The results are:

  Syck (YAML 1.0) - Ruby
    Sample1 ... PASS
    Sample2 ... PASS

  YAML.pm (YAML 1.0) - Perl
    Sample1 ... FAIL
    Sample2 ... PASS

  PyYAML (YAML 1.1) - Python / LibYAML
    Sample1 ... PASS
    Sample2 ... FAIL

  Psych     (YAML 1.1) - Ruby / LibYAML
    Sample1 ... PASS
    Sample2 ... FAIL

  SnakeYAML (YAML 1.1) - Java / based on LibYAML
    Sample1 ... PASS
    Sample2 ... FAIL

  JS-YAML&lt;/pre&gt;</description>
    <dc:creator>KOSEKI Kengo</dc:creator>
    <dc:date>2013-04-13T11:10:31</dc:date>
  </item>
  <item rdf:about="http://comments.gmane.org/gmane.text.yaml.general/3774">
    <title>feature request for libyaml: support "\/" escape sequence for YAML 1.2/JSON compatibility</title>
    <link>http://comments.gmane.org/gmane.text.yaml.general/3774</link>
    <description>&lt;pre&gt;I attempted to submit a feature request ticket for libyaml:

http://pyyaml.org/newticket?component=libyaml

but it rejected my ticket, telling me it was spam.  (I could go off on a 
whole rant about how so-called "spam filtering" makes it impossible for 
legitimate users to get anything done these days, but that would be 
off-topic.)

Anyway, since I can't submit a ticket, sending the feature request to 
this list seemed like the next-best thing.

Here is the text of the ticket I attempted to submit to libyaml:

YAML 1.2 adds support for the escape sequence "\/", which was not 
present in YAML 1.1:

http://www.yaml.org/spec/1.2/spec.html#id2776092

YAML 1.2 added this escape sequence in order to be compatible with JSON. 
  (Since YAML's goal is to be a superset of JSON.)

Although libyaml is only a YAML 1.1 parser, it would be nice to have 
this feature, and adding it shouldn't cause any trouble with parsing 
YAML 1.1.

This is all that's needed:

{{{
--- a/scanner.c~
+++ b/scanner.c
&amp;lt; at &amp;gt;&amp;lt; at &amp;gt; -3164,6 +3164,10 &amp;lt; at &amp;gt;&amp;lt; at &amp;gt; y&lt;/pre&gt;</description>
    <dc:creator>Patrick Pelletier</dc:creator>
    <dc:date>2013-03-28T00:31:24</dc:date>
  </item>
  <item rdf:about="http://comments.gmane.org/gmane.text.yaml.general/3771">
    <title>Load Delegation</title>
    <link>http://comments.gmane.org/gmane.text.yaml.general/3771</link>
    <description>&lt;pre&gt;I'd like to get some feedback on an idea I have to implementing a YAML 
parser.

I was thinking that instead of instantiating the objects to native types 
directly, it could instantiate a delegator around the native type. e.g. 
instead of (in Ruby code):

     YAML.load('--- "string"') =&amp;gt; "string"

It would produce

     YAML.load('--- "string"') =&amp;gt; Y("string")

For all practical purposes Y("string") behaves just like "string".

The main reason for doing this is because of immutable types. Immutable 
types are difficult to load with self-referencing anchors --indeed the only 
solution I found was to forbid it. Immutable types also might not round 
trip well, b/c they are often singleton. So if the same object comes in via 
two different tags --say a schema supports both `!foo` and 
`foo.org,2000:foo`, it is only possible to emit it with on or the other. 
There is no way to remember which it came in with. Using the delegator is 
also nice b/c schemas then don't need to specify the type-class a tag goes 
with &lt;/pre&gt;</description>
    <dc:creator>Trans</dc:creator>
    <dc:date>2013-02-21T15:47:48</dc:date>
  </item>
  <item rdf:about="http://comments.gmane.org/gmane.text.yaml.general/3767">
    <title>Tag Spec</title>
    <link>http://comments.gmane.org/gmane.text.yaml.general/3767</link>
    <description>&lt;pre&gt;I was reading over the spec on Tags. There is an aspect of it that is
confusing. To the general viewer, it is not intuitive that the following
tag is not a "domain" tag:

    --- !tag:foo.org:org

It is actually a local tag with a very domain-esque name. The correct tag
is:

    --- !&amp;lt;tag:foo.org:org&amp;gt;

That's a very technical distinction and I think too difficult.

Would it be acceptable to just designate domain tags as any tag that
contains a `:` or `/`? I realize it might not be as efficient to parse, but
it would be a whole lot more comprehensible to humans.
------------------------------------------------------------------------------
Everyone hates slow websites. So do we.
Make your web apps faster with AppDynamics
Download AppDynamics Lite for free today:
http://p.sf.net/sfu/appdyn_d2d_jan_______________________________________________
Yaml-core mailing list
Yaml-core-5NWGOfrQmneRv+LV9MX5uipxlwaOVQ5f&amp;lt; at &amp;gt;public.gmane.org
https://lists.sourceforge.net/lists/listinfo/yaml-core
&lt;/pre&gt;</description>
    <dc:creator>Trans</dc:creator>
    <dc:date>2013-02-03T18:02:11</dc:date>
  </item>
  <item rdf:about="http://comments.gmane.org/gmane.text.yaml.general/3761">
    <title>Help understanfing tag resolution confusion</title>
    <link>http://comments.gmane.org/gmane.text.yaml.general/3761</link>
    <description>&lt;pre&gt;HI, I've been work with the Pysch library which is the YAML library that 
Ruby uses built upon libyaml.

Psych provides a away to add domain tag. Below I add a tag with `foo.org` 
domain and `foo` name,
it creates a tag from that called `tag:foo.org:foo`. It also creates a tag 
called `tag:foo`.
(See https://github.com/tenderlove/psych/blob/master/lib/psych.rb#L304-L308)

    require 'yaml'

    YAML.add_domain_type('foo.org', 'foo'){ |*a| "frak" }
    ["tag:foo.org:foo", #&amp;lt;Proc:0x00000000eec280&amp;lt; at &amp;gt;(irb):2&amp;gt;]

But then I can use all the following tags in the YAML to reolve to this 
domain tag:

    YAML.load('--- !&amp;lt;tag:foo.org:foo&amp;gt; "a"')
    =&amp;gt; "frak"

    YAML.load('--- !&amp;lt;tag:foo&amp;gt; "a"')
    =&amp;gt; "frak"

    YAML.load('--- !tag:foo.org:foo "a"')
    =&amp;gt; "frak"

    YAML.load('--- !tag:foo "a"')
    =&amp;gt; "frak"

    YAML.load('--- !foo.org:foo "a"')
    =&amp;gt; "frak"

    YAML.load('--- !foo "a"')
    =&amp;gt; "frak"

Are all of these tags actually valid and resolvable to `tag:foo.org:foo` of 
`tag:foo` ?
It seems like the `tag&lt;/pre&gt;</description>
    <dc:creator>Trans</dc:creator>
    <dc:date>2013-02-01T19:34:44</dc:date>
  </item>
  <item rdf:about="http://comments.gmane.org/gmane.text.yaml.general/3760">
    <title>Disabling implicit tag for timestamp in PyYaml</title>
    <link>http://comments.gmane.org/gmane.text.yaml.general/3760</link>
    <description>&lt;pre&gt;Greetings,

I get the following result in PyYaml:

 &amp;gt;&amp;gt;&amp;gt; import yaml
 &amp;gt;&amp;gt;&amp;gt; yaml.load('2012-12-24T22:45:51.000000Z')
datetime.datetime(2012, 12, 24, 22, 45, 51)
 &amp;gt;&amp;gt;&amp;gt;

However I do not want this conversion to datetime object, I just want a 
string. Changing the input (i.e. adding quotes) is not desirable.  How 
can I disable this implicit tag?

Thanks,
--dan


------------------------------------------------------------------------------
Master Visual Studio, SharePoint, SQL, ASP.NET, C# 2012, HTML5, CSS,
MVC, Windows 8 Apps, JavaScript and much more. Keep your skills current
with LearnDevNow - 3,200 step-by-step video tutorials by Microsoft
MVPs and experts. ON SALE this month only -- learn more at:
http://p.sf.net/sfu/learnnow-d2d
&lt;/pre&gt;</description>
    <dc:creator>Daniel Kahn</dc:creator>
    <dc:date>2013-01-24T16:15:17</dc:date>
  </item>
  <item rdf:about="http://comments.gmane.org/gmane.text.yaml.general/3759">
    <title>defining a tuple_of_tuples tag in PyYAML</title>
    <link>http://comments.gmane.org/gmane.text.yaml.general/3759</link>
    <description>&lt;pre&gt;
Hi,

I'm planning to use PyYAML for a configuration file. Some of the items in 
that configuration file are Python tuples of tuples. So, I need a 
convenient way to represent them. One can represent Python tuples of 
tuples as follows using PyYAML

print yaml.load("!!python/tuple [ !!python/tuple [1, 2], !!python/tuple [3, 4]]")

However, this is not convenient notation for a long sequence of items. I 
think it should be possible to define a custom tag, like 
python/tuple_of_tuples

See my attempt to define this below, by mimicking how python/tuple is 
defined, and trying to do similar subclassing. It fails, but gives an idea 
what I am after, I think. A proper solution would be most welcome.

I have a couple of comments on my attempted solution.

1) I'd have thought that the constructor 
`construct_python_tuple_of_tuples` would return the completed structure, 
but in fact it seems to return an empty structure as follows

([], [])

However, the value that is returned is a tuple of lists of integers, so 
qui&lt;/pre&gt;</description>
    <dc:creator>Faheem Mitha</dc:creator>
    <dc:date>2013-01-24T08:46:01</dc:date>
  </item>
  <item rdf:about="http://comments.gmane.org/gmane.text.yaml.general/3754">
    <title>C++ wrappers for libyaml, plus CMake port.</title>
    <link>http://comments.gmane.org/gmane.text.yaml.general/3754</link>
    <description>&lt;pre&gt;Hi all!

First, thanks for libyaml, it's come in quite handy :-)

I've written some C++ bindings for libyaml in order to simplify some
tasks when using the native API directly.  For instance, this API
allows easily iterating over sequences:

   yaml::Document document("some-yaml-text");
   yaml::List list = document.root();
   for (std::size_t i=0; (i &amp;lt; list.size()); ++i)
   {
       const std::string item = list[i];
       // use item...
   }

I'm planning on releasing these wrappers as an open source project,
but I was wondering if it were possible to include these wrappers in
the reference distribution?

Also, have you ever thought about switching from Autotools to CMake?
CMake much more convenient than Autotools, especially for Windows
builds.  I've already made the port for my own use,but if you've ever
thought about switching to CMake, I can provide patches.

Regards,
André

------------------------------------------------------------------------------
LogMeIn Rescue: Anywhere, Anytime Remote support &lt;/pre&gt;</description>
    <dc:creator>André Caron</dc:creator>
    <dc:date>2012-12-18T19:03:20</dc:date>
  </item>
  <item rdf:about="http://comments.gmane.org/gmane.text.yaml.general/3753">
    <title>[ANN] yamerl, a YAML 1.2 parser in Erlang</title>
    <link>http://comments.gmane.org/gmane.text.yaml.general/3753</link>
    <description>&lt;pre&gt;Hi everyone!

Yakaz is pleased to release yamerl, our YAML parser, written in Erlang.

This parser supports YAML 1.1 and YAML 1.2. The code, documentation and
testsuite are available on GitHub:
  https://github.com/yakaz/yamerl

Beside YAML 1.2 node types, it supports two Erlang-specific node types:
    o  Erlang atom node type.
    o  Erlang fun() node type.

Compared to yamler[1], another parser for Erlang but based on libyaml,
it has the following features and differences:
    o  Support for stream parsing.
    o  Support for YAML 1.2.
    o  Erlang atom autodetection (ie. no tag is specified):
         - yamerl (this one, pure Erlang) tries to represent plain
           scalar as Erlang atom only
         - yamler (libyaml-based) tries to represent both plain
           and single-quoted scalars. This looks more like Erlang
           syntax (where atoms can be unquoted or single-quoted) but
           breaks YAML specification, if I understand correctly.

Also, still compared to yamler, yamerl has the c&lt;/pre&gt;</description>
    <dc:creator>Jean-Sébastien Pédron</dc:creator>
    <dc:date>2012-12-17T15:18:31</dc:date>
  </item>
  <item rdf:about="http://comments.gmane.org/gmane.text.yaml.general/3748">
    <title>yaml command line tool</title>
    <link>http://comments.gmane.org/gmane.text.yaml.general/3748</link>
    <description>&lt;pre&gt;I was thinking it would be a good idea to have an "official" yaml command
line tool. The tool would make it possible for shell scripts to work with
yaml documents. It should be able to do things like read a value give a
"ypath" (whatever that is exactly), set a value, handle possible
conversions (e.g. json&amp;lt;-&amp;gt;yaml), etc.

I have a ruby script that I created that is basically like this called `yc`
(https://github.com/rubyworks/yc). But I don't think it should be official
though (at the very least b/c its not really complete). For an official
tool it would probably be best if it is written in C (or perhaps it's okay
to use Node.js Javascript since it is becoming so ubiquitous?).

                  trans.
------------------------------------------------------------------------------
LogMeIn Rescue: Anywhere, Anytime Remote support for IT. Free Trial
Remotely access PCs and mobile devices and provide instant support
Improve your efficiency, and focus on delivering more value-add services
Discover what IT Professi&lt;/pre&gt;</description>
    <dc:creator>Trans</dc:creator>
    <dc:date>2012-12-07T15:52:24</dc:date>
  </item>
  <item rdf:about="http://comments.gmane.org/gmane.text.yaml.general/3745">
    <title>PyYAML multi-line strings</title>
    <link>http://comments.gmane.org/gmane.text.yaml.general/3745</link>
    <description>&lt;pre&gt;Hello,

We (Pyrseas project) are trying to deal with text returned by PostgreSQL
representing either SQL views or functions (stored procedures).  Until
now, the text was retrieved from the database into a Python string and
then passed to yaml.dump.  The output usually ended up as quoted or
unquoted strings, e.g.,

# function
    source: SELECT $1 + $1;
# view
    definition: SELECT DISTINCT product.product_id,
product.product_code, product.product_description
      FROM (warehouse.inventory JOIN product.product USING (product_id));
# or
    definition: " SELECT DISTINCT product.product_id,
product.product_code, product.product_description\n\
      \   FROM warehouse.inventory\n   JOIN product.product USING
(product_id);"

The first view was fetched in "raw" format, i.e., as a single line, and
apparently the line break before the "FROM" is just a fortunate
coincidence.  The second view was requested "prettified" so the actual
value in Python looks like:

def = """SELECT DISTINCT product.product_id, product.pr&lt;/pre&gt;</description>
    <dc:creator>Joe Abbate</dc:creator>
    <dc:date>2012-11-28T22:26:04</dc:date>
  </item>
  <item rdf:about="http://comments.gmane.org/gmane.text.yaml.general/3742">
    <title>YAML Implentation Guidelines</title>
    <link>http://comments.gmane.org/gmane.text.yaml.general/3742</link>
    <description>&lt;pre&gt;Is the google-group mirror still broken? Did any one else receive this
post? I have replicated below:

I was thinking that it would be a very a good idea to create an offical
YAML Implementation Guide, which could serve as a set of guidelines
for implementation developers. I am not qualified to write such a document
myself, so I can probably only help with surface level details, e.g. proof
reading, etc. But I think it is important. So I want to try to find a way
to encourage those who are qualified to work on it. Of all the people I
know I imagine Oren and Kirill Simonov (the creator of libYAML) might be
the best qualified. What can I do to help this happen?

Also, let me explain how I came to this quest. I use YAML almost
exclusively via Ruby. And Ruby's implementation, Psych, which is build on
top of libYAML, lacks what I consider an important feature for any "LAMP"
language implementation. Namely, it loads arbitrary types without error but
provides no way to access the type tag. e.g.

    YAML.load &amp;lt;&amp;lt;-HER&lt;/pre&gt;</description>
    <dc:creator>Trans</dc:creator>
    <dc:date>2012-11-26T00:07:26</dc:date>
  </item>
  <item rdf:about="http://comments.gmane.org/gmane.text.yaml.general/3741">
    <title>YAML Implentation Guide</title>
    <link>http://comments.gmane.org/gmane.text.yaml.general/3741</link>
    <description>&lt;pre&gt;I was thinking that it would be a very a good idea to create an offical 
YAML Implementation Guide, which could serve as a set of guidelines 
for implementation developers. I am not qualified to write such a document 
myself, so I can probably only help with surface level details, e.g. proof 
reading, etc. But I think it is important. So I want to try to find a way 
to encourage those who are qualified to work on it. Of all the people I 
know I imagine Oren and Kirill Simonov (the creator of libYAML) might be 
the best qualified. What can I do to help this happen?

Also, let me explain how I came to this quest. I use YAML almost 
exclusively via Ruby. And Ruby's implementation, Psych, which is build on 
top of libYAML, lacks what I consider an important feature for any "LAMP" 
language implementation. Namely, it loads arbitrary types without error but 
provides no way to access the type tag. e.g.

    YAML.load &amp;lt;&amp;lt;-HERE
      --- !foo
      a: 1
      b: 2
    HERE

This returns a regular old Hash `{'a'=&amp;gt;1, '&lt;/pre&gt;</description>
    <dc:creator>Trans</dc:creator>
    <dc:date>2012-11-23T17:51:12</dc:date>
  </item>
  <item rdf:about="http://comments.gmane.org/gmane.text.yaml.general/3739">
    <title>floating point regexp</title>
    <link>http://comments.gmane.org/gmane.text.yaml.general/3739</link>
    <description>&lt;pre&gt;Hi,

The regexp for base 10 floating point values listed on this page:

  http://yaml.org/type/float.html

Says:

  [-+]?([0-9][0-9_]*)?\.[0-9.]*([eE][-+][0-9]+)? (base 10)

This regexp allows any number of dots in a row to be a valid base 10
float (for example "." or ".." or "....").  Shouldn't this regexp at
least be:

  [-+]?([0-9][0-9_]*)?\.[0-9]*([eE][-+][0-9]+)? (base 10)

Or am I missing something? (I realize the above regexp would match "."
as a valid float, but what are you going to do? ;-) ).

Thanks for your time.

&lt;/pre&gt;</description>
    <dc:creator>Aaron Patterson</dc:creator>
    <dc:date>2012-11-17T02:58:40</dc:date>
  </item>
  <item rdf:about="http://comments.gmane.org/gmane.text.yaml.general/3738">
    <title>Python tool for sharing-preserving transformations</title>
    <link>http://comments.gmane.org/gmane.text.yaml.general/3738</link>
    <description>&lt;pre&gt;Hi YAML users,

I'd like to share a small general-purpose Python function that I've 
written a couple of months ago. It can be used to perform custom 
transformations across a YAML document, such as

- reversing all sequences
- capitalizing all strings
- changing mappings with multiple entries into sequences of one-entry 
mappings

while preserving sharing (aliases). The first variant of the function is 
easier to use but does not support cyclic structures; the second variant 
does support them, but is a bit harder to understand.

http://code.activestate.com/recipes/578117-sharing-aware-tree-transformations/
http://code.activestate.com/recipes/578118-cycle-aware-tree-transformations/

Cheers,
Sander Evers

------------------------------------------------------------------------------
LogMeIn Central: Instant, anywhere, Remote PC access and management.
Stay in control, update software, and manage PCs from one command center
Diagnose problems and improve visibility into emerging IT issues
Automate, monitor and&lt;/pre&gt;</description>
    <dc:creator>Sander Evers</dc:creator>
    <dc:date>2012-11-06T14:42:00</dc:date>
  </item>
  <item rdf:about="http://comments.gmane.org/gmane.text.yaml.general/3736">
    <title>Progress of YAML2</title>
    <link>http://comments.gmane.org/gmane.text.yaml.general/3736</link>
    <description>&lt;pre&gt;Hi, Daniel here,
I've been following this mailing list for quite some time, I'm currently
toying with a YAML parser for Fantom (a rather obscure language), and I'm
wondering how far is YAML2 specification? Should I try to make such a
parser if YAML2 is coming soon? From what I've seen YAML2 seems, at least
in theory, superior to current specs. What would be the best course of
action? Make a 1.2 parser and then add 2.0 features?

Truly curious,
Daniel Fath
------------------------------------------------------------------------------
LogMeIn Central: Instant, anywhere, Remote PC access and management.
Stay in control, update software, and manage PCs from one command center
Diagnose problems and improve visibility into emerging IT issues
Automate, monitor and manage. Do more in less time with Central
http://p.sf.net/sfu/logmein12331_d2d_______________________________________________
Yaml-core mailing list
Yaml-core-5NWGOfrQmneRv+LV9MX5uipxlwaOVQ5f&amp;lt; at &amp;gt;public.gmane.org
https://lists.sourceforge.net/lists/listinfo/y&lt;/pre&gt;</description>
    <dc:creator>Daniel Fath</dc:creator>
    <dc:date>2012-11-05T08:51:14</dc:date>
  </item>
  <item rdf:about="http://comments.gmane.org/gmane.text.yaml.general/3734">
    <title>An Idea for Aliases</title>
    <link>http://comments.gmane.org/gmane.text.yaml.general/3734</link>
    <description>&lt;pre&gt;Greetings,

I had an idea today. It probably would apply to YAML2 more than YAML. I
just wanted to throw it out there, and see if people can shoot it down.

The idea is to turn aliases into plain scalars, and the normal convention
would be to load them as references to anchors. So things work as before
under normal dump/load.

Thus * is no longer a special syntax char and can start any plain scalar.

This might be extended as the normal way to do other kinds of fancy
impliciting like file includes:

content: *include file.yaml

Whether it gets used in new ways or not, I just think that *foo can be
parsed as an implicit scalar. Can people see holes in that logic?

Ingy
------------------------------------------------------------------------------
LogMeIn Central: Instant, anywhere, Remote PC access and management.
Stay in control, update software, and manage PCs from one command center
Diagnose problems and improve visibility into emerging IT issues
Automate, monitor and manage. Do more in less time with Cent&lt;/pre&gt;</description>
    <dc:creator>Ingy dot Net</dc:creator>
    <dc:date>2012-11-05T05:37:17</dc:date>
  </item>
  <item rdf:about="http://comments.gmane.org/gmane.text.yaml.general/3730">
    <title>unmarshalling using yaml.dump doesn't maintain properformat (PyYAML)</title>
    <link>http://comments.gmane.org/gmane.text.yaml.general/3730</link>
    <description>&lt;pre&gt;Hi list,
I am using the PyYAML implementation for yaml (They don't have their own
mailing list, so I'm bringing this question here. I hope some folks are
familiar with it and can assist.

I have the following yaml doc:
---
instance:
     id: i-1234567
     saltId: APPSRV-X
     grains:
       roles:
         - webserver
         - php
       environment: X

I then try to dump it from one file to another, there are multiple yaml
docs in this file, and I am picking one doc and copying it to another file
basically.

Here is the code I used to do it:
https://gist.github.com/3941410

This is the resulting output:

id: APPSRV-X
environment: X
roles: [webserver, php]

For some reason it doesn't maintain it's structure, and I cannot figure out
how to keep it.

I tried changing the line with
            yaml.dump(configDict['instance']['grains'], TEST_CONFIG_FILE)


to
            yaml.dump(configDict['instance']['id'], TEST_CONFIG_FILE)


and the output get's even stranger:
id: APPSRV-X
i-1234567
...

any help is ap&lt;/pre&gt;</description>
    <dc:creator>Zippy Zeppoli</dc:creator>
    <dc:date>2012-10-23T20:45:06</dc:date>
  </item>
  <item rdf:about="http://comments.gmane.org/gmane.text.yaml.general/3725">
    <title>[Trac] DatabaseError: database disk image is malformed</title>
    <link>http://comments.gmane.org/gmane.text.yaml.general/3725</link>
    <description>&lt;pre&gt;Hi,

I'm trying to submit comment on a ticket or submit a ticket at
http://pyyaml.org/
and getting this:

=============
Oops…
Trac detected an internal error:

DatabaseError: database disk image is malformed

There was an internal error in Trac. It is recommended that you inform
your local Trac administrator and give him all the information he
needs to reproduce the issue.

To that end, you could a ticket.

The action that triggered the error was:

POST: /ticket/208

TracGuide — The Trac User and Administration Guide
=============

Best regards,
&lt;/pre&gt;</description>
    <dc:creator>Mateusz Loskot</dc:creator>
    <dc:date>2012-10-20T00:17:24</dc:date>
  </item>
  <textinput rdf:about="http://search.gmane.org/?group=$group=gmane.text.yaml.general">
    <title>Search Engine</title>
    <description>Search the mailing list at Gmane</description>
    <name>query</name>
    <link>http://search.gmane.org/?group=$group=gmane.text.yaml.general</link>
  </textinput>
</rdf:RDF>
