Module: RIO::IF::YAML

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

Instance Method Summary collapse

Instance Method Details

#documents(*selectors, &block) ⇒ Object

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



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

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

#dump(obj) ⇒ Object

Alias for IF::YAML#putobj!



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

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



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

def getobj() target.getobj() end

#load ⇒ Object

Alias for #getobj



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

def load() target.load() end

#objects(*selectors, &block) ⇒ Object

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



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

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

#putobj(obj) ⇒ Object

Calls YAML.dump, leaving the Rio open.



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

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

#putobj!(obj) ⇒ Object

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

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

is identical to 

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



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

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



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

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

#skipobjects(*selectors, &block) ⇒ Object

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



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

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 IF::GrandeStream#records, IF::GrandeStream#rows and IF::GrandeStream#lines. Rio returns objects loaded via YAML#load when records is used; returns the YAML text as a String when rows is used; and returns lines as Strings as normal when lines is used. records is the default. In yaml-mode, (skip)records can be called as (skip)objects and (skip)rows can be called as (skip)documents

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 IF::Grande#putrec (aliased to IF::YAML#putobj and IF::YAML#dump)

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

Single objects can be loaded using IF::Grande#getrec (aliase to IF::Grande#getobj and IF::YAML#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 IF::Grande#each and read into an array using IF::Grande#[] 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



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

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

#yaml? ⇒ Boolean

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

Returns:

  • (Boolean) 


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

def yaml?() target.yaml? end