config_volumizer 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 10a449433b7b4ca3479a4c362f276f9b74a07836
-  data.tar.gz: 7330a1c32aed1e002d9d8d748b2af31989815925
+  metadata.gz: bc9530cd3c91c5a4fe838039cb30de8a14830e4f
+  data.tar.gz: 55016643bfc942b257bb0697bc033dde16befae7
 SHA512:
-  metadata.gz: f175ab8adcbc7da7d5da1b8af4c8d91838a4a07c03b9ad14fa2c40a6f8dcc6306b90928ce3fe29c34136c299a1bd6be60ca580f6582d56e8ca040d4903bbf6f1
-  data.tar.gz: 0d8b1f5b36cfef85ed2cae3a9c36857afa4f4b838271b3a36838306690b067c47936a1376f195f929aceca59ea12657337ac8b95e6043debc9d2faa6adfb706e
+  metadata.gz: 4ea31fbd58d7f9067f0de317969777793669c210b50f41b45d08cfa32d6eccb9c2e98368f9964a0441f496ccb66c950b3fb9c2c2dcd131e548ef594421b85ed3
+  data.tar.gz: ba803bd708d6c13b5bc2426269f40a880a28aef3da8c1dbd7865eb766d1f235990bc12d110b7b1bd3707bf58e039c3e973c729aba17cd63cc14258938a67ab10

data/.coveralls.yml

@@ -0,0 +1 @@
+repo_token: Ra3YeFoOEOvZbWACZz5hRTUbqRq4Uewi9

data/Gemfile

@@ -2,13 +2,17 @@ source 'https://rubygems.org'
 
 gemspec
 
-group :development do
+group :development, :test do
+  gem 'awesome_print'
   gem 'kramdown'
   gem 'bundler'
   gem 'rake'
   gem 'rspec'
   gem 'rubygems-tasks'
+  gem 'github_changelog_generator'
   gem 'yard'
   gem 'flay'
   gem 'flog'
+
+  gem 'coveralls', require: false
 end

data/README.md

@@ -2,6 +2,8 @@
 
 [![Build Status](https://travis-ci.org/payrollhero/config_volumizer.svg)](https://travis-ci.org/payrollhero/config_volumizer)
 [![Code Climate](https://codeclimate.com/github/payrollhero/config_volumizer/badges/gpa.svg)](https://codeclimate.com/github/payrollhero/config_volumizer)
+[![Coverage Status](https://coveralls.io/repos/payrollhero/config_volumizer/badge.svg?branch=master)](https://coveralls.io/r/payrollhero/config_volumizer?branch=master)
+[![Dependency Status](https://gemnasium.com/payrollhero/config_volumizer.svg)](https://gemnasium.com/payrollhero/config_volumizer)
 
 * [Homepage](https://rubygems.org/gems/config_volumizer)
 * [Documentation](http://rubydoc.info/gems/config_volumizer/frames)
@@ -32,31 +34,40 @@ some:
 info a series of ENV variables like so:
 
 ```
-some.setting[0] = one
-some.setting[1] = two
-some.setting[2] = three
-some.with.another = setting
+some_setting = one,two,three
+some_with_another = setting
 ```
 
 ... and then just give it some volume with the volumizer to turn it back to the original rich structure
 
 ```ruby
-ConfigVolumizer.parse(ENV, 'some')
+mapping = { "some" => { "setting" => :value, "with" => { "another" => :value } } }
+ConfigVolumizer.parse(ENV, 'some', mapping)
 ```
 
 ## Features
 
 ### Parsing
 
-You can parse a flattened config via `ConfigVolumizer.parse(ENV, 'some')`
+You can parse a flattened config via `ConfigVolumizer.parse(ENV, 'some', mapping)`
 
 For example if your ENV was:
 
 ```
-some.setting[0] = one
-some.setting[1] = two
-some.setting[2] = three
-some.with.another = setting
+some_setting = one,two,three
+some_with_another = setting
+```
+
+And you created a map like so:
+```ruby
+mapping = {
+  "some" => {
+    "setting" => :value,
+    "with" => {
+      "another" => :value
+    }
+  }
+}
 ```
 
 This would yield a {Hash} like the following:
@@ -87,13 +98,48 @@ some:
     another: setting
 ```
 
-You would get back a hash looking like this:
+You would get back the data and mapping looking like this:
+
+```yaml
+some:
+  setting: :value
+  with:
+    another: :value
+```
 
 ```yaml
-"some.setting[0]": one
-"some.setting[1]": two
-"some.setting[2]": three
-"some.with.another": setting
+"some_setting": one,two,three
+"some_with_another": setting
+```
+
+## Deployment
+
+In order to deploy a new version of the gem into the wild ...
+
+You will need to configure your github api token for the changelog.
+
+Generate a new token for changelogs [here](https://github.com/settings/tokens/new).
+
+add:
+
+```bash
+export CHANGELOG_GITHUB_TOKEN=YOUR_CHANGELOG_API_TOKEN
+```
+
+somewhere in your shell init. (ie .zshrc or simillar)
+
+
+```bash
+vim lib/config_volumizer/version.rb
+# set the new version
+# commit the changed version file
+# name your commit with the version number eg: "1.8.0"
+rake release
+# to push the gem to rubygems.org
+rake changelog
+# commit the changed changelog
+# name your commit with the version again eg: "changelog for 1.8.0"
+git push
 ```
 
 ## Install

data/Rakefile

@@ -32,3 +32,8 @@ task :default => :spec
 require 'yard'
 YARD::Rake::YardocTask.new  
 task :doc => :yard
+
+desc "Updates the changelog"
+task :changelog do
+  sh "github_changelog_generator payrollhero/dispatch-rider"
+end

data/lib/config_volumizer/generator.rb

@@ -1,3 +1,4 @@
+require 'ostruct'
 module ConfigVolumizer
 
   # Converts a {Hash} into a flattened {Hash} as a template for volumizing your configs
@@ -11,21 +12,56 @@ module ConfigVolumizer
       # @param [Hash] data
       # @return [Hash]
       def generate(data)
+        OpenStruct.new(
+          env_hash: generate_env(data),
+          mapping_hash: generate_mapping(data),
+        )
+      end
+
+      private
+
+      def generate_env(data)
+        data.inject({}) do |result, (key, value)|
+          process_env_item(result, key, value)
+          result
+        end
+      end
+
+      def generate_mapping(data)
         data.inject({}) do |result, (key, value)|
-          process_item(result, key, value)
+          result[key] = process_mapping_item(value)
+          result
+        end
+      end
+
+      def process_mapping_item(value)
+        case value
+        when Array
+          result = []
+          value.each_with_index do |item, index|
+            result[index] = process_mapping_item(item)
+          end
+          result.uniq
+        when Hash
+          result = {}
+          value.each do |key, item|
+            result[key] = process_mapping_item(item)
+          end
           result
+        else
+          :value
         end
       end
 
-      def process_item(result, prefix, value)
+      def process_env_item(result, prefix, value)
         case value
         when Array
           value.each_with_index do |item, index|
-            process_item(result, "#{prefix}[#{index}]", item)
+            process_env_item(result, "#{prefix}_#{index}", item)
           end
         when Hash
           value.each do |key, item|
-            process_item(result, "#{prefix}.#{key}", item)
+            process_env_item(result, "#{prefix}_#{key}", item)
           end
         else
           result[prefix] = value

data/lib/config_volumizer/parser.rb

@@ -1,5 +1,6 @@
 require 'strscan'
 require 'yaml'
+require 'csv'
 
 module ConfigVolumizer
   module Parser
@@ -13,13 +14,15 @@ module ConfigVolumizer
       #
       # @param [Hash] source
       # @param [String] base_name
+      # @param [Hash] mapping
       # @return [Hash]
-      def parse(source, base_name)
+      def parse(source, mapping)
         result = {}
-        source.each do |key, value|
-          if matches_name(base_name, key)
-            fragments = key.gsub(/^#{base_name}/, '')
-            handle_item(result, base_name, fragments, value)
+        mapping.each do |mapping_key, mapping_info|
+          source.each do |key, value|
+            if matches_name(mapping_key, key)
+              handle_item(result, key, value, mapping_key, mapping_info)
+            end
           end
         end
         result
@@ -28,61 +31,63 @@ module ConfigVolumizer
       private
 
       def matches_name(base_name, key)
-        key == base_name || key =~ /^#{base_name}([.\[])/
+        key == base_name || key =~ /^#{base_name}_/
       end
 
       def format_value(value)
         YAML.load(value)
       end
 
-      def initialize_array(result, key)
-        validate_result_key_kind(result, key, Array)
-        result[key] ||= []
+      def format_array_value(value)
+        CSV.parse_line(value).map { |inner_value| format_value(inner_value) }
       end
 
-      def initialize_hash(result, key)
-        validate_result_key_kind(result, key, Hash)
-        result[key] ||= {}
-      end
-
-      def validate_result_key_kind(result, key, kind)
-        if result[key] && !result[key].kind_of?(kind)
-          raise ArgumentError, "referencing #{kind} key #{name} when its already a #{result[key].class}"
-        end
-      end
-
-      def handle_item(result, base_name, name, value)
-        dst, key = result, base_name
-        scanner = StringScanner.new(name)
-
-        until scanner.eos?
-          dst, key = case next_fragment(scanner)
-                     when /^\.(.+)/
-                       handle_hash($~, dst, key)
-                     when /\[(\d+)\]/
-                       handle_array($~, dst, key)
-                     end
+      def handle_item(result, name, value, mapping_key, mapping_info)
+        case mapping_info
+        when Array
+          handle_array_item(mapping_info, mapping_key, name, result, value)
+        when Hash
+          handle_hash_item(mapping_info, mapping_key, name, result, value)
+        when :value
+          result[mapping_key] = format_value(value)
+        when :hash
+          new_name = name.gsub(/^#{mapping_key}_/, '')
+          result[mapping_key] ||= {}
+          result[mapping_key][new_name] = format_value(value)
+        else
+          raise ArgumentError, "don't know how to deal with #{mapping_info.inspect}"
         end
 
-        dst[key] = format_value(value)
       end
 
-      def handle_array(match, dst, key)
-        index = match[1].to_i
-        initialize_array(dst, key)
-        return dst[key], index
+      def handle_hash_item(mapping_info, mapping_key, name, result, value)
+        result[mapping_key] ||= {}
+        new_name = name.gsub(/^#{mapping_key}_/, '')
+        mapping_info.each do |inner_mapping_key, inner_mapping_info|
+          if matches_name(inner_mapping_key, new_name)
+            handle_item(result[mapping_key], new_name, value, inner_mapping_key, inner_mapping_info)
+          end
+        end
       end
 
-      def handle_hash(match, dst, key)
-        hash_key = match[1]
-        initialize_hash(dst, key)
-        return dst[key], hash_key
+      def handle_array_item(mapping_info, mapping_key, name, result, value)
+        result[mapping_key] ||= []
+        mapping_info.each do |inner_mapping_info|
+          case inner_mapping_info
+          when :value
+            result[mapping_key] += format_array_value(value)
+          when :hash, Hash
+            handle_array_hash_item(inner_mapping_info, mapping_key, name, result, value)
+          else
+            raise "don't know how to handle: #{inner_mapping_info.inspect}"
+          end
+        end
       end
 
-      def next_fragment(scanner)
-        fragment = scanner.scan /\.[^.\[]+|\[\d+\]/
-        raise "failed: rest: #{scanner.rest} inside #{scanner.string}" unless fragment
-        fragment
+      def handle_array_hash_item(inner_mapping_info, mapping_key, name, result, value)
+        new_name = name.gsub(/^#{mapping_key}_(\d+)(?:_)?/, '')
+        index = $~[1].to_i
+        handle_item(result[mapping_key], new_name, value, index, inner_mapping_info)
       end
 
     end

data/lib/config_volumizer/version.rb

@@ -1,3 +1,3 @@
 module ConfigVolumizer
-  VERSION = "0.2.0"
+  VERSION = "0.3.0"
 end

data/lib/config_volumizer.rb

@@ -13,8 +13,8 @@ module ConfigVolumizer
     # @param [Hash] source
     # @param [String] base_name
     # @return [Hash]
-    def parse(source, base_name)
-      Parser.parse(source, base_name)
+    def parse(source, mapping)
+      Parser.parse(source, mapping)
     end
 
     # Generates a flattened config out of a data hash

data/spec/config_volumizer_spec.rb

@@ -2,11 +2,11 @@ require 'spec_helper'
 
 describe ConfigVolumizer do
   describe '.parse' do
-    let(:key) { 'ex' }
-    let(:result) { described_class.parse(input, key) }
+    let(:result) { described_class.parse(input, mapping) }
 
     describe "1 level hash" do
       let(:input) { { "ex" => "1a" } }
+      let(:mapping) { { "ex" => :value }}
       let(:expected_result) { { 'ex' => '1a' } }
 
       example do
@@ -15,11 +15,18 @@ describe ConfigVolumizer do
     end
 
     describe "2 level hash" do
-      let(:key) { 'ex1' }
+      let(:mapping) {
+        {
+          "ex1" => {
+            "bar" => :value,
+            "bar2" => :value,
+          }
+        }
+      }
       let(:input) do
         {
-          "ex1.bar" => "1a",
-          "ex1.bar2" => "2a",
+          "ex1_bar" => "1a",
+          "ex1_bar2" => "2a",
         }
       end
       let(:expected_result) do
@@ -37,12 +44,24 @@ describe ConfigVolumizer do
     end
 
     describe "3 level hash" do
-      let(:key) { 'ex3' }
+      let(:mapping) do
+        {
+          "ex3" => {
+            "one" => {
+              "two" => :value,
+              "three" => :value,
+            },
+            "two" => {
+              "three" => :value,
+            }
+          }
+        }
+      end
       let(:input) do
         {
-          "ex3.one.two" => "1a",
-          "ex3.one.three" => "2a",
-          "ex3.two.three" => "3a",
+          "ex3_one_two" => "1a",
+          "ex3_one_three" => "2a",
+          "ex3_two_three" => "3a",
         }
       end
       let(:expected_result) do
@@ -65,10 +84,16 @@ describe ConfigVolumizer do
     end
 
     describe "array of values in hash" do
+      let(:mapping) do
+        {
+          "ex" => {
+            "one" => [:value]
+          }
+        }
+      end
       let(:input) do
         {
-          "ex.one[0]" => "1a",
-          "ex.one[1]" => "2a",
+          "ex_one" => "1a,2a",
         }
       end
       let(:expected_result) do
@@ -83,10 +108,14 @@ describe ConfigVolumizer do
     end
 
     describe "just array of values" do
+      let(:mapping) do
+        {
+          "ex" => [:value],
+        }
+      end
       let(:input) do
         {
-          "ex[0]" => "1a",
-          "ex[1]" => "2a",
+          "ex" => "1a,2a",
         }
       end
       let(:expected_result) do
@@ -101,11 +130,19 @@ describe ConfigVolumizer do
     end
 
     describe "array of hashes" do
+      let(:mapping) do
+        {
+          "ex" => [{
+                     "foo" => :value,
+                     "bar" => :value,
+                   }],
+        }
+      end
       let(:input) do
         {
-          "ex[0].foo" => "1a",
-          "ex[0].bar" => "2a",
-          "ex[1].foo" => "3a",
+          "ex_0_foo" => "1a",
+          "ex_0_bar" => "2a",
+          "ex_1_foo" => "3a",
         }
       end
       let(:expected_result) do
@@ -123,12 +160,23 @@ describe ConfigVolumizer do
     end
 
     describe "array of hash in hash" do
-      let(:key) { 'ex2' }
+      let(:mapping) do
+        {
+          "ex2" => {
+            "one" => [
+              {
+                "foo" => :value,
+                "bar" => :value,
+              }
+            ]
+          },
+        }
+      end
       let(:input) do
         {
-          "ex2.one[0].foo" => "1a",
-          "ex2.one[0].bar" => "2a",
-          "ex2.one[1].foo" => "3a",
+          "ex2_one_0_foo" => "1a",
+          "ex2_one_0_bar" => "2a",
+          "ex2_one_1_foo" => "3a",
         }
       end
       let(:expected_result) do
@@ -153,6 +201,11 @@ describe ConfigVolumizer do
     end
 
     describe "empty hash value" do
+      let(:mapping) {
+        {
+          "ex" => {}
+        }
+      }
       let(:input) { { "ex" => "{}", } }
       let(:expected_result) { { 'ex' => {} } }
 
@@ -162,6 +215,11 @@ describe ConfigVolumizer do
     end
 
     describe "empty array value" do
+      let(:mapping) {
+        {
+          "ex" => []
+        }
+      }
       let(:input) { { "ex" => "[]", } }
       let(:expected_result) { { 'ex' => [] } }
 
@@ -170,56 +228,101 @@ describe ConfigVolumizer do
       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
+    describe "hash values" do
+      context "at root" do
+        let(:mapping) do
+          {
+            "ex" => :hash
+          }
+        end
+        let(:input) do
+          {
+            'ex_one' => "1a",
+            'ex_two' => "2a",
+            'ex_three' => "3a",
+          }
+        end
+        let(:expected_result) do
+          {
+            'ex' => {
+              "one" => "1a",
+              "two" => "2a",
+              "three" => "3a",
+            }
+          }
+        end
 
-      example do
-        expect(result).to eq(expected_result)
+        example do
+          expect(result).to eq(expected_result)
+        end
       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",
-        }
+      context "in a hash" do
+        let(:mapping) do
+          {
+            "ex" => {
+              "ex2" => :hash
+            }
+          }
+        end
+        let(:input) do
+          {
+            'ex_ex2_one' => "1a",
+            'ex_ex2_two' => "2a",
+            'ex_ex2_three' => "3a",
+          }
+        end
+        let(:expected_result) do
+          {
+            'ex' => {
+              'ex2' => {
+                "one" => "1a",
+                "two" => "2a",
+                "three" => "3a",
+              }
+            }
+          }
+        end
+
+        example do
+          expect(result).to eq(expected_result)
+        end
       end
-      let(:expected_result) do
-        {
-          'ex' => [
-            [
-              [nil, '1a'],
-              ['2a'],
-            ],
-            [
-              [nil, '3a'],
-              ['4a'],
+
+      context "in an array" do
+        let(:mapping) do
+          {
+            "ex" => [:hash]
+          }
+        end
+        let(:input) do
+          {
+            'ex_0_one' => "1a",
+            'ex_0_two' => "2a",
+            'ex_0_three' => "3a",
+            'ex_1_two' => "4a",
+          }
+        end
+        let(:expected_result) do
+          {
+            'ex' => [
+              {
+                "one" => "1a",
+                "two" => "2a",
+                "three" => "3a",
+              },
+              {
+                "two" => "4a",
+              }
             ]
-          ]
-        }
-      end
+          }
+        end
 
-      example do
-        expect(result).to eq(expected_result)
+        example do
+          expect(result).to eq(expected_result)
+        end
       end
     end
+
   end
 end

data/spec/generator_spec.rb

@@ -13,13 +13,22 @@ describe ConfigVolumizer do
           ]
         }
       }
-      expected_data = {
+      expected_env_data = {
         "one" => "two",
-        "three.four" => "five",
-        "three.six[0]" => "seven",
-        "three.six[1]" => "eight",
+        "three_four" => "five",
+        "three_six_0" => "seven",
+        "three_six_1" => "eight",
       }
-      expect(described_class.generate(data)).to eq(expected_data)
+      expected_mapping_data = {
+        "one" => :value,
+        "three" => {
+          "four" => :value,
+          "six" => [:value]
+        }
+      }
+      result = described_class.generate(data)
+      expect(result.env_hash).to eq(expected_env_data)
+      expect(result.mapping_hash).to eq(expected_mapping_data)
     end
   end
 end

data/spec/spec_helper.rb

@@ -1,2 +1,7 @@
-require 'rspec'
+require 'bundler'
+Bundler.require :test
+
 require 'config_volumizer'
+
+require 'coveralls'
+Coveralls.wear!

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: config_volumizer
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Piotr Banasik
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-04-03 00:00:00.000000000 Z
+date: 2015-04-18 00:00:00.000000000 Z
 dependencies: []
 description: Allows turning dot notation config from ENV to rich Hash/Array structures
 email: piotr.banasik@gmail.com
@@ -16,6 +16,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".coveralls.yml"
 - ".document"
 - ".gitignore"
 - ".rspec"