mkrf 0.1.0

data/test/sample_files/syck-0.55/ext/ruby/yts/YtsErrorTests.yml

@@ -0,0 +1,23 @@
+--- 
+test: Missing value for hash item 
+brief: | 
+    Third item in this hash doesn't have a value 
+yaml: | 
+    okay: value 
+    also okay: ~ 
+    causes error because no value specified 
+    last key: value okay here too 
+python-error: causes error because no value specified 
+ 
+--- 
+test: Not indenting enough 
+brief: | 
+    There was a bug in PyYaml where it was off by one 
+    in the indentation check.  It was allowing the YAML  
+    below. 
+# This is actually valid YAML now. Someone should tell showell. 
+yaml: | 
+    foo: 
+    firstline: 1 
+    secondline: 2 
+python-error: Inadequate indentation 

data/test/sample_files/syck-0.55/ext/ruby/yts/YtsFlowCollections.yml

@@ -0,0 +1,73 @@
+--- 
+test: Simple Inline Array 
+brief: > 
+    Sequences can be contained on a 
+    single line, using the inline syntax. 
+    Separate each entry with commas and 
+    enclose in square brackets. 
+yaml: | 
+    ---  
+    seq: [ a, b, c ] 
+python: | 
+    [ 
+        { 'seq': [ 'a', 'b', 'c' ] } 
+    ] 
+ruby: | 
+    { 'seq' => [ 'a', 'b', 'c' ] } 
+ 
+--- 
+test: Simple Inline Hash 
+brief: > 
+    Mapping can also be contained on 
+    a single line, using the inline 
+    syntax.  Each key-value pair is 
+    separated by a colon, with a comma 
+    between each entry in the mapping. 
+    Enclose with curly braces. 
+yaml: | 
+    --- 
+    hash: { name: Steve, foo: bar } 
+python: | 
+    [ 
+        { 'hash': {'name': 'Steve', 'foo': 'bar'} } 
+    ] 
+ruby: | 
+    { 'hash' => { 'name' => 'Steve', 'foo' => 'bar' } } 
+ 
+--- 
+test: Multi-line Inline Collections 
+brief: > 
+    Both inline sequences and inline mappings 
+    can span multiple lines, provided that you 
+    indent the additional lines. 
+yaml: | 
+    languages: [ Ruby, 
+                 Perl, 
+                 Python ] 
+    websites: { YAML: yaml.org, 
+                Ruby: ruby-lang.org, 
+                Python: python.org, 
+                Perl: use.perl.org } 
+ruby: | 
+    { 'languages' => [ 'Ruby', 'Perl', 'Python' ], 
+      'websites' => { 
+        'YAML' => 'yaml.org', 
+        'Ruby' => 'ruby-lang.org', 
+        'Python' => 'python.org', 
+        'Perl' => 'use.perl.org'  
+      } 
+    } 
+--- 
+test: Commas in Values 
+brief: > 
+    List items in collections are delimited by commas, but  
+    there must be a space after each comma.  This allows you 
+    to add numbers without quoting. 
+yaml: | 
+    attendances: [ 45,123, 70,000, 17,222 ] 
+python: | 
+    [ 
+        {'attendances': [ 45123, 70000, 17222 ]} 
+    ] 
+ruby: | 
+    { 'attendances' => [ 45123, 70000, 17222 ] } 

data/test/sample_files/syck-0.55/ext/ruby/yts/YtsFoldedScalars.yml

@@ -0,0 +1,215 @@
+--- %YAML:1.0 
+test: Single ending newline 
+brief: > 
+    A pipe character, followed by an indented
+    block of text is treated as a literal
+    block, in which newlines are preserved
+    throughout the block, including the final
+    newline.
+yaml: | 
+    ---
+    this: |
+        Foo
+        Bar
+
+ruby: | 
+    { 'this' => "Foo\nBar\n" } 
+python: | 
+    [  
+        { 'this': "Foo\nBar\n" } 
+    ] 
+--- 
+test: The '+' indicator 
+brief: > 
+    The '+' indicator says to keep newlines at the end of text 
+    blocks. 
+yaml: |
+    normal: |
+      extra new lines not kept
+
+    preserving: |+
+      extra new lines are kept
+
+
+    dummy: value
+ruby: | 
+    { 
+        'normal' => "extra new lines not kept\n", 
+        'preserving' => "extra new lines are kept\n\n\n", 
+        'dummy' => 'value' 
+    } 
+python: | 
+    [ { 
+        'normal': "extra new lines not kept\n", 
+        'preserving': "extra new lines are kept\n\n\n", 
+        'dummy': 'value' 
+    } ] 
+--- 
+test: Three trailing newlines in literals 
+brief: > 
+    To give you more control over how space 
+    is preserved in text blocks, YAML has 
+    the keep '+' and chomp '-' indicators. 
+    The keep indicator will preserve all 
+    ending newlines, while the chomp indicator 
+    will strip all ending newlines. 
+yaml: |
+    clipped: |
+        This has one newline.
+
+
+
+    same as "clipped" above: "This has one newline.\n"
+
+    stripped: |-
+        This has no newline.
+
+
+
+    same as "stripped" above: "This has no newline."
+
+    kept: |+
+        This has four newlines.
+
+
+
+    same as "kept" above: "This has four newlines.\n\n\n\n"
+ruby: |
+    {  
+      'clipped' => "This has one newline.\n", 
+      'same as "clipped" above' => "This has one newline.\n", 
+      'stripped' => 'This has no newline.', 
+      'same as "stripped" above' => 'This has no newline.', 
+      'kept' => "This has four newlines.\n\n\n\n", 
+      'same as "kept" above' => "This has four newlines.\n\n\n\n" 
+    } 
+not_yet_in_python: | 
+    [ 
+    {  
+      'clipped': "This has one newline.\n", 
+      'same as "clipped" above': "This has one newline.\n", 
+      'stripped': 'This has no newline.', 
+      'same as "stripped" above': 'This has no newline.', 
+      'kept': "This has four newlines.\n\n\n\n", 
+      'same as "kept" above': "This has four newlines.\n\n\n\n" 
+    } 
+    ] 
+ 
+--- 
+test: Extra trailing newlines with spaces
+brief: >
+    Normally, only a single newline is kept 
+    from the end of a literal block, unless the 
+    keep '+' character is used in combination 
+    with the pipe.  The following example 
+    will preserve all ending whitespace 
+    since the last line of both literal blocks 
+    contains spaces which extend past the indentation 
+    level. 
+yaml: |
+    ---
+    this: |
+        Foo
+
+          
+    kept: |+
+        Foo
+
+          
+ruby: | 
+    { 'this' => "Foo\n\n  \n",  
+      'kept' => "Foo\n\n  \n" } 
+ 
+--- 
+test: Folded Block in a Sequence 
+brief: > 
+    A greater-then character, followed by an indented 
+    block of text is treated as a folded block, in 
+    which lines of text separated by a single newline 
+    are concatenated as a single line. 
+yaml: | 
+    ---
+    - apple
+    - banana
+    - >
+        can't you see
+        the beauty of yaml?
+        hmm
+    - dog
+python: | 
+    [ 
+        [ 
+            'apple',  
+            'banana',  
+            "can't you see the beauty of yaml? hmm\n", 
+            'dog' 
+        ] 
+    ] 
+ruby: | 
+    [ 
+        'apple',  
+        'banana',  
+        "can't you see the beauty of yaml? hmm\n", 
+        'dog' 
+    ] 
+--- 
+test: Folded Block as a Mapping Value 
+brief: > 
+    Both literal and folded blocks can be 
+    used in collections, as values in a  
+    sequence or a mapping. 
+yaml: |
+    ---
+    quote: >
+        Mark McGwire's
+        year was crippled
+        by a knee injury.
+    source: espn
+python: |
+    [ 
+        {  
+            'quote': "Mark McGwire's year was crippled by a knee injury.\n", 
+            'source': 'espn' 
+        } 
+    ] 
+ruby: | 
+    {  
+        'quote' => "Mark McGwire's year was crippled by a knee injury.\n", 
+        'source' => 'espn' 
+    } 
+ 
+--- 
+test: Three trailing newlines in folded blocks 
+brief: > 
+    The keep and chomp indicators can also 
+    be applied to folded blocks. 
+yaml: | 
+    clipped: >
+        This has one newline.
+
+
+
+    same as "clipped" above: "This has one newline.\n" 
+ 
+    stripped: >-
+        This has no newline.
+
+
+
+    same as "stripped" above: "This has no newline."
+
+    kept: >+
+        This has four newlines.
+
+
+
+    same as "kept" above: "This has four newlines.\n\n\n\n"
+ruby: |
+    {  
+      'clipped' => "This has one newline.\n", 
+      'same as "clipped" above' => "This has one newline.\n", 
+      'stripped' => 'This has no newline.', 
+      'same as "stripped" above' => 'This has no newline.', 
+      'kept' => "This has four newlines.\n\n\n\n", 
+      'same as "kept" above' => "This has four newlines.\n\n\n\n" 
+    } 

data/test/sample_files/syck-0.55/ext/ruby/yts/YtsNullsAndEmpties.yml

@@ -0,0 +1,66 @@
+--- %YAML:1.0 
+test: Empty Sequence 
+brief: > 
+    You can represent the empty sequence 
+    with an empty inline sequence. 
+yaml: | 
+    empty: [] 
+python: | 
+    [ 
+        { 'empty': [] } 
+    ] 
+ruby: | 
+    { 'empty' => [] } 
+ 
+--- 
+test: Empty Mapping 
+brief: > 
+    You can represent the empty mapping 
+    with an empty inline mapping. 
+yaml: | 
+    empty: {} 
+python: | 
+    [ 
+        { 'empty': {} } 
+    ] 
+ruby: | 
+    { 'empty' => {} } 
+ 
+--- 
+test: Empty Sequence as Entire Document 
+yaml: | 
+    --- [] 
+python: | 
+    [ [] ] 
+ruby: | 
+    [] 
+ 
+--- 
+test: Empty Mapping as Entire Document 
+yaml: | 
+    --- {} 
+python: | 
+    [ {} ] 
+ruby: | 
+    {} 
+ 
+---  
+test: Null as Document 
+yaml: | 
+    --- ~ 
+python: | 
+    [ None ] 
+ruby: | 
+    nil 
+ 
+--- 
+test: Empty String 
+brief: > 
+    You can represent an empty string 
+    with a pair of quotes. 
+yaml: | 
+    --- '' 
+python: | 
+    [ '' ] 
+ruby: | 
+    '' 

data/test/sample_files/syck-0.55/ext/ruby/yts/YtsRubyTests.yml

@@ -0,0 +1,182 @@
+--- %YAML:1.0 
+test: Symbols 
+brief: > 
+    Ruby Symbols can be simply serialized using 
+    the !ruby/symbol transfer method, or the 
+    abbreviated !ruby/sym. 
+yaml: | 
+    simple symbol: !ruby/symbol Simple 
+    shortcut syntax: !ruby/sym Simple 
+    symbols in seqs: 
+      - !ruby/symbol ValOne 
+      - !ruby/symbol ValTwo 
+      - !ruby/symbol ValThree 
+    symbols in maps: 
+      - !ruby/symbol MapKey: !ruby/symbol MapValue 
+ruby: | 
+    { 'simple symbol' => :Simple, 
+      'shortcut syntax' => :Simple, 
+      'symbols in seqs' => [ :ValOne, :ValTwo, :ValThree ], 
+      'symbols in maps' => [ { :MapKey => :MapValue } ]
+    } 
+ 
+--- 
+test: Ranges 
+brief: > 
+    Ranges are serialized with the !ruby/range 
+    type family. 
+yaml: | 
+    normal range: !ruby/range 10..20 
+    exclusive range: !ruby/range 11...20 
+    negative range: !ruby/range -1..-5 
+    ? !ruby/range 0..40 
+    : range as a map key 
+ruby: | 
+    { 'normal range' => (10..20), 
+      'exclusive range' => (11...20), 
+      'negative range' => (-1..-5), 
+      (0..40) => 'range as a map key' 
+    } 
+ 
+--- 
+test: Regexps 
+brief: > 
+    Regexps may be serialized to YAML, both its 
+    syntax and any modifiers. 
+yaml: | 
+    case-insensitive: !ruby/regexp "/George McFly/i" 
+    complex: !ruby/regexp "/\\A\"((?:[^\"]|\\\")+)\"/" 
+    simple: !ruby/regexp '/a.b/' 
+ruby: | 
+    { 'simple' => /a.b/, 'complex' => /\A"((?:[^"]|\")+)"/, 
+      'case-insensitive' => /George McFly/i } 
+ 
+--- 
+test: Struct class 
+brief: > 
+    The Ruby Struct class is registered as a YAML 
+    builtin type through Ruby, so it can safely  
+    be serialized.  To use it, first make sure you 
+    define your Struct with Struct::new.  Then, 
+    you are able to serialize with Struct#to_yaml 
+    and unserialize from a YAML stream. 
+yaml: | 
+    --- !ruby/struct:BookStruct 
+      author: Yukihiro Matsumoto 
+      title: Ruby in a Nutshell 
+      year: 2002 
+      isbn: 0-596-00214-9 
+ruby-setup: | 
+    book_struct = Struct::new( "BookStruct", :author, :title, :year, :isbn ) 
+ruby: | 
+    book_struct.new( "Yukihiro Matsumoto", "Ruby in a Nutshell", 2002, "0-596-00214-9" ) 
+ 
+--- 
+test: Nested Structs 
+brief: > 
+    As with other YAML builtins, you may nest the 
+    Struct inside of other Structs or other data 
+    types. 
+yaml: | 
+    - !ruby/struct:FoodStruct 
+      name: Nachos 
+      ingredients: 
+        - Mission Chips 
+        - !ruby/struct:FoodStruct 
+          name: Tostitos Nacho Cheese 
+          ingredients: 
+            - Milk and Enzymes 
+            - Jack Cheese 
+            - Some Volatile Chemicals 
+          taste: Angelic 
+        - Sour Cream 
+      taste: Zesty 
+    - !ruby/struct:FoodStruct 
+      name: Banana Cream Pie 
+      ingredients: 
+        - Bananas 
+        - Creamy Stuff 
+        - And Such 
+      taste: Puffy 
+ruby-setup: | 
+    food_struct = Struct::new( "FoodStruct", :name, :ingredients, :taste ) 
+ruby: | 
+    [ 
+      food_struct.new( 'Nachos', [ 'Mission Chips', 
+        food_struct.new( 'Tostitos Nacho Cheese', [ 'Milk and Enzymes', 'Jack Cheese', 'Some Volatile Chemicals' ], 'Angelic' ), 
+        'Sour Cream' ], 'Zesty' ), 
+      food_struct.new( 'Banana Cream Pie', [ 'Bananas', 'Creamy Stuff', 'And Such' ], 'Puffy' ) 
+    ] 
+ 
+--- 
+test: Objects 
+brief: > 
+    YAML has generic support for serializing objects 
+    from any class available in Ruby.  If using the 
+    generic object serialization, no extra code is 
+    needed. 
+yaml: | 
+    --- !ruby/object:Zoolander 
+      name: Derek 
+      look: Blue Steel 
+ruby-setup: | 
+    class Zoolander 
+      attr_accessor :name, :look 
+      def initialize( look ) 
+        @name = "Derek" 
+        @look = look 
+      end 
+      def ==( z ) 
+        self.name == z.name and self.look == z.look 
+      end 
+    end 
+ruby: | 
+    Zoolander.new( "Blue Steel" ) 
+ 
+--- 
+test: Extending Kernel::Array 
+brief: >  
+    When extending the Array class, your instances 
+    of such a class will dump as YAML sequences, 
+    tagged with a class name. 
+yaml: | 
+    --- !ruby/array:MyArray 
+    - jacket 
+    - sweater 
+    - windbreaker 
+ruby-setup: | 
+    class MyArray < ::Array; end 
+ruby: | 
+    outerwear = MyArray.new 
+    outerwear << 'jacket' 
+    outerwear << 'sweater' 
+    outerwear << 'windbreaker' 
+    outerwear 
+ 
+--- 
+test: Extending Kernel::Hash 
+brief: > 
+    When extending the Hash class, your instances 
+    of such a class will dump as YAML maps, tagged 
+    with a class name. 
+yaml: | 
+    --- !ruby/hash:MyHash 
+    Black Francis: Frank Black 
+    Kim Deal: Breeders 
+    Joey Santiago: Martinis 
+ruby-setup: | 
+    # Note that the @me attribute isn't dumped 
+    # because the default to_yaml is trained 
+    # to dump as a regular Hash. 
+    class MyHash < ::Hash 
+      attr_accessor :me 
+      def initialize 
+        @me = "Why" 
+      end 
+    end 
+ruby: | 
+    pixies = MyHash.new 
+    pixies['Black Francis'] = 'Frank Black' 
+    pixies['Kim Deal'] = 'Breeders' 
+    pixies['Joey Santiago'] = 'Martinis' 
+    pixies