funfig 0.0.3 → 0.0.4

data/lib/funfig/declaration_sugar.rb

@@ -0,0 +1,49 @@
+require "funfig/group"
+
+module Funfig
+  class ProxyParam < BasicObject
+    def initialize(group)
+      @group = group
+    end
+    def method_missing(name, value = NOT_SET, &block)
+      unless value.equal? NOT_SET
+        @group.param name, value
+      else
+        @group.param name, &block
+      end
+    end
+  end
+
+  class ProxyGroup < BasicObject
+    def initialize(group)
+      @group = group
+    end
+    def method_missing(name, &block)
+      @group.group name, &block
+    end
+  end
+
+  class Group
+    # syntax sugar proxy for declaring params
+    #
+    # :call-seq
+    #   conf = Funfig.new do
+    #     p.name_of_param :default_value
+    #     p.other_param { calculate_default }
+    #   end
+    def self.p
+      @proxy_param ||= ProxyParam.new(self)
+    end
+
+    # syntax sugar proxy for declaring group
+    #
+    # :call-seq
+    #   conf = Funfig.new do
+    #     g.name_of_group do
+    #     end
+    #   end
+    def self.g
+      @group_param ||= ProxyGroup.new(self)
+    end
+  end
+end

data/lib/funfig/group.rb

@@ -0,0 +1,205 @@
+module Funfig
+  NOT_SET = Object.new.freeze
+  class Group
+    def initialize(parent=nil) # :nodoc:
+      @parent = parent
+    end
+
+    # Get enclosing group
+    def _parent
+      @parent
+    end
+
+    # Get root of configuration
+    # :call-seq:
+    #   _
+    #   _root
+    def _root
+      @parent._root
+    end
+    alias _ _root
+
+    # Update config by hash
+    def update(hash)
+      if hash.respond_to?(:each)
+        hash.each{|k, v|
+          k = k.gsub('-', '_')
+          self.send("#{k}=", v)
+        }
+      end
+      self
+    end
+
+    # Iterate over parameter names
+    def each_param
+      return to_enum(:each_param) unless block_given?
+      self.class._params.each{|k, _|
+        yield k
+      }
+    end
+
+    # Iterate over parameters and values
+    # If called with parameter +true+, then iterate only over explicit setted parameters
+    #
+    # :call-seq:
+    #    config.each{|name, value| puts "#{name} = #{value}"}
+    #    config.each(true){|name, value| puts "#{name} = #{value}"}
+    def each(explicit=false)
+      return to_enum(:each, explicit) unless block_given?
+      self.class._params.each{|k, _|
+        yield k, send(k)  unless explicit && !instance_variable_defined?("@#{k}")
+      }
+    end
+
+    # Convert configuration to hash
+    # If called with parameter +true+ than consider only explicit setted parameters
+    def to_hash(explicit=false)
+      h = {}
+      each(explicit){|k, v|
+        if Group === v
+          v = v.to_hash(explicit)
+          next  if explicit && v.empty?
+        end
+        h[k] = v
+      }
+      h
+    end
+
+    def inspect
+      "<#{self.class.name} #{each.map{|k,v| "#{k}=#{v.inspect}"}.join(' ')}>"
+    end
+
+    # :stopdoc:
+
+    def _cache_get(k, &block)
+      _._cache.fetch(_sub_name(k), NOT_SET)
+    end
+
+    def _cache_set(k, v)
+      _._cache[_sub_name(k)] = v
+    end
+
+    def _sub_name(name)
+      self.class._sub_name(name)
+    end
+
+    def _path
+      self.class._path
+    end
+
+    def self._params
+      @params ||= {}
+    end
+
+    def self.initialize_clone(arg)
+      super
+      if @params
+        params, @params = @params, {}
+        params.each{|name, par|
+          if par.is_a?(Class) && Group >= par
+            @params[name] = par.clone
+          else
+            @params[name] = par
+          end
+        }
+      end
+    end
+
+    def self._sub_name(name)
+      "#{_path}.#{name}"
+    end
+
+    # :startdoc:
+
+    # Define named group of values
+    #
+    # :call-seq:
+    #   config = Funfig.new do
+    #     group :name_of_group do
+    #     end
+    #   end
+    def self.group(name, &block)
+      name = name.to_sym
+      vname = :"@#{name}"
+      _prev = _params[name]
+      klass = _prev.is_a?(Class) && Group >= _prev ? _prev : Class.new(Group)
+      _params[name] = klass
+      path = _sub_name(name)
+      const_set name.capitalize, klass
+
+      klass.send(:define_singleton_method, :_path) do
+        path
+      end
+
+      define_method(name) do |*args, &block|
+        instance_variable_get(vname) ||
+          instance_variable_set(vname, klass.new(self))
+      end
+
+      define_method("#{name}=") do |hash|
+        send(name).update(hash)  if hash
+      end
+
+      define_method("#{name}_reset!") do
+        _._cache_clear!
+        remove_instance_variable(vname)  if instance_variable_defined?(vname)
+      end
+      klass.class_exec &block
+    end
+
+    # define named parameter
+    #
+    # :call-seq:
+    #   config = Funfig.new do
+    #     param :name_of_param do calculate_default_value end
+    #   end
+    def self.param(name, value = NOT_SET, &block)
+      _params[name] = true
+      vname = :"@#{name}"
+      name = name.to_sym
+
+      block ||= proc{
+        begin
+          value.dup
+        rescue TypeError
+          block = proc { value }
+          value
+        end
+      }
+
+      define_method(name) do |*args|
+        if instance_variable_defined?(vname)
+          instance_variable_get(vname)
+        else
+          if (v = _cache_get(name)).equal? NOT_SET
+            raise "Parameter #{_sub_name(name)} must be set!" unless block
+            _cache_set(name, (v = instance_exec &block))
+          end
+          v
+        end
+      end
+
+      define_method("#{name}=") do |v|
+        _._cache_clear!
+        instance_variable_set(vname, v)
+      end
+
+      define_method("#{name}_reset!") do
+        _._cache_clear!
+        remove_instance_variable(vname)  if instance_variable_defined?(vname)
+      end
+    end
+
+    # Create a copy of configuration scheme
+    #
+    # :call-seq:
+    #   other_conf = config.clone do
+    #     param :other_value do other_default end
+    #   end
+    def self.clone(&block)
+      new = super
+      new.class_exec &block  if block_given?
+      new
+    end
+  end
+end

data/lib/funfig/ini_parser.rb

@@ -0,0 +1,307 @@
+require 'yaml'
+require 'strscan'
+
+module Funfig
+  # fake ini file loader
+  # loads *.ini file by converting it to YAML first
+  class IniParser
+    attr :hash
+    attr_accessor :string
+
+    def initialize(string = nil, file = nil)
+      @string = string
+      @file = file
+    end
+
+    def parse(string = @string, file = @file)
+      raise "Should specify string for parse"  unless String === string
+      prepare_parse(string, file)
+      do_parse
+      finish_parse
+    end
+
+    class << self
+      def parse_file(file)
+        if file.respond_to?(:read)
+          new(file.read).parse
+        else
+          new(File.read(file), file).parse
+        end
+      end
+    end
+  private
+    def prepare_parse(string, file)
+      @file = file
+      @scanner = StringScanner.new(string)
+      @hash = {}
+      @line_number = 0
+    end
+
+    def finish_parse
+      @scanner = @line_number = nil
+      @hash
+    end
+
+    def line_number(line = @line_number)
+      if @file
+        "#{@file}:#{line}"
+      else
+        line
+      end
+    end
+
+    def do_parse
+      section = "global"
+      yaml = false
+      while true
+        skip_empty_lines!
+        break if @scanner.eos?
+        if @scanner.scan(/\s*\[\s*([-.\w]+)\s*\]/)
+          section = @scanner[1]
+        elsif @scanner.scan(/\s*([-.\w]+)\s*[:=]\s*/)
+          param = @scanner[1]
+          line_no = @line_number
+          if @scanner.match?(/YAML([- #\[{"'<]|$)/)
+            @scanner.skip(/YAML\s*/)
+            yaml = true
+          elsif @scanner.skip(/WORDS[ \t]+/)
+            words = true
+          end
+
+          if @scanner.scan(/\s*<<(\w+)/)
+            multiline = @scanner[1]
+            skip_eol!
+            unless @scanner.scan(/(.*?)^([ \t]*)#{multiline}/m)
+              raise "Multiline '#{multiline}' started at line #{line_number(line_no)} is not finished"
+            end
+            adjust_lineno!(@scanner[1])
+            value = @scanner[1].chomp
+            if words
+              value = scan_multiline_words(value)
+            elsif !yaml
+              value = unindent(value, @scanner[2])
+            end
+          elsif yaml
+            value = scan_yaml
+          elsif words
+            value = scan_words
+          else
+            value = scan_simple
+          end
+
+          if yaml
+            value = YAML.load(value)
+            yaml = false
+          end
+
+          set_value(section, param, value, line_no)
+        else
+          raise "Parse error at line #{line_number}"
+        end
+      end
+    end
+
+    EMPTY = /\s*([#;].*?)?(?:\r\n|\r|\n|\z)/
+    def skip_eol!
+      if (s = @scanner.skip(EMPTY)) && s > 0
+        @line_number += 1
+      end
+    end
+
+    def adjust_lineno!(str)
+      @line_number += str.scan(/\r\n|\r|\n/).size
+    end
+
+    def skip_empty_lines!
+      while skip_eol!; end
+    end
+
+    REPLACE_SQUOTE = {"\\'" => "'", "\\\\" => "\\"}
+    REPLACE_DQUOTE = Hash.new{|h,k| h[k] = eval("\"#{k}\"")}
+    def _replace_squote(str)
+      str.gsub(/\\[\\']/, REPLACE_SQUOTE)
+    end
+
+    def _replace_dquote(str)
+      str.gsub(/\\(x[a-fA-F\d]{1,2}|u[a-fA-F\d]{4}|[^xu])/, REPLACE_DQUOTE)
+    end
+
+    def convert_value(value)
+      case value
+      when '', 'null'
+        nil
+      when /\A[+-]?[1-9]\d*\z/
+        value.to_i
+      when /\A[+-]?\d*(\.\d+)?([eE][+-]?\d+)?\z/
+        value.to_f
+      when 'True', 'TRUE', 'true', 'Yes', 'yes'
+        true
+      when 'False', 'FALSE', 'false', 'No', 'no'
+        false
+      else
+        value
+      end
+    end
+
+    def scan_simple
+      val = ''
+      quoted = false
+      scan_value do |kind, string|
+        case kind
+        when :space
+          val << ' '
+        when :raw
+          val << string
+        when :single_quote
+          quoted = true
+          val << _replace_squote(string)
+        when :double_quote
+          quoted = true
+          val << _replace_dquote(string)
+        end
+      end
+      unless quoted
+        convert_value(val)
+      else
+        val
+      end
+    end
+
+    def scan_yaml
+      val = ''
+      scan_value do |kind, string|
+        case kind
+        when :space
+          val << ' '
+        when :raw
+          val << string
+        when :single_quote
+          val << "'#{string}'"
+        when :double_quote
+          val << %{"#{string}"}
+        end
+      end
+      val
+    end
+
+    def scan_words
+      val = ['']
+      quoted = false
+      scan_value do |kind, string|
+        case kind
+        when :space
+          val[-1] = convert_value(val[-1]) unless quoted
+          quoted = false
+          val << ''
+        when :raw
+          val[-1] << string
+        when :single_quote
+          val[-1] << _replace_squote(string)
+          quoted = true
+        when :double_quote
+          val[-1] << _replace_dquote(string)
+          quoted = true
+        end
+      end
+      return []  if val == ['']
+      val[-1] = convert_value(val[-1]) unless quoted
+      val
+    end
+
+    def scan_value
+      empty = true
+      while ! skip_eol! && ! @scanner.eos?
+        if @scanner.skip(/[ \t]+/)
+          yield(:space)  unless empty
+        end
+        if @scanner.scan(/([^"'#;\s\r\n]+)/)
+          yield(:raw, @scanner[1])
+        elsif s = @scanner.scan(/'((?:\\'|[^'])*)'/)
+          adjust_lineno!(s)
+          yield(:single_quote, @scanner[1])
+        elsif s = @scanner.scan(/"(\\.|[^"]*)"/)
+          adjust_lineno!(s)
+          yield(:double_quote, @scanner[1])
+        else
+          break
+        end
+        empty = false
+      end
+    end
+
+    def scan_multiline_words(string)
+      scanner = StringScanner.new(string)
+      value = []
+      while !scanner.eos?
+        scanner.skip(/\s+/)
+        if s = scanner.scan(/([^"'#;\s\r\n]+)/)
+          value << convert_value(s)
+        elsif scanner.scan(/'((?:\\'|[^'])*)'/)
+          value << _replace_squote(scanner[1])
+        elsif s = scanner.scan(/"(\\.|[^"]*)"/)
+          value << _replace_dquote(scanner[1])
+        else
+          break
+        end
+      end
+      value
+    end
+
+    def set_value(section, param, value, line_no)
+      key = "#{section}.#{param}"
+      seq = key.split('.')
+      seq.shift  if seq.first == 'global'
+      hash = @hash
+      path = []
+      while seq.size > 1
+        path << seq.shift
+        if current = hash[path.last]
+          unless Hash === current
+            raise "Could not insert [#{section}] #{param} on line #{line_number(line_no)} cause #{path.join('.')} is not a hash"
+          end
+        else
+          hash[path.last] = current = {}
+        end
+        hash = current
+      end
+      hash[seq.first] = value
+    end
+
+    def count_space(line)
+      n, i = 0, 0
+      while true
+        if line[i] == ?\x20
+          n += 1
+        elsif line[i] == ?\t
+          n = (n / 8) * 8 + 8
+        else
+          break
+        end
+        i += 1
+      end
+      n
+    end
+
+    def skip_space(line, nspace)
+      n, i = 0, 0
+      while n < nspace
+        if line[i] == ?\x20
+          n += 1
+        elsif line[i] == ?\t
+          n = (n / 8) * 8 + 8
+        else
+          break
+        end
+        i += 1
+      end
+      raise unless n >= nspace
+      (" "*(n - nspace) + line[i..-1])
+    end
+
+    def unindent(value, space)
+      nspace = count_space(space)
+      value.each_line.map{|line| skip_space(line, nspace)}.join
+    end
+
+  end
+end

data/lib/funfig/load.rb

@@ -0,0 +1,87 @@
+require 'funfig/load_proxy'
+require 'funfig/ini_parser'
+module Funfig
+  class Group
+    # Update config by yaml file
+    def load_yaml(filename)
+      params = YAML.load_file(filename)
+      update(params)
+    end
+
+    # Update config by yaml string
+    def load_yaml_string(string)
+      params = YAML.load(string)
+      update(params)
+    end
+
+    # Update config by ini file
+    def load_ini(filename)
+      params = IniParser.parse_file(filename)
+      update(params)
+    end
+
+    # Update config by ini string
+    def load_ini_string(string, file = nil)
+      params = IniParser.new.parse(string, file)
+      update(params)
+    end
+
+    # Update config by evaluating ruby file
+    def load_ruby(file)
+      rb = File.read(file)
+      load_ruby_string(rb, file)
+    end
+
+    # Update config by evaluating string containing ruby code
+    def load_ruby_string(string, file = nil)
+      unless file
+        for cl in caller
+          next  if cl =~ %r{funfig/load\.rb}
+          file, line = caller.first.match(/^(.*):(\d*)/).captures
+          break
+        end
+      end
+      LoadProxy.new(self).instance_eval string, file, line.to_i
+      self
+    end
+
+    # Update config by executing block inside of proxy
+    def exec(&block)
+      LoadProxy.new(self).instance_exec &block
+    end
+  end
+
+  class Root
+    # Load config from yaml file
+    def self.from_yaml_file(file)
+      self.new.load_yaml(file)
+    end
+
+    # Load config from ini file
+    def self.from_ini_file(file)
+      self.new.load_ini(file)
+    end
+
+    # Evaluate config file inside of configuration object
+    def self.from_ruby_file(file)
+      self.new.load_ruby(file)
+    end
+
+    def self.from_file(file)
+      case file
+      when /\.yml$/, /\.yaml$/
+        from_yaml_file(file)
+      when /\.ini$/
+        from_ini_file(file)
+      when /\.rb$/
+        from_ruby_file(file)
+      when Hash
+        if fl = file[:yaml]
+          from_yaml_file(fl)
+        elsif fl = file[:ruby]
+          from_ruby_file(fl)
+        end
+      end
+    end
+  end
+end

data/lib/funfig/load_proxy.rb

@@ -0,0 +1,41 @@
+module Funfig
+  class LoadProxy < BasicObject
+    def initialize(group)
+      @group = group
+      methods = {}
+      group.public_methods(false).each{|m| methods[m] = true}
+      @methods = methods
+      @params = @group.class._params
+    end
+
+    def _parent
+      @group._parent
+    end
+
+    def _root
+      @group._root
+    end
+    alias _ _root
+
+    def method_missing(name, *args, &block)
+      if @methods.include?(name)
+        if par = @params[name]
+          if par.is_a?(::Class) && par < Group && args.empty? && block
+            proxy = LoadProxy.new(@group.send(name))
+            proxy.instance_exec &block
+          elsif !args.empty?
+            raise "Could not pass both block and value for option"  if block
+            raise "Could set only single value for option"  if args.size > 1
+            @group.send("#{name}=", args[0])
+          else
+            @group.send(name)
+          end
+        else
+          @group.send(name, *args, &block)
+        end
+      else
+        ::Kernel.raise ::NotImplementedError, "no configuration option #{@group._sub_name(name)}"
+      end
+    end
+  end
+end

data/lib/funfig/root.rb

@@ -0,0 +1,32 @@
+require 'funfig/group'
+module Funfig
+  # :stopdoc:
+  class Root < Group
+    attr_reader :_cache
+    def initialize
+      @_cache = {}
+    end
+
+    def _cache_clear!
+      @_cache.clear
+    end
+
+    def _parent
+      raise "Already at root"
+    end
+
+    def _root
+      self
+    end
+    alias _ _root
+
+    def self._path
+      ""
+    end
+
+    def self._sub_name(name)
+      name.to_s
+    end
+  end
+  # :startdoc:
+end

data/lib/funfig/version.rb

@@ -1,3 +1,3 @@
 module Funfig
-  VERSION = "0.0.3"
+  VERSION = "0.0.4"
 end

data/lib/funfig.rb

@@ -1,294 +1,17 @@
 require "funfig/version"
+require "funfig/group"
+require "funfig/root"
+require "funfig/declaration_sugar"
+require "funfig/load"
 require "yaml" unless defined? YAML
 
 module Funfig
-  NOT_SET = Object.new.freeze
-  class ProxyParam < BasicObject
-    def initialize(group)
-      @group = group
-    end
-    def method_missing(name, value = NOT_SET, &block)
-      unless value.equal? NOT_SET
-        @group.param name, value
-      else
-        @group.param name, &block
-      end
-    end
-  end
-
-  class ProxyGroup < BasicObject
-    def initialize(group)
-      @group = group
-    end
-    def method_missing(name, &block)
-      @group.group name, &block
-    end
-  end
-
-  class Group
-    def initialize(parent=nil) # :nodoc:
-      @parent = parent
-    end
-
-    # Get enclosing group
-    def _parent
-      @parent
-    end
-
-    # Get root of configuration
-    # :call-seq:
-    #   _
-    #   _root
-    def _
-      @parent._
-    end
-    alias _root _
-
-    # Update config by yaml file
-    def load_file(filename)
-      params = YAML.load_file(filename)
-      update(params)
-    end
-
-    # Update config by hash
-    def update(hash)
-      if hash.respond_to?(:each)
-        hash.each{|k, v|
-          self.send("#{k}=", v)
-        }
-      end
-    end
-
-    # Iterate over parameter names
-    def each_param
-      return to_enum(:each_param) unless block_given?
-      self.class._params.each{|k, _|
-        yield k
-      }
-    end
-
-    # Iterate over parameters and values
-    # If called with parameter +true+, then iterate only over explicit setted parameters
-    #
-    # :call-seq:
-    #    config.each{|name, value| puts "#{name} = #{value}"}
-    #    config.each(true){|name, value| puts "#{name} = #{value}"}
-    def each(explicit=false)
-      return to_enum(:each, explicit) unless block_given?
-      self.class._params.each{|k, _|
-        yield k, send(k)  unless explicit && !instance_variable_defined?("@#{k}")
-      }
-    end
-
-    # Convert configuration to hash
-    # If called with parameter +true+ than consider only explicit setted parameters
-    def to_hash(explicit=false)
-      h = {}
-      each(explicit){|k, v|
-        if Group === v
-          v = v.to_hash(explicit)
-          next  if explicit && v.empty?
-        end
-        h[k] = v
-      }
-      h
-    end
-
-    def inspect
-      "<#{self.class.name} #{each.map{|k,v| "#{k}=#{v.inspect}"}.join(' ')}>"
-    end
-
-    # :stopdoc:
-
-    def _cache_get(k, &block)
-      _._cache.fetch(_sub_name(k), NOT_SET)
-    end
-
-    def _cache_set(k, v)
-      _._cache[_sub_name(k)] = v
-    end
-
-    def _sub_name(name)
-      self.class._sub_name(name)
-    end
-
-    def _path
-      self.class._path
-    end
-
-    def self._params
-      @params ||= {}
-    end
-
-    def self.initialize_clone(arg)
-      super
-      if @params
-        params, @params = @params, {}
-        params.each{|name, par|
-          if par.is_a?(Class) && Group >= par
-            @params[name] = par.clone
-          else
-            @params[name] = par
-          end
-        }
-      end
-    end
-
-    def self._sub_name(name)
-      "#{_path}.#{name}"
-    end
-
-    # :startdoc:
-
-    # Define named group of values
-    #
-    # :call-seq:
-    #   config = Funfig.new do
-    #     group :name_of_group do
-    #     end
-    #   end
-    def self.group(name, &block)
-      name = name.to_sym
-      vname = :"@#{name}"
-      _prev = _params[name]
-      klass = _prev.is_a?(Class) && Group >= _prev ? _prev : Class.new(Group)
-      _params[name] = klass
-      path = _sub_name(name)
-      const_set name.capitalize, klass
-
-      klass.send(:define_singleton_method, :_path) do
-        path
-      end
-
-      define_method(name) do
-        instance_variable_get(vname) ||
-          instance_variable_set(vname, klass.new(self))
-      end
-
-      define_method("#{name}=") do |hash|
-        send(name).update(hash)  if hash
-      end
-
-      define_method("#{name}_reset!") do
-        _._cache_clear!
-        remove_instance_variable(vname)  if instance_variable_defined?(vname)
-      end
-      klass.class_exec ProxyParam.new(klass), &block
-    end
-
-    # define named parameter
-    #
-    # :call-seq:
-    #   config = Funfig.new do
-    #     param :name_of_param do calculate_default_value end
-    #   end
-    def self.param(name, value = NOT_SET, &block)
-      _params[name] = true
-      vname = :"@#{name}"
-      name = name.to_sym
-
-      block ||= proc{
-        begin
-          value.dup
-        rescue TypeError
-          block = proc { value }
-          value
-        end
-      }
-
-      define_method(name) do
-        if instance_variable_defined?(vname)
-          instance_variable_get(vname)
-        else
-          if (v = _cache_get(name)).equal? NOT_SET
-            raise "Parameter #{_sub_name(name)} must be set!" unless block
-            _cache_set(name, (v = instance_eval &block))
-          end
-          v
-        end
-      end
-
-      define_method("#{name}=") do |v|
-        _._cache_clear!
-        instance_variable_set(vname, v)
-      end
-
-      define_method("#{name}_reset!") do
-        _._cache_clear!
-        remove_instance_variable(vname)  if instance_variable_defined?(vname)
-      end
-    end
-
-    # syntax sugar proxy for declaring params
-    #
-    # :call-seq
-    #   conf = Funfig.new do
-    #     p.name_of_param :default_value
-    #     p.other_param { calculate_default }
-    #   end
-    def self.p
-      @proxy_param ||= ProxyParam.new(self)
-    end
-
-    # syntax sugar proxy for declaring group
-    #
-    # :call-seq
-    #   conf = Funfig.new do
-    #     g.name_of_group do
-    #     end
-    #   end
-    def self.g
-      @group_param ||= ProxyGroup.new(self)
-    end
-
-    # Create a copy of configuration scheme
-    #
-    # :call-seq:
-    #   other_conf = config.clone do
-    #     param :other_value do other_default end
-    #   end
-    def self.clone(&block)
-      new = super
-      new.send(:class_eval, &block)  if block_given?
-      new
-    end
-  end
-
-  # :stopdoc:
-  class Root < Group
-    attr_reader :_cache
-    def initialize
-      @_cache = {}
-    end
-
-    def _cache_clear!
-      @_cache.clear
-    end
-
-    def _parent
-      raise "Already at root"
-    end
-
-    def _
-      self
-    end
-
-    def self._path
-      ""
-    end
-
-    def self._sub_name(name)
-      name.to_s
-    end
-  end
-  # :startdoc:
-
   # Create configuration schema
   #
   # :call-seq:
   def self.new(&block)
     conf = Class.new(Root)
-    conf.class_exec ProxyParam.new(conf), &block
+    conf.class_exec &block
     conf
   end
 end

data/test/test_ini_parser.rb

@@ -0,0 +1,157 @@
+require 'minitest/autorun'
+require 'funfig/ini_parser'
+
+describe Funfig::IniParser do
+  let(:parser){ Funfig::IniParser.new }
+
+  def parse(string)
+    parser.parse(string)
+  end
+
+  it "should parse empty string as empty hash" do
+    parse('').must_equal({})
+  end
+
+  it "should parse simple value" do
+    parse('a=').must_equal(               {'a'=>nil}  )
+    parse("a= \t ").must_equal(           {'a'=>nil}  )
+    parse("a= \t # comment").must_equal(  {'a'=>nil}  )
+    parse('a=1').must_equal(              {'a'=>1}    )
+    parse('a=  1  ').must_equal(          {'a'=>1}    )
+    parse('a=  1  # comment').must_equal( {'a'=>1}    )
+    parse('a=1.0').must_equal(            {'a'=>1.0}  )
+    parse('a=  1.0  ').must_equal(        {'a'=>1.0}  )
+    parse('a= 1.0 # comment').must_equal( {'a'=>1.0}  )
+    parse('a= "b"').must_equal(           {'a'=>'b'} )
+    parse('a= a"b"').must_equal(          {'a'=>'ab'} )
+    parse('a= a "b"').must_equal(         {'a'=>'a b'} )
+    parse('a= a "\\nb"').must_equal(      {'a'=>"a \nb"} )
+    parse("a= a '\\nb'").must_equal(      {'a'=>"a \\nb"} )
+    parse("a= a \t '\nb'").must_equal(       {'a'=>"a \nb"} )
+    parse("a= a \"sdf\nb\"").must_equal(  {'a'=>"a sdf\nb"} )
+  end
+
+  it 'should parse boolean value' do
+    parse('a= true').must_equal(  {'a'=>true}  )
+    parse('a= True').must_equal(  {'a'=>true}  )
+    parse('a= TRUE').must_equal(  {'a'=>true}  )
+    parse('a= Yes ').must_equal(  {'a'=>true}  )
+    parse('a= yes ').must_equal(  {'a'=>true}  )
+    parse('a= false').must_equal( {'a'=>false} )
+    parse('a= False').must_equal( {'a'=>false} )
+    parse('a= FALSE').must_equal( {'a'=>false} )
+    parse('a= No   ').must_equal( {'a'=>false} )
+    parse('a= no   ').must_equal( {'a'=>false} )
+  end
+
+  it "should parse couple of values" do
+    parse("a = 1\n b = 3").must_equal(    {'a'=>1, 'b'=>3})
+    parse("a=1 #comment\n  ; other comment;\n b = 3").must_equal(
+      {'a'=>1, 'b'=>3}
+    )
+  end
+
+  it "should parse nested value" do
+    parse("a.x = 1").must_equal( {'a'=>{'x'=>1}} )
+    parse("a.x.z = 1").must_equal( {'a'=>{'x'=>{'z'=>1}}} )
+  end
+
+  it "should consider section" do
+    parse("[sec]\na.x = 1").must_equal( {'sec'=>{'a'=>{'x'=>1}}} )
+    parse("[sec.a]\nx = 1").must_equal( {'sec'=>{'a'=>{'x'=>1}}} )
+  end
+
+  it "should consider 'global' section as empty" do
+    parse("[global]\na.x = 1").must_equal( {'a'=>{'x'=>1}} )
+    parse("[global.a]\nx = 1").must_equal( {'a'=>{'x'=>1}} )
+  end
+
+  it "should parse multiline value" do
+    val = parse <<-EOF
+      [section]
+      my-value = <<EOV
+                 hello
+                   world!
+               (and others)
+               EOV
+    EOF
+    val.must_equal({'section'=>{
+      'my-value'=>"  hello\n    world!\n(and others)"
+    }})
+    val = parse <<-EOF
+      [section]
+      first_value = No
+      my-value = <<EOV
+                 hello
+                   world!
+               EOV
+      other_value = false
+    EOF
+    val.must_equal({'section'=>{
+      'first_value' => false,
+      'my-value' => "  hello\n    world!",
+      'other_value' => false
+    }})
+  end
+
+  it "should parse oneline yaml" do
+    parse('a = YAML "hi"').must_equal('a'=>'hi')
+    parse('a = YAML hi').must_equal('a'=>'hi')
+    parse('a = YAML hi: ho').must_equal('a'=>{'hi'=>'ho'})
+    parse('a = YAML {hi: ho}').must_equal('a'=>{'hi'=>'ho'})
+    parse('a = YAML [hi, ho]').must_equal('a'=>['hi', 'ho'])
+    parse('a = YAML 2011-01-01').must_equal('a'=>Date.new(2011, 1, 1))
+    parse('a = YAML ["hi:ho", "ya:yo"]').must_equal(
+      'a'=>['hi:ho', 'ya:yo']
+    )
+  end
+
+  it "should parse multiline yaml" do
+    val = parse <<-EOF
+      a = YAML <<EOV
+        - b : 4.0
+          c : Yes
+        - x : {1 : 2012-06-09}
+      EOV
+    EOF
+    val.must_equal({
+      'a' => [
+          { 'b' => 4.0, 'c' => true },
+          { 'x' => {1 => Date.new(2012, 6, 9)} }
+        ]
+    })
+  end
+
+  it "should parse oneline words" do
+    val = parse <<-EOF
+      sockets = WORDS tcp://127.0.0.1:80 udp://10.0.0.1:900
+      paths = WORDS "/here and/there" "/search/ and destroy" true
+      empty = WORDS   # nothing here
+    EOF
+    val.must_equal(
+      'sockets' => ['tcp://127.0.0.1:80', 'udp://10.0.0.1:900'],
+      'paths' => ['/here and/there', '/search/ and destroy', true],
+      'empty' => []
+    )
+  end
+
+  it "should parse multiline words" do
+    val = parse <<-EOF
+      sockets = WORDS <<EOV
+        tcp://127.0.0.1:80 udp://10.0.0.1:900
+        "/here and/there" "/search/ and destroy"
+        true
+      EOV
+      empty = WORDS <<EOV
+      EOV
+    EOF
+    val.must_equal(
+      'sockets' => [
+        'tcp://127.0.0.1:80', 'udp://10.0.0.1:900',
+        '/here and/there', '/search/ and destroy',
+        true
+      ],
+      'empty' => []
+    )
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: funfig
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-05-12 00:00:00.000000000 Z
+date: 2012-06-08 00:00:00.000000000 Z
 dependencies: []
 description: Defines configuration schema with calculable defaults
 email:
@@ -24,7 +24,14 @@ files:
 - Rakefile
 - funfig.gemspec
 - lib/funfig.rb
+- lib/funfig/declaration_sugar.rb
+- lib/funfig/group.rb
+- lib/funfig/ini_parser.rb
+- lib/funfig/load.rb
+- lib/funfig/load_proxy.rb
+- lib/funfig/root.rb
 - lib/funfig/version.rb
+- test/test_ini_parser.rb
 homepage: ''
 licenses: []
 post_install_message: