everyday-cli-utils 1.4.0 → 1.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: bb045208150105efa9606f2f664bec0b98339044
-  data.tar.gz: b1a094050c0298cff7a93315b02058e7833d5a11
+  metadata.gz: 5f9fc1d7f33b7176bce22227eb740e2ac62471de
+  data.tar.gz: 618d8eec3dba4932423a28cd162f17876dbc778f
 SHA512:
-  metadata.gz: c0352f72cadc509d1158b54203755c7476ba68b018a87d845f21ade0cde965ed42ce44e12eddea2ffdff5c0a8706812b521b3687abbb48a52548a2d4bbd51937
-  data.tar.gz: 8480de538db701d0fd034e2e69767464bad8b1be7d3d1005ddf3e727f08d71b4125e83a4a3b6953de4def1b18fbfb6f68c334506bd0755f31bd2a99c4ed1da17
+  metadata.gz: 62e8a9e6fecc2acaf672c576792209e4b81a843a908cb970f6325495b5d0f67f822787bf8d2ba846dd765e3a959861cc9af0a8ed3bafbdfe67f6971450908d6a
+  data.tar.gz: 00230d29037dda5978fd74d37e04720a4e71d60f2867e26dd3f15f337eb0362da0e6f9ebf07973332463b7cdec964f422991606d8cfe9ae746a11eb33007e926

data/README.md

@@ -338,6 +338,10 @@ As of version 0.7.0, there is now built-in handling for setting and retrieving d
 
 As of version 1.0.0, there is now support for the help display in `OptionParser`.  You can now provide a `desc:` hash option to the option creating methods (even pre-made ones like `defaults_option` and `help_option`).  You can set the banner with the `EverydayCliUtils::OptionUtil.banner` method, which takes the banner string as its parameter.  You can get the help string with `EverydayCliUtils::OptionUtil.help` or `EverydayCliUtils::OptionUtil.to_s`, or you can handle it with `EverydayCliUtils::OptionUtil.help_option`, which takes an array of the names and an optional `desc:` hash option.  When the user specifies one of those options, the utility will automatically print out the help and exit (unless you specify the hash option `exit_on_print: false`).
 
+As of version 1.4.0, there is support for overriding the built-in help display.  You can now use the `help_str=` method to set the help string override.  See my `mvr` gem for an example.
+
+As of version 1.5.0, there is support for having global defaults.  It is basically the same as the regular defaults option, but it uses the method `global_default_options` instead of just `default_options`.  If the global defaults file exists, it will be loaded first, with the local defaults being loaded on top of it as if they were passed as flags, and then the flags are loaded on top of that in the same manner.
+
 ## Contributing
 
 1. Fork it ( http://github.com/henderea/everyday-cli-utils/fork )

data/lib/everyday-cli-utils/option.rb

@@ -22,93 +22,273 @@ module EverydayCliUtils
     end
   end
 
-  module OptionUtil
-    attr_reader :options, :opts
+  class OptionType
+    def initialize(default_value_block, value_determine_block, name_mod_block = nil, value_transform_block = nil)
+      @default_value_block   = default_value_block
+      @value_determine_block = value_determine_block
+      @name_mod_block        = name_mod_block
+      @value_transform_block = value_transform_block
+    end
 
-    def option(opt_name, names, settings = {})
-      @opts             ||= OptionParser.new
-      @options          ||= {}
-      @default_settings ||= {}
-      settings[:toggle] = @default_settings[:toggle] unless settings.has_key?(:toggle) || !@default_settings.has_key?(:toggle)
-      names << settings[:desc] if settings.has_key?(:desc)
-      @options[opt_name] = false
-      @opts.on(*names) {
-        @options[opt_name] = !settings[:toggle] || !@options[opt_name]
-        yield if block_given?
-      }
+    def default_value(settings = {})
+      @default_value_block.call(settings)
     end
 
-    def option_with_param(opt_name, names, settings = {})
-      @opts             ||= OptionParser.new
-      @options          ||= {}
-      @default_settings ||= {}
-      settings[:append] = @default_settings[:append] unless settings.has_key?(:append) || !@default_settings.has_key?(:append)
-      settings[:type]   = @default_settings[:type] unless settings.has_key?(:type) || !@default_settings.has_key?(:type)
-      names[0] << ' PARAM' unless names.any? { |v| v.include?(' ') }
-      names << settings[:desc] if settings.has_key?(:desc)
-      @options[opt_name] = settings[:append] ? [] : nil
-      @opts.on(*names, settings[:type] || String) { |param|
-        settings[:append] ? @options[opt_name] << param : @options[opt_name] = param
-        yield if block_given?
+    def updated_value(current_value, new_value, settings = {})
+      new_value = @value_transform_block.call(new_value, settings) unless @value_transform_block.nil?
+      @value_determine_block.call(current_value, new_value, settings)
+    end
+
+    def mod_names(names, settings = {})
+      @name_mod_block.call(names, settings)
+    end
+  end
+
+  class OptionTypes
+    def self.def_type(type, default_value_block, value_determine_block, name_mod_block = nil, value_transform_block = nil)
+      @types       ||= {}
+      @types[type] = OptionType.new(default_value_block, value_determine_block, name_mod_block, value_transform_block)
+    end
+
+    def self.default_value(type, settings = {})
+      @types ||= {}
+      @types.has_key?(type) ? @types[type].default_value(settings) : nil
+    end
+
+    def self.updated_value(type, current_value, new_value, settings = {})
+      @types ||= {}
+      @types.has_key?(type) ? @types[type].updated_value(current_value, new_value, settings) : current_value
+    end
+
+    def self.mod_names(type, names, settings = {})
+      @types ||= {}
+      @types.has_key?(type) ? @types[type].mod_names(names, settings) : names
+    end
+
+    def_type(:option,
+             ->(_) {
+               false
+             },
+             ->(current_value, new_value, settings) {
+               new_value ? (!settings[:toggle] || !current_value) : current_value
+             },
+             ->(names, settings) {
+               settings.has_key?(:desc) ? (names + [settings[:desc]]) : names
+             },
+             ->(new_value, _) {
+               !(!new_value)
+             })
+    def_type(:option_with_param,
+             ->(settings) {
+               settings[:append] ? [] : nil
+             },
+             ->(current_value, new_value, settings) {
+               settings[:append] ? (current_value + new_value) : new_value
+             },
+             ->(names, settings) {
+               names[0] << ' PARAM' unless names.any? { |v| v.include?(' ') }
+               names = settings.has_key?(:desc) ? (names + [settings[:desc]]) : names
+               settings.has_key?(:type) ? (names + [settings[:type]]) : names
+             },
+             ->(new_value, settings) {
+               new_value.is_a?(Array) ? (settings[:append] ? new_value : new_value[0]) : (settings[:append] ? [new_value] : new_value)
+             })
+  end
+
+  class OptionDef
+    attr_reader :value
+
+    def initialize(type, settings = {}, &block)
+      @type     = type
+      @settings = settings
+      @block    = block
+      @value    = OptionTypes.default_value(type, settings)
+      @values   = {}
+    end
+
+    def set(value)
+      @value  = value
+      @values = {}
+    end
+
+    def update(value, layer)
+      @values[layer] = OptionTypes.default_value(@type, @settings) unless @values.has_key?(layer)
+      @values[layer] = OptionTypes.updated_value(@type, @values[layer], value, @settings)
+    end
+
+    def run
+      @block.call unless @block.nil? || !@block
+    end
+
+    def composite(*layers)
+      value = @value
+      layers.each { |layer| value = OptionTypes.updated_value(@type, value, @values[layer], @settings) if @values.has_key?(layer) }
+      value
+    end
+
+    def self.register(opts, options, type, opt_name, names, settings = {}, default_settings = {}, &block)
+      settings = settings.clone
+      default_settings.each { |v| settings[v[0]] = v[1] unless settings.has_key?(v[0]) }
+      opt               = OptionDef.new(type, settings, &block)
+      options[opt_name] = opt
+      names             = OptionTypes.mod_names(type, names, settings)
+      opts.on(*names) { |*args|
+        opt.update(args, :arg)
+        opt.run
       }
     end
+  end
+
+  class OptionList
+    attr_reader :opts
+    attr_accessor :default_settings, :help_str
+
+    def initialize
+      @options          = {}
+      @default_settings = {}
+      @opts             = OptionParser.new
+      @help_str         = nil
+    end
+
+    def []=(opt_name, opt)
+      @options[opt_name] = opt
+    end
+
+    def set(opt_name, value)
+      @options[opt_name].set(value) if @options.has_key?(opt_name)
+    end
+
+    def update(opt_name, value, layer)
+      @options[opt_name].update(value, layer) if @options.has_key?(opt_name)
+    end
+
+    def register(type, opt_name, names, settings = {}, &block)
+      OptionDef.register(@opts, @options, type, opt_name, names, settings, @default_settings, &block)
+    end
+
+    def composite(*layers)
+      hash = {}
+      @options.each { |v| hash[v[0]] = v[1].composite(*layers) }
+      hash
+    end
+
+    def help
+      @help_str.nil? ? @opts.help : @help_str
+    end
+
+    def to_s
+      @help_str.nil? ? @opts.to_s : @help_str
+    end
+
+    def banner=(banner)
+      @opts.banner = banner
+    end
+
+    def parse!(argv = ARGV)
+      @opts.parse!(argv)
+    end
+  end
+
+  module OptionUtil
+    def option(opt_name, names, settings = {}, &block)
+      @options ||= OptionList.new
+      @options.register(:option, opt_name, names, settings, &block)
+    end
+
+    def option_with_param(opt_name, names, settings = {}, &block)
+      @options ||= OptionList.new
+      @options.register(:option_with_param, opt_name, names, settings, &block)
+    end
 
     def defaults_option(file_path, names, settings = {})
-      @opts          ||= OptionParser.new
+      @options       ||= OptionList.new
       @set_defaults  = false
       @defaults_file = File.expand_path(file_path)
       @exit_on_save  = !settings.has_key?(:exit_on_save) || settings[:exit_on_save]
       names << settings[:desc] if settings.has_key?(:desc)
-      @opts.on(*names) { @set_defaults = true }
+      @options.opts.on(*names) { @set_defaults = true }
+    end
+
+    def global_defaults_option(file_path, names, settings = {})
+      @options              ||= OptionList.new
+      @set_global_defaults  = false
+      @global_defaults_file = File.expand_path(file_path)
+      @exit_on_global_save  = !settings.has_key?(:exit_on_save) || settings[:exit_on_save]
+      names << settings[:desc] if settings.has_key?(:desc)
+      @options.opts.on(*names) { @set_global_defaults = true }
     end
 
     def help_option(names, settings = {})
-      @opts          ||= OptionParser.new
+      @options       ||= OptionList.new
       @display_help  = false
       @exit_on_print = !settings.has_key?(:exit_on_print) || settings[:exit_on_print]
       names << settings[:desc] if settings.has_key?(:desc)
-      @opts.on(*names) { @display_help = true }
+      @options.opts.on(*names) { @display_help = true }
     end
 
     def default_settings(settings = {})
-      @default_settings = settings
+      @options                  ||= OptionList.new
+      @options.default_settings = settings
     end
 
     def default_options(opts = {})
-      opts.each { |opt| @options[opt[0]] = opt[1] }
+      @options ||= OptionList.new
+      opts.each { |opt| @options.set(opt[0], opt[1]) }
+    end
+
+    def apply_options(layer, opts = {})
+      @options ||= OptionList.new
+      opts.each { |opt| @options.update(opt[0], opt[1], layer) }
     end
 
     def banner(banner)
-      @opts        ||= OptionParser.new
-      @opts.banner = banner
+      @options        ||= OptionList.new
+      @options.banner = banner
+    end
+
+    def opts
+      @options.opts
+    end
+
+    def options
+      @options.composite(:global, :local, :arg)
+    end
+
+    def option_list
+      @options
     end
 
     def help
-      @opts     ||= OptionParser.new
-      @help_str ||= nil
-      @help_str.nil? ? @opts.help : @help_str
+      @options ||= OptionList.new
+      @options.help
     end
 
     def to_s
-      @opts     ||= OptionParser.new
-      @help_str ||= nil
-      @help_str.nil? ? @opts.to_s : @help_str
+      @options ||= OptionList.new
+      @options.to_s
     end
 
     def help_str=(str)
-      @help_str = str
+      @options.help_str = str
     end
 
     def parse!(argv = ARGV)
-      @opts ||= OptionParser.new
-      default_options YAML::load_file(@defaults_file) unless @defaults_file.nil? || !File.exist?(@defaults_file)
-      @opts.parse!(argv)
+      @options ||= OptionList.new
+      apply_options :global, YAML::load_file(@global_defaults_file) unless @global_defaults_file.nil? || !File.exist?(@global_defaults_file)
+      apply_options :local, YAML::load_file(@defaults_file) unless @defaults_file.nil? || !File.exist?(@defaults_file)
+      @options.parse!(argv)
       if @display_help
         puts help
         exit 0 if @exit_on_print
       end
-      if @set_defaults
-        IO.write(@defaults_file, @options.to_yaml)
+      if @set_global_defaults
+        IO.write(@global_defaults_file, @options.composite(:global, :arg).to_yaml)
+        if @exit_on_global_save
+          puts 'Global defaults set'
+          exit 0
+        end
+      elsif @set_defaults
+        IO.write(@defaults_file, @options.composite(:local, :arg).to_yaml)
         if @exit_on_save
           puts 'Defaults set'
           exit 0

data/lib/everyday-cli-utils/version.rb

@@ -1,3 +1,3 @@
 module EverydayCliUtils
-  VERSION = '1.4.0'
+  VERSION = '1.5.0'
 end

data/spec/everyday-cli-utils/option_spec.rb

@@ -183,4 +183,26 @@ describe EverydayCliUtils::OptionUtil do
 '
     opt.to_s.should eq expected
   end
+
+  it 'supports layers' do
+    expected1 = { opt1: true }
+    expected2 = { opt1: false }
+    clean     = { opt1: false }
+    opt       = Option1.new
+    opt.default_settings toggle: true
+    opt.option :opt1, %w(-1 --opt-1)
+    opt.options.should eq clean
+    opt.default_options opt1: false
+    opt.apply_options :global, opt1: true
+    opt.options.should eq expected1
+    opt.apply_options :local, opt1: false
+    opt.options.should eq expected1
+    opt.apply_options :arg, opt1: true
+    opt.options.should eq expected2
+    opt.option_list.composite(:global, :arg).should eq expected2
+    opt.option_list.composite(:global).should eq expected1
+    opt.option_list.composite(:local, :arg).should eq expected1
+    opt.option_list.composite(:arg).should eq expected1
+    opt.option_list.composite(:global, :local, :arg).should eq expected2
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: everyday-cli-utils
 version: !ruby/object:Gem::Version
-  version: 1.4.0
+  version: 1.5.0
 platform: ruby
 authors:
 - Eric Henderson
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-02-06 00:00:00.000000000 Z
+date: 2014-02-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -137,7 +137,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.0
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: A few CLI and general utils