figtree 1.2.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 027349cba07d928b55c539c415a8677994c2ad4f
-  data.tar.gz: 2f16fbdf432e44763f6d07fee7d56f31a96f1b72
+  metadata.gz: 027e03ceb0e9b227e731efdacc239459ee0a344b
+  data.tar.gz: cda00334893c5bbc8c7d2c299ad91f35c6df4859
 SHA512:
-  metadata.gz: 70cd81c1f602ddb2b8e845958ad005592c663abb8fe5d7b85a69a4db618fea5408b11312013484ec49cd42595f3495869c30a3bf48483acf8af352eab220e0d1
-  data.tar.gz: 3cc856774fb2130c8152e24e25e63b2f5561a9eea951fccffeb2f906c9d752072a3e1e06fc260b43a761c06a3e032810e802eac0389b701eda69119ba6bfb5bf
+  metadata.gz: 76e628f7ef15ff4474d8f2bc09adfa02b2c6a315607b68b2c3879a1b12e1938022e05b0a82aecccc70ab7c47e011109cc4eb46de9c8d5dcbc353a03b310e8979
+  data.tar.gz: a6552300f61d0d71020667b41a01e37ecc9bdc09f4b87888eef1b547d496fa2ced5783a4f5cff170da637a1e7e51dfc939a88ba8b8ae7b66e03fae5fc61a00c4

data/README.md

@@ -11,10 +11,17 @@
 
 # Figtree
 ## about
-A parser and transformer for loading `.ini` files into Ruby dot notation accessible objects. `.ini` is not a standardized format. But the parser and transformer are easy to extend, unlike regex. :) And it's at 100% LOC coverage.
+A parser and transformer for loading `.ini` files into Ruby dot notation accessible objects. `.ini` is not a standardized format. But the parser and transformer are easy to extend.
+
+The goal of figtree is not to accept all `.ini` files generously, but more strictly define `.ini` files so we can make smarter guesses about how to covert your settings into objects.
+
+What kinds of objects are supported? Currently we can recognize [unix style filepaths into Pathname](http://ruby-doc.org/stdlib-2.0.0/libdoc/pathname/rdoc/Pathname.html), [ip4 and ip6 addresses into IPAddr](http://ruby-doc.org/stdlib-2.0.0/libdoc/ipaddr/rdoc/IPAddr.html), and most common Ruby types (String, Array, Boolean, Integer). If there's other types you'd like to see supported, please [file an issue](https://github.com/mooreniemi/figtree/issues/new).
 
 If the `.ini` file is invalid, an error will be raised, with the line and char position of the error. If you extend this gem to have more rules, and one of those rules fails to transform, you will have an error raised.
 
+## alternatives
+If you want an industrial strength, pure Ruby solution, check out [inifile gem](https://github.com/TwP/inifile). It is much looser about what it accepts as valid `.ini` files, and with no pesky dependencies! If you want to see exactly which cases `figtree` supports vs `inifile`, compare our spec files. Many of the cases in our `invalid/` folder `inifile` will parse for you.
+
 ## disambiguation
 Looking for the graphical viewer of phyllogenic trees? You want this other [Figtree](http://tree.bio.ed.ac.uk/software/figtree/).
 
@@ -43,13 +50,15 @@ A typical `.ini` file takes slightly less than 0.02s to be parsed, transformed,
     => "/srv/var/tmp/"
 
 ## development
-### installation
-`bundle install`
+### helpers
+`bin/setup`
+`bin/console`
+
+While in console, you can use `parse_ini_named name` and as long as it's in `spec/support/name.ini` it'll parse it for you with helpful error output. Sometimes this is a faster feedback mechanism than going through the tests.
 
 ### tests
 `rspec spec/`
 
 #### TODO
-- move way from needing to parse whole file at once? (move to `IO.foreach` ?)
+- more cleanup
 - give char/line position of transformer failures
-- refactor marked TODO listings in files (mostly refactoring to generic in Transformer)

data/bin/console

@@ -0,0 +1,20 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "figtree"
+
+require "parslet/convenience"
+
+parser = Figtree::Parser.new
+
+require "pry"
+command_set = Pry::CommandSet.new do
+  command "parse_ini_named", "", :keep_retval => true do |name|
+    parser = Figtree::Parser.new
+    ini_as_string = File.read("spec/support/#{name}.ini")
+    parser.parse_with_debug(ini_as_string)
+  end
+end
+
+#Pry.start parser, :commands => command_set
+Pry.start nil, :commands => command_set

data/bin/setup

@@ -0,0 +1,8 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install
+
+# Do any other automated setup that you need to do here
+

data/lib/figtree/ini_config.rb

@@ -20,9 +20,13 @@ module Figtree
 
     def figgy_parse(str)
       Parser.new.parse(str)
-    rescue Parslet::ParseFailed => failure
+      # argument error is invalid byte sequence
+    rescue Parslet::ParseFailed, ArgumentError => failure
+      if failure.class == Parslet::ParseFailed
+        failure = failure.cause.ascii_tree
+      end
       STDERR.puts "\nInvalid ini file.\n" +
-        "Error: #{failure.cause.ascii_tree}" +
+        "Error: #{failure}" +
         "Please correct the file and retry."
         raise
     end

data/lib/figtree/parser.rb

@@ -8,33 +8,73 @@ module Figtree
     include IPv6
 
     rule(:eof) { any.absent? }
-    rule(:group_title) { match('[a-zA-Z]').repeat(1) }
-    rule(:space) { match("\s").repeat(0) }
-    rule(:newline) { match("\n") >> match("\r").maybe }
+    rule(:group_title) { match('[a-zA-Z_]').repeat(1) }
+    rule(:space) { (match("\s") | str(' ')) }
+    rule(:spaces) { (space.repeat(2) | comment) }
+    rule(:newline) { str("\n") >> match("\r").maybe }
+    rule(:terminator) do
+      space.repeat(0) >> (comment | newline | eof)
+    end
+    rule(:backslash) do
+      space.repeat(0) >> str("\\")
+    end
 
     rule(:grouper) do
-      newline.maybe >>
       str('[') >>
       group_title.as(:group_title) >>
       str(']')
     end
 
+    rule(:comment_start) { (str(';') | str('#')) }
+    rule(:comment_end) { (newline | eof) }
     rule(:comment) do
-      # comments go uncaptured
-      (str(';') >>
-       (newline.absent? >> any).repeat) >>
-      newline.maybe
+      (
+        comment_start >>
+        space.repeat(0) >>
+        (
+          comment_end.absent? >> any
+        ).repeat
+      ) >>
+      space.repeat(0) >>
+      comment_end
+    end
+
+    rule(:quoted_string) do
+      str('"') >>
+      (
+        (str('\\') >> any) | (str('"').absent? >> any)
+      ).repeat(1) >>
+      str('"')
+    end
+
+
+    rule(:unquoted_string) do
+      (
+        (
+          (
+            (backslash | terminator).absent?
+          ) >> any
+        ).repeat(1).as(:left) >>
+        backslash >>
+        terminator
+      ).repeat(0) >>
+      (
+        terminator.absent? >> any
+      ).repeat(1).as(:right) >>
+      terminator
     end
 
     rule(:string) do
-      str('"') >>
-      ((str('\\') >> any) | (str('"').absent? >> any)).repeat.as(:string) >>
-      str('"')
+      (quoted_string | unquoted_string).as(:string)
     end
 
     rule(:boolean) do
-      # expand this check
-      (str('no') | str('yes')).as(:boolean)
+      (
+        str('no') |
+        str('yes') |
+        str('false') |
+        str('true')
+      ).as(:boolean)
     end
 
     rule(:number) do
@@ -45,19 +85,36 @@ module Figtree
       (ipv4 | ipv6).as(:ip_address)
     end
 
+    rule(:at_least_one_char) do
+      match('[a-zA-Z]').repeat(1)
+    end
+
     rule(:array) do
-      (match('[a-zA-Z]').repeat(1) >>
-       (str(',') >>
-        match('[a-zA-Z]').repeat(1)).repeat.maybe).maybe.as(:array) >>
-      (str(',') | newline | eof)
+      (
+        # minimum array
+        at_least_one_char >>
+        (
+          # extending elementwise
+          str(',') >> space.repeat.maybe >>
+          at_least_one_char
+        ).repeat(1)
+      ).as(:array) >>
+      (newline | eof)
     end
 
     rule(:file_path) do
-      match('[/a-z/]').repeat(1).as(:file_path)
+      (
+        (
+          str('/') >>
+          at_least_one_char
+        ).repeat(1) >>
+        str('/').maybe
+      ).as(:file_path)
     end
 
     rule(:snake_case_key) do
-      match('[a-zA-Z0-9_]').repeat(1).as(:snake_case_key)
+      match('[a-zA-Z0-9_]').repeat(1).
+        as(:snake_case_key)
     end
 
     rule(:snakey_option_key) do
@@ -67,29 +124,36 @@ module Figtree
       str('>')
     end
 
-    rule(:assignment) do
-      snake_case_key >>
-      space >>
-      str("=") >>
-      space >>
+    rule(:value) do
       # this ordering matters
       # we are roughly moving from more
       # to less specific
-      (ip_address |
-       number |
-       boolean |
-       array |
-       snake_case_key |
-       file_path |
-       string)
+      (
+        ip_address |
+        number |
+        boolean |
+        array |
+        file_path |
+        string
+      )
+    end
+
+    rule(:equals_value) do
+      space.repeat(0) >>
+      str("=") >>
+      space.repeat(0) >>
+      value >>
+      newline.repeat(0)
+    end
+
+    rule(:assignment) do
+      snake_case_key >>
+      equals_value
     end
 
     rule(:override_assignment) do
       snakey_option_key >>
-      space >>
-      str("=") >>
-      space >>
-      file_path
+      equals_value
     end
 
     rule(:assignment_or_comment) do
@@ -97,21 +161,27 @@ module Figtree
     end
 
     rule(:group_member) do
-      newline.maybe >>
       assignment_or_comment >>
-      newline.maybe
+      space.repeat(0) >>
+      newline.repeat(0)
     end
 
     rule(:group) do
-      (grouper >>
-       group_member.repeat.maybe).as(:group).
-      repeat.maybe
+      (
+        grouper >>
+        space.repeat(0) >>
+        comment.maybe >>
+        newline.repeat(0) >>
+        group_member.repeat(0)
+      ).as(:group).
+      repeat(0)
     end
 
     rule(:comment_or_group) do
-      comment.maybe >>
-      newline.maybe >>
-      group.maybe
+      # may start file with attribution
+      # comment or timestamp etc
+      comment.repeat.maybe >>
+      group
     end
 
     root(:comment_or_group)

data/lib/figtree/transformer.rb

@@ -4,71 +4,84 @@ require 'ipaddr'
 require 'wannabe_bool'
 
 module Figtree
-	# a transformer takes a parsed, valid AST and applies rules, usually
-	# in a context free manner
-	class Transformer < Parslet::Transform
-		# TODO these could largely be consolidated with some rearrangement
-		# these are all type conversions
-		rule(:snake_case_key => simple(:key), :number => simple(:value)) do
-			{
-				key.to_sym => Integer(value)
-			}
-		end
-		rule(:snake_case_key => simple(:key), :string => simple(:value)) do
-			{
-				key.to_sym => String(value)
-			}
-		end
-		rule(:snake_case_key => simple(:key), :file_path => simple(:value)) do
-			{
-				key.to_sym => String(value)
-			}
-		end
-		# depends on wannabe_bool refining String class
-		rule(:snake_case_key => simple(:key), :boolean => simple(:value)) do
-			{
-				key.to_sym => String(value).to_b
-			}
-		end
-		rule(:snake_case_key => simple(:key), :array => simple(:value)) do
-			{
-				key.to_sym => String(value).split(",")
-			}
-		end
+  # a transformer takes a parsed, valid AST and applies rules, usually
+  # in a context free manner
+  class Transformer < Parslet::Transform
+    rule(:snake_case_key => simple(:key), :number => simple(:value)) do
+      {
+        key.to_sym => Integer(value)
+      }
+    end
+    rule(:snake_case_key => simple(:key), :string => subtree(:value)) do
+      merged_string =
+        case value
+        when Hash
+          value[:right]
+        when Array
+          value.inject("") do |string, element|
+            if !element[:left].nil?
+              string + element[:left]
+            else
+              string + element[:right]
+            end
+          end
+        else
+          value
+        end
+      {
+        # remove whitespace after cast
+        key.to_sym => String(merged_string).strip
+      }
+    end
+    rule(:snake_case_key => simple(:key), :file_path => simple(:value)) do
+      {
+        key.to_sym => Pathname.new(value)
+      }
+    end
+    # depends on wannabe_bool refining String class
+    rule(:snake_case_key => simple(:key), :boolean => simple(:value)) do
+      {
+        key.to_sym => String(value).to_b
+      }
+    end
+    rule(:snake_case_key => simple(:key), :array => simple(:value)) do
+      {
+        key.to_sym => String(value).split(",")
+      }
+    end
 
-		rule(:snake_case_key => simple(:key), :ip_address => subtree(:value)) do
-			# right now we're not distinguishing what kind of ip it is
-			{
-				key.to_sym => IPAddr.new((value.values.first.to_s))
-			}
-		end
+    rule(:snake_case_key => simple(:key), :ip_address => subtree(:value)) do
+      {
+        key.to_sym => IPAddr.new((value.values.first.to_s))
+      }
+    end
 
-		# ini files are trees of a fixed height, if the file handle is the root
-		# subgroups are its children, and subgroup members are the next level of children
-		rule(:group => subtree(:group_members)) do
-			group_title = group_members[0][:group_title].to_sym
-			group_values = Subgroup.new(group_members[1..-1].reduce({}, :merge!))
-			{
-				group_title => group_values
-			}
-		end
+    # ini files are trees of a fixed height, if the file handle is the root
+    # subgroups are its children, and subgroup members are the next level of children
+    rule(:group => subtree(:group_members)) do
+      group_title = group_members[0][:group_title].to_sym
+      group_values = Subgroup.new(group_members[1..-1].reduce({}, :merge!))
+      {
+        group_title => group_values
+      }
+    end
 
-		# where does overrides come from? an argument into #apply on
-		# Transformer, that allows an additional capture outside the AST
-		# to be added to the context of the transform
-		rule(
-			:key_to_be_overridden => subtree(:overridden_key),
-			:optional_key => subtree(:overriding_key),
-			:file_path => subtree(:new_file_path),
-		) do
-			if override.to_sym == overriding_key[:snake_case_key].to_sym
-				{
-					overridden_key[:snake_case_key] => String(new_file_path)
-				}
-			else
-				{
-				}
-			end
-		end
-	end
+    # where does overrides come from? an argument into #apply on
+    # Transformer, that allows an additional capture outside the AST
+    # to be added to the context of the transform
+    rule(
+      :key_to_be_overridden => subtree(:overridden_key),
+      :optional_key => subtree(:overriding_key),
+      :file_path => subtree(:new_file_path),
+    ) do
+      if override.to_sym == overriding_key[:snake_case_key].to_sym
+        {
+          overridden_key[:snake_case_key] => Pathname.new(new_file_path)
+        }
+      else
+        {
+        }
+      end
+    end
+  end
 end

data/lib/figtree/version.rb

@@ -1,5 +1,5 @@
 module Figtree
 	# for reference see
 	# http://guides.rubygems.org/patterns/#semantic-versioning
-  VERSION = "1.2.0"
+  VERSION = "2.0.0"
 end

data/spec/figtree/parser_spec.rb

@@ -3,79 +3,154 @@ require 'spec_helper'
 module Figtree
   describe Parser do
     let(:parser) { Parser.new }
+    let(:string) do
+      "a bb ccc dddd eeeee ffffff\n"
+    end
+
     it 'can parse newlines' do
       expect(parser.newline).to parse("\n")
+      expect(parser.newline).to_not parse("\\n")
+      expect(parser.newline).to_not parse("\\\n")
+    end
+    it 'terminates correctly' do
+      expect(parser.terminator).to parse("     #comment")
+      expect(parser.terminator).to parse("     #comment\n")
+      expect(parser.terminator).to parse("   \n")
+      expect(parser.terminator).to parse("   ")
+      expect(parser.unquoted_string).to parse("f    #ffoo")
+      expect(parser.unquoted_string).to parse("f    #ffoo\n")
     end
     it 'can parse group names' do
       expect(parser.grouper).to parse('[common]')
+      expect(parser.grouper).to parse('[common_also]')
     end
     it 'can parse comments' do
       expect(parser.comment).to parse("; This is a comment\n")
+      expect(parser.comment).to parse("# This is also a comment\n")
       expect(parser.comment).to parse("; last modified 1 April 2001 by John Doe\n")
+      expect(parser.comment).to parse("#comment \\n")
       comment_first = File.open('spec/support/wiki_example.ini', &:readline)
       expect(parser.comment).to parse(comment_first)
     end
-    it 'can parse comments then groups' do
-      expect(parser.comment_or_group).to parse("; comment\n[groop]\nassignment = present")
-    end
     it 'can parse snake_case keys' do
       expect(parser.snake_case_key).to parse('basic_size_limit')
     end
-    it 'can parse strings' do
-      expect(parser.string).to parse('"hello there, ftp uploading"')
+
+    describe 'strings of all kinds' do
+      it 'can parse spaces' do
+        expect(parser.spaces).to parse("#foo")
+        expect(parser.spaces).to parse("# foo")
+        expect(parser.spaces).to parse("# foo\n")
+        expect(parser.spaces).to_not parse(" ")
+        expect(parser.spaces).to_not parse("\s")
+        expect(parser.spaces).to_not parse("a b")
+      end
+      it 'can parse strings' do
+        expect(parser.string).to parse('"hello there, ftp uploading"')
+      end
+      it 'can parse unquoted strings' do
+        expect(parser.unquoted_string).to parse(string)
+        expect(parser.unquoted_string).to parse("multiline \\\nsupport\n")
+      end
+      it 'can parse multiline with comment' do
+        expect(parser.unquoted_string).to parse("a #comment\n")
+        expect(parser.unquoted_string).to parse("a #")
+        expect(parser.unquoted_string).to_not parse("a\nb")
+        expect(parser.unquoted_string).to parse("a \\#comment\n b\n")
+        expect(parser.assignment).to parse("foo = a \\nb\n")
+        expect(parser.assignment).to parse("foo = a \\   # and here, too\nb\n")
+
+        group = "[section_three]\nthree   = hello \\\nmultiline\nother = 2"
+        expect(parser.group).to parse(group)
+
+        multiline_only = File.read('spec/support/multiline_only.ini')
+        expect(parser.group).to parse(multiline_only)
+      end
     end
+
     it 'can parse arrays' do
-      expect(parser.array).to parse("a,")
+      expect(parser.array).to_not parse(',,')
+      expect(parser.array).to_not parse("a\n")
+      expect(parser.array).to_not parse("a,")
+      expect(parser.array).to parse("a,b\n")
       expect(parser.array).to parse("a,b")
       expect(parser.array).to parse("a,b,c\n")
-      expect(parser.array).to_not parse(',,')
+      expect(parser.array).to parse("words, with, spaces, after\n")
+      expect(parser.array).to parse("several,diff,words,only,nonumbers\n")
       expect(parser.array).to parse("array,of,values\n")
       expect(parser.array).to parse("array,of,values")
     end
+
     it 'can parse numbers' do
       expect(parser.number).to parse("26214400")
     end
+
     it 'can parse ip addresses' do
       expect(parser.ip_address).to parse("FE80:0000:0000:0000:0202:B3FF:FE1E:8329")
       expect(parser.ip_address).to parse('111.222.3.4')
-			expect(parser.ip_address).to parse('192.0.2.62')
+      expect(parser.ip_address).to parse('192.0.2.62')
       expect(parser.ip_address).to_not parse('f11.222.3.4')
       expect(parser.ip_address).to_not parse('111.222.3')
     end
     it 'can parse booleans flexibly' do
       expect(parser.boolean).to parse("no")
       expect(parser.boolean).to parse("yes")
-    end
-    it 'can parse assignments' do
-      expect(parser.assignment).to parse('basic_size_limit = 26214400')
-      expect(parser.assignment).to parse('path = /srv/var/tmp/')
-      expect(parser.assignment).to_not parse('path<itscript> = /srv/tmp/')
-      expect(parser.assignment).to parse('name = "hello there, ftp uploading"')
-      expect(parser.assignment).to parse('params = array,of,values')
-    end
-    it 'can parse keys with optional overrides' do
-      expect(parser.snakey_option_key).to parse('path<itscript>')
+      expect(parser.boolean).to parse("true")
+      expect(parser.boolean).to parse("false")
     end
     it 'can parse file_paths' do
       expect(parser.file_path).to parse('/srv/tmp/')
+      expect(parser.file_path).to_not parse(string)
     end
-    it 'can parse overrides' do
-      expect(parser.override_assignment).to parse('path<itscript> = /srv/tmp/')
+
+    describe 'overriding stuff' do
+      it 'can parse keys with optional overrides' do
+        expect(parser.snakey_option_key).to parse('path<itscript>')
+      end
+      it 'can parse overrides' do
+        expect(parser.override_assignment).to parse('path<itscript> = /srv/tmp/')
+      end
     end
 
-    describe "using the settings.conf file for input" do
+    describe "building up from root, checking group, etc" do
       let(:settings_path) { 'spec/support/settings.conf' }
       let(:multi_group) {
         [
           "[common]",
           "basic_size_limit = 234234",
           "[rare]",
-          "pepes = 0"
+          "pepes = 0",
+          "and = feels guy"
         ].join("\n") + "\n"
       }
 
+      it 'can parse assignments' do
+        expect(parser.assignment).to parse('basic_size_limit = 26214400')
+        expect(parser.assignment).to parse('path = /srv/var/tmp/')
+        expect(parser.assignment).to_not parse('path<itscript> = /srv/tmp/')
+        expect(parser.assignment).to parse('name = "hello there, ftp uploading"')
+        expect(parser.assignment).to parse('params = array,of,values')
+        expect(parser.assignment).to parse("hostname = My Computer\n")
+      end
+      it 'can parse comments then groups' do
+        expect(parser.comment_or_group).to parse("; comment\n[groop]\nassignment = 0\n")
+      end
+      it 'parses comment or group' do
+        expect(parser.comment_or_group).to parse("[database]\nserver = 192.0.2.62")
+      end
       it 'parses a group member' do
-        expect(parser.group_member).to parse("\nbasic_size_limit = 26214400\n")
+        expect(parser.group_member).to parse("basic_size_limit = 26214400\n")
+      end
+      it 'can parse group members with inline comments' do
+        group_with_comments = "[section_two]  # you can comment here" +
+          "\none = 42       # and even here!"
+        expect(parser.group).to parse(group_with_comments)
+      end
+      it 'can parse assignment irrespective of spacing' do
+        expect(parser.assignment).
+          to parse("basic_size_limit=         26214400\n")
+        expect(parser.assignment).
+          to parse("basic_size_limit          = 26214400\n")
       end
       it 'can parse single assignment inside a group' do
         expect(parser.group).
@@ -85,6 +160,10 @@ module Figtree
         expect(parser.group).
           to parse("[common]\nbasic_size_limit = 26214400\nstudent_size_limit = 52428800\n")
       end
+      it 'can parse values including strings' do
+        group_member = "hostname = #{string}"
+        expect(parser.group_member).to parse(group_member)
+      end
       it 'can parse multiple groups' do
         expect(parser.group).to parse(multi_group)
       end

data/spec/figtree/transformer_spec.rb

@@ -12,8 +12,12 @@ module Figtree
 			let(:bool_tree) do
 				Parser.new.parse("[ftp]\nenabled = no\n")
 			end
+			let(:string_tree) do
+        Parser.new.parse_with_debug("[database]\nserver = is here\n")
+				Parser.new.parse("[database]\nserver = is here\n")
+			end
 			let(:ip_tree) do
-				Parser.new.parse("[database]\nserver=192.0.2.62")
+				Parser.new.parse("[database]\nserver = 192.0.2.62")
 			end
 			it 'can apply an int type conversion' do
 				expect(Transformer.new.apply(int_tree)).to eq(
@@ -42,6 +46,15 @@ module Figtree
 					]
 				)
 			end
+			it 'it can apply a string type conversion' do
+				expect(Transformer.new.apply(string_tree)).to eq(
+					[
+						{
+							database: Subgroup.new(server: "is here")
+						}
+					]
+				)
+			end
 			it 'it can apply an ip address type conversion' do
 				expect(Transformer.new.apply(ip_tree)).to eq(
 					[
@@ -60,7 +73,7 @@ module Figtree
 				expect(Transformer.new.apply(override_tree, override: :production)).to eq(
 					[
 						{
-							http: Subgroup.new(path: '/srv/var/tmp/')
+              http: Subgroup.new(path: Pathname.new('/srv/var/tmp/'))
 						}
 					]
 				)

data/spec/figtree_spec.rb

@@ -1,6 +1,4 @@
 require 'spec_helper'
-# for the performance test at bottom
-require 'benchmark'
 
 describe Figtree do
   describe '#load_config' do
@@ -10,7 +8,7 @@ describe Figtree do
         :basic_size_limit => 26214400,
         :student_size_limit => 52428800,
         :paid_users_size_limit => 2147483648,
-        :path => "/srv/var/tmp/",
+        :path => Pathname.new("/srv/var/tmp/"),
       )
     end
 
@@ -19,7 +17,7 @@ describe Figtree do
         :basic_size_limit => 26214400,
         :student_size_limit => 52428800,
         :paid_users_size_limit => 2147483648,
-        :path => "/srv/tmp/",
+        :path => Pathname.new("/srv/tmp/"),
       )
     end
 
@@ -32,15 +30,15 @@ describe Figtree do
                 :basic_size_limit => 26214400,
                 :student_size_limit=> 52428800,
                 :paid_users_size_limit=> 2147483648,
-                :path=> "/srv/var/tmp/"
+                :path=> Pathname.new("/srv/var/tmp/")
               }
             )
           },
           {
             ftp: Figtree::Subgroup.new(
               {
-                :name => "hello there, ftp uploading",
-                :path => "/tmp/",
+                :name => "\"hello there, ftp uploading\"",
+                :path => Pathname.new("/tmp/"),
                 :enabled => false
               }
             )
@@ -48,8 +46,8 @@ describe Figtree do
           {
             http: Figtree::Subgroup.new(
               {
-                :name => "http uploading",
-                :path => "/tmp/",
+                :name => "\"http uploading\"",
+                :path => Pathname.new("/tmp/"),
                 :params => ["array", "of", "values"]
               }
             )
@@ -70,24 +68,68 @@ describe Figtree do
     end
 
     it 'can parse the wiki example' do
-			wiki_example = Figtree::IniConfig.new('spec/support/wiki_example.ini')
+      wiki_example = Figtree::IniConfig.new('spec/support/wiki_example.ini')
       expect(wiki_example.database.server).to_not be_nil
     end
 
     context "performance" do
+      require 'benchmark'
       it 'can parse the whole ini file quickly' do
         expect(
           Benchmark.realtime do
             Figtree::IniConfig.new(settings_path)
           end
         ).to be < 0.025
-				# without ip_address parsing this was under 0.014 :(
+        # without ip_address parsing this was under 0.014 :(
+      end
+    end
+
+    context "checking full transform" do
+      let(:mini_ini_file) { 'spec/support/mini_ini_example.ini' }
+      let(:mini_ini_config) do
+        Figtree::IniConfig.new(
+          {
+            Network: Figtree::Subgroup.new(
+              hostname: "My Computer",
+              address: "dhcp",
+              dns: IPAddr.new("192.168.1.1")
+            )
+          }
+        )
+      end
+
+      it 'parses unquoted strings properly' do
+        expect(Figtree::IniConfig.new(mini_ini_file)).
+          to eq(mini_ini_config)
+      end
+    end
+
+    context "comparing to inifile gem" do
+      it 'does not parse anything INIFile gem cant parse' do
+        bad_ini_files = Dir["spec/support/invalid/*.ini"]
+        bad_ini_files.each do |ini_file|
+          #puts "\nfile is: #{ini_file}"
+          expect{ Figtree::IniConfig.new("#{ini_file}") }.
+            to raise_error
+        end
+      end
+      it 'can parse a subset of what INIFile gem can parse' do
+        ini_files = Dir["spec/support/*.ini"]
+        ini_files.each do |ini_file|
+          #puts "\nfile is: #{ini_file}"
+          expect(Figtree::IniConfig.new("#{ini_file}")).
+            to be_a Figtree::IniConfig
+        end
       end
     end
 
     context "invalid ini file" do
-      let(:unparseable_config) { 'spec/support/unparseable_settings.conf' }
-      let(:untransformable_config) { 'spec/support/untransformable_settings.conf' }
+      let(:unparseable_config) do
+        'spec/support/invalid/unparseable_settings.conf'
+      end
+      let(:untransformable_config) do
+        'spec/support/invalid/untransformable_settings.conf'
+      end
       it 'throws ParseFailed if unparseable' do
         expect { Figtree::IniConfig.new(unparseable_config) }.
           to raise_error(Parslet::ParseFailed)

data/spec/spec_helper.rb

@@ -14,6 +14,10 @@ Dir[File.join(File.dirname(__FILE__), "..", "lib" , "**.rb")].each do |file|
   require file
 end
 
+# because we raise more than one error type from invalid
+# this should prob be avoided though
+RSpec::Expectations.configuration.warn_about_potential_false_positives = false
+
 RSpec.configure do |config|
   # quiet output from figtree_spec invalid ini context
   config.before { allow($stderr).to receive(:puts) }

data/spec/support/comment.ini

@@ -0,0 +1,10 @@
+# comments should be ignored
+[section_one]
+one = 1
+two = 2
+
+[section_two]  # you can comment here
+one = 42       # and even here!
+multi = a \    # and here, too
+b
+

data/spec/support/good.ini

@@ -0,0 +1,18 @@
+[section_one]
+one = 1
+two = 2
+
+[section_two]
+three =         "-3"
+multi = multiline \
+support
+
+; comments should be ignored
+[section_three]
+four =true
+five=false   # comments can go here
+six = "6.0"     ; and here, too
+
+[section_five]
+seven_and_eight= "7 & 8"
+

data/spec/support/invalid/bad_1.ini

@@ -0,0 +1,6 @@
+[section_one]
+one = 1
+two = 2
+
+; the following is not a valid line
+invalid line

data/spec/support/invalid/bad_2.ini

@@ -0,0 +1,11 @@
+[section_one]
+one = 1
+two = 2
+
+[section_two]
+close-quote = "some text without
+a closing quote - should
+be interesting
+
+[section_three]
+wat = where is that closing quote?

data/spec/support/invalid/browscap.ini

@@ -0,0 +1,5 @@
+
+;just the offending entry
+[www.substancia.com AutoHTTPAgent (ver *)]
+Parent=Version Checkers
+Browser=Subst�ncia

data/spec/support/invalid/continuation.ini

@@ -0,0 +1,6 @@
+[section_one]
+one = 1
+two = 2
+
+[section_two]
+end-of-file = here is the last value \

data/spec/support/invalid/escape.ini

@@ -0,0 +1,13 @@
+; this test file demonstrates escape sequences supported by IniFile
+[normal]
+foo = http://en.wikipedia.org/wiki/Foobar
+
+[escaped]
+tabs = There is a tab\tcharacter in here somewhere
+carriage return = Who uses these anyways?\r
+newline = Trust newline!\nAlways there when you need him.\nSplittin' those lines.
+null = Who'd be silly enough to put\0 a null character in the middle of a string? \
+Stroustrup would not approve!
+backslash = This string \\t contains \\n no \\r special \\0 characters!
+quoted = "Escaping works\tinside quoted strings!"
+

data/spec/support/invalid/global.ini

@@ -0,0 +1,3 @@
+; without any section, a default 'global' section will be created
+one = 1
+two = 2

data/spec/support/merge.ini

@@ -0,0 +1,5 @@
+[section_one]
+one = 3
+
+[section_five]
+five=5

data/spec/support/mini_ini_example.ini

@@ -0,0 +1,4 @@
+[Network]
+hostname = My Computer
+address = dhcp
+dns = 192.168.1.1

data/spec/support/mixed_comment.ini

@@ -0,0 +1,7 @@
+# comments should be ignored
+; multiple comments characters are supported
+; (I'm lookin' at you, samba)
+[section_one]
+one = 1
+two = 2
+

data/spec/support/multiline.ini

@@ -0,0 +1,23 @@
+[section_one]
+one = 1
+two = 2
+
+[section_two]
+three =         3
+
+; comments should be ignored
+[section_three]
+three   = hello \
+multiline
+other = "stuff"
+
+[section_four]
+four   = hello \  # comments work here, too
+multiple \        # and here !!!
+multilines        # and even here (OMG)
+five = "multiple lines
+inside of quotations
+preserve everything"
+
+[empty_lines]
+not_empty=full

data/spec/support/multiline_only.ini

@@ -0,0 +1,5 @@
+[section_three]
+two = 2
+three = hello \
+multiline
+other = "stuff"

data/spec/support/param.ini

@@ -0,0 +1,5 @@
+; comments should be ignored
+[section_one]
+one = 1
+two=2
+

data/spec/support/section.ini

@@ -0,0 +1,4 @@
+; section headers can be values
+[section_one]
+one=[value]
+two=2

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: figtree
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 2.0.0
 platform: ruby
 authors:
 - Alex Moore-Niemi
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-10-10 00:00:00.000000000 Z
+date: 2015-10-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parslet
@@ -88,7 +88,9 @@ dependencies:
         version: '0.10'
 description: See README.md
 email: moore.niemi@gmail.com
-executables: []
+executables:
+- console
+- setup
 extensions: []
 extra_rdoc_files: []
 files:
@@ -99,6 +101,8 @@ files:
 - Gemfile.lock
 - MIT-LICENSE
 - README.md
+- bin/console
+- bin/setup
 - figtree.gemspec
 - lib/figtree.rb
 - lib/figtree/ini_config.rb
@@ -110,9 +114,24 @@ files:
 - spec/figtree/transformer_spec.rb
 - spec/figtree_spec.rb
 - spec/spec_helper.rb
+- spec/support/comment.ini
+- spec/support/good.ini
+- spec/support/invalid/bad_1.ini
+- spec/support/invalid/bad_2.ini
+- spec/support/invalid/browscap.ini
+- spec/support/invalid/continuation.ini
+- spec/support/invalid/escape.ini
+- spec/support/invalid/global.ini
+- spec/support/invalid/unparseable_settings.conf
+- spec/support/invalid/untransformable_settings.conf
+- spec/support/merge.ini
+- spec/support/mini_ini_example.ini
+- spec/support/mixed_comment.ini
+- spec/support/multiline.ini
+- spec/support/multiline_only.ini
+- spec/support/param.ini
+- spec/support/section.ini
 - spec/support/settings.conf
-- spec/support/unparseable_settings.conf
-- spec/support/untransformable_settings.conf
 - spec/support/wiki_example.ini
 homepage: https://github.com/mooreniemi/figtree
 licenses:
@@ -144,8 +163,23 @@ test_files:
 - spec/figtree/transformer_spec.rb
 - spec/figtree_spec.rb
 - spec/spec_helper.rb
+- spec/support/comment.ini
+- spec/support/good.ini
+- spec/support/invalid/bad_1.ini
+- spec/support/invalid/bad_2.ini
+- spec/support/invalid/browscap.ini
+- spec/support/invalid/continuation.ini
+- spec/support/invalid/escape.ini
+- spec/support/invalid/global.ini
+- spec/support/invalid/unparseable_settings.conf
+- spec/support/invalid/untransformable_settings.conf
+- spec/support/merge.ini
+- spec/support/mini_ini_example.ini
+- spec/support/mixed_comment.ini
+- spec/support/multiline.ini
+- spec/support/multiline_only.ini
+- spec/support/param.ini
+- spec/support/section.ini
 - spec/support/settings.conf
-- spec/support/unparseable_settings.conf
-- spec/support/untransformable_settings.conf
 - spec/support/wiki_example.ini
 has_rdoc: