configgy 0.6

data/lib/treetop/configgy.treetop

@@ -0,0 +1,177 @@
+grammar Treetop_Configgy
+  rule root
+    d:declaration* whitespace* {
+      def apply(config_map, parser)
+        d.elements.each { |node| node.apply(config_map, parser) }
+      end
+    }
+  end
+
+  rule declaration
+    whitespace* d:(include_file / assignment / toggle / section) {
+      def apply(config_map, parser)
+        d.apply(config_map, parser)
+      end
+    }
+  end
+
+  rule assignment
+    identifier whitespace* op:("=" / "?=") whitespace* value {
+      def apply(config_map, parser)
+        key = identifier.text_value
+        if (op.text_value == "=") or !config_map.has_key?(key)
+          config_map[key] = value.to_value(config_map)
+        end
+      end
+    }
+  end
+
+  rule toggle
+    identifier whitespace* true_false {
+      def apply(config_map, parser)
+        key = identifier.text_value
+        config_map[key] = true_false.to_value
+      end
+    }
+  end
+
+  rule value
+    number / string / true_false / string_list
+  end
+
+  rule whitespace
+    (" " / "\t" / "\n" / "#" [^\n]* "\n")
+  end
+
+  rule number
+    "-"? [0-9]+ decimal:("." [0-9]+)? {
+      def to_value(config_map=nil)
+        decimal.text_value.empty? ? text_value.to_i : text_value.to_f
+      end
+    }
+  end
+
+  rule string
+    "\"" raw:string_innards* "\"" {
+      def to_value(config_map=nil)
+        rv = raw.elements.inject("") { |total, segment| total + segment.unquoted }
+        config_map ? config_map.interpolate(rv) : rv
+      end
+    }
+  end
+
+  rule string_innards
+    [^\\\"]+ {
+      def unquoted
+        text_value
+      end
+    } / "\\" quoted_entity {
+      def unquoted
+        quoted_entity.unquoted
+      end
+    }
+  end
+
+  rule quoted_entity
+    [^ux] {
+      def unquoted
+        case text_value
+          when "r" then "\r"
+          when "n" then "\n"
+          when "t" then "\t"
+          when "$" then "\\$"
+          else text_value
+        end
+      end
+    } / "u" digits:(hex_digit hex_digit hex_digit hex_digit) {
+      def unquoted
+        [ digits.text_value.to_i(16) ].pack("U")
+      end
+    } / "x" digits:(hex_digit hex_digit) {
+      def unquoted
+        digits.text_value.to_i(16).chr
+      end
+    }
+  end
+
+  rule hex_digit
+    [0-9a-fA-F]
+  end
+
+  rule true_false
+    "true" {
+      def to_value(config_map=nil)
+        true
+      end
+    } / "on" {
+      def to_value(config_map=nil)
+        true
+      end
+    } / "false" {
+      def to_value(config_map=nil)
+        false
+      end
+    } / "off" {
+      def to_value(config_map=nil)
+        false
+      end
+    }
+  end
+
+  rule string_list
+    "[" whitespace* list:(item:(string / number) (whitespace* ",")? whitespace*)* "]" {
+      def to_value(config_map=nil)
+        list.elements.map { |e| e.item.to_value(config_map) }
+      end
+    }
+  end
+
+  rule identifier
+    identifier_token ("\." identifier_token)*
+  end
+
+  rule identifier_token
+    ([\da-zA-Z] [-\da-zA-Z_]*)
+  end
+
+  rule section
+    identifier_token whitespace* attribute_list:("(" whitespace* attributes:(tag_attribute whitespace*)* ")")? whitespace* "{" root "}" {
+      def apply(config_map, parser)
+        new_name = identifier_token.text_value
+        nested_config_map = Configgy::ConfigMap.new(config_map.root, config_map.name == "" ? new_name : config_map.name + "." + new_name)
+        if attribute_list.elements
+          attribute_list.attributes.elements.map { |e| e.tag_attribute }.each do |attr|
+            case attr.name.text_value
+            when "inherit"
+              v = attr.value.to_value
+              if config_map[v].instance_of?(Configgy::ConfigMap)
+                nested_config_map.inherit_from = config_map[v]
+              elsif config_map.root
+                config_map.root[v] = Configgy::ConfigMap.new(config_map.root, v) unless config_map.root.has_key?(v)
+                if config_map.root[v].instance_of?(Configgy::ConfigMap)
+                  nested_config_map.inherit_from = config_map.root[v]
+                else
+                  raise ConfigException("can only inherit from blocks")
+                end
+              end
+            end
+          end
+        end
+        config_map[new_name] = nested_config_map
+        root.apply(nested_config_map, parser)
+      end
+    }
+  end
+
+  rule tag_attribute
+    name:"inherit" "=" value:string
+  end
+
+  rule include_file
+    "include" whitespace* string {
+      def apply(config_map, parser)
+        parser.load_file(string.to_value, config_map)
+      end
+    }
+  end
+end

data/spec/config_map_spec.rb

@@ -0,0 +1,161 @@
+$LOAD_PATH << "lib"
+
+require 'rubygems'
+require 'configgy'
+
+describe "ConfigMap" do
+  before do
+    @map = Configgy::ConfigMap.new(nil, "root")
+  end
+
+  it "sets values" do
+    @map.inspect.should == '{root: }'
+    @map[:name] = "Communist"
+    @map.inspect.should == '{root: name="Communist"}'
+    @map[:age] = 8
+    @map.inspect.should == '{root: age=8 name="Communist"}'
+    @map[:age] = 19
+    @map.inspect.should == '{root: age=19 name="Communist"}'
+    @map[:sleepy] = true
+    @map.inspect.should == '{root: age=19 name="Communist" sleepy=true}'
+  end
+
+  it "gets values" do
+    @map[:name] = "Communist"
+    @map[:age] = 8
+    @map[:sleepy] = true
+    @map[:money] = 1900500400300
+    @map[:name].should == "Communist"
+    @map[:age].should == 8
+    @map[:unknown].should == nil
+    @map[:money].should == 1900500400300
+    @map[:sleepy].should == true
+  end
+
+  it "sets compound values" do
+    @map[:name] = "Communist"
+    @map[:age] = 8
+    @map[:disposition] = "fighter"
+    @map["diet.food"] = "Meow Mix"
+    @map["diet.liquid"] = "water"
+    @map[:data] = "\r\r"
+    @map.inspect.should == '{root: age=8 data="\\r\\r" diet={root.diet: food="Meow Mix" liquid="water"} disposition="fighter" name="Communist"}'
+  end
+
+  it "knows what it contains" do
+    @map[:name] = "Communist"
+    @map[:age] = 8
+    @map["diet.food"] = "Meow Mix"
+    @map["diet.liquid"] = "water"
+    @map["age"].should_not == nil
+    @map["unknown"].should == nil
+    @map["diet.food"].should_not == nil
+    @map["diet.gas"].should == nil
+  end
+
+  it "auto-vivifies" do
+    @map["a.b.c"] = 8
+    @map.inspect.should == "{root: a={root.a: b={root.a.b: c=8}}}"
+    @map["a.d.x"].should == nil
+    @map.inspect.should == "{root: a={root.a: b={root.a.b: c=8}}}"
+  end
+
+  it "compares with ==" do
+    @map[:name] = "Communist"
+    @map[:age] = 8
+    @map["diet.food.dry"] = "Meow Mix"
+    map2 = Configgy::ConfigMap.new(nil, "root")
+    map2[:name] = "Communist"
+    map2[:age] = 8
+    map2["diet.food.dry"] = "Meow Mix"
+    @map.should == map2
+  end
+
+  it "removes values" do
+    @map[:name] = "Communist"
+    @map[:age] = 8
+    @map["diet.food"] = "Meow Mix"
+    @map["diet.liquid"] = "water"
+    @map.inspect.should == '{root: age=8 diet={root.diet: food="Meow Mix" liquid="water"} name="Communist"}'
+    @map.delete("diet.food").should == "Meow Mix"
+    @map.delete("diet.food").should == nil
+    @map.inspect.should == '{root: age=8 diet={root.diet: liquid="water"} name="Communist"}'
+    @map.delete("age").should == 8
+    @map.delete("age").should == nil
+    @map.inspect.should == '{root: diet={root.diet: liquid="water"} name="Communist"}'
+  end
+
+  it "converts to a map" do
+    @map[:name] = "Communist"
+    @map[:age] = 8
+    @map["diet.food"] = "Meow Mix"
+    @map["diet.liquid"] = "water"
+    @map.to_map.should == { "name" => "Communist", "age" => 8, "diet" => { "food" => "Meow Mix", "liquid" => "water" } }
+  end
+
+  it "dupes" do
+    @map[:name] = "Communist"
+    @map[:age] = 8
+    @map["diet.food"] = "Meow Mix"
+    @map["diet.liquid"] = "water"
+    t = @map.dup
+    @map.inspect.should == '{root: age=8 diet={root.diet: food="Meow Mix" liquid="water"} name="Communist"}'
+    t.inspect.should == '{root: age=8 diet={root.diet: food="Meow Mix" liquid="water"} name="Communist"}'
+
+    @map["diet.food"] = "fish"
+    @map[:age] = 9
+    @map.inspect.should == '{root: age=9 diet={root.diet: food="fish" liquid="water"} name="Communist"}'
+    t.inspect.should == '{root: age=8 diet={root.diet: food="Meow Mix" liquid="water"} name="Communist"}'
+  end
+
+  it "dupes with inheritance" do
+    @map[:name] = "Communist"
+    @map[:age] = 8
+    ancestor = Configgy::ConfigMap.new(nil, "ancestor")
+    ancestor[:age] = 12
+    ancestor[:disposition] = "hungry"
+    @map.inherit_from = ancestor
+
+    t = @map.dup
+    @map.inspect.should == '{root (inherit=ancestor): age=8 name="Communist"}'
+    t.inspect.should == '{root: age=8 disposition="hungry" name="Communist"}'
+  end
+
+  it "merges a map" do
+    @map[:name] = "Communist"
+    @map[:age] = 8
+    new_map = @map.merge(:age => 20, :weight => 10)
+    @map[:age].should == 8
+    new_map[:age].should == 20
+    new_map[:name].should == "Communist"
+    new_map[:weight].should == 10
+  end
+
+  it "creates a config string" do
+    @map[:name] = "Sparky"
+    @map[:age] = 10
+    @map[:diet] = "poor"
+    @map["muffy.name"] = "Muffy"
+    @map["muffy.age"] = 11
+    @map["fido.name"] = "Fido"
+    @map["fido.age"] = 5
+    @map["fido.roger.name"] = "Roger"
+    @map["fido.roger"].inherit_from = @map[:muffy]
+    @map.to_config_string.should == <<-END
+age = 10
+diet = "poor"
+fido {
+  age = 5
+  name = "Fido"
+  roger (inherit="root.muffy") {
+    name = "Roger"
+  }
+}
+muffy {
+  age = 11
+  name = "Muffy"
+}
+name = "Sparky"
+END
+  end
+end

data/spec/config_parser_spec.rb

@@ -0,0 +1,283 @@
+$LOAD_PATH << "lib"
+
+require 'rubygems'
+require 'configgy'
+
+describe "ConfigParser" do
+  before do
+    @parser = Configgy::ConfigParser.new
+  end
+
+  def parse(str)
+    @parser.root = :root
+    @parser.read(str)
+  end
+
+  def unquoted(str)
+    @parser.root = :string
+    @parser.parse(str).to_value
+  end
+
+  it "unquotes strings" do
+    unquoted('"nothing"').should == "nothing"
+    unquoted('"name\\tvalue\\t\\x44b\\xfcllet?"').should == "name\tvalue\tDb\xfcllet?"
+    unquoted('"name\\tvalue\\t\\u20acb\\u00fcllet?\\u20ac"').should == "name\tvalue\t\342\202\254b\303\274llet?\342\202\254"
+    unquoted('"she said \\"hello\\""').should == "she said \"hello\""
+    unquoted('"\\\\backslash"').should == "\\backslash"
+    unquoted('"real\\$dollar"').should == "real\\$dollar"
+    unquoted('"silly\\/quote"').should == "silly/quote"
+  end
+
+  it "parses assignment" do
+    parse("weight = 48").inspect.should == "{: weight=48}"
+  end
+
+  it "parses conditional assignment" do
+    parse("weight = 48\n weight ?= 16").inspect.should == "{: weight=48}"
+  end
+
+  it "ignores comments" do
+    parse("# doing stuff\n  weight = 48\n  # more comments\n").inspect.should == "{: weight=48}"
+  end
+
+  it "parses booleans" do
+    parse("wine off\nwhiskey on\n").inspect.should == '{: whiskey=true wine=false}'
+    parse("wine = false\nwhiskey = on\n").inspect.should == '{: whiskey=true wine=false}'
+  end
+
+  it "handles string lists" do
+    b = parse('cats = ["Commie", "Buttons", "Sockington"]')
+    b[:cats].should == [ 'Commie', 'Buttons', 'Sockington' ]
+  end
+
+  it "handles number lists" do
+    b = parse('widths = [ 90, 100 ]')
+    b[:widths].should == [ 90, 100 ]
+  end
+
+  it "handles whole numbers as identifiers" do
+    parse("1 = 2").inspect.should == "{: 1=2}"
+    parse("1 = 2\n 3 = 4").inspect.should == "{: 1=2 3=4}"
+    parse("20 = 1").inspect.should == "{: 20=1}"
+    parse("2 = \"skeletor\"").inspect.should == "{: 2=\"skeletor\"}"
+    parse("4 = \"hostname:1234\"").inspect.should == "{: 4=\"hostname:1234\"}"
+    parse("4 = [\"a\", \"b\"]").inspect.should == "{: 4=[\"a\", \"b\"]}"
+  end
+
+  it "handles lists without comma separators" do
+    b = parse('cats = ["Commie" "Buttons" "Sockington"]')
+    b[:cats].should == [ 'Commie', 'Buttons', 'Sockington' ]
+  end
+
+  it "handles lists with a trailing comma" do
+    b = parse('cats = ["Commie", "Buttons", "Sockington",]')
+    b[:cats].should == [ 'Commie', 'Buttons', 'Sockington' ]
+  end
+
+  it "handles nested blocks" do
+    parse('''alpha="hello"
+             beta {
+               gamma=23
+             }
+          ''').inspect.should == '{: alpha="hello" beta={beta: gamma=23}}'
+    parse('''alpha="hello"
+             beta {
+               gamma=23
+               toaster on
+             }
+          ''').inspect.should == '{: alpha="hello" beta={beta: gamma=23 toaster=true}}'
+    parse('''home {
+               states = ["California", "Tennessee", "Idaho"]
+               regions = ["pacific", "southeast", "northwest"]
+             }
+          ''').inspect.should == '{: home={home: regions=["pacific", "southeast", "northwest"] states=["California", "Tennessee", "Idaho"]}}'
+  end
+
+  it "handles items after closing a block" do
+    parse('''alpha = 17
+             inner {
+               name = "foo"
+               further {
+                 age = 500
+               }
+               zipcode = 99999
+             }
+             beta = 19
+          ''').inspect.should == '{: alpha=17 beta=19 inner={inner: further={inner.further: age=500} name="foo" zipcode=99999}}'
+  end
+
+  it "imports files" do
+    def @parser.load_file(filename, map=nil)
+      if filename == "test1"
+        read("staff=\"weird skull\"\n", map)
+      end
+    end
+
+    parse('''toplevel = "skeletor"
+             inner {
+               include "test1"
+               home = "greyskull"
+             }
+          ''').inspect.should == '{: inner={inner: home="greyskull" staff="weird skull"} toplevel="skeletor"}'
+  end
+
+  it "imports multiple, nested files" do
+    def @parser.load_file(filename, map=nil)
+      if filename == "test2"
+        data = '''
+          inner {
+            cat="meow"
+            include "test3"
+            dog ?= "blah"
+          }
+        '''
+      end
+      if filename == "test3"
+        data = '''
+          dog="bark"
+          cat ?= "blah"
+        '''
+      end
+      if filename == "test4"
+        data = '''
+          cow = "moo"
+        '''
+      end
+      read(data, map)
+    end
+
+    parse('''toplevel = "hat"
+             include "test2"
+             include "test4"
+          ''').inspect.should == '{: cow="moo" inner={inner: cat="meow" dog="bark"} toplevel="hat"}'
+  end
+
+  it "interpolate strings" do
+    parse('horse="ed" word="sch$(horse)ule"').inspect.should == '{: horse="ed" word="schedule"}'
+    parse('lastname="Columbo" firstname="Bob" fullname="$(firstname) $(lastname)"').inspect.should ==
+      '{: firstname="Bob" fullname="Bob Columbo" lastname="Columbo"}'
+  end
+
+  it "doesn't interpolate unassigned strings" do
+    parse('horse="ed" word="sch\\$(horse)ule"').inspect.should == '{: horse="ed" word="sch$(horse)ule"}'
+  end
+
+  it "interpolates nested references" do
+    parse('''horse="ed"
+             alpha {
+               horse="frank"
+               drink="$(horse)ly"
+               beta {
+                 word="sch$(horse)ule"
+                 greeting="$(alpha.drink) yours"
+               }
+             }
+          ''').inspect.should == '{: alpha={alpha: beta={alpha.beta: greeting="frankly yours" word="schedule"} drink="frankly" horse="frank"} horse="ed"}'
+  end
+
+  it "interpolates environment vars" do
+    ENV["GOOBER"] = "sparky"
+    parse('user="$(GOOBER)"').inspect.should != '{: user="sparky"}'
+  end
+
+  it "inherits" do
+    p = parse('''daemon {
+                   ulimit_fd = 32768
+                   uid = 16
+                 }
+
+                 upp (inherit="daemon") {
+                   uid = 23
+                 }
+              ''')
+    p.inspect.should == '{: daemon={daemon: uid=16 ulimit_fd=32768} upp={upp (inherit=daemon): uid=23}}'
+    p["upp.ulimit_fd"].should == 32768
+    p["upp.uid"].should == 23
+  end
+
+  it "uses parent scope for inherit lookups" do
+    p = parse('''daemon {
+                   inner {
+                     common {
+                       ulimit_fd = 32768
+                       uid = 16
+                     }
+                     upp (inherit="common") {
+                       uid = 23
+                     }
+                     slac (inherit="daemon.inner.common") {
+                     }
+                   }
+                 }
+              ''')
+    p["daemon.inner.upp.ulimit_fd"].should == 32768
+    p["daemon.inner.upp.uid"].should == 23
+    p["daemon.inner.slac.uid"].should == 16
+  end
+
+  it "handles block names with dashes" do
+    parse('''horse="ed"
+             daemon {
+               base-dat {
+                 ulimit_fd = 32768
+               }
+             }
+          ''').inspect.should == '{: daemon={daemon: base-dat={daemon.base-dat: ulimit_fd=32768}} horse="ed"}'
+  end
+
+  it "handles an assignment after a block" do
+    parse('''daemon {
+               base {
+                 ulimit_fd = 32768
+               }
+               useless = 3
+             }
+          ''').inspect.should == '{: daemon={daemon: base={daemon.base: ulimit_fd=32768} useless=3}}'
+  end
+
+  it "handles two consecutive groups" do
+    parse('''daemon {
+               useless = 3
+             }
+
+             upp (inherit="daemon") {
+               uid = 16
+             }
+          ''').inspect.should == '{: daemon={daemon: useless=3} upp={upp (inherit=daemon): uid=16}}'
+  end
+
+  it "handles a complex case" do
+    p = parse('''daemon {
+                   useless = 3
+                   base {
+                     ulimit_fd = 32768
+                   }
+                 }
+
+                 upp (inherit="daemon.base") {
+                   uid = 16
+                   alpha (inherit="upp") {
+                     name="alpha"
+                   }
+                   beta (inherit="daemon") {
+                     name="beta"
+                   }
+                   some_int = 1
+                 }
+              ''')
+    p.inspect.should == ('{: daemon={daemon: base={daemon.base: ulimit_fd=32768} useless=3} upp={upp (inherit=daemon.base): ' +
+                         'alpha={upp.alpha (inherit=upp): name="alpha"} beta={upp.beta (inherit=daemon): name="beta"} some_int=1 uid=16}}')
+    p["daemon.useless"].should == 3
+    p["upp.uid"].should == 16
+    p["upp.ulimit_fd"].should == 32768
+    p["upp.name"].should == nil
+    p["upp.alpha.name"].should == "alpha"
+    p["upp.beta.name"].should == "beta"
+    p["upp.alpha.ulimit_fd"].should == 32768
+    p["upp.beta.ulimit_fd"].should == nil
+    p["upp.alpha.useless"].should == nil
+    p["upp.beta.useless"].should == 3
+    p["upp.some_int"].should == 1
+  end
+
+end