ini_file 0.0.1

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2012 Jerry D'Antonio
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1 @@
+README for ini_file

data/Rakefile

@@ -0,0 +1,16 @@
+require "rubygems"
+require "bundler/gem_tasks"
+require "rspec"
+require "rspec/core/rake_task"
+
+$:.unshift 'tasks'
+Dir.glob('tasks/**/*.rake').each do|rakefile|
+  load rakefile
+end
+
+Bundler::GemHelper.install_tasks
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.rspec_opts = '-fd --color'
+end
+
+#task :default => [:default_task]

data/lib/ini_file.rb

@@ -0,0 +1,32 @@
+$:.push File.join(File.dirname(__FILE__))
+
+require "ini_file/content"
+require "ini_file/parser"
+require "ini_file/version"
+
+# http://en.wikipedia.org/wiki/INI_file
+
+module IniFile
+  extend self
+
+  def load(path, safe = false)
+    contents = File.open(File.expand_path(path), 'r') {|f| f.read }
+    return Content.parse(contents)
+  rescue
+    if safe
+      return nil
+    else
+      raise $!
+    end
+  end
+
+  def parse(contents, safe = false)
+    return Parser.parse(contents)
+  rescue
+    if safe
+      return nil
+    else
+      raise $!
+    end
+  end
+end

data/lib/ini_file/content.rb

@@ -0,0 +1,76 @@
+require 'ini_file/parser'
+
+module IniFile
+
+  class Content
+
+    attr_reader :name
+
+    def empty?
+      return @content.empty?
+    end
+
+    def [](key)
+      if @content[key].is_a? Hash
+        return Content.from_hash(key, @content[key])
+      else
+        return @content[key]
+      end
+    end
+
+    def to_hash
+      return Marshal.load( Marshal.dump(@content) )
+    end
+
+    def each(&block)
+      @content.each do |key, value|
+        yield(key, value) unless value.is_a? Hash
+      end
+    end
+
+    def each_section(&block)
+      @content.each do |key, value|
+        yield(Content.from_hash(key, value)) if value.is_a? Hash
+      end
+    end
+
+    def method_missing(method, *args, &block)
+
+      key = method.to_s.downcase.to_sym
+
+      if @content.has_key?(key)
+        if args.count > 0
+          raise ArgumentError.new("wrong number of arguments(#{args.count} for 0)")
+        elsif block_given?
+          raise ArgumentError.new("block syntax not supported")
+        elsif @content[key].is_a? Hash
+          return Content.from_hash(key, @content[key])
+        else
+          return @content[key]
+        end
+      else
+        super
+      end
+    end
+
+    def self.parse(contents)
+      content = Content.new
+      content.instance_variable_set(:@content, Parser.parse(contents))
+      return content
+    end
+
+    private
+
+    def initialize(name = nil)
+      @name = name
+      @content = {}
+    end
+
+    def self.from_hash(name, contents)
+      content = Content.new(name)
+      content.instance_variable_set(:@content, contents)
+      return content
+    end
+
+  end
+end

data/lib/ini_file/parser.rb

@@ -0,0 +1,93 @@
+module IniFile
+
+  IniFormatError = Class.new(StandardError)
+
+  module Parser
+    extend self
+
+    def parse(contents)
+      raise ArgumentError.new('contents cannot be nil') if contents.nil?
+      raise ArgumentError.new('contents must be a string') unless contents.is_a? String
+      raise ArgumentError.new('contents cannot be blank') if contents.strip.empty?
+
+      root = {}
+
+      section_pattern = /^\s*\[([^\]]+)\]\s*$/
+      property_pattern = /^\s*([^;#:=\r\n]++)\s*[:=](.*)$/
+      comment_pattern = /^\s*([;#].*)$/
+
+      pattern = /#{section_pattern}|#{property_pattern}|#{comment_pattern}|^(.*)$/
+
+      current = root
+
+      contents.scan(pattern) do |section, key, value, comment, garbage|
+
+        if section
+          if section.scan(/[\.\\\/,]/).uniq.size > 1
+            raise IniFormatError.new("Section hierarchy names must use one delimiter: #{section}")
+          end
+          sections = section.strip.split(/\s*[\.\\\/,\s]{1}\s*/)
+          if sections.empty?
+            raise IniFormatError.new("Section names cannot be blank: #{section}")
+          end
+
+          current = root
+
+          sections.each do |section|
+            section = $1 || $2 if section =~ /^"([^"]+)"$|^'([^']+)'$/
+            section = section.strip.downcase.to_sym
+            if section.empty?
+              raise IniFormatError.new("Section names cannot be blank: #{section}")
+            elsif section =~ /[\W]+/
+              raise IniFormatError.new("Section names cannot contain punctuation: #{section}")
+            elsif current.has_key?(section) && !current[section].is_a?(Hash)
+              raise IniFormatError.new("Section name matches existing property name: #{section}")
+            else
+              current[section] = {} unless current.has_key?(section)
+              current = current[section]
+            end
+          end
+
+        elsif key && value
+          key = key.strip.downcase.gsub(/-/, '_').to_sym
+          value = value.strip
+          if key.empty?
+            raise IniFormatError.new("Property names cannot be blank: #{key}")
+          elsif current[key]
+            raise IniFormatError.new("Duplicate keys are not allowed: #{key}")
+          elsif key =~ /[\W\s]+/
+            raise IniFormatError.new("Property names cannot contain spaces or punctuation: #{key}")
+          end
+          value = value.gsub(/\s+/, ' ') unless value =~ /^"(.+)"$|^'(.+)'$/
+          if value =~ /^\d+$/
+            value = value.to_i
+          elsif value =~ /^\d*\.\d+$/
+            value = value.to_f
+          else
+            if value =~ /^"(.+)"$|^'(.+)'$/
+              value = $1 || $2
+            else
+              value = value.gsub(/\s*[^\\]{1}[#;].*$/, '')
+              value = value.gsub(/\\([#;])/, '\1')
+            end
+            value = value.gsub(/\\[0abtrn\\]/) {|s| eval('"%s"' % "#{s}") }
+            value = value.gsub(/\\[ux](\d{4})/) {|s| eval('"%s"' % "\\u#{$1}") }
+          end
+          current[key] = value
+
+        elsif comment
+          # do nothing
+        elsif garbage
+          raise IniFormatError.new("Unrecognized pattern: #{garbage}")
+        else
+          # possibly throw exceptions?
+        end
+      end
+
+      root.freeze
+      return root
+    end
+
+  end
+
+end

data/lib/ini_file/version.rb

@@ -0,0 +1,3 @@
+module IniFile
+  VERSION = "0.0.1"
+end

data/spec/ini_file/content_spec.rb

@@ -0,0 +1,335 @@
+require 'spec_helper'
+
+module IniFile
+
+  describe Content do
+
+    let(:contents) do
+      <<-DATA
+        ; this line is a comment
+        KEY1 = value1
+        key2 = "The second value"
+        the-third-key = 3
+
+        [section_1]
+        key3: value3
+
+        [section_1.sub_1]
+        sub_1_key: 'This is the subsection key'
+
+        [section_1/sub_1/sub_2]
+        key: value
+
+        [section_1 \ sub_1 \ sub_2 \ sub_3]
+        key: value
+
+        [section_1,sub_1,sub_2,sub_3,sub_4]
+        key: value
+      DATA
+    end
+
+    context '#new' do
+
+      it 'calls Parser.parse with the contents' do
+        ini_contents = 'key=value'
+        Parser.should_receive(:parse).with(ini_contents)
+        Content.parse(ini_contents)
+      end
+
+    end
+
+    context 'accessor methods' do
+
+      context 'attribute reader' do
+
+        subject { Content.parse(contents) }
+
+        it 'throws an ArgumentError if parameters are passed' do
+          lambda { subject.key1(nil) }.should raise_error(ArgumentError)
+        end
+
+        it 'throws an ArgumentError if a block is provided' do
+          lambda { subject.key1{|x| nil} }.should raise_error(ArgumentError)
+        end
+
+        it 'converts global property keys to attributes at the root' do
+          subject.key1.should_not be_nil
+        end
+
+        it 'converts global property values to string values at the root' do
+          subject.key1.should eq 'value1'
+        end
+
+        it 'ignores case of property keys' do
+          subject.KEY1.should eq 'value1'
+        end
+
+        it 'replaces dashes in the key name with underscores' do
+          subject.the_third_key.should eq 3
+        end
+
+        it 'converts section names to attributes at the root' do
+          subject.section_1.should_not be_nil
+        end
+
+        it 'converts sections to nested attributes under the root' do
+          subject.section_1[:key3].should eq 'value3'
+        end
+
+        it 'converts section property keys to attributes under the section' do
+          subject.section_1.key3.should eq 'value3'
+        end
+
+        it 'converts section property values to string values under the section' do
+          section = subject.section_1
+          value = subject.section_1.key3
+          subject.section_1.key3.should eq 'value3'
+        end
+
+        it 'converts section hierarchies to nested section hierarchies' do
+          subject.section_1.sub_1.sub_2.sub_3.sub_4.should_not be_nil
+        end
+
+        it 'ignores case of section names' do
+          subject.SECTION_1[:key3].should eq 'value3'
+        end
+
+        it 'ignores case of section hierarchies' do
+          subject.section_1.SUB_1.should_not be_nil
+        end
+
+        it 'ignores case of property names in section hierarchies' do
+          subject.section_1.sub_1.SUB_1_KEY.should eq 'This is the subsection key'
+        end
+
+        it 'throws NoMethodError when accessing a non-existing property' do
+          lambda { subject.bogus }.should raise_error(NoMethodError)
+        end
+
+        it 'throws NoMethodError when accessing a non-existing section' do
+          lambda { subject.bogus[:key1] }.should raise_error(NoMethodError)
+        end
+
+        it 'throws NoMethodError when accessing a non-existing subsection' do
+          lambda { subject.section_1.bogus }.should raise_error(NoMethodError)
+        end
+
+        it 'throws NoMethodError when accessing a non-existing subsection property' do
+          lambda { subject.section_1.sub.bogus }.should raise_error(NoMethodError)
+        end
+
+      end
+
+      context '#[]' do
+
+        subject { Content.parse(contents) }
+
+        it 'converts global property keys to symbols at the root' do
+          subject[:key1].should_not be_nil
+          subject[:key2].should_not be_nil
+        end
+
+        it 'converts global property values to string values at the root' do
+          subject[:key1].should eq 'value1'
+          subject[:key2].should eq 'The second value'
+        end
+
+        it 'converts section names to symbols at the root' do
+          subject[:section_1].should_not be_nil
+        end
+
+        it 'converts sections to nodes' do
+          subject[:section_1].should be_kind_of IniFile::Content
+        end
+
+        it 'converts section property keys to symbols in the section hash' do
+          subject[:section_1][:key3].should_not be_nil
+        end
+
+        it 'converts section property values to string values in the section hash' do
+          subject[:section_1][:key3].should eq 'value3'
+        end
+
+        it 'converts section hierarchies to node hierarchies' do
+          subject[:section_1].should be_kind_of IniFile::Content
+          subject[:section_1][:sub_1].should be_kind_of IniFile::Content
+          subject[:section_1][:sub_1][:sub_2].should be_kind_of IniFile::Content
+          subject[:section_1][:sub_1][:sub_2][:sub_3].should be_kind_of IniFile::Content
+          subject[:section_1][:sub_1][:sub_2][:sub_3][:sub_4].should be_kind_of IniFile::Content
+        end
+
+      end
+
+      context '#to_hash' do
+
+        subject { Content.parse(contents).to_hash }
+
+        it 'converts global property keys to symbols at the root' do
+          subject[:key1].should_not be_nil
+          subject[:key2].should_not be_nil
+        end
+
+        it 'converts global property values to string values at the root' do
+          subject[:key1].should eq 'value1'
+          subject[:key2].should eq 'The second value'
+        end
+
+        it 'converts section names to symbols at the root' do
+          subject[:section_1].should_not be_nil
+        end
+
+        it 'converts sections to hash values at the root' do
+          subject[:section_1].should be_a Hash
+        end
+
+        it 'converts section property keys to symbols in the section hash' do
+          subject[:section_1][:key3].should_not be_nil
+        end
+
+        it 'converts section property values to string values in the section hash' do
+          subject[:section_1][:key3].should eq 'value3'
+        end
+
+        it 'converts section hierarchies to hash hierarchies' do
+          subject[:section_1][:sub_1][:sub_2][:sub_3][:sub_4].should be_a Hash
+        end
+
+      end
+
+    end
+
+    context 'iterators' do
+
+      let(:contents) do
+        <<-DATA
+          ; this line is a comment
+          KEY1 = value1
+          key2 = "The second value"
+
+          [section_1]
+          key1-1: value1
+          key1-2: value2
+          key1-3: value3
+          key1-4: value4
+
+          [section_2]
+          key2-1: value1
+          key2-2: value2
+          key2-3: value3
+          key2-4: value4
+
+          [section_1.sub_1]
+          key1-1-1: value1
+          key1-1-2: value2
+          key1-1-3: value3
+          key1-1-4: value4
+
+          [section_1.sub_2]
+          key1-2-1: value1
+          key1-2-2: value2
+          key1-2-3: value3
+          key1-2-4: value4
+        DATA
+      end
+
+      let(:keys) { [ :key1, :key2 ] }
+      let(:sections) { [ :section_1, :section_2 ] }
+      let(:section_keys) { [ :key1_1, :key1_2, :key1_3, :key1_4 ] }
+      let(:subsections) { [ :sub_1, :sub_2 ] }
+      let(:subsection_keys) { [ :key2_1, :key2_2, :key2_3, :key2_4 ] }
+      let(:subsection_1_keys) { [ :key1_1_1, :key1_1_2, :key1_1_3, :key1_1_4 ] }
+      let(:subsection_2_keys) { [ :key1_2_1, :key1_2_2, :key1_2_3, :key1_2_4 ] }
+
+      subject { Content.parse(contents) }
+
+      context '#each' do
+
+        it 'iterates over each key/value pair in the global section' do
+          subject.each do |key, value|
+            keys.should include key
+          end
+        end
+
+        it 'returns the value associated with the current key' do
+          subject.each do |key, value|
+            subject[key].should eq value
+          end
+        end
+
+        it 'does not iterate over sections at the root' do
+          subject.each do |key, value|
+            sections.should_not include key
+          end
+        end
+
+      end
+
+      context '#each_section' do
+
+        it 'iterates over each section in the root' do
+          subject.each_section do |section|
+            sections.should include section.name
+          end
+        end
+
+        it 'returns the node associated with the current section' do
+          subject.each_section do |section|
+            section.should be_kind_of IniFile::Content
+          end
+        end
+
+        it 'does not iterate over properties at the root' do
+          subject.each_section do |section|
+            keys.should_not include section.name
+          end
+        end
+
+      end
+
+      context '#each for sections' do
+
+        it 'iterates over each key/value pair in the given section' do
+          subject.section_1.each do |key, value|
+            section_keys.should include key
+          end
+        end
+
+        it 'returns the value associated with the current key' do
+          subject.section_1.each do |key, value|
+            subject.section_1[key].should eq value
+          end
+        end
+
+        it 'does not iterate over subsections of the given section' do
+          subject[:section_1].each do |key, value|
+            subsections.should_not include key
+          end
+        end
+
+      end
+
+      context '#each_section for sections' do
+
+        it 'iterates over each section in the root' do
+          subject.section_1.each_section do |section|
+            subsections.should include section.name
+          end
+        end
+
+        it 'returns the node associated with the current section' do
+          subject.section_1.each_section do |section|
+            section.should be_kind_of IniFile::Content
+          end
+        end
+
+        it 'does not iterate over properties at the root' do
+          subject.section_1.each_section do |section|
+            subsection_keys.should_not include section.name
+          end
+        end
+
+      end
+
+    end
+  end
+end

data/spec/ini_file/parser_spec.rb

@@ -0,0 +1,499 @@
+require 'spec_helper'
+
+# http://en.wikipedia.org/wiki/INI_file
+
+module IniFile
+
+  describe Parser do
+
+    context '#parse' do
+
+      context 'method call' do
+
+        let(:contents) { "; this is a comment" }
+
+        it 'requires the first argument to be a string' do
+          lambda { subject.parse(contents) }.should_not raise_error
+        end
+
+        it 'throws an exception if the first argument is nil' do
+          lambda { subject.parse(nil) }.should raise_error(ArgumentError)
+        end
+
+        it 'throws an exception if the first argument is an empty string' do
+          lambda { subject.parse('') }.should raise_error(ArgumentError)
+        end
+
+        it 'throws an exception if the first argument is nothing but whitespace' do
+          lambda { subject.parse('    ') }.should raise_error(ArgumentError)
+        end
+
+        it 'throws an exception if the first argument is not a string' do
+          lambda { subject.parse(123) }.should raise_error(ArgumentError)
+        end
+
+      end
+
+      context 'return value' do
+
+        it 'is a hash on success' do
+          subject.parse('key=value').should be_a Hash
+        end
+
+        it 'is an empty hash when the content is only comments' do
+          subject.parse('; this is a comment').should be_empty
+        end
+
+      end
+
+      context 'content' do
+
+        context 'properties' do
+
+          it 'extracts the key from the left of the delimiter' do
+            ini = subject.parse('key=value')
+            ini[:key].should_not be_nil
+          end
+
+          it 'ignores whitespace before the key' do
+            ini = subject.parse('    key=value')
+            ini[:key].should eq 'value'
+          end
+
+          it 'throws an exception on a blank key' do
+            lambda {
+              subject.parse('   =value')
+            }.should raise_error(IniFormatError)
+          end
+
+          it 'throws an exception on whitespace within the key' do
+            lambda {
+              subject.parse('this is the key=value')
+            }.should raise_error(IniFormatError)
+          end
+
+          it 'allows underscores in the key' do
+            ini = subject.parse('main_window_maximized=value')
+            ini[:main_window_maximized].should eq 'value'
+          end
+
+          it 'converts dashes in the key to underscores' do
+            ini = subject.parse('main-window-maximized=value')
+            ini[:main_window_maximized].should eq 'value'
+          end
+
+          it 'throws an exception on punctuation within the key' do
+            lambda {
+              subject.parse("the'key=value")
+            }.should raise_error(IniFormatError)
+          end
+
+          it 'throws an exception for a duplicate key' do
+            lambda {
+              subject.parse("key=value1\nkey=value2")
+            }.should raise_error(IniFormatError)
+          end
+
+          it 'ignores the case of the key' do
+            ini = subject.parse('KEY=value')
+            ini[:key].should eq 'value'
+          end
+
+          it 'allows an equal sign as the delimiter' do
+            ini = subject.parse('key=value')
+            ini[:key].should eq 'value'
+          end
+
+          it 'allows a colon as the delimiter' do
+            ini = subject.parse('key:value')
+            ini[:key].should eq 'value'
+          end
+
+          it 'allows spaces before the delimiter' do
+            ini = subject.parse('key  =value')
+            ini[:key].should eq 'value'
+          end
+
+          it 'allows spaces after the delimiter' do
+            ini = subject.parse('key:   value')
+            ini[:key].should eq 'value'
+          end
+
+          it 'ignores single quotes around the value' do
+            ini = subject.parse("key='value'")
+            ini[:key].should eq 'value'
+          end
+
+          it 'ignores double quotes around the value' do
+            ini = subject.parse('key="value"')
+            ini[:key].should eq 'value'
+          end
+
+          it 'allows a blank value' do
+            ini = subject.parse('key=')
+            ini[:key].should be_empty
+          end
+
+          it 'allows spaces within the value' do
+            ini = subject.parse('key=this is the value')
+            ini[:key].should eq 'this is the value'
+          end
+
+          it 'allows punctuation within the value' do
+            value = "+refs/heads/*:refs/remotes/origin/*"
+            ini = subject.parse("fetch = #{value}")
+            ini[:fetch].should eq value
+
+            value = "url = git@github.com:jdantonio/ini_file.git"
+            ini = subject.parse("url = #{value}")
+            ini[:url].should eq value
+          end
+
+          it 'collapses concurrent space characters within the value' do
+            ini = subject.parse("key=this   is\tthe    value")
+            ini[:key].should eq 'this is the value'
+          end
+
+          it 'does not collapse concurrent space within quoted values' do
+            ini = subject.parse("key='this   is\tthe    value'")
+            ini[:key].should eq "this   is\tthe    value"
+          end
+
+          it 'preserves the case of the value' do
+            ini = subject.parse('key=This is the VALUE')
+            ini[:key].should eq 'This is the VALUE'
+          end
+
+          it 'allows line continuation when a line ends with a backslash' do
+            pending
+            ini = subject.parse("key=this\\\nvalue")
+            ini[:key].should eq 'this value'
+          end
+
+        end
+
+        context 'escape sequences' do
+
+          it "converts \\\\ into \\" do
+            ini = subject.parse("key=this\\\\value")
+            ini[:key].should eq "this\\value"
+          end
+
+          it "converts \\0 into a null character" do
+            ini = subject.parse("key=this\\0value")
+            ini[:key].should eq "this\0value"
+          end
+
+          it "converts \\a into a bell/alert" do
+            ini = subject.parse("key=this\\avalue")
+            ini[:key].should eq "this\avalue"
+          end
+
+          it "converts \\b into a bell/alert" do
+            ini = subject.parse("key=this\\bvalue")
+            ini[:key].should eq "this\bvalue"
+          end
+
+          it "converts \\t into a tab" do
+            ini = subject.parse("key=this\\tvalue")
+            ini[:key].should eq "this\tvalue"
+          end
+
+          it "converts \\r into carriage return" do
+            ini = subject.parse("key=this\\rvalue")
+            ini[:key].should eq "this\rvalue"
+          end
+
+          it "converts \\n into a newline" do
+            ini = subject.parse("key=this\\nvalue")
+            ini[:key].should eq "this\nvalue"
+          end
+
+          it "converts \\; into a semicolon" do
+            ini = subject.parse("key=this\\;value")
+            ini[:key].should eq "this;value"
+          end
+
+          it "converts \\# into a number sign" do
+            ini = subject.parse("key=this\\#value")
+            ini[:key].should eq "this#value"
+          end
+
+          it 'converts \\x???? into a hexidecimal character' do
+            ini = subject.parse("key=this\\x1234value")
+            ini[:key].should eq "this\u1234value"
+          end
+
+          it 'converts \\u???? into a hexidecimal character' do
+            ini = subject.parse("key=this\\u1234value")
+            ini[:key].should eq "this\u1234value"
+          end
+
+        end
+
+        context 'comments' do
+
+          it 'ignores lines beginning with a semicolon' do
+            ini = subject.parse(';this is a comment')
+            ini.should be_empty
+          end
+
+          it 'ignores lines beginning with a pound sign' do
+            ini = subject.parse('#this is a comment')
+            ini.should be_empty
+          end
+
+          it 'ignores inline comments beginning with a semicolon in unquoted values' do
+            ini = subject.parse("key = value ; comment")
+            ini[:key].should eq "value"
+          end
+
+          it 'ignores inline comments beginning with a pound sign in unquoted values' do
+            ini = subject.parse("key = value # comment")
+            ini[:key].should eq "value"
+          end
+
+          it 'allows inline comments beginning with a semicolon in quoted values' do
+            ini = subject.parse("key = \"value ; comment\"")
+            ini[:key].should eq "value ; comment"
+          end
+
+          it 'allows inline comments beginning with a pound sign in quoted values' do
+            ini = subject.parse('key = "value # comment"')
+            ini[:key].should eq 'value # comment'
+          end
+
+          it 'allows equal signs within comments' do
+            ini = subject.parse('  ;editor = mate -w')
+            ini.should be_empty
+          end
+
+          it 'allows colons within comments' do
+            ini = subject.parse('  #editor = mate -w')
+            ini.should be_empty
+          end
+
+          it 'ignores spaces before the comment indicator' do
+            ini = subject.parse('     # this is a comment')
+            ini.should be_empty
+          end
+
+          it 'ignores blank lines' do
+            ini = subject.parse("key1=value1\n   \n\t\n  \t key2=value2\n#comment")
+            ini[:key1].should eq 'value1'
+            ini[:key2].should eq 'value2'
+          end
+
+          it 'ignores empty lines' do
+            ini = subject.parse("key1=value1\n\n\n\nkey2=value2")
+            ini[:key1].should eq 'value1'
+            ini[:key2].should eq 'value2'
+          end
+
+        end
+
+        context 'sections' do
+
+          it 'assigns properties before any section headers to the global section' do
+            ini = subject.parse("key1=value1\n[section]\nkey2=value2")
+            ini[:key1].should eq 'value1'
+          end
+
+          it 'assigns properties after a section header to that section' do
+            ini = subject.parse("[section]\nkey=value")
+            ini[:key].should be_nil
+            ini[:section][:key].should eq 'value'
+          end
+
+          it 'allows whitespace before the opening bracket' do
+            ini = subject.parse("    [section]\nkey=value")
+            ini[:key].should be_nil
+            ini[:section][:key].should eq 'value'
+          end
+
+          it 'ignores whitespace between the opening bracket and the section name' do
+            ini = subject.parse("[    section]\nkey=value")
+            ini[:key].should be_nil
+            ini[:section][:key].should eq 'value'
+          end
+
+          it 'ignores whitespace between the closing bracket and the section name' do
+            ini = subject.parse("[section    ]\nkey=value")
+            ini[:key].should be_nil
+            ini[:section][:key].should eq 'value'
+          end
+
+          it 'allows whitespace after the closing bracket' do
+            ini = subject.parse("[section]    \nkey=value")
+            ini[:key].should be_nil
+            ini[:section][:key].should eq 'value'
+          end
+
+          it 'allows section names to be enclosed in double quotes' do
+            ini = subject.parse("[ \"section\" ]\nkey=value")
+            ini[:key].should be_nil
+            ini[:section][:key].should eq 'value'
+          end
+
+          it 'allows section names to be enclosed in single quotes' do
+            ini = subject.parse("[ 'section' ]\nkey=value")
+            ini[:key].should be_nil
+            ini[:section][:key].should eq 'value'
+          end
+
+          it 'throws an exception on punctuation within the section name' do
+            lambda {
+              subject.parse("[the'section]\nkey=value")
+            }.should raise_error(IniFormatError)
+          end
+
+          it 'throws an exception when a section name is the same as a property key' do
+            lambda {
+              subject.parse("foo=value1\n[foo]\nkey2=value2")
+            }.should raise_error(IniFormatError)
+          end
+
+          it 'throws an exception on duplicate keys within a section' do
+            lambda {
+              subject.parse("[section]\nfoo=value1\n[section]\nfoo=value2")
+            }.should raise_error(IniFormatError)
+          end
+
+          it 'ignores the case of the section name' do
+            ini = subject.parse("[SeCtIoN]\nkey=value")
+            ini[:key].should be_nil
+            ini[:section][:key].should eq 'value'
+          end
+
+          it 'creates a hierarchy when a section name is delimited by a dot' do
+            ini = subject.parse("[section.subsection]\nkey=value")
+            ini[:key].should be_nil
+            ini[:section][:subsection][:key].should eq 'value'
+          end
+
+          it 'creates a hierarchy when a section name is delimited by a backslash' do
+            ini = subject.parse("[section\\subsection]\nkey=value")
+            ini[:key].should be_nil
+            ini[:section][:subsection][:key].should eq 'value'
+          end
+
+          it 'creates a hierarchy when a section name is delimited by a forward slash' do
+            ini = subject.parse("[section/subsection]\nkey=value")
+            ini[:key].should be_nil
+            ini[:section][:subsection][:key].should eq 'value'
+          end
+
+          it 'creates a hierarchy when a section name is delimited by a comma' do
+            ini = subject.parse("[section,subsection]\nkey=value")
+            ini[:key].should be_nil
+            ini[:section][:subsection][:key].should eq 'value'
+          end
+
+          it 'creates a hierarchy when a section name is delimited by whitespace' do
+            ini = subject.parse("[section subsection]\nkey=value")
+            ini[:key].should be_nil
+            ini[:section][:subsection][:key].should eq 'value'
+          end
+
+          it 'allows whitespace before the section delimiter' do
+            ini = subject.parse("[section    .subsection]\nkey=value")
+            ini[:key].should be_nil
+            ini[:section][:subsection][:key].should eq 'value'
+          end
+
+          it 'allows whitespace after the section delimiter' do
+            ini = subject.parse("[section.\t     subsection]\nkey=value")
+            ini[:key].should be_nil
+            ini[:section][:subsection][:key].should eq 'value'
+          end
+
+          it 'does not collide names when a section has subsections' do
+            ini = subject.parse("[section]\nkey1=value1\n[section.subsection]\nkey2=value2")
+            ini[:section].should be_a Hash
+            ini[:section][:key1].should eq 'value1'
+            ini[:section].count.should eq 2
+            ini[:section][:subsection].should be_a Hash
+            ini[:section][:subsection][:key2].should eq 'value2'
+            ini[:section][:subsection].count.should eq 1
+          end
+
+          it 'allows a section to have a subsection with the same name' do
+            ini = subject.parse("[section]\nkey1=value1\n[section.section]\nkey2=value2")
+            ini[:section].should be_a Hash
+            ini[:section][:key1].should eq 'value1'
+            ini[:section].count.should eq 2
+            ini[:section][:section].should be_a Hash
+            ini[:section][:section][:key2].should eq 'value2'
+            ini[:section][:section].count.should eq 1
+          end
+
+          it 'throws an exception when a section name is blank' do
+            lambda {
+              subject.parse("[      ]")
+            }.should raise_error(IniFormatError)
+          end
+
+          it 'throws an exception when a subsection name is blank' do
+            lambda {
+              subject.parse("[head..subsection]")
+            }.should raise_error(IniFormatError)
+          end
+
+          it 'throws an exception when a section name mixes hierarchy delimiters' do
+            lambda {
+              subject.parse("[this.is\\the/section,header]")
+            }.should raise_error(IniFormatError)
+          end
+
+        end
+
+        context 'multiple lines' do
+
+          it 'supports multiple property lines' do
+            ini = subject.parse("key1=value1\nkey2=value2")
+            ini[:key1].should eq 'value1'
+            ini[:key2].should eq 'value2'
+          end
+
+          it 'supports multiple comment lines' do
+            ini = subject.parse(";this is a comment\n#this is also a comment")
+            ini.should be_empty
+          end
+
+          it 'supports multiple blank lines' do
+            ini = subject.parse("key1=value1\n\n\n\n\n\nkey2=value2")
+            ini[:key1].should eq 'value1'
+            ini[:key2].should eq 'value2'
+          end
+
+        end
+
+        context 'garbage' do
+
+          it 'throws an exception when encountering garbage lines' do
+            lambda {
+              subject.parse('this line is garbage')
+            }.should raise_error(IniFormatError)
+          end
+
+        end
+
+        context 'property data types' do
+
+          it 'converts non-quoted integer property values to integers' do
+            ini = subject.parse("key1 = 123")
+            ini[:key1].should be_a Numeric
+            ini[:key1].should eq 123
+          end
+
+          it 'converts non-quoted numeric property values to numbers' do
+            ini = subject.parse("key1 = 123.45")
+            ini[:key1].should be_a Numeric
+            ini[:key1].should be_within(0.1).of(123.45)
+          end
+        end
+
+      end
+    end
+  end
+end

data/spec/ini_file_spec.rb

@@ -0,0 +1,75 @@
+require 'fileutils'
+require 'spec_helper'
+
+# http://en.wikipedia.org/wiki/INI_file
+
+describe IniFile do
+
+  subject { IniFile }
+
+  let(:filename) { 'test.ini' }
+  let(:contents) { '; this is a comment' }
+
+  def write_ini_file(path = '.')
+    File.open(File.join(path, filename), 'w') {|f| f.write(contents) }
+  end
+
+  context '#parse' do
+
+    it 'returns a hash on success' do
+      subject.parse(contents).should be_a Hash
+    end
+
+    it 'bubbles any exceptions thrown by the Parser' do
+      lambda { subject.parse('garbage') }.should raise_error
+    end
+
+    it 'returns nil on error when safe is set to true' do
+      subject.parse('garbage', true).should be_nil
+    end
+
+  end
+
+  context '#load' do
+
+    it 'throws an exception if the file does not exist' do
+      lambda { subject.load(filename) }.should raise_error
+    end
+
+    it 'throws an exception on inadequate file permissions' do
+      #pending 'FakeFS is not properly setting file permissions'
+      #write_ini_file
+      #FileUtils.chmod(0222, filename)
+      File.stub(:open).and_raise(Errno::EACCES)
+      lambda { subject.load(filename) }.should raise_error
+    end
+
+    it 'passes the file contents to the Parser' do
+      write_ini_file
+      IniFile::Parser.should_receive(:parse).with(contents)
+      subject.load(filename)
+    end
+
+    it 'expands the full file path' do
+      write_ini_file(ENV['HOME'])
+      lambda { subject.load(File.join("~/#{filename}")) }.should_not raise_error
+    end
+
+    it 'bubbles any exceptions thrown by the Content parser' do
+      File.open(filename, 'w') {|f| f.write(contents) }
+      IniFile::Content.stub(:parse).with(any_args()).and_raise(StandardError.new('test exception'))
+      lambda { subject.load(filename) }.should raise_error(StandardError)
+    end
+
+    it 'returns the new contents object' do
+      File.open(filename, 'w') {|f| f.write(contents) }
+      IniFile.load(filename).should be_instance_of IniFile::Content
+    end
+
+    it 'returns nil on error when safe is set to true' do
+      subject.load('file that does not exist', true).should be_nil
+    end
+
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,12 @@
+$:.unshift(File.join(File.dirname(__FILE__), "..", "lib"))
+
+require 'bundler/setup'
+
+require 'ini_file'
+
+require 'rspec'
+require 'fakefs'
+
+RSpec.configure do |config|
+
+end

data/tasks/rcov.rake

@@ -0,0 +1,11 @@
+namespace :rcov do
+
+  RSpec::Core::RakeTask.new(:rspec) do |t|
+    rm "coverage.data" if File.exist?("coverage.data")
+    t.pattern = 'spec/**/*_spec.rb'
+    t.rcov = true
+    t.rcov_opts = %w{--exclude osx\/objc,Users\/,gems\/,spec\/,teamcity}
+    t.verbose = true
+  end
+
+end

metadata

@@ -0,0 +1,160 @@
+--- !ruby/object:Gem::Specification
+name: ini_file
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Jerry D'Antonio
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-01-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: debugger
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: fakefs
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: ! '''The INI file format is an informal standard for configuration files
+  for some platforms or software. INI files are simple text files with a basic structure
+  composed of ''sections'' and ''properties''.'' - Wikipedia'
+email:
+- jerry.dantonio@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Rakefile
+- README.rdoc
+- LICENSE
+- lib/ini_file.rb
+- lib/ini_file/version.rb
+- lib/ini_file/parser.rb
+- lib/ini_file/content.rb
+- spec/ini_file_spec.rb
+- spec/spec_helper.rb
+- spec/ini_file/content_spec.rb
+- spec/ini_file/parser_spec.rb
+- tasks/rcov.rake
+homepage: https://github.com/jdantonio/ini_file
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+- lib/ini_file
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Manage simple INI files.
+test_files:
+- spec/ini_file_spec.rb
+- spec/spec_helper.rb
+- spec/ini_file/content_spec.rb
+- spec/ini_file/parser_spec.rb