iniparse 1.1.6 → 1.2.0

data/spec/generator/without_section_blocks_spec.rb

@@ -1,136 +0,0 @@
-require 'spec_helper'
-
-# Tests use of the Generator when used like so:
-#
-#   @gen = IniParse::Generator.new
-#   @gen.comment('My very own comment')
-#   @gen.section('my_section')
-#   @gen.option('my_option', 'my value')
-#   ...
-#
-# Or
-#
-#   IniParse::Generator.gen do |doc|
-#     doc.comment('My very own comment')
-#     doc.section('my_section')
-#     doc.option('my_option', 'my value')
-#   end
-#
-
-describe 'When generating a document using Generator without section blocks,' do
-  before(:each) { @gen = IniParse::Generator.new }
-
-  # --
-  # ==========================================================================
-  #   SECTION LINES
-  # ==========================================================================
-  # ++
-
-  describe 'adding a section' do
-    it 'should add a Section to the document' do
-      @gen.section("a section")
-      @gen.document.should have_section("a section")
-    end
-
-    it 'should change the Generator context to the section' do
-      @gen.section("a section")
-      @gen.context.should == @gen.document['a section']
-    end
-
-    it 'should pass extra options to the Section instance' do
-      @gen.section("a section", :indent => '    ')
-      @gen.document["a section"].to_ini.should match(/\A    /)
-    end
-  end
-
-  # --
-  # ==========================================================================
-  #   OPTION LINES
-  # ==========================================================================
-  # ++
-
-  describe 'adding a option' do
-    it 'should pass extra options to the Option instance' do
-      @gen.section("a section")
-      @gen.option("my option", "a value", :indent => '    ')
-      @gen.document["a section"].option("my option").to_ini.should match(/^    /)
-    end
-
-    describe 'when the context is a Document' do
-      it "should raise a NoSectionError" do
-        lambda { @gen.option("key", "value") }.should \
-          raise_error(IniParse::NoSectionError)
-      end
-    end
-
-    describe 'when the context is a Section' do
-      it 'should add the option to the section' do
-        @gen.section("a section")
-        @gen.option("my option", "a value")
-        @gen.document["a section"].should have_option("my option")
-        @gen.document["a section"]["my option"].should == "a value"
-      end
-    end
-  end
-
-  # --
-  # ==========================================================================
-  #   COMMENT LINES
-  # ==========================================================================
-  # ++
-
-  describe 'adding a comment' do
-    it 'should pass extra options to the Option instance' do
-      @gen.comment("My comment", :indent => '    ')
-      @gen.document.lines.to_a.first.to_ini.should match(/^    /)
-    end
-
-    it 'should ignore any extra :comment option' do
-      @gen.comment("My comment", :comment => 'Ignored')
-      comment_ini = @gen.document.lines.to_a.first.to_ini
-      comment_ini.should match(/My comment/)
-      comment_ini.should_not match(/Ignored/)
-    end
-
-    describe 'when the context is a Document' do
-      it 'should add a comment to the document' do
-        @gen.comment('My comment')
-        comment = @gen.document.lines.to_a.first
-        comment.should be_kind_of(IniParse::Lines::Comment)
-        comment.to_ini.should match(/; My comment/)
-      end
-    end
-
-    describe 'when the context is a Section' do
-      it 'should add a comment to the section' do
-        @gen.section('a section')
-        @gen.comment('My comment')
-        comment = @gen.document['a section'].lines.to_a.first
-        comment.should be_kind_of(IniParse::Lines::Comment)
-        comment.to_ini.should match(/My comment/)
-      end
-    end
-  end
-
-  # --
-  # ==========================================================================
-  #   BLANK LINES
-  # ==========================================================================
-  # ++
-
-  describe 'adding a blank line' do
-    it 'should add a blank line to the document when it is the context' do
-      @gen.blank
-      comment = @gen.document.lines.to_a.first
-      comment.should be_kind_of(IniParse::Lines::Blank)
-    end
-
-    it 'should add a blank line to the section when it is the context' do
-      @gen.section('a section')
-      @gen.blank
-      comment = @gen.document['a section'].lines.to_a.first
-      comment.should be_kind_of(IniParse::Lines::Blank)
-    end
-  end
-
-end

data/spec/iniparse_spec.rb

@@ -1,21 +0,0 @@
-require 'spec_helper'
-
-
-describe "IniParse" do
-  describe '.open' do
-    before(:each) { File.stub!(:read).and_return('[section]') }
-
-    it 'should return an IniParse::Document' do
-      IniParse.open('/my/path.ini').should be_kind_of(IniParse::Document)
-    end
-
-    it 'should set the path on the returned Document' do
-      IniParse.open('/my/path.ini').path.should == '/my/path.ini'
-    end
-
-    it 'should read the file at the given path' do
-      File.should_receive(:read).with('/my/path.ini').and_return('[section]')
-      IniParse.open('/my/path.ini')
-    end
-  end
-end

data/spec/line_collection_spec.rb

@@ -1,214 +0,0 @@
-require 'spec_helper'
-
-# ----------------------------------------------------------------------------
-# Shared specs for all Collection types...
-# ----------------------------------------------------------------------------
-
-share_examples_for "LineCollection" do
-  before(:each) do
-    @collection << (@c1 = IniParse::Lines::Comment.new)
-    @collection <<  @i1
-    @collection <<  @i2
-    @collection << (@b1 = IniParse::Lines::Blank.new)
-    @collection <<  @i3
-    @collection << (@b2 = IniParse::Lines::Blank.new)
-  end
-
-  describe '#each' do
-    it 'should remove blanks and comments by default' do
-      @collection.each { |l| l.should be_kind_of(@i1.class) }
-    end
-
-    it 'should not remove blanks and comments if true is given' do
-      arr = []
-
-      # map(true)->each(true) not possible with Enumerable
-      @collection.each(true) do |line|
-        arr << line
-      end
-
-      arr.should == [@c1, @i1, @i2, @b1, @i3, @b2]
-    end
-  end
-
-  describe '#[]' do
-    it 'should fetch the correct value' do
-      @collection['first'].should  == @i1
-      @collection['second'].should == @i2
-      @collection['third'].should  == @i3
-    end
-
-    it 'should return nil if the given key does not exist' do
-      @collection['does not exist'].should be_nil
-    end
-  end
-
-  describe '#[]=' do
-    it 'should successfully add a new key' do
-      @collection['fourth'] = @new
-      @collection['fourth'].should == @new
-    end
-
-    it 'should successfully update an existing key' do
-      @collection['second'] = @new
-      @collection['second'].should == @new
-
-      # Make sure the old data is gone.
-      @collection.detect { |s| s.key == 'second' }.should be_nil
-    end
-
-    it 'should typecast given keys to a string' do
-      @collection[:a_symbol] = @new
-      @collection['a_symbol'].should == @new
-    end
-  end
-
-  describe '#<<' do
-    it 'should set the key correctly if given a new item' do
-      @collection.should_not have_key(@new.key)
-      @collection << @new
-      @collection.should have_key(@new.key)
-    end
-
-    it 'should append Blank lines' do
-      @collection << IniParse::Lines::Blank.new
-      @collection.instance_variable_get(:@lines).last.should \
-        be_kind_of(IniParse::Lines::Blank)
-    end
-
-    it 'should append Comment lines' do
-      @collection << IniParse::Lines::Comment.new
-      @collection.instance_variable_get(:@lines).last.should \
-        be_kind_of(IniParse::Lines::Comment)
-    end
-
-    it 'should return self' do
-      (@collection << @new).should == @collection
-    end
-  end
-
-  describe '#delete' do
-    it 'should remove the given value and adjust the indicies' do
-      @collection['second'].should_not be_nil
-      @collection.delete('second')
-      @collection['second'].should be_nil
-      @collection['first'].should == @i1
-      @collection['third'].should == @i3
-    end
-
-    it "should do nothing if the supplied key does not exist" do
-      @collection.delete('does not exist')
-      @collection['first'].should == @i1
-      @collection['third'].should == @i3
-    end
-  end
-
-  describe '#to_a' do
-    it 'should return an array' do
-      @collection.to_a.should be_kind_of(Array)
-    end
-
-    it 'should include all lines' do
-      @collection.to_a.should == [@c1, @i1, @i2, @b1, @i3, @b2]
-    end
-
-    it 'should include references to the same line objects as the collection' do
-      @collection << @new
-      @collection.to_a.last.object_id.should == @new.object_id
-    end
-  end
-
-  describe '#to_hash' do
-    it 'should return a hash' do
-      @collection.to_hash.should be_kind_of(Hash)
-    end
-
-    it 'should have the correct keys' do
-      hash = @collection.to_hash
-      hash.keys.length.should == 3
-      hash.should have_key('first')
-      hash.should have_key('second')
-      hash.should have_key('third')
-    end
-
-    it 'should have the correct values' do
-      hash = @collection.to_hash
-      hash['first'].should  == @i1
-      hash['second'].should == @i2
-      hash['third'].should  == @i3
-    end
-  end
-
-  describe '#keys' do
-    it 'should return an array of strings' do
-      @collection.keys.should == ['first', 'second', 'third']
-    end
-  end
-end
-
-# ----------------------------------------------------------------------------
-# On with the collection specs...
-# ----------------------------------------------------------------------------
-
-describe 'IniParse::OptionCollection' do
-  before(:each) do
-    @collection = IniParse::OptionCollection.new
-    @i1  = IniParse::Lines::Option.new('first',  'v1')
-    @i2  = IniParse::Lines::Option.new('second', 'v2')
-    @i3  = IniParse::Lines::Option.new('third',  'v3')
-    @new = IniParse::Lines::Option.new('fourth', 'v4')
-  end
-
-  it_should_behave_like 'LineCollection'
-
-  describe '#<<' do
-    it 'should raise a LineNotAllowed exception if a Section is pushed' do
-      lambda { @collection << IniParse::Lines::Section.new('s') }.should \
-        raise_error(IniParse::LineNotAllowed)
-    end
-
-    it 'should add the Option as a duplicate if an option with the same key exists' do
-      option_one = IniParse::Lines::Option.new('k', 'value one')
-      option_two = IniParse::Lines::Option.new('k', 'value two')
-
-      @collection << option_one
-      @collection << option_two
-
-      @collection['k'].should == [option_one, option_two]
-    end
-  end
-
-  describe '#keys' do
-    it 'should handle duplicates' do
-      @collection << @i1 << @i2 << @i3
-      @collection << IniParse::Lines::Option.new('first', 'v5')
-      @collection.keys.should == ['first', 'second', 'third']
-    end
-  end
-end
-
-describe 'IniParse::SectionCollection' do
-  before(:each) do
-    @collection = IniParse::SectionCollection.new
-    @i1  = IniParse::Lines::Section.new('first')
-    @i2  = IniParse::Lines::Section.new('second')
-    @i3  = IniParse::Lines::Section.new('third')
-    @new = IniParse::Lines::Section.new('fourth')
-  end
-
-  it_should_behave_like 'LineCollection'
-
-  describe '#<<' do
-    it 'should raise a LineNotAllowed exception if an Option is pushed' do
-      lambda { @collection << IniParse::Lines::Option.new('k', 'v') }.should \
-        raise_error(IniParse::LineNotAllowed)
-    end
-
-    it 'should add merge Section with the other, if it is a duplicate' do
-      new_section = IniParse::Lines::Section.new('first')
-      @collection << @i1
-      @i1.should_receive(:merge!).with(new_section).once
-      @collection << new_section
-    end
-  end
-end

data/spec/lines_spec.rb

@@ -1,407 +0,0 @@
-require 'spec_helper'
-
-module IniParse::Test
-  class FakeLine
-    include IniParse::Lines::Line
-
-    def line_contents
-      'fake line'
-    end
-  end
-end
-
-describe "IniParse::Lines::Line module" do
-  describe '#to_ini' do
-    it 'should return +line_contents+' do
-      IniParse::Test::FakeLine.new.to_ini.should == 'fake line'
-    end
-
-    it 'should preserve line indents' do
-      IniParse::Test::FakeLine.new(
-        :indent => '    '
-      ).to_ini.should == '    fake line'
-    end
-
-    describe 'when a comment is set' do
-      it 'should correctly include the comment' do
-        IniParse::Test::FakeLine.new(
-          :comment => 'comment', :comment_sep => ';', :comment_offset => 10
-        ).to_ini.should == 'fake line ; comment'
-      end
-
-      it 'should correctly indent the comment' do
-        IniParse::Test::FakeLine.new(
-          :comment => 'comment', :comment_sep => ';', :comment_offset => 15
-        ).to_ini.should == 'fake line      ; comment'
-      end
-
-      it 'should use ";" as a default comment seperator' do
-        IniParse::Test::FakeLine.new(
-          :comment => 'comment'
-        ).to_ini.should == 'fake line ; comment'
-      end
-
-      it 'should use the correct seperator' do
-        IniParse::Test::FakeLine.new(
-          :comment => 'comment', :comment_sep => '#'
-        ).to_ini.should == 'fake line # comment'
-      end
-
-      it 'should use the ensure a space is added before the comment seperator' do
-        IniParse::Test::FakeLine.new(
-          :comment => 'comment', :comment_sep => ';', :comment_offset => 0
-        ).to_ini.should == 'fake line ; comment'
-      end
-
-      it 'should not add an extra space if the line is blank' do
-        line = IniParse::Test::FakeLine.new(
-          :comment => 'comment', :comment_sep => ';', :comment_offset => 0
-        )
-
-        line.stub!(:line_contents).and_return('')
-        line.to_ini.should == '; comment'
-      end
-    end
-
-    describe 'when no comment is set' do
-      it 'should not add trailing space if :comment_offset has a value' do
-        IniParse::Test::FakeLine.new(:comment_offset => 10).to_ini.should == 'fake line'
-      end
-
-      it 'should not add a comment seperator :comment_sep has a value' do
-        IniParse::Test::FakeLine.new(:comment_sep => ';').to_ini.should == 'fake line'
-      end
-    end
-  end
-
-  describe '#has_comment?' do
-    it 'should return true if :comment has a non-blank value' do
-      IniParse::Test::FakeLine.new(:comment => 'comment').should have_comment
-    end
-
-    it 'should return true if :comment has a blank value' do
-      IniParse::Test::FakeLine.new(:comment => '').should have_comment
-    end
-
-    it 'should return false if :comment has a nil value' do
-      IniParse::Test::FakeLine.new.should_not have_comment
-      IniParse::Test::FakeLine.new(:comment => nil).should_not have_comment
-    end
-  end
-end
-
-#
-# Section
-#
-
-describe 'IniParse::Lines::Section' do
-  before(:each) { @section = IniParse::Lines::Section.new('a section') }
-
-  it 'should respond_to +lines+' do
-    @section.should respond_to(:lines)
-  end
-
-  it 'should not respond_to +lines=+' do
-    @section.should_not respond_to(:lines=)
-  end
-
-  it 'should include Enumerable' do
-    IniParse::Lines::Section.included_modules.should include(Enumerable)
-  end
-
-  describe '#initialize' do
-    it 'should typecast the given key to a string' do
-      IniParse::Lines::Section.new(:symbol).key.should == 'symbol'
-    end
-  end
-
-  describe '#option' do
-    it 'should retrieve the line identified by the given key' do
-      option = IniParse::Lines::Option.new('k', 'value one')
-      @section.lines << option
-      @section.option('k').should == option
-    end
-
-    it 'should return nil if the given key does not exist' do
-      @section.option('does_not_exist').should be_nil
-    end
-  end
-
-  describe '#each' do
-    it 'should call #each on +lines+' do
-      @section.lines.should_receive(:each)
-      @section.each { |l| }
-    end
-  end
-
-  describe '#[]' do
-    it 'should return nil if the given key does not exist' do
-      @section['k'].should be_nil
-    end
-
-    it 'should return a value if the given key exists' do
-      @section.lines << IniParse::Lines::Option.new('k', 'v')
-      @section['k'].should == 'v'
-    end
-
-    it 'should return an array of values if the key is a duplicate' do
-      @section.lines << IniParse::Lines::Option.new('k', 'v1')
-      @section.lines << IniParse::Lines::Option.new('k', 'v2')
-      @section.lines << IniParse::Lines::Option.new('k', 'v3')
-      @section['k'].should == ['v1', 'v2', 'v3']
-    end
-
-    it 'should typecast the key to a string' do
-      @section.lines << IniParse::Lines::Option.new('k', 'v')
-      @section[:k].should == 'v'
-    end
-  end
-
-  describe '#[]=' do
-    it 'should add a new Option with the given key and value' do
-      @section['k'] = 'a value'
-      @section.option('k').should be_kind_of(IniParse::Lines::Option)
-      @section['k'].should == 'a value'
-    end
-
-    it 'should update the Option if one already exists' do
-      @section.lines << IniParse::Lines::Option.new('k', 'orig value')
-      @section['k'] = 'new value'
-      @section['k'].should == 'new value'
-    end
-
-    it 'should replace the existing Option if it is an array' do
-      @section.lines << IniParse::Lines::Option.new('k', 'v1')
-      @section.lines << IniParse::Lines::Option.new('k', 'v2')
-      @section['k'] = 'new value'
-      @section.option('k').should be_kind_of(IniParse::Lines::Option)
-      @section['k'].should == 'new value'
-    end
-
-    it 'should typecast the key to a string' do
-      @section[:k] = 'a value'
-      @section['k'].should == 'a value'
-    end
-  end
-
-  describe '#merge!' do
-    before(:each) do
-      @section.lines << IniParse::Lines::Option.new('a', 'val1')
-      @section.lines << IniParse::Lines::Blank.new
-      @section.lines << IniParse::Lines::Comment.new
-      @section.lines << IniParse::Lines::Option.new('b', 'val2')
-
-      @new_section = IniParse::Lines::Section.new('new section')
-    end
-
-    it 'should merge options from the given Section into the receiver' do
-      @new_section.lines << IniParse::Lines::Option.new('c', 'val3')
-      @new_section.lines << IniParse::Lines::Option.new('d', 'val4')
-
-      @section.merge!(@new_section)
-      @section['a'].should == 'val1'
-      @section['b'].should == 'val2'
-      @section['c'].should == 'val3'
-      @section['d'].should == 'val4'
-    end
-
-    it 'should handle duplicates' do
-      @new_section.lines << IniParse::Lines::Option.new('a', 'val2')
-      @section.merge!(@new_section)
-      @section['a'].should == ['val1', 'val2']
-    end
-
-    it 'should handle duplicates on both sides' do
-      @section.lines << IniParse::Lines::Option.new('a', 'val2')
-      @new_section.lines << IniParse::Lines::Option.new('a', 'val3')
-      @new_section.lines << IniParse::Lines::Option.new('a', 'val4')
-
-      @section.merge!(@new_section)
-      @section['a'].should == ['val1', 'val2', 'val3', 'val4']
-    end
-
-    it 'should copy blank lines' do
-      @new_section.lines << IniParse::Lines::Blank.new
-      @section.merge!(@new_section)
-      line = nil
-      @section.each(true) { |l| line = l }
-      line.should be_kind_of(IniParse::Lines::Blank)
-    end
-
-    it 'should copy comments' do
-      @new_section.lines << IniParse::Lines::Comment.new
-      @section.merge!(@new_section)
-      line = nil
-      @section.each(true) { |l| line = l }
-      line.should be_kind_of(IniParse::Lines::Comment)
-    end
-  end
-
-  describe '#to_ini' do
-    it 'should include the section key' do
-      IniParse::Lines::Section.new('a section').to_ini.should == '[a section]'
-    end
-
-    it 'should include lines belonging to the section' do
-      @section.lines << IniParse::Lines::Option.new('a', 'val1')
-      @section.lines << IniParse::Lines::Blank.new
-      @section.lines << IniParse::Lines::Comment.new(
-        :comment => 'my comment', :comment_sep => ';', :comment_offset => 0
-      )
-      @section.lines << IniParse::Lines::Option.new('b', 'val2')
-
-      @section.to_ini.should ==
-        "[a section]\n" \
-        "a = val1\n" \
-        "\n" \
-        "; my comment\n" \
-        "b = val2"
-    end
-
-    it 'should include duplicate lines' do
-      @section.lines << IniParse::Lines::Option.new('a', 'val1')
-      @section.lines << IniParse::Lines::Option.new('a', 'val2')
-
-      @section.to_ini.should ==
-        "[a section]\n" \
-        "a = val1\n" \
-        "a = val2"
-    end
-  end
-
-  describe '#has_option?' do
-    before do
-      @section['first'] = 'value'
-    end
-
-    it 'should return true if an option with the given key exists' do
-      @section.should have_option('first')
-    end
-
-    it 'should return true if no option with the given key exists' do
-      @section.should_not have_option('second')
-    end
-  end
-end
-
-#
-# Option
-#
-
-describe 'Iniparse::Lines::Option' do
-  describe '#initialize' do
-    it 'should typecast the given key to a string' do
-      IniParse::Lines::Option.new(:symbol, '').key.should == 'symbol'
-    end
-  end
-
-  describe '#to_ini' do
-    it 'should include the key and value' do
-      IniParse::Lines::Option.new('key', 'value').to_ini.should == 'key = value'
-    end
-  end
-
-  describe '.parse' do
-    def parse(line, opts = {})
-      IniParse::Lines::Option.parse(line, opts)
-    end
-
-    it 'should typecast empty values to nil' do
-      parse('key =').should be_option_tuple('key', nil)
-      parse('key = ').should be_option_tuple('key', nil)
-      parse('key =    ').should be_option_tuple('key', nil)
-    end
-
-    it 'should typecast "true" to TrueClass' do
-      parse('key = true').should be_option_tuple('key', true)
-      parse('key = TRUE').should be_option_tuple('key', true)
-    end
-
-    it 'should typecast "false" to FalseClass' do
-      parse('key = false').should be_option_tuple('key', false)
-      parse('key = FALSE').should be_option_tuple('key', false)
-    end
-
-    it 'should typecast integer values to Integer' do
-      parse('key = 1').should be_option_tuple('key', 1)
-      parse('key = 10').should be_option_tuple('key', 10)
-    end
-
-    it 'should not typecast integers with a leading 0 to Integer' do
-      parse('key = 0700').should be_option_tuple('key', '0700')
-    end
-
-    it 'should typecast negative integer values to Integer' do
-      parse('key = -1').should be_option_tuple('key', -1)
-    end
-
-    it 'should typecast float values to Float' do
-      parse('key = 3.14159265').should be_option_tuple('key', 3.14159265)
-    end
-
-    it 'should typecast negative float values to Float' do
-      parse('key = -3.14159265').should be_option_tuple('key', -3.14159265)
-    end
-
-    it 'should typecast scientific notation numbers to Float' do
-      parse('key = 10e5').should be_option_tuple('key', 10e5)
-      parse('key = 10e+5').should be_option_tuple('key', 10e5)
-      parse('key = 10e-5').should be_option_tuple('key', 10e-5)
-
-      parse('key = -10e5').should be_option_tuple('key', -10e5)
-      parse('key = -10e+5').should be_option_tuple('key', -10e5)
-      parse('key = -10e-5').should be_option_tuple('key', -10e-5)
-
-      parse('key = 3.14159265e5').should be_option_tuple('key', 3.14159265e5)
-      parse('key = 3.14159265e+5').should be_option_tuple('key', 3.14159265e5)
-      parse('key = 3.14159265e-5').should be_option_tuple('key', 3.14159265e-5)
-
-      parse('key = -3.14159265e5').should be_option_tuple('key', -3.14159265e5)
-      parse('key = -3.14159265e+5').should be_option_tuple('key', -3.14159265e5)
-      parse('key = -3.14159265e-5').should be_option_tuple('key', -3.14159265e-5)
-    end
-  end
-end
-
-#
-# Blank
-#
-
-#
-# Comment
-#
-
-describe 'IniParse::Lines::Comment' do
-  describe '#has_comment?' do
-    it 'should return true if :comment has a non-blank value' do
-      IniParse::Lines::Comment.new(:comment => 'comment').should have_comment
-    end
-
-    it 'should return true if :comment has a blank value' do
-      IniParse::Lines::Comment.new(:comment => '').should have_comment
-    end
-
-    it 'should return true if :comment has a nil value' do
-      IniParse::Lines::Comment.new.should have_comment
-      IniParse::Lines::Comment.new(:comment => nil).should have_comment
-    end
-  end
-
-  describe '#to_ini' do
-    it 'should return the comment' do
-      IniParse::Lines::Comment.new(
-        :comment => 'a comment'
-      ).to_ini.should == '; a comment'
-    end
-
-    it 'should preserve comment offset' do
-      IniParse::Lines::Comment.new(
-        :comment => 'a comment', :comment_offset => 10
-      ).to_ini.should == '          ; a comment'
-    end
-
-    it 'should return just the comment_sep if the comment is blank' do
-      IniParse::Lines::Comment.new.to_ini.should == ';'
-    end
-  end
-end