config_volumizer 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 51fccd17634bc4c6605169c3f0aaa1552ed7e09b
-  data.tar.gz: 7eedb6855853b5e3e643bfd95dc4286b4ef6a654
+  metadata.gz: 10a449433b7b4ca3479a4c362f276f9b74a07836
+  data.tar.gz: 7330a1c32aed1e002d9d8d748b2af31989815925
 SHA512:
-  metadata.gz: a451d91280f236cbc6fc3442f1be856542d5042f7ba1113fb4996a78f11b44a4f121c342edcb76138eea9459dffb553c71638b65ad7bf5b64acbfd56285fce6c
-  data.tar.gz: 493db1a62e270c7f0d01c4ca2545b85f9e38c33760ae6b3f4b24466210beff9dfda2625939bad0eed7dbdb058a869df008247017d97de59496058b326de97109
+  metadata.gz: f175ab8adcbc7da7d5da1b8af4c8d91838a4a07c03b9ad14fa2c40a6f8dcc6306b90928ce3fe29c34136c299a1bd6be60ca580f6582d56e8ca040d4903bbf6f1
+  data.tar.gz: 0d8b1f5b36cfef85ed2cae3a9c36857afa4f4b838271b3a36838306690b067c47936a1376f195f929aceca59ea12657337ac8b95e6043debc9d2faa6adfb706e

data/ChangeLog.md

@@ -1,4 +1,5 @@
-### 0.1.0 / 2015-04-03
+### 0.2.0 / 2015-04-03
 
 * Initial release:
-
+ - Implements parsing
+ - Implements generation

data/README.md

@@ -46,9 +46,55 @@ ConfigVolumizer.parse(ENV, 'some')
 
 ## Features
 
-The gem basically smartly parses all keys within the passed in Hash that match the prefix specified.
+### Parsing
 
-It allows to nest either arrays or hashes inside eachother, basically any reasonable combination of hash/array notation should work.
+You can parse a flattened config via `ConfigVolumizer.parse(ENV, 'some')`
+
+For example if your ENV was:
+
+```
+some.setting[0] = one
+some.setting[1] = two
+some.setting[2] = three
+some.with.another = setting
+```
+
+This would yield a {Hash} like the following:
+
+```yaml
+some:
+  setting:
+    - one
+    - two
+    - three
+  with:
+    another: setting
+```
+
+### Generation
+
+You can generate a flat list of configs (mostly as examples for your actual config) via:
+`ConfigVolumizer.generate(data_hash)`
+
+For example, given a hash simillar to:
+```yaml
+some:
+  setting:
+    - one
+    - two
+    - three
+  with:
+    another: setting
+```
+
+You would get back a hash looking like this:
+
+```yaml
+"some.setting[0]": one
+"some.setting[1]": two
+"some.setting[2]": three
+"some.with.another": setting
+```
 
 ## Install
 

data/lib/config_volumizer/generator.rb

@@ -0,0 +1,37 @@
+module ConfigVolumizer
+
+  # Converts a {Hash} into a flattened {Hash} as a template for volumizing your configs
+  module Generator
+    class << self
+
+      # Generates a flattened config out of a data hash
+      #
+      # See Readme for an example
+      #
+      # @param [Hash] data
+      # @return [Hash]
+      def generate(data)
+        data.inject({}) do |result, (key, value)|
+          process_item(result, key, value)
+          result
+        end
+      end
+
+      def process_item(result, prefix, value)
+        case value
+        when Array
+          value.each_with_index do |item, index|
+            process_item(result, "#{prefix}[#{index}]", item)
+          end
+        when Hash
+          value.each do |key, item|
+            process_item(result, "#{prefix}.#{key}", item)
+          end
+        else
+          result[prefix] = value
+        end
+      end
+
+    end
+  end
+end

data/lib/config_volumizer/parser.rb

@@ -6,6 +6,14 @@ module ConfigVolumizer
 
     class << self
 
+      # Parses keys within the {source} hash matching {base_name}
+      # returning a hash with all the matched data under a string key matching the {base_name}
+      #
+      # See Readme for an example
+      #
+      # @param [Hash] source
+      # @param [String] base_name
+      # @return [Hash]
       def parse(source, base_name)
         result = {}
         source.each do |key, value|

data/lib/config_volumizer/version.rb

@@ -1,4 +1,3 @@
 module ConfigVolumizer
-  # config_volumizer version
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/lib/config_volumizer.rb

@@ -1,12 +1,31 @@
 require 'config_volumizer/version'
 require 'config_volumizer/parser'
+require 'config_volumizer/generator'
 
 module ConfigVolumizer
   class << self
 
+    # Parses keys within the {source} hash matching {base_name}
+    # returning a hash with all the matched data under a string key matching the {base_name}
+    #
+    # @see ConfigVolumizer::Parser.parse
+    #
+    # @param [Hash] source
+    # @param [String] base_name
+    # @return [Hash]
     def parse(source, base_name)
       Parser.parse(source, base_name)
     end
 
+    # Generates a flattened config out of a data hash
+    #
+    # @see ConfigVolumizer::Generator.generate
+    #
+    # @param [Hash] data
+    # @return [Hash]
+    def generate(data)
+      Generator.generate(data)
+    end
+
   end
 end

data/spec/config_volumizer_spec.rb

@@ -1,224 +1,225 @@
 require 'spec_helper'
 
 describe ConfigVolumizer do
-  let(:key) { 'ex' }
-  let(:result) { described_class.parse(input, key) }
-
-  describe "1 level hash" do
-    let(:input) { { "ex" => "1a" } }
-    let(:expected_result) { { 'ex' => '1a' } }
-
-    example do
-      expect(result).to eq(expected_result)
-    end
-  end
-
-  describe "2 level hash" do
-    let(:key) { 'ex1' }
-    let(:input) do
-      {
-        "ex1.bar" => "1a",
-        "ex1.bar2" => "2a",
-      }
-    end
-    let(:expected_result) do
-      {
-        'ex1' => {
-          'bar' => '1a',
-          'bar2' => '2a',
-        },
-      }
-    end
-
-    example do
-      expect(result).to eq(expected_result)
-    end
-  end
-
-  describe "3 level hash" do
-    let(:key) { 'ex3' }
-    let(:input) do
-      {
-        "ex3.one.two" => "1a",
-        "ex3.one.three" => "2a",
-        "ex3.two.three" => "3a",
-      }
-    end
-    let(:expected_result) do
-      {
-        'ex3' => {
-          'one' => {
-            'two' => '1a',
-            'three' => '2a',
+  describe '.parse' do
+    let(:key) { 'ex' }
+    let(:result) { described_class.parse(input, key) }
+
+    describe "1 level hash" do
+      let(:input) { { "ex" => "1a" } }
+      let(:expected_result) { { 'ex' => '1a' } }
+
+      example do
+        expect(result).to eq(expected_result)
+      end
+    end
+
+    describe "2 level hash" do
+      let(:key) { 'ex1' }
+      let(:input) do
+        {
+          "ex1.bar" => "1a",
+          "ex1.bar2" => "2a",
+        }
+      end
+      let(:expected_result) do
+        {
+          'ex1' => {
+            'bar' => '1a',
+            'bar2' => '2a',
           },
-          'two' => {
-            'three' => '3a',
-          },
-        },
-      }
-    end
-
-    example do
-      expect(result).to eq(expected_result)
-    end
-  end
-
-  describe "array of values in hash" do
-    let(:input) do
-      {
-        "ex.one[0]" => "1a",
-        "ex.one[1]" => "2a",
-      }
-    end
-    let(:expected_result) do
-      {
-        'ex' => { 'one' => ['1a', '2a'] }
-      }
-    end
-
-    example do
-      expect(result).to eq(expected_result)
-    end
-  end
-
-  describe "just array of values" do
-    let(:input) do
-      {
-        "ex[0]" => "1a",
-        "ex[1]" => "2a",
-      }
-    end
-    let(:expected_result) do
-      {
-        'ex' => ['1a', '2a']
-      }
-    end
-
-    example do
-      expect(result).to eq(expected_result)
-    end
-  end
-
-  describe "array of hashes" do
-    let(:input) do
-      {
-        "ex[0].foo" => "1a",
-        "ex[0].bar" => "2a",
-        "ex[1].foo" => "3a",
-      }
-    end
-    let(:expected_result) do
-      {
-        'ex' => [
-          { 'foo' => '1a', 'bar' => '2a' },
-          { 'foo' => '3a' },
-        ]
-      }
-    end
-
-    example do
-      expect(result).to eq(expected_result)
-    end
-  end
-
-  describe "array of hash in hash" do
-    let(:key) { 'ex2' }
-    let(:input) do
-      {
-        "ex2.one[0].foo" => "1a",
-        "ex2.one[0].bar" => "2a",
-        "ex2.one[1].foo" => "3a",
-      }
-    end
-    let(:expected_result) do
-      {
-        'ex2' => {
-          'one' => [
-            {
-              "foo" => '1a',
-              "bar" => '2a',
+        }
+      end
+
+      example do
+        expect(result).to eq(expected_result)
+      end
+    end
+
+    describe "3 level hash" do
+      let(:key) { 'ex3' }
+      let(:input) do
+        {
+          "ex3.one.two" => "1a",
+          "ex3.one.three" => "2a",
+          "ex3.two.three" => "3a",
+        }
+      end
+      let(:expected_result) do
+        {
+          'ex3' => {
+            'one' => {
+              'two' => '1a',
+              'three' => '2a',
             },
-            {
-              "foo" => '3a',
-            }
-          ],
-        },
-      }
-    end
-
-    example do
-      expect(result).to eq(expected_result)
-    end
-  end
-
-  describe "empty hash value" do
-    let(:input) { { "ex" => "{}", } }
-    let(:expected_result) { { 'ex' => {} } }
-
-    example do
-      expect(result).to eq(expected_result)
-    end
-  end
-
-  describe "empty array value" do
-    let(:input) { { "ex" => "[]", } }
-    let(:expected_result) { { 'ex' => [] } }
-
-    example do
-      expect(result).to eq(expected_result)
-    end
-  end
-
-  describe "2d arrays" do
-    let(:input) do
-      {
-        "ex[0][0]" => "1a",
-        "ex[0][1]" => "2a",
-        "ex[1][0]" => "3a",
-        "ex[1][1]" => "4a",
-      }
-    end
-    let(:expected_result) do
-      {
-        'ex' => [
-          ['1a', '2a'],
-          ['3a', '4a']
-        ]
-      }
-    end
-
-    example do
-      expect(result).to eq(expected_result)
-    end
-  end
-
-  describe "3d arrays" do
-    let(:input) do
-      {
-        'ex[0][0][1]' => "1a",
-        'ex[0][1][0]' => "2a",
-        'ex[1][0][1]' => "3a",
-        'ex[1][1][0]' => "4a",
-      }
-    end
-    let(:expected_result) do
-      {
-        'ex' => [
-          [
-            [nil, '1a'],
-            ['2a'],
-          ],
-          [
-            [nil, '3a'],
-            ['4a'],
+            'two' => {
+              'three' => '3a',
+            },
+          },
+        }
+      end
+
+      example do
+        expect(result).to eq(expected_result)
+      end
+    end
+
+    describe "array of values in hash" do
+      let(:input) do
+        {
+          "ex.one[0]" => "1a",
+          "ex.one[1]" => "2a",
+        }
+      end
+      let(:expected_result) do
+        {
+          'ex' => { 'one' => ['1a', '2a'] }
+        }
+      end
+
+      example do
+        expect(result).to eq(expected_result)
+      end
+    end
+
+    describe "just array of values" do
+      let(:input) do
+        {
+          "ex[0]" => "1a",
+          "ex[1]" => "2a",
+        }
+      end
+      let(:expected_result) do
+        {
+          'ex' => ['1a', '2a']
+        }
+      end
+
+      example do
+        expect(result).to eq(expected_result)
+      end
+    end
+
+    describe "array of hashes" do
+      let(:input) do
+        {
+          "ex[0].foo" => "1a",
+          "ex[0].bar" => "2a",
+          "ex[1].foo" => "3a",
+        }
+      end
+      let(:expected_result) do
+        {
+          'ex' => [
+            { 'foo' => '1a', 'bar' => '2a' },
+            { 'foo' => '3a' },
           ]
-        ]
-      }
-    end
+        }
+      end
+
+      example do
+        expect(result).to eq(expected_result)
+      end
+    end
+
+    describe "array of hash in hash" do
+      let(:key) { 'ex2' }
+      let(:input) do
+        {
+          "ex2.one[0].foo" => "1a",
+          "ex2.one[0].bar" => "2a",
+          "ex2.one[1].foo" => "3a",
+        }
+      end
+      let(:expected_result) do
+        {
+          'ex2' => {
+            'one' => [
+              {
+                "foo" => '1a',
+                "bar" => '2a',
+              },
+              {
+                "foo" => '3a',
+              }
+            ],
+          },
+        }
+      end
+
+      example do
+        expect(result).to eq(expected_result)
+      end
+    end
+
+    describe "empty hash value" do
+      let(:input) { { "ex" => "{}", } }
+      let(:expected_result) { { 'ex' => {} } }
+
+      example do
+        expect(result).to eq(expected_result)
+      end
+    end
+
+    describe "empty array value" do
+      let(:input) { { "ex" => "[]", } }
+      let(:expected_result) { { 'ex' => [] } }
+
+      example do
+        expect(result).to eq(expected_result)
+      end
+    end
+
+    describe "2d arrays" do
+      let(:input) do
+        {
+          "ex[0][0]" => "1a",
+          "ex[0][1]" => "2a",
+          "ex[1][0]" => "3a",
+          "ex[1][1]" => "4a",
+        }
+      end
+      let(:expected_result) do
+        {
+          'ex' => [
+            ['1a', '2a'],
+            ['3a', '4a']
+          ]
+        }
+      end
+
+      example do
+        expect(result).to eq(expected_result)
+      end
+    end
+
+    describe "3d arrays" do
+      let(:input) do
+        {
+          'ex[0][0][1]' => "1a",
+          'ex[0][1][0]' => "2a",
+          'ex[1][0][1]' => "3a",
+          'ex[1][1][0]' => "4a",
+        }
+      end
+      let(:expected_result) do
+        {
+          'ex' => [
+            [
+              [nil, '1a'],
+              ['2a'],
+            ],
+            [
+              [nil, '3a'],
+              ['4a'],
+            ]
+          ]
+        }
+      end
 
-    example do
-      expect(result).to eq(expected_result)
+      example do
+        expect(result).to eq(expected_result)
+      end
     end
   end
-
 end

data/spec/generator_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe ConfigVolumizer do
+  describe '.generate' do
+    example do
+      data = {
+        "one" => "two",
+        "three" => {
+          "four" => "five",
+          "six" => [
+            "seven",
+            "eight",
+          ]
+        }
+      }
+      expected_data = {
+        "one" => "two",
+        "three.four" => "five",
+        "three.six[0]" => "seven",
+        "three.six[1]" => "eight",
+      }
+      expect(described_class.generate(data)).to eq(expected_data)
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: config_volumizer
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Piotr Banasik
@@ -28,9 +28,11 @@ files:
 - Rakefile
 - config_volumizer.gemspec
 - lib/config_volumizer.rb
+- lib/config_volumizer/generator.rb
 - lib/config_volumizer/parser.rb
 - lib/config_volumizer/version.rb
 - spec/config_volumizer_spec.rb
+- spec/generator_spec.rb
 - spec/spec_helper.rb
 homepage: https://rubygems.org/gems/config_volumizer
 licenses:
@@ -58,4 +60,5 @@ specification_version: 4
 summary: Adds volume to an otherwise flat config
 test_files:
 - spec/config_volumizer_spec.rb
+- spec/generator_spec.rb
 - spec/spec_helper.rb