fedux_org-stdlib 0.6.5 → 0.6.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7418a29a232a5bc769216face7fb0944198fbf3b
-  data.tar.gz: 4d24b417091a37127912474cdb84558533a315dd
+  metadata.gz: 1e1c1b6589229f82b454ee913a23fab92aca494a
+  data.tar.gz: 916a27b4cc5109c456b93db736c2d3b72b6a6006
 SHA512:
-  metadata.gz: ac596659d174262a38364006052fd4b27b405fb032e31b876e0e5f76946f46fba899e500a2e396fe0c19edf8a51b159e18336537ff6b7618e51c96c759498607
-  data.tar.gz: 4d85e4bf3a51c2bd407fc8f78a3d2f49f2175347aa77e8f671d52429b713d4a35329132e1a45243ce5c9e3199a711583e7789d7b3b992b92568d1a54b86998fe
+  metadata.gz: f1bbd124f791e27d8371887e72979dc1bc7754c28cc884efb0e6a06203c1cfd1e4aafd5b0344df7b31b07eebd1c370fe28387c21c740d7a159e5f27f48a7cd1c
+  data.tar.gz: ea6f1b3636255e4c1ee4c61571ee15da4f24d8b6296623b8063e3b3e3b5bd1854d09dff54bd9e8b9a7282bcb30518b6bc484f64bb6c0d66e8db3a6ee517bde4f

data/lib/fedux_org_stdlib/app_config.rb

@@ -1,32 +1,34 @@
 # encoding: utf-8
 require 'fedux_org_stdlib/require_files'
-require_library %w{ json psych active_support/core_ext/string/inflections }
+require 'fedux_org_stdlib/app_config/exceptions'
+require 'fedux_org_stdlib/process_environment'
+require 'fedux_org_stdlib/core_ext/array'
+require_library %w{ json psych active_support/core_ext/string/inflections thread set active_support/hash_with_indifferent_access }
 
 module FeduxOrgStdlib
-  module Exceptions
-    # One wants to modify a locked config
-    class ConfigLocked < StandardError; end
-
-    # Found config file is not readable
-    class ConfigFileNotReadable < StandardError; end
-
-    # No allowed config file could be found
-    class NoConfigFileFound < StandardError; end
-  end
-
   # This class makes a config file available as an object. The config file
   # needs to be `YAML` by default. It is read by `Psych` and converted to a
   # hash. If you chose to use a different file format: Each config file needs
   # to translatable to a hash or another data structure which responds to
-  # `[]` by the given `config_engine`.
+  # `[]` by the given `config_engine`. If no suitable config file can be found
+  # the config uses only the defined defaults within the class.
   #
   # By default it will look for a suitable config file in the given order:
   #
-  # 1. $HOME/.config/<application_name>/<config_file>
-  # 2. $HOME/.<application_name>/<config_file>
-  # 3. /etc/.<application_name>/<config_file>
+  # 1. $HOME/.config/<application_name>/<config_file>.yaml
+  # 2. $HOME/.<application_name>/<config_file>.yaml
+  # 2. $HOME/.<config_file>.yaml
+  # 2. $HOME/.<config_file>rc
+  # 3. /etc/.<application_name>/<config_file>.yaml
   #
-  # Most conventions are implemented by separate methods. If one conventions
+  # Please keep in mind
+  #
+  # * application_name: Module of your class, e.g. "MyApplication" becomes
+  #   "my_application"
+  # * config_file: Pluarized name of your class and "Config" strip
+  #   off, e.g "ClientConfig" becomes "clients.yaml" (mind the pluralized name)
+  #
+  # Most conventions defined by me are implemented as separate methods. If one convention
   # is not suitable for your use case, just overwrite the method. 
   #
   # If you prefer to use a different path to the config file or name of the
@@ -43,31 +45,39 @@ module FeduxOrgStdlib
   #
   # Below you find some examples for the usage of the class:
   #
-  # @example Create config
+  # @example Create config with one writer and reader
+  #   module MyApplication
+  #     class ClientConfig < AppConfig
+  #       # 'data1' is the default for option1
+  #       # if you create a file
+  #       option :option1, 'data1'
+  #     end
+  #   end
   #
-  # class MyConfig < AppConfig
-  #   # This is the default if no config file exists
-  #   option :option1, 'data1'
-  # end
+  # @example Create config with a reader only
+  #   module MyApplication
+  #     class ClientConfig < AppConfig
+  #       # 'data1' is the default for option1
+  #       # if you create a file
+  #       option_reader :option1, 'data1'
+  #     end
+  #   end
   #
-  # @example Config file
-  #
-  # option1: 'data2'
+  # @example Config yaml file for the classes above: clients.yaml
+  #   ---
+  #   option1: 'data2'
   class AppConfig
-
-    # Set all neccessary class instance variables
-    def self.inherited(base)
-      base.instance_variable_set :@options, Set.new
-      base.instance_variable_set :@process_environment, ProcessEnvironment.new
-    end
-
     class << self
-      # @!attribute [r] options
-      #   Read access to defined options
-      #
-      # @!attribute [r] process_environment
-      #   Read access to environment of process using this config
-      attr_reader :options, :process_environment
+      
+      # @api private
+      def options
+        @options ||= Set.new
+      end
+
+      # @api private
+      def process_environment
+        @process_environment ||= ProcessEnvironment.new
+      end
 
       # Define a reader for option
       #
@@ -81,11 +91,17 @@ module FeduxOrgStdlib
           config.fetch(option.to_sym, default_value)
         end
 
-        @options << option
+        self.options << option
       end
 
       # Define a writer for option
       #
+      # Please make sure that you define a reader as well. Otherwise you cannot
+      # access the option. Under normal conditions it does not make sense to
+      # use this method.
+      #
+      # @api private
+      #
       # @param [Symbol] option
       #   Name of option
       #
@@ -100,7 +116,7 @@ module FeduxOrgStdlib
           end
         end
 
-        @options << option
+        self.options << option
       end
 
       # Define a writer and a reader for option
@@ -118,12 +134,17 @@ module FeduxOrgStdlib
 
     private
 
+    # @!attribute [r] config
+    #   Holds the config
     attr_reader :config
 
     public
 
     # Create a new instance of config
     #
+    # It tries to find a suitable configuration file. If it doesn't find one
+    # the config is empty and uses the defaults defined within a config class
+    #
     # @param [String] file
     #   Path where config file is stored. The file will be read by the
     #   `config_engine`.
@@ -141,23 +162,30 @@ module FeduxOrgStdlib
     #   The config instance. If the resulting data structure created by the
     #   config_engine does not respond to `:[]` an empty config object will be
     #   created. 
-    def initialize(file = available_config_file, config_engine = Psych)
-      fail Exceptions::NoConfigFileFound, JSON.dump(files: allowed_config_file_paths) unless file
+    def initialize(
+      file: available_config_file, 
+      config_engine: Psych,
+      logger: FeduxOrgStdlib::Logging::Logger.new
+    )
+      @logger = logger
 
-      config_mutex = Mutex.new
+      unless file
+        logger.debug "No configuration file found at #{allowed_config_file_paths.to_list}, using an empty config." 
+        @config = HashWithIndifferentAccess.new
 
-      yaml = config_mutex.synchronize do
-        begin
-          Psych.load_file(file)
-        rescue StandardError => e
-          fail Exceptions::ConfigFileNotReadable, JSON.dump(message: e.message, file: file)
-        end
+        return 
+      end
+
+      begin
+        yaml = Psych.load_file(file, safe: true)
+      rescue StandardError => e
+        fail Exceptions::ConfigFileNotReadable, JSON.dump(message: e.message, file: file)
       end
 
       if yaml.respond_to? :[]
-        @config = yaml.symbolize_keys
+        @config = HashWithIndifferentAccess.new(yaml.symbolize_keys)
       else
-        @config = {}
+        @config = HashWithIndifferentAccess.new
       end
     end
 
@@ -175,7 +203,7 @@ module FeduxOrgStdlib
       result << sprintf("%20s | %s", 'option', 'value')
       result << sprintf("%s + %s", '-' * 20, '-' * 80)
 
-      Config.options.each do |o|
+      self.class.options.each do |o|
         result << sprintf("%20s | %s", o, Array(public_send(o)).join(', '))
       end
 
@@ -191,7 +219,15 @@ module FeduxOrgStdlib
     #   you want to use a different file name you need to overwrite this
     #   method.
     def config_file
-      "#{config_name}.yaml"
+      "#{config_name}#{config_file_suffix}"
+    end
+
+    # The suffix of the config file
+    #
+    # @return [String]
+    #   The suffix of the config file
+    def config_file_suffix
+      '.yaml'
     end
 
     # The base name of the config
@@ -206,7 +242,11 @@ module FeduxOrgStdlib
     #
     # This will result in `client` as base name for the config file.
     def config_name
-      self.class.name.demodulize.sub(/Config/, '').underscore.pluralize
+      unless (name = class_name.sub(/Config/, '').underscore.pluralize).blank?
+        return name
+      end
+      
+      fail Exceptions::ClassNameIsMissing, JSON.dump(klass: class_name)
     end
 
     # The name of your application
@@ -223,7 +263,7 @@ module FeduxOrgStdlib
     #
     #    my_application
     def application_name
-      self.class.to_s.deconstantize.underscore
+      module_name.underscore
     end
 
     # The paths where to look for the config file
@@ -235,11 +275,21 @@ module FeduxOrgStdlib
       [
         ::File.expand_path(::File.join(self.class.process_environment.fetch('HOME'), '.config', application_name, config_file)),
         ::File.expand_path(::File.join(self.class.process_environment.fetch('HOME'), format('.%s', application_name), config_file)),
+        ::File.expand_path(::File.join(self.class.process_environment.fetch('HOME'), format('.%s', config_file))),
+        ::File.expand_path(::File.join(self.class.process_environment.fetch('HOME'), format('.%src', config_name))),
         ::File.expand_path(::File.join('/etc', application_name, config_file)),
         #          ::File.expand_path("../../../../files/#{config_file}", __FILE__),
       ]
     end
 
+    def class_name
+      self.class.name.to_s.demodulize
+    end
+
+    def module_name
+      self.class.to_s.deconstantize
+    end
+
     def available_config_file
       allowed_config_file_paths.find { |f| ::File.exists? f }
     end

data/lib/fedux_org_stdlib/app_config/exceptions.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+module FeduxOrgStdlib
+  class AppConfig
+    module Exceptions
+      # One wants to modify a locked config
+      class ConfigLocked < StandardError; end
+
+      # Found config file is not readable
+      class ConfigFileNotReadable < StandardError; end
+
+      # No allowed config file could be found
+      class NoConfigFileFound < StandardError; end
+
+      # If no module is given on class
+      class NamespaceIsMissing < StandardError; end
+
+      # If no class name is present
+      class ClassNameIsMissing < StandardError; end
+    end
+  end
+end

data/lib/fedux_org_stdlib/process_environment.rb

@@ -0,0 +1,23 @@
+# encoding: utf-8
+module FeduxOrgStdlib
+  class ProcessEnvironment
+    private
+
+    attr_reader :environment
+
+    public
+
+    def initialize(environment = ENV)
+      @environment = environment
+
+    end
+
+    def fetch(key, default_value = nil)
+      environment.to_hash.symbolize_keys.fetch(key.to_sym, default_value).to_s
+    end
+
+    def write(key, value)
+      environment[key.to_s] = value
+    end
+  end
+end

data/lib/fedux_org_stdlib/project/generators/taskjuggler.rb

@@ -8,6 +8,12 @@ module FeduxOrgStdlib
   module Project
     module Generators
       class Taskjuggler
+        # Generate report
+        #
+        # @param [String] directory
+        #   The directory where the report should be generated
+        # @param [Plan] plan
+        #   The project plan to use
         def generate_report(directory, plan)
           FeduxOrgStdlib::Project.logger.debug "Start generating report."
 
@@ -29,7 +35,6 @@ module FeduxOrgStdlib
           FeduxOrgStdlib::Project.logger.info "Generating report succeeded."
         end
       end
-
     end
   end
 end

data/lib/fedux_org_stdlib/project/plan.rb

@@ -5,19 +5,40 @@ module FeduxOrgStdlib
 
       private
 
-      attr_reader :main_file, :additional_files
+      attr_reader :main_file,
+ :additional_files
 
       public
 
-      def initialize(main_file: File.join(Dir.getwd, 'plan.tjp'), additional_files: [])
+      # Create a new project plan
+      #
+      # @param [String] main_file
+      #   The main project file
+      # @param [Array] additional_files
+      #   Additional files containing information about project plan
+      def initialize(
+        main_file: File.join(Dir.getwd, 'plan.tjp'),
+        additional_files: []
+      )
         @main_file        = main_file
         @additional_files = Array(additional_files)
       end
 
+      # Does the plan needs to be compiled
+      #
+      # @param [String] base_file
+      #   The output file which should be used to determine if the report is
+      #   older then the project plan
+      # @return [true,false]
+      #   Result of comparism
       def needs_to_be_compiled?(base_file)
         (Array(main_file) + additional_files).any? { |f| File.mtime(f) > File.mtime(base_file) }
       end
 
+      # Output a textual representation of self
+      #
+      # @return [String]
+      #   The path to the main file of the project plan
       def to_s
         main_file
       end

data/lib/fedux_org_stdlib/project/report.rb

@@ -19,6 +19,14 @@ module FeduxOrgStdlib
 
       public
 
+      # Create a new report
+      #
+      # @param [Plan] plan
+      #   Project plan to be used for report
+      # @param [String] output_file
+      #   The main output file for the report
+      # @param [Generator] generator
+      #   A generator to be used to be generator the report
       def initialize(
         plan:, 
         output_file:,
@@ -30,6 +38,7 @@ module FeduxOrgStdlib
         @generator        = generator
       end
 
+      # Generate report
       def generate
         prepare_environment
 
@@ -40,6 +49,7 @@ module FeduxOrgStdlib
         end
       end
 
+      # Open report in web browser
       def open
         Launchy.open(output_file)
       end

data/lib/fedux_org_stdlib/rake/project_task.rb

@@ -13,6 +13,31 @@ module FeduxOrgStdlib
       #   The report to be generated
       attr_reader :report
 
+      # Create a new project task
+      #
+      # @param [String] report_file
+      #   The main report file
+      # @param [String] plan_file
+      #   The main plan file
+      # @param [Array] additional_files
+      #   A list of additional files for the project plan
+      #
+      # @example Create new task
+      #   FeduxOrgStdlib::Rake::ProjectTask.new
+      #
+      # @example Create new task using a different report file
+      #   FeduxOrgStdlib::Rake::ProjectTask.new( 
+      #     report_file: File.join(Dir.getwd, 'reports', 'Index.html')
+      #   )
+      #
+      # @example Create new task using a different project plan and adding additional files
+      #   FeduxOrgStdlib::Rake::ProjectTask.new( 
+      #     plan_file: File.join(Dir.getwd, 'project1.tjp'),
+      #     additional_files: %W{
+      #     #{File.join(Dir.getwd, 'resources.tjp')}
+      #     #{File.join(Dir.getwd, 'leaves.tjp')}
+      #     }
+      #   )
       def initialize(
         report_file: File.join(Dir.getwd, 'reports', 'Overview.html'),
         plan_file: File.join(Dir.getwd, 'plan.tjp'),

data/lib/fedux_org_stdlib/rake/shell_task.rb

@@ -17,7 +17,21 @@ module FeduxOrgStdlib
       #   Use bundler to run command
       attr_reader :use_bundler
 
-      def initialize(command:, use_bundler: false, **args)
+      # Create a new shell task
+      # 
+      # @param [String] command
+      #   The command to be executed
+      #
+      # @param [true,false] use_bundler
+      #   Should the command be prefixed with `bundle exec`
+      #
+      # @see Task
+      #   For other arguments accepted
+      def initialize(
+        command:, 
+        use_bundler: false, 
+        **args
+      )
         super(**args)
 
         @use_bundler = use_bundler

data/lib/fedux_org_stdlib/rake/sub_task.rb

@@ -5,13 +5,22 @@ module FeduxOrgStdlib
   module Rake
     # Sub Task
     #
+    # This class can be used to call other defined rake-tasks
+    #
     # @see Rakefile
     class SubTask < Task
       # @!attribute [r] command
       #   The command to be executed
       attr_reader :sub_tasks
 
-      def initialize(sub_tasks:, **args)
+      # Create a new sub task task
+      #
+      # @param [Array] sub_tasks
+      #   A list of sub tasks, e.g. 'namespace1:task1', 'task2'
+      def initialize(
+        sub_tasks:, 
+        **args
+      )
         super(**args)
 
         @sub_tasks = Array(sub_tasks)

data/lib/fedux_org_stdlib/rake/task.rb

@@ -9,6 +9,9 @@ module FeduxOrgStdlib
   module Rake
     # Rake Task
     #
+    # This class is mainly used as basis for more specific class like
+    # {Shelltask} or {Projecttask}.
+    #
     # @see Rakefile
     class Task < ::Rake::TaskLib
       include ::Rake::DSL if defined?(::Rake::DSL)
@@ -31,7 +34,45 @@ module FeduxOrgStdlib
       attr_reader :task_arguments, :task_block, :logger, :working_directory
 
       # Create task instance
-      def initialize(description:, name: self.class.to_s.split(/::/).slice(-2..-1).join(':').gsub(/Task$/, '').underscore, arguments: [], define_in_ci_mode: true, activate_ci_mode: false, dependencies: [], &task_block)
+      #
+      # @param [String] description
+      #   A description for the task
+      #
+      # @param [String] name
+      #   The name for the task (including namespace), e.g. namespace1:task1
+      #
+      # @param [Array] arguments
+      #   Arguments for the task. Look
+      #   [here](http://viget.com/extend/protip-passing-parameters-to-your-rake-tasks)
+      #   for a better description on how to use arguments in rake tasks
+      #
+      # @param [true,false] define_in_ci_mode
+      #   Should the task be defined and therefor available when in Continous
+      #   Integration (CI)-mode + all needed dependencies (gems etc.)? It is
+      #   best not to include some rubygems (debugger etc.) when running in
+      #   CI-mode. CI-mode is detected by looking for a defined environment variable
+      #   'CI' (ENV['CI']).
+      #
+      # @param [true,false] activate_ci_mode
+      #   Activate CI-mode when task is called.
+      #
+      # @param [Array] dependencies
+      #   An array of other tasks this task depends on.
+      #
+      # @yield 
+      #   A block which is called before the "run_task"-method is called. The
+      #   parameters it taskes depends on the number of parameters the block
+      #   can take. If the block is defined which two parameters, it takes two
+      #   parameters from the paramter 'arguments'.
+      def initialize(
+        description:,
+        name: self.class.to_s.split(/::/).slice(-2..-1).join(':').gsub(/Task$/, '').underscore,
+        arguments: [],
+        define_in_ci_mode: true,
+        activate_ci_mode: false,
+        dependencies: [],
+        &task_block
+      )
         before_initialize
 
         @description        = description
@@ -53,8 +94,6 @@ module FeduxOrgStdlib
 
         define_task unless running_in_ci_mode?
         define_task if define_in_ci_mode? and running_in_ci_mode?
-
-        activate_ci_mode if activate_ci_mode?
       end
 
       private
@@ -75,6 +114,8 @@ module FeduxOrgStdlib
         desc description unless ::Rake.application.last_comment
 
         task name, *task_arguments do |_, task_args|
+          activate_ci_mode if activate_ci_mode?
+
           RakeFileUtils.__send__(:verbose, verbose) do
             task_block.call(*[self, task_args].slice(0, task_block.arity)) if task_block.respond_to? :call
             run_task verbose

data/lib/fedux_org_stdlib/rake/version_bump_task.rb

@@ -6,6 +6,24 @@ module FeduxOrgStdlib
   module Rake
     # Version Bump Task
     #
+    # @example Create new version task for bumping the major number X.0.0
+    #   FeduxOrgStdlib::Rake::VersionBumpTask.new(
+    #     name: 'version:bump:major', 
+    #     description: 'Bump major version part'
+    #   ) { |t| t.bump_version :major }
+    #
+    # @example Create new version task for bumping the minor number 0.X.0
+    #   FeduxOrgStdlib::Rake::VersionBumpTask.new(
+    #     name: 'version:bump:minor', 
+    #     description: 'Bump minor version part'
+    #   ) { |t| t.bump_version :minor }
+    #
+    # @example Create new version task for bumping the tiny number 0.0.X
+    #   FeduxOrgStdlib::Rake::VersionBumpTask.new(
+    #     name: 'version:bump:tiny', 
+    #     description: 'Bump tiny version part'
+    #   ) { |t| t.bump_version :tiny }
+    #
     # @see Rakefile
     class VersionBumpTask < Task
       include Versionable

data/lib/fedux_org_stdlib/version.rb

@@ -1,5 +1,5 @@
 # encoding: utf-8
 # FeduxOrgStdlib
 module FeduxOrgStdlib
-  VERSION = '0.6.5'
+  VERSION = '0.6.6'
 end

data/spec/app_config_spec.rb

@@ -4,4 +4,199 @@ require 'fedux_org_stdlib/app_config'
 
 RSpec.describe AppConfig do
 
+  context 'options' do
+    it 'creates readers and writers' do
+      with_environment 'HOME' => working_directory do
+        config_klass = Class.new(AppConfig) do
+          option :opt1, nil
+
+          def class_name
+            'TestConfig'
+          end
+
+          def module_name
+            'MyApplication'
+          end
+        end
+
+        config = config_klass.new
+        expect(config.opt1).to be_nil
+
+        config.opt1 = 'blub'
+        expect(config.opt1).to eq 'blub'
+      end
+    end
+
+    it 'creates readers' do
+      with_environment 'HOME' => working_directory do
+        config_klass = Class.new(AppConfig) do
+          option_reader :opt1, nil
+
+          def class_name
+            'TestConfig'
+          end
+
+          def module_name
+            'MyApplication'
+          end
+        end
+
+        config = config_klass.new
+        expect(config.opt1).to be_nil
+
+        expect {
+          config.opt1 = 'blub'
+        }.to raise_error NoMethodError
+      end
+    end
+
+  end
+
+  context 'config files' do
+    it 'looks at ~/.test.yaml' do
+      with_environment 'HOME' => working_directory do
+        create_file '.tests.yaml', <<-EOS.strip_heredoc
+        ---
+        opt1: hello world
+        EOS
+
+        config_klass = Class.new(AppConfig) do
+          option_reader :opt1, nil
+
+          def class_name
+            'TestConfig'
+          end
+
+          def module_name
+            'MyApplication'
+          end
+        end
+
+        config = config_klass.new
+        expect(config.opt1).to eq 'hello world'
+      end
+    end
+
+    it 'looks at ~/.config/my_application/tests.yaml' do
+      with_environment 'HOME' => working_directory do
+        create_file '.config/my_application/tests.yaml', <<-EOS.strip_heredoc
+        ---
+        opt1: hello world
+        EOS
+
+        config_klass = Class.new(AppConfig) do
+          option_reader :opt1, nil
+
+          def class_name
+            'TestConfig'
+          end
+
+          def module_name
+            'MyApplication'
+          end
+        end
+
+        config = config_klass.new
+        expect(config.opt1).to eq 'hello world'
+      end
+    end
+  end
+  it 'looks at ~/.my_application/tests.yaml' do
+    with_environment 'HOME' => working_directory do
+      create_file '.my_application/tests.yaml', <<-EOS.strip_heredoc
+        ---
+        opt1: hello world
+      EOS
+
+      config_klass = Class.new(AppConfig) do
+        option_reader :opt1, nil
+
+        def class_name
+          'TestConfig'
+        end
+
+        def module_name
+          'MyApplication'
+        end
+      end
+
+      config = config_klass.new
+      expect(config.opt1).to eq 'hello world'
+    end
+  end
+
+  it 'looks at ~/.tests.yaml' do
+    with_environment 'HOME' => working_directory do
+      create_file '.tests.yaml', <<-EOS.strip_heredoc
+        ---
+        opt1: hello world
+      EOS
+
+      config_klass = Class.new(AppConfig) do
+        option_reader :opt1, nil
+
+        def class_name
+          'TestConfig'
+        end
+
+        def module_name
+          'MyApplication'
+        end
+      end
+
+      config = config_klass.new
+      expect(config.opt1).to eq 'hello world'
+    end
+  end
+
+  it 'looks at ~/.testsrc' do
+    with_environment 'HOME' => working_directory do
+      create_file '.testsrc', <<-EOS.strip_heredoc
+        ---
+        opt1: hello world
+      EOS
+
+      config_klass = Class.new(AppConfig) do
+        option_reader :opt1, nil
+
+        def class_name
+          'TestConfig'
+        end
+
+        def module_name
+          'MyApplication'
+        end
+      end
+
+      config = config_klass.new
+      expect(config.opt1).to eq 'hello world'
+    end
+  end
+
+  context '#to_s' do
+    it 'outputs a list of variables' do
+      with_environment 'HOME' => working_directory do
+        config_klass = Class.new(AppConfig) do
+          option :opt1, 'test1'
+          option :opt2, 'test2'
+
+          def class_name
+            'TestConfig'
+          end
+
+          def module_name
+            'MyApplication'
+          end
+        end
+
+        config = config_klass.new
+        expect(config.to_s).to eq <<-EOS.strip_heredoc.chomp
+                         option | value
+           -------------------- + --------------------------------------------------------------------------------
+                           opt1 | test1
+                           opt2 | test2
+        EOS
+      end
+    end
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fedux_org-stdlib
 version: !ruby/object:Gem::Version
-  version: 0.6.5
+  version: 0.6.6
 platform: ruby
 authors:
 - Max Meyer
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-07-14 00:00:00.000000000 Z
+date: 2014-07-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -48,6 +48,7 @@ files:
 - fedux_org-stdlib.gemspec
 - lib/fedux_org_stdlib.rb
 - lib/fedux_org_stdlib/app_config.rb
+- lib/fedux_org_stdlib/app_config/exceptions.rb
 - lib/fedux_org_stdlib/ci.rb
 - lib/fedux_org_stdlib/colors/html_color.rb
 - lib/fedux_org_stdlib/command.rb
@@ -74,6 +75,7 @@ files:
 - lib/fedux_org_stdlib/models/class_based_model.rb
 - lib/fedux_org_stdlib/models/exceptions.rb
 - lib/fedux_org_stdlib/models/filesystem_based_model.rb
+- lib/fedux_org_stdlib/process_environment.rb
 - lib/fedux_org_stdlib/project.rb
 - lib/fedux_org_stdlib/project/generators/taskjuggler.rb
 - lib/fedux_org_stdlib/project/logger.rb