configliere 0.0.1

data/examples/commandline_script.rb

@@ -0,0 +1,74 @@
+#!/usr/bin/env ruby
+require 'rubygems' ; $: << File.dirname(__FILE__)+'/../lib'
+require 'pp'
+# module Configliere ; DEFAULT_CONFIG_FILENAME = File.dirname(__FILE__)+'/commandline_script.yaml' end
+require 'configliere'
+
+Settings.use :all
+
+puts %Q{
+This is a demo of the Configliere interface. It parses all command line options to load keys, global options, etc.
+
+Try running it as
+
+   PLACES='go' NOISES='who' ./examples/simple_script.rb --cat=hat
+
+which should create
+
+  expect: {:password=>"zike_bike", :horton=>{:hears_a=>"who"}, :key=>"asdf", :cat=>"hat", :things=>["thing_1", "thing_2"], :rate_per_hour=>10, :places=>"go", :wocket=>"pocket"}
+}
+
+# describe and define params
+Settings.define :cat,    :description => 'The type of feline haberdashery to include in the story', :required => true, :type => Symbol
+Settings.define :wocket, :description => 'where the wocket is residing'
+Settings.define :password, :encrypted => true
+
+# static settings
+Settings :wocket => 'pocket', :key => 'asdf'
+# from environment
+Settings.environment_variables 'PLACES', 'NOISES' => 'horton.hears_a'
+
+# from config file
+Settings.read(File.dirname(__FILE__)+'/commandline_script.yaml')
+
+# from finally block
+Settings.finally do |c|
+  c.lorax = 'tree'
+end
+
+# bookkeeping
+Settings.resolve!
+# Get the value for param[:key] from the keyboard if missing
+Settings.param_or_ask :key
+
+# Print results
+print '  actual: '
+p Settings
+
+
+fiddle = Configliere.new; fiddle.encrypt_pass = 'pass'
+fiddle.define 'amazon.api.key', :encrypted => true
+fiddle['amazon.api.encrypted_key'] = "{bo\335\256nt2Rc\016\244\216c\030\2627g\233%\300\035l\225\325\305z\207LR\333\035"
+fiddle.resolve!
+puts  'expect: [nil, "bite_me"]'
+print "actual: "; p [fiddle['amazon.api.encrypted_key'], fiddle['amazon.api.key'], fiddle.send(:export)]
+#
+fiddle = Configliere.new; fiddle.encrypt_pass = 'pass'
+fiddle.define 'amazon.api.key', :encrypted => true
+fiddle['amazon.api.key'] = 'bite_me'
+fiddle.resolve!
+puts  'expect: [nil, "bite_me"]'
+print "actual: "; p [fiddle['amazon.api.encrypted_key'], fiddle['amazon.api.key'], fiddle.send(:export)]
+#
+fiddle = Configliere.new; fiddle.encrypt_pass = 'pass'
+fiddle.define 'amazon.api.key', :encrypted => true
+fiddle['amazon.api.encrypted_key'] = "{bo\335\256nt2Rc\016\244\216c\030\2627g\233%\300\035l\225\325\305z\207LR\333\035"
+# fiddle.resolve!
+puts  'expect: ["{bo\335\256nt2Rc\016\244\216c\030\2627g\233%\300\035l\225\325\305z\207LR\333\035", nil]'
+print "actual: "; p [fiddle['amazon.api.encrypted_key'], fiddle['amazon.api.key'], fiddle.send(:export)]
+
+
+
+# save to disk
+# you can check that :password and :api_key have been properly encrypted.
+Settings.save! File.dirname(__FILE__)+'/foo.yaml'

data/examples/commandline_script.yaml

@@ -0,0 +1,8 @@
+--- 
+:encrypted_password: !binary |
+  el58XhZZYLJ+IZZ1/Q1ab/JSyI7KuYyj8+dgf2vW9Fw=
+
+:things: 
+- thing_1
+- thing_2
+:rate_per_hour: 10

data/examples/foo.yaml

@@ -0,0 +1,15 @@
+--- 
+:horton: 
+  :hears_a: who
+:wocket: pocket
+:encrypted_password: !binary |
+  BdwUvxy0xWh2oB5yWKm/BZ099E6pi+6Al+k09PoPik4=
+
+:things: 
+- thing_1
+- thing_2
+:lorax: tree
+:rate_per_hour: 10
+:cat: :hat
+:key: asdf
+:places: go

data/examples/simple_script.rb

@@ -0,0 +1,23 @@
+#!/usr/bin/env ruby
+require 'rubygems' ; $: << File.dirname(__FILE__)+'/../lib'
+require 'configliere'
+SCRIPT_DIR = File.dirname(__FILE__)
+
+# Intro text
+puts %Q{
+This is a demo of the Configliere interface. It takse settings
+Try running it as
+   ./examples/simple_script.rb --cat=hat
+with those args, we
+  expect: {:things=>["thing_1", "thing_2"], :rate_per_hour=>10, :cat=>"hat"}
+}
+
+# Configuration
+Settings.use :commandline, :param_store, :config_blocks
+Settings.read SCRIPT_DIR+'/simple_script.yaml'
+
+Settings.resolve!
+
+# Print results
+print '  actual: '
+p Settings

data/examples/simple_script.yaml

@@ -0,0 +1,5 @@
+--- 
+:things: 
+- thing_1
+- thing_2
+:rate_per_hour: 10

data/lib/configliere.rb

@@ -0,0 +1,36 @@
+require 'configliere/core_ext'
+require 'configliere/param'
+
+module Configliere
+  # Where to load params given only a symbol
+  DEFAULT_CONFIG_FILE = ENV['HOME']+'/.configliere.yaml' unless defined?(DEFAULT_CONFIG_FILE)
+  # Where to load params given a bare filename
+  DEFAULT_CONFIG_DIR  = ENV['HOME']+'/.configliere'      unless defined?(DEFAULT_CONFIG_DIR)
+
+  #
+  #
+  # delegates to Configliere::Param
+  def self.new *args, &block
+    Configliere::Param.new *args, &block
+  end
+
+  ALL_MIXINS = [:define, :encrypted, :environment, :param_store, :commandline, :config_blocks]
+  def self.use *mixins
+    mixins = ALL_MIXINS if mixins.include?(:all)
+    mixins.each do |mixin|
+      require "configliere/#{mixin}"
+    end
+  end
+end
+
+# Defines a global config object
+Settings = Configliere.new unless defined?(Settings)
+
+#
+# Allows the
+#   Config :this => that, :cat => :hat
+# pattern.
+#
+def Settings *args
+  Settings.defaults *args
+end

data/lib/configliere/commandline.rb

@@ -0,0 +1,102 @@
+# Configliere.use :define
+module Configliere
+
+  #
+  # Command line tool to manage param info
+  #
+  module Commandline
+    attr_accessor :rest
+
+    def resolve!
+      process_argv!
+      dump_help_if_requested
+      begin ; super() ; rescue NoMethodError ; nil ; end
+    end
+
+    #
+    # Parse the command-line args into the params hash.
+    #
+    # '--happy_flag'   produces :happy_flag => true in the params hash
+    # '--foo=foo_val'  produces :foo => 'foo_val' in the params hash.
+    # '--'             Stop parsing; all remaining args are piled into :rest
+    #
+    # self.rest        contains all arguments that don't start with a '--'
+    #                  and all args following the '--' sentinel if any.
+    #
+    def process_argv!
+      args = ARGV.dup
+      self.rest = []
+      until args.empty? do
+        arg = args.shift
+        case
+        when arg == '--'
+          self.rest += args
+          break
+        when arg =~ /\A--([\w\-\.]+)(?:=(.*))?\z/
+          param, val = [$1, $2]
+          param.gsub!(/\-/, '.')
+          if    val == nil then val = true     # --flag    option on its own means 'set that option'
+          elsif val == ''  then val = nil  end # --flag='' the explicit empty string means nil
+          self[param] = val
+        else
+          self.rest << arg
+        end
+      end
+    end
+
+    # If your script uses the 'script_name verb [...params...]'
+    # pattern, list the commands here:
+    COMMANDS= {}
+
+    # Configliere internal params
+    def define_special_params
+      Settings.define :encrypt_pass, :description => "Passphrase to extract encrypted config params.", :internal => true
+    end
+
+    # All commandline name-value params that aren't internal to configliere
+    def normal_params
+      reject{|param, val| param_definitions[param][:internal] }
+    end
+
+    # die with a warning
+    def die str
+      puts help
+      warn "\n****\n#{str}\n****"
+      exit -1
+    end
+
+    # Retrieve the given param, or prompt for it
+    def param_or_ask attr, hint=nil
+      return self[attr] if include?(attr)
+      require 'highline/import'
+      self[attr] = ask("#{attr}"+(hint ? " for #{hint}?" : '?'))
+    end
+
+    def help
+      help_str  = [ usage ]
+      help_str += [ "\nParams:", descriptions.map{|param, desc| "  %-20s %s"%[param.to_s+':', desc]}.join("\n"), ] if respond_to?(:descriptions)
+      # help_str += ["\nCommands", commands.map{|cmd, desc| "  %-20s %s"%[cmd.to_s+':', desc]}.join("\n")] if respond_to?(:commands)
+      help_str += [ "\nEnvironment Variables:", params_from_environment.map{|param, env| "  %-20s %s"%[env.to_s+':', param]}.join("\n"), ] if respond_to?(:params_from_environment)
+      help_str.join("\n")
+    end
+
+    # Usage line
+    def usage
+      %Q{usage: #{File.basename($0)} [...--param=val...]}
+    end
+
+  protected
+
+    # Ouput the help string if requested
+    def dump_help_if_requested
+      return unless self[:help]
+      $stderr.puts help
+      exit
+    end
+  end
+
+  Param.class_eval do
+    # include read / save operations
+    include Commandline
+  end
+end

data/lib/configliere/commandline/commands.rb

@@ -0,0 +1,30 @@
+require 'logger'
+Log = Logger.new(STDERR) unless defined?(Log)
+module Configliere
+  class CommandClient < Client
+    attr_accessor :command
+    COMMANDS[:help] = "Show this usage info"
+
+    def usage
+      %Q{usage: #{File.basename($0)} command [...--option=val...]
+where
+  command:             One of: #{COMMANDS.keys[0..-2].join(', ')} or #{COMMANDS.keys.last}
+
+Configuration taken from #{configliere_file} by default.}
+    end
+
+    #
+    # Run the command
+    #
+    def run
+      dump_help_if_requested
+      # Check options
+      die "Please give a command and the name of the configliere group to encrypt" unless command
+      die "Please give the name of the configliere group to encrypt" unless handle || ([:help, :list].include?(command))
+      die "\n**\nUnknown command\n**\n" unless COMMANDS.include?(command)
+      #
+      self.send(command)
+    end
+
+  end
+end

data/lib/configliere/commandline/options.rb

@@ -0,0 +1,4 @@
+module Configliere
+  class Client
+  end
+end

data/lib/configliere/config_blocks.rb

@@ -0,0 +1,41 @@
+Configliere.use :define
+module Configliere
+  module Block
+    # Config blocks to be executed at end of resolution (just before validation)
+    attr_accessor :final_blocks
+    def final_blocks
+      @final_blocks ||= []
+    end
+
+    # @param param the setting to describe. Either a simple symbol or a dotted param string.
+    # @param definitions the defineables to set (:description, :type, :encrypted, etc.)
+    #
+    # @example
+    #   Settings.define :dest_time, :type => Date, :description => 'Arrival time. If only a date is given, the current time of day on that date is assumed.'
+    #   Settings.define 'delorean.power_source', :description => 'Delorean subsytem supplying power to the Flux Capacitor.'
+    #   Settings.define :password, :required => true, :obscure => true
+    #
+    def finally &block
+      self.final_blocks << block
+    end
+
+    # calls superclass resolution
+    def resolve!
+      begin ; super() ; rescue NoMethodError ; nil ; end
+      resolve_finally_blocks!
+      self
+    end
+
+  protected
+    def resolve_finally_blocks!
+      final_blocks.each do |block|
+        block.call(self)
+      end
+    end
+
+  end
+
+  Param.class_eval do
+    include Configliere::Block
+  end
+end

data/lib/configliere/core_ext.rb

@@ -0,0 +1 @@
+require 'configliere/core_ext/hash'

data/lib/configliere/core_ext/hash.rb

@@ -0,0 +1,98 @@
+#
+# core_ext/hash.rb -- hash extensions
+#
+class Hash
+
+  # lambda for recursive merges
+  Hash::DEEP_MERGER = proc do |key,v1,v2|
+    (v1.respond_to?(:merge) && v2.respond_to?(:merge)) ? v1.merge(v2.compact, &Hash::DEEP_MERGER) : (v2.nil? ? v1 : v2)
+  end
+
+  #
+  # Merge hashes recursively.
+  # Nothing special happens to array values
+  #
+  #     x = { :subhash => { 1 => :val_from_x, 222 => :only_in_x, 333 => :only_in_x }, :scalar => :scalar_from_x}
+  #     y = { :subhash => { 1 => :val_from_y, 999 => :only_in_y },                    :scalar => :scalar_from_y }
+  #     x.deep_merge y
+  #     => {:subhash=>{1=>:val_from_y, 222=>:only_in_x, 333=>:only_in_x, 999=>:only_in_y}, :scalar=>:scalar_from_y}
+  #     y.deep_merge x
+  #     => {:subhash=>{1=>:val_from_x, 222=>:only_in_x, 333=>:only_in_x, 999=>:only_in_y}, :scalar=>:scalar_from_x}
+  #
+  # Nil values always lose.
+  #
+  #     x = {:subhash=>{:nil_in_x=>nil, 1=>:val1,}, :nil_in_x=>nil}
+  #     y = {:subhash=>{:nil_in_x=>5},              :nil_in_x=>5}
+  #     y.deep_merge x
+  #     => {:subhash=>{1=>:val1, :nil_in_x=>5}, :nil_in_x=>5}
+  #     x.deep_merge y
+  #     => {:subhash=>{1=>:val1, :nil_in_x=>5}, :nil_in_x=>5}
+  #
+  def deep_merge hsh2
+    merge hsh2, &Hash::DEEP_MERGER
+  end
+
+  def deep_merge! hsh2
+    merge! hsh2, &Hash::DEEP_MERGER
+  end
+
+  #
+  # Treat hash as tree of hashes:
+  #
+  #     x = { 1 => :val, :subhash => { 1 => :val1 } }
+  #     x.deep_set(:subhash, :cat, :hat)
+  #     # => { 1 => :val, :subhash => { 1 => :val1,   :cat => :hat } }
+  #     x.deep_set(:subhash, 1, :newval)
+  #     # => { 1 => :val, :subhash => { 1 => :newval, :cat => :hat } }
+  #
+  #
+  def deep_set *args
+    val      = args.pop
+    last_key = args.pop
+    # dig down to last subtree (building out if necessary)
+    hsh = args.empty? ? self : args.inject(self){|hsh, key| hsh[key] ||= {} }
+    # set leaf value
+    hsh[last_key] = val
+  end
+
+  #
+  # Treat hash as tree of hashes:
+  #
+  #     x = { 1 => :val, :subhash => { 1 => :val1 } }
+  #     x.deep_get(:subhash, 1)
+  #     # => :val
+  #     x.deep_get(:subhash, 2)
+  #     # => nil
+  #     x.deep_get(:subhash, 2, 3)
+  #     # => nil
+  #     x.deep_get(:subhash, 2)
+  #     # => nil
+  #
+  def deep_get *args
+    last_key = args.pop
+    # dig down to last subtree (building out if necessary)
+    hsh = args.inject(self){|hsh, key| hsh[key] || {} }
+    # get leaf value
+    hsh[last_key]
+  end
+
+  def deep_delete *args
+    last_key  = args.pop
+    last_hsh  = args.empty? ? self : (deep_get(*args)||{})
+    last_hsh.delete(last_key)
+  end
+
+  #
+  # remove all key-value pairs where the value is nil
+  #
+  def compact
+    reject{|key,val| val.nil? }
+  end
+  #
+  # Replace the hash with its compacted self
+  #
+  def compact!
+    replace(compact)
+  end
+
+end