configfiles 0.0.1

data/configfiles-example.rb

@@ -0,0 +1,86 @@
+$LOAD_PATH.unshift 'lib'
+
+require 'pp'
+require 'ipaddr'
+require 'configfiles'
+
+class MyConfig < ConfigFiles::Base
+
+  class MyException < Exception; end
+  class MyArgumentError < ArgumentError; end
+
+  # I find more rubystic defining a "conversion"
+  # rater than statically declaring classes ;)
+  parameter :par_integer, :to_i
+  parameter :par_str # no conversion needed
+  parameter :par_custom do |s|
+    s.length 
+  end
+
+  # receive an Enumerator from Parser, and turn into another Enumerator
+  #
+  # NOTE: Enumerable#map_enum would be cool ;-)
+  #
+  # TODO: use facets Enumerable#defer? Mmm, let's try to depend
+  # just on the std lib if possible...
+  #
+  enumerator :iplist do |ipstr| 
+    IPAddr.new(ipstr)
+  end
+
+  validate do |data| 
+    raise MyArgumentError if data[:par_custom] > 100
+    raise MyException unless data[:par_str] =~ /\S+/
+    # or you may use standard exceptions....
+    true
+  end
+
+end
+
+class MyKeyValueParser 
+
+  include ConfigFiles::Parser
+
+  def self.read(io, opt_h={}) 
+    h = {}
+    io.each_line do |line|
+      key_re    = '[\w\d_\-\.]+'
+      value_re  = '[\w\d_\-\.]+'
+      if line =~ /(#{key_re})\s*=\s*(#{value_re})/ 
+        h[$1.to_sym] = $2
+      end
+    end
+    return h
+  end
+end
+
+
+class MyListSlurper
+
+  include ConfigFiles::Parser
+
+  def self.read(io, opt_h={})
+    if block_given?
+      io.each_line do |line|
+        yield line.strip if line =~ /\S/
+      end
+    else
+      enum_for :read, io
+    end
+  end
+
+end
+
+
+
+c = MyConfig.new
+
+parse_result = MyKeyValueParser.read(File.open 'keyval.conf')
+
+c.load parse_result
+
+pp c
+
+
+
+

data/lib/configfiles.rb

@@ -0,0 +1,108 @@
+# Copyright 2010, Guido De Rosa <guido.derosa*vemarsas.it>
+# License: same of Ruby
+
+
+
+module ConfigFiles
+
+  VERSION = 0.0.1
+
+  module Parser
+    def self.read_file(path)
+      self.read File.open path
+    end
+  end
+
+  class Base
+
+    class ArgumentError < ::ArgumentError; end
+    class RuntimeError < ::RuntimeError; end
+
+    @@parameters ||= {}
+    @@options ||= {}
+
+    # examples: 
+    #   on :unknown_parameter, :fail | :accept | :ignore
+    #   on :unknown_parameter, {|str| str.to_i}
+    #
+    def self.on(name, value=nil, &block)
+      if block
+        @@options[name] = block
+      elsif name == :unknown_parameter and value == :accept
+        @@options[name] = lambda {|x| x} 
+      else
+        @@options[name] = value
+      end
+    end
+
+    def self.option(name)
+      @@options[name]
+    end
+
+    def self.parameter(name, converter=nil, &converter_block)
+      if converter
+        if converter_block
+          raise ArgumentError, 'you must either specify a symbol or a block'
+        else
+          converter_block = lambda {|x| x.method(converter).call}
+        end
+      else
+        converter_block ||= lambda {|x| x}  
+      end
+      @@parameters[name] = {
+        :converter  => converter_block
+      }
+    end
+
+    # A special kind of parameter, with a special kind of converter, which in turn
+    # converts an Enumerator of Strings into an Enumerator of custom objects. 
+    # Working with Enumerators instead of
+    # Arrays is the right thing to do when you deal with very long list of
+    # names, IP adresses, URIs etc. 
+    def self.enumerator(name, &block)
+      parameter name do |enum|
+        Enumerator.new do |yielder|
+          enum.each do |string|
+            yielder << block.call(string) 
+          end
+        end
+      end
+    end
+
+    def self.validate(&block)
+      @@validate = block
+    end
+
+    attr_accessor :options, :data
+
+    def initialize
+      @options = @@options.dup
+      @data = {}
+      def @data.missing_method(id); @data[id]; end
+    end
+
+    def validate
+      @@validate.call(@data)
+    end
+
+    def load(h)
+      h.each_pair do |id, value|
+        if @@parameters[id][:converter]
+          @data[id] = @@parameters[id][:converter].call(value)
+        elsif @options[:unknown_parameter] == :fail
+          raise RuntimeError, "unknown parameter #{key}" # otherwise ignore
+        elsif @options[:unknown_parameter].respond_to? :call
+          block = @options[:unknown_parameter]
+          @data[id] = block.call value
+        end
+      end
+      validate  
+    end
+
+    def flush
+      @data = {}
+    end
+
+  end
+
+end

metadata

@@ -0,0 +1,63 @@
+--- !ruby/object:Gem::Specification 
+name: configfiles
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Guido De Rosa
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-08-03 00:00:00 +02:00
+default_executable: 
+dependencies: []
+
+description: "A simple library to specify the format of configuration files and the way to turn them into Ruby objects. Ruby1.9 centric. It supports lazy lists. No write support: it's strongly sugested to use ERB or other templating systems for that."
+email: guido.derosa@vemarsas.it
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- configfiles-example.rb
+- lib/configfiles.rb
+has_rdoc: true
+homepage: http://github.com/gderosa/configfiles
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: A simple library to specify the format of configuration files and the way to turn them into Ruby objects.
+test_files: []
+