centroid 1.0.0 → 1.1.0.pre.alpha1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f35b492a4ea8767187a77faae2f6b6bd5d5a66b6
-  data.tar.gz: 9fe53378ae98e8b4175dba7fe6af296e7fd9ad0d
+  metadata.gz: 21355e7ed1634fc2fd8998d212c18bed7b14862a
+  data.tar.gz: c7a3f4b2e51a39f8f477de85f979d25afc2a4362
 SHA512:
-  metadata.gz: 7585bc76ed87101a41c3b46d7febd24f9fdefb4df32ed7bba4b5af60f15d6339f4a90d015d8a14a5aaa32b1d717a94af5acbc1a6ddd8410634fb6a07eaf87de0
-  data.tar.gz: fc57f08f83b93363132a68c6f866c9f5723834fd400c690d11a68776d826f5250f266eadc9a871e432f1f5fb5a92f3aed8e5ad91143113e054c4c86b7dcfdfda
+  metadata.gz: 9fb748e78951b7480633d6be39263e97040f4f7a0d5dbb72e14ac823bdeb68cd09cf3b615961d296d85bf5f45f6566b18fcc515a662b71d66453503dab343c44
+  data.tar.gz: 25bf6604d42caaa270a8fbf6cadbf6c4655937bc559dab9f0eaf2ca210432db6cee735ba1d091f3156083bb54f897f21d2a4c369f6353740d58427be5c3b26a2

data/README.md

@@ -1,36 +1,25 @@
 # 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
+This document includes information specific to Ruby in Centroid. Refer to the [Centroid document] (../README.md) for general information, including information the JSON configuration file. 
 
-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"
-    }
-}
-```
+## Installation
 
-With Centroid's API, Ruby applications can then use the configuration values in this JSON.
+The Centroid Ruby package is hosted at [rubygems.org](https://rubygems.org/gems/centroid). Install Centroid using gem with `gem install centroid` or clone the repo and then `gem build centroid.gemspec` and `gem install -l centroid` from the `ruby/` directory.
 
-### Ruby API
+## Config Class with Ruby
 
-The Ruby API is available through the `Centroid::Config` class, an instance of which is used to consume the JSON.
+In Ruby, the `Centroid::Config` class exposes the following: 
 
-The `Config` class exposes the `from_file` class method, an initializer, and the instance method `for_environment`.
++ Static `from_file` class method
++ Initializer
++ `for_environment` instance method
++ `has_key?` instance method
 
-#### from_file(filename)
+> *Note:* The examples given in the following sections are based on the JSON configuration file examples in the [Centroid document] (../README.md#examples). 
 
-You can create an instance of `Config` from a JSON file using the `Centroid::Config.from_file(filename)` class method.
+### from_file 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.
+Using the static `Centroid::Config.from_file(filename)` class method, you can create an instance of `Config` from a JSON file, as in the example below. 
 
 ```rb
 # from_file.rb
@@ -38,9 +27,9 @@ config = Centroid::Config.from_file("config.json")
 server = config.database.server_address # => "my-server.local"
 ```
 
-### Config(json)
+### Config Initializer
 
-Alternatively, you can create an instance of `Config` by passing a JSON string to the `Config` initializer.
+To load a string instead of a file, create an instance of `Config` by passing a JSON string to the `Config` initializer, as in the following example.
 
 ```rb
 # from_string.rb
@@ -49,35 +38,13 @@ 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"
-        }
-    }
-}
-```
+### for_environment Instance Method
+
+In the `Config` instance, you can use the `for_environment` instance method to retrieve the configuration values for an environment. 
 
-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.
+If you specify an environment in `for_environment`, Centroid will merge the requested environment's configuration values with the values in *all*. Refer to [Examples in the Centroid document] (../README.md#examples) for information on creating an environment-based JSON configuration file. 
 
-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`.
+With the following example, Centroid will merge the configuration for *prod* with the configuration for *all*; the result is then available from a new instance of `Config`.
 
 ```rb
 # for_enviroment.rb
@@ -86,6 +53,13 @@ server = config.some_resource.server # => "resource-prod.local"
 solution_path = config.keys.ssh # => "path/to/id_rsa.pub"
 ```
 
-## Contributing
+### has_key? Instance Method
 
-See the [contributing section of the main README](../README.md#contributing)
+In a `Config` instance, you can use the `has_key?` method to determine if a key exists. `has_key?` is also aliased as `include?`. These methods use the same case and underscore rules as is used for value lookups.
+
+```rb
+json = '{ "database": { "serverAddress": "my-server.local" } }'
+config = Centroid::Config(json)
+config.has_key?(:database) # => true
+config.include?("DoesNotExist") # => false
+```

data/centroid.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name = 'centroid'
-  s.version = '1.0.0'
+  s.version = '1.1.0-alpha1'
   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'

data/lib/centroid.rb

@@ -17,10 +17,14 @@ module Centroid
       self[attrib]
     end
 
+    def respond_to_missing?(method_name, include_all)
+      has_key?(method_name)
+    end
+
     def [](key)
-      value = find_value(key, raw_config)
+      raise KeyError.new("Centroid::Config instance does not contain key: #{key}") unless has_key?(key)
 
-      raise KeyError.new("Centroid::Config instance does not contain key: #{key}") if value.nil?
+      value = find_value(key)
 
       if value.is_a?(Hash)
         Config.new(value)
@@ -29,18 +33,24 @@ module Centroid
       end
     end
 
+    def has_key?(key)
+      !!actual_key(key)
+    end
+
+    alias_method :include?, :has_key?
+
     def to_s
       JSON.dump(raw_config)
     end
 
     def for_environment(env)
       env_json = raw_config[env]
-      all_key = actual_key("all", raw_config)
+      all_key = actual_key("all")
       if all_key.nil?
         Config.new(env_json)
       else
         all_json = raw_config[all_key]
-        Config.new(all_json.merge(env_json))
+        Config.new(deep_merge(all_json, env_json))
       end
     end
 
@@ -55,12 +65,12 @@ module Centroid
       unnormalised_key.to_s.gsub("_", "").downcase
     end
 
-    def find_value(key, hashtable)
-      hashtable[actual_key(key, hashtable)]
+    def find_value(key)
+      raw_config[actual_key(key)]
     end
 
-    def actual_key(key, hashtable)
-      hashtable.keys.find { |k| normalize_key(key) == normalize_key(k) }
+    def actual_key(key)
+      raw_config.keys.find { |k| normalize_key(key) == normalize_key(k) }
     end
 
     def validate_unique_keys!
@@ -72,5 +82,20 @@ module Centroid
       keys = dups.values.flat_map { |d| d.map { |e| e[:key] } }
       raise KeyError, "Centroid::Config instance contains duplicate keys: #{keys.join(', ')}"
     end
+
+    def deep_merge(left, right)
+      return right if not right.is_a?(Hash)
+
+      right.each_pair do |k, rv|
+        lv = left[k]
+        left[k] = if lv.is_a?(Hash) && rv.is_a?(Hash)
+          deep_merge(lv, rv)
+        else
+          rv
+        end
+      end
+
+      left
+    end
   end
 end

data/test/centroid_test.rb

@@ -84,4 +84,33 @@ class ConfigTests < Test::Unit::TestCase
     config = config.for_environment("Prod")
     assert_equal(config.shared, "production!")
   end
+
+  def test_all_environment_is_not_case_sensitive
+    config = Centroid::Config.new('{"Prod": {"Shared": "production!"}, "All": {"Shared": "none", "AllOnly": "works"}}')
+    config = config.for_environment("Prod")
+    assert_equal(config.all_only, "works")
+
+    config = Centroid::Config.new('{"Prod": {"Shared": "production!"}, "all": {"Shared": "none", "AllOnly": "works"}}')
+    config = config.for_environment("Prod")
+    assert_equal(config.all_only, "works")
+  end
+
+  def test_supports_deep_merge
+    config = Centroid::Config.new('{"Prod": {"Database": {"Server": "prod-sql"}}, "All": {"Database": {"MigrationsPath": "path/to/migrations"}}}')
+    config = config.for_environment("Prod")
+    assert_equal(config.database.server, "prod-sql")
+    assert_equal(config.database.migrations_path, "path/to/migrations")
+  end
+
+  def test_has_key
+    config = Centroid::Config.new(json_config)
+    assert(config.has_key?("environment"))
+    assert(!config.has_key?("does_not_exist"))
+  end
+
+  def test_respond_to
+    config = Centroid::Config.new(json_config)
+    assert(config.respond_to?(:environment))
+    assert(!config.respond_to?(:does_not_exist))
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: centroid
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0.pre.alpha1
 platform: ruby
 authors:
 - Resource Data, Inc
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-02-20 00:00:00.000000000 Z
+date: 2014-06-30 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.
@@ -36,12 +36,12 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.0
+rubygems_version: 2.3.0
 signing_key: 
 specification_version: 4
 summary: A centralizaed paradigm to configuration management.