lukeredpath-simpleconfig 1.0

data/lib/controller_mixin.rb

@@ -0,0 +1,31 @@
+module SimpleConfig
+  module ControllerMixin
+    
+    def self.included(base)
+      base.extend     ClassMethods
+      base.class_eval do
+        include       InstanceMethods
+        helper_method :config
+      end
+    end
+    
+    module ClassMethods
+      
+      # Returns the application config.
+      def config
+        SimpleConfig.for(:application)
+      end
+      
+    end
+    
+    module InstanceMethods
+      
+      # Instance-level proxy to class-level +config+ method.
+      def config
+        self.class.config
+      end
+      
+    end
+    
+  end
+end

data/lib/simple_config/utilities.rb

@@ -0,0 +1,40 @@
+require 'uri'
+
+module SimpleConfig
+  module Utilities
+    class NetworkHost
+      attr_reader :name, :port
+
+      def initialize(name, port = nil, secure = false)
+        @name, @port = name, port
+        @secure = secure
+      end
+      
+      def secure?
+        @secure
+      end
+
+      def self.from_string(host_string)
+        host, port = host_string.split(':')
+        new(host, port.to_i)
+      end
+
+      def to_uri(uri_options = {})
+        options = uri_options.except(:host, :port)
+        URI::Generic.build(options.reverse_merge(:host => name, :port => port, :scheme => default_uri_scheme))
+      end
+
+      def url_for_path(path)
+        to_uri(:path => path).to_s
+      end
+
+      def to_s
+        [name, port].compact.join(':')
+      end
+      
+      def default_uri_scheme
+        secure? ? 'https' : 'http'
+      end
+    end
+  end
+end

data/lib/simple_config.rb

@@ -0,0 +1,148 @@
+require 'yaml'
+
+module SimpleConfig
+  
+  class << self
+    def for(config_name, &block)
+      default_manager.for(config_name, &block)
+    end
+    
+    def default_manager
+      @default_manager ||= Manager.new
+    end
+  end
+  
+  class Manager
+    def initialize
+      @configs = {}
+    end
+    
+    def for(config_name, &block)
+      returning @configs[config_name] ||= Config.new do |config|
+        config.configure(&block) if block_given?
+      end
+    end
+  end
+  
+  class Config
+    def initialize
+      @groups = {}
+      @settings = {}
+    end
+    
+    def configure(&block)
+      instance_eval(&block)
+    end
+    
+    def group(name, &block)
+      returning @groups[name] ||= Config.new do |group|
+        group.configure(&block) if block_given?
+      end
+    end
+    
+    def set(key, value)
+      @settings[key] = value
+    end
+    
+    def get(key)
+      @settings[key]
+    end
+    
+    # 
+    # Unsets any variable with given +key+ 
+    # and returns variable value if it exists, nil otherwise.
+    # Any successive call to exists? :key will return false.
+    # 
+    #   exists? :bar      # => false
+    # 
+    #   set :bar, 'foo'
+    #   exists? :bar      # => true
+    # 
+    #   unset :bar        # => 'foo'
+    #   exists? :bar      # => false
+    # 
+    def unset(key)
+      @settings.delete(key)
+    end
+    
+    # 
+    # Returns whether a variable with given +key+ is set.
+    # 
+    # Please note that this method doesn't care about variable value.
+    # A nil variable is considered as set.
+    # 
+    #   exists? :bar      # => false
+    # 
+    #   set :bar, 'foo'
+    #   exists? :bar      # => true
+    # 
+    #   set :bar, nil
+    #   exists? :bar      # => true
+    # 
+    # Use unset to completely remove a variable from the collection.
+    # 
+    #   set :bar, 'foo'
+    #   exists? :bar      # => true
+    # 
+    #   unset :bar
+    #   exists? :bar      # => false
+    # 
+    def exists?(key)
+      @settings.key?(key)
+    end
+    
+    def load(external_config_file, options={})
+      options.reverse_merge!(:if_exists? => false)
+      
+      if options[:if_exists?]
+        return unless File.exist?(external_config_file)
+      end
+      
+      case File.extname(external_config_file)
+      when /rb/
+        instance_eval(File.read(external_config_file))
+      when /yml|yaml/
+        YAMLParser.parse_contents_of_file(external_config_file).parse_into(self)
+      end
+    end
+    
+    private
+      def method_missing(method_name, *args)
+        case true
+        when @groups.key?(method_name)
+          return @groups[method_name]
+        when @settings.key?(method_name)
+          return get(method_name)
+        else
+          super(method_name, *args)
+        end
+      end
+  end
+  
+  class YAMLParser
+    def initialize(raw_yaml_data)
+      @data = YAML.load(raw_yaml_data)
+    end
+    
+    def self.parse_contents_of_file(yaml_file)
+      new(File.read(yaml_file))
+    end
+    
+    def parse_into(config)
+      @data.each do |key, value|
+        parse(key, value, config)
+      end
+    end
+    
+    private
+      def parse(key, value, config)
+        if value.is_a?(Hash)
+          group = config.group(key.to_sym)
+          value.each { |key, value| parse(key, value, group) }
+        else
+          config.set(key.to_sym, value)
+        end
+      end
+  end
+  
+end

data/test/controller_mixin_test.rb

@@ -0,0 +1,38 @@
+require File.join(File.dirname(__FILE__), *%w[test_helper])
+
+require 'simple_config'
+require 'controller_mixin'
+
+class RailsController
+  class << self
+    attr_reader :helper_methods
+    def helper_method(name)
+      (@helper_methods ||= []) << name
+    end
+  end
+end
+
+class ControllerMixinTest < Test::Unit::TestCase
+
+  def setup
+    @app_config = SimpleConfig.for(:application) do
+    end
+    
+    @controller_klass = Class.new(RailsController)
+  end
+  
+  def test_should_define_a_config_class_method_that_returns_the_application_config_when_included
+    @controller_klass.send(:include, SimpleConfig::ControllerMixin)
+    assert_equal @app_config, @controller_klass.config
+  end
+  
+  def test_should_define_a_config_instance_method_that_returns_the_application_config_when_included
+    @controller_klass.send(:include, SimpleConfig::ControllerMixin)
+    assert_equal @app_config, @controller_klass.new.config
+  end
+  
+  def test_should_define_the_config_method_as_helper_method_to_make_it_available_to_views_when_included
+    @controller_klass.send(:include, SimpleConfig::ControllerMixin)
+    assert_equal [:config], @controller_klass.helper_methods
+  end
+end

data/test/network_host_test.rb

@@ -0,0 +1,38 @@
+require File.join(File.dirname(__FILE__), *%w[test_helper])
+
+require 'simple_config/utilities'
+
+class NetworkHostTest < Test::Unit::TestCase
+  include SimpleConfig::Utilities
+    
+  def test_should_default_to_no_port
+    host = NetworkHost.new('www.example.com')
+    assert_nil host.port
+  end
+  
+  def test_should_build_a_uri_object_with_the_specified_hostname_and_port_and_a_http_scheme
+    uri = NetworkHost.new('www.example.com', 9000).to_uri
+    assert_instance_of URI::Generic, uri
+    assert_equal 'http', uri.scheme
+  end
+  
+  def test_should_build_a_uri_object_with_an_https_scheme_if_secure
+    uri = NetworkHost.new('www.example.com', 443, secure = true).to_uri
+    assert_equal 'https', uri.scheme
+  end
+  
+  def test_should_return_a_url_for_a_given_path
+    host = NetworkHost.new('www.example.com')
+    assert_equal 'http://www.example.com/foo/bar', host.url_for_path('/foo/bar')
+  end
+  
+  def test_should_return_a_string_representation
+    assert_equal 'www.example.com:9000', NetworkHost.new('www.example.com', 9000).to_s
+  end
+  
+  def test_should_be_constructed_from_a_string_representation
+    host = NetworkHost.from_string('www.example.com:9000')
+    assert_equal 'www.example.com', host.name
+    assert_equal 9000, host.port
+  end
+end

data/test/simple_config_functional_test.rb

@@ -0,0 +1,100 @@
+require File.join(File.dirname(__FILE__), *%w[test_helper])
+
+require 'simple_config'
+
+class SimpleConfigFunctionalTest < Test::Unit::TestCase
+  
+  def test_simple_config_with_top_level_settings
+    config = SimpleConfig.for(:my_test) do
+      set :var_one, 'foo'
+      set :var_two, 'bar'
+    end
+    
+    assert_equal 'foo', config.var_one
+    assert_equal 'bar', config.var_two
+  end
+  
+  def test_config_with_groups
+    config = SimpleConfig.for(:my_test) do
+      group :test_group do
+        set :var_one, 'foo'
+      end
+    end
+    
+    assert_equal 'foo', config.test_group.var_one
+  end
+  
+  def test_config_with_top_level_settings_and_groups
+    config = SimpleConfig.for(:my_test) do
+      group :test_group do
+        set :var_one, 'foo'
+      end
+      
+      set :var_two, 'bar'
+    end
+    
+    assert_equal 'foo', config.test_group.var_one
+    assert_equal 'bar', config.var_two
+  end
+  
+  def test_config_with_nested_groups
+    config = SimpleConfig.for(:my_test) do
+      group :test_group do
+        group :inner_group do
+          set :var_one, 'foo'
+        end
+      end
+    end
+    
+    assert_equal 'foo', config.test_group.inner_group.var_one
+  end
+  
+  def test_config_with_externally_loaded_ruby_config
+    sample_file = File.join(File.dirname(__FILE__), *%w[example.rb])
+    File.open(sample_file, "w") do |io|
+      io << %(
+        set :foo, 'bar'
+      )
+    end
+    
+    config = SimpleConfig.for(:my_test) do
+      load sample_file
+    end
+    
+    assert_equal 'bar', config.foo
+    
+    FileUtils.rm_f(sample_file)
+  end
+  
+  def test_config_with_externally_loaded_yaml_config
+    sample_file = File.join(File.dirname(__FILE__), *%w[example.yml])
+    File.open(sample_file, "w") do |io|
+      io << %(
+      example:
+        foo: bar
+        baz: qux
+      
+      test: foo
+      )
+    end
+    
+    config = SimpleConfig.for(:my_test) do
+      load sample_file
+    end
+    
+    assert_equal 'foo', config.test
+    assert_equal 'bar', config.example.foo
+    assert_equal 'qux', config.example.baz
+    
+    FileUtils.rm_f(sample_file)
+  end
+  
+  def test_config_with_optional_external_config
+    assert_nothing_raised do
+      SimpleConfig.for(:my_test) do
+        load "non_existent_file", :if_exists? => true
+      end
+    end
+  end
+  
+end

data/test/simple_config_test.rb

@@ -0,0 +1,108 @@
+require File.join(File.dirname(__FILE__), *%w[test_helper])
+
+require 'simple_config'
+
+class SimpleConfigConfigTest < Test::Unit::TestCase
+  
+  def setup
+    @config = SimpleConfig::Config.new
+  end
+  
+  def test_should_be_able_to_set_config_values
+    @config.set(:var_one, 'hello world')
+    assert_equal 'hello world', @config.get(:var_one)
+  end
+  
+  def test_should_be_able_to_access_settings_using_method_access
+    @config.set(:foo, 'bar')
+    assert_equal 'bar', @config.foo
+  end
+  
+  def test_should_raise_NoMethodError_if_setting_does_not_exist_when_using_method_access
+    assert_raises(NoMethodError) { @config.some_non_existent_variable }
+  end
+  
+  def test_should_return_nil_if_setting_does_not_exist_when_using_get
+    assert_nil @config.get(:some_non_existent_variable)
+  end
+  
+  def test_unset_should_delete_config_values
+    @config.set(:foo, 'bar')
+    assert_equal('bar', @config.foo)
+    @config.unset(:foo)
+    assert_raises(NoMethodError) { @config.foo }
+  end
+  
+  def test_unset_should_return_deleted_value
+    @config.set(:foo, 'bar')
+    assert_equal('bar', @config.unset(:foo))
+  end
+  
+  def test_exists_should_return_whether_variable_isset
+    assert(!@config.exists?(:foo))
+    @config.set(:foo, 'bar')
+    assert(@config.exists?(:foo))
+    @config.unset(:foo)
+    assert(!@config.exists?(:foo))
+  end
+  
+  def test_exists_should_consider_empty_values_as_set
+    [nil, 0, ''].each do |empty_value|
+      @config.set(:foo, empty_value)
+      assert_equal(empty_value, @config.get(:foo))
+      assert(@config.exists?(:foo))
+    end
+  end
+  
+  def test_should_return_a_new_group_as_a_separate_config
+    group = @config.group(:test)
+    assert_instance_of(SimpleConfig::Config, group)
+    assert_not_equal @config, group
+  end
+  
+  def test_should_return_an_existing_group
+    group = @config.group(:test)
+    assert_equal group, @config.group(:test)
+  end
+  
+  def test_should_configure_group_with_supplied_block_when_given
+    group = @config.group(:test) do
+      set :group_var, 'value'
+    end
+    assert_equal 'value', group.group_var
+  end
+  
+  def test_should_load_and_parse_external_config_as_ruby_in_context_of_config_instance
+    File.stubs(:read).with('external_config.rb').returns(ruby_code = stub('ruby'))
+    @config.expects(:instance_eval).with(ruby_code)
+    @config.load('external_config.rb')
+  end
+  
+  def test_should_laod_and_parse_external_config_as_yaml_in_context_of_config_instance
+    parser = stub('YAMLParser')
+    SimpleConfig::YAMLParser.stubs(:parse_contents_of_file).with('external_config.yml').returns(parser)
+    parser.expects(:parse_into).with(@config)
+    @config.load('external_config.yml')
+  end
+  
+  def test_should_load_and_parse_external_config_as_yaml_if_config_file_has_full_yaml_extension
+    parser = stub('YAMLParser')
+    SimpleConfig::YAMLParser.expects(:parse_contents_of_file).with('external_config.yaml').returns(parser)
+    parser.stubs(:parse_into)
+    @config.load('external_config.yaml')
+  end
+  
+  def test_should_load_and_parse_external_config_if_file_exists_when_if_exists_is_true
+    File.stubs(:read).with('external_config.rb').returns(ruby_code = stub('ruby'))
+    @config.expects(:instance_eval).with(ruby_code)
+    File.stubs(:exist?).with('external_config.rb').returns(true)
+    @config.load('external_config.rb', :if_exists? => true)
+  end
+  
+  def test_should_not_load_and_parse_external_config_if_file_does_not_exist_when_if_exists_is_true
+    @config.expects(:instance_eval).never
+    File.stubs(:exist?).with('external_config.rb').returns(false)
+    @config.load('external_config.rb', :if_exists? => true)
+  end
+    
+end

data/test/yaml_parser_test.rb

@@ -0,0 +1,58 @@
+require File.join(File.dirname(__FILE__), *%w[test_helper])
+
+require 'simple_config'
+
+class YAMLParserTest < Test::Unit::TestCase
+  include SimpleConfig
+  
+  def setup
+    @config = Config.new
+  end
+  
+  def test_parsing_of_a_single_variable
+    parser = YAMLParser.new({'foo' => 'bar'}.to_yaml)
+    parser.parse_into(@config)
+
+    assert_equal 'bar', @config.foo
+  end
+  
+  def test_parsing_of_multiple_variables
+    parser = YAMLParser.new({'foo' => 'bar', 'baz' => 'qux'}.to_yaml)
+    parser.parse_into(@config)
+
+    assert_equal 'bar', @config.foo
+    assert_equal 'qux', @config.baz
+  end
+  
+  def test_parsing_of_a_group_with_one_variable
+    parser = YAMLParser.new({'group1' => {'foo' => 'bar'}}.to_yaml)
+    parser.parse_into(@config)
+    
+    assert_equal 'bar', @config.group1.foo
+  end
+  
+  def test_parsing_of_a_group_with_two_variables
+    parser = YAMLParser.new({'group1' => {'foo' => 'bar', 'baz' => 'qux'}}.to_yaml)
+    parser.parse_into(@config)
+    
+    assert_equal 'bar', @config.group1.foo
+    assert_equal 'qux', @config.group1.baz
+  end
+  
+  def test_parsing_of_a_nested_group
+    parser = YAMLParser.new({'group1' => {'group2' => {'foo' => 'bar'}}}.to_yaml)
+    parser.parse_into(@config)
+    
+    assert_equal 'bar', @config.group1.group2.foo
+  end
+end
+
+class YAMLParserFromContentsOfFile < Test::Unit::TestCase
+  include SimpleConfig
+  
+  def test_should_initialize_new_parser_from_contents_of_given_file
+    File.stubs(:read).with('config.yml').returns(yaml_data = stub('yaml data'))
+    YAMLParser.expects(:new).with(yaml_data).returns(parser = stub('YAMLParser'))
+    assert_equal parser, YAMLParser.parse_contents_of_file('config.yml')
+  end
+end

metadata

@@ -0,0 +1,59 @@
+--- !ruby/object:Gem::Specification 
+name: lukeredpath-simpleconfig
+version: !ruby/object:Gem::Version 
+  version: "1.0"
+platform: ruby
+authors: 
+- Luke Redpath
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-12-05 00:00:00 -08:00
+default_executable: 
+dependencies: []
+
+description: Simple Config is a plugin designed to make application-wide configuration settings (e.g. in a Rails app) easy to set and access in an object-oriented fashion.
+email: contact@lukeredpath.co.uk
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/simple_config.rb
+- lib/controller_mixin.rb
+- lib/simple_config/utilities.rb
+has_rdoc: false
+homepage: http://github.com/lukeredpath/simpleconfig
+post_install_message: 
+rdoc_options: []
+
+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.2.0
+signing_key: 
+specification_version: 2
+summary: Simple object-oriented application settings
+test_files: 
+- test/controller_mixin_test.rb
+- test/network_host_test.rb
+- test/simple_config_functional_test.rb
+- test/simple_config_test.rb
+- test/yaml_parser_test.rb