Module: RIO::IF::YAML

Included in:
Rio
Defined in:
lib/rio/if/yaml.rb

Instance Method Summary collapse

Instance Method Details

#document(*args, &block) ⇒ Object

Select a single yaml document. See #documents, #line and #yaml.



148
 
# File 'lib/rio/if/yaml.rb', line 148

def document(*args,&block) target.document(*args,&block); self end

#documents(*selectors, &block) ⇒ Object

Select documents from a YAML file. See #yaml and RIO::Doc::INTRO



137
 
# File 'lib/rio/if/yaml.rb', line 137

def documents(*selectors,&block) target.documents(*selectors,&block); self end

#dump(obj) ⇒ Object

Alias for #putobj!



189
 
# File 'lib/rio/if/yaml.rb', line 189

def dump(obj) target.dump(obj); self end

#getobj ⇒ Object

Calls YAML.load.

Loads a single YAML object from the stream referenced by the Rio

rio('database.yml').yaml.getobj

See #yaml and RIO::Doc::INTRO



159
 
# File 'lib/rio/if/yaml.rb', line 159

def getobj() target.getobj() end

#load ⇒ Object

Calls YAML.load.

Loads a single YAML object from the stream referenced by the Rio

rio('database.yml').yaml.load

See #yaml and RIO::Doc::INTRO



169
 
# File 'lib/rio/if/yaml.rb', line 169

def load() target.load() end

#object(*args, &block) ⇒ Object

Select a single object. See #objects, #line and #yaml.



144
 
# File 'lib/rio/if/yaml.rb', line 144

def object(*args,&block) target.object(*args,&block); self end

#objects(*selectors, &block) ⇒ Object

Select objects from a YAML file. See #yaml and RIO::Doc::INTRO



129
 
# File 'lib/rio/if/yaml.rb', line 129

def objects(*selectors,&block) target.objects(*selectors,&block); self end

#putobj(obj) ⇒ Object

Calls YAML.dump, leaving the Rio open.



176
 
# File 'lib/rio/if/yaml.rb', line 176

def putobj(obj) target.putobj(obj); self end

#putobj!(obj) ⇒ Object

Dumps an object to a Rio as with #putobj, and closes the Rio.

rio('afile.yaml').yaml.putobj!(anobject)

is identical to 

rio('afile.yaml').yaml.putobj(anobject).close



186
 
# File 'lib/rio/if/yaml.rb', line 186

def putobj!(obj) target.putobj!(obj); self end

#skipdocuments(*selectors, &block) ⇒ Object

Reject documents from a YAML file. Calls #skiprows. See #yaml and RIO::Doc::INTRO



141
 
# File 'lib/rio/if/yaml.rb', line 141

def skipdocuments(*selectors,&block) target.skipdocuments(*selectors,&block); self end

#skipobjects(*selectors, &block) ⇒ Object

Reject objects from a YAML file. Calls #skiprecords. See #yaml and RIO::Doc::INTRO



133
 
# File 'lib/rio/if/yaml.rb', line 133

def skipobjects(*selectors,&block) target.skipobjects(*selectors,&block); self end

#yaml(&block) ⇒ Object

Puts a Rio in YAML mode.

Rio uses the YAML class from the Ruby standard library to provide support for reading and writing YAML files. Normally using (skip)records is identical to (skip)lines because while records only selects and does not specify the record-type, lines is the default.

The YAML extension distingishes between items selected using #records, #rows and #lines. Rio returns objects loaded via YAML#load when records or #objects is used; returns the YAML text as a String when rows or #documents is used; and returns lines as Strings as normal when lines is used. records is the default.

To read a single YAML document, Rio provides #getobj and #load. For example, consider the following partial ‘database.yml’ from the rails distribution:

development:
  adapter: mysql
  database: rails_development

test:
  adapter: mysql
  database: rails_test

To get the object represented in the yaml file:

rio('database.yml').yaml.load
   ==>{"development"=>{"adapter"=>"mysql", "database"=>"rails_development"}, 
       "test"=>{"adapter"=>"mysql", "database"=>"rails_test"}}

Or one could read parts of the file like so:

rio('database.yml').yaml.getobj['development']['database']
   ==>"rails_development"

Single objects can be written using #putobj and #putobj! which is aliased to #dump

anobject = {
  'production' => {
    'adapter' => 'mysql',
    'database' => 'rails_production',
  }
}
rio('afile.yaml').yaml.dump(anobject)

Single objects can be written using #putrec (aliased to #putobj and #dump)

rio('afile.yaml').yaml.putobj(anobject)

Single objects can be loaded using #getrec (aliased to #getobj and #load)

anobject = rio('afile.yaml').yaml.getobj

A Rio in yaml-mode is just like any other Rio. And all the things you can do with any Rio come for free. They can be iterated over using #each and read into an array using #[] just like any other Rio. All the selection criteria are identical also.

Get the first three objects into an array:

array_of_objects = rio('afile.yaml').yaml[0..2]

Iterate over only YAML documents that are a kind_of ::Hash:

rio('afile.yaml').yaml(::Hash) {|ahash| ...}

This takes advantage of the fact that the default for matching records is ===

Selecting records using a Proc can be used as normal:

anarray = rio('afile.yaml').yaml(proc{|anobject| ...}).to_a

One could even use the copy operator to convert a CSV file to a YAML representation of the same data:

rio('afile.yaml').yaml < rio('afile.csv').csv



118
119
120
121
 
# File 'lib/rio/if/yaml.rb', line 118

def yaml(&block) 
  target.yaml(&block); 
  self 
end

#yaml? ⇒ Boolean

Queries if the Rio is in yaml-mode. See #yaml

Returns:

  • (Boolean) 


125
 
# File 'lib/rio/if/yaml.rb', line 125

def yaml?() target.yaml? end