lab419-config 0.1

data/lib/lab419/config.rb

@@ -0,0 +1,2 @@
+
+require 'lab419/config/reader'

data/lib/lab419/config/data.rb

@@ -0,0 +1,58 @@
+require 'forwardable'
+
+module Lab419
+  module Config
+    class Data
+      extend Forwardable
+      def_delegators :@store, :empty?
+
+      def [] key
+        @store[ key.to_sym ]
+      end
+      def []= key, val
+        case key
+        when String
+           store_value val, key.split(".")
+        when Symbol
+          @store[ key ] = val
+        end
+      end
+      private
+      def initialize params={}
+        @store = {}
+        @overrideable = params[:overrideable]
+      end # def initialize
+
+      def method_missing name, *args, &blk
+        if blk.nil? && args.size == 1 && /=\z/ === name then
+          return self[ name[0..-2] ] = args.first
+        end
+
+        return super( name, *args, &blk ) unless args.empty?
+        @store.fetch( name ){ @store[ name ] = self.class.new( overrideable: @overrideable ) }.
+          tap do | ele |
+            blk[ ele ] if blk
+          end
+      end
+      def store_value val, keys
+        # TODO: This needs HEAVY refactoring
+        last_key = keys.pop
+        child = parent = @store
+        keys.each do | key |
+          child = parent[ key.to_sym ]
+          case child
+          when self.class
+            parent = child
+          when nil
+            parent[ key.to_sym ] = self.class::new
+            child = parent = parent[ key.to_sym ]
+          else
+            raise ArgumentError, "cannot reassign to #{child}"
+          end
+        end
+        raise ArgumentError, "cannot reassign to #{child[last_key]}" if child[last_key]
+        child[ last_key.to_sym ] = val
+      end
+    end # class Data
+  end # module Config
+end # module Lab419

data/lib/lab419/config/parser.rb

@@ -0,0 +1,81 @@
+
+module Lab419
+  module Config
+    IllegalMonitorState = Class::new RuntimeError
+
+    module Parser
+
+      SyntaxError = Class::new RuntimeError
+
+      def parse params={}
+        check_source_setup
+        @params = params
+        @parsed = true
+        loop do
+          @source.next while @source.current && @source.current =~ comment
+          return self if @source.eos?
+          key, value = @source.current.split separator_rgx, 2
+          raise SyntaxError, "No = found in line \"#{key}\"" unless value
+          @config[key.strip] = parse_value value, params
+          @source.next
+        end
+      end
+
+      private
+      def default_handler value
+        case value
+        when /\A\s*"/
+          # TODO: Implement a real string parser
+          value.sub(/.*?"/,"").reverse.sub(/\s*"/,"").reverse
+        when /\A\s*\[\s*(.*)/
+          parse_array $1
+        when /\A\s*\{\s*(.*)/
+          parse_hash $1
+        else
+          value.strip
+        end
+      end
+      # HMMM: This might be overkill?
+      def invocation handler
+        case handler
+        when Symbol
+          send handler
+        when Array
+          handler.next.send( @source, *handler )
+        when Proc
+          handler[ @source ]
+        else
+          raise IllegalHandlerSpec, "#{handler} is neither a sym, array or proc"
+        end
+      end
+      def parse_array current_element
+        result = current_element.strip.empty? ? [] : [ parse_value( current_element ) ]
+        while line = @source.next do
+          if line =~ /\A\s*\]/ then
+            return result
+          end
+          result << parse_value( line )
+        end
+        raise SyntaxError, "missing ]"
+      end
+      def parse_hash current_pair
+        raise SyntaxError, "not yet implemented"
+      end
+      def parse_value value, params={}
+        @handlers.update( params.fetch( :handlers, {} ) ).
+          each do | trigger_rgx, handler |
+            if value =~ trigger_rgx then
+              return invocation( handler )
+            end
+          end
+        return default_handler( value )
+      end
+
+      def check_source_setup
+        raise Lab419::Config::IllegalMonitorState, "source not set up, either call new with a string source or set the source up with
+    one of the with_* methods" unless @source
+
+      end
+    end # module Parser
+  end # module Config
+end # module Lab419

data/lib/lab419/config/reader.rb

@@ -0,0 +1,80 @@
+
+require 'lab419/config/data'
+require 'lab419/config/source'
+require 'lab419/config/parser'
+
+module Lab419
+  module Config
+    IllegalHandlerSpec = Class::new RuntimeError
+    DataError          = Class::new RuntimeError
+    # TODO: code @handler setters, @handler is a dead variable right now
+    #       no specs imply its usage yet
+    class Reader
+      include Parser
+
+      attr_reader :config, :name
+
+      def parsed?; @parsed end
+
+      def handle trigger_rgx, message_name = nil, &blk
+        if message_name && blk || blk.nil? && message_name.nil?
+          raise ArgumentError, "please specify a message_name *or* a block, not both or none"
+        end
+        @handlers.update( trigger_rgx => message_name || blk )
+      end
+      def with_file filename, &blk
+        File.open( filename ) do | f |
+          init_source f, filename
+        end
+        blk[self] if blk
+        self
+      rescue Errno::ENOENT
+        raise DataError, "hmm file: '#{filename}' does not seem to be readable!"
+      end
+
+      def with_string string, &blk
+        init_source string
+        blk[self] if blk
+        self
+      end
+
+      private
+      def comment
+        %r{\A\s*#|\A\s*\z}
+      end
+      def separator_rgx
+        @params.fetch( :separator, %r{\s*=} )
+      end
+      def initialize input=nil
+        @config = Data::new
+        @params = {}
+        @source = nil
+        @parsed = false
+        init_source input if input
+        init_handlers
+      end
+
+      def init_handlers
+        @handlers={}
+      end
+
+      def init_source input, name=nil
+        source = 
+          case input
+          when String
+            input.split( %r{\r?\n} )
+          when Array
+            input
+          when IO
+            input.readlines.map( &:chomp )
+          end
+        @name   = name
+        @source = Lab419::Config::Source::new( source, name )
+      end # def init_source
+      
+      def syntax_error msg=""
+        raise SyntaxError, msg
+      end
+    end  # class Reader
+  end # module Config
+end # module Lab419

data/lib/lab419/config/source.rb

@@ -0,0 +1,56 @@
+
+module Lab419
+  module Config
+    #
+    # Source is a wrapper arround an array of lines, adding the ability to
+    # store the current line_number #line_nb and the name of the source #name.
+    # It implements a minimal interface, allowing to advance line by line via
+    # the #next method, accessing the current element via #current and testing
+    # for the end of the array via the #eos? method
+    #
+    class Source
+
+      attr_reader :name
+
+      #
+      # Readers
+      #
+
+      #
+      # accesses the current element
+      def current
+        @lines[ @cursor ]
+      end
+      # 
+      # true iff #next has advanced over the last line
+      def eos?
+        @lines[ @cursor ].nil?
+      end
+      #
+      # current line number, starting with 1, incremented by each
+      # call of #next, up to a maximum of the size of the underlying
+      # array.
+      def line_nb
+        [ @cursor + 1, @lines.length ].min
+      end
+      
+      # This is the *only* modifier of Source, it
+      # advances to the next line of the underlying array.
+      # The operation is irreversible.
+      def next
+        @cursor += 1
+        current
+      end
+
+      def to_debug
+        "#{@lines[@cursor-1]}:>#{current}<:#{@lines[@cursor+1]}"
+      end
+      private
+      def initialize lines, name=nil
+        @lines  = lines
+        @cursor = 0
+        @name   = name || "<annon>"
+      end
+    end # class Source
+  end # module Config
+end # module Lab419

data/specs/config_data_spec.rb

@@ -0,0 +1,68 @@
+
+$:.unshift File.join( File.dirname( __FILE__ ), %w{ .. lib } )
+require 'lab419/config/data'
+
+describe Lab419::Config::Data do
+  before :each do
+    @data = Lab419::Config::Data::new
+  end
+
+  it "shall not have any data [Symbol]" do
+    @data[:x].should be_nil
+  end
+  it "shall not have any data Method" do
+    @data.x.should be_empty
+  end
+  it "shall recoginze missing methods with params" do
+    lambda{ @data.x(42) }.should raise_error( NoMethodError )
+  end #   it "shall recoginze all other method formats as missing methods"  
+  it "shall recoginze missing methods with params and blocks" do
+    lambda{ @data.x(42){42} }.should raise_error( NoMethodError )
+  end #   it "shall recoginze all other method formats as missing methods"  
+  it "shall not have any data [String]" do
+    @data["x"].should be_nil
+  end
+
+  it "shall store values for simple keys" do
+    @data["x"] = 42
+    @data["x"].should == 42
+  end
+  it "shall store values for simple keys being Str/Sym agnostic" do
+    @data["x"] = 42
+    @data[:x].should == 42
+  end
+
+  describe "compund keys" do
+    before :each do
+      @data["a.b.c"] = 41
+    end #     before :each  
+
+    it "shall intercept the compound key" do
+      @data['a.b.c'].should be_nil
+    end #     it "shall intercept the compound key"  
+
+    it "shall give data objects for intermediates" do
+      @data['a'].should be_kind_of( @data.class )
+    end #     it "shall give data objects for intermediates"  
+
+    it "shall give scalars for final objects" do
+      @data['a'].b[:c].should == 41
+    end #     it "shall give scalars for final objects"  
+
+  end #   describe "compund keys"  
+
+  describe "autoassignment via method" do
+    before :each do
+      @data.x = 42
+      @data.alpha.beta do | d |
+        d.gamma = 41
+      end
+    end
+    it "should have the key" do
+      @data[:x].should == 42
+    end
+    it "should have the compound key" do
+      @data[:alpha].beta.gamma.should == 41
+    end
+  end
+end # describe Lab419::Config::Data  

data/specs/config_reader_spec.rb

@@ -0,0 +1,133 @@
+
+#require 'config_spec_helper'
+$:.unshift File.join( File.dirname( __FILE__ ), %w{ .. lib } )
+require 'lab419/config'
+
+describe Lab419::Config::Reader do
+
+  before :all do
+    @cr = Lab419::Config::Reader::new %{ 
+      a=42
+      b = 43
+      c.d = alpha
+      e = "   "
+      some.list = [ e1
+        e2
+        e3
+        ]
+      empty.list = [
+      ]
+      notha = [
+      1
+      2
+      3
+      ]
+    }
+    @c = @cr.parse.config
+  end
+
+  describe "should contain correct values" do
+    describe "scalars" do
+      it "shall contain :a == 42" do
+        @c[:a].should == "42"
+      end
+      it "shall contain a == 42" do
+        @c["a"].should == "42"
+      end
+      it "shall contain .a == 42" do
+        @c.a.should == "42"
+      end
+      it "shall contain b" do
+        @c.b.should == "43"
+      end
+      it "shall contain subobjects" do
+        @c.c["d"].should == "alpha"
+      end
+      it "shall contain spaces" do
+        @c.e.should == "   "
+      end
+    end
+    describe "arrays" do
+      it "should have e1 to e3" do
+        @c.some.list.should == %w{ e1 e2 e3 }
+      end
+      it "should have an empty list" do
+        @c[:empty].list.should be_empty
+      end #       it "should have an empty list"  
+      it "1,2,3" do
+        @c.notha.should == (1..3).map(&:to_s)
+      end #       it "1,2,3"  
+    end
+  end #   describe "should contain correct values"  
+  describe "can customize the assignment syntax" do
+    before :all do
+      @cr = Lab419::Config::Reader::new %{
+        a: 42
+        b : true
+      }
+      @d = @cr.parse separator: /\s*:/
+    end
+    it "shall see the values" do
+      @d.config.a.should == "42"
+    end #     it "shall see the"  
+  end #   describe "can customize the assignment syntax"  
+  describe "can use custom handlers" do
+    before :all do
+      @cr = Lab419::Config::Reader::new %w{
+        a = 42
+        b.c = nil
+        d = {
+          a, b,
+          c
+        }
+      }
+    end
+  end #   describe "can use custom handlers"  
+end # describe Lab419::ConfigReader  
+
+def should_parse_correctly
+  @cr.config.a.should == '42'
+end
+describe "how to provide data" do
+  before :all do
+    File.open( "xxx", "w" ) do |f|
+      f.puts "a = 42"
+    end
+  end
+  before :each do
+    @cr = Lab419::Config::Reader::new
+  end
+
+  after :all do
+    File.unlink "xxx"
+  end
+
+  it "shall not parse without a source" do
+    lambda{ @cr.parse }.should raise_error( Lab419::Config::IllegalMonitorState )
+  end #   it "shall not parse without a source"  
+  it "shall parse with a string source" do
+    @cr.with_string( "a=42" ).parse
+    should_parse_correctly
+  end
+  it "shall parse with a file source" do
+    @cr.with_file "xxx"
+    @cr.parse
+    should_parse_correctly
+  end
+  it "shall have a correct name" do
+    @cr.with_file "xxx" do | r |
+      r.parse
+      r.config[:a].should == "42"
+    end
+    @cr.parsed?.should == true
+  end
+  it "shall have access to the name" do
+    @cr.with_file "xxx" do | r |
+      r.name.should == "xxx"
+    end # with_file "xxx"  
+  end
+  it "shall raise a DataError if provided file does not exist" do
+    lambda{ @cr.with_file "yyy" }.should raise_error( Lab419::Config::DataError )
+  end #   it "shall raise a DataError if provided file does not exist"  
+end
+