YAML Ain't Markup Language

I have prepared a hash called people that is ready to be saved as a
yaml file.
The docs are bit shabby on how to just add a hash but I figured it was
something like this:

y = YAML::Store.new( "people.yml", :indent => 2 )
y.transaction { y[] = people) }

When I check the people.yml I get ---{}
How do I get this to work?


Monsterbox Productions
putting small businesses on-line

Andrew Brown
web-developer

andrew@...

Just a simple beginning, but compiles, and works.

Prints out status line for each yaml element "constructed".

Useful for me, so perhaps useful for others...

zen

-- 
Homepage: http://www.SoulSound.net -- Free Australia: http://www.UPMART.org
Please respect the confidentiality of this email as sensibly warranted.

Can any yaml document be represented fully in flow style?
(with { }  for hashes and [ ] for arrays at all levels)
I assume so, since JSON is a subset.

I ask because a blind programmer on another list mentioned that
braces and brackets are better than indentation when used with
a screen reader.

It should be possible to load one style and dump another,
but I was only able to emit flow style using a JSON Perl module.
What modules and tools should I recommend here?
(The original query was on a Perl list but tools in other languages
could be useful for this purpose).

Is there a longer indenting/flow equivalence example online?

Brad

-- 
  You cannot tell whether a person is good or bad by his vicissitudes in
  life. Good and bad fortune are matters of fate. Good and bad actions
  are Man's Way. Retribution of good and evil is taught simply as a moral
  lesson.                        -- Hagakure http://bereft.net/hagakure/

Hi Jeff,

Jeff Kowalczyk wrote:
>> I'm happy to report that Kirill's YamlLexer implementation was accepted
>> right away into pygments main mercurial repository.
> 
> See the current output at:
> 
> http://pygments.org/demo/?lang=yaml&sort=
> 
> YamlLexer example.yaml http://pygments.org/demo/810
> 
> YAML.org homepage YAML http://pygments.org/demo/809
> 
> View HTML source to see the currently-unstyled CSS class id's, e.g:
> 
> <span class="p-Indicator">-</span> <span class="l-Scalar-Plain">

Thank you for your efforts, Jeff!

I've noticed that plain scalars within flow collections are highlighted, 
but those outside [] or {} are not.  This is because for 
'plain-scalar-in-flow-context', the class Name.Variable is used while 
'plain-scalar-in-block-context' still uses Literal.Scalar.Plain.  Also 
escape codes got highlighted with String.Escape, but escape characters 
didn't.

Personally, I'll prefer to have all scalar text not to be highlighted at 
all.  Instead it would be most useful if the punctuation marks 
(indicators) are highlighted so that the document structure is emphasized.


Thanks,
Kirill

Hello all,

I am looking at how best to represent MARC[1] records in YAML.  My
thinking is following a couple of tracks: 1) exploring a (Perl)
MARC::File::YAML (or some such) module that reads a stream of YAML
documents and loads them as MARC::Record objects, and 2) defining a
workable set of (non-language-specific) routines that can process a
!!pairs[2] data structure directly. The latter because I think MARC records
can faithfully be represented as !!pairs of !!pairs.

The MARC issues aside, I have uploaded a couple of modules to cpan,
Data::Pairs[3] and--incidentally--Data::Omap[4] that are a stab at defining
this workable set of routines.  If you want to critique them, I'm all ears,
but primarily I want to ask if the namespaces "Data::Omap" and
"Data::Pairs" look reasonable.  I plan to register them at some point, but
want to pass them through a few gauntlets first.

Regards,

-- Brad

[1] http://www.loc.gov/marc/
[2] http://yaml.org/type/pairs.html
[3] http://search.cpan.org/~bbaxter/Data-Pairs-0.03/
[4] http://search.cpan.org/~bbaxter/Data-Omap-0.04/

Hello all,

Here's hoping I don't offend anyone in this list with a post using "XML" in
the title. :-D

There's a good reason, though: I've been working for a while on a generic
XSLT-driven XML-based document viewer called XMLEye, to which pretty much
any script that can print to standard output can plug into (i.e., Perl
programs). I made a while ago a plugin script (and some XSLT stylesheets) so
it could open YAML files. This way, XMLEye can be customized to browse
through some interesting YAML/JSON formats in the future, like Firefox
bookmarks or Django fixtures.

What this script does is basically parse the YAML 1.1/JSON file using the
YAML::XS Perl binding for libyaml and output the resulting data structure as
an XML file. The format is heavily inspired from the YAXML binding, with
some refinements. It has a suite of tests which perform a roundtrip
YAML->XML->YAML transformation (using an improved version of the YAXML XSLT
stylesheet) and make sure that parsing the original and regenerated YAML
files results in equal data structures.

Anchors are detected by filtering multiple references to the same memory
address. I don't know how to detect which one contained the original anchor
definition from the Perl data structure itself, but I think that's
irrelevant. Is it, though?

I've got more information on XMLEye and YAXML::Reverse under
http://wiki.shoyusauce.org. From there, you can get to the forge, which has
links to the SVN repository, some code snapshots and Ubuntu packages. I
recommend using the SVN version: I still haven't updated the Ubuntu packages
so they get YAML 1.1/JSON support rather than just YAML 1.0.

I'd like to hear your opinion on the way this is handled. Do you think I'm
missing something?

Cheers,
Antonio