easy_app_helper 0.0.9 → 1.0.0

data/lib/easy_app_helper/core/places.rb

@@ -0,0 +1,52 @@
+################################################################################
+# EasyAppHelper
+#
+# Copyright (c) 2013 L.Briais under MIT license
+# http://opensource.org/licenses/MIT
+################################################################################
+
+# Possible places regarding the OS
+# TODO: Add equivalent for Mac
+class EasyAppHelper::Core::Config::Places
+  module Unix
+    # Where could be stored admin configuration that rules all EasyAppHelper
+    # based applications.
+    POSSIBLE_PLACES = {
+
+        system: ["/etc"],
+
+        # Where could be stored global wide configuration
+        global: ["/etc",
+                 "/usr/local/etc"],
+
+        # Where could be stored user configuration
+        user:  ["#{ENV['HOME']}/.config"]
+    }
+  end
+
+  module Windows
+    # Where could be stored admin configuration that rules all EasyAppHelper
+    # based applications.
+    POSSIBLE_PLACES = {
+
+        system: ["#{ENV['systemRoot']}/Config"],
+
+        # Where could be stored global configuration
+        global: ['C:/Windows/Config',
+                 "#{ENV['ALLUSERSPROFILE']}/Application Data"],
+
+        # Where could be stored user configuration
+        user: [ENV['APPDATA']]
+    }
+  end
+
+  CONF ={
+      mingw32: Windows
+  }
+  DEFAULT = Unix
+
+  def self.get_OS_module
+    conf = CONF[RbConfig::CONFIG['target_os'].to_sym]
+    conf.nil? ? DEFAULT : conf
+  end
+end

data/lib/easy_app_helper/module_manager.rb

@@ -0,0 +1,61 @@
+################################################################################
+# EasyAppHelper
+#
+# Copyright (c) 2013 L.Briais under MIT license
+# http://opensource.org/licenses/MIT
+################################################################################
+
+module EasyAppHelper::Core
+
+end
+
+require 'easy_app_helper/core/logger'
+require 'easy_app_helper/core/base'
+require 'easy_app_helper/core/config'
+
+# This module contains the exposed methods of the framework
+# It is included and extended into EasyAppHelper
+module EasyAppHelper::ModuleManager
+
+  # @return [EasyAppHelper::Core::Logger] The application logger
+  def logger
+    @@logger
+  end
+
+  # @return [EasyAppHelper::Core::Config] The application config
+  def config
+    @@config
+  end
+
+  # Convenient method that logs at info level, but also outputs the message to STDOUT if
+  # verbose is set in the config.
+  # @param [String] msg to be displayed
+  def puts_and_logs(msg)
+    @@logger.puts_and_logs msg
+  end
+
+  def self.included(base)
+    init_core_modules
+    base.extend self
+  end
+
+  ################################################################################
+  private
+
+  def self.init_logger
+    @@logger ||= EasyAppHelper::Core::Logger.instance
+    @@logger
+  end
+
+  def self.init_config
+    @@config ||= EasyAppHelper::Core::Config.new @@logger
+    @@logger.set_app_config(@@config)
+    @@config
+  end
+
+  def self.init_core_modules
+    init_logger
+    init_config
+  end
+
+end

data/lib/easy_app_helper/version.rb

@@ -6,6 +6,5 @@
 ################################################################################
 
 module EasyAppHelper
-  # Framework version
-  EASY_APP_HELPER_VERSION = "0.0.9"
+  EASY_APP_HELPER_VERSION = "1.0.0"
 end

data/lib/easy_app_helper.rb

@@ -5,21 +5,16 @@
 # http://opensource.org/licenses/MIT
 ################################################################################
 
-require "easy_app_helper/version"
-require "easy_app_helper/common"
-require "easy_app_helper/base"
-require 'easy_app_helper/places'
-require "easy_app_helper/config"
-require "easy_app_helper/logger"
+require 'easy_app_helper/version'
 
-
-# This module will provide helpers for your applications. Currently supported
-# modules are:
-# - EasyAppHelper::Base included by default.
-# - EasyAppHelper::Logger adds logging capabilities to your scripts.
-# - EasyAppHelper::Config provides a consistent configuration framework.
+# When this module is included in any class, it mixes in automatically
+# EasyAppHelper::ModuleManager methods both into the
+# instance and the class of the instance that includes it.
+# Thus to have access to the helper methods, the only requirement is to include
+# this module...
 module EasyAppHelper
-  include EasyAppHelper::Base
+  require 'easy_app_helper/module_manager'
+  include ModuleManager
 end
 
 

data/test/test.yml

@@ -0,0 +1,7 @@
+stupid_config: true
+
+pipo: bimbo
+
+hash_example:
+  first: one
+  second: two

data/test/test2_app.rb

@@ -0,0 +1,33 @@
+#!/usr/bin/env ruby
+
+
+require 'easy_app_helper'
+
+
+# EasyAppHelper.logger.level = 0
+EasyAppHelper.puts_and_logs "Groovy baby !"
+EasyAppHelper.config[:zboubi] = "Hi shared"
+
+class A
+  include EasyAppHelper
+
+  def echo
+    puts_and_logs config[:zboubi]
+  end
+end
+
+A.new.echo
+EasyAppHelper.puts_and_logs EasyAppHelper.config[:zboubi]
+
+include EasyAppHelper
+puts_and_logs "ZBOUBI: #{config[:zboubi]}"
+config.reset
+puts_and_logs "ZBOUBI2: #{config[:zboubi]}"
+
+puts config.to_yaml
+config.script_filename = 'batch_audio_convert'
+puts 'Internal configs'
+puts config.internal_configs.to_yaml
+puts 'Resulting config'
+puts config.to_yaml
+

data/test/test3_app.rb

@@ -0,0 +1,90 @@
+#!/usr/bin/env ruby
+
+require 'easy_app_helper'
+
+# You can directly access the config or the logger through the EasyAppHelper module
+puts "The application verbose flag is #{EasyAppHelper.config[:verbose]}"
+
+# You can directly use the logger according to the command line flags
+# This will do nothing unless --debug is set and --log-level is set to the correct level
+EasyAppHelper.logger.info "Hi guys!"
+
+# Fed up with the EasyAppHelper prefix ? Just include the module where you want
+include EasyAppHelper
+
+# You can override programmatically any part of the config
+config[:debug] = true
+logger.level = 1
+config[:test] = 'Groovy'
+EasyAppHelper.logger.info "Hi guys!... again"
+
+# You can see the internals of the config
+puts config.internal_configs.to_yaml
+# Which will output
+#:modified:
+#  :content:
+#    :log-level: 1
+#    :debug: true
+#    :test: cool
+#  :source: Changed by code
+#:command_line:
+#  :content:
+#    :auto:
+#    :simulate:
+#    :verbose: true
+#    :help:
+#    :config-file:
+#    :config-override:
+#    :debug:
+#    :debug-on-err:
+#    :log-level:
+#    :log-file:
+#  :source: Command line
+#:system:
+#  :content: {}
+#  :source:
+#  :origin: EasyAppHelper
+#:global:
+#  :content: {}
+#  :source:
+#  :origin: ''
+#:user:
+#  :content: {}
+#  :source:
+#  :origin: ''
+#:specific_file:
+#  :content: {}
+
+# You see of course that the two modifications we did are in the modified sub-hash
+# And now the merged config
+puts config.to_hash
+
+# But you can see the modified part as it is:
+puts config.internal_configs[:modified]
+
+# Of course you can access it from any class
+class Dummy
+  include EasyAppHelper
+
+  def initialize
+    puts "#{config[:test]} baby !"
+    # Back to the original
+    config.reset
+    puts config.internal_configs[:modified]
+  end
+end
+
+Dummy.new
+
+# Some methods are provided to ease common tasks. For example this one will log at info level
+# (so only displayed if debug mode and log level low enough), but will also puts on the console
+# if verbose if set...
+puts_and_logs "Hi world"
+
+# It is actually one of the few methods added to regular Logger class (The added value of this logger
+# is much more to be tightly coupled with the config object). Thus could access it like that:
+logger.puts_and_logs "Hi world"
+
+# or even
+EasyAppHelper.logger.puts_and_logs "Hi world... 3 is enough."
+

data/test/test4_app.rb

@@ -0,0 +1,36 @@
+#!/usr/bin/env ruby
+
+require 'easy_app_helper'
+
+class MyApp
+  include EasyAppHelper
+
+  APP_NAME = "My super application"
+  # SCRIPT_NAME = File.basename($0, '.*')
+  VERSION = '0.0.1'
+  DESCRIPTION = 'This application is a proof of concept for EasyAppHelper.'
+
+
+  def initialize
+    # Providing this data is optional
+    config.describes_application(app_name: APP_NAME, app_version: VERSION, app_description: DESCRIPTION)
+  end
+
+
+  def run
+    if config[:help]
+      puts config.help
+      exit 0
+    end
+    puts_and_logs "Application is starting"
+    do_some_processing
+  end
+
+  def do_some_processing
+    puts_and_logs "Starting some heavy processing"
+  end
+
+end
+
+
+MyApp.new.run

data/test/test_app.rb

@@ -0,0 +1,56 @@
+#!/usr/bin/env ruby
+
+
+require 'easy_app_helper'
+
+
+class Pipo
+  include EasyAppHelper
+
+
+  def toto
+    puts_and_logs "Now from a second class"
+    puts_and_logs config.to_hash
+  end
+end
+
+
+
+class TestApp
+  include EasyAppHelper
+
+  def initialize
+    #config.script_filename = File.basename $0
+    config.app_name = 'Test application'
+    #config.app_description = 'Best app to test the framework'
+    #config.app_version = '1.0.0'
+    puts_and_logs "Hello World"
+    p = Pipo.new.toto
+    config.script_filename = 'batch_audio_convert'
+    puts config.to_hash
+    config.internal_configs.each do |layer|
+      puts layer
+    end
+    add_cmd_line_options
+    puts config.help
+    logger.error "INTARG: #{config[:intarg]}"
+
+    # puts config.help
+  end
+
+  def add_cmd_line_options
+    config.add_command_line_section do |slop|
+      slop.on :s, :stupid, 'Stupid option', :argument => false
+      slop.on :i, :intarg, 'Stupid option with integer argument', :argument => true, :as => Integer
+    end
+  end
+
+end
+
+t = TestApp.new
+include EasyAppHelper
+logger.warn "Yeah"
+EasyAppHelper.logger.error "Groovy baby !"
+puts_and_logs "Hey man"
+#puts config.inspect
+puts "bye"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: easy_app_helper
 version: !ruby/object:Gem::Version
-  version: 0.0.9
+  version: 1.0.0
 platform: ruby
 authors:
 - L.Briais
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-06-06 00:00:00.000000000 Z
+date: 2013-06-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -80,12 +80,18 @@ files:
 - Rakefile
 - easy_app_helper.gemspec
 - lib/easy_app_helper.rb
-- lib/easy_app_helper/base.rb
-- lib/easy_app_helper/common.rb
-- lib/easy_app_helper/config.rb
-- lib/easy_app_helper/logger.rb
-- lib/easy_app_helper/places.rb
+- lib/easy_app_helper/core/base.rb
+- lib/easy_app_helper/core/config.rb
+- lib/easy_app_helper/core/logger.rb
+- lib/easy_app_helper/core/merge_policies.rb
+- lib/easy_app_helper/core/places.rb
+- lib/easy_app_helper/module_manager.rb
 - lib/easy_app_helper/version.rb
+- test/test.yml
+- test/test2_app.rb
+- test/test3_app.rb
+- test/test4_app.rb
+- test/test_app.rb
 homepage: https://github.com/lbriais/easy_app_helper
 licenses:
 - MIT
@@ -111,5 +117,10 @@ signing_key:
 specification_version: 4
 summary: Provides cool helpers to your application, including configuration and logging
   features
-test_files: []
+test_files:
+- test/test.yml
+- test/test2_app.rb
+- test/test3_app.rb
+- test/test4_app.rb
+- test/test_app.rb
 has_rdoc: 

data/lib/easy_app_helper/base.rb

@@ -1,211 +0,0 @@
-################################################################################
-# EasyAppHelper 
-#
-# Copyright (c) 2013 L.Briais under MIT license
-# http://opensource.org/licenses/MIT
-################################################################################
-
-require 'slop'
-
-# Once this module is included in your class which may be in the "application class",
-# you probably want to call the init_app_helper method as first statement of your
-# initialize method.
-#
-# This module provides some basic command line options ({using the slop gem}[https://rubygems.org/gems/slop])
-# and 
-# initializes all included EasyAppHelper modules (which may themselves add their
-# own command line options). Calling the init_app_helper method is the only thing
-# required to instanciate the whole framework.
-#
-# You can access to any command line option value through the app_config hash attribute.
-#
-# If you want to add any extra command line option to the one provided by default 
-# by this module or by any other EasyAppHelper modules, then your class just needs
-# to respond to add_specifc_command_line_options(opt).
-# The opt object is a Slop object that enables to define any extra command line
-# options.
-#
-# Passing the --help option to the program will cause this module to display the 
-# inline help and to exit.
-module EasyAppHelper::Base
-
-  include EasyAppHelper::Common
-
-
-  @app_config = {}
-
-  # Gives access to the application config. This should be the only attribute you will
-  # use once this module is fully configured.
-  attr_accessor :app_config
-
-  # Gives access to the initial command line options. Just for information as already 
-  # merged into the app_config.
-  def app_cmd_line_options
-    @slop_definition.nil? ? {} : @slop_definition.to_hash
-  end
-
-  # This method initializes the whole EasyAppHelper helpers framework.
-  # Even if only the first parameter is mandatory, you may pass all of them if you want
-  # consistent inline help to be displayed.
-  def init_app_helper(script_filename,
-                      app_name="Undefined application name",
-                      app_description="No description available",
-                      app_version="unknown")
-    # A brand new config is created.
-    @app_config = {}
-    # Initialize default options, and creates @slop_definition.
-    build_default_command_line_options script_filename, app_name, app_description, app_version
-    # Process all actions on EasyAppHelper modules that change app_config or add command
-    # line options.
-    process_helpers_instanciators script_filename, app_name, app_description, app_version
-    # Provides possibility to the script writer to add its own command line options
-    add_script_specific_cmd_line_options
-    # Parses command line options, and merges with the app_config
-    merge_cmd_line_options_into_config
-    # Performs modules entry points
-    process_helpers_post_config_actions
-    # check if help is requested.
-    check_help_option_invoked
-    # Log useful debug info
-    log_debug_info
-  end
-
-
-
-  # Returns the text of the inline help. Generated by Slop.
-  def help
-    @slop_definition.to_s
-  end
-
-  # Provides access to a standard logger, fully configured according to command line options
-  # or config files.
-  def logger
-    return @logger unless @logger.nil?
-    return EasyAppHelper::Common::DummyLogger.instance
-  end
-
-
-  ################################################################################
-  private 
-
-  # Checks EasyAppHelper modules and perform some actions on them.
-  # - Does it add some command line options? Then add them by calling add_cmd_line_options
-  # - Does it modify app_config? Then call provides_config. 
-  def process_helpers_instanciators(script_filename, app_name, app_description, app_version)
-    begin
-      if (ENV['DEBUG_EASY_MODULES'])
-        @logger = Logger.new(STDOUT)
-        @logger.level = Logger::Severity::DEBUG
-      end
-      process_helper_modules_instanciators do |mod|
-        # Command line: Does the module add some command line options ?
-        if mod.respond_to? :add_cmd_line_options
-          mod.add_cmd_line_options self, @slop_definition
-        end
-        # Does the module modify the global configuration
-        if mod.respond_to? :provides_config
-          module_config = mod.provides_config self, script_filename, app_name, app_description, app_version
-          @app_config = EasyAppHelper::Common.override_config app_config, module_config
-        end
-      end
-    ensure
-      unless @logger.nil?
-        @logger = nil
-      end
-    end
-  end
-
-  # Call each post config action for modules if any.
-  def process_helpers_post_config_actions
-    process_helper_modules_instanciators do |mod|
-      if mod.respond_to? :post_config_action
-        mod.post_config_action self
-      end
-    end
-  end
-
-
-
-
-
-  # Utility method to process EasyAppHelper modules in order of priority.
-  def process_helper_modules_instanciators
-    self.class.included_modules
-      .map {|mod| mod if mod.name =~ /^EasyAppHelper::/}
-      .compact
-      .map {|mod| mod::Instanciator}
-      .sort {|a,b| a::MODULE_PRIORITY <=> b::MODULE_PRIORITY }
-      .each {|mod| logger.debug "Processing helper module: #{mod.name}"; yield mod}
-  end
-
-  def merge_cmd_line_options_into_config
-    @slop_definition.parse!
-    @app_config = EasyAppHelper::Common.override_config app_config, @slop_definition.to_hash
-  end
-
-  # Builds common used command line options
-  def build_default_command_line_options(script_filename, app_name, app_description, app_version)
-    # Default options
-    @slop_definition = Slop.new do
-      banner "\nUsage: #{script_filename} [options]\n#{app_name} Version: #{app_version}\n\n#{app_description}"
-      separator "-- Generic options -------------------------------------------"
-      on :auto, 'Auto mode. Bypasses questions to user.', :argument => false
-      on :simulate, 'Do not perform the actual underlying actions.', :argument => false
-      on :v, :verbose, 'Enable verbose mode.', :argument => false
-      on :h, :help, 'Displays this help.', :argument => false
-    end
-  end
-
-  # Hook for the script to add its own command line options
-  #
-  # Just need to implement a add_specifc_command_line_options method that tal=ke a slop object as parameter
-  def add_script_specific_cmd_line_options
-    if self.respond_to? :add_specifc_command_line_options
-      @slop_definition.separator "\n-- Script specific options------------------------------------"
-      self.add_specifc_command_line_options @slop_definition
-    end
-  end
-
-  # Check if the help command line option has been passed and if the case,
-  # display the inline help and exits the program.
-  def check_help_option_invoked
-    return unless app_config[:help]
-    puts self.help
-    exit 0
-  end
-
-  # Displays useful debug info after all EasyAppHelper modules initialization.
-  def log_debug_info
-    return unless app_config[:debug] || app_config[:'debug-on-err']
-    size = ENV.keys.map {|k| k.length }.max + 1
-    logger.debug '-' * 80
-    logger.debug " Script environment variables"
-    logger.debug '-' * 80
-    # print formatted environment
-    ENV.sort.each {|k,v| logger.debug "- %-#{size}s %s" % ["#{k}:", v] }
-    logger.debug '-' * 80
-    logger.debug " Script Ruby load path"
-    logger.debug '-' * 80
-    $:.each {|p| logger.debug p}
-    logger.debug '-' * 80
-    logger.debug " Script command line parameters"
-    logger.debug '-' * 80
-    size = app_cmd_line_options.to_hash.keys.map {|k| k.length }.max + 1
-    app_cmd_line_options.to_hash.sort.each {|k,v| logger.debug "- %-#{size}s %s" % ["#{k}:", v] }
-    logger.debug '-' * 80
-    logger.debug " Script global configuration"
-    logger.debug '-' * 80
-    logger.debug "\n" + app_config.to_yaml
-    logger.debug '-' * 80
-  end
-
-end
-
-
-module EasyAppHelper::Base::Instanciator
-  extend EasyAppHelper::Common::Instanciator
-
-  # Default module priority
-  MODULE_PRIORITY = 10
-
-end