yamldoc 0.0.1

data/.gitignore

@@ -0,0 +1,9 @@
+.DS_Store
+*.gem
+*.log
+*.sqlite3
+pkg/*
+coverage/*
+doc/*
+benchmarks/*
+

data/CHANGELOG.rdoc

@@ -0,0 +1,27 @@
+== 2.0.2 released 2009-08-22
+
+* Define methods during method_missing instead of during initialization. Allows for modification on the fly.
+
+== 2.0.0 released 2009-08-22
+
+* Less magic, instead of automatically defining a Settings constant, you should define your own constant. See the readme for an example.
+
+== 1.0.3 released 2009-04-23
+
+* Fix Settings initialized with a Hash to work with both symbol and string hash keys.
+
+== 1.0.2 released 2009-04-09
+
+* Call key? off of the self in the class level name method.
+
+== 1.0.1 released 2009-04-02
+
+* Inherit from hash.
+
+== 1.0.0 released 2008-12-05
+
+* Only define methods if we have settings.
+
+== 0.9.0 released 2008-10-30
+
+* Initial release

data/LICENSE

@@ -0,0 +1,21 @@
+Copyright (c) 2009 dreamcat4
+Copyright (c) 2008 Ben Johnson of Binary Logic (binarylogic.com)
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,98 @@
+= YamlDoc
+
+YamlDoc is a simple Yaml reader/writer solution that uses an ERB enabled YAML file. Yaml is represented as a Hash tree. Features include
+
+Autosave, object detection (modified in-place). Force uniform hash keys as String or Sym, dot notation for nested objects, and manual write for large files.
+
+== Install
+
+Install from gemcutter:
+
+  gem install yamldoc
+
+== Quickstart
+
+There are various ways to create 
+
+  class Settings < YamlDoc
+    self.filename = "file.yml"
+    self.autosave = true
+    ...
+  end
+  file = Settings.new
+
+Or
+
+  settings = YamlDoc.new("file.yml")
+
+Or
+
+  settings = YamlDoc.new :filename => "file.yml", :autosave => true
+
+== YmlDoc Methods
+
+In most cases the `:save` method is all you will need.
+
+  config.methods.inspect
+  => [:load, :save, :methods, :properties, :reload_hooks]
+
+`:load` will reload the existing file, or (with a parameter) merge the existing object  into the newly loaded file (and re-save it). So generally use `YamlDoc.new` to load a different file.
+
+== YmlDoc Properties
+
+  YamlDoc.defaults.inspect
+  => {:ymldoc_pfx=>"", :deep_clone=>false, :force_keys=>false, :key_type=>String, :autosave=>false, :object_detection=>false, :filename=>nil}
+
+== AutoYamlDoc Class
+
+Of course it's tempting to just turn everything on for easy access to yml settings file. So we've gone ahead and created an "everythin on" class.
+
+  AutoYamlDoc.defaults.inspect
+  => {:ymldoc_pfx=>"", :deep_clone=>false, :force_keys=>true, :key_type=>String, :autosave=>true, :object_detection=>true, :filename=>nil}
+
+  AutoYmlDoc.new("settings.yml")
+
+== Object Manipulation
+
+The deserialized Yaml object just a special kind of nested hash.
+
+  settings.a = "Somestring"
+  settings.b = [:label1,:label2,:label3]
+  settings.b[1].inspect
+  => :label2
+
+  settings.defaults.d = { "key1" => "val1", ... }
+  settings.defaults.key1
+  => "val1"
+
+  other_hash = { "key1" => 5 }
+  settings.merge! other_hash
+  settings.key1
+  => 5
+
+== Advanced yamldoc methods and properties
+
+  config.methods.inspect
+  => [:load, :save, :methods, :properties, :reload_hooks]
+
+You can rename the standard YmlDoc methods by setting the :ymldoc_pfx property. This is useful should any namespace clashes occur at the root (topmost) level of your yaml file. For example if we encountered a yaml file which has topmost nodes `save` and `:filename`. These are part of the YamlDoc API methods. So we use a `:ymldoc_pfx` to rename the YmlDoc object methods to something else. For example:
+
+  config.properties.inspect
+  => [:object_detection, :root_obj, :ymldoc_pfx, :force_keys, :deep_clone, :detection_hooks, :key_type, :autosave, :filename]
+
+  config.ymldoc_pfx = "yml_"
+  config.reload_hooks
+  config.yml_methods.inspect
+  => [:yml_load, :yml_save, :yml_methods, :yml_properties, :yml_reload_hooks]
+
+  config.save = "somestring"
+  config.save
+  => "somestring"
+
+  config.yml_save()
+  # file saved.
+
+== Copyright, License
+
+Copyright (c) 2009 dreamcat4
+Copyright (c) 2008 {Ben Johnson}[http://github.com/binarylogic] of {Binary Logic}[http://www.binarylogic.com], released under the MIT license 

data/Rakefile

@@ -0,0 +1,33 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "yamldoc"
+    gem.summary = "A simple solution for ERB enabled YAML file."
+    gem.email = "dreamcat4@gmail.com"
+    gem.homepage = "http://github.com/dreamcat4/yamldoc"
+    gem.authors = ["dreamcat4, Ben Johnson"]
+    gem.rubyforge_project = ""
+  end
+  Jeweler::RubyforgeTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
+end
+
+require 'spec/rake/spectask'
+Spec::Rake::SpecTask.new(:spec) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+Spec::Rake::SpecTask.new(:rcov) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :spec => :check_dependencies
+
+task :default => :spec

data/VERSION.yml

@@ -0,0 +1,4 @@
+--- 
+:patch: 1
+:major: 0
+:minor: 0

data/init.rb

@@ -0,0 +1 @@
+require File.dirname(__FILE__) + "/rails/init.rb"

data/lib/class_attributes.rb

@@ -0,0 +1,128 @@
+# class_attributes.rb - Class Attributes
+# A Feature-complete alternative to @@
+
+class Object
+  def deep_clone; Marshal::load(Marshal.dump(self)); end
+end
+
+module ClassAttributes
+
+  def cattr(*args, &block)
+    (class << self; self; end).class_eval do
+      attr_accessor *args
+    end
+    @cattr ||= []
+    @cattr.concat(args)
+  end
+
+  def iattr(*args, &block)
+    (class << self; self; end).class_eval do
+      attr_accessor *args
+    end
+    @iattr ||= []
+    @iattr.concat(args)
+  end
+
+  def oattr(*args, &block)
+    (class << self; self; end).class_eval do
+      attr_accessor *args
+    end
+    @oattr ||= []
+    @oattr.concat(args)
+  end
+
+  def oattr_i(*args, &block)
+    (class << self; self; end).class_eval do
+      attr_accessor *args
+    end
+    @oattr_i ||= []
+    @oattr_i.concat(args)
+  end
+
+  def co_attr(*args, &block)
+    cattr(*args,&block)
+    oattr(*args,&block)    
+  end
+
+  def co_attr_i(*args, &block)
+    iattr(*args,&block)
+    oattr_i(*args,&block)
+  end
+
+  alias_method :class_inherited_attribute_shared,                 :cattr
+  alias_method :class_inherited_attribute_independant,            :iattr
+
+  alias_method :object_inherited_attribute_shared,                :oattr
+  alias_method :object_inherited_attribute_independant,           :oattr_i
+
+  alias_method :class_and_object_shared_inherited_attribute,      :co_attr
+  alias_method :class_and_object_independant_inherited_attribute, :co_attr_i
+
+  def inherited(subclass)
+    super(subclass) if respond_to?('super')
+    iattr.each do |a|
+      # puts "a=#{a}"
+      subclass.send("#{a}=", send(a).deep_clone)
+      subclass.send("iattr", a.to_sym)
+    end
+    cattr.each do |a|
+      subclass.send("#{a}=", send(a))
+      subclass.send("cattr", a.to_sym)
+    end
+    oattr.each do |a|
+      subclass.send("oattr", a.to_sym)
+    end
+    oattr_i.each do |a|
+      subclass.send("oattr_i", a.to_sym)
+    end
+    subclass.send(:inherit) if subclass.respond_to?('inherit')
+  end
+
+  def inherit(*args, &block)
+    super if respond_to?('super')
+  end
+end
+
+module ObjectPreInitialize
+  private
+  def pre_initialize(*args, &block)
+    super if respond_to?('super')
+
+    class_attrs = self.class.cattr + self.class.iattr
+
+    self.class.oattr.each do |a|
+      sac = self.class.send(a)
+      eval "@#{a.to_s}=sac" if class_attrs.include? a
+    end
+
+    self.class.oattr_i.each do |a|
+      sac = self.class.send(a)
+      eval "@#{a.to_s}=sac.deep_clone" if class_attrs.include? a
+    end
+  end
+
+  # def postinitialize(*args, &block)
+  # end
+end
+
+module OverloadNew
+  def new(*args, &block)
+    newObj = self.allocate
+    newObj.send :extend, ObjectPreInitialize
+    newObj.send :pre_initialize, *args, &block
+    newObj.send :initialize,     *args, &block
+    # newObj.send :postinitialize, *args, &block
+    return newObj
+  end
+end
+
+def has_class_attributes
+  extend ClassAttributes
+end
+
+def has_class_object_attributes
+  extend ClassAttributes
+  extend OverloadNew
+end
+
+

data/lib/yamldoc.rb

@@ -0,0 +1,264 @@
+require "yaml"
+require "erb"
+require "class_attributes"
+
+class Object
+  def to_yaml_properties; instance_variables - ["@_","@_ro","@_yp","@_ym","@_as"]; end
+  def deep_clone; Marshal::load(Marshal.dump(self)); end
+end
+
+class YamlDoc < Hash
+  private
+  has_class_object_attributes; co_attr_i :_
+
+  @_ = {  
+    :filename => nil,
+    :key_type => String,
+    :force_keys => false,
+    :object_detection => false,
+    :autosave => false,
+    :deep_clone => false,
+    :ymldoc_pfx => ""
+  }
+
+  def self.properties ; @_ ; end
+
+  def self.inherit(*args, &block)
+    # define class accessors for @_ (properties)
+    @_.keys.each do |sym|
+      getter = sym
+      self.class.send(:define_method, getter) { @_[sym] }    
+      setter = (sym.to_s+"=").to_sym
+      self.class.send(:define_method, setter) { |val| @_[sym] = val }
+    end    
+  end
+
+  def initialize(*args, &block)
+    @_ro = self
+    self.send(:reload_hooks)
+
+    case args.first
+      when String
+        @_[:filename] = args.first
+      when Hash
+        @_.merge! args.first
+      when nil
+        ;;
+      else
+        args.each do |obj|
+          self["#{obj.class.inspect}"] ||= []
+          self["#{obj.class.inspect}"] << obj
+        end
+    end
+    
+    load()
+    save(&block) if block_given?
+  end
+
+  def load(file=nil)
+    f = file || @_[:filename]
+    if f
+      if File.exists? f
+        yaml = YAML.load(ERB.new(File.read(f)).result)
+        hash = yaml.to_hash if yaml
+        puts yaml if yaml
+      end
+
+      hash = Hash.new if hash.nil?
+      self.merge! hash
+      @_[:filename] = f
+    end
+  end
+
+  def save(&block)
+    # always disable autosave for effecient write
+    @_as = @_[:autosave] ; @_[:autosave] = false
+    _call_block(block) if block_given?
+    @_[:autosave] = @_as ; _write_file
+  end
+
+  def _call_block(block)
+    if block.arity == 1
+      block.call(self)
+    else
+      raise "Wrong number of arguments (#{block.arity}). This block takes 1 argument"
+    end
+  end
+
+  def properties ; @_ ; end
+
+  def methods ; @_ym ; end
+
+  def reload_hooks
+    pfx = @_[:ymldoc_pfx].to_s
+
+    old_props = @_yp || [] ; @_yp = []
+    old_props.each do |sym|
+      self.class.send(:remove_method,sym)
+    end
+
+    @_.keys.each do |sym|
+      getter = (pfx+sym.to_s).to_sym
+      self.class.send(:define_method, getter) { @_[sym] }
+      @_yp << getter
+
+      setter = (pfx+sym.to_s+"=").to_sym
+      self.class.send(:define_method, setter) { |val| @_[sym] = val }
+    end
+    
+    old_methods = @_ym || [] ; @_ym = []
+    old_methods.each do |sym|
+      self.class.send(:remove_method,sym)
+    end
+
+    [:load, :save, :methods, :properties, :reload_hooks].each do |sym|
+      m = (pfx+sym.to_s).to_sym
+      self.class.send(:define_method, m, self.method(sym))
+      @_ym << m
+    end
+  end
+
+  module HashChanged
+    def self.object_changed_methods(obj=nil)
+      hash_keys_method = [:[]=]
+      [:[]=,:clear,:default=,:delete,:delete_if,:merge!,:rehash,:reject,
+      :reject!,:replace,:shift,:store,:update] - hash_keys_method
+    end
+  end
+  module ArrayChanged
+    def self.object_changed_methods(obj=nil) 
+      [:<<,:[]=,:clear,:collect!,:compact!,:delete,:delete_at,:delete_if,
+      :fill,:flatten!,:insert,:map!,:pop,:push,:reject!,:replace,:reverse!,
+      :shift,:slice!,:sort!,:transpose,:uniq!,:unshift]
+    end
+  end  
+  module StringChanged
+    def self.object_changed_methods(obj=nil)
+      [:<<,:[]=,:capitalize,:chomp!,:chop!,:concat,:delete!,:downcase!,:gsub!,
+      :insert,:lstrip!,:next!,:replace,:reverse!,:rstrip!,:slice!,:squeeze!,
+      :strip!,:sub!,:succ!,:swapcase!,:tr!,:tr_s!,:upcase!]
+    end
+  end
+  module ObjectChanged
+    def self.object_changed_methods(obj)
+      obj.instance_variables.map { |s| s.delete("@")+"=" }
+    end
+  end
+  module ChangedHook
+    def self.extended(base)
+      override_obj_changed_methods base
+    end
+    private
+    def self.override_obj_changed_methods(obj)
+      eigen_class = self
+      obj_class = obj.class.to_s.match("Hash|Array|String") || "Object"
+      m = eval "#{obj_class}Changed::object_changed_methods obj"
+      m.each do |method|
+        eigen_class.send(:define_method, method) { 
+          result = super
+          # eval "puts \"__obj_changed_hook #{method}\""
+          __obj_changed_hook
+          return result
+          }
+      end
+    end
+  end
+  module HashMethods
+    def self.extended(hash)
+      sanitize_hashes_recursive(hash) if hash.instance_eval{@_}[:force_keys]
+    end
+
+    def []=(name, *args, &block)
+      if @_[:force_keys]
+        name = name.to_s   if name.class == Symbol && @_[:key_type] == String
+        name = name.to_sym if name.class == String && @_[:key_type] == Symbol
+      end
+      result = super
+      __obj_changed_hook
+      return result
+    end
+
+    private
+    def self.sanitize_hashes_recursive(hash)
+      if hash.instance_eval{@_}[:key_type] == String; force_class = Symbol ; conv = "to_s"   ; end
+      if hash.instance_eval{@_}[:key_type] == Symbol; force_class = String ; conv = "to_sym" ; end
+      
+      hash.each do |k,v|
+        if v.class == Hash; sanitize_hashes_recursive(v) ; break; end
+        target = eval "k.#{conv}"
+        if force_class == k.class && ! hash.include?(target) ; hash.store(target,v); end
+      end
+      hash.delete_if { |k,v| force_class == k.class }
+    end
+  end
+  module EigenMethodDefiner # :nodoc:
+    private
+    def method_missing(name, *args, &block)
+      value = nil
+      str_full = name.to_s
+      str = str_full.match("=$") ? str_full.chop : str_full
+      sym = str.to_sym
+
+      s = @_[:key_type] == Symbol ? "sym" : "str"
+      eval "define_eigen_method_#{s}(#{s})"
+      
+      if str_full.match "=$"
+        obj = args.first
+        obj = Hash.new if obj.nil?
+        value = @_[:deep_clone] ? obj.deep_clone : obj
+        eval "self[#{s}] = value"
+      else
+        eval "value = self[#{s}] = self[#{s}].nil? ? Hash.new : self[#{s}]"
+      end
+
+      yaml_types = [Hash, Array, String, Object]
+      yaml_types.each do |yaml_type|
+        if value.is_a?(yaml_type)
+          value.extend(EigenMethodDefiner)
+          parent_opts = @_
+          value.instance_eval { @_ = parent_opts }
+          root_obj = @_ro
+          value.instance_eval { @_ro = root_obj }
+          value.extend YamlDoc::ChangedHook if @_[:object_detection]
+          value.extend(HashMethods) if value.is_a?(Hash)
+          break
+        end
+      end
+      value
+    end
+
+    def __obj_changed_hook
+        _write_file if @_[:autosave]
+    end
+
+    def _write_file
+      if @_[:filename]
+        File.open(@_[:filename], 'w') do |output|
+          output.puts YAML.dump(@_ro)
+        end
+      end
+    end
+
+    def define_eigen_method_sym(sym)
+      eigen_class = class << self; self; end
+      eigen_class.send(:define_method, sym) { self[sym] }
+      eigen_class.send(:define_method, (sym.to_s+'=').to_sym) { |val| self[sym] = val }
+    end
+    def define_eigen_method_str(str)
+      eigen_class = class << self; self; end
+      eigen_class.send(:define_method, str.to_sym) { self[str] }
+      eigen_class.send(:define_method, (str+'=').to_sym) { |val| self[str] = val }
+    end
+  end
+
+  include EigenMethodDefiner
+end
+
+class AutoYamlDoc < YamlDoc
+    self.force_keys = true
+    self.object_detection = true
+    self.autosave = true  
+end
+
+
+

data/rails/init.rb

@@ -0,0 +1 @@
+require "yamldoc"

data/spec/examples_unsorted.rb

@@ -0,0 +1,219 @@
+# puts config.methods.inspect
+# puts config.properties.inspect
+# puts config.key_type
+
+# puts config.String[0]
+# config.defaults.sendary = "overwritten"
+# config.defaults["sendary"] = "overwritten"
+# config.defaults[:sendary] = "overwritten2"
+# config.ymldoc_pfx = "yml_"
+# config.reload_hooks
+# puts config.methods.inspect
+# puts config.properties.inspect
+# puts config.yml_methods.inspect
+# puts config.yml_properties.inspect
+# puts config.properties.each {|p| puts "#{p} => " + eval("config.#{p}").inspect }
+# puts config.properties.pretty_print
+# puts config.filename
+
+
+# config.load("new.yml")
+# config.save
+# puts ""
+# config.save() do |c|
+#   c.leftjustify = true
+# end
+# config.save
+# puts config.yml_service_hooks.inspect
+# 
+# puts config.hooks.inspect
+# config.hook_pfx=("_")
+# puts config.hook_pfx.inspect
+# config.reload_hooks
+# puts config._hooks.inspect
+# puts config.hooks.inspect
+# config.save
+
+# require 'matrix'
+# config.matrix = Matrix[ [25, 93], [-1, 66] ]
+
+# class Car
+#   # attr_accessor :wheels, :engine, :doors, :trunk
+#   @wheels = 4
+#   @engine = "Big V-6"
+#   @doors = 5
+#   # def initialize(*args, &block)
+#   #   case args.first
+#   #   when Hash
+#   #     args.first.each do |k,v|        
+#   #       s = k.to_s
+#   #       eval "self.#{s} = v"
+#   #     end
+#   #   end
+#   # end
+# end
+
+# car = Car.new :wheels => 4, :engine => "2.4 Litre Diesel", :doors => 5
+# car = Car.new
+# puts car.inspect
+
+# config.car = car
+# config.car.trunk = "hatchback"
+# car.engine = "2.4 Litre Diesel"
+# config.car = Car.new :wheels => 4, :engine => "2.4 Litre Diesel", :doors => 5
+
+# config.car.engine = "No engine"
+# car.engine = "EasyJet"
+
+# puts ""
+# puts car.class.to_s.match("Array|String|Hash")
+# puts car.class.to_s.match("Array|String|Hash|Car")
+# puts config.yml_filename
+
+# puts "car=#{car.inspect}"
+# puts ""
+# puts "config.car=#{config.car.inspect}"
+# puts "------------------------------------------------------"
+# puts ""
+
+# config._foo = "bartender"
+# config._foo = String.new "bartender"
+# config._root = "somestring"
+
+# # service hook
+# config._filename = "filename"
+# config._.filename = "filename"
+# config._.merge! { filename => "filename" }
+
+# config.defaults.insert "x-plane"
+# config.defaults.delete "a"
+# config.defaults.update({})
+# config.defaults.replace "one"=> 1, :two => 2
+# 
+# 
+# config.tee = "chocolate"
+# puts "config[\"tee\"]=#{config["tee"]}"
+# config.tee.upcase!
+# 
+# config.moon = "the lazy cat"
+# config.moon.upcase!
+# 
+# puts config.inspect
+# config.__write_file
+
+# puts config.sub1
+# config.sub1.a1 = [1]
+# # puts config.sub1.a1.inspect
+# config.sub1.a1[1] = 2
+# # config.sub1.a1 << 2
+# # puts config.sub1.a1.inspect
+# config.sub1.a1 = [1,2,3]
+# # config.sub1.a1.insert (0,3)
+# config.sub1.a1.compact!
+# # puts config.sub1.a1.inspect
+
+# config[1] = "foo"
+# config[2] = "bar"
+# puts config.inspect
+# config._save
+
+# require 'yamldoc'
+# class Settings < AutoYamlDoc
+#   self.filename = File.expand_path("~/.moonshadow")
+#   self.key_type = Symbol 
+#   self.deep_clone = true
+#   # self.service_hook = "yml_"
+# end
+
+# config = Settings.new() do |c|
+#   # c.defaults = {"one"=> 1, :two => 2}
+#   c.defaults = {"a"=> 1, :sendary => 3}
+#   c.defaults.array = [1,2,3,4]
+#   # config = [1,2,3,4]
+# end
+
+# puts "YamlDoc  "+YamlDoc.properties.inspect
+# puts "AutoYaml "+AutoYamlDoc.properties.inspect
+# puts "Settings "+Settings.properties.inspect
+# config = Settings.new
+# config.key_type = String
+# puts "object   "+config.properties.inspect
+# puts "object   "+config.instance_eval("@_").inspect
+# 
+# puts "YamlDoc  "+YamlDoc.properties.inspect
+# puts "AutoYaml "+AutoYamlDoc.properties.inspect
+# puts "Settings "+Settings.properties.inspect
+# 
+# puts "AutoYaml autosave = "+AutoYamlDoc.autosave.inspect
+# puts "YamlDoc autosave  = "+YamlDoc.autosave.inspect
+# puts "YamlDoc key_type  = "+YamlDoc.key_type.inspect
+
+
+# puts "AutoYamlDoc.object_detection=#{AutoYamlDoc.object_detection}"
+
+# config = Settings.new("filename")
+# config = Settings.new("file.yml"){}
+# config = Settings.new :filename => "file.yml", :autosave => true
+# config = Settings.new(:filename => "file.yml", :autosave => true){}
+# config = Settings.new
+
+# config.sub2.hash1.two = 2
+# config.sub2.hash1.three = 3
+# config.sub1.a1 = [1,2,3]
+# config.strings.about = "About string for this ruby application"
+# 
+# require 'matrix'
+# config.matrix = Matrix[ [25, 93], [-1, 66] ]
+# config.strings.about.reverse!
+# puts config.strings.about
+
+# puts config.sub1
+# config.sub1.a1 = [1]
+# puts config.sub1.a1.inspect
+# # config.sub1.a1 = [2]
+# config.sub1.a1 << 2
+# puts config.sub1.a1.inspect
+# config.sub1.a1 = [1,2,3]
+# config.sub1.a1.insert (0,3)
+# puts config.sub1.a1.inspect
+# 
+# # puts config.sub1.hash1.inspect
+# config.sub1.sub2.hash1 = {"2" => 2, "three" => 3, :three => "three"}
+# puts config.sub1.sub2.hash1.inspect
+
+# config = Settings.new "filename"
+# config = Settings.new "filename2"
+# config = Settingslogic.new "filename2"
+# puts config.ancestors
+# config = Settings.new(:config1 => 1, :config2 => 2)
+# config[:config1] = 1
+# config[:config2] = 2
+# config[:blue] = "Nixon"
+# puts config.blue
+# # config["blue"] = 3
+# config["blue"] = "four"
+# puts config.blue
+
+# puts ""
+# # puts config[:config2]
+# # puts config.settings
+# puts config.blue
+# # puts config.config2
+# 
+# config.blue = "canary"
+# puts config.blue
+
+# config.sub1.hash1 = {"2" => 2, "three" => 3, :three => "three"}
+# config.sub1 = {}
+
+# config.foo = {"hash1"=>"one"}
+# config.yellow = true
+
+# config = Settings.new
+# config.transaction("file.yml", hash){ |config|
+#   # config.defaults = {"one"=> 1, :two => 2}
+#   # config.defaults.array = [1,2,3,4]
+#   config.defaults = {"one"=> 1, :two => 2}
+#   # config = [1,2,3,4]
+#   }
+

data/spec/settings.rb

@@ -0,0 +1,3 @@
+class Settings < YamlDoc
+  source "#{File.dirname(__FILE__)}/settings.yml"
+end

data/spec/settings.yml

@@ -0,0 +1,16 @@
+setting1:
+  setting1_child: saweet
+  deep:
+    another: my value
+    child:
+      value: 2
+
+setting2: 5
+setting3: <%= 5 * 5 %>
+name: test
+
+language:
+  haskell:
+    paradigm: functional
+  smalltalk:
+    paradigm: object oriented 

data/spec/settings2.rb

@@ -0,0 +1,4 @@
+class Settings2 < YamlDoc
+  source "#{File.dirname(__FILE__)}/settings.yml"
+  namespace "setting1"
+end

data/spec/spec_helper.rb

@@ -0,0 +1,12 @@
+require 'spec'
+require 'rubygems'
+require 'ruby-debug'
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'yamldoc'
+require 'settings'
+require 'settings2'
+
+Spec::Runner.configure do |config|
+end

data/spec/yamldoc_spec.rb

@@ -0,0 +1,36 @@
+require File.expand_path(File.dirname(__FILE__) + "/spec_helper")
+
+describe "YamlDoc" do
+  it "should be a hash" do
+    Settings.send(:instance).should be_is_a(Hash)
+  end
+  
+  it "should access settings" do
+    Settings.setting2.should == 5
+  end
+  
+  it "should access nested settings" do
+    Settings.setting1.setting1_child.should == "saweet"
+  end
+  
+  it "should access deep nested settings" do
+    Settings.setting1.deep.another.should == "my value"
+  end
+  
+  it "should access extra deep nested settings" do
+    Settings.setting1.deep.child.value.should == 2
+  end
+  
+  it "should enable erb" do
+    Settings.setting3.should == 25
+  end
+  
+  it "should namespace settings" do
+    Settings2.setting1_child.should == "saweet"
+  end
+
+  it "should distinguish nested keys" do
+    Settings.language.haskell.paradigm.should == 'functional'
+    Settings.language.smalltalk.paradigm.should == 'object oriented'
+  end
+end

data/yamldoc.gemspec

@@ -0,0 +1,60 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE
+# Instead, edit Jeweler::Tasks in Rakefile, and run `rake gemspec`
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{yamldoc}
+  s.version = "0.0.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["dreamcat4, Ben Johnson"]
+  s.date = %q{2009-10-15}
+  s.email = %q{dreamcat4@gmail.com}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.rdoc"
+  ]
+  s.files = [
+    ".gitignore",
+     "CHANGELOG.rdoc",
+     "LICENSE",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION.yml",
+     "init.rb",
+     "lib/class_attributes.rb",
+     "lib/yamldoc.rb",
+     "rails/init.rb",
+     "spec/examples_unsorted.rb",
+     "spec/settings.rb",
+     "spec/settings.yml",
+     "spec/settings2.rb",
+     "spec/spec_helper.rb",
+     "spec/yamldoc_spec.rb",
+     "yamldoc.gemspec"
+  ]
+  s.homepage = %q{http://github.com/dreamcat4/yamldoc}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{}
+  s.rubygems_version = %q{1.3.4}
+  s.summary = %q{A simple solution for ERB enabled YAML file.}
+  s.test_files = [
+    "spec/examples_unsorted.rb",
+     "spec/settings.rb",
+     "spec/settings2.rb",
+     "spec/spec_helper.rb",
+     "spec/yamldoc_spec.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end

metadata

@@ -0,0 +1,76 @@
+--- !ruby/object:Gem::Specification 
+name: yamldoc
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- dreamcat4, Ben Johnson
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-10-15 00:00:00 +01:00
+default_executable: 
+dependencies: []
+
+description: 
+email: dreamcat4@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- .gitignore
+- CHANGELOG.rdoc
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION.yml
+- init.rb
+- lib/class_attributes.rb
+- lib/yamldoc.rb
+- rails/init.rb
+- spec/examples_unsorted.rb
+- spec/settings.rb
+- spec/settings.yml
+- spec/settings2.rb
+- spec/spec_helper.rb
+- spec/yamldoc_spec.rb
+- yamldoc.gemspec
+has_rdoc: true
+homepage: http://github.com/dreamcat4/yamldoc
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: ""
+rubygems_version: 1.3.4
+signing_key: 
+specification_version: 3
+summary: A simple solution for ERB enabled YAML file.
+test_files: 
+- spec/examples_unsorted.rb
+- spec/settings.rb
+- spec/settings2.rb
+- spec/spec_helper.rb
+- spec/yamldoc_spec.rb