use-config 0.1.1

data/LICENSE

@@ -0,0 +1,7 @@
+Copyright (c) 2008 Slava Chernobai <chernobai@gmail.com>
+
+This is free software. You may redistribute copies of it under the terms
+of the GNU General Public License.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND.
+

data/README

@@ -0,0 +1,34 @@
+== 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/Rakefile

@@ -0,0 +1,67 @@
+require 'rubygems'
+
+require 'rake/clean'
+require 'rake/testtask'
+require 'rake/rdoctask'
+require 'rake/gempackagetask'
+
+$:.insert(0, File.dirname(__FILE__) + '/lib')
+
+require 'use_config'
+
+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 ]
+
+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
+
+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')
+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/'
+end
+
+task :test => [ :README ]
+Rake::TestTask.new do |t|
+  t.libs << 'test' << 'lib'
+  t.test_files = FileList[ 'test/test*.rb' ].sort
+  t.verbose = true
+end
+
+task :gem => [ :README ]
+Rake::GemPackageTask.new(spec) do |p|
+  p.gem_spec = spec
+  p.need_tar = true
+  p.need_zip = true
+end
+

data/config/asd.yml

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

data/config/qwe.yml

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

data/lib/use_config.rb

@@ -0,0 +1,61 @@
+require 'rubygems'
+require 'use_config/configuration'
+
+# Extends calling class with UseConfig::ClassMethods when included
+module UseConfig
+  VERSION = '0.1.1'
+
+  def self.included(base) # :nodoc:
+    base.extend ClassMethods
+  end
+
+  # Extends Object class with UseConfig::ClassMethods when included
+  module ObjectExtend
+    def self.included(base) # :nodoc:
+      Object.extend ClassMethods
+    end
+  end
+
+  module ClassMethods
+    # Adds configuration hash readed from config/name.yaml file
+    # to configuration class, and generates configuration access methods.
+    def use_config(name, options = {}, &block)
+      metaclass = class << self; self; end
+
+      if self.respond_to? name
+        conf = self.send(name)
+        unless conf.respond_to? :configuration? and conf.configuration?
+          raise "Method '#{name}' already in use"
+        end
+      end
+
+      metaclass.instance_eval do
+        attr_accessor name
+      end
+      self.send "#{name}=".to_sym, UseConfig::Configuration.add_conf(self, name, options, &block)
+
+      class_eval <<-EVAL
+        def #{name}
+          self.class.#{name}
+        end
+      EVAL
+    end # def use_config(name, options = {}, &block)
+
+    # Removes configuration access methods
+    def drop_config(name, options = {})
+      if respond_to? name
+        conf = send(name)
+        if conf.respond_to? :configuration? and conf.configuration?
+          UseConfig::Configuration.drop_conf(self, name)
+          metaclass = class << self; self; end
+          metaclass.instance_eval do
+            remove_method name.to_sym
+          end
+          remove_method name.to_sym
+        end
+      end
+    end
+  end
+
+end
+

data/lib/use_config/configuration.rb

@@ -0,0 +1,151 @@
+require 'rubygems'
+require 'hash_access'
+require 'yaml'
+require 'thread'
+
+module UseConfig
+  include HashAccess
+
+  class Configuration < Hash
+    class << self
+      attr_accessor :accessors
+      attr_accessor :default_config_path
+      attr_accessor :extentions
+      attr_accessor :conf
+      attr_accessor :settings
+      attr_accessor :mutex
+    end
+
+    self.mutex = Mutex.new
+
+    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.accessors.each do |a|
+      attr_accessor a
+    end
+
+    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].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].used_by_add(used_by)
+        end
+        self.conf[sname]
+      end # self.mutex.synchronize do
+    end
+
+    def self.drop_conf(used_by, name)
+      sname = name.to_s
+      self.mutex.synchronize do
+        if self.conf[sname]
+          self.conf[sname].used_by_drop(used_by)
+          if self.conf[sname].used_by.size == 0
+            self.conf.delete(sname)
+          end
+        end
+      end # self.mutex.synchronize do
+    end
+
+    # Instance methods
+
+    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
+        else
+          self.config_path.unshift(options[:path_insert])
+        end
+      end
+      if options[:empty]
+        self.use_config_file = false
+      end
+      if use_config_file and config_file.nil?
+        config_file_find
+        if config_file.nil?
+          raise "Configuration file not found"
+        end
+        load_configuration
+      end
+      access_by_methods
+      yield self if block_given?
+      self
+    end # def initialize(name, options = {}, &block)
+
+    def used_by_add(used_by)
+      self.used_by.push(used_by) unless self.used_by.include?(used_by)
+      self
+    end
+
+    def used_by_drop(used_by)
+      if self.used_by.include?(used_by)
+        self.used_by.delete(used_by)
+      end
+      self
+    end
+
+    def config_file_find
+      self.config_path.each do |dir|
+        self.extentions.each do |ext|
+          file = "#{dir}/#{name}.#{ext}"
+          if File.exist?(file)
+            self.config_file = file
+            return self
+          end
+        end
+      end
+      self
+    end # def config_file_find
+
+    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
+      end
+      self
+    end
+
+    def clear!
+      each_key do |key|
+        next if self.class.accessors.include?(key.to_sym)
+        delete(key)
+      end
+      yield self if block_given?
+      self
+    end
+
+    def reload!
+      clear!
+      load_configuration if use_config_file
+      yield self if block_given?
+      self
+    end
+
+  end # class Configuration
+end # module UseConfig
+

data/test/test_010_configuration.rb

@@ -0,0 +1,90 @@
+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

@@ -0,0 +1,74 @@
+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
+

metadata

@@ -0,0 +1,73 @@
+--- !ruby/object:Gem::Specification 
+name: use-config
+version: !ruby/object:Gem::Version 
+  version: 0.1.1
+platform: ruby
+authors: 
+- Slava Chernobai
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-01-18 00:00:00 +03:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: hash-access
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    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
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+- LICENSE
+files: 
+- README
+- 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
+has_rdoc: true
+homepage: http://code.slava.pp.ru/use-config/
+post_install_message: 
+rdoc_options: 
+- --main=README
+- --line-numbers
+- --inline-source
+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: 
+rubygems_version: 1.0.1
+signing_key: 
+specification_version: 2
+summary: UseConfig. Allows Ruby classes to use configuration, stored in YAML files.
+test_files: []
+