Merge 0c39fd7 into c99f922

README.md

@@ -4,14 +4,14 @@
 
 # aws-ssm-env
 
-This tool sets parameters acquired from `AWS EC2 Parameter Store` as environment variables.  
+This tool sets parameters acquired from `AWS EC2 Parameter Store` as environment variables or another scope.  
 
 By default, the last hierarchy of the parameter name is
 set as the environment variable name.  
 
 For example, if the parameter name is `/staging/secure/DB_PASSWORD`,
-the parameter value is set to `ENV['DB_PASSWORD']`.  
-The naming of environment variables is optional and can be customized.
+the parameter value is set to `ENV['DB_PASSWORD']` or Settings.DB_PASSWORD.  
+The naming of variables is optional and can be customized.
 (described later)
 
 ## Installation
@@ -32,7 +32,7 @@ gem 'aws-ssm-env', group: :aws
 ```ruby
 # config/application.rb
 if defined?(AwsSsmEnv)
-  AwsSsmEnv.load(path: "/myapp/#{ENV['RAILS_ENV']}", recursive: true)
+  AwsSsmEnv.load(path: "/myapp/#{ENV['RAILS_ENV']}", recursive: true, scope: Settings)
 end
 ```
 

aws-ssm-env.gemspec

@@ -4,7 +4,7 @@ Gem::Specification.new do |spec|
 
   spec.name          = 'aws-ssm-env'
   spec.version       = AwsSsmEnv::VERSION
-  spec.summary       = spec.description = 'Set parameters acquired from AWS EC2 Parameter Store as environment variables.'
+  spec.summary       = spec.description = 'Set parameters acquired from AWS EC2 Parameter Store as environment variables or Rails Settings.'
 
   spec.homepage      = 'https://github.com/sonodar/aws-ssm-env-ruby'
   spec.authors       = [ 'Ryohei Sonoda' ]

lib/aws-ssm-env/loader.rb

@@ -1,5 +1,6 @@
 require 'aws-ssm-env/fetchers/factory'
 require 'aws-ssm-env/naming_strategies/factory'
+require 'aws-ssm-env/parameter_setter'
 
 module AwsSsmEnv
   # このgemのエントリポイントとなるクラス。メイン処理を行う。
@@ -16,17 +17,17 @@ def self.load(**args)
     def initialize(**args)
       parse_options(args)
       if @logger
-        @logger.debug("#{self.class.name} overwrite: #{@overwrite}")
         @logger.debug("#{self.class.name} fetcher: #{@fetcher}")
         @logger.debug("#{self.class.name} naming_strategy: #{@naming_strategy}")
+        @logger.debug("#{self.class.name} parameter_setter: #{@parameter_setter}")
       end
     end
 
     def load
       @fetcher.each do |parameter|
         var_name = @naming_strategy.parse_name(parameter)
         @logger.debug("#{self.class.name} #{parameter.name} parameter value into ENV['#{var_name}']") if @logger
-        send(@applier, var_name, parameter.value)
+        @parameter_setter.save(var_name, parameter.value)
       end
     end
 
@@ -36,32 +37,7 @@ def parse_options(**options)
       @logger = options[:logger]
       @fetcher = AwsSsmEnv::FetcherFactory.create_fetcher(options)
       @naming_strategy = AwsSsmEnv::NamingStrategyFactory.create_naming_strategy(options)
-      @overwrite = overwrite?(options)
-      if @overwrite
-        @applier = :apply!
-      else
-        @applier = :apply
-      end
-    end
-
-    # overwriteフラグが指定されているかどうかを返す。
-    def overwrite?(overwrite: nil, **)
-      if overwrite.nil?
-        false
-      else
-        overwrite.to_s.downcase == 'true'
-      end
-    end
-
-    def apply(name, value)
-      if ENV[name]
-        return
-      end
-      apply!(name, value)
-    end
-
-    def apply!(name, value)
-      ENV[name] = value
+      @parameter_setter = AwsSsmEnv::ParameterSetter.new(options)
     end
   end
 end

lib/aws-ssm-env/parameter_setter.rb

@@ -0,0 +1,45 @@
+module AwsSsmEnv
+  # @author Dominic O'Connor
+  # @since 0.1.2
+  class ParameterSetter
+    def initialize(**args)
+      @overwrite = overwrite?(args)
+      @scope = scope?(args)
+    end
+
+    def save(name, value)
+      if @scope[name] && !@overwrite
+        return
+      end
+      @scope[name] = value
+    end
+
+    def scope
+      @scope
+    end
+
+    private
+
+    def overwrite?(overwrite: nil, **)
+      if overwrite.nil?
+        false
+      else
+        overwrite.to_s.downcase == 'true'
+      end
+    end
+
+    def scope?(**args)
+      scope_type = args[:scope]
+      case scope_type
+      when nil
+        ENV
+      else
+        unless scope_type.is_a?(OpenStruct)
+          raise ArgumentError, 'Possible values for :scope are either :environment ' \
+                + 'or an "OpenStruct" implementation class.'
+        end
+        scope_type
+      end
+    end
+  end
+end

spec/aws-ssm-env/loader_spec.rb

@@ -9,76 +9,16 @@
     it 'has fetcher and naming_strategy' do
       expect(loader.instance_variable_get(:@fetcher)).to be_a(AwsSsmEnv::PathFetcher)
       expect(loader.instance_variable_get(:@naming_strategy)).to be_a(AwsSsmEnv::BasenameNamingStrategy)
-    end
-
-    describe 'overwrite option' do
-      let(:applier) { loader.instance_variable_get(:@applier) }
-
-      context 'when overwrite was not set' do
-        it '@applier is not overwrite method' do
-          expect(applier).to eq(:apply)
-        end
-      end
-
-      context 'when overwrite is nil' do
-        let(:args) { { path: '/foo', overwrite: nil } }
-
-        it '@applier is not overwrite method' do
-          expect(applier).to eq(:apply)
-        end
-      end
-
-      context 'when overwrite is truthy string' do
-        let(:args) { { path: '/foo', overwrite: 'truE' } }
-
-        it '@applier is overwrite method' do
-          expect(applier).to eq(:apply!)
-        end
-      end
-
-      context 'when overwrite is not truthy string' do
-        let(:args) { { path: '/foo', overwrite: 'foo' } }
-
-        it '@applier is not overwrite method' do
-          expect(applier).to eq(:apply)
-        end
-      end
+      expect(loader.instance_variable_get(:@parameter_setter)).to be_a(AwsSsmEnv::ParameterSetter)
     end
   end
 
   describe '#load' do
-    context 'when overwrite is false' do
-      it 'environment variables were not overwritten' do
-        ENV['foo'] = nil
-        ENV['fizz'] = 'fizz'
-
-        loader = described_class.new(args)
-        loader.instance_variable_set(:@fetcher,
-          [ Parameter.new('foo', 'bar'), Parameter.new('fizz', 'buzz') ])
-
-        loader.load
-
-        expect(ENV['foo']).to eq('bar')
-        expect(ENV['fizz']).to eq('fizz')
-      end
-    end
-
-    context 'when overwrite is true' do
-      let(:args) { { path: '/foo', overwrite: true } }
-
-      it 'environment variables were overwritten' do
-        ENV['foo'] = nil
-        ENV['fizz'] = 'fizz'
-
-        loader = described_class.new(args)
-        loader.instance_variable_set(:@fetcher,
-          [ Parameter.new('foo', 'bar'), Parameter.new('fizz', 'buzz') ])
-
-        loader.load
+    let(:loader) { described_class.new(args) }
 
-        expect(ENV['foo']).to eq('bar')
-        expect(ENV['fizz']).to eq('buzz')
-      end
+    it 'parses the parameter name' do
+      expect(loader.instance_variable_get(:@naming_strategy)).to respond_to(:parse_name).with(1).argument
+      expect(loader.instance_variable_get(:@parameter_setter)).to respond_to(:save).with(2).argument
     end
   end
 end

spec/aws-ssm-env/parameter_setter_spec.rb

@@ -0,0 +1,63 @@
+require 'spec_helper'
+
+describe AwsSsmEnv::ParameterSetter do
+  let(:parameter_setter) { described_class.new(args) }
+  let(:args) { {} }
+
+  describe '#initialize' do
+    context 'when scope was not set' do
+      let(:args) { { scope: nil } }
+
+      it 'scope should default to ENV' do
+        expect(parameter_setter.scope).to eq(ENV)
+      end
+    end
+
+    context 'when scope is OpenStruct instance' do
+      let(:parameter_scope) { OpenStruct.new }
+      let(:args) { { scope: parameter_scope } }
+
+      it 'return it as is' do
+        expect(parameter_setter.scope).to eq(parameter_scope)
+      end
+    end
+
+    context 'in other cases' do
+      let(:args) { { scope: 'foo' } }
+
+      it 'raise error' do
+        expect { parameter_setter }.to raise_error(ArgumentError)
+      end
+    end
+  end
+
+  describe '#save' do
+    context 'when overwrite is false' do
+      it 'does not existing parameters' do
+        ENV['foo'] = nil
+        ENV['fizz'] = 'fizz'
+
+        parameter_setter.save('foo', 'bar')
+        parameter_setter.save('fizz', 'buzz')
+
+        expect(ENV['foo']).to eq('bar')
+        expect(ENV['fizz']).to eq('fizz')
+      end
+    end
+
+    context 'when overwrite is true' do
+      let(:args) { { overwrite: 'TrUe' } }
+
+      it 'overwrites existing parameters' do
+        ENV['foo'] = nil
+        ENV['fizz'] = 'fizz'
+
+        parameter_setter.save('foo', 'bar')
+        parameter_setter.save('fizz', 'buzz')
+
+        expect(ENV['foo']).to eq('bar')
+        expect(ENV['fizz']).to eq('buzz')
+      end
+    end
+  end
+end