configliere 0.3.4 → 0.4.4

data/spec/configliere/define_spec.rb

@@ -1,49 +1,68 @@
 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'}
+      @config.define :simple, :description => 'desc'
+      @config.definition_of(:simple).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'}
+      @config.define :described_in_steps, :description => 'desc 1'
+      @config.define :described_in_steps, :description => 'desc 2'
+      @config.definition_of(:described_in_steps).should == { :description => 'desc 2'}
+      @config.define :described_in_steps, :encrypted => true
+      @config.definition_of(:described_in_steps).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)
+      @config.define :has_description,      :description => 'desc 1'
+      @config.define :also_has_description, :description => 'desc 2'
+      @config.define :no_description,       :something_else => 'foo'
+      @config.params_with(:description).should include(:has_description)
+      @config.params_with(:description).should include(:also_has_description)
+      @config.params_with(:description).should_not include(:no_description)
     end
   end
 
-  describe 'defining descriptions' do
-    before do
-      @config.define :param_1, :description => 'desc 1'
-      @config.define :param_2, :description => 'desc 2'
+  describe 'definition_of' do
+    it 'with a param, gives me the description hash' do
+      @config.define :has_description,      :description => 'desc 1'
+      @config.definition_of(:has_description).should == { :description => 'desc 1' }
     end
-    it 'shows description for a param' do
-      @config.description_for(:param_1).should == 'desc 1'
+    it 'with a param and attr, gives me the description hash' do
+      @config.define :has_description,      :description => 'desc 1'
+      @config.definition_of(:has_description, :description).should == 'desc 1'
+    end
+    it 'symbolizes the param' do
+      @config.define :has_description,      :description => 'desc 1'
+      @config.definition_of('has_description').should == { :description => 'desc 1' }
+      @config.definition_of('has_description', 'description').should be_nil
+    end
+  end
+
+  describe 'has_definition?' do
+    before do
+      @config.define :i_am_defined, :description => 'desc 1'
     end
-    it 'lists descriptions' do
-      @config.descriptions.should == { :param_1 => 'desc 1', :param_2 => 'desc 2'}
+    it 'is true if defined' do
+      @config.has_definition?(:i_am_defined).should == true
     end
-    it 'lists descriptions' do
-      @config.described_params.should include(:param_1)
-      @config.described_params.should include(:param_2)
+    it 'is false if not defined' do
+      @config.has_definition?(:i_am_not_defined).should == false
     end
   end
 
-  require 'date'; require 'time'
+  it 'takes a description' do
+    @config.define :has_description,      :description => 'desc 1'
+    @config.define :also_has_description, :description => 'desc 2'
+    @config.definition_of(:has_description, :description).should == 'desc 1'
+  end
+
   describe 'type coercion' do
     [
       [:boolean, '0', false],  [:boolean, 0, false], [:boolean, '',  false], [:boolean, [],     true], [:boolean, nil, nil],
@@ -52,26 +71,48 @@ describe "Configliere::Define" do
       [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],     [Date, 'blah', nil],
+      [Date,     '1985-11-05',          Date.parse('1985-11-05')],               [Date, nil, nil],     [Date, '', nil],     [Date, 'blah', nil],
       [DateTime, '1985-11-05 11:00:00', DateTime.parse('1985-11-05 11:00:00')],  [DateTime, nil, nil], [DateTime, '', nil], [DateTime, 'blah', nil],
       [Array,  ['this', 'that', 'thother'], ['this', 'that', 'thother']],
       [Array,  'this,that,thother',         ['this', 'that', 'thother']],
       [Array,  'alone',                     ['alone'] ],
       [Array,  '',                          []        ],
       [Array,  nil,                         nil       ],
+      ['other', '5', '5'],     ['other', 5,   5],    ['other', nil, nil],    ['other', '', 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
+        @config.define :has_type, :type => type
+        @config[:has_type] = orig ; @config.resolve! ; @config[:has_type].should == desired
       end
     end
-    it 'converts :now to the current moment' do
-      @config.define :param, :type => DateTime
-      @config[:param] = 'now' ; @config.resolve! ; @config[:param].should be_close(DateTime.now, 4)
-      @config[:param] = :now  ; @config.resolve! ; @config[:param].should be_close(DateTime.now, 4)
-      @config.define :param, :type => Date
-      @config[:param] = :now  ; @config.resolve! ; @config[:param].should be_close(Date.today, 4)
-      @config[:param] = 'now' ; @config.resolve! ; @config[:param].should be_close(Date.today, 4)
+    # it 'converts :now to the current moment' do
+    #   @config.define :has_type, :type => DateTime
+    #   @config[:has_type] = 'now' ; @config.resolve! ; @config[:has_type].should be_within(4).of(DateTime.now, 4)
+    #   @config[:has_type] = :now  ; @config.resolve! ; @config[:has_type].should be_within(4).of(DateTime.now, 4)
+    #   @config.define :has_type, :type => Date
+    #   @config[:has_type] = :now  ; @config.resolve! ; @config[:has_type].should be_within(4).of(Date.today, 4)
+    #   @config[:has_type] = 'now' ; @config.resolve! ; @config[:has_type].should be_within(4).of(Date.today, 4)
+    # end
+  end
+
+  describe 'creates magical methods' do
+    before do
+      @config.define :has_magic_method, :default => 'val1'
+      @config[:no_magic_method] = 'val2'
+    end
+    it 'answers to a getter if the param is defined' do
+      @config.has_magic_method.should == 'val1'
+    end
+    it 'answers to a setter if the param is defined' do
+      @config.has_magic_method = 'new_val1'
+      @config.has_magic_method.should == 'new_val1'
+      @config[:has_magic_method].should == 'new_val1'
+    end
+    it 'does not answer to a getter if the param is not defined' do
+      lambda{ @config.no_magic_method }.should raise_error(NoMethodError)
+    end
+    it 'does not answer to a setter if the param is not defined' do
+      lambda{ @config.no_magic_method = 3 }.should raise_error(NoMethodError)
     end
   end
 
@@ -83,12 +124,12 @@ describe "Configliere::Define" do
       @config.define :optional_2
     end
     it 'lists required params' do
-      @config.required_params.should include(:param_1)
-      @config.required_params.should include(:param_2)
+      @config.params_with(:required).should include(:param_1)
+      @config.params_with(:required).should include(:param_2)
     end
-    it 'counts false values as required' do
+    it 'counts false values as present' do
       @config.defaults :param_1 => true, :param_2 => false
-      @config.validate!.should == true
+      @config.validate!.should equal(@config)
     end
     it 'counts nil-but-set values as missing' do
       @config.defaults :param_1 => true, :param_2 => nil
@@ -98,10 +139,48 @@ describe "Configliere::Define" do
       lambda{ @config.validate! }.should raise_error(RuntimeError)
     end
     it 'lists all missing values when it raises' do
-      Configliere.use :define
-      lambda{ @config.validate! }.should raise_error(RuntimeError)
+      lambda{ @config.validate! }.should raise_error(RuntimeError, "Missing values for: param_1, param_2")
     end
   end
-end
 
+  describe 'defining deep keys' do
+    it 'allows required params' do
+      @config.define 'delorean.power_supply', :required => true
+      @config[:'delorean.power_supply'] = 'household waste'
+      @config.params_with(:required).should include(:'delorean.power_supply')
+      @config.should == { :normal_param=>"normal", :delorean => { :power_supply => 'household waste' } }
+      lambda{ @config.validate! }.should_not raise_error
+    end
+
+    it 'allows flags' do
+      @config.define 'delorean.power_supply', :flag => 'p'
+      @config.use :commandline
+      ARGV.replace ['-p', 'household waste']
+      @config.params_with(:flag).should include(:'delorean.power_supply')
+      @config.resolve!
+      @config.should == { :normal_param=>"normal", :delorean => { :power_supply => 'household waste' } }
+      ARGV.replace []
+    end
+
+    it 'type converts' do
+      @config.define 'delorean.power_supply', :type => Array
+      @config.use :commandline
+      ARGV.replace ['--delorean.power_supply=household waste,plutonium,lightning']
+      @config.definition_of('delorean.power_supply', :type).should == Array
+      @config.resolve!
+      @config.should == { :normal_param=>"normal", :delorean => { :power_supply => ['household waste', 'plutonium', 'lightning'] } }
+      ARGV.replace []
+    end
+  end
+
+  describe '#resolve!' do
+    it 'calls super and returns self' do
+      Configliere::ParamParent.class_eval do def resolve!() dummy ; end ; end
+      @config.should_receive(:dummy)
+      @config.resolve!.should equal(@config)
+      Configliere::ParamParent.class_eval do def resolve!() self ; end ; end
+    end
+  end
+
+end
 

data/spec/configliere/encrypted_spec.rb

@@ -1,60 +1,76 @@
 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.use :encrypted
     @config.define :secret, :encrypted => true
-    @config.encrypt_pass = 'pass'
+    @config[:encrypt_pass] = 'pass'
   end
 
-  describe 'defining encrypted params' do
-    it 'is encrypted if defined with :encrypted => true' do
+  describe 'defines encrypted params' do
+    it 'with :encrypted => true' do
       @config.send(:encrypted_params).should include(:secret)
     end
-    it 'is not encrypted if defined with :encrypted => false' do
+    it 'but not if :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
+    it 'only if :encrypted is given' 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'}
+  describe 'the encrypt_pass' do
+    it 'will take an environment variable if any exists' do
+      @config[:encrypt_pass] = nil
+      ENV.should_receive(:[]).with('ENCRYPT_PASS').at_least(:once).and_return('monkey')
+      @config.send(:export)
+      @config.send(:instance_variable_get, "@encrypt_pass").should == 'monkey'
     end
-    it 'gets encrypted params successfully' do
+    it 'will take an internal value if given, and remove it' do
+      @config[:encrypt_pass] = 'hello'
+      @config.send(:export)
+      @config.send(:instance_variable_get, "@encrypt_pass").should == 'hello'
+      @config[:encrypt_pass].should be_nil
+      @config.has_key?(:encrypt_pass).should_not be_true
+    end
+  end
+
+  describe 'encrypts' do
+    it 'all params with :encrypted' do
       Configliere::Crypter.should_receive(:encrypt).with('encrypt_me', 'pass').and_return('ok_encrypted')
-      @config.send(:encrypted, @config[:secret]).should == 'ok_encrypted'
+      @config.send(:export).should == { :normal_param => 'normal', :encrypted_secret => 'ok_encrypted'}
     end
-    it 'fails if no pass is set' do
+
+    it 'fails unless encrypt_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!')
+      @config.use :encrypted
+      lambda{ @config.send(:encrypted, @config[:secret]) }.should raise_error('Missing encryption password!')
     end
   end
 
-  describe 'decrypting encryptable params' do
-    it 'decrypts all params marked encrypted' do
+  describe 'decrypts' do
+    it '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'}
+      @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"
+      @encrypted_str = "KohCTcXr1aAulopntmZ8f5Gqa7PzsBmz+R2vFGYrAeg=\n"
     end
     it 'encrypts' do
       Configliere::Crypter.should_receive(:encrypt).and_return(@encrypted_str)
-      Configliere::ConfigFile.should_receive(:write_yaml_file).with('/fake/file', :normal_param=>"normal", :encrypted_secret => @encrypted_str)
+      FileUtils.stub(:mkdir_p)
+      File.should_receive(:open).and_yield([])
+      YAML.should_receive(:dump).with({ :normal_param => "normal", :encrypted_secret => @encrypted_str })
       @config.save! '/fake/file'
     end
     it 'decrypts' do
@@ -63,9 +79,26 @@ describe "Configliere::Encrypted" do
       YAML.should_receive(:load).and_return(@hsh)
       @config.read 'file.yaml'
       @config.resolve!
+      @config.should_not include(:encrypted_secret)
       @config.should == { :loaded_param => "loaded", :secret => 'decrypt_me', :normal_param => 'normal' }
     end
   end
-end
 
+  describe '#resolve!' do
+    it 'calls super and returns self' do
+      Configliere::ParamParent.class_eval do def resolve!() dummy ; end ; end
+      @config.should_receive(:dummy)
+      @config.resolve!.should equal(@config)
+      Configliere::ParamParent.class_eval do def resolve!() self ; end ; end
+    end
 
+    it 'removes the encrypt_pass from sight' do
+      @config[:encrypt_pass] = 'hello'
+      @config.resolve!
+      @config.send(:instance_variable_get, "@encrypt_pass").should == 'hello'
+      @config[:encrypt_pass].should be_nil
+      @config.has_key?(:encrypt_pass).should_not be_true
+    end
+  end
+
+end

data/spec/configliere/env_var_spec.rb

@@ -1,24 +1,44 @@
 require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
-Configliere.use :env_var
 
 describe "Configliere::EnvVar" do
   before do
     @config = Configliere::Param.new
+    @config.use :env_var
   end
 
-  describe 'loads environment variables' do
-    it 'loads a simple value into the corresponding symbolic key' do
+  describe 'environment variables can be defined' do
+    it 'with #env_vars, a simple value like "HOME" uses the corresponding key :home' do
       ENV.should_receive(:[]).with('HOME').and_return('/fake/path')
       @config.env_vars 'HOME'
       @config[:home].should == '/fake/path'
     end
-    it 'loads a hash into the individual params' do
+
+    it 'with #env_vars, a hash pairs environment variables 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.env_vars :home => 'HOME', 'delorean.power_supply' => 'POWER_SUPPLY'
       @config[:home].should == '/fake/path'
       @config[:delorean][:power_supply].should == '1.21 jigawatts'
     end
+
+    it 'with #define' do
+      ENV.should_receive(:[]).with('HOME').and_return('/fake/path')
+      ENV.should_receive(:[]).with('POWER_SUPPLY').and_return('1.21 jigawatts')
+      @config.define :home, :env_var => 'HOME'
+      @config.define 'delorean.power_supply', :env_var => 'POWER_SUPPLY'
+      @config[:home].should == '/fake/path'
+      @config[:delorean][:power_supply].should == '1.21 jigawatts'
+    end
   end
+
+  describe '#resolve!' do
+    it 'calls super and returns self' do
+      Configliere::ParamParent.class_eval do def resolve!() dummy ; end ; end
+      @config.should_receive(:dummy)
+      @config.resolve!.should equal(@config)
+      Configliere::ParamParent.class_eval do def resolve!() self ; end ; end
+    end
+  end
+
 end
 

data/spec/configliere/param_spec.rb

@@ -5,45 +5,43 @@ describe "Configliere::Param" do
     @config = Configliere::Param.new :hat => :cat, :basket => :lotion, :moon => { :man => :smiling }
   end
 
-  describe '#defaults' do
+  describe 'calling #defaults' do
     it 'deep_merges new params' do
       @config.defaults :basket => :tasket, :moon => { :cow => :jumping }
       @config.should == { :hat => :cat, :basket => :tasket, :moon => { :man => :smiling, :cow => :jumping } }
     end
+    it 'returns self, to allow chaining' do
+      obj = @config.defaults(:basket => :ball)
+      obj.should equal(@config)
+    end
   end
 
-  describe '#[]=' do
-    it 'symbolizes keys' do
-      @config['hat'] = :fedora
-      @config['new'] = :unseen
-#      @config.should == { :hat => :fedora, :basket => :lotion, :new => :unseen, :moon => { :man => :smiling } }
+  describe 'adding plugins with #use' do
+    before do
+      Configliere.should_receive(:use).with(:foobar)
     end
-    it 'deep-sets dotted vals, replacing values' do
-      @config['moon.man'] = :cheesy
-      @config[:moon][:man].should == :cheesy
+    it 'requires the corresponding library' do
+      obj = @config.use(:foobar)
     end
-    it 'deep-sets dotted vals, creating new values' do
-      @config['moon.cheese.type'] = :tilsit
-      @config[:moon][:cheese][:type].should == :tilsit
+    it 'returns self, to allow chaining' do
+      obj = @config.use(:foobar)
+      obj.should equal(@config)
     end
-    it 'deep-sets dotted vals, auto-vivifying intermediate hashes' do
-      @config['this.that.the_other'] = :fuhgeddaboudit
-      @config[:this][:that][:the_other].should == :fuhgeddaboudit
+    it 'invokes the on_use handler' do
+      Configliere::Param.on_use(:foobar) do
+        method_on_config(:param)
+      end
+      @config.should_receive(:method_on_config).with(:param)
+      @config.use(:foobar)
     end
   end
 
-  describe '#[]' do
-    it 'deep-gets dotted vals' do
-      hsh = { :hat => :cat, :basket => :lotion, :moon => { :man => :smiling, :cheese => {:type => :tilsit} } }
-      @config = Configliere::Param.new hsh.dup
-      @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
-      if (RUBY_VERSION >= '1.9') then lambda{ @config['hat.cat'] }.should raise_error(TypeError)
-      else                            lambda{ @config['hat.cat'] }.should raise_error(NoMethodError, 'undefined method `[]\' for :cat:Symbol') end
-      @config.should == hsh # shouldn't change from reading (specifically, shouldn't autovivify)
+  describe '#resolve!' do
+    it 'calls super and returns self' do
+      Configliere::ParamParent.class_eval do def resolve!() dummy ; end ; end
+      @config.should_receive(:dummy)
+      @config.resolve!.should equal(@config)
+      Configliere::ParamParent.class_eval do def resolve!() self ; end ; end
     end
   end