easy_app_helper 1.0.14 → 2.0.2

data/lib/easy_app_helper/core/base.rb

@@ -1,228 +0,0 @@
-################################################################################
-# EasyAppHelper
-#
-# Copyright (c) 2013 L.Briais under MIT license
-# http://opensource.org/licenses/MIT
-################################################################################
-
-require 'slop'
-
-# This class is the base class for the {EasyAppHelper::Core::Config config} object.
-# It handles the internal_configs hash that actually contains all configurations read from
-# various sources: command line, config files etc...
-
-class EasyAppHelper::Core::Base
-  CHANGED_BY_CODE = 'Changed by code'
-  INTRODUCED_SORTED_LAYERS = [:modified, :command_line]
-
-  attr_reader :script_filename, :app_name, :app_version, :app_description, :internal_configs, :logger
-
-  def initialize(logger)
-    @app_name = @app_version = @app_description = ""
-    @script_filename = File.basename $0, '.*'
-    @internal_configs = {modified: {content: {}, source: CHANGED_BY_CODE}}
-    @logger = logger
-    @slop_definition = Slop.new
-    build_command_line_options
-  end
-
-
-  # @return [String] The formatted command line help
-  def help
-    @slop_definition.to_s
-  end
-
-  # sets the filename while maintaining the slop definition upto date
-  # @param [String] filename
-  def script_filename=(filename)
-    @script_filename = filename
-    @slop_definition.banner = build_banner
-  end
-  # sets the application name used for logging while maintaining the slop definition upto date
-  # @param [String] fname
-  def app_name=(name)
-    @app_name = name
-    @slop_definition.banner = build_banner
-  end
-  # sets the version while maintaining the slop definition upto date
-  # @param [String] version
-  def app_version=(version)
-    @app_version = version
-    @slop_definition.banner = build_banner
-  end
-  # sets the filename while maintaining the slop definition upto date
-  # @param [String] description
-  def app_description=(description)
-    @app_description = description
-    @slop_definition.banner = build_banner
-  end
-
-  # helper to add in one command any of the four base properties used
-  # by the logger and the config objects.
-  # @param [String] app_name
-  # @param [String] script_filename
-  # @param [String] app_version
-  # @param [String] app_description
-  def describes_application(options = {})
-    app_name = options.fetch(:app_name, nil)
-    script_filename = options.fetch(:script_filename, nil)
-    app_version = options.fetch(:app_version, nil)
-    app_description = options.fetch(:app_description, nil)
-    self.app_name = app_name unless app_name.nil?
-    self.app_version = app_version unless app_version.nil?
-    self.app_description = app_description unless app_description.nil?
-    self.script_filename = script_filename unless script_filename.nil?
-  end
-
-  # @return [Hash] This hash built from slop definition correspond to the :command_line layer of internal_configs
-  def command_line_config
-    @slop_definition.parse
-    @slop_definition.to_hash
-  end
-
-  # Yields a slop definition to modify the command line parameters
-  # @param [String] title used to insert a slop separator
-  def add_command_line_section(title='Script specific')
-    raise "Incorrect usage" unless block_given?
-    @slop_definition.separator build_separator(title)
-    yield @slop_definition
-  ensure
-    sync!
-  end
-
-  # Sets the :command_line layer of internal_configs to the computed {#command_line_config}
-  def load_config
-    sync!
-    self
-  end
-
-  # Convenient method to set a value in a particular layer
-  # If the layer does not exist it is correctly created and filled in with the key/value couple
-  def set_value key, value, layer = nil
-    if layer.nil?
-      self[key] = value
-      return
-    end
-    unless layers.include? layer
-      internal_configs[layer] = {content: {}, source: 'Unknown source'}
-      logger.warn "Trying to modify a non existing config layer: \"#{layer.to_s}\". Automatically creating it..."
-    end
-    internal_configs[layer][:content][key] = value
-  end
-
-  def get_value key, layer = nil
-    if layer.nil?
-      return self[key]
-    end
-    res = nil
-    begin
-      res = internal_configs[layer][:content][key]
-    rescue => e
-      logger.warn "Trying to reading from a non existing config layer: \"#{layer}\". Returning nil for the key \"#{key}\"..."
-    end
-    res
-  end
-
-
-
-  # Any modification done to the config is in fact stored in the :modified layer of internal_configs
-  # @param [String] key
-  # @param [String] value
-  def []=(key,value)
-    internal_configs[:modified][:content][key] = value unless check_hardcoded_properties key, value
-  end
-
-  # Reset the :modified layer of internal_configs rolling back any change done to the config
-  def reset
-    internal_configs[:modified] = {content: {}, source: CHANGED_BY_CODE}
-    self
-  end
-
-
-  # @return [Array] List of layers
-  def layers
-    res = self.class.layers
-    internal_configs.keys.each do |layer|
-      next if res.include? layer
-      res << layer
-    end
-    res
-  end
-
-  def self.layers
-    res = []
-    self.ancestors.each do |klass|
-      next unless klass.is_a? Class
-      break if EasyAppHelper::Core::Base < klass
-      res << klass::INTRODUCED_SORTED_LAYERS.reverse
-    end
-    res.flatten.reverse
-  end
-
-
-  def find_layer(key)
-    layers.each do |layer|
-      return layer if internal_configs[layer][:content][key]
-    end
-    nil
-  end
-
-
-  # Executes code (block given) unless :simulate is in the config.
-  # If :simulate specified then display message instead of executing the code (block).
-  def safely_exec(message, *args)
-    raise "No block given" unless block_given?
-    if self[:simulate]
-      logger.puts_and_logs "SIMULATING: #{message}" unless message.nil?
-    else
-      logger.puts_and_logs message
-      yield(*args)
-    end
-  end
-
-
-  private
-
-  def sync!
-    internal_configs[:command_line] = {content: command_line_config, source: 'Command line'}
-  end
-
-
-  # Performs actions related the very specific config parameters
-  # @param [String] key The parameter to check
-  # @param [Object] value The value it expects to be set to
-  # @param [Symbol] layer Optional layer, default is :modified
-  # @return [Boolean] Whether or not the internal state has been changed
-  def check_hardcoded_properties(key, value, layer = :modified)
-    processed = false
-    case key
-      when :'log-level'
-        logger.send :level=, value, false
-      when :'config-file'
-        set_value key, value, layer
-        force_reload
-        processed = true
-    end
-    processed
-  end
-
-  # Builds a nice separator
-  def build_separator(title, width = 80, filler = '-')
-    "#{filler * 2} #{title} ".ljust width, filler
-  end
-
-  # Builds common used command line options
-  def build_command_line_options
-    add_command_line_section('Generic options') do |slop|
-      slop.on :auto, 'Auto mode. Bypasses questions to user.', :argument => false
-      slop.on :simulate, 'Do not perform the actual underlying actions.', :argument => false
-      slop.on :v, :verbose, 'Enable verbose mode.', :argument => false
-      slop.on :h, :help, 'Displays this help.', :argument => false
-    end
-  end
-
-  def build_banner
-    "\nUsage: #{script_filename} [options]\n#{app_name} Version: #{app_version}\n\n#{app_description}"
-  end
-
-end

data/lib/easy_app_helper/core/config.rb

@@ -1,220 +0,0 @@
-################################################################################
-# EasyAppHelper
-#
-# Copyright (c) 2013 L.Briais under MIT license
-# http://opensource.org/licenses/MIT
-################################################################################
-
-require 'yaml'
-# This is the class that will handle the configuration.
-# Configuration is read from different sources:
-# - config files (system, global, user, specified on the command line)
-# - command line options
-# - any extra config you provide programmatically
-#
-# == Config files:
-# system, global, and user config files are searched in the file system according to
-# complex rules. First the place where to search them depends on the OS
-# (Provided by {EasyAppHelper::Core::Config::Places}), and then multiple file extensions are
-# tested ({EasyAppHelper::Core::Config::CONFIG_FILE_POSSIBLE_EXTENSIONS}). This is basically
-# performed by the private method {#find_file}. The config specified on command line (if any)
-# is loaded the same way.
-#
-# == Command line:
-# Any option can be declared as being callable from the command line. Modules add already some
-# command line options, but the application can obviously add its own (see
-# {EasyAppHelper::Core::Base#add_command_line_section}).
-#
-# Each of the config sources are kept in a separated "layer" and addressed this way using the
-# #internal_configs attribute reader. But of course the config object provides a "merged" config
-# result of the computation of all the sources. See the {#to_hash} method to see the order for the
-# merge.
-# Any option can be accessed or modified directly using the {#[]} and {#[]=} methods.
-# Any change to the global config should be done using the {#[]=} method and is kept in the last separated
-# layer called "modified". Therefore the config can be easily reset using the {#reset}
-# method.
-class EasyAppHelper::Core::Config < EasyAppHelper::Core::Base
-end
-
-require 'easy_app_helper/core/places'
-require 'easy_app_helper/core/merge_policies'
-
-
-class EasyAppHelper::Core::Config
-  include EasyAppHelper::Core::HashesMergePolicies
-
-  ADMIN_CONFIG_FILENAME = EasyAppHelper.name
-  INTRODUCED_SORTED_LAYERS = [:specific_file, :user, :global, :internal, :system]
-
-  # Potential extensions a config file can have
-  CONFIG_FILE_POSSIBLE_EXTENSIONS = %w(conf yml cfg yaml CFG YML YAML Yaml)
-
-  # @param [EasyAppHelper::Core::Logger] logger
-  # The logger passed to this constructor should be a temporary logger until the full config is loaded.
-  def initialize(logger)
-    super
-    add_cmd_line_options
-    load_config
-  end
-
-  # After calling the super method, triggers a forced reload of the file based config.
-  # @param [String] name of the config file
-  # @see Base#script_filename=
-  def script_filename=(name)
-    super
-    force_reload
-  end
-
-  # Sets the Application name and passes it to the logger.
-  # @param [String] name
-  # @see Base#app_name=
-  def app_name=(name)
-    super
-    logger.progname = name
-  end
-
-  # Loads all config (command line and config files)
-  # Do not reload a file if already loaded unless forced too.
-  # It *does not flush the "modified" layer*. Use {#reset} instead
-  # @param [Boolean] force to force the reload
-  def load_config(force=false)
-    super()
-    load_layer_config :system, ADMIN_CONFIG_FILENAME, force
-    load_layer_config :internal, script_filename, force
-    load_layer_config :global, script_filename, force
-    load_layer_config :user, script_filename, force
-    load_layer_config :specific_file, internal_configs[:command_line][:content][:'config-file'], force
-    self
-  end
-
-  # @see #load_config
-  def force_reload
-    load_config true
-  end
-
-
-  # This is the main method that provides the config as a hash.
-  #
-  # Every layer is kept untouched (and could accessed independently
-  # using {#internal_configs}), while this methods provides a merged config.
-  # @return [Hash] The hash of the merged config.
-  def to_hash
-
-    merged_config = {}
-
-    # Process any other level as a low priority unmanaged layer
-    internal_configs.keys.each do |layer|
-      next if self.class.layers.include? layer
-      hashes_second_level_merge merged_config, internal_configs[layer][:content]
-    end
-
-    # Process Config-level layers
-    merged_config = [:system, :internal, :global, :user].inject(merged_config) do |temp_config, config_level|
-      hashes_second_level_merge temp_config, internal_configs[config_level][:content]
-    end
-    if get_value :'config-file', :command_line
-      if get_value :'config-override', :command_line
-        override_merge merged_config, internal_configs[:specific_file][:content]
-      else
-        hashes_second_level_merge merged_config, internal_configs[:specific_file][:content]
-      end
-
-    end
-
-    # Process Base-level layers with highest priority (last processed the highest)
-    [:command_line, :modified].each { |base_layer|  hashes_second_level_merge merged_config, internal_configs[base_layer][:content]}
-    merged_config
-
-  end
-
-  # @param [Object] key: The key to access the data in the merged_config hash (see {#to_hash})
-  # @return [String] Value for this key in the merged config.
-  def [](key = nil)
-    key.nil? ? to_hash : to_hash[key]
-  end
-
-
-  # @return [String] The merged config (see {#to_hash}) rendered as Yaml
-  def to_yaml
-    to_hash.to_yaml
-  end
-
-  alias_method :to_s, :to_yaml
-  alias_method :inspect, :internal_configs
-
-  #############################################################################
-  private
-
-  # Command line options specific to config manipulation
-  def add_cmd_line_options
-    add_command_line_section('Configuration options') do |slop|
-      slop.on 'config-file', 'Specify a config file.', :argument => true
-      slop.on 'config-override', 'If specified override all other config.', :argument => false
-    end
-  end
-
-  # Tries to find a config file to be loaded into the config layer cake unless cached.
-  def load_layer_config(layer, filename_or_pattern, force=false)
-    unless_cached(layer,  filename_or_pattern, force) do |layer, filename_or_pattern|
-      fetch_config_layer layer, filename_or_pattern
-    end
-  end
-
-  # Actual loads
-  def fetch_config_layer(layer, filename_or_pattern)
-    if filename_or_pattern.nil?
-      internal_configs[layer] = {content: {}}
-      filename = nil
-    else
-      if File.exists? filename_or_pattern and !File.directory? filename_or_pattern
-        filename = filename_or_pattern
-      else
-        places = Places.possible_config_places[layer]
-        filename = find_file places, filename_or_pattern
-      end
-      internal_configs[layer] = {content: load_config_file(filename, layer), source: filename, origin: filename_or_pattern}
-    end
-  ensure
-    logger.info "No config file found for layer #{layer}." if filename.nil?
-  end
-
-  def unless_cached(layer, filename_or_pattern, forced)
-    cached = false
-    if internal_configs[layer]
-      cached = true unless internal_configs[layer][:origin] == filename_or_pattern
-    end
-    if forced or not cached
-      yield layer, filename_or_pattern
-    end
-  end
-
-  # Tries to find config files according to places (array) given and possible extensions
-  def find_file(places, filename)
-    return nil if places.nil? or filename.nil? or filename.empty?
-    places.each do |dir|
-      CONFIG_FILE_POSSIBLE_EXTENSIONS.each do |ext|
-        filename_with_path = dir + '/' + filename + '.' + ext
-        if File.exists? filename_with_path and !File.directory? filename_with_path
-          return filename_with_path 
-        else
-          logger.debug "Trying \"#{filename_with_path}\" as config file."
-        end
-      end
-    end
-    nil
-  end
-
-  def load_config_file(conf_filename, layer=nil)
-    conf = {}
-    return conf if conf_filename.nil?
-    ext = layer.nil? ? '' : " as layer #{layer}"
-    begin
-      logger.debug "Loading config file \"#{conf_filename}\"#{ext}"
-      conf = Hash[YAML::load(open(conf_filename)).map { |k, v| [k.to_sym, v] }]
-    rescue => e
-      logger.error "Invalid config file \"#{conf_filename}\"#{ext}. Skipped as not respecting YAML syntax!\n#{e.message}"
-    end
-    conf
-  end
-
-end

data/lib/easy_app_helper/core/logger.rb

@@ -1,111 +0,0 @@
-################################################################################
-# EasyAppHelper
-#
-# Copyright (c) 2013 L.Briais under MIT license
-# http://opensource.org/licenses/MIT
-################################################################################
-
-require 'logger'
-require 'singleton'
-
-# Official Ruby Logger re-opened to introduce a method to hand-over the temporary history from a temporary logger
-# to the definitive one.
-# TODO: Ensure only the messages that are above the current level are displayed when handing over to the definitive logger.
-class Logger
-  def hand_over_to(log)
-    history = []
-    history = @logdev.dev.history if @logdev.dev.respond_to? :history
-    @logdev.close
-    @logdev = LogDevice.new log
-    history.each do |msg|
-      @logdev.write msg if ENV['DEBUG_EASY_MODULES'] or (msg =~ /^[WE]/)
-    end
-  end
-end
-
-# This is the logger that will be used by the application and any class that include {EasyAppHelper} module. It is
-# configured by the {EasyAppHelper::Core::Config Config} object, and provides a temporary logger until the config
-# is fully loaded.
-class EasyAppHelper::Core::Logger < Logger
-  include Singleton
-
-
-  def initialize
-    @config = {}
-    super(TempLogger.new)
-    self.level = Severity::DEBUG
-    debug "Temporary initialisation logger created..."
-  end
-
-  # Change the log level while keeping the config in sync.
-  def level=(level, update_config = true)
-    super(level)
-    @config[:'log-level'] = level if update_config
-  end
-
-  # Displays the message according to application verbosity and logs it as info.
-  def puts_and_logs(msg)
-    puts msg if @config[:verbose]
-    info(msg)
-  end
-
-  # Reset the logger regarding the config provided
-  def set_app_config(config)
-    @config = config
-    add_cmd_line_options
-    @config.load_config
-    debug "Config layers:\n#{@config.internal_configs.to_yaml}"
-    debug "Merged config:\n#{@config.to_yaml}"
-    if config[:debug]
-      if config[:'log-file']
-        hand_over_to config[:'log-file']
-      elsif config[:"debug-on-err"]
-        hand_over_to STDERR
-      else
-        hand_over_to STDOUT
-      end
-    else
-      close
-    end
-    self.level = config[:'log-level'] ? config[:'log-level'] : Severity::WARN
-    self
-  end
-
-  private
-
-
-  def add_cmd_line_options
-    @config.add_command_line_section('Debug and logging options') do |slop|
-      slop.on :debug, 'Run in debug mode.', :argument => false
-      slop.on 'debug-on-err', 'Run in debug mode with output to stderr.', :argument => false
-      slop.on 'log-level', "Log level from 0 to 5, default #{Severity::WARN}.", :argument => true, :as => Integer
-      slop.on 'log-file', 'File to log to.', :argument => true
-    end
-  end
-
-  # This class will act as a temporary logger, actually just keeping the history until the real
-  # configuration for the logger is known. Then the history is displayed or not regarding the
-  # definitive logger configuration.
-  class TempLogger
-    attr_reader :history
-
-    def initialize
-      @history = []
-    end
-
-    def write(data)
-      return if closed?
-      @history << data if @history
-    end
-
-    def close
-      @closed = true
-    end
-
-    def opened?() not @closed ; end
-    def closed?() @closed ; end
-  end
-
-end
-
-

data/lib/easy_app_helper/core/merge_policies.rb

@@ -1,40 +0,0 @@
-################################################################################
-# EasyAppHelper
-#
-# Copyright (c) 2013 L.Briais under MIT license
-# http://opensource.org/licenses/MIT
-################################################################################
-
-# This module proposes different merge policies for two hashes.
-module EasyAppHelper::Core::HashesMergePolicies
-
-  # Performs a merge at the second level of hashes.
-  # simple entries and arrays are overridden.
-  def hashes_second_level_merge(h1, h2)
-    return [] if h1.nil? && h2.nil?
-    return h1 if h2.nil?
-    return h2 if h1.nil?
-    h2.each do |key, v|
-      if h1[key] and h1[key].is_a?(Hash)
-        # Merges hashes
-        h1[key].merge! h2[key]
-      else
-        # Overrides the rest
-        h1[key] = h2[key] unless h2[key].nil?
-      end
-    end
-    h1
-  end
-
-  # Uses the standard "merge!" method
-  def simple_merge(h1, h2)
-    h1.merge! h2
-  end
-
-  # Brutal override
-  def override_merge(h1, h2)
-    h1 = nil
-    h1 = h2
-
-  end
-end

data/lib/easy_app_helper/core/places.rb

@@ -1,87 +0,0 @@
-################################################################################
-# EasyAppHelper
-#
-# Copyright (c) 2013 L.Briais under MIT license
-# http://opensource.org/licenses/MIT
-################################################################################
-
-# The goal of this class is to return a module containing the POSSIBLE_PLACES hash
-# that provides a list of OS dependant paths.
-# The only method that should be used is the #get_os_module method that returns this module.
-# TODO: Add equivalent for Mac
-
-module EasyAppHelper
-  module Core
-    class Config
-      module Places
-
-        OS_FLAVOURS = {
-            mingw32: :windows,
-            linux: :unix
-        }
-        DEFAULT_OS_FLAVOUR = :unix
-
-        FLAVOUR_PLACES = {
-            unix: {
-                internal: [],
-
-                system: ['/etc'],
-
-                # Where could be stored global wide configuration
-                global: %w(/etc /usr/local/etc),
-
-                # Where could be stored user configuration
-                user:  ["#{ENV['HOME']}/.config"]
-            },
-            windows: {
-                internal: [],
-
-                system: ["#{ENV['systemRoot']}/Config"],
-
-                # Where could be stored global configuration
-                global: ["#{ENV['systemRoot']}/Config",
-                         "#{ENV['ALLUSERSPROFILE']}/Application Data"],
-
-                # Where could be stored user configuration
-                user: [ENV['APPDATA']]
-            }
-        }
-
-
-        def self.os_flavour
-          flavour = OS_FLAVOURS[RbConfig::CONFIG['target_os'].to_sym]
-          flavour.nil? ? DEFAULT_OS_FLAVOUR : flavour
-        end
-
-        def self.gem_root_path(file=__FILE__)
-          file=__FILE__ if file.nil?
-          searcher = if Gem::Specification.respond_to? :find
-                       # ruby 2.0
-                       Gem::Specification
-                     elsif Gem.respond_to? :searcher
-                       # ruby 1.8/1.9
-                       Gem.searcher.init_gemspecs
-                     end
-          spec = unless searcher.nil?
-                   searcher.find do |spec|
-                     File.fnmatch(File.join(spec.full_gem_path,'*'), file)
-                   end
-                 end
-
-          spec.gem_dir
-        end
-
-
-        def self.possible_config_places(file_of_gem=nil)
-          root = gem_root_path file_of_gem
-          places = FLAVOUR_PLACES[os_flavour].dup
-          places[:internal] = %w(etc config).map do |place|
-            File.join root, place
-          end
-          places
-        end
-
-      end
-    end
-  end
-end