secretary 0.0.1

data/History.txt

@@ -0,0 +1,8 @@
+=== 0.0.1 / 2008-08-11
+
+* 1 major enhancement
+
+  * Birthday; project created
+  * Standard secretary, error, and YAML gopher classes created
+  * Secretary, error, and YAML gopher RSpec specifications created
+

data/Manifest.txt

@@ -0,0 +1,15 @@
+History.txt
+Manifest.txt
+README.txt
+Rakefile
+lib/secretary.rb
+lib/secretary/error.rb
+lib/secretary/gopher.rb
+lib/secretary/gopher/yaml.rb
+spec/spec_helper.rb
+spec/secretary_spec.rb
+spec/error_spec.rb
+spec/gopher_spec.rb
+spec/hash.yaml
+spec/array.yaml
+spec/broken-yaml.txt

data/README.txt

@@ -0,0 +1,92 @@
+= secretary
+
+* http://secretary.rubyforge.org
+
+== DESCRIPTION:
+
+Secretary is a gem who makes managing simple preference files in Ruby easy
+and painless. If you tire of being bound to PStore or YAML and want a
+consistent, pluggable way to read and write preferences, your Secretary would
+be happy to help!
+
+== FEATURES:
+
+* She's smooth and simple: just import and initialize!
+* She flexible: though she uses the simple YAML markup language by default, she
+  can easily switch to any other format!
+* She supports custom defaults, a big essential!
+* She's easily extensible--subclass Secretary::Gopher to be able to load any
+  kind of file you wish!
+* All in all, she's a small, no-frills object who gives you one less thing to
+  worry about. It can't be any easier!
+
+== SYNOPSIS:
+
+  import 'secretary/simple'
+  
+  preferences = {'name': 'Samantha', 'port': 151}
+  defaults = {'name': '', 'port': 80}
+  
+  secretary = Secretary.new 'preferences.yaml', defaults
+  
+  # The first argument is the path to the file that she will sync to.
+  # The second argument indicates the object that contains her defaults.
+  # There's also an optional third argument that determines how she will sync
+  # with her file--by default, it'll be YAML.
+  
+  secretary['url'] = 'http://samantha.name'
+  
+  secretary['name'] # <- 'Samantha'
+  secretary['url'] = 'http://samantha.name'
+  secretary['port'] # <- 80
+  
+  secretary.save # Saves to a YAML file called 'preferences.yaml'.
+
+== REQUIREMENTS:
+
+* At least Ruby 1.8.0
+* The standard forwarable.rb
+* The standard yaml.rb
+* At least RSpec 1.1 (but only if you want to unit test using Secretary's
+  included specs)
+
+== INSTALL:
+
+The recommended way to install Secretary is to use rubygems to download and
+install it automatically:
+
+  gem install secretary
+
+== NOTES:
+
+I'm planning to add support for managing arbitrary objects, not just Hashes,
+as well as support for more formats like CSV (easy), JSON (easier), and XML
+(hard).
+
+In addition, this is my first programming project ever, and I'm sort of not
+used to this. I'd be very happy to hear your comments and bugs on Rubyforge.
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2008
+
+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/Rakefile

@@ -0,0 +1,12 @@
+# -*- ruby -*-
+
+require 'rubygems'
+require 'hoe'
+require './lib/secretary'
+
+Hoe.new('secretary', Secretary::VERSION) do |p|
+  p.developer('Joshua Choi', 'joshua@choi.name')
+  p.remote_rdoc_dir = '' # Release to root
+end
+
+# vim: syntax=Ruby

data/lib/secretary.rb

@@ -0,0 +1,57 @@
+$: << File.expand_path(File.dirname(__FILE__) + '/../lib')
+require 'secretary/error'
+require 'secretary/gopher/yaml'
+require 'forwardable'
+
+class Secretary
+  VERSION = '0.0.1'
+  extend Forwardable
+  include Enumerable
+  attr_reader :file_path, :defaults, :gopher
+  
+  def initialize(file_path, defaults={}, gopher_class=Gopher::YAML)
+    unless gopher_class.respond_to? :new
+      raise ArgumentError, "given gopher class is not a class (#{gopher_class})"
+    end
+    @file_path = file_path
+    @defaults = defaults
+    @gopher = gopher_class.new Hash
+    unless @gopher.respond_to? :load_from_path
+      raise ArgumentError, "given gopher class\'s members do not respond to :load_from_path (#{gopher})"
+    end
+    @contents = {}
+    reload
+  end
+  
+  def_delegators :to_hash, :[], :include?, :each, :each_pair, :each_key, :each_value
+  def_delegators :@contents, :[]=, :delete
+  
+  def ==(other)
+    other.respond_to? :file_path and other.respond_to? :defaults \
+      and other.respond_to? :gopher and other.respond_to? :to_hash \
+      and file_path == other.file_path and defaults == other.defaults \
+      and gopher == other.gopher and to_hash == other.to_hash
+  end
+  
+  def to_hash
+    defaults.merge @contents
+  end
+  
+  def reload
+    begin
+      loaded_data = gopher.load_from_path(file_path)
+      unless loaded_data.respond_to? :to_hash
+        raise IOError, "gopher's loaded data is unconvertable to a Hash and thus invalid (#{loaded_data})"
+      end
+      @contents.merge! loaded_data
+      return true
+    rescue Error::MissingFile
+      return false
+    end
+  end
+  
+  def save
+    gopher.save self.to_hash, file_path
+  end
+  
+end

data/lib/secretary/error.rb

@@ -0,0 +1,31 @@
+class Secretary
+  
+  module Error
+    
+    class MissingFile < IOError
+
+      def initialize(missing_file_path)
+        super "no such file or directory (#{missing_file_path})"
+      end
+
+    end
+
+    class Parsing < IOError
+
+      def initialize(parsing_error, file_type)
+        super "attempted to parse an invalid #{file_type} file (#{parsing_error})"
+      end
+
+    end
+
+    class InvalidData < IOError
+
+      def initialize(data, valid_data_type)
+        super "preference file of invalid data type (should be #{valid_data_type} instead of #{data.class})"
+      end
+
+    end
+
+  end
+  
+end

data/lib/secretary/gopher.rb

@@ -0,0 +1,59 @@
+require 'secretary/error'
+
+class Secretary
+  
+  class Gopher
+    # Abstract base class that requires methods #parse_file(input_file),
+    # #valid_file_type(), and #emit(data) to survive.
+    VERSION = '0.0.1'
+    attr_reader :valid_data_type
+    class << self
+      attr_reader :valid_file_type
+    end
+    
+    def initialize(valid_data_type)
+      @valid_data_type = valid_data_type
+    end
+
+    def load_from_path(file_path)
+      if File.exist? file_path
+        open file_path do |file|
+          return load_from_file(file)
+        end
+      else
+        raise Secretary::Error::MissingFile.new(file_path)
+      end
+    end
+
+    def load_from_file(file)
+      begin
+        file_data = parse_file file
+      rescue Secretary::Error::Parsing => parsing_error
+        raise parsing_error
+      end
+      unless file_data.kind_of? valid_data_type
+        raise Secretary::Error::InvalidData.new(file_data, valid_data_type)
+      end
+      return file_data
+    end
+    
+    def save(data, file_path)
+      unless data.kind_of? valid_data_type
+        raise ArgumentError, "invalid data #{data} is not a kind of #{valid_data_type}"
+      end
+      open file_path, 'w' do |file|
+        file.puts emit(data)
+      end
+    end
+    
+    def valid_file_type
+      self.class.valid_file_type
+    end
+    
+    def ==(other)
+      self.class == other.class
+    end
+    
+  end
+  
+end

data/lib/secretary/gopher/yaml.rb

@@ -0,0 +1,27 @@
+require 'secretary/gopher'
+require 'yaml'
+
+class Secretary
+  
+  class Gopher
+    
+    class YAML < Secretary::Gopher
+      @valid_file_type = 'YAML'
+      
+      def parse_file(file)
+        begin
+          return ::YAML::load(file)
+        rescue ArgumentError => parsing_error
+          raise Secretary::Error::Parsing.new(parsing_error, valid_file_type)
+        end
+      end
+      
+      def emit(data)
+        data.to_yaml
+      end
+      
+    end
+    
+  end
+  
+end

data/spec/array.yaml

@@ -0,0 +1,4 @@
+---
+- Foo
+- Bar
+- Bam

data/spec/broken-yaml.txt

@@ -0,0 +1,5 @@
+This is an invalid preferences file for use in unit tests and specs. The
+following lines are meant to be invalid YAML syntax.
+
+foo bar: bash
+[32, 23, 53]

data/spec/error_spec.rb

@@ -0,0 +1,30 @@
+require File.dirname(__FILE__) + '/spec_helper'
+require 'lib/secretary'
+
+describe Secretary::Error::MissingFile do
+  
+  it 'should have a message with the missing file\'s path' do
+    Secretary::Error::MissingFile.new('missing-file.txt').to_s \
+      .should == 'no such file or directory (missing-file.txt)'
+  end
+  
+end
+
+describe Secretary::Error::Parsing do
+  
+  it 'should have a message with the missing file\'s path' do
+    parsing_error = SyntaxError.new 'invalid char found at line 3'
+    Secretary::Error::Parsing.new(parsing_error, 'YAML').to_s \
+      .should == 'attempted to parse an invalid YAML file (invalid char found at line 3)'
+  end
+  
+end
+
+describe Secretary::Error::InvalidData do
+  
+  it 'should have a message with the missing file\'s path' do
+    Secretary::Error::InvalidData.new([3, 2], Hash).to_s \
+      .should == 'preference file of invalid data type (should be Hash instead of Array)'
+  end
+  
+end

data/spec/gopher_spec.rb

@@ -0,0 +1,157 @@
+require File.dirname(__FILE__) + '/spec_helper'
+require 'lib/secretary/gopher/yaml'
+
+describe Secretary::Gopher::YAML do
+  
+  it 'should be equal with another if they are of equal class' do
+    gopher0 = Secretary::Gopher::YAML.new stub_everything
+    gopher1 = Secretary::Gopher::YAML.new stub_everything
+    gopher0.should == gopher1
+    gopher1.should == gopher0
+  end
+  
+  it 'should be unequal with another if they are of unequal class, even if the other is a kind of its class' do
+    gopher0 = Secretary::Gopher::YAML.new stub_everything
+    gopher1 = stub :kind_of? => true
+    gopher0.should_not == gopher1
+  end
+  
+  
+  it 'should know its valid data type' do
+    data_type = stub 'Data Type'
+    gopher = Secretary::Gopher::YAML.new data_type
+    gopher.valid_data_type.should == data_type
+  end
+  
+  it 'should know its valid file type and it should be YAML' do
+    Secretary::Gopher::YAML.new(stub_everything).valid_file_type.should == 'YAML'
+  end
+  
+  describe 'when trying to save an object into a YAML file using a file path' do
+    
+    it 'should save a given Hash when the valid data type is Hash' do
+        gopher = Secretary::Gopher::YAML.new Hash
+        data = {:name => 'Tracy', :url => 'http://tracy.name'}
+        file_path = File.dirname(__FILE__) + '/temporary.yaml'
+        gopher.save data, file_path
+        open file_path do |file|
+          YAML::load(file).should == data
+        end
+        File.delete file_path
+      end
+  
+    it 'should save a given object when the object is of its valid data type' do
+      class Person
+        def initialize
+          @name = 'Sal'
+          @age = 76
+        end
+        def ==(other)
+          self.class == other.class
+        end
+      end
+      data = Person.new
+      gopher = Secretary::Gopher::YAML.new Person
+      file_path = File.dirname(__FILE__) + '/temporary.yaml'
+      gopher.save data, file_path
+      open file_path do |file|
+        YAML::load(file).should == data
+      end
+      File.delete file_path
+    end
+  
+    it 'should raise an error if it tries to save data that is not of its valid data type' do
+      gopher = Secretary::Gopher::YAML.new Hash
+      data = [3, 2, 1]
+      file_path = File.dirname(__FILE__) + '/temporary.yaml'
+      lambda { gopher.save data, file_path }.should raise_error(ArgumentError)
+    end
+  
+    it 'should not create a new file if it tries to save data that is not of its valid data type' do
+      gopher = Secretary::Gopher::YAML.new Hash
+      data = [3, 2, 1]
+      file_path = File.dirname(__FILE__) + '/temporary.yaml'
+      begin
+        gopher.save data, file_path
+      rescue ArgumentError
+      end
+      File.exists?(file_path).should_not be_true
+    end
+  
+    it 'should not modify any file if it tries to save data that is not of its valid data type' do
+      gopher = Secretary::Gopher::YAML.new Hash
+      data0 = {:name => 'Tracy', :url => 'http://tracy.name'}
+      data1 = [3, 2, 1]
+      file_path = File.dirname(__FILE__) + '/temporary.yaml'
+      gopher.save data0, file_path
+      begin
+        gopher.save data1, file_path
+      rescue ArgumentError
+      end
+      open file_path do |file|
+        YAML::load(file).should == data0
+      end
+      File.delete file_path
+    end
+    
+  end
+  
+  describe 'when reading from a file' do
+    
+    it 'should get the file\'s data when the file is YAML and that data is a Hash and the given type is Hash' do
+      preferences0 = {'name' => 'Billy Bob', 'email' => 'xxx@yyy.zzz'}
+      file_path = File.dirname(__FILE__) + '/hash.yaml'
+      open file_path do |file|
+        require 'yaml'
+        gopher = Secretary::Gopher::YAML.new Hash
+        preferences1 = gopher.load_from_file file
+        preferences1.should == preferences0
+      end
+    end
+    
+    it 'should raise a ParsingError when the file is not YAML' do
+      gopher = Secretary::Gopher::YAML.new stub_everything
+      file_path = File.dirname(__FILE__) + '/broken-yaml.txt'
+      open file_path do |file|
+        lambda { gopher.load_from_file file } \
+          .should raise_error(Secretary::Error::Parsing)
+      end
+    end
+
+    it 'should raise an InvalidDataError when the file\'s data is not a Hash and the valid data type is Hash' do
+      gopher = Secretary::Gopher::YAML.new Hash
+      file_path = File.dirname(__FILE__) + '/array.yaml'
+      open file_path do |file|
+        lambda { gopher.load_from_file file } \
+          .should raise_error(Secretary::Error::InvalidData)
+      end
+    end
+
+  end
+  
+  describe 'when reading from a path to a file' do
+  
+    it 'should raise a MissingFileError when the path leads to nowhere' do
+      gopher = Secretary::Gopher::YAML.new Hash
+      lambda { gopher.load_from_path 'missing-file.yaml' } \
+        .should raise_error(Secretary::Error::MissingFile)
+    end
+
+    it 'should get the path\'s file\'s data when the file is YAML and that data is a Hash and the given type is Hash' do
+      preferences0 = {'name' => 'Billy Bob', 'email' => 'xxx@yyy.zzz'}
+      gopher = Secretary::Gopher::YAML.new Hash
+      file_path = File.dirname(__FILE__) + '/hash.yaml'
+      preferences1 = gopher.load_from_path(file_path)
+      preferences1.should == preferences0
+    end
+    
+    it 'should raise an InvalidDataError when the path\'s file\'s data is not a Hash and the valid data type is Hash' do
+      gopher = Secretary::Gopher::YAML.new Hash
+      file_path = File.dirname(__FILE__) + '/array.yaml'
+      lambda { gopher.load_from_path file_path } \
+        .should raise_error(Secretary::Error::InvalidData)
+    end
+    
+  end
+
+end

data/spec/hash.yaml

@@ -0,0 +1,3 @@
+---
+name: Billy Bob
+email: xxx@yyy.zzz

data/spec/secretary_spec.rb

@@ -0,0 +1,259 @@
+require File.dirname(__FILE__) + '/spec_helper'
+require 'lib/secretary'
+require 'lib/secretary/gopher/yaml'
+
+describe Secretary do
+  
+  it 'should be enumerable' do
+    gopher = stub 'Gopher', :load_from_path => {}
+    gopher_class = stub 'Gopher Class', :new => gopher
+    file_path = stub 'File Path'
+    secretary = Secretary.new file_path, {}, gopher_class
+    secretary.should be_a_kind_of(Enumerable)
+  end
+  
+  it 'should know the file path it saves to' do
+    gopher = stub 'Gopher', :load_from_path => {}
+    gopher_class = stub 'Gopher Class', :new => gopher
+    file_path = stub 'File Path'
+    secretary = Secretary.new file_path, {}, gopher_class
+    secretary.file_path.should == file_path
+  end
+  
+  it 'should know its defaults' do
+    gopher = stub 'Gopher', :load_from_path => {}
+    gopher_class = stub 'Gopher Class', :new => gopher
+    secretary = Secretary.new stub_everything, {'name' => ''}, gopher_class
+    secretary.defaults.should == {'name' => ''}
+  end
+  
+  it 'should have an empty hash for its defaults by default' do
+    gopher = stub 'Gopher', :load_from_path => {}
+    gopher_class = stub 'Gopher Class', :new => gopher
+    secretary = Secretary.new stub_everything, {}, gopher_class
+    secretary.defaults.should == {}
+  end
+  
+  it 'should create a new gopher, which expects a Hash, from the given gopher class' do
+    gopher = stub 'Gopher', :load_from_path => {}
+    gopher_class = mock 'Gopher Class'
+    gopher_class.should_receive(:new).with(Hash).and_return(gopher)
+    secretary = Secretary.new stub_everything, stub_everything, gopher_class
+  end
+  
+  it 'should create a new YAML gopher by default' do
+    secretary = Secretary.new 'file_path'
+    secretary.gopher.should be_a_kind_of(Secretary::Gopher::YAML)
+  end
+  
+  it 'should know its gopher' do
+    defaults = stub_everything
+    gopher = stub 'Gopher', :load_from_path => {}
+    gopher_class = stub 'Gopher Class', :new => gopher
+    secretary = Secretary.new stub_everything, defaults, gopher_class
+  end
+  
+  it 'should be able to set its values' do
+    data = {'name' => 'Billy Bob'}
+    gopher = stub 'Gopher', :load_from_path => data
+    gopher_class = stub 'Gopher Class', :new => gopher
+    secretary = Secretary.new stub_everything, {}, gopher_class
+    secretary['name'] = 'Joe'
+    secretary['name'].should == 'Joe'
+  end
+  
+  it 'should be able to delete its values' do
+    data = {'name' => 'Billy Bob'}
+    gopher = stub 'Gopher', :load_from_path => data
+    gopher_class = stub 'Gopher Class', :new => gopher
+    secretary = Secretary.new stub_everything, {}, gopher_class
+    secretary.delete 'name'
+    secretary.should_not include('name')
+  end
+  
+  describe 'when accessing a key' do
+    
+    it 'should know the key\'s value' do
+      data = {'name' => 'Billy Bob'}
+      gopher = stub 'Gopher', :load_from_path => data
+      gopher_class = stub 'Gopher Class', :new => gopher
+      secretary = Secretary.new stub_everything, {}, gopher_class
+      secretary['name'].should == 'Billy Bob'
+    end
+    
+    it 'should give the key\'s corresponding default value if the key\'s does not otherwise exist in its contents' do
+      defaults = {'name' => 'Billy Bob'}
+      data = {}
+      gopher = stub 'Gopher', :load_from_path => data
+      gopher_class = stub 'Gopher Class', :new => gopher
+      secretary = Secretary.new stub_everything, defaults, gopher_class
+      secretary['name'].should == 'Billy Bob'
+    end
+    
+    it 'should give the key\'s corresponding default value after the key is deleted' do
+      defaults = {'name' => 'Joe'}
+      data = {'name' => 'Billy Bob'}
+      gopher = stub 'Gopher', :load_from_path => data
+      gopher_class = stub 'Gopher Class', :new => gopher
+      secretary = Secretary.new stub_everything, defaults, gopher_class
+      secretary.delete 'name'
+      secretary['name'].should == 'Joe'
+    end
+    
+  end
+  
+  describe 'using a custom gopher' do
+    
+    it 'should raise an error when its given gopher class cannot make new gophers' do
+      gopher_class = stub 'Gopher Class'
+      lambda { Secretary.new stub_everything, {}, gopher_class } \
+        .should raise_error(ArgumentError)
+    end
+
+    it 'should raise an error when its given gopher class\'s objects cannot act like gophers' do
+      gopher = stub 'Gopher'
+      gopher_class = stub 'Gopher Class', :new => gopher
+      lambda { Secretary.new stub_everything, {}, gopher_class } \
+        .should raise_error(ArgumentError)
+    end
+
+    describe 'updating itself based on what the gopher brings from its file path' do
+      
+      it 'have contents of its defaults merged with the file\'s data, when initialized' do
+        defaults = {:bash => 'bang', :bar => 'bing'}
+        data = {:bar => 'foo', :bam => 'fiz'}
+        gopher = stub 'Gopher', :load_from_path => data
+        gopher_class = stub 'Gopher Class', :new => gopher
+        secretary = Secretary.new stub_everything, defaults, gopher_class
+        secretary.to_hash.should == defaults.merge(data)
+      end
+      
+      it 'have contents of its defaults only if its file does not yet exist, when initialized' do
+        defaults = {:bash => 'bang', :bar => 'bing'}
+        gopher = stub 'Gopher'
+        gopher.stub!(:load_from_path).and_raise(
+          Secretary::Error::MissingFile.new(stub_everything)
+        )
+        gopher_class = stub 'Gopher Class', :new => gopher
+        secretary = Secretary.new stub_everything, defaults, gopher_class
+        secretary.to_hash.should == defaults
+      end
+    
+      it 'should update its contents with its defaults, based on what the gopher brings from its file path, when reloaded' do
+        defaults = {:bash => 'bang', :bar => 'bing'}
+        data = {:bar => 'foo', :bam => 'fiz'}
+        gopher = stub 'Gopher'
+        gopher.stub!(:load_from_path).and_return({}, data)
+        gopher_class = stub 'Gopher Class', :new => gopher
+        secretary = Secretary.new stub_everything, defaults, gopher_class
+        secretary.reload
+        secretary.to_hash.should == defaults.merge(data)
+      end
+      
+    end
+
+    it 'should send its contents to the gopher when saving' do
+      contents = {:bar => 'foo', :bam => 'fiz'}
+      file_path = stub_everything
+      gopher = stub 'Gopher', :load_from_path => contents
+      gopher.should_receive(:save).with(contents, file_path).once
+      gopher_class = stub 'Gopher Class', :new => gopher
+      secretary = Secretary.new file_path, {}, gopher_class
+      secretary.save
+    end
+    
+  end
+
+  describe 'using a default YAML gopher' do
+
+    describe 'updating itself based on what the gopher brings from its file path' do
+      
+      it 'have contents of its defaults merged with the file\'s data, when initialized' do
+        defaults = {'name' => '', 'port' => 80}
+        data = {'name' => 'Billy Bob', 'email' => 'xxx@yyy.zzz'}
+        file_path = File.dirname(__FILE__) + '/hash.yaml'
+        secretary = Secretary.new file_path, defaults
+        secretary.to_hash.should == defaults.merge(data)
+      end
+      
+      it 'have contents of its defaults only if its file does not yet exist, when initialized' do
+        defaults = {'name' => '', 'port' => 80}
+        file_path = File.dirname(__FILE__) + '/missing_file.yaml'
+        secretary = Secretary.new file_path, defaults
+        secretary.to_hash.should == defaults
+      end
+      
+    end
+    
+    describe 'when saving data' do
+      
+      it 'should create a new data file if it does not exist' do
+        defaults = {'name' => '', 'port' => 80}
+        data = {'name' => 'Billy Bob', 'email' => 'xxx@yyy.zzz'}
+        file_path = File.dirname(__FILE__) + '/temporary.yaml'
+        secretary = Secretary.new file_path, defaults
+        secretary.save
+        File.exists?(file_path).should be_true
+        File.delete file_path
+      end
+
+    end
+    
+  end
+  
+  describe 'when comparing with another object' do
+    
+    it 'should be equal if their file paths, defaults, and contents are equal' do
+      file_path = stub_everything
+      defaults = {:boo => 'bash'}
+      contents = {:boo => 'bam', :foo => 'bar'}
+      gopher = stub 'Gopher', :load_from_path => contents
+      gopher_class = stub 'Gopher Class', :new => gopher
+      secretary = Secretary.new file_path, defaults, gopher_class
+      other = stub 'Other', :file_path => file_path, :defaults => defaults,
+        :gopher => gopher, :to_hash => contents
+      secretary.to_hash.should == other.to_hash
+      secretary.should == other
+    end
+    
+    it 'should be unequal if their file paths are unequal' do
+      defaults = {:bash => 'bang', :bar => 'bing'}
+      gopher_class = stub 'Gopher Class', :new => stub('Gopher', :load_from_path => {})
+      secretary0 = Secretary.new stub_everything, defaults, gopher_class
+      secretary1 = Secretary.new stub_everything, defaults, gopher_class
+      secretary0.should_not == secretary1
+    end
+    
+    it 'should be unequal if their defaults are unequal' do
+      gopher_class = stub 'Gopher Class', :new => stub('Gopher', :load_from_path => {})
+      defaults0 = {:bash => 'bang', :bar => 'bing'}
+      defaults1 = {:bash => 'foo', :bar => 'bing'}
+      secretary0 = Secretary.new stub_everything, defaults0, gopher_class
+      secretary1 = Secretary.new stub_everything, defaults1, gopher_class
+      secretary0.should_not == secretary1
+    end
+    
+    it 'should be unequal if the other does not respond to :file_path' do
+      gopher_class = stub 'Gopher Class', :new => stub('Gopher', :load_from_path => {})
+      secretary = Secretary.new stub_everything, {}, gopher_class
+      other = stub 'Other'
+      secretary.should_not == other
+    end
+    
+    it 'should be unequal if the other does not respond to :gopher' do
+      gopher_class = stub 'Gopher Class', :new => stub('Gopher', :load_from_path => {})
+      secretary = Secretary.new stub_everything, {}, gopher_class
+      other = stub 'Other'
+      secretary.should_not == other
+    end
+    
+    it 'should be unequal if the other does not respond to :file_path' do
+      gopher_class = stub 'Gopher Class', :new => stub('Gopher', :load_from_path => {})
+      secretary = Secretary.new stub_everything, {}, gopher_class
+      other = stub 'Other'
+      secretary.should_not == other
+    end
+    
+  end
+  
+end

data/spec/spec_helper.rb

@@ -0,0 +1 @@
+$: << File.expand_path(File.dirname(__FILE__) + '/../lib')

metadata

@@ -0,0 +1,81 @@
+--- !ruby/object:Gem::Specification 
+name: secretary
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Joshua Choi
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-08-12 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.7.0
+    version: 
+description: Secretary is a gem who makes managing simple preference files in Ruby easy and painless. If you tire of being bound to PStore or YAML and want a consistent, pluggable way to read and write preferences, your Secretary would be happy to help!
+email: 
+- joshua@choi.name
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- History.txt
+- Manifest.txt
+- README.txt
+- spec/broken-yaml.txt
+files: 
+- History.txt
+- Manifest.txt
+- README.txt
+- Rakefile
+- lib/secretary.rb
+- lib/secretary/error.rb
+- lib/secretary/gopher.rb
+- lib/secretary/gopher/yaml.rb
+- spec/spec_helper.rb
+- spec/secretary_spec.rb
+- spec/error_spec.rb
+- spec/gopher_spec.rb
+- spec/hash.yaml
+- spec/array.yaml
+- spec/broken-yaml.txt
+has_rdoc: true
+homepage: http://secretary.rubyforge.org
+post_install_message: 
+rdoc_options: 
+- --main
+- README.txt
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: secretary
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: Secretary is a gem who makes managing simple preference files in Ruby easy and painless
+test_files: []
+