centroid 0.1.1 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 88cda261ba612223506881320d31fc55cef45946
-  data.tar.gz: d6fd6b798585da95fe94311ef96053c1451a0589
+  metadata.gz: f35b492a4ea8767187a77faae2f6b6bd5d5a66b6
+  data.tar.gz: 9fe53378ae98e8b4175dba7fe6af296e7fd9ad0d
 SHA512:
-  metadata.gz: d8faf1555e47cd66426de9f35cf4befacdaec03398d426bdeb9cdecf328417b286683e6df56c1b9409b74ec8ca7edf19a5063687facf93fecf5a9c40391c77f2
-  data.tar.gz: 5537aca1475d76f33b8b55d0220fb2fb679491229aa07683dc88ab0459bbe09f39497e1db67d21e79fcfd844655ac85d1831329b69e3f1a1aae962591a35ce01
+  metadata.gz: 7585bc76ed87101a41c3b46d7febd24f9fdefb4df32ed7bba4b5af60f15d6339f4a90d015d8a14a5aaa32b1d717a94af5acbc1a6ddd8410634fb6a07eaf87de0
+  data.tar.gz: fc57f08f83b93363132a68c6f866c9f5723834fd400c690d11a68776d826f5250f266eadc9a871e432f1f5fb5a92f3aed8e5ad91143113e054c4c86b7dcfdfda

data/README.md

@@ -1,91 +1,91 @@
-# Centroid - Ruby
-
-## Installation
-
-The Centroid Ruby package is hosted at [rubygems.org](https://rubygems.org/gems/centroid).
-
-You can install Centroid using gem with `gem install centroid`, or you can clone the repo, then `gem build centroid.gemspec`, and `gem install -l centroid` from the `ruby/` directory.
-
-## Usage
-
-Begin by declaring your application's configuration values in JSON. The following example stores the database's server address.
-
-```json
-{
-    "database": {
-        "serverAddress": "my-server.local"
-    }
-}
-```
-
-With Centroid's API, Ruby applications can then use the configuration values in this JSON.
-
-### Ruby API
-
-The Ruby API is available through the `Centroid::Config` class, an instance of which is used to consume the JSON.
-
-The `Config` class exposes the `from_file` class method, an initializer, and the instance method `for_environment`.
-
-#### from_file(filename)
-
-You can create an instance of `Config` from a JSON file using the `Centroid::Config.from_file(filename)` class method.
-
-In the example below, note the `serverAddress` configuration value is retrieved using the snake_case `server_address` method even though the value is specified as camelCase in the JSON.
-
-```rb
-# from_file.rb
-config = Centroid::Config.from_file("config.json")
-server = config.database.server_address # => "my-server.local"
-```
-
-### Config(json)
-
-Alternatively, you can create an instance of `Config` by passing a JSON string to the `Config` initializer.
-
-```rb
-# from_string.rb
-json = '{ "database": { "serverAddress": "my-server.local" } }'
-config = Centroid::Config(json)
-server = config.database.server_address # => "my-server.local"
-```
-
-### for_enviroment(environment)
-
-Typically, real-world applications have different configuration values depending on the environment. For example, you might have *dev* and *prod* environments that use different servers, user accounts, etc. However, applications usually have other configuration values that are the same across all environments. Centroid makes it easy to retrieve all the configuration values you need for a specific environment.
-
-In environment-based configuration, the top-level objects in the JSON represent the various environments. Place the configuration values that are the same across all environments within the *all* environment.
-
-```json
-{
-    "dev": {
-        "someResource": {
-            "server": "resource-dev.local"
-        }
-    },
-    "prod": {
-        "someResource": {
-            "server": "resource-prod.local"
-        }
-    },
-    "all": {
-        "keys": {
-            "ssh": "path/to/id_rsa.pub"
-        }
-    }
-}
-```
-
-Then, in the `Config` instance, use the instance method `for_environment` to retrieve the environment-based configuration. Centroid merges the requested environment's configuration values with the *all* environment configuration values.
-
-In the following example, the configuration for `prod` is merged with the configuration from `all`; the result is then available from a new instance of `Config`.
-
-```rb
-# for_enviroment.rb
-config = Centroid::Config.from_file("config.json").for_environment("prod")
-server = config.some_resource.server # => "resource-prod.local"
-solution_path = config.keys.ssh # => "path/to/id_rsa.pub"
-```
-
-## Contributing
-
-See the [contributing section of the main README](../README.md#contributing)
+# Centroid - Ruby
+
+## Installation
+
+The Centroid Ruby package is hosted at [rubygems.org](https://rubygems.org/gems/centroid).
+
+You can install Centroid using gem with `gem install centroid`, or you can clone the repo, then `gem build centroid.gemspec`, and `gem install -l centroid` from the `ruby/` directory.
+
+## Usage
+
+Begin by declaring your application's configuration values in JSON. The following example stores the database's server address.
+
+```json
+{
+    "database": {
+        "serverAddress": "my-server.local"
+    }
+}
+```
+
+With Centroid's API, Ruby applications can then use the configuration values in this JSON.
+
+### Ruby API
+
+The Ruby API is available through the `Centroid::Config` class, an instance of which is used to consume the JSON.
+
+The `Config` class exposes the `from_file` class method, an initializer, and the instance method `for_environment`.
+
+#### from_file(filename)
+
+You can create an instance of `Config` from a JSON file using the `Centroid::Config.from_file(filename)` class method.
+
+In the example below, note the `serverAddress` configuration value is retrieved using the snake_case `server_address` method even though the value is specified as camelCase in the JSON.
+
+```rb
+# from_file.rb
+config = Centroid::Config.from_file("config.json")
+server = config.database.server_address # => "my-server.local"
+```
+
+### Config(json)
+
+Alternatively, you can create an instance of `Config` by passing a JSON string to the `Config` initializer.
+
+```rb
+# from_string.rb
+json = '{ "database": { "serverAddress": "my-server.local" } }'
+config = Centroid::Config(json)
+server = config.database.server_address # => "my-server.local"
+```
+
+### for_enviroment(environment)
+
+Typically, real-world applications have different configuration values depending on the environment. For example, you might have *dev* and *prod* environments that use different servers, user accounts, etc. However, applications usually have other configuration values that are the same across all environments. Centroid makes it easy to retrieve all the configuration values you need for a specific environment.
+
+In environment-based configuration, the top-level objects in the JSON represent the various environments. Place the configuration values that are the same across all environments within the *all* environment.
+
+```json
+{
+    "dev": {
+        "someResource": {
+            "server": "resource-dev.local"
+        }
+    },
+    "prod": {
+        "someResource": {
+            "server": "resource-prod.local"
+        }
+    },
+    "all": {
+        "keys": {
+            "ssh": "path/to/id_rsa.pub"
+        }
+    }
+}
+```
+
+Then, in the `Config` instance, use the instance method `for_environment` to retrieve the environment-based configuration. Centroid merges the requested environment's configuration values with the *all* environment configuration values.
+
+In the following example, the configuration for `prod` is merged with the configuration from `all`; the result is then available from a new instance of `Config`.
+
+```rb
+# for_enviroment.rb
+config = Centroid::Config.from_file("config.json").for_environment("prod")
+server = config.some_resource.server # => "resource-prod.local"
+solution_path = config.keys.ssh # => "path/to/id_rsa.pub"
+```
+
+## Contributing
+
+See the [contributing section of the main README](../README.md#contributing)

data/centroid.gemspec

@@ -1,11 +1,11 @@
-Gem::Specification.new do |s|
-  s.name = 'centroid'
-  s.version = '0.1.1'
-  s.summary = 'A centralizaed paradigm to configuration management.'
-  s.description = 'Centroid is a tool for loading configuration values declared in JSON, and accessing those configuration values using object properties.'
-  s.author = 'Resource Data, Inc'
-  s.email = 'oss@resdat.com'
-  s.files = `git ls-files`.split("\n")
-  s.homepage = 'https://github.com/ResourceDataInc/Centroid'
-  s.license = 'MIT'
-end
+Gem::Specification.new do |s|
+  s.name = 'centroid'
+  s.version = '1.0.0'
+  s.summary = 'A centralizaed paradigm to configuration management.'
+  s.description = 'Centroid is a tool for loading configuration values declared in JSON, and accessing those configuration values using object properties.'
+  s.author = 'Resource Data, Inc'
+  s.email = 'oss@resdat.com'
+  s.files = `git ls-files`.split("\n")
+  s.homepage = 'https://github.com/ResourceDataInc/Centroid'
+  s.license = 'MIT'
+end

data/lib/centroid.rb

@@ -1,63 +1,76 @@
-require "json"
-
-module Centroid
-  class Config
-    attr_reader :raw_config
-
-    def initialize(config)
-      if config.is_a?(Hash)
-        @raw_config = config
-      else
-        @raw_config = JSON.parse(config)
-      end
-    end
-
-    def method_missing(attrib, *)
-      self[attrib]
-    end
-
-    def [](key)
-      value = find_value(key, raw_config)
-
-      raise Exception.new("Key not found in collection.") if value.nil?
-
-      if value.is_a?(Hash)
-        Config.new(value)
-      else
-        value
-      end
-    end
-
-    def to_s
-      JSON.dump(raw_config)
-    end
-
-    def for_environment(env)
-      env_json = raw_config[env]
-      all_key = actual_key("all", raw_config)
-      if all_key.nil?
-        Config.new(env_json)
-      else
-        all_json = raw_config[all_key]
-        Config.new(all_json.merge(env_json))
-      end
-    end
-
-    def self.from_file(filename)
-      str_json = File.read(filename)
-      self.new(str_json)
-    end
-
-    def normalised_key(unnormalised_key)
-      unnormalised_key.to_s.gsub("_", "").downcase
-    end
-
-    def find_value(key, hashtable)
-      hashtable[actual_key(key, hashtable)]
-    end
-
-    def actual_key(key, hashtable)
-      hashtable.keys.find { |k| normalised_key(key) == normalised_key(k) }
-    end
-  end
-end
+require "json"
+
+module Centroid
+  class Config
+    attr_reader :raw_config
+
+    def initialize(config)
+      if config.is_a?(Hash)
+        @raw_config = config
+      else
+        @raw_config = JSON.parse(config)
+        validate_unique_keys!
+      end
+    end
+
+    def method_missing(attrib, *)
+      self[attrib]
+    end
+
+    def [](key)
+      value = find_value(key, raw_config)
+
+      raise KeyError.new("Centroid::Config instance does not contain key: #{key}") if value.nil?
+
+      if value.is_a?(Hash)
+        Config.new(value)
+      else
+        value
+      end
+    end
+
+    def to_s
+      JSON.dump(raw_config)
+    end
+
+    def for_environment(env)
+      env_json = raw_config[env]
+      all_key = actual_key("all", raw_config)
+      if all_key.nil?
+        Config.new(env_json)
+      else
+        all_json = raw_config[all_key]
+        Config.new(all_json.merge(env_json))
+      end
+    end
+
+    def self.from_file(filename)
+      str_json = File.read(filename)
+      self.new(str_json)
+    end
+
+    private
+
+    def normalize_key(unnormalised_key)
+      unnormalised_key.to_s.gsub("_", "").downcase
+    end
+
+    def find_value(key, hashtable)
+      hashtable[actual_key(key, hashtable)]
+    end
+
+    def actual_key(key, hashtable)
+      hashtable.keys.find { |k| normalize_key(key) == normalize_key(k) }
+    end
+
+    def validate_unique_keys!
+      normalized_keys = raw_config.keys.map { |k| { key: k, normalized_key: normalize_key(k) } }
+      dups = normalized_keys.group_by { |nk| nk[:normalized_key] }.select { |_, g| g.size > 1 }
+
+      return if dups.empty?
+
+      keys = dups.values.flat_map { |d| d.map { |e| e[:key] } }
+      raise KeyError, "Centroid::Config instance contains duplicate keys: #{keys.join(', ')}"
+    end
+  end
+end

data/test/centroid_test.rb

@@ -1,71 +1,87 @@
-require_relative "../lib/centroid"
-require "test/unit"
-require "json"
-
-class ConfigTests < Test::Unit::TestCase
-  def json_config
-    '{"Environment":{"TheKey":"TheValue"}}'
-  end
-
-  def shared_file_path
-    'config.json'
-  end
-
-  def test_create_from_string
-    config = Centroid::Config.new(json_config)
-    assert_equal(config.environment.the_key, "TheValue")
-  end
-
-  def test_create_from_file
-    config = Centroid::Config.from_file(shared_file_path)
-    assert_equal(config.dev.database.server, "sqldev01.centroid.local")
-  end
-
-  def test_raises_if_key_not_found
-    config = Centroid::Config.new(json_config)
-    assert_raise Exception do
-      config = config.does_not_exist
-    end
-  end
-
-  def test_readable_using_snake_case_property
-    config = Centroid::Config.new(json_config)
-    assert_equal(config.environment.the_key, "TheValue")
-  end
-
-  def test_environment_specific_config_is_included
-    config = Centroid::Config.new(json_config)
-    environment_config = config.for_environment("Environment")
-    assert_equal(environment_config.the_key, "TheValue")
-  end
-
-  def test_shared_config_is_included
-    config = Centroid::Config.from_file(shared_file_path)
-    config = config.for_environment("Dev")
-    assert_equal(config.ci.repo, "https://github.com/ResourceDataInc/Centroid")
-  end
-
-  def test_to_string_returns_json
-    config = Centroid::Config.new(json_config)
-    assert_equal(config.to_s, json_config)
-  end
-
-  def test_iterating_raw_config
-    config = Centroid::Config.from_file(shared_file_path)
-    keyCount = 0
-    config.raw_config.each { |k| keyCount += 1 }
-    assert_equal(keyCount, 4)
-  end
-
-  def test_modifying_raw_config
-    config = Centroid::Config.new(json_config)
-    config.raw_config["Environment"]["TheKey"] = "NotTheValue"
-    assert_equal(config.environment.the_key, "NotTheValue")
-  end
-
-  def test_environment_specific_config_overrides_all
-    config = Centroid::Config.new('{"Prod": {"Shared": "production!"}, "All": {"Shared": "none"}}')
-    config = config.for_environment("Prod")
-    assert_equal(config.shared, "production!")
-  end
-end
+require_relative "../lib/centroid"
+require "test/unit"
+require "json"
+
+class ConfigTests < Test::Unit::TestCase
+  def json_config
+    '{"Environment":{"TheKey":"TheValue"}}'
+  end
+
+  def shared_file_path
+    'config.json'
+  end
+
+  def test_create_from_string
+    config = Centroid::Config.new(json_config)
+    assert_equal(config.environment.the_key, "TheValue")
+  end
+
+  def test_create_from_file
+    config = Centroid::Config.from_file(shared_file_path)
+    assert_equal(config.dev.database.server, "sqldev01.centroid.local")
+  end
+
+  def test_raises_if_key_not_found
+    config = Centroid::Config.new(json_config)
+
+    exception = assert_raise KeyError do
+      config = config.does_not_exist
+    end
+
+    assert exception.message =~ /does not contain/i, "Message should indicate key does not exist"
+    assert exception.message =~ /does_not_exist/, "Message should contain missing key"
+  end
+
+  def test_raises_if_duplicate_normalized_keys_exist
+    json = '{ "someKey": "value", "some_key": "value" }'
+
+    exception = assert_raise KeyError do
+      Centroid::Config.new(json)
+    end
+
+    assert exception.message =~ /duplicate/i, "Message should indicate duplicate key"
+    assert exception.message =~ /someKey/, "Message should contain duplicate key"
+    assert exception.message =~ /some_key/, "Message should contain duplicate key"
+  end
+
+  def test_readable_using_snake_case_property
+    config = Centroid::Config.new(json_config)
+    assert_equal(config.environment.the_key, "TheValue")
+  end
+
+  def test_environment_specific_config_is_included
+    config = Centroid::Config.new(json_config)
+    environment_config = config.for_environment("Environment")
+    assert_equal(environment_config.the_key, "TheValue")
+  end
+
+  def test_shared_config_is_included
+    config = Centroid::Config.from_file(shared_file_path)
+    config = config.for_environment("Dev")
+    assert_equal(config.ci.repo, "https://github.com/ResourceDataInc/Centroid")
+  end
+
+  def test_to_string_returns_json
+    config = Centroid::Config.new(json_config)
+    assert_equal(config.to_s, json_config)
+  end
+
+  def test_iterating_raw_config
+    config = Centroid::Config.from_file(shared_file_path)
+    keyCount = 0
+    config.raw_config.each { |k| keyCount += 1 }
+    assert_equal(keyCount, 4)
+  end
+
+  def test_modifying_raw_config
+    config = Centroid::Config.new(json_config)
+    config.raw_config["Environment"]["TheKey"] = "NotTheValue"
+    assert_equal(config.environment.the_key, "NotTheValue")
+  end
+
+  def test_environment_specific_config_overrides_all
+    config = Centroid::Config.new('{"Prod": {"Shared": "production!"}, "All": {"Shared": "none"}}')
+    config = config.for_environment("Prod")
+    assert_equal(config.shared, "production!")
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: centroid
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 1.0.0
 platform: ruby
 authors:
 - Resource Data, Inc
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-02-19 00:00:00.000000000 Z
+date: 2014-02-20 00:00:00.000000000 Z
 dependencies: []
 description: Centroid is a tool for loading configuration values declared in JSON,
   and accessing those configuration values using object properties.
@@ -31,17 +31,17 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.2.0
 signing_key: 
 specification_version: 4
 summary: A centralizaed paradigm to configuration management.