climatic 0.2.26

data/lib/climatic/config_layers/command_line_layer.rb

@@ -0,0 +1,46 @@
+require 'climatic/config_layers/command_line_manager_binder'
+
+module Climatic
+  module ConfigLayers
+
+    class CommandLineLayer < SuperStack::Layer
+
+      include Climatic::ConfigLayers::CommandLineManagerBinder
+
+      CONFIG_ROOT_DIR = %w(etc config).freeze
+      DEFAULT_COMMAND_LINE_DEFINITION_FILE = 'command_line.yml'.freeze
+      COMMAND_LINE_MANAGER_CLASS = UltraCommandLine::Manager::Base
+
+      def initialize(command_line_manager = self.class.default_command_line_manager)
+        # raise UltraCommandLine::Error, 'Invalid command line manager !' unless command_line_manager.is_a? MANAGER_CLASS
+        @command_line_manager = command_line_manager
+      end
+
+      private
+
+      def self.default_command_line_manager
+        begin
+          CONFIG_ROOT_DIR.each do |sub_dir|
+            default_definition_file = File.join Climatic::ConfigLayers::ExecutableGemLayer.executable_gem_config_root, sub_dir, DEFAULT_COMMAND_LINE_DEFINITION_FILE
+            if File.readable? default_definition_file
+              return build_command_line_manager default_definition_file
+            end
+          end
+        rescue => e
+          Climatic.logger.debug "#{e.message}\nBacktrace:\n#{e.backtrace.join("\n\t")}"
+        end
+        UltraCommandLine::Manager::Base.new
+      end
+
+
+      def self.build_command_line_manager(definition_file)
+        mngr = COMMAND_LINE_MANAGER_CLASS.from_yaml_file definition_file
+        mngr.definition_hash_to_commands
+        mngr
+      end
+
+
+    end
+
+  end
+end

data/lib/climatic/config_layers/command_line_manager_binder.rb

@@ -0,0 +1,84 @@
+module Climatic
+  module ConfigLayers
+
+    module CommandLineManagerBinder
+
+      SUB_COMMANDS_HELP_HEADER = [
+          '',
+          '-' * 80,
+          ' Following subcommands exist too:',
+          ' For more information you can always issue sub_command_name --help...',
+          '-' * 80
+      ]
+
+      attr_accessor :command_line_manager
+
+      def cmd_line_args
+        command_line_manager.cmd_line_args
+      end
+
+      def cmd_line_args=(args)
+        command_line_manager.cmd_line_args = args
+        reload
+      end
+
+      def extra_parameters
+        with_selected_command {|c| c.extra_arguments }
+      end
+
+      def load
+        with_selected_command do |c|
+          replace c.params_hash
+          @file_name = :none
+        end
+        self
+      end
+      alias reload load
+
+      def help
+        with_selected_command do |c|
+          if c.root_command?
+            res = c.help
+            sub_commands = command_line_manager.commands.select {|command| not command.root_command?}
+            unless sub_commands.empty?
+              res.concat SUB_COMMANDS_HELP_HEADER
+              sub_commands.each do |command|
+                # command_summary = "#{command.help[0][0,60].tr("\n", ' ')}..."
+                res << " * #{command.name}: #{command_summary command}"
+              end
+
+            end
+            res
+          else
+            c.help
+          end
+        end
+      end
+
+      private
+
+      def command_summary(command)
+        text = command.help[0][0,60].tr("\n", ' ')
+        text.match(/^\s*(?<sentence>[^\s][^\.]+)\./) do |md|
+          return "#{md['sentence']} ..."
+        end
+        text
+      end
+
+      def with_selected_command(&block)
+        selected_command = nil
+        begin
+          selected_command = command_line_manager.command
+        rescue UltraCommandLine::Error => e
+          UltraCommandLine.logger.debug 'No valid command found !'
+        end
+        unless selected_command.nil?
+          block.call selected_command
+        end
+      end
+
+
+    end
+
+  end
+end

data/lib/climatic/config_layers/env_layer.rb

@@ -0,0 +1,41 @@
+module Climatic
+  module ConfigLayers
+
+    class EnvLayer < SuperStack::Layer
+
+      attr_reader :filter
+
+      def initialize(filter=nil)
+        self.filter = filter
+      end
+
+      def filter=(filter)
+        raise 'Invalid filter' unless [NilClass, String, Array, Regexp].include? filter.class
+        @filter = filter
+        load
+      end
+
+      def load(*args)
+        self.replace read_filtered_environment
+        @file_name = :none
+        self
+      end
+
+      private
+
+      def read_filtered_environment
+        return ENV.to_hash if filter.nil?
+
+        if filter.is_a? Array
+          ENV.to_hash.select {|k, v| filter.include?(k) }
+        elsif  filter.is_a? Regexp
+          ENV.to_hash.select {|k, v| k =~ filter }
+        elsif filter.is_a? String
+          ENV.to_hash.select {|k, v| k == filter }
+        end
+      end
+
+    end
+
+  end
+end

data/lib/climatic/config_layers/executable_gem_layer.rb

@@ -0,0 +1,45 @@
+module Climatic
+  module ConfigLayers
+
+    class ExecutableGemLayer < Climatic::ConfigLayers::GenericLayer
+
+
+      def self.executable_gem_config_root
+        return nil unless $PROGRAM_NAME
+
+        Gem.loaded_specs.each_pair do |name, spec|
+          executable_basename = File.basename($PROGRAM_NAME)
+          return spec.full_gem_path if spec.executables.include? executable_basename
+        end
+        nil
+      end
+
+      def executable_gem_config_root
+        self.class.executable_gem_config_root
+      end
+
+      def possible_sources
+        [
+            %w(##EXECUTABLE_GEM_CONFIG_ROOT## etc ##PROGRAM_NAME##.##EXTENSION##),
+            %w(##EXECUTABLE_GEM_CONFIG_ROOT## etc ##PROGRAM_NAME## config.##EXTENSION##),
+            %w(##EXECUTABLE_GEM_CONFIG_ROOT## etc ##PROGRAM_NAME## ##PROGRAM_NAME##.##EXTENSION##),
+            %w(##EXECUTABLE_GEM_CONFIG_ROOT## config ##PROGRAM_NAME##.##EXTENSION##),
+            %w(##EXECUTABLE_GEM_CONFIG_ROOT## config ##PROGRAM_NAME## config.##EXTENSION##),
+            %w(##EXECUTABLE_GEM_CONFIG_ROOT## config ##PROGRAM_NAME## ##PROGRAM_NAME##.##EXTENSION##)
+        ]
+      end
+
+      def perform_substitutions path_part
+        return nil unless executable_gem_config_root
+        res = path_part.dup
+        res.gsub! '##EXECUTABLE_GEM_CONFIG_ROOT##', executable_gem_config_root
+        exec_name = manager.nil? ? Climatic::LayersManager.default_config_file_base_name : manager.config_file_base_name
+        res.gsub! '##PROGRAM_NAME##', exec_name
+        res
+      end
+
+
+    end
+
+  end
+end

data/lib/climatic/config_layers/gem_layer.rb

@@ -0,0 +1,50 @@
+module Climatic
+  module ConfigLayers
+
+    class GemLayer < Climatic::ConfigLayers::GenericLayer
+
+      attr_reader :gem_name
+
+      def self.gem_config_root(gem_name)
+        return nil unless gem_name
+        Gem.loaded_specs.each_pair do |name, spec|
+          return spec.full_gem_path if name == gem_name
+        end
+        nil
+      end
+
+      def gem_config_root
+        self.class.gem_config_root gem_name
+      end
+
+
+      def gem_name=(gem_name)
+        @gem_name = gem_name.to_s
+        rescan
+        reload
+      end
+
+      def possible_sources
+        [
+            %w(##GEM_CONFIG_ROOT## etc ##GEM_NAME##.##EXTENSION##),
+            %w(##GEM_CONFIG_ROOT## etc ##GEM_NAME## config.##EXTENSION##),
+            %w(##GEM_CONFIG_ROOT## etc ##GEM_NAME## ##GEM_NAME##.##EXTENSION##),
+            %w(##GEM_CONFIG_ROOT## config ##GEM_NAME##.##EXTENSION##),
+            %w(##GEM_CONFIG_ROOT## config ##GEM_NAME## config.##EXTENSION##),
+            %w(##GEM_CONFIG_ROOT## config ##GEM_NAME## ##GEM_NAME##.##EXTENSION##)
+        ]
+      end
+
+      def perform_substitutions path_part
+        return nil unless gem_config_root
+        res = path_part.dup
+        res.gsub! '##GEM_CONFIG_ROOT##', gem_config_root
+        res.gsub! '##GEM_NAME##', gem_name if self.respond_to? :gem_name
+        res
+      end
+
+
+    end
+
+  end
+end

data/lib/climatic/config_layers/generic_layer.rb

@@ -0,0 +1,62 @@
+module Climatic
+  module ConfigLayers
+
+    class GenericLayer < SuperStack::Layer
+
+      include Climatic::ConfigLayers::SourceHelper
+
+      def rescan
+        set_config_file possible_sources
+      end
+
+      def initialize
+        rescan
+      end
+
+      def possible_config_files(places=possible_sources)
+        result = {}
+        already_found = false
+        browse_files(places) do |file|
+          exists = File.readable?(file)
+          used = false
+          already_found = used = true if exists and not already_found
+          result[file] = {
+              exists: exists,
+              used: used,
+              layer: [name]
+          }
+        end
+        result
+      end
+
+      private
+
+      def set_config_file(places)
+        @file_name = nil
+        browse_files(places) do |file|
+          if File.readable? file
+            @file_name = file
+            return @file_name
+          end
+        end
+      end
+
+      def browse_files(places, &block)
+        places.each do |path_array|
+          begin
+            potential_config_file = File.join(path_array.map { |path_part| perform_substitutions path_part })
+          rescue
+            # do nothing
+          end
+          return unless potential_config_file
+          EXTENSIONS.each do |extension|
+            file  = potential_config_file.gsub '##EXTENSION##', extension
+            yield file
+          end
+        end
+      end
+
+    end
+
+  end
+end

data/lib/climatic/config_layers/global_layer.rb

@@ -0,0 +1,28 @@
+module Climatic
+  module ConfigLayers
+
+    class GlobalLayer < Climatic::ConfigLayers::SystemLayer
+      def possible_sources
+        [
+            ['##SYSTEM_CONFIG_ROOT##', '##PROGRAM_NAME##.##EXTENSION##' ],
+            ['##SYSTEM_CONFIG_ROOT##', '##PROGRAM_NAME##', 'config.##EXTENSION##' ],
+            ['##SYSTEM_CONFIG_ROOT##', '##PROGRAM_NAME##', '##PROGRAM_NAME##.##EXTENSION##' ]
+        ]
+      end
+
+      def perform_substitutions(path_part)
+        res = path_part.dup
+        res.gsub! '##SYSTEM_CONFIG_ROOT##', system_config_root
+
+        exec_name = manager.nil? ? Climatic::LayersManager.default_config_file_base_name : manager.config_file_base_name
+        res.gsub! '##PROGRAM_NAME##', exec_name
+
+        res
+      end
+
+    end
+
+
+
+  end
+end

data/lib/climatic/config_layers/program_description_helper.rb

@@ -0,0 +1,94 @@
+module Climatic
+  module ConfigLayers
+
+    module ProgramDescriptionHelper
+
+      attr_reader :config_file_base_name, :app_name, :app_version, :app_description
+
+      def add_command_line_section(title='Script specific', &block)
+        command_line_layer.add_command_line_section title, &block
+      end
+
+      def config_file_base_name=(config_file_base_name)
+        return if config_file_base_name.nil?
+        @config_file_base_name = config_file_base_name
+        rescan_layers
+        reload_layers
+      end
+
+      def app_name=(app_name)
+        return if app_name.nil?
+        @app_name = app_name
+        command_line_layer.reload
+      end
+
+      def app_version=(app_version)
+        return if app_version.nil?
+        @app_version = app_version
+        command_line_layer.reload
+      end
+
+      def app_description=(app_description)
+        return if app_description.nil?
+        @app_description = app_description
+        command_line_layer.reload
+      end
+
+      def rescan_layers
+        layers.values.each do |layer|
+          if layer.respond_to? :rescan
+            layer.clear
+            layer.rescan
+          end
+        end
+
+      end
+
+
+      def detailed_layers_info
+        info, sep = [], '-' * 80
+        info << sep
+        layers.values.sort {|a, b| a.priority <=> b.priority}.each do |layer|
+          info << layer.name
+          if layer.file_name.nil?
+            info << 'There is no file attached to this level.'
+          else
+            info << "Using '#{layer.file_name}' as config file for this layer."
+          end
+          if layer.empty?
+            info << 'There is no data in this layer'
+          else
+            info << 'This layer contains the following data:'
+            info << layer.to_yaml
+          end
+          info << sep
+        end
+        info.join "\n"
+      end
+
+      def detailed_config_files_info
+        merger = SuperStack::Manager.new
+        merger.merge_policy = SuperStack::MergePolicies::FullMergePolicy
+        layers.values.each do |layer|
+          merger << layer.possible_config_files if layer.respond_to? :possible_config_files
+        end
+        merger[]
+      end
+
+
+      def command_line_help
+        command_line_layer.help
+      end
+
+      def describes_application(options = {})
+        self.app_name = options.fetch(:app_name, nil)
+        self.app_version = options.fetch(:app_version, nil)
+        self.app_description = options.fetch(:app_description, nil)
+        self.config_file_base_name = options.fetch(:config_file_base_name, nil)
+      end
+
+    end
+
+  end
+end
+

data/lib/climatic/config_layers/project_layer.rb

@@ -0,0 +1,61 @@
+module Climatic
+  module ConfigLayers
+
+    class ProjectLayer < SuperStack::Layer
+
+      attr_reader :started_from_directory, :project_file_basename
+
+      def initialize(file_or_directory, project_file_basename=nil)
+        if Dir.exists? file_or_directory
+          raise 'You have to provide the basename of the project file !' if project_file_basename.nil?
+          @started_from_directory = File.expand_path file_or_directory
+          self.project_file_basename = project_file_basename
+        else
+          raise "Invalid project file '#{file_or_directory}' !" unless File.readable? file_or_directory
+          normalized = File.expand_path file_or_directory
+          @started_from_directory = File.dirname normalized
+          self.project_file_basename = File.basename normalized
+        end
+      end
+
+      def file_name
+        @file_name ||= find_root_file project_file_basename, started_from_directory
+      end
+
+      def project_root
+        File.dirname file_name
+      end
+
+      def project_file_basename=(file)
+        @file_name = nil
+        @project_file_basename = file
+      end
+
+      private
+
+      def find_root_file(file_basename, initial_directory)
+        prev_dir = nil
+        cur_dir = initial_directory
+        found_file = nil
+        file_basename = file_basename.to_s
+
+        raise Climatic::Error, "Invalid directory '#{initial_directory}'" unless File.readable? initial_directory
+
+        while found_file.nil? and cur_dir != prev_dir
+          candidate_file = File.join cur_dir, file_basename
+          if File.readable? candidate_file
+            found_file = candidate_file
+          end
+          prev_dir = cur_dir
+          cur_dir = File.expand_path '..', cur_dir
+        end
+
+        raise Climatic::Error, "Cannot find any root file named '#{file_basename}' starting from '#{initial_directory}'." if found_file.nil?
+
+        found_file
+      end
+
+    end
+
+  end
+end

data/lib/climatic/config_layers/provided_config_file_layer.rb

@@ -0,0 +1,26 @@
+module Climatic
+  module ConfigLayers
+
+    class ProvidedConfigFileLayer < SuperStack::Layer
+
+
+      def managed
+        if manager[:'config-file']
+          if File.readable? manager[:'config-file']
+            @file_name = manager[:'config-file']
+            self.merge_policy = SuperStack::MergePolicies::OverridePolicy if manager[:'config-override']
+          end
+        end
+      end
+
+      private
+
+      def config_filepath
+        File.expand_path File.join('..', '..', '..', '..', 'etc', 'default_cmd_line_options.yml'), __FILE__
+      end
+
+
+    end
+
+  end
+end

data/lib/climatic/config_layers/source_helper.rb

@@ -0,0 +1,48 @@
+module Climatic
+  module ConfigLayers
+
+    module SourceHelper
+
+      OS_FLAVOURS = {
+          mingw32: :windows,
+          linux: :unix
+      }
+      DEFAULT_OS_FLAVOUR = :unix
+
+
+      EXTENSIONS = %w(conf CONF cfg CFG yml YML yaml YAML)
+
+      def self.included(base)
+        base.extend ClassMethods
+      end
+
+      module ClassMethods
+        def os_flavour
+          Climatic::ConfigLayers::SourceHelper.os_flavour
+        end
+
+        def supported_oses
+          Climatic::ConfigLayers::SourceHelper.supported_oses
+        end
+      end
+
+      def self.os_flavour
+        OS_FLAVOURS[RbConfig::CONFIG['target_os'].to_sym] || DEFAULT_OS_FLAVOUR
+      end
+
+      def self.supported_oses
+        OS_FLAVOURS.values.sort.uniq
+      end
+
+      def os_flavour
+        @os_flavour ||= self.class.os_flavour
+      end
+
+      def supported_oses
+        self.class.supported_oses
+      end
+
+    end
+
+  end
+end

data/lib/climatic/config_layers/system_layer.rb

@@ -0,0 +1,37 @@
+module Climatic
+  module ConfigLayers
+
+    class SystemLayer < Climatic::ConfigLayers::GenericLayer
+
+      SYSTEM_CONFIG_ROOT = {
+          windows: [File.join(ENV['systemRoot'] || '', 'Config')],
+          unix: '/etc'
+      }
+
+      def self.system_config_root
+        SYSTEM_CONFIG_ROOT[os_flavour]
+      end
+
+      def system_config_root
+        self.class.system_config_root
+      end
+
+
+      def possible_sources
+        [
+            ['##SYSTEM_CONFIG_ROOT##', 'stacked_config.##EXTENSION##' ],
+            ['##SYSTEM_CONFIG_ROOT##', 'stacked_config', 'config.##EXTENSION##' ]
+        ]
+      end
+
+      def perform_substitutions path_part
+        res = path_part.dup
+        res.gsub! '##SYSTEM_CONFIG_ROOT##', system_config_root
+        res
+      end
+
+
+    end
+
+  end
+end

data/lib/climatic/config_layers/user_layer.rb

@@ -0,0 +1,40 @@
+module Climatic
+  module ConfigLayers
+
+    class UserLayer < Climatic::ConfigLayers::GenericLayer
+
+
+      def self.user_config_root
+        Dir.home
+      end
+
+      def user_config_root
+        self.class.user_config_root
+      end
+
+
+      def possible_sources
+        [
+            ['##USER_CONFIG_ROOT##', '.##PROGRAM_NAME##.##EXTENSION##' ],
+            ['##USER_CONFIG_ROOT##', '.config', '##PROGRAM_NAME##.##EXTENSION##' ],
+            ['##USER_CONFIG_ROOT##', '.config', '##PROGRAM_NAME##', 'config.##EXTENSION##' ],
+            ['##USER_CONFIG_ROOT##', '.config', '##PROGRAM_NAME##', '##PROGRAM_NAME##.##EXTENSION##' ],
+            ['##USER_CONFIG_ROOT##', '.##PROGRAM_NAME##', 'config.##EXTENSION##' ],
+            ['##USER_CONFIG_ROOT##', '.##PROGRAM_NAME##', '##PROGRAM_NAME##.##EXTENSION##' ]
+        ]
+      end
+
+      def perform_substitutions path_part
+        res = path_part.dup
+        res.gsub! '##USER_CONFIG_ROOT##', user_config_root
+
+        exec_name = manager.nil? ? Climatic::LayersManager.default_config_file_base_name : manager.config_file_base_name
+        res.gsub! '##PROGRAM_NAME##', exec_name
+
+        res
+      end
+
+    end
+
+  end
+end