use-config 0.1.1 → 0.2.0

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2008 Slava Chernobai <chernobai@gmail.com>
+Copyright (c) 2008, 2011 Svetoslav Chernobay <slava@chernobay.info>
 
 This is free software. You may redistribute copies of it under the terms
 of the GNU General Public License.

data/README.md

@@ -0,0 +1,77 @@
+# UseConfig
+
+Easy configuration solution for any Ruby class.
+
+[UseConfig](https://github.com/slavach/use-config) allows a Ruby class to use
+configuration stored in a YAML file.
+
+Configuration is loaded by a single line of code, like:
+
+    use_config :conf
+
+Once been loaded, configuration values are accessible by calling to the
+corresponding methods:
+
+    conf.project.name
+
+## Installation
+
+UseConfig is available as the gem use-config.
+
+    gem ins use-config
+
+## Usage Example
+
+First, create the configuration file conf.yaml, containing a hash
+representation:
+
+    project:
+      name: use-config-demo
+      title: UseConfig Demo Project
+
+    messages:
+      welcome: Welcome to the UseConfig Demo
+      lorem: Lorem ipsum dolor sit amet, consectetur adipisicing elit
+
+Next, create a ruby program that uses the above configuration:
+
+    require 'use_config'
+    include UseConfig
+
+    class UseConfigDemo
+      use_config :conf # Creates a hash accessible by the 'conf' method
+
+      def show_project
+        print 'Name: ', conf.project.name, "\n"
+        print 'Title: ', conf.project.title, "\n"
+      end
+    end
+
+    demo = UseConfigDemo.new
+
+    demo.show_project
+
+    print demo.conf.messages.welcome, "\n"
+    print demo.conf.messages.lorem, "\n"
+
+## Development
+
+Clone the latest code from Github:
+
+    git clone git://github.com/slavach/use-config.git
+
+Install bundler:
+
+    gem install bundler
+
+Install required gems:
+
+    bundle install
+
+To invoke tests - run `rake spec` or simply `rake`.
+
+## Author
+
+UseConfig has been written by Svetoslav Chernobay <slava@chernobay.info>.
+Feel free to contact him if you have any questions or comments.
+

data/Rakefile

@@ -1,67 +1,37 @@
 require 'rubygems'
 
 require 'rake/clean'
-require 'rake/testtask'
 require 'rake/rdoctask'
-require 'rake/gempackagetask'
 
-$:.insert(0, File.dirname(__FILE__) + '/lib')
+require 'yard'
+require 'rspec'
+require 'rspec/core/rake_task'
 
-require 'use_config'
+require File.dirname(__FILE__) + "/lib/use_config/version.rb"
 
-spec = Gem::Specification.new do |s|
-  s.name = 'use-config'
-  s.version = UseConfig::VERSION
-  s.platform = Gem::Platform::RUBY
-  s.has_rdoc = true
-  s.extra_rdoc_files = %w[ README LICENSE ]
-  s.rdoc_options = %w[ --main=README --line-numbers --inline-source ]
-  s.summary = 'UseConfig. Allows Ruby classes to use configuration, stored in YAML files.'
-  s.description = s.summary
-  s.author = 'Slava Chernobai'
-  s.email = 'chernobai@gmail.com'
-  s.homepage = 'http://code.slava.pp.ru/use-config/'
-  s.files = %w[ README LICENSE Rakefile ] + Dir.glob("{config,lib,test}/*") + Dir.glob('lib/*/*')
-  s.require_path = 'lib'
-  s.add_dependency 'hash-access', '>= 0.1.0'
-end
-
-task :default => [ :test ]
+task :default => [ :spec ]
 
-CLEAN.include(%w[ pkg doc README ])
-
-desc 'Generate README'
-file 'README' do
-  %x[erb -T 1 README.erb > README] if File.exists?('README.erb')
-end
+CLEAN.include(%w[ pkg doc .yardoc use-config-*.gem ])
 
-desc 'Generate RDoc'
-task :rdoc => [ :README ]
-Rake::RDocTask.new do |rd|
-  rd.main = 'README'
-  rd.title = 'UseConfig'
-  rd.rdoc_dir = 'doc'
-  rd.template = 'jamis'
-  rd.options = %w[ --line-numbers --inline-source ]
-  rd.rdoc_files.include('README', 'LICENSE', 'lib/*.rb', 'lib/*/*.rb')
+desc 'Run RSpec examples'
+RSpec::Core::RakeTask.new :spec do |t|
+  t.rspec_opts = "--colour --format documentation"
+  t.pattern = 'spec/*.rb'
 end
 
-desc 'Upload RDoc to site'
-task :rdoc_pub => [:rdoc] do
-  sh 'rsync -ae ssh --delete doc/ slava@slava.cn:/var/www/code/htdocs/use-config/doc/'
+desc "Build the gem"
+task :build do
+  system "gem build use-config.gemspec"
 end
 
-task :test => [ :README ]
-Rake::TestTask.new do |t|
-  t.libs << 'test' << 'lib'
-  t.test_files = FileList[ 'test/test*.rb' ].sort
-  t.verbose = true
+desc "Push the gem to rubygems.org"
+task :push do
+  system "gem push use-config-#{UseConfig::VERSION}.gem"
 end
 
-task :gem => [ :README ]
-Rake::GemPackageTask.new(spec) do |p|
-  p.gem_spec = spec
-  p.need_tar = true
-  p.need_zip = true
+desc "Generate documentation"
+YARD::Rake::YardocTask.new :doc do |t|
+  t.files = %w[ README.md, LICENSE, lib/**/*.rb ]
+  t.options = %w[ --title UseConfig ]
 end
 

data/lib/use_config.rb

@@ -1,21 +1,22 @@
-require 'rubygems'
+require 'use_config/version'
 require 'use_config/configuration'
 
-# Extends calling class with UseConfig::ClassMethods when included
+# Extends the calling class with UseConfig::ClassMethods
 module UseConfig
-  VERSION = '0.1.1'
-
   def self.included(base) # :nodoc:
     base.extend ClassMethods
   end
 
-  # Extends Object class with UseConfig::ClassMethods when included
+  # Extends the Object class with UseConfig::ClassMethods
+  # When UseConfig::ObjectExtend included, all the UseConfig::ClassMethods
+  # methods been added to Object and all its derivatives.
   module ObjectExtend
     def self.included(base) # :nodoc:
       Object.extend ClassMethods
     end
   end
 
+  # This module contains class methods use_config and drop_config.
   module ClassMethods
     # Adds configuration hash readed from config/name.yaml file
     # to configuration class, and generates configuration access methods.
@@ -29,11 +30,13 @@ module UseConfig
         end
       end
 
+      # Generates class accessor.
       metaclass.instance_eval do
         attr_accessor name
       end
       self.send "#{name}=".to_sym, UseConfig::Configuration.add_conf(self, name, options, &block)
 
+      # Generates instance accessor.
       class_eval <<-EVAL
         def #{name}
           self.class.#{name}
@@ -56,6 +59,5 @@ module UseConfig
       end
     end
   end
-
 end
 

data/lib/use_config/configuration.rb

@@ -1,49 +1,110 @@
 require 'rubygems'
-require 'hash_access'
 require 'yaml'
 require 'thread'
 
-module UseConfig
-  include HashAccess
+require 'hash_access'
 
+module UseConfig
+  # UseConfig::Configuration class plays two roles.
+  #
+  # An instance of the class is a hash, a configuration placeholder.
+  # It contents could be loaded from a YAML file or could be populated
+  # manually. Configuration values can be accessed using the hash notation
+  # +object['key']+ as well as using the method notation +object.key+.
+  #
+  # The class itself is a container. It containas above-mentioned configuration
+  # objects that are stored in the +conf+ hash attribute which is accessible
+  # by the +conf+ method.
+  #
+  # A particular instance should be created with the +add_conf+ method.
+  # It is not intended to use an instance as a standalone object.
+  #
+  # Usage example:
+  #
+  #     UseConfig::Configuration.add_conf self, :qwerty, :empty => true
+  #     UseConfig::Configuration.conf.qwerty.param_1 = 'Value 1'
+  #     print UseConfig::Configuration.conf.qwerty.to_s, "\n"
+  #
+  # This class is designed as the UseConfig supplemental class. It is not very
+  # useful by its own.
   class Configuration < Hash
+    include HashAccess
+
     class << self
-      attr_accessor :accessors
-      attr_accessor :default_config_path
+      attr_accessor :path
       attr_accessor :extentions
+      attr_accessor :reload_when_add
+      attr_accessor :default_instance_properties
       attr_accessor :conf
-      attr_accessor :settings
       attr_accessor :mutex
     end
 
-    self.mutex = Mutex.new
+    self.path = %w[. config]
+    self.extentions = %w[yml yaml]
+    self.reload_when_add = false
+
+    self.default_instance_properties = {
+      :name => nil,
+      :file => nil,
+      :use_file => true,
+      :path => self.path,
+      :extentions => self.extentions,
+      :used_by => [],
+    }
 
     self.conf = {}
-    self.settings = {}
 
-    self.accessors = [ :name, :config_path, :config_file, :use_config_file, :extentions, :used_by ]
-    self.default_config_path = [ '.', 'config' ]
-    self.extentions = [ 'yml', 'yaml' ]
+    self.mutex = Mutex.new
 
-    self.accessors.each do |a|
-      attr_accessor a
+    # Passes self to calling block.
+    #
+    # Example:
+    #
+    #   UseConfig::Configuration.configure do |c|
+    #     c.path << APP_ROOT + 'config'
+    #   end
+    #
+    def self.configure
+      yield self if block_given?
     end
 
+    # Creates a new config (an instance of +self+) (calls +self.new+)
+    # and inserts the result object it into +self.conf+ hash as
+    # +self.conf[name]+ element. If the config already exists and the
+    # +:reload_when_add+ class setting is set - reloads config contents.
+    #
+    # Returns the created config object.
+    #
+    # Parameters
+    #
+    # * +used_by+ - The class that uses the config. After the config created
+    #   created, this class is assotiated with it. This prevents the config to
+    #   be deleted if any class uses it.
+    # * +name+ - Config name. It is used as the +conf+ hash key as well as the
+    #   attribute of the config itself.
+    # * +options+ - The options hash to be passed to +new+.
+    #
+    # Options
+    #
+    # * +:empty+ - Create an empty config. Don't load config from file.
+    # * +:file+ - Use the mentioned file instead of the default.
+    #   files' search path.
     def self.add_conf(used_by, name, options = {}, &block)
       sname = name.to_s
       self.mutex.synchronize do
         if self.conf[sname]
-          self.conf[sname].reload! if self.settings[:reload_when_add]
+          self.conf[sname].reload! if self.reload_when_add
           self.conf[sname].used_by_add(used_by)
           yield self.conf[sname] if block_given?
         else
-          self.conf[sname] = UseConfig::Configuration.new(sname, options, &block)
+          self.conf[sname] = self.new(sname, options, &block)
           self.conf[sname].used_by_add(used_by)
         end
         self.conf[sname]
       end # self.mutex.synchronize do
     end
 
+    # Deletes the config if it is not in use.
     def self.drop_conf(used_by, name)
       sname = name.to_s
       self.mutex.synchronize do
@@ -56,96 +117,137 @@ module UseConfig
       end # self.mutex.synchronize do
     end
 
-    # Instance methods
+    # Deletes all configs.
+    def self.reset!
+      self.mutex.synchronize do
+        self.conf = {}
+      end
+    end
+
+    # Instance behavior
 
+    attr_accessor :instance_properties
+
+    # What's this?
     def configuration?
       true
     end
 
-    def initialize(name, options = {}, &block)
-      self.name = name.to_s
-      self.config_path = self.class.default_config_path.clone
-      self.config_file = nil
-      self.use_config_file = true
-      self.extentions = self.class.extentions
-      self.used_by = []
-      if options[:file]
-        self.config_file = options[:file]
-      end
-      if options[:path_insert]
-        if options[:path_insert].is_a? Array
-          options[:path_insert].reverse.each do |dir|
-            self.config_path.unshift(dir)
-          end
+    # Passes self to a calling block.
+    def configure(&block)
+      yield self if block_given?
+    end
+
+    # Initializes a new instance. Load configuration from file if given.
+    #
+    # Parameters:
+    #
+    # * +name+ - The object's name.
+    # * +options+ - Options' hash.
+    #
+    # Options:
+    #
+    # * +:empty: - Create empty object, don't read configuration from file.
+    # * No other options yet.
+    #
+    # Notes:
+    #
+    # Doesn't add any +use_by+ properties, even being passed in +options+.
+    # +use_by+ should be added later, by the caller, using +add_use_by+
+    # method.
+    def initialize(name, options, &block)
+      self.instance_properties = {}.access_by_methods
+      self.class.default_instance_properties.keys.each do |key|
+        if options[key].nil?
+          instance_properties[key] = self.class.default_instance_properties[key]
         else
-          self.config_path.unshift(options[:path_insert])
+          instance_properties[key] = options[key]
         end
       end
+      instance_properties.name = name.to_s
+      instance_properties.used_by = []
       if options[:empty]
-        self.use_config_file = false
+        instance_properties.use_file = false
       end
-      if use_config_file and config_file.nil?
+      if instance_properties.use_file and instance_properties.file.nil?
         config_file_find
-        if config_file.nil?
+        if instance_properties.file.nil?
           raise "Configuration file not found"
         end
         load_configuration
       end
-      access_by_methods
+      self.access_by_methods
       yield self if block_given?
       self
-    end # def initialize(name, options = {}, &block)
+    end # def initialize
+
+    private
 
+    # Sets +name+ property.
+    def set_name(name)
+      if name
+        self.instance_properties.name = name.to_s
+      end
+    end
+
+    # Adds the class to usage list.
     def used_by_add(used_by)
-      self.used_by.push(used_by) unless self.used_by.include?(used_by)
-      self
+      unless self.instance_properties.used_by.include?(used_by)
+        self.instance_properties.used_by.push(used_by)
+      end
     end
 
+    # Removes the class from usage list.
     def used_by_drop(used_by)
-      if self.used_by.include?(used_by)
-        self.used_by.delete(used_by)
+      if self.instance_properties.used_by.include?(used_by)
+        self.instance_properties.used_by.delete(used_by)
       end
-      self
     end
 
+    # Returns +used_by+ property
+    def used_by
+      self.instance_properties.used_by
+    end
+
+    # Serches for configuration file.
     def config_file_find
-      self.config_path.each do |dir|
-        self.extentions.each do |ext|
-          file = "#{dir}/#{name}.#{ext}"
+      instance_properties.path.each do |dir|
+        instance_properties.extentions.each do |ext|
+          file = "#{dir}/#{self.instance_properties.name}.#{ext}"
           if File.exist?(file)
-            self.config_file = file
-            return self
+            self.instance_properties.use_file = true
+            self.instance_properties.file = file
           end
         end
       end
-      self
     end # def config_file_find
 
+    # Loads configuration from the +config_file+.
+    # TODO: rename this function to +load+
     def load_configuration
-      cfg = YAML.load_file(config_file)
-      cfg.each do |key, value|
-        next if self.class.accessors.include?(key.to_sym)
-        self[key] = value
+      begin
+        cfg = YAML.load_file(instance_properties.file)
+        cfg.each do |key, value|
+          self[key] = value
+        end
+        true
+      rescue
+        false
       end
-      self
     end
 
+    # Removes all the keys from itself.
     def clear!
-      each_key do |key|
-        next if self.class.accessors.include?(key.to_sym)
-        delete(key)
-      end
-      yield self if block_given?
-      self
+      self.clear
     end
 
+    # Reloads configuration from file.
     def reload!
-      clear!
-      load_configuration if use_config_file
-      yield self if block_given?
-      self
+      self.clear!
+      if (instance_properties.file && instance_properties.use_file)
+        load_configuration
+      end
     end
-
   end # class Configuration
 end # module UseConfig
 

data/lib/use_config/version.rb

@@ -0,0 +1,4 @@
+module UseConfig
+  VERSION = '0.2.0'
+end
+

data/spec/use_config_configuration_spec.rb

@@ -0,0 +1,294 @@
+# vim foldmethod=syntax
+
+require 'rubygems'
+require 'rspec'
+
+require File.dirname(__FILE__) + "/../lib/use_config/configuration.rb"
+
+describe UseConfig::Configuration, "instance public interface" do
+  before :each do
+    UseConfig::Configuration.reset!
+    UseConfig::Configuration.configure do |c|
+      c.path << "#{File.dirname(__FILE__)}/config"
+    end
+  end
+
+  describe "#initialize" do
+    describe "correct usage" do
+      context "when option :empty given" do
+        before :each do
+          @conf = UseConfig::Configuration.new :empty_conf,
+            :empty => true
+        end
+
+        it "is empty after creation" do
+          @conf.should == {}
+        end
+
+        it "assigns values by methods" do
+          @conf.core.name = 'conf'
+          @conf.core.name.should == 'conf'
+        end
+
+        it "has instance_properties" do
+          @conf.instance_properties.should_not == nil
+        end
+
+        it "has instance_properties.name" do
+          @conf.instance_properties.name.should == 'empty_conf'
+        end
+      end
+
+      context "when option :file given" do
+        it "loads configuration from file" do
+          c = UseConfig::Configuration.new :the_first_conf,
+            :file => 'first_conf.yaml'
+          c.core.name.should = 'first_conf'
+        end
+      end
+    end
+
+    describe "incorrect usage" do
+      context "when config file missing" do
+        it "raises an error" do
+          expect {
+            UseConfig::Configuration.new :none_conf
+          }.to raise_error
+        end
+      end
+    end
+  end
+end
+
+describe UseConfig::Configuration, "private instance methods" do
+  before :each do
+    module ::UseConfig
+      class Configuration
+        public :set_name, :used_by_add, :used_by_drop, :used_by,
+          :config_file_find, :load_configuration,
+          :clear!, :reload!
+      end
+    end
+
+    @conf = UseConfig::Configuration.new :empty_conf,
+      :empty => true
+  end
+
+  describe "#set_name" do
+    it "changes name property" do
+      @conf.set_name :empty_conf_changed
+      @conf.instance_properties.name.should == 'empty_conf_changed'
+    end
+
+    it "doesn't change name when no parameter given" do
+      expect {
+        @conf.set_name
+      }.should raise_error
+    end
+  end
+
+  describe "#used_by_add" do
+    it "adds the element" do
+      @conf.used_by_add :class_one
+      @conf.used_by.include?(:class_one).should == true
+      @conf.used_by.count.should == 1
+    end
+
+    it "doesn't add the same element twice" do
+      @conf.used_by_add :class_two
+      @conf.used_by_add :class_two
+      @conf.used_by.count.should == 1
+    end
+
+    it "adds two different elements" do
+      @conf.used_by_add :class_three
+      @conf.used_by_add :class_four
+      @conf.used_by.count.should == 2
+    end
+  end
+
+  describe "#used_by_drop" do
+    it "removes the element" do
+      @conf.used_by_add :class_five
+      @conf.used_by_drop :class_five
+      @conf.used_by.count.should == 0
+    end
+
+    it "doesn't remove anything if the key is unknown" do
+      @conf.used_by_add :class_six
+      @conf.used_by_drop :non_existing_class
+      @conf.used_by.count.should == 1
+    end
+  end
+
+  describe "#used_by" do
+    it "returns used_by array" do
+      @conf.used_by_add :class_seven
+      @conf.used_by.should == [ :class_seven ]
+    end
+  end
+
+  describe "#config_file_find" do
+    it "finds the existing file" do
+      @conf.set_name :first_conf
+      @conf.config_file_find
+      @conf.instance_properties.file.should_not == nil
+    end
+
+    it "doesn't find any non-existent file" do
+      @conf.set_name :first_conf_missing
+      @conf.config_file_find
+      @conf.instance_properties.file.should == nil
+    end
+  end
+
+  describe "#load_configuration" do
+    it "loads configuration from the existing file" do
+      @conf.set_name :first_conf
+      @conf.config_file_find
+      @conf.load_configuration
+      @conf.core.name.should == 'first_conf'
+    end
+
+    it "doesn't load configuration if the file is missing" do
+      @conf.name = :first_conf
+      @conf.config_file = 'missing_file'
+      @conf.load_configuration.should == false
+    end
+  end
+
+  describe "#clear!" do
+    it "clears itself" do
+      @conf.qwerty = 'qwerty'
+      @conf.asdfgh = 'asdfgh'
+      @conf.clear!
+      @conf.keys.should == []
+    end
+  end
+
+  describe "#reload!" do
+    context "when uses config file" do
+      it "clears itself and loads configuration" do
+        @conf.set_name :first_conf
+        @conf.config_file_find
+        @conf.load_configuration
+        @conf.core.name = 'changed'
+        @conf.reload!
+        @conf.core.name.should == 'first_conf'
+      end
+    end
+
+    context "when doesn't use config file" do
+      it "clears itself" do
+        @conf.core.name = 'changed'
+        @conf.reload!
+        @conf.keys.should == []
+      end
+    end
+  end
+end
+
+describe UseConfig::Configuration, "class" do
+  before :each do
+    UseConfig::Configuration.reset!
+    UseConfig::Configuration.configure do |c|
+      c.path << "#{File.dirname(__FILE__)}/config"
+    end
+  end
+
+  describe "general class behaivior" do
+  end
+
+  describe ".add_conf" do
+    context "config file is not used" do
+      before :each do
+        UseConfig::Configuration.add_conf :some_class, :cfg,
+          :empty => true
+      end
+
+      it "creates a new empty config hash" do
+        UseConfig::Configuration.conf['cfg'].should == {}
+      end
+
+      it "hash values are accessible by methods" do
+        UseConfig::Configuration.conf['cfg'].a_key = 'a_value'
+        UseConfig::Configuration.conf['cfg'].a_key.should == 'a_value'
+      end
+
+      it "child hash values are accessinle by methods" do
+        UseConfig::Configuration.conf['cfg'].one.two.three = 'a_value'
+        UseConfig::Configuration.conf['cfg'].one.two.three == 'a_value'
+      end
+
+      it "keeps configuration when called the next time" do
+        UseConfig::Configuration.conf['cfg'].a_key = 'a_value'
+        UseConfig::Configuration.add_conf :another_class, :cfg,
+          :empty => true
+        UseConfig::Configuration.conf['cfg'].a_key.should == 'a_value'
+      end
+    end
+
+    context "config file present" do
+      before :each do
+        UseConfig::Configuration.add_conf :some_class, :first_conf
+        UseConfig::Configuration.add_conf :another_class, :second_conf
+      end
+
+      it "loads first configuration" do
+        UseConfig::Configuration.conf['first_conf'].should_not == nil
+      end
+
+      it "loads second configuration" do
+        UseConfig::Configuration.conf['second_conf'].should_not == nil
+      end
+
+      it "first configuration is correct" do
+        UseConfig::Configuration.conf['first_conf'].core.name.should == 'first_conf'
+      end
+
+      it "second configuration is correct" do
+        UseConfig::Configuration.conf['second_conf'].name.should == 'second_conf'
+      end
+    end
+
+    context "config file missing" do
+      it "raises error" do
+        expect {
+          UseConfig::Configuration.add_conf :some_class, :missing_conf
+        }.to raise_error
+      end
+    end
+  end
+
+  describe ".drop_conf" do
+    before :each do
+      UseConfig::Configuration.add_conf :some_class, :cfg,
+        :empty => true
+    end
+
+    context "configuration is used by a single class" do
+      it "destroys configuration" do
+        UseConfig::Configuration.drop_conf :some_class, :cfg
+        UseConfig::Configuration.conf['cfg'].should == nil
+      end
+    end
+
+    context "configuration is used by two classes" do
+      it "keeps configuration when called once" do
+        UseConfig::Configuration.add_conf :another_class, :cfg,
+          :empty => true
+        UseConfig::Configuration.drop_conf :some_class, :cfg
+        UseConfig::Configuration.conf['cfg'].should_not == nil
+      end
+
+      it "destroys configuration when called a second time" do
+        UseConfig::Configuration.add_conf :another_class, :cfg,
+          :empty => true
+        UseConfig::Configuration.drop_conf :some_class, :cfg
+        UseConfig::Configuration.drop_conf :another_class, :cfg
+        UseConfig::Configuration.conf['cfg'].should == nil
+      end
+    end
+  end
+end
+

data/spec/use_config_spec.rb

@@ -0,0 +1,51 @@
+require 'rubygems'
+require 'rspec'
+
+require File.dirname(__FILE__) + "/../lib/use_config.rb"
+
+class Sample; include UseConfig; end
+
+describe UseConfig do
+  before :each do
+    UseConfig::Configuration.reset!
+    UseConfig::Configuration.configure do |c|
+      c.path << "#{File.dirname(__FILE__)}/config"
+    end
+  end
+
+  context "Sample class includes UseConfig" do
+    it "has method use_config" do
+      Sample.respond_to?(:use_config).should == true
+    end
+
+    it "has method drop_config" do
+      Sample.respond_to?(:drop_config).should == true
+    end
+
+    it "uses configuration" do
+      Sample.use_config :first_conf
+      Sample.respond_to?(:first_conf).should == true
+    end
+
+    it "loads configuration" do
+      Sample.use_config :first_conf
+      Sample.first_conf.core.name.should == 'first_conf'
+    end
+  end
+
+  context "Samle class instance" do
+    before :each do
+      Sample.use_config :first_conf
+      @sample = Sample.new
+    end
+
+    it "has configuration accessor" do
+      @sample.respond_to? :first_conf
+    end
+
+    it "has the actual configuration" do
+      @sample.first_conf.core.name.should == 'first_conf'
+    end
+  end
+end
+

metadata

@@ -1,48 +1,54 @@
 --- !ruby/object:Gem::Specification 
 name: use-config
 version: !ruby/object:Gem::Version 
-  version: 0.1.1
+  prerelease: 
+  version: 0.2.0
 platform: ruby
 authors: 
-- Slava Chernobai
+- Svetoslav Chernobay
 autorequire: 
 bindir: bin
 cert_chain: []
 
-date: 2008-01-18 00:00:00 +03:00
+date: 2011-03-08 00:00:00 +03:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: hash-access
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 0.1.0
-    version: 
-description: UseConfig. Allows Ruby classes to use configuration, stored in YAML files.
-email: chernobai@gmail.com
+        version: "0.2"
+    - - <=
+      - !ruby/object:Gem::Version 
+        version: "0.3"
+  type: :runtime
+  version_requirements: *id001
+description: UseConfig library allows a Ruby class to use configuration stored in a YAML file
+email: slava@chernobay.info
 executables: []
 
 extensions: []
 
 extra_rdoc_files: 
-- README
+- README.md
 - LICENSE
 files: 
-- README
+- README.md
 - LICENSE
 - Rakefile
-- config/asd.yml
-- config/qwe.yml
 - lib/use_config.rb
-- lib/use_config
-- test/test_020_use_config.rb
-- test/test_010_configuration.rb
 - lib/use_config/configuration.rb
+- lib/use_config/version.rb
+- spec/use_config_spec.rb
+- spec/use_config_configuration_spec.rb
 has_rdoc: true
-homepage: http://code.slava.pp.ru/use-config/
+homepage: http://github.com/slavach/use-config
+licenses: []
+
 post_install_message: 
 rdoc_options: 
 - --main=README
@@ -51,23 +57,23 @@ rdoc_options:
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
       version: "0"
-  version: 
 required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      version: "0"
-  version: 
+      version: 1.3.6
 requirements: []
 
-rubyforge_project: 
-rubygems_version: 1.0.1
+rubyforge_project: use-config
+rubygems_version: 1.5.2
 signing_key: 
-specification_version: 2
-summary: UseConfig. Allows Ruby classes to use configuration, stored in YAML files.
+specification_version: 3
+summary: Easy configuration solution for any Ruby class
 test_files: []
 

data/README

@@ -1,34 +0,0 @@
-== UseConfig 0.1.1
-
-This library allows Ruby classes to use configuration stored in YAML file,
-or several configurations in several files.
-
-=== Installation
-
- gem ins use-config
-
-=== Usage
-
-Create configuration file 'qwe.yaml'.
-
- project:
-   name: my_project
-   title: Project using UseConfig
-
-Sample code:
-
- $:.unshift 'lib'
-
- require 'use_config'
- include UseConfig
-
- class UseConfigExample
-   use_config :qwe
- end
-
- print 'UseConfig Example', "\n"
-
- ex = UseConfigExample.new
- print ' ex.qwe.common.name: ', ex.qwe.common.name, "\n"
- print ' ex.qwe.common.title: ', ex.qwe.common.title, "\n"
-

data/config/asd.yml

@@ -1,7 +0,0 @@
-common:
-  name: use_config_example
-  title: UseConfig Example
-
-uses_use_config:
-  title: Class That Uses UseConfig
-

data/config/qwe.yml

@@ -1,10 +0,0 @@
-common:
-  name: use_config_example
-  title: UseConfig Example
-  other:
-    first: First
-    second: Second
-
-uses_use_config:
-  title: Class That Uses UseConfig
-

data/test/test_010_configuration.rb

@@ -1,90 +0,0 @@
-require 'test/unit'
-require 'use_config/configuration'
-
-class UseConfigConfigurationTest < Test::Unit::TestCase
-  def test_010
-    cfg = UseConfig::Configuration.new(:zxc, :empty => true)
-    assert_instance_of(UseConfig::Configuration, cfg)
-    assert_respond_to(cfg, :name)
-    assert_respond_to(cfg, :config_path)
-    assert_respond_to(cfg, :config_file)
-    assert_respond_to(cfg, :config_file_find)
-    assert_respond_to(cfg, :configuration?)
-  end
-
-  def test_020
-    cfg = UseConfig::Configuration.new(:zxc, :empty => true)
-    assert_equal(true, cfg.configuration?)
-    assert_equal('zxc', cfg.name)
-    assert_equal([ '.', 'config' ], cfg.config_path)
-    assert_nil(cfg.config_file)
-  end
-
-  def test_030
-    assert_raise RuntimeError do
-      UseConfig::Configuration.new :zxc
-    end
-    assert_raise RuntimeError do
-      UseConfig::Configuration.new(:zxc, :empty => false)
-    end
-  end
-
-  def test_040
-    cfg = UseConfig::Configuration.new(:qwe)
-    assert_equal(true, cfg.configuration?)
-    assert_equal('qwe', cfg.name)
-    assert_equal([ '.', 'config' ], cfg.config_path)
-    assert_equal('config/qwe.yml', cfg.config_file)
-  end
-
-  def test_050
-    cfg = UseConfig::Configuration.new(:qwe, :path_insert => '123456')
-    assert_equal([ '123456', '.', 'config' ], cfg.config_path)
-    cfg = UseConfig::Configuration.new(:qwe, :path_insert => [ '123456', '654321' ])
-    assert_equal([ '123456', '654321', '.', 'config' ], cfg.config_path)
-  end
-
-  def test_060
-    cfg = UseConfig::Configuration.new(:zxc, :empty => true) do |c|
-      c.qwerty = 11
-      c.asdfgh = 22
-      c.zxcvbn = 33
-      c.one.two.three.four = 44
-    end
-    assert_equal(11, cfg.qwerty)
-    assert_equal(22, cfg.asdfgh)
-    assert_equal(33, cfg.zxcvbn)
-    assert_equal(44, cfg.one.two.three.four)
-    cfg.reload! do |c|
-      c.qwerty = 1111
-      c.asdfgh = 2222
-    end
-    assert_equal(1111, cfg.qwerty)
-    assert_equal(2222, cfg.asdfgh)
-    assert_equal({}, cfg.zxcvbn)
-    assert_equal({}, cfg.one.two.three.four)
-  end
-
-  def test_070
-    cfg = UseConfig::Configuration.new(:qwe)
-    assert_equal('use_config_example', cfg.common.name)
-    assert_equal('UseConfig Example', cfg.common.title)
-    assert_equal('First', cfg.common.other.first)
-  end
-
-  def test_080
-    cfg = UseConfig::Configuration.new(:qwe)
-    cfg.common = 'Common'
-    assert_equal('Common', cfg.common)
-    cfg.clear!
-    assert_nil(cfg['common'])
-    cfg.common = 'Common'
-    cfg.reload!
-    assert_equal('use_config_example', cfg.common.name)
-    assert_equal('UseConfig Example', cfg.common.title)
-    assert_equal('First', cfg.common.other.first)
-    cfg.common.other.first = 'Another First'
-    assert_equal('Another First', cfg.common.other.first)
-  end
-end
-

data/test/test_020_use_config.rb

@@ -1,74 +0,0 @@
-require 'test/unit'
-require 'use_config'
-
-class UsesUseConfig
-  include UseConfig
-  use_config :qwe
-  use_config :asd
-  def self.name_in_use
-    true
-  end
-end
-
-class UsesUseConfigSecond
-  include UseConfig
-end
-
-class UsesUseConfigThird
-  include UseConfig
-end
-
-class UseConfigTest < Test::Unit::TestCase
-  def test_010_sender_class_extend
-    assert_respond_to(UsesUseConfig, :use_config)
-    assert_respond_to(UsesUseConfig, :qwe)
-    assert_respond_to(UsesUseConfig, :asd)
-  end
-
-  def test_020_object_class_extend
-    UsesUseConfig.send :include, UseConfig::ObjectExtend
-    assert_respond_to(Object, :use_config)
-  end
-
-  def test_030
-    5.times do
-      UsesUseConfig.use_config :qwe
-    end
-    assert_equal(1, UsesUseConfig.qwe.used_by.size)
-    UsesUseConfigSecond.use_config :qwe
-    assert_equal(2, UsesUseConfig.qwe.used_by.size)
-    UsesUseConfigThird.use_config :qwe
-    assert_equal(3, UsesUseConfig.qwe.used_by.size)
-    UsesUseConfigThird.drop_config :qwe
-    assert_equal(2, UsesUseConfig.qwe.used_by.size)
-    UsesUseConfigSecond.drop_config :qwe
-    assert_equal(1, UsesUseConfig.qwe.used_by.size)
-    UsesUseConfig.drop_config :qwe
-    assert_equal(false, UsesUseConfig.respond_to?(:qwe))
-    assert_equal(false, UsesUseConfig.instance_methods.include?(:qwe))
-    UsesUseConfig.drop_config :qwe
-  end
-
-  def test_040
-    UsesUseConfig.use_config :qwe
-    assert_equal('use_config_example', UsesUseConfig.qwe.common.name)
-    UsesUseConfig.qwe.clear!
-    assert_equal({}, UsesUseConfig.qwe.common)
-    UsesUseConfig.qwe.reload!
-    assert_equal('use_config_example', UsesUseConfig.qwe.common.name)
-  end
-
-  def test_050
-    assert_raise RuntimeError do
-      UsesUseConfig.use_config :name_in_use
-    end
-  end
-
-  def test_050
-    UsesUseConfig.use_config :qwe
-    inst = UsesUseConfig.new
-    assert_respond_to(inst, :qwe)
-    assert_equal('use_config_example', inst.qwe.common.name)
-  end
-end
-