global 0.2.2 → 2.1.0

data/Rakefile

@@ -1,11 +1,19 @@
+# frozen_string_literal: true
+
 require 'rubygems'
 require 'bundler'
 
 Bundler.require
 
 require 'rspec/core/rake_task'
-require "bundler/gem_tasks"
+require 'bundler/gem_tasks'
+require 'rubocop/rake_task'
 
 RSpec::Core::RakeTask.new(:spec)
+RuboCop::RakeTask.new(:rubocop) do |task|
+  task.options = ['-D'] # Display cop name
+  task.fail_on_error = true
+end
 
-task :default => :spec
+desc 'Run all tests'
+task default: %i[rubocop spec]

data/bin/console

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'global'
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require 'irb'
+IRB.start(__FILE__)

data/global.gemspec

@@ -1,33 +1,31 @@
-$:.push File.expand_path("../lib", __FILE__)
-require "global/version"
+# frozen_string_literal: true
+
+$LOAD_PATH.push File.expand_path('lib', __dir__)
+require 'global/version'
 
 Gem::Specification.new do |s|
-  s.name = "global"
+  s.name = 'global'
   s.version = Global::VERSION
-  s.authors = ["Railsware LLC"]
-  s.email = "contact@railsware.com"
-
-  s.rubyforge_project = "global"
+  s.authors = ['Railsware LLC']
+  s.email = 'contact@railsware.com'
 
-  s.description = "Simple way to load your configs from yaml"
-  s.summary = "Simple way to load your configs from yaml"
+  s.description = 'Simple way to load your configs from yaml/aws/gcp'
+  s.summary = 'Simple way to load your configs from yaml/aws/gcp'
 
   s.files         = `git ls-files`.split("\n")
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
-  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
-  s.require_paths = ["lib"]
+  s.executables   = `git ls-files -- bin/*`.split("\n").map { |f| File.basename(f) }
+  s.require_paths = ['lib']
 
-  s.homepage = "https://github.com/railsware/global"
-  s.licenses = ["MIT"]
+  s.homepage = 'https://github.com/railsware/global'
+  s.licenses = ['MIT']
 
-  s.add_development_dependency "rspec",     ">= 3.0"
-  s.add_development_dependency "simplecov", "~> 0.7.1"
-  s.add_development_dependency "rake",      "~> 10.1.0"
-  if defined?(JRUBY_VERSION)
-    s.add_development_dependency "therubyrhino", ">= 0"
-  else
-    s.add_development_dependency "therubyracer", ">= 0"
-  end
+  s.add_development_dependency 'aws-sdk-ssm', '~> 1'
+  s.add_development_dependency 'google-cloud-secret_manager', '~> 0'
+  s.add_development_dependency 'rake',      '~> 12.3.1'
+  s.add_development_dependency 'rspec',     '>= 3.0'
+  s.add_development_dependency 'rubocop',   '~> 0.81.0'
+  s.add_development_dependency 'simplecov', '~> 0.16.1'
 
-  s.add_runtime_dependency "activesupport", ">= 2.0"
+  s.add_runtime_dependency 'activesupport', '>= 2.0'
 end

data/lib/global/backend/aws_parameter_store.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+module Global
+  module Backend
+    # Loads Global configuration from the AWS Systems Manager Parameter Store
+    # https://docs.aws.amazon.com/systems-manager/latest/userguide/systems-manager-parameter-store.html
+    #
+    # This backend requires the `aws-sdk` or `aws-sdk-ssm` gem, so make sure to add it to your Gemfile.
+    #
+    # Available options:
+    # - `prefix` (required): the prefix in Parameter Store; all parameters within the prefix will be loaded;
+    #   make sure to add a trailing slash, if you want it
+    #   see https://docs.aws.amazon.com/systems-manager/latest/userguide/sysman-paramstore-su-organize.html
+    # - `client`: pass you own Aws::SSM::Client instance, or alternatively set:
+    # - `aws_options`: credentials and other AWS configuration options that are passed to AWS::SSM::Client.new
+    #   see https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/SSM/Client.html#initialize-instance_method
+    #   If AWS access is already configured through environment variables,
+    #   you don't need to pass the credentials explicitly.
+    #
+    # For Rails:
+    # - the `prefix` is optional and defaults to `/[Rails enviroment]/[Name of the app class]/`,
+    #    for example: `/production/MyApp/`
+    # - to use a different app name, pass `app_name`,
+    #    for example: `backend :aws_parameter_store, app_name: 'new_name_for_my_app'`
+    class AwsParameterStore
+
+      PATH_SEPARATOR = '/'
+
+      def initialize(options = {})
+        require_aws_gem
+        init_prefix(options)
+        init_client(options)
+      end
+
+      def load
+        build_configuration_from_parameters(load_all_parameters_from_ssm)
+      end
+
+      private
+
+      def require_aws_gem
+        require 'aws-sdk-ssm'
+      rescue LoadError
+        begin
+          require 'aws-sdk'
+        rescue LoadError
+          raise 'Either the `aws-sdk-ssm` or `aws-sdk` gem must be installed.'
+        end
+      end
+
+      def init_prefix(options)
+        @prefix = if defined?(Rails)
+                    options.fetch(:prefix) do
+                      environment = Rails.env.to_s
+                      app_name = options.fetch(:app_name) { Rails.application.class.module_parent_name }
+                      "/#{environment}/#{app_name}/"
+                    end
+                  else
+                    options.fetch(:prefix)
+                  end
+      end
+
+      def init_client(options)
+        if options.key?(:client)
+          @ssm = options[:client]
+        else
+          aws_options = options.fetch(:aws_options, {})
+          @ssm = Aws::SSM::Client.new(aws_options)
+        end
+      end
+
+      def load_all_parameters_from_ssm
+        response = load_parameters_from_ssm
+        all_parameters = response.parameters
+        loop do
+          break unless response.next_token
+
+          response = load_parameters_from_ssm(response.next_token)
+          all_parameters.concat(response.parameters)
+        end
+
+        all_parameters
+      end
+
+      def load_parameters_from_ssm(next_token = nil)
+        @ssm.get_parameters_by_path(
+          path: @prefix,
+          recursive: true,
+          with_decryption: true,
+          next_token: next_token
+        )
+      end
+
+      # builds a nested configuration hash from the array of parameters from SSM
+      def build_configuration_from_parameters(parameters)
+        configuration = {}
+        parameters.each do |parameter|
+          parameter_parts = parameter.name[@prefix.length..-1].split(PATH_SEPARATOR).map(&:to_sym)
+          param_container = parameter_parts[0..-2].reduce(configuration) do |container, part|
+            container[part] ||= {}
+          end
+          param_container[parameter_parts[-1]] = parameter.value
+        end
+
+        configuration
+      end
+
+    end
+  end
+end

data/lib/global/backend/filesystem.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module Global
+  module Backend
+    # Loads Global configuration from the filesystem
+    #
+    # Available options:
+    # - `path` (required): the directory with config files
+    # - `environment` (required): the environment to load
+    # - `yaml_whitelist_classes`: the set of classes that are permitted to unmarshal from the configuration files
+    #
+    # For Rails:
+    # - the `path` is optional and defaults to `config/global`
+    # - the `environment` is optional and defaults to the current Rails environment
+    class Filesystem
+
+      FILE_ENV_SPLIT = '.'
+      YAML_EXT = '.yml'
+
+      def initialize(options = {})
+        if defined?(Rails)
+          @path = options.fetch(:path) { Rails.root.join('config', 'global').to_s }
+          @environment = options.fetch(:environment) { Rails.env.to_s }
+        else
+          @path = options.fetch(:path)
+          @environment = options.fetch(:environment)
+        end
+        @yaml_whitelist_classes = options.fetch(:yaml_whitelist_classes, [])
+      end
+
+      def load
+        load_from_path(@path)
+      end
+
+      private
+
+      def load_from_path(path)
+        load_from_file(path).deep_merge(load_from_directory(path))
+      end
+
+      def load_from_file(path)
+        config = {}
+
+        if File.exist?(file = "#{path}#{YAML_EXT}")
+          configurations = load_yml_file(file)
+          config = get_config_by_key(configurations, 'default')
+          config.deep_merge!(get_config_by_key(configurations, @environment))
+          if File.exist?(env_file = "#{path}#{FILE_ENV_SPLIT}#{@environment}#{YAML_EXT}")
+            config.deep_merge!(load_yml_file(env_file) || {})
+          end
+        end
+
+        config
+      end
+
+      def get_config_by_key(config, key)
+        return {} if config.empty?
+
+        config[key.to_sym] || config[key.to_s] || {}
+      end
+
+      def load_yml_file(file)
+        file_contents = ERB.new(IO.read(file)).result
+        permitted_classes = [Date, Time, DateTime, Symbol].concat(@yaml_whitelist_classes)
+
+        if Gem::Version.new(Psych::VERSION) >= Gem::Version.new('4')
+          YAML.safe_load(file_contents, permitted_classes: permitted_classes, aliases: true)
+        else
+          YAML.safe_load(file_contents, permitted_classes, [], true)
+        end
+      end
+
+      def load_from_directory(path)
+        config = {}
+
+        if File.directory?(path)
+          Dir["#{path}/*"].each do |entry|
+            namespace = File.basename(entry, YAML_EXT)
+            next if namespace.include? FILE_ENV_SPLIT # skip files with dot(s) in name
+
+            file_with_path = File.join(File.dirname(entry), File.basename(entry, YAML_EXT))
+            config.deep_merge!(namespace => load_from_path(file_with_path))
+          end
+        end
+
+        config
+      end
+
+    end
+  end
+end

data/lib/global/backend/gcp_secret_manager.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+module Global
+  module Backend
+    # Loads Global configuration from the Google Cloud Secret Manager
+    # https://cloud.google.com/secret-manager/docs
+    #
+    # This backend requires the `google-cloud-secret_manager` gem, so make sure to add it to your Gemfile.
+    #
+    # Available options:
+    # - `project_id` (required): Google Cloud project name
+    # - `prefix` (required): the prefix in Secret Manager; all parameters within the prefix will be loaded;
+    #   make sure to add a undescore, if you want it
+    #   see https://cloud.google.com/secret-manager/docs/overview
+    # - `client`: pass you own Google::Cloud::SecretManager instance, or alternatively set:
+    # - `gcp_options`: credentials and other Google cloud configuration options
+    #   that are passed to Google::Cloud::SecretManager.configure
+    #   see https://googleapis.dev/ruby/google-cloud-secret_manager/latest/index.html
+    #   If Google Cloud access is already configured through environment variables,
+    #   you don't need to pass the credentials explicitly.
+    #
+    # For Rails:
+    # - the `prefix` is optional and defaults to `[Rails enviroment]-[Name of the app class]-`,
+    #    for example: `production-myapp-`
+    # - to use a different app name, pass `app_name`,
+    #    for example: `backend :gcp_secret_manager, app_name: 'new_name_for_my_app'`
+    class GcpSecretManager
+
+      GCP_SEPARATOR = '/'
+      PATH_SEPARATOR = '-'
+
+      def initialize(options = {})
+        @project_id = options.fetch(:project_id)
+        require_gcp_gem
+        init_prefix(options)
+        init_client(options)
+      end
+
+      def load
+        pages = load_all_parameters_from_gcsm
+
+        configuration = {}
+        pages.each do |page|
+          configuration.deep_merge!(build_configuration_from_page(page))
+        end
+
+        configuration
+      end
+
+      private
+
+      def require_gcp_gem
+        require 'google/cloud/secret_manager'
+      rescue LoadError
+        raise 'The `google-cloud-secret_manager` gem must be installed.'
+      end
+
+      def init_prefix(options)
+        @prefix = if defined?(Rails)
+                    options.fetch(:prefix) do
+                      environment = Rails.env.to_s
+                      app_name = options.fetch(:app_name) { Rails.application.class.module_parent_name }
+                      "#{environment}-#{app_name}-"
+                    end
+                  else
+                    options.fetch(:prefix)
+                  end
+      end
+
+      def init_client(options)
+        if options.key?(:client)
+          @gcsm = options[:client]
+        else
+          gcp_options = options.fetch(:gcp_options, {})
+          @gcsm = Google::Cloud::SecretManager.secret_manager_service do |config|
+            config.credentials = gcp_options[:credentials] if gcp_options[:credentials]
+            config.timeout = gcp_options[:timeout] if gcp_options[:timeout]
+          end
+        end
+      end
+
+      def load_all_parameters_from_gcsm
+        response = load_parameters_from_gcsm
+        all_pages = [response]
+        loop do
+          break if response.next_page_token.empty?
+
+          response = load_parameters_from_gcsm(response.next_page_token)
+          all_pages << response
+        end
+
+        all_pages
+      end
+
+      def load_parameters_from_gcsm(next_token = nil)
+        @gcsm.list_secrets(
+          parent: @gcsm.project_path(project: @project_id),
+          page_size: 25_000,
+          page_token: next_token
+        )
+      end
+
+      # builds a nested configuration hash from the array of parameters from Secret Manager
+      def build_configuration_from_page(page)
+        configuration = {}
+
+        page.each do |parameter|
+          key_name = get_gcp_key_name(parameter)
+          next unless key_name.start_with?(@prefix)
+
+          parameter_parts = key_name[@prefix.length..-1].split(PATH_SEPARATOR).map(&:to_sym)
+          param_container = parameter_parts[0..-2].reduce(configuration) do |container, part|
+            container[part] ||= {}
+          end
+          param_container[parameter_parts[-1]] = get_latest_key_value(key_name)
+        end
+
+        configuration
+      end
+
+      def get_gcp_key_name(parameter)
+        parameter.name.split(GCP_SEPARATOR).last
+      end
+
+      def get_latest_key_value(key_name)
+        name = @gcsm.secret_version_path(
+          project:        @project_id,
+          secret:         key_name,
+          secret_version: 'latest'
+        )
+        version = @gcsm.access_secret_version(name: name)
+        version.payload.data
+      end
+
+    end
+  end
+end

data/lib/global/base.rb

@@ -1,20 +1,26 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
 require 'erb'
 require 'json'
 
 module Global
   module Base
-    extend self
 
-    attr_writer :environment, :config_directory, :namespace, :except, :only
+    extend self
 
     def configure
       yield self
     end
 
     def configuration
-      @configuration ||= load_configuration(config_directory, environment)
+      raise 'Backend must be defined' unless @backends
+
+      @configuration ||= begin
+        configuration_hash = @backends.reduce({}) do |configuration, backend|
+          configuration.deep_merge(backend.load.with_indifferent_access)
+        end
+        Configuration.new(configuration_hash)
+      end
     end
 
     def reload!
@@ -22,72 +28,46 @@ module Global
       configuration
     end
 
-    def environment
-      @environment || raise("environment should be defined")
-    end
-
-    def config_directory
-      @config_directory || raise("config_directory should be defined")
-    end
-
-    def namespace
-      @namespace ||= 'Global'
-    end
-
-    def except
-      @except ||= :all
-    end
-
-    def only
-      @only ||= []
-    end
-
-    def generate_js(options = {})
-      current_namespace = options[:namespace] || namespace
-
-      js_options = { except: except, only: only }.merge(options)
-      "window.#{current_namespace} = #{configuration.filter(js_options).to_json}"
+    # Add a backend to load configuration from.
+    #
+    # You can define several backends; they will all be loaded
+    # and the configuration hashes will be merged.
+    #
+    # Configure with either:
+    #   Global.backend :filesystem, path: 'config', environment: Rails.env
+    # or:
+    #   Global.backend YourConfigurationBackend.new
+    #
+    # backend configuration classes MUST have a `load` method that returns a configuration Hash
+    def backend(backend, options = {})
+      @backends ||= []
+      if backend.is_a?(Symbol)
+        require "global/backend/#{backend}"
+        backend_class = Global::Backend.const_get(camel_case(backend.to_s))
+        @backends.push backend_class.new(options)
+      elsif backend.respond_to?(:load)
+        @backends.push backend
+      else
+        raise 'Backend must be either a Global::Backend class or a symbol'
+      end
     end
 
     protected
 
-    def load_configuration(dir, env)
-      config = load_from_file(dir, env)
-      config.deep_merge!(load_from_directory(dir, env))
-      Configuration.new(config)
+    def respond_to_missing?(method, include_private = false)
+      configuration.key?(method) || super
     end
 
-    def load_from_file(dir, env)
-      config = {}
-
-      if File.exists?(file = "#{dir}.yml")
-        configurations = YAML::load(ERB.new(IO.read(file)).result)
-        config = configurations[:default] || configurations["default"] || {}
-        config.deep_merge!(configurations[env] || {})
-      end
-
-      config
+    def method_missing(method, *args, &block)
+      configuration.key?(method) ? configuration.get_configuration_value(method) : super
     end
 
-    def load_from_directory(dir, env)
-      config = {}
+    # from Bundler::Thor::Util.camel_case
+    def camel_case(str)
+      return str if str !~ /_/ && str =~ /[A-Z]+.*/
 
-      if File.directory?(dir)
-        Dir["#{dir}/*"].each do |entry|
-          namespace = entry.gsub(/^#{dir}\/?/, '').gsub(/\.yml$/, '')
-          config.deep_merge!(namespace => load_configuration(entry.gsub(/\.yml$/, ''), env))
-        end
-      end
-
-      config
-    end
-    
-    def respond_to_missing?(method, include_private=false)
-      configuration.key?(method) || super
+      str.split('_').map(&:capitalize).join
     end
 
-    def method_missing(method, *args, &block)
-      configuration.key?(method) ? configuration[method] : super
-    end
   end
 end

data/lib/global/configuration.rb

@@ -1,15 +1,17 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
 require 'forwardable'
 
 module Global
   class Configuration
+
     extend Forwardable
 
     attr_reader :hash
 
-    def_delegators :hash, :key?, :has_key?, :include?, :member?, :[], :[]=, :to_hash, :to_json, :inspect
-
+    def_delegators :hash, :key?, :has_key?, :include?,
+                   :member?, :[], :[]=, :to_hash, :to_json,
+                   :inspect, :fetch
 
     def initialize(hash)
       @hash = hash.respond_to?(:with_indifferent_access) ? hash.with_indifferent_access : hash
@@ -17,46 +19,51 @@ module Global
 
     def filter(options = {})
       keys = filtered_keys_list(options)
-      hash.select{|key, _| keys.include?(key)}
+      hash.select { |key, _| keys.include?(key) }
+    end
+
+    def get_configuration_value(key)
+      return nil unless key?(key)
+
+      value = hash[key]
+      value.is_a?(Hash) ? Global::Configuration.new(value) : value
     end
 
     private
 
     def filtered_keys_list(options)
-      if options[:except].is_a?(Array)
-        return hash.keys - options[:except].map(&:to_s)
-      end
-
-      if options[:only].is_a?(Array)
-        return hash.keys & options[:only].map(&:to_s)
-      end
+      return hash.keys - options[:except].map(&:to_s) if options[:except].is_a?(Array)
+      return hash.keys & options[:only].map(&:to_s) if options[:only].is_a?(Array)
 
       return hash.keys if options[:only] == :all
       return [] if options[:except] == :all
-      return []
+
+      []
     end
 
     protected
 
-    def respond_to_missing?(method_name, include_private=false)
+    def respond_to_missing?(method_name, include_private = false)
       method = normalize_key_by_method(method_name)
-      key?(method) || super
+      key?(method) || boolean_method?(method) || super
     end
 
     def method_missing(method, *args, &block)
       method = normalize_key_by_method(method)
       if key?(method)
-        value = hash[method]
-        value.kind_of?(Hash) ? Global::Configuration.new(value) : value
+        get_configuration_value(method)
       else
         super
       end
     end
 
-    def normalize_key_by_method(method)
-      '?' == method.to_s[-1] ? method.to_s[0..-2] : method
+    def boolean_method?(method)
+      '?' == method.to_s[-1]
     end
 
+    def normalize_key_by_method(method)
+      boolean_method?(method) ? method.to_s[0..-2].to_sym : method
+    end
 
   end
 end

data/lib/global/version.rb

@@ -1,5 +1,7 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
 module Global
-  VERSION = "0.2.2"
+
+  VERSION = '2.1.0'
+
 end

data/lib/global.rb

@@ -1,4 +1,6 @@
-# encoding: utf-8
+# frozen_string_literal: true
+
+require 'date'
 require 'yaml'
 
 require 'active_support/core_ext/hash/indifferent_access'
@@ -6,9 +8,10 @@ require 'active_support/core_ext/hash/deep_merge'
 
 require 'global/configuration'
 require 'global/base'
-require 'global/engine' if defined?(Rails)
 require 'global/version'
 
 module Global
+
   extend Base
+
 end