configue 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 86dd4fa550a529d4050ba85051d25b434c657dff
-  data.tar.gz: 54fd3e9d60f20f95863df2431020dcdce4252222
+  metadata.gz: b2a6932c57f41d3a8e0face2437eb0ed9c6c9577
+  data.tar.gz: 4efa8934701bd705a9c79030782465f2a8a93813
 SHA512:
-  metadata.gz: e2c90a3fd197642ee4fb7a92bfc307aa69b5a903135bb88a24e2ac9d487c0d3527367a5f840f12ff1774e4c60ab2e498bb710fca84a3ef81944ed53a97f09221
-  data.tar.gz: 7bb08f81f3621dab09766199e4a00aa1b35d92792877eaa0dad6da686e7c2b74af9131aa6235fe8acdce0863bd5c913d3644c9f5b596cba7b7fb2a6b01dd358f
+  metadata.gz: 61a7c799b95237f0278b333a85fb460f17790106940145e22c8a34f3e26fe2a04c5cd62762bac6988a04ec716a06c3da21ed829d5ac747ecb3d8db6afb923674
+  data.tar.gz: d00f683e0554cde0dd4f43ce81f947a2133f96146d7fe8e6061017190feae6ad6aefd649620dd161b4b5b9856b477727d58e1c59730ada7800f205021155a05e

data/README.md

@@ -1,7 +1,7 @@
 # Configue
 Configue is a configuration / settings solution that uses YAML files.
 It is almost a fork of SettingsLogic.
-Configue can read multiple YAML files and you can use big configration data
+Configue can read multiple YAML files and you can use big configuration data
 simply.
 
 ## Installation
@@ -9,10 +9,91 @@ simply.
 gem install configue
 ```
 
-## Usage
+## Basic Usage
 ### Define your class
 ```ruby
-class Conf < Configue::Container
-  config_setting.source_dir "#{File.dirname(__FILE__)}/config"
+class MyConf < Configue::Container
+  config.source_dir "#{File.dirname(__FILE__)}/config"
 end
 ```
+
+### Write your settings in YAML file
+```yaml
+# config/accounts/admin_users.yml
+config:
+  accounts:
+    admin_users:
+      - grumpy
+      - sneezy
+```
+
+You can make multiple settings files.
+
+```yaml
+# config/accounts/test_users.yml
+config:
+  accounts:
+    test_users:
+      - sleepy
+      - dopey
+```
+
+### Access your settings
+```
+>> MyConf.config.accounts.admin_users
+=> ["grumpy", "sneezy"]
+
+>> MyConf.config.accounts.test_users
+=> ["sleepy", "dopey"]
+```
+
+## Other usage
+### namespace
+You can specify `namespace` and `base_namespace`.
+
+When you write settings as follows:
+```yaml
+# config/settings/base.yml
+base:
+  foo:
+    baa:
+      - a
+      - b
+      - c
+    baz:
+      - one
+      - two
+      - three
+
+# config/settings/dev.yml
+dev:
+  foo:
+    baa:
+      - pee
+      - kaa
+      - boo
+
+# config/settings/test.yml
+test:
+  foo:
+    baa:
+      - boo
+      - foo
+      - woo
+```
+and define a class for the settings
+```ruby
+class MyConf < Configue::Container
+  config.source_dir "#{File.dirname(__FILE__)}/config/settings"
+  config.base_namespace :base
+  config.namespace :test
+end
+```
+you can access it in the following manner:
+```
+>> MyConf.foo.baa
+=> ["boo", "foo", "woo"]
+
+>> MyConf.foo.baz
+=> ["one", "two", "three"]
+```

data/configue.gemspec

@@ -12,7 +12,7 @@ Gem::Specification.new do |s|
   s.files         = `git ls-files`.split("\n")
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
   s.require_paths = ["lib"]
-  s.version       = "0.1.0"
+  s.version       = "0.1.1"
   s.license       = "MIT" 
 
   s.add_development_dependency 'rspec'

data/lib/configue/container.rb

@@ -1,19 +1,39 @@
 # coding: utf-8
 
+require "forwardable"
+require "configue/criteria"
+
 module Configue
   class Container
+    extend Forwardable
+
+    def_delegators :@node, :keys, :key?, :has_key?, :[]
+
+    def initialize(hash)
+      @node = hash
+    end
+
+    def query(key=nil)
+      q = Criteria.new(@node)
+      q = key.split('.').each.inject(q) {|c, k| c[k] } if key
+      q
+    end
+
     class << self
-      def config_setting
+      def config
         @setting ||= Setting.new(self)
       end
+      alias_method :config_setting, :config
 
-      def [](*args)
-        key = args[0].to_s
-        @setting.hash[key]
+      private
+      def method_missing(name, *args, &block)
+        @instance ||= new(@setting.load_source)
+        if @instance.key?(name)
+          @instance[name]
+        else
+          @instance.__send__(name, *args, &block)
+        end
       end
-
-      def key?(key); @setting.hash.key?(key.to_s); end
-      alias_method :has_key?, :key?
     end
   end
 end

data/lib/configue/criteria.rb

@@ -0,0 +1,29 @@
+# coding: utf-8
+
+module Configue
+  class Criteria
+    def initialize(hash, *path)
+      @hash = hash
+      @path = path
+    end
+
+    def [](key)
+      self.class.new(@hash, *@path, key.to_s)
+    end
+
+    def retrieve
+      @path.each.inject(@hash) do |h, key|
+        return nil unless h.is_a?(Hash) and h.has_key?(key)
+        h[key]
+      end
+    end
+
+    def exist?
+      @path.each.inject(@hash) do |h, key|
+        return false unless h.is_a?(Hash) and h.has_key?(key)
+        h[key]
+      end
+      true
+    end
+  end
+end

data/lib/configue/inner_hash.rb

@@ -3,14 +3,17 @@
 module Configue
   class InnerHash < Hash
     def initialize(source_hash=nil)
-      if source_hash
-        deep_update(source_hash)
+      deep_merge!(source_hash) if source_hash
+    end
 
-        sig = class << self; self; end
-        source_hash.keys.each do |k|
-          sig.__send__(:define_method, k, ->{ self[k] })
-        end
+    def deep_merge!(other)
+      deep_update(other)
+
+      sig = class << self; self; end
+      other.keys.each do |k|
+        sig.__send__(:define_method, k, ->{ self[k] })
       end
+      self
     end
 
     def fetch(key, *args); super(key.to_s, *args); end

data/lib/configue/setting.rb

@@ -1,25 +1,82 @@
 # coding: utf-8
 
+require "configue/yaml_loader"
+
 module Configue
   class Setting
     def initialize(owner_class)
       @owner_class = owner_class
+      @loader = YamlLoader.new
+    end
+
+    def base_namespace(key=nil)
+      @base_namespace = key if key
+      @base_namespace
+    end
+
+    def base_namespace=(key)
+      base_namespace(key)
     end
 
-    def source_dir(dir)
-      @hash ||= InnerHash.new
-      Dir.glob("#{dir}/**/*.yml") do |filenm|
-        h = YAML.load_file(filenm)
-        @hash.__send__(:deep_update, h)
+    def namespace(key=nil)
+      @namespace = key if key
+      @namespace
+    end
+
+    def namespace=(key)
+      namespace(key)
+    end
+
+    def source_dir(*dirs)
+      @source_dirs ||= []
+      @source_dirs += dirs unless dirs.empty?
+      @source_dirs
+    end
 
-        sig = class << @owner_class; self; end
-        h.keys.each do |k|
-          sig.__send__(:define_method, k, ->{ self[k] })
+    def source_dir=(dir)
+      if dir.is_a?(Array)
+        source_dir(*dir)
+      else
+        source_dir(dir)
+      end
+    end
+
+    def load_source
+      hash = load_sources
+
+      space = namespace.to_s
+      unless space.empty?
+        base = base_namespace.to_s
+        result = InnerHash.new
+        result.deep_merge!(hash[base]) if base_namespace
+        result.deep_merge!(hash[space]) if hash[space]
+        hash = result
+      end
+      hash
+    end
+
+    private
+    def load_sources
+      @source_dirs.each.inject(InnerHash.new) do |root, dir|
+        Dir.glob("#{dir}/**/*.#{@loader.extention}") do |path|
+          source = @loader.load(path)
+          if namespace and source[namespace.to_s]
+            namespaced_hash(root, source)
+          else
+            root.deep_merge!(source)
+          end
         end
+        root
       end
-      @hash
     end
 
-    attr_reader :hash
+    def namespaced_hash(root, hash)
+      base = base_namespace.to_s
+      space = namespace.to_s
+
+      root.deep_merge!(base => hash[base]) if ! base.empty? and hash[base]
+      root.deep_merge!(space => hash[space])
+      root
+    end
   end
 end

data/lib/configue/yaml_loader.rb

@@ -0,0 +1,14 @@
+# coding: utf-8
+require "yaml"
+
+module Configue
+  class YamlLoader
+    def extention
+      "yml"
+    end
+
+    def load(path)
+      YAML.load_file(path)
+    end
+  end
+end

data/lib/configue.rb

@@ -1,5 +1,5 @@
 # coding: utf-8
-require "yaml"
 require "configue/setting"
 require "configue/container"
 require "configue/inner_hash"
+

data/spec/base_namespace_conf.rb

@@ -0,0 +1,8 @@
+# coding: utf-8
+require "configue"
+
+class BaseNamespaceConf < Configue::Container
+  config.source_dir "#{File.dirname(__FILE__)}/namespace"
+  config.base_namespace :base
+  config.namespace :test
+end

data/spec/configue/basic_spec.rb

@@ -0,0 +1,49 @@
+# coding: utf-8
+require File.expand_path("../../spec_helper", __FILE__)
+
+describe "Configue::Container" do
+  context "when reading a single yaml file" do
+    require "#{File.dirname(__FILE__)}/../single_yaml_conf"
+
+    context "1st level" do
+      it_should_behave_like "an InnerHash instance",
+        SingleYamlConf,
+        {"foo" => ["baa"], "pee" => ["kaa0", "kaa1"]}
+    end
+
+    context "2nd level" do
+      it_should_behave_like "an InnerHash instance",
+        SingleYamlConf["foo"],
+        {"baa" => ["baz0", "baz1"]}
+      it_should_behave_like "an InnerHash instance",
+        SingleYamlConf["pee"],
+        {"kaa0" => ["boo"], "kaa1" => ["boo"]}
+    end
+  end
+
+  context "when reading multiple yaml files" do
+    require "#{File.dirname(__FILE__)}/../multiple_yaml_conf"
+
+    context "1st level" do
+      it_should_behave_like "an InnerHash instance",
+        MultipleYamlConf,
+        {"foo" => ["baa", "bar", "pee"]}
+    end
+
+    context "2nd level" do
+      it_should_behave_like "an InnerHash instance",
+        MultipleYamlConf["foo"],
+        {"baa" => ["baz"], "bar" => ["ding", "tick"], "pee" => ["kaa", "boo"]}
+    end
+
+    context "3rd level" do
+      it_should_behave_like "an InnerHash instance",
+        MultipleYamlConf["foo"]["baa"], {"baz" => nil}
+      it_should_behave_like "an InnerHash instance",
+        MultipleYamlConf["foo"]["pee"], {"kaa" => nil, "boo" => nil}
+      it_should_behave_like "an InnerHash instance",
+        MultipleYamlConf["foo"]["bar"],
+        {"ding" => ["dong", "dang"], "tick" => ["tack", "toe"]}
+    end
+  end
+end

data/spec/configue/namespace_spec.rb

@@ -0,0 +1,55 @@
+# coding: utf-8
+require File.expand_path("../../spec_helper", __FILE__)
+
+describe "Configue::Container" do
+  context "when specifing 'namespace'" do
+    require "#{File.dirname(__FILE__)}/../namespace_conf"
+
+    context "1st level" do
+      it_should_behave_like "an InnerHash instance",
+        NamespaceConf,
+        {"pee" => ["kaa"]}
+    end
+
+    context "2nd level" do
+      it_should_behave_like "an InnerHash instance",
+        NamespaceConf["pee"],
+        {"kaa" => ["boo"]}
+    end
+
+    context "3rd level" do
+      it_should_behave_like "an InnerHash instance",
+        NamespaceConf["pee"]["kaa"],
+        {"boo" => ["foo", "baa", "baz"]}
+    end
+  end
+
+  context "when specifing 'namespace' and 'base_namespace'" do
+    require "#{File.dirname(__FILE__)}/../base_namespace_conf"
+
+    context "1st level" do
+      it_should_behave_like "an InnerHash instance",
+        BaseNamespaceConf,
+        {"pee" => ["kaa"]}
+    end
+
+    context "2nd level" do
+      it_should_behave_like "an InnerHash instance",
+        BaseNamespaceConf["pee"],
+        {"kaa" => ["boo"]}
+    end
+
+    context "3rd level" do
+      it_should_behave_like "an InnerHash instance",
+        BaseNamespaceConf["pee"]["kaa"],
+        {"boo" => ["foo", "baa", "baz", "boo", "woo", "poo"]}
+
+      it "returns values defined in namespaced hash" do
+        root = BaseNamespaceConf.query[:pee][:kaa][:boo]
+        expect(root[:foo].retrieve).to eq "one"
+        expect(root[:baa].retrieve).to eq "two"
+        expect(root[:baz].retrieve).to eq "three"
+      end
+    end
+  end
+end

data/spec/multiple_yaml_conf.rb

@@ -1,5 +1,5 @@
 # coding: utf-8
 
 class MultipleYamlConf < Configue::Container
-  config_setting.source_dir "#{File.dirname(__FILE__)}/multiple_yaml"
+  config.source_dir "#{File.dirname(__FILE__)}/multiple_yaml"
 end

data/spec/namespace/base/pee/kaa/conf.yml

@@ -0,0 +1,10 @@
+base:
+  pee:
+    kaa:
+      boo:
+        foo: a
+        baa: b
+        baz: c
+        boo: x
+        woo: y
+        poo: z

data/spec/namespace/dev/pee/kaa/conf.yml

@@ -0,0 +1,7 @@
+dev:
+  pee:
+    kaa:
+      boo:
+        foo: un
+        baa: deux
+        baz: trois

data/spec/namespace/test/pee/kaa/conf.yml

@@ -0,0 +1,7 @@
+test:
+  pee:
+    kaa:
+      boo:
+        foo: one
+        baa: two
+        baz: three

data/spec/namespace_conf.rb

@@ -0,0 +1,7 @@
+# coding: utf-8
+require "configue"
+
+class NamespaceConf < Configue::Container
+  config.source_dir "#{File.dirname(__FILE__)}/namespace"
+  config.namespace :dev
+end

data/spec/single_yaml_conf.rb

@@ -1,5 +1,5 @@
 # coding: utf-8
 
 class SingleYamlConf < Configue::Container
-  config_setting.source_dir "#{File.dirname(__FILE__)}/single_yaml"
+  config.source_dir "#{File.dirname(__FILE__)}/single_yaml"
 end

data/spec/spec_helper.rb

@@ -2,5 +2,9 @@
 require 'rspec'
 require 'configue'
 
+Dir.glob("#{File.dirname(__FILE__)}/support/**/*.rb") do |f|
+  require f
+end
+
 RSpec.configure do |config|
 end

data/spec/support/inner_hash.rb

@@ -0,0 +1,91 @@
+# coding: utf-8
+
+shared_examples_for "an InnerHash instance" do |object, hash|
+  describe ".has_key?" do
+    context "when specifing the existing key names" do
+      it "returns true" do
+        hash.keys.each do |key|
+          expect(object).to have_key(key)
+        end
+      end
+    end
+
+    context "when specifing the non-existing key names" do
+      it "returns false" do
+        hash.keys.each do |key|
+          expect(object).not_to have_key(key.reverse)
+        end
+      end
+    end
+
+    context "when specifing the existing key names in symbol" do
+      it "returns true" do
+        hash.keys.each do |key|
+          expect(object).to have_key(key.to_sym)
+        end
+      end
+    end
+
+    context "when specifing the non-existing key names in symbol" do
+      it "returns false" do
+        hash.keys.each do |key|
+          expect(object).not_to have_key(key.reverse.to_sym)
+        end
+      end
+    end
+  end
+
+  describe ".[]" do
+    context "when specifing the existing key names" do
+      it "returns a Hash value" do
+        hash.each do |key, value|
+          expect(object[key]).to be_a(Hash) if value
+        end
+      end
+
+      describe "the Hash value" do
+        it "has keys described in the setting(s)" do
+          hash.each do |key, value|
+            expect(object[key].keys).to match_array(value) if value
+          end
+        end
+      end
+    end
+
+    context "when specifing the existing key names in symbol" do
+      it "returns a Hash value" do
+        hash.each do |key, value|
+          expect(object[key.to_sym]).to be_a(Hash) if value
+        end
+      end
+
+      describe "the Hash value" do
+        it "has keys described in the setting(s)" do
+          hash.each do |key, value|
+            expect(object[key.to_sym].keys).to match_array(value) if value
+          end
+        end
+      end
+    end
+  end
+
+  describe ".(key_name)" do
+    context "when call methods which names are existing in the setting(s)" do
+      it "returns a Hash value" do
+        hash.each do |key, value|
+          expect(object.__send__(key)).to be_a(Hash) if value
+        end
+      end
+
+      describe "the Hash value" do
+        it "has keys described in the setting(s)" do
+          hash.each do |key, value|
+            next unless value
+            actual = object.__send__(key)
+            expect(actual.keys).to match_array(value)
+          end
+        end
+      end
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: configue
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - hosim
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-03-16 00:00:00.000000000 Z
+date: 2014-03-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -37,17 +37,26 @@ files:
 - configue.gemspec
 - lib/configue.rb
 - lib/configue/container.rb
+- lib/configue/criteria.rb
 - lib/configue/inner_hash.rb
 - lib/configue/setting.rb
-- spec/configue_spec.rb
+- lib/configue/yaml_loader.rb
+- spec/base_namespace_conf.rb
+- spec/configue/basic_spec.rb
+- spec/configue/namespace_spec.rb
 - spec/multiple_yaml/foo/baa.yml
 - spec/multiple_yaml/foo/bar/ding.yml
 - spec/multiple_yaml/foo/bar/tick.yml
 - spec/multiple_yaml/foo/pee.yml
 - spec/multiple_yaml_conf.rb
+- spec/namespace/base/pee/kaa/conf.yml
+- spec/namespace/dev/pee/kaa/conf.yml
+- spec/namespace/test/pee/kaa/conf.yml
+- spec/namespace_conf.rb
 - spec/single_yaml/conf.yml
 - spec/single_yaml_conf.rb
 - spec/spec_helper.rb
+- spec/support/inner_hash.rb
 homepage: https://github.com/hosim/configue
 licenses:
 - MIT
@@ -73,12 +82,19 @@ signing_key:
 specification_version: 4
 summary: A simple configuration solution
 test_files:
-- spec/configue_spec.rb
+- spec/base_namespace_conf.rb
+- spec/configue/basic_spec.rb
+- spec/configue/namespace_spec.rb
 - spec/multiple_yaml/foo/baa.yml
 - spec/multiple_yaml/foo/bar/ding.yml
 - spec/multiple_yaml/foo/bar/tick.yml
 - spec/multiple_yaml/foo/pee.yml
 - spec/multiple_yaml_conf.rb
+- spec/namespace/base/pee/kaa/conf.yml
+- spec/namespace/dev/pee/kaa/conf.yml
+- spec/namespace/test/pee/kaa/conf.yml
+- spec/namespace_conf.rb
 - spec/single_yaml/conf.yml
 - spec/single_yaml_conf.rb
 - spec/spec_helper.rb
+- spec/support/inner_hash.rb

data/spec/configue_spec.rb

@@ -1,126 +0,0 @@
-# coding: utf-8
-require File.expand_path(File.dirname(__FILE__) + "/spec_helper")
-
-describe "Configue::Container" do
-  context "when reading a single yaml file" do
-    require "#{File.dirname(__FILE__)}/single_yaml_conf"
-
-    describe ".[]" do
-      context "when specifing the root keys in the yaml" do
-        it "returns a Hash value" do
-          expect(SingleYamlConf["foo"]).to be_a(Hash)
-          expect(SingleYamlConf["pee"]).to be_a(Hash)
-        end
-
-        describe "the Hash value (2nd level)" do
-          subject { SingleYamlConf["foo"] }
-
-          it "has keys described in the yaml" do
-            expect(subject).to have_key("baa")
-            expect(subject.keys.size).to be 1
-          end
-
-          describe "the Hash value (3rd level)" do
-            subject { SingleYamlConf["foo"]["baa"] }
-
-            it "has keys described in the yaml" do
-              expect(subject).to have_key("baz0")
-              expect(subject).to have_key("baz1")
-              expect(subject.keys.size).to be 2
-            end
-          end
-        end
-      end
-
-      context "when specifing the existing root key in symbol" do
-        it "returns a Hash value" do
-          expect(SingleYamlConf[:foo]).to be_a(Hash)
-          expect(SingleYamlConf[:pee]).to be_a(Hash)
-        end
-
-        describe "the Hash value" do
-          subject { SingleYamlConf[:foo] }
-
-          it "has a key described in the yaml" do
-            expect(subject).to have_key(:baa)
-            expect(subject.keys.size).to be 1
-          end
-
-          describe "the Hash value (3rd level)" do
-            subject { SingleYamlConf[:foo][:baa] }
-
-            it "has keys described in the yaml" do
-              expect(subject).to have_key(:baz0)
-              expect(subject).to have_key(:baz1)
-              expect(subject.keys.size).to be 2
-            end
-          end
-        end
-      end
-    end
-
-    describe ".(key)" do
-      context "when call a method which name is the root key in the yaml" do
-        it "returns a Hash value" do
-          expect(SingleYamlConf.foo).to be_a(Hash)
-          expect(SingleYamlConf.pee).to be_a(Hash)
-        end
-
-        describe "the Hash value (2nd level)" do
-          subject { SingleYamlConf.foo }
-
-          it "has methods which names are name of keys described in the yaml" do
-            expect(subject).to respond_to(:baa)
-          end
-
-          describe "the Hash value (3rd level)" do
-            subject { SingleYamlConf.foo.baa }
-
-            it "has methods which names are name of keys described in the yaml" do
-              expect(subject).to respond_to(:baz0)
-              expect(subject).to respond_to(:baz1)
-            end
-          end
-        end
-      end
-    end
-  end
-
-  context "when reading multiple yaml files" do
-    require "#{File.dirname(__FILE__)}/multiple_yaml_conf"
-
-    describe ".[]" do
-      context "when specifing the root keys in the yaml" do
-        it "return a Hash value" do
-          expect(MultipleYamlConf["foo"]).to be_a(Hash)
-        end
-
-        describe "the Hash value (2nd level)" do
-          subject { MultipleYamlConf["foo"] }
-
-          it "has keys described in the yaml files" do
-            expect(subject.keys).to match_array(["baa", "bar", "pee"])
-          end
-
-          describe "the Hash value (3rd level)" do
-            subject do
-              ["baa", "bar", "pee"].map {|k|
-                MultipleYamlConf["foo"][k]
-              }
-            end
-
-            it "has keys described in the yaml files" do
-              expect(subject[0]).to have_key("baz")
-
-              expect(subject[1]).to have_key("ding")
-              expect(subject[1]).to have_key("tick")
-
-              expect(subject[2]).to have_key("kaa")
-              expect(subject[2]).to have_key("boo")
-            end
-          end
-        end
-      end
-    end
-  end
-end