configliere 0.0.1

data/spec/configliere/commandline_spec.rb

@@ -0,0 +1,62 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+require 'configliere/commandline'
+
+describe "Configliere::Commandline" do
+  before do
+    @config = Configliere::Param.new :param_1 => 'val 1', :cat => :hat
+  end
+
+  it 'handles --param=val pairs' do
+    ::ARGV.replace ['--my_param=my_val']
+    @config.resolve!
+    @config.should == { :my_param => 'my_val', :param_1 => 'val 1', :cat => :hat}
+  end
+  it 'handles --dotted.param.name=val pairs' do
+    ::ARGV.replace ['--dotted.param.name=my_val']
+    @config.resolve!
+    @config.rest.should be_empty
+    @config.should == { :dotted => { :param => { :name => 'my_val' }}, :param_1 => 'val 1', :cat => :hat}
+  end
+  it 'handles --dashed-param-name=val pairs' do
+    ::ARGV.replace ['--dashed-param-name=my_val']
+    @config.resolve!
+    @config.rest.should be_empty
+    @config.should == { :dashed => { :param => { :name => 'my_val' }}, :param_1 => 'val 1', :cat => :hat}
+  end
+  it 'uses the last-seen of the commandline values' do
+    ::ARGV.replace ['--param_1=A', '--param_1=B']
+    @config.resolve!
+    @config.rest.should be_empty
+    @config.should == { :param_1 => 'B', :cat => :hat}
+  end
+  it 'sets a bare parameter (no "=") to true' do
+    ::ARGV.replace ['--param_1', '--deep.param']
+    @config.resolve!
+    @config.rest.should be_empty
+    @config.should == { :param_1 => true, :deep => { :param => true }, :cat => :hat}
+  end
+  it 'sets an explicit blank to nil' do
+    ::ARGV.replace ['--param_1=', '--deep.param=']
+    @config.resolve!
+    @config.should == { :param_1 => nil, :deep => { :param => nil }, :cat => :hat}
+  end
+
+  it 'saves non --param args into rest' do
+    ::ARGV.replace ['--param_1', 'file1', 'file2']
+    @config.resolve!
+    @config.should == { :param_1 => true, :cat => :hat}
+    @config.rest.should == ['file1', 'file2']
+  end
+
+  it 'stops processing on "--"' do
+    ::ARGV.replace ['--param_1=A', '--', '--param_1=B']
+    @config.resolve!
+    @config.rest.should == ['--param_1=B']
+    @config.should == { :param_1 => 'A', :cat => :hat}
+  end
+
+  after do
+    ::ARGV.replace []
+  end
+end
+

data/spec/configliere/config_blocks_spec.rb

@@ -0,0 +1,26 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+Configliere.use :config_blocks
+
+describe "Configliere::ConfigBlocks" do
+  before do
+    @config = Configliere::Param.new :normal_param => 'normal'
+  end
+
+  describe 'resolving' do
+    it 'runs blocks' do
+      @block_watcher = 'watcher'
+      @block_watcher.should_receive(:fnord).with(@config)
+      @config.finally{|arg| @block_watcher.fnord(arg) }
+      @config.resolve!
+    end
+    it 'resolves blocks last' do
+      Configliere.use :config_blocks, :define, :encrypted
+      @config.should_receive(:resolve_types!).ordered
+      @config.should_receive(:resolve_finally_blocks!).ordered
+      @config.resolve!
+    end
+  end
+
+end
+
+

data/spec/configliere/crypter_spec.rb

@@ -0,0 +1,18 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+require 'configliere/crypter'
+include Configliere
+
+describe "Crypter" do
+  ENCRYPTED_FOO_VAL = "q\317\201\247\230\314P\021\305\n\363\315d\207\345y\346\255\a\202\006i\245\343T\203e\327a\316\245\313"
+  it "encrypts" do
+    # Force the same initialization vector as used to prepare the test value
+    @cipher = Crypter.send(:new_cipher, :encrypt, 'sekrit')
+    Crypter.should_receive(:new_cipher).and_return(@cipher)
+    @cipher.should_receive(:random_iv).and_return ENCRYPTED_FOO_VAL[0..15]
+    # OK so do the test now.
+    Crypter.encrypt('foo_val', 'sekrit').should == ENCRYPTED_FOO_VAL
+  end
+  it "decrypts" do
+    Crypter.decrypt(ENCRYPTED_FOO_VAL, 'sekrit').should == 'foo_val'
+  end
+end

data/spec/configliere/define_spec.rb

@@ -0,0 +1,97 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+Configliere.use :define
+
+describe "Configliere::Define" do
+  before do
+    @config = Configliere::Param.new :normal_param => 'normal'
+  end
+  describe 'defining any aspect of a param' do
+    it 'adopts values' do
+      @config.define :param, :description => 'desc'
+      @config.param_definitions[:param].should == { :description => 'desc'}
+    end
+    it 'merges new definitions' do
+      @config.define :param, :description => 'desc 1'
+      @config.define :param, :description => 'desc 2'
+      @config.param_definitions[:param].should == { :description => 'desc 2'}
+      @config.define :param, :encrypted => true
+      @config.param_definitions[:param].should == { :encrypted => true, :description => 'desc 2'}
+    end
+    it 'lists params defined as the given aspect' do
+      @config.define :param_1, :description => 'desc 1'
+      @config.define :param_2, :description => 'desc 2'
+      @config.define :param_3, :something_else => 'foo'
+      @config.send(:params_with, :description).should include(:param_1)
+      @config.send(:params_with, :description).should include(:param_2)
+    end
+  end
+
+  describe 'defining descriptions' do
+    before do
+      @config.define :param_1, :description => 'desc 1'
+      @config.define :param_2, :description => 'desc 2'
+    end
+    it 'shows description for a param' do
+      @config.description_for(:param_1).should == 'desc 1'
+    end
+    it 'lists descriptions' do
+      @config.descriptions.should == { :param_1 => 'desc 1', :param_2 => 'desc 2'}
+    end
+    it 'lists descriptions' do
+      @config.described_params.should include(:param_1)
+      @config.described_params.should include(:param_2)
+    end
+  end
+
+  require 'date'; require 'time'
+  describe 'type coercion' do
+    [
+      [:boolean, '0', false],  [:boolean, 0, false], [:boolean, '',  false], [:boolean, [], false], [:boolean, nil, nil],
+      [:boolean, '1', true],   [:boolean, 1, true],  [:boolean, '5', true],  [:boolean, 'true', true],
+      [Integer, '5', 5],       [Integer, 5,   5],    [Integer, nil, nil],    [Integer, '', nil],
+      [Integer, '5', 5],       [Integer, 5,   5],    [Integer, nil, nil],    [Integer, '', nil],
+      [Float,   '5.2', 5.2],   [Float,   5.2, 5.2],  [Float, nil, nil],      [Float, '', nil],
+      [Symbol,   'foo', :foo], [Symbol, :foo, :foo], [Symbol, nil, nil],     [Symbol, '', nil],
+      [Date,    '1985-11-05',           Date.parse('1985-11-05')],               [Date, nil, nil], [Date, '', nil],
+      [DateTime, '1985-11-05 11:00:00', DateTime.parse('1985-11-05 11:00:00')],  [DateTime, nil, nil], [DateTime, '', nil],
+      [Time,     '1985-11-05 11:00:00', Time.parse('1985-11-05 11:00:00')],      [Time, nil, nil], [Time, '', nil],
+    ].each do |type, orig, desired|
+      it "for #{type} converts #{orig.inspect} to #{desired.inspect}" do
+        @config.define :param, :type => type
+        @config[:param] = orig ; @config.resolve! ; @config[:param].should == desired
+      end
+    end
+  end
+
+
+  describe 'defining requireds' do
+    before do
+      @config.define :param_1, :required => true
+      @config.define :param_2, :required => true
+      @config.define :optional_1, :required => false
+      @config.define :optional_2
+    end
+    it 'lists required params' do
+      @config.required_params.should include(:param_1)
+      @config.required_params.should include(:param_2)
+    end
+    it 'counts false values as required' do
+      p [@config]
+      @config.defaults :param_1 => true, :param_2 => false
+      @config.validate!.should == true
+    end
+    it 'counts nil-but-set values as missing' do
+      @config.defaults :param_1 => true, :param_2 => nil
+      lambda{ @config.validate! }.should raise_error "Missing values for param_2"
+    end
+    it 'counts never-set values as missing' do
+      lambda{ @config.validate! }.should raise_error "Missing values for param_1, param_2"
+    end
+    it 'lists all missing values when it raises' do
+      Configliere.use :define
+      lambda{ p @config.validate! }.should raise_error "Missing values for param_1, param_2"
+    end
+  end
+end
+
+

data/spec/configliere/encrypted_spec.rb

@@ -0,0 +1,71 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+Configliere.use :encrypted
+
+describe "Configliere::Encrypted" do
+  before do
+    @config = Configliere::Param.new :secret => 'encrypt_me', :normal_param => 'normal'
+    @config.define :secret, :encrypted => true
+    @config.encrypt_pass = 'pass'
+  end
+
+  describe 'defining encrypted params' do
+    it 'is encrypted if defined with :encrypted => true' do
+      @config.send(:encrypted_params).should include(:secret)
+    end
+    it 'is not encrypted if defined with :encrypted => false' do
+      @config.define :another_param,   :encrypted => false
+      @config.send(:encrypted_params).should_not include(:another_param)
+      @config.send(:encrypted_params).should     include(:secret)
+    end
+    it 'is encrypted if not defined' do
+      @config.send(:encrypted_params).should_not include(:missing_param)
+    end
+  end
+
+  describe 'encrypting encryptable params' do
+    it 'encrypts all params marked encrypted' do
+      Configliere::Crypter.should_receive(:encrypt).with('encrypt_me', 'pass').and_return('ok_encrypted')
+      @config.send(:export).should == { :normal_param => 'normal', :encrypted_secret => 'ok_encrypted'}
+    end
+    it 'gets encrypted params successfully' do
+      Configliere::Crypter.should_receive(:encrypt).with('encrypt_me', 'pass').and_return('ok_encrypted')
+      @config.send(:encrypted, @config[:secret]).should == 'ok_encrypted'
+    end
+    it 'fails if no pass is set' do
+      # create the config but don't set an encrypt_pass
+      @config = Configliere::Param.new :secret => 'encrypt_me', :normal_param => 'normal'
+      lambda{ @config.send(:encrypted, @config[:secret]) }.should raise_error('Blank encryption password!')
+    end
+  end
+
+  describe 'decrypting encryptable params' do
+    it 'decrypts all params marked encrypted' do
+      @config.delete   :secret
+      @config.defaults :encrypted_secret => 'decrypt_me'
+      Configliere::Crypter.should_receive(:decrypt).with('decrypt_me', 'pass').and_return('ok_decrypted')
+      @config.send(:resolve_encrypted!)
+      @config.should == { :normal_param => 'normal', :secret => 'ok_decrypted'}
+    end
+  end
+
+  describe 'loading a file' do
+    before do
+      @encrypted_str = "*\210BM\305\353\325\240.\226\212g\266f|\177\221\252k\263\363\260\031\263\371\035\257\024f+\001\350"
+    end
+    it 'encrypts' do
+      Configliere::Crypter.should_receive(:encrypt).and_return(@encrypted_str)
+      Configliere::ParamStore.should_receive(:write_yaml_file).with('/fake/file', :normal_param=>"normal", :encrypted_secret => @encrypted_str)
+      @config.save! '/fake/file'
+    end
+    it 'decrypts' do
+      @hsh = { :loaded_param => "loaded", :encrypted_secret => @encrypted_str }
+      File.stub(:open)
+      YAML.should_receive(:load).and_return(@hsh)
+      @config.read 'file.yaml'
+      @config.resolve!
+      @config.should == { :loaded_param => "loaded", :secret => 'decrypt_me', :normal_param => 'normal' }
+    end
+  end
+end
+
+

data/spec/configliere/environment_spec.rb

@@ -0,0 +1,23 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+Configliere.use :environment
+
+describe "Configliere::Environment" do
+  before do
+    @config = Configliere::Param.new
+  end
+
+  describe 'loads environment variables' do
+    it 'loads a simple value into the corresponding symbolic key' do
+      ENV.should_receive(:[]).with('HOME').and_return('/fake/path')
+      @config.environment_variables 'HOME'
+      @config[:home].should == '/fake/path'
+    end
+    it 'loads a hash into the individual params' do
+      ENV.should_receive(:[]).with('HOME').and_return('/fake/path')
+      ENV.should_receive(:[]).with('POWER_SUPPLY').and_return('1.21 jigawatts')
+      @config.environment_variables 'HOME' => :home, 'POWER_SUPPLY' => 'delorean.power_supply'
+      @config[:home].should == '/fake/path'
+      @config[:delorean][:power_supply].should == '1.21 jigawatts'
+    end
+  end
+end

data/spec/configliere/param_spec.rb

@@ -0,0 +1,43 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe "Configliere::Param" do
+  before do
+    @config = Configliere::Param.new
+  end
+
+  describe '#defaults' do
+    it 'merges new params' do
+      @config.defaults :hat => :cat, :basket => :lotion, :moon => { :man => :smiling }
+      @config.defaults :basket => :tasket, :moon => { :cow => :jumping }
+      @config.should == { :hat => :cat, :basket => :tasket, :moon => { :man => :smiling, :cow => :jumping } }
+    end
+  end
+
+  describe 'setting vals' do
+    it 'symbolizes keys' do
+      @config.defaults :hat => :cat, :basket => :lotion
+      @config['hat'] = :fedora
+      @config['new'] = :unseen
+      @config.should == { :hat => :fedora, :basket => :lotion, :new => :unseen }
+    end
+    it 'deep-sets dotted vals' do
+      @config.defaults :hat => :cat, :basket => :lotion, :moon => { :man => :smiling }
+      @config['moon.man'] = :cheesy
+      @config[:moon][:man].should == :cheesy
+      @config['moon.cheese.type'] = :tilsit
+      @config[:moon][:cheese][:type].should == :tilsit
+    end
+    it 'deep-gets dotted vals' do
+      hsh = { :hat => :cat, :basket => :lotion, :moon => { :man => :smiling, :cheese => {:type => :tilsit} } }
+      @config.defaults hsh
+      @config['moon.man'].should == :smiling
+      @config['moon.cheese.type'].should == :tilsit
+      @config['moon.cheese.smell'].should be_nil
+      @config['moon.non.existent.interim.values'].should be_nil
+      @config['moon.non'].should be_nil
+      lambda{ @config['hat.cat'] }.should raise_error(NoMethodError, 'undefined method `[]\' for :cat:Symbol')
+      @config.should == hsh # shouldn't change from reading
+    end
+  end
+
+end

data/spec/configliere/param_store_spec.rb

@@ -0,0 +1,81 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+Configliere.use :param_store
+
+describe "Configliere::ParamStore" do
+  before do
+    @config = Configliere.new :my_param => 'val'
+  end
+
+  describe 'loads a config file' do
+    before do
+      @config = Configliere::Param.new :my_param => 'val'
+      @fake_file = '{ :my_param: val }'
+    end
+    describe 'successfully' do
+      it 'loads a symbol name from the default config file' do
+        File.should_receive(:open).with(Configliere::DEFAULT_CONFIG_FILE).and_return(':my_settings: ' + @fake_file)
+        @config.read :my_settings
+      end
+      it 'loads an absolute pathname from the given file' do
+        File.should_receive(:open).with('/fake/path.yaml').and_return(@fake_file)
+        @config.read '/fake/path.yaml'
+      end
+      it 'loads a simple filename from the default config dir' do
+        File.should_receive(:open).with(Configliere::DEFAULT_CONFIG_DIR + '/file.yaml').and_return(@fake_file)
+        @config.read 'file.yaml'
+      end
+      after do
+        @config[:my_param].should == 'val'
+      end
+    end
+    describe 'in edge cases' do
+      it 'handles a file not found' do
+        @config = Configliere::Param.new
+        File.stub(:open).and_raise(Errno::ENOENT)
+        @config.read('nonexistent_file.yaml').should == {}
+      end
+    end
+  end
+
+  describe 'saves to a config file' do
+    describe 'successfully' do
+      it 'saves a symbol name to the default config file' do
+        Configliere::ParamStore.should_receive(:merge_into_yaml_file).
+          with(Configliere::DEFAULT_CONFIG_FILE, :my_settings, { :my_param => 'val'})
+        @config.save! :my_settings
+      end
+      it 'saves a pathname to the given file' do
+        fake_file = StringIO.new('', 'w')
+        File.should_receive(:open).with('/fake/path.yaml', 'w').and_yield(fake_file)
+        fake_file.should_receive(:<<).with("--- \n:my_param: val\n")
+        @config.save! '/fake/path.yaml'
+      end
+    end
+  end
+
+  describe 'merge_into_yaml_file' do
+    it 'merges, leaving existing values put' do
+      fake_file = StringIO.new(":my_settings: { :my_param: orig_val }\n:other_settings: { :that_param: other_val }", 'r+')
+      File.should_receive(:open).with('/fake/path.yaml').and_return(fake_file)
+      File.should_receive(:open).with('/fake/path.yaml', 'w').and_yield(fake_file)
+      mock_dump = 'mock_dump'
+      YAML.should_receive(:dump).with({ :my_settings => { :my_param => 'new_val'}, :other_settings => { :that_param => 'other_val'}}).and_return(mock_dump)
+      fake_file.should_receive(:<<).with(mock_dump)
+      Configliere::ParamStore.merge_into_yaml_file '/fake/path.yaml', :my_settings, :my_param => 'new_val'
+    end
+  end
+
+  describe 'maps handles to filenames' do
+    it 'loads a symbol name from the default config file' do
+      @config.send(:filename_for_handle, :my_settings).should == Configliere::DEFAULT_CONFIG_FILE
+    end
+    it 'loads an absolute pathname from the given file' do
+      @config.send(:filename_for_handle, '/fake/path.yaml').should == '/fake/path.yaml'
+    end
+    it 'loads a simple filename from the default config dir' do
+      @config.send(:filename_for_handle, 'file.yaml').should == Configliere::DEFAULT_CONFIG_DIR + '/file.yaml'
+    end
+  end
+
+end
+

data/spec/configliere_spec.rb

@@ -0,0 +1,21 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "Configliere" do
+  it 'creates a new param on new' do
+    mock_param = 'mock_param'
+    Configliere::Param.should_receive(:new).with(:this => :that).and_return(mock_param)
+    Configliere.new(:this => :that).should == mock_param
+  end
+  it 'creates a global variable Settings' do
+    Settings.class.should == Configliere::Param
+  end
+  it 'creates a glocal method Settings' do
+    Settings.should_receive(:defaults).with(:foo => :bar)
+    Settings(:foo => :bar)
+  end
+
+  it 'requires modules with use' do
+    lambda{ Configliere.use(:param, :foo) }.should raise_error(LoadError, 'no such file to load -- configliere/foo')
+  end
+
+end