configliere 0.3.4 → 0.4.4

data/lib/configliere/commands.rb

@@ -1,4 +1,3 @@
-Configliere.use :commandline
 module Configliere
 
   #
@@ -6,54 +5,39 @@ module Configliere
   #
   # To include, specify
   #
-  #   Configliere.use :commands
+  #   Settings.use :commands
   #
   module Commands
-
     # The name of the command.
     attr_accessor :command_name
 
+    #
+    # FIXME: this will be refactored to look like Configliere::Define
+    #
+
     # Add a command, along with a description of its predicates and the command itself.
     def define_command cmd, options={}, &block
-      command_configuration = Configliere.new
+      cmd = cmd.to_sym
+      command_configuration = Configliere::Param.new
+      command_configuration.use :commandline, :env_var
       yield command_configuration if block_given?
       commands[cmd] = options.merge(:config => command_configuration)
     end
 
-    # Define a help command.
-    def define_help_command!
-      define_command :help, :description => "Print detailed help on each command"
-    end
-
-    # Are there any commands that have been defined?
-    def commands?
-      (! commands.empty?)
-    end
-    
-    # Is +cmd+ the name of a known command?
-    def command? cmd
-      return false if cmd.blank?
-      commands.include?(cmd) || commands.include?(cmd.to_s)
-    end
-
     def commands
-      @commands ||= Sash.new
-    end
-
-    def command
-      command_name && commands[command_name]
+      @commands ||= DeepHash.new
     end
 
-    # The Param object for the command
-    def command_settings
-      command && command[:config]
+    def command_info
+      commands[command_name]
     end
 
     def resolve!
       super()
-      commands.each_value do |command|
-        command[:config].resolve!
+      commands.each_value do |cmd_info|
+        cmd_info[:config].resolve!
       end
+      self
     end
 
     #
@@ -68,41 +52,41 @@ module Configliere
     #
     def process_argv!
       super()
-      if raw_script_name =~ /(\w+)-([\w\-]+)/
-        self.command_name = $2
-      else
-        self.command_name = rest.shift if command?(rest.first)
+      base, cmd = script_base_and_command
+      if cmd
+        self.command_name = cmd.to_sym
+      elsif (not rest.empty?) && commands.include?(rest.first.to_sym)
+        self.command_name = rest.shift.to_sym
       end
     end
 
-    # The script name without command appendix if any: For $0 equal to any of
-    # 'git', 'git-reset', or 'git-cherry-pick', base_script_name is 'git'
-    #
-    def base_script_name
-      raw_script_name.gsub(/-.*/, '')
-    end
-
     # Usage line
     def usage
-      %Q{usage: #{base_script_name} command [...--param=val...]}
+      %Q{usage: #{script_base_and_command.first} [command] [...--param=val...]}
     end
 
+ protected
+
     # Return help on commands.
-    def dump_command_help
-      help = ["Available commands"]
-      help += commands.keys.map(&:to_s).sort.map do |key|
-        "  %-27s %s" % [key.to_s, commands[key][:description]] unless commands[key][:no_help]
+    def commands_help
+      help = ["\nAvailable commands:"]
+      commands.sort_by(&:to_s).each do |cmd, info|
+        help << ("  %-27s %s" % [cmd, info[:description]]) unless info[:internal]
       end
-      help += ["\nRun `#{base_script_name} help COMMAND' for more help on COMMAND"] if command?(:help)
-      $stderr.puts help.join("\n")
+      help << "\nRun `#{script_base_and_command.first} help COMMAND' for more help on COMMAND" if commands.include?(:help)
+      help.flatten.join("\n")
+    end
+
+    # The script name without command appendix if any: For $0 equal to any of
+    # 'git', 'git-reset', or 'git-cherry-pick', base_script_name is 'git'
+    #
+    def script_base_and_command
+      raw_script_name.split('-', 2)
     end
-    
   end
 
-  Param.class_eval do
-    # include command syntax methods in chain.  Since commandline is required
-    # first at the top of this file, Commands methods sit below
-    # Commandline methods in the superclass chain.
-    include Commands
+  Param.on_use(:commands) do
+    use :commandline
+    extend Configliere::Commands
   end
 end

data/lib/configliere/config_block.rb

@@ -1,4 +1,3 @@
-Configliere.use :define
 module Configliere
   #
   # ConfigBlock lets you use pure ruby to change and define settings.  Call
@@ -8,6 +7,8 @@ module Configliere
   #     Settings.finally{|c| c.your_mom[:college] = 'went' unless (! c.mom_jokes_allowed) }
   #
   module ConfigBlock
+    #
+    # Define a block of code to run after all other settings are in place.
     #
     # @param &block each +finally+ block is called once, in the order it was
     #   defined, when the resolve! method is invoked. +config_block+ resolution
@@ -43,10 +44,11 @@ module Configliere
     def final_blocks
       @final_blocks ||= []
     end
+
     # call each +finally+ config block in the order it was defined
     def resolve_finally_blocks!
       final_blocks.each do |block|
-        block.call()
+        (block.arity == 1) ? block.call(self) : block.call()
       end
     end
   end

data/lib/configliere/config_file.rb

@@ -1,8 +1,4 @@
-require 'yaml'
-require 'fileutils'
 module Configliere
-  # Where to load params given only a symbol
-  DEFAULT_CONFIG_FILE = ENV['HOME'].to_s+'/.configliere.yaml' unless defined?(DEFAULT_CONFIG_FILE)
   # Where to load params given a bare filename
   DEFAULT_CONFIG_DIR  = ENV['HOME'].to_s+'/.configliere'      unless defined?(DEFAULT_CONFIG_DIR)
 
@@ -10,84 +6,66 @@ module Configliere
   # ConfigFile -- load configuration from a simple YAML file
   #
   module ConfigFile
-    # Load params from disk.
-    # * file is in YAML format, as a hash of handle => param_hash pairs
-    # * filename defaults to Configliere::DEFAULT_CONFIG_FILE (~/.configliere, probably)
+    # Load params from a YAML file, as a hash of handle => param_hash pairs
     #
-    # @option [String] :env
+    # @param filename [String] the file to read. If it does not contain a '/',
+    #   the filename is expanded relative to Configliere::DEFAULT_CONFIG_DIR
+    # @param options [Hash]
+    # @option options :env [String]
     #   If an :env option is given, only the indicated subhash is merged. This
     #   lets you for example specify production / environment / test settings
     #
-    # @returns [Configliere::Params] the Settings object
+    # @return [Configliere::Params] the Settings object
     #
     # @example
-    #     # Read from config/apey_eye.yaml and use settings appropriate for development/staging/production
-    #     Settings.read(root_path('config/apey_eye.yaml'), :env => (ENV['RACK_ENV'] || 'production'))
+    #     # Read from ~/.configliere/foo.yaml
+    #     Settings.read(foo.yaml)
     #
-    def read handle, options={}
-      filename = filename_for_handle(handle)
+    # @example
+    #     # Read from config/foo.yaml and use settings appropriate for development/staging/production
+    #     Settings.read(App.root.join('config', 'environment.yaml'), :env => ENV['RACK_ENV'])
+    #
+    # The env option is *not* coerced to_sym, so make sure your key type matches the file's
+    def read filename, options={}
+      if filename.is_a?(Symbol) then raise Configliere::DeprecatedError, "Loading from a default config file is no longer provided" ; end
+      filename = expand_filename(filename)
       begin
-        params = YAML.load(File.open(filename)) || {}
+        new_data = YAML.load(File.open(filename)) || {}
       rescue Errno::ENOENT => e
         warn "Loading empty configliere settings file #{filename}"
-        params = {}
+        new_data = {}
       end
-      params = params[handle] if handle.is_a?(Symbol)
       # Extract the :env (production/development/etc)
       if options[:env]
-        params = params[options[:env]] || {}
+        new_data = new_data[options[:env]] || {}
       end
-      deep_merge! params
+      deep_merge! new_data
       self
     end
 
     # save to disk.
     # * file is in YAML format, as a hash of handle => param_hash pairs
     # * filename defaults to Configliere::DEFAULT_CONFIG_FILE (~/.configliere, probably)
-    def save! handle
-      filename = filename_for_handle(handle)
-      if handle.is_a?(Symbol)
-        ConfigFile.merge_into_yaml_file filename, handle, self.export
-      else
-        ConfigFile.write_yaml_file filename, self.export
-      end
-    end
-
-  protected
-
-    # form suitable for serialization to disk
-    # (e.g. the encryption done in configliere/encrypted)
-    def export
-      super.to_hash
-    end
-
-    def self.write_yaml_file filename, hsh
+    def save! filename
+      filename = expand_filename(filename)
+      hsh = self.export.to_hash
       FileUtils.mkdir_p(File.dirname(filename))
       File.open(filename, 'w'){|f| f << YAML.dump(hsh) }
     end
 
-    def self.merge_into_yaml_file filename, handle, params
-      begin
-        all_settings = YAML.load(File.open(filename)) || {}
-      rescue Errno::ENOENT => e;
-        all_settings = {}
-      end
-      all_settings[handle] = params
-      write_yaml_file filename, all_settings
-    end
+  protected
 
-    def filename_for_handle handle
-      case
-      when handle.is_a?(Symbol)      then Configliere::DEFAULT_CONFIG_FILE
-      when handle.to_s.include?('/') then File.expand_path(handle)
-      else                                File.join(Configliere::DEFAULT_CONFIG_DIR, handle)
+    def expand_filename filename
+      if filename.to_s.include?('/')
+        File.expand_path(filename)
+      else
+        File.expand_path(File.join(Configliere::DEFAULT_CONFIG_DIR, filename))
       end
     end
-
   end
 
+  # ConfigFile is included by default
   Param.class_eval do
-    # include read / save operations
     include ConfigFile
   end
 end

data/lib/configliere/crypter.rb

@@ -1,5 +1,6 @@
-require 'openssl'
-require 'digest/sha2'
+require 'openssl'                   # for encryption
+require 'digest/sha2'               # for encryption
+require "base64"                    # base64-encode the binary encrypted string
 module Configliere
   #
   # Encrypt and decrypt values in configliere stores
@@ -22,7 +23,7 @@ module Configliere
       cipher.iv  = iv = cipher.random_iv
       ciphertext = cipher.update(plaintext)
       ciphertext << cipher.final
-      combine_iv_and_ciphertext(iv, ciphertext)
+      Base64.encode64(combine_iv_and_ciphertext(iv, ciphertext))
     end
     #
     # Decrypt the given string, using the key and iv supplied
@@ -31,7 +32,8 @@ module Configliere
     # @param [String] encrypt_pass secret passphrase to decrypt with
     # @return [String] the decrypted plaintext
     #
-    def self.decrypt iv_and_ciphertext, encrypt_pass, options={}
+    def self.decrypt enc_ciphertext, encrypt_pass, options={}
+      iv_and_ciphertext = Base64.decode64(enc_ciphertext)
       cipher    = new_cipher :decrypt, encrypt_pass, options
       cipher.iv, ciphertext = separate_iv_and_ciphertext(cipher, iv_and_ciphertext)
       plaintext = cipher.update(ciphertext)
@@ -64,7 +66,8 @@ module Configliere
 
     # Convert the encrypt_pass passphrase into the key used for encryption
     def self.encrypt_key encrypt_pass, options={}
-      raise 'Blank encryption password!' if encrypt_pass.blank?
+      encrypt_pass = encrypt_pass.to_s
+      raise 'Missing encryption password!' if encrypt_pass.empty?
       # this provides the required 256 bits of key for the aes-256-cbc cipher
       Digest::SHA256.digest(encrypt_pass)
     end

data/lib/configliere/deep_hash.rb

@@ -0,0 +1,368 @@
+#
+# A magical hash: allows deep-nested access and proper merging of settings from
+# different sources
+#
+class DeepHash < Hash
+
+  # @param constructor<Object>
+  #   The default value for the DeepHash. Defaults to an empty hash.
+  #   If constructor is a Hash, adopt its values.
+  def initialize(constructor = {})
+    if constructor.is_a?(Hash)
+      super()
+      update(constructor) unless constructor.empty?
+    else
+      super(constructor)
+    end
+  end
+
+  unless method_defined?(:regular_writer) then alias_method :regular_writer, :[]=  ; end
+  unless method_defined?(:regular_update) then alias_method :regular_update, :update  ; end
+
+  # @param key<Object> The key to check for. This will be run through convert_key.
+  #
+  # @return [Boolean] True if the key exists in the mash.
+  def key?(key)
+    attr = convert_key(key)
+    if attr.is_a?(Array)
+      fk = attr.shift
+      attr = attr.first if attr.length == 1
+      super(fk) && (self[fk].key?(attr)) rescue nil
+    else
+      super(attr)
+    end
+  end
+
+  # def include? def has_key? def member?
+  alias_method :include?, :key?
+  alias_method :has_key?, :key?
+  alias_method :member?,  :key?
+
+  # @param key<Object> The key to fetch. This will be run through convert_key.
+  # @param *extras<Array> Default value.
+  #
+  # @return [Object] The value at key or the default value.
+  def fetch(key, *extras)
+    super(convert_key(key), *extras)
+  end
+
+  # @param *indices<Array>
+  #   The keys to retrieve values for. These will be run through +convert_key+.
+  #
+  # @return [Array] The values at each of the provided keys
+  def values_at(*indices)
+    indices.collect{|key| self[convert_key(key)]}
+  end
+
+  # @param key<Object>
+  #   The key to delete from the DeepHash.
+  def delete attr
+    attr = convert_key(attr)
+    attr.is_a?(Array) ? deep_delete(*attr) : super(attr)
+  end
+
+  # @return [Hash] converts to a plain hash.
+  def to_hash
+    Hash.new(default).merge(self)
+  end
+
+  # @param hash<Hash> The hash to merge with the deep_hash.
+  #
+  # @return [DeepHash] A new deep_hash with the hash values merged in.
+  def merge(hash, &block)
+    self.dup.update(hash, &block)
+  end
+
+  alias_method :merge!, :update
+
+  # @param other_hash<Hash>
+  #   A hash to update values in the deep_hash with. The keys and the values will be
+  #   converted to DeepHash format.
+  #
+  # @return [DeepHash] The updated deep_hash.
+  def update(other_hash, &block)
+    deep_hash = self.class.new
+    other_hash.each_pair do |key, value|
+      val = convert_value(value)
+      deep_hash[key] = val
+    end
+    regular_update(deep_hash, &block)
+  end
+
+  # Return a new hash with all keys converted to symbols, as long as
+  # they respond to +to_sym+.
+  def symbolize_keys
+    dup.symbolize_keys!
+  end unless method_defined?(:symbolize_keys)
+
+  # Used to provide the same interface as Hash.
+  #
+  # @return [DeepHash] This deep_hash unchanged.
+  def symbolize_keys!; self 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
+  # Slice a hash to include only the given keys. This is useful for
+  # limiting an options hash to valid keys before passing to a method:
+  #
+  #   def search(criteria = {})
+  #     assert_valid_keys(:mass, :velocity, :time)
+  #   end
+  #
+  #   search(options.slice(:mass, :velocity, :time))
+  #
+  # If you have an array of keys you want to limit to, you should splat them:
+  #
+  #   valid_keys = [:mass, :velocity, :time]
+  #   search(options.slice(*valid_keys))
+  def slice(*keys)
+    keys = keys.map!{|key| convert_key(key) } if respond_to?(:convert_key)
+    hash = self.class.new
+    keys.each { |k| hash[k] = self[k] if has_key?(k) }
+    hash
+  end unless method_defined?(:slice)
+
+  # Replaces the hash with only the given keys.
+  # Returns a hash containing the removed key/value pairs
+  # @example
+  #   hsh = {:a => 1, :b => 2, :c => 3, :d => 4}
+  #   hsh.slice!(:a, :b)
+  #   # => {:c => 3, :d =>4}
+  #   hsh
+  #   # => {:a => 1, :b => 2}
+  def slice!(*keys)
+    keys = keys.map!{|key| convert_key(key) } if respond_to?(:convert_key)
+    omit = slice(*self.keys - keys)
+    hash = slice(*keys)
+    replace(hash)
+    omit
+  end unless method_defined?(:slice!)
+
+  # Removes the given keys from the hash
+  # Returns a hash containing the removed key/value pairs
+  #
+  # @example
+  #   hsh = {:a => 1, :b => 2, :c => 3, :d => 4}
+  #   hsh.extract!(:a, :b)
+  #   # => {:a => 1, :b => 2}
+  #   hsh
+  #   # => {:c => 3, :d =>4}
+  def extract!(*keys)
+    result = self.class.new
+    keys.each{|key| result[key] = delete(key) }
+    result
+  end unless method_defined?(:extract!)
+
+  # Allows for reverse merging two hashes where the keys in the calling hash take precedence over those
+  # in the <tt>other_hash</tt>. This is particularly useful for initializing an option hash with default values:
+  #
+  #   def setup(options = {})
+  #     options.reverse_merge! :size => 25, :velocity => 10
+  #   end
+  #
+  # Using <tt>merge</tt>, the above example would look as follows:
+  #
+  #   def setup(options = {})
+  #     { :size => 25, :velocity => 10 }.merge(options)
+  #   end
+  #
+  # The default <tt>:size</tt> and <tt>:velocity</tt> are only set if the +options+ hash passed in doesn't already
+  # have the respective key.
+  def reverse_merge(other_hash)
+    other_hash.merge(self)
+  end unless method_defined?(:reverse_merge)
+
+  # Performs the opposite of <tt>merge</tt>, with the keys and values from the first hash taking precedence over the second.
+  # Modifies the receiver in place.
+  def reverse_merge!(other_hash)
+    merge!( other_hash ){|k,o,n| o }
+  end unless method_defined?(:reverse_merge!)
+
+  # Validate all keys in a hash match *valid keys, raising ArgumentError on a mismatch.
+  # Note that keys are NOT treated indifferently, meaning if you use strings for keys but assert symbols
+  # as keys, this will fail.
+  #
+  # ==== Examples
+  #   { :name => "Rob", :years => "28" }.assert_valid_keys(:name, :age) # => raises "ArgumentError: Unknown key(s): years"
+  #   { :name => "Rob", :age => "28" }.assert_valid_keys("name", "age") # => raises "ArgumentError: Unknown key(s): name, age"
+  #   { :name => "Rob", :age => "28" }.assert_valid_keys(:name, :age) # => passes, raises nothing
+  def assert_valid_keys(*valid_keys)
+    unknown_keys = keys - [valid_keys].flatten
+    raise(ArgumentError, "Unknown key(s): #{unknown_keys.join(", ")}") unless unknown_keys.empty?
+  end unless method_defined?(:assert_valid_keys)
+
+  # Sets a member value.
+  #
+  # Given a deep key (one that contains '.'), uses it as a chain of hash
+  # memberships. Otherwise calls the normal hash member setter
+  #
+  # @example
+  #   foo = DeepHash.new :hi => 'there'
+  #   foo['howdy.doody'] = 3
+  #   foo # => { :hi => 'there', :howdy => { :doody => 3 } }
+  #
+  def []= attr, val
+    attr = convert_key(attr)
+    val  = convert_value(val)
+    attr.is_a?(Array) ? deep_set(*(attr | [val])) : super(attr, val)
+  end
+
+
+  # Gets a member value.
+  #
+  # Given a deep key (one that contains '.'), uses it as a chain of hash
+  # memberships. Otherwise calls the normal hash member getter
+  #
+  # @example
+  #   foo = DeepHash.new({ :hi => 'there', :howdy => { :doody => 3 } })
+  #   foo['howdy.doody'] # => 3
+  #   foo['hi']          # => 'there'
+  #   foo[:hi]           # => 'there'
+  #
+  def [] attr
+    attr = convert_key(attr)
+    raise if (attr == [:made])
+    attr.is_a?(Array) ? deep_get(*attr) : super(attr)
+  end
+
+  # lambda for recursive merges
+  ::DeepHash::DEEP_MERGER = proc do |key,v1,v2|
+    if (v1.respond_to?(:update) && v2.respond_to?(:update))
+      v1.update(v2.reject{|kk,vv| vv.nil? }, &DeepHash::DEEP_MERGER)
+    elsif v2.nil?
+      v1
+    else
+      v2
+    end
+  end unless defined?(::DeepHash::DEEP_MERGER)
+
+  #
+  # 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, &DeepHash::DEEP_MERGER
+  end
+
+  def deep_merge! hsh2
+    update hsh2, &DeepHash::DEEP_MERGER
+    self
+  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 = self
+    args.each  do |key|
+      hsh.regular_writer(key, self.class.new) unless hsh.has_key?(key)
+      hsh = hsh[key]
+    end
+    # 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){|h, k| h[k] || self.class.new }
+    # get leaf value
+    hsh[last_key]
+  end
+
+  #
+  # Treat hash as tree of hashes:
+  #
+  #     x = { 1 => :val, :subhash => { 1 => :val1, 2 => :val2 } }
+  #     x.deep_delete(:subhash, 1)
+  #     #=> :val
+  #     x
+  #     #=> { 1 => :val, :subhash => { 2 => :val2 } }
+  #
+  def deep_delete *args
+    last_key  = args.pop
+    last_hsh  = args.empty? ? self : (deep_get(*args)||{})
+    last_hsh.delete(last_key)
+  end
+
+protected
+  # @attr key<Object> The key to convert.
+  #
+  # @attr [Object]
+  #   The converted key. A dotted attr ('moon.cheese.type') becomes
+  #   an array of sequential keys for deep_set and deep_get
+  #
+  # @private
+  def convert_key(attr)
+    case
+    when attr.to_s.include?('.') then attr.to_s.split(".").map{|sub_attr| sub_attr.to_sym }
+    when attr.is_a?(String)      then attr.to_sym
+    else                              attr
+    end
+  end
+
+
+  # @param value<Object> The value to convert.
+  #
+  # @return [Object]
+  #   The converted value. A Hash or an Array of hashes, will be converted to
+  #   their DeepHash equivalents.
+  #
+  # @private
+  def convert_value(value)
+    if value.class == Hash   then self.class.new(value)
+    elsif value.is_a?(Array) then value.collect{|e| convert_value(e) }
+    else                          value
+    end
+  end
+
+end