cli-modular_options 0.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5b7e5cd4033fe5f65cc4058d851f2b37ecac55bf
+  data.tar.gz: 76f08750cf87f2ffa3834bfc9b09639a6783780b
+SHA512:
+  metadata.gz: 79a6af03599049f0210d6156facac70150d4c07b77354795ae12c868e2e4680afb9a436abb49dc4ea00a0bac45ca62620b910a58959556202ab75114fda4cb11
+  data.tar.gz: d05bfefea65b7bed219f580b6deaee53dd667fd1ddb6ca284eda58ba2233150fedb279d5565b22cd809e9320cd72eebc07adbae146d9166242c77ae88aa5ee1f

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Erik Elmore
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,96 @@
+Modular CLI Options
+===================
+
+Facilitates modular application design by allowing you to declare command-line
+options in the context of a class or module and consume them in the context of
+an object instance using conventional ruby inheritance semantics.
+
+### Install:
+
+    gem install cli-modular_options
+
+### Example:
+```ruby
+require 'cli/modular_options'
+
+module DatabaseStuff
+  extend CLI::WithOptions
+  
+  # Your mixin methods might go here
+  
+  cli_options do |parser|
+    p.separator 'Database Options:'
+    p.on '--db-user', 'Database username' do |v|
+      cli_opts[:db_user] = v
+    end
+    p.on '--db-pass', 'Database password' do |v|
+      cli_opts[:db_pass] = v
+    end
+  end
+end
+
+module StandardOptions
+  extend CLI::WithOptions
+  cli_options do |parser|
+    p.on_head '-h', '--help', 'Display help' do
+      cli_opts[:show_help] = true
+      cli_opts[:parser] = parser
+    end
+  end
+end
+
+class MyApp
+  include CLI::ModularOptions
+  include DatabaseStuff
+  include StandardOptions
+  
+  def show_help
+    puts cli_opts[:parser]
+    Process.exit 0
+  end
+  
+  def initialize( argv = ARGV.map(&:dup) )
+    parse_options! argv
+    # Your options are available in cli_opts
+    show_help if cli_opts[:show_help]
+  end
+end
+
+# You can inherit options in a subclass
+class MyDerivedApp < MyApp
+  # Maybe you prefer to let the caller decide what to do about --help
+  def show_help
+    throw :help, cli_opts[:parser]
+  end
+end
+
+# You can append more options directly to a class
+class MyVerboseApp < MyApp
+  extend CLI::WithOptions
+  cli_options do |parser|
+    parser.separator 'Options added by MyVerboseApp:'
+    cli_opts[:verbose] = false
+    parser.on '--verbose', 'Enable verbose output' do
+      cli_opts[:verbose] = true
+    end
+  end
+end
+
+# The order in which callbacks are invoked is well-defined.
+# Your cli_options blocks are called in a natural order that aligns
+# with normal ruby inheritance semantics.
+class MyQuietApp < MyVerboseApp
+  cli_options do |parser|
+    # This appears on the list of options after those declared in MyVerboseApp
+    parser.on '--no-verbose', 'Disable verbose output' do
+      cli_opts[:verbose] = false
+    end
+  end
+end
+```
+
+### Copyrights
+Copyright (C) 2014 Erik Elmore <erik@erikelmore.com>
+
+### License
+MIT License.  See LICENSE file for full text.

data/lib/cli/modular_options.rb

@@ -0,0 +1,44 @@
+require 'optparse'
+
+module CLI
+  
+  module WithOptions
+    def cli_options( &block )
+      raise ArgumentError, 'Block required but not given' unless block_given?
+      const_set :CLI_OPTS_HOOKS, Array.new unless const_defined? :CLI_OPTS_HOOKS, false
+      const_get(:CLI_OPTS_HOOKS) << block
+    end
+  end # WithOptions
+  
+  module ModularOptions
+    def cli_opts
+      @cli_opts ||= Hash.new
+    end
+    
+    def new_options_parser
+      OptionParser.new do |p|
+        self.class.cli_hooks.each{ |b| instance_exec p, cli_opts, &b }
+      end
+    end
+    
+    def parse_options!( argv )
+      cli_opts[:positional] = new_options_parser.parse! argv
+    end
+    
+    def self.included( base )
+      base.extend ClassMethods
+      super
+    end
+    
+    module ClassMethods
+      def ancestors_with_cli_hooks
+        ancestors.select{ |m| m.const_defined? :CLI_OPTS_HOOKS, false }
+      end
+      
+      def cli_hooks
+        ancestors_with_cli_hooks.map{ |m| m::CLI_OPTS_HOOKS }.reverse.flatten
+      end
+    end # ClassMethods
+  end # ModularOptions
+
+end # CLI

data/spec/helpers/test_model.rb

@@ -0,0 +1,58 @@
+require 'cli/modular_options'
+
+module TestModel
+  def self.new_cli_hook( mod, name )
+    k = name.to_s.downcase.to_sym
+    mod.instance_eval do
+      cli_options do |p, cfg|
+        cfg[:context]    << self.class
+        cfg[:call_order] << name.to_s
+        cfg[k] = false
+        p.on "--#{k}" do
+          cfg[k] = true
+        end
+      end
+    end
+  end
+  
+  def self.new_module( args = {} )
+    args = {
+      :name        => 'TestMod',
+      :add_options => true
+    }.merge args
+    Module.new do
+      extend CLI::WithOptions
+      TestModel.new_cli_hook self, args[:name] if args[:add_options]
+    end
+  end
+  
+  def self.new_class( args = {} )
+    args = {
+      :base            => Object,
+      :modular_options => false,
+      :with_options    => false,
+      :name            => 'TestClass',
+      :feature_modules =>  Array.new
+    }.merge args
+    
+    Class.new args[:base] {
+      if args[:modular_options]
+        include CLI::ModularOptions
+        def initialize( argv = [] )
+          cli_opts[:context]    = Array.new
+          cli_opts[:call_order] = Array.new
+          parse_options! argv
+        end
+      end
+      
+      args[:feature_modules].each do |m|
+        include m.kind_of?(Module)? m : TestModel.new_module(:name => m)
+      end
+      
+      if args[:with_options]
+        extend CLI::WithOptions
+        TestModel.new_cli_hook self, args[:name]
+      end
+    }
+  end
+end

data/spec/modular_options_spec.rb

@@ -0,0 +1,248 @@
+require 'cli/modular_options'
+require 'helpers/test_model'
+
+describe CLI::ModularOptions do
+  shared_examples_for TestModel do
+    it 'Inherits included cli_hooks' do
+      expect(klass.cli_hooks.size).to be call_order.size
+    end
+    
+    it 'Invokes cli_hooks in the context of self' do
+      expect(klass.new.cli_opts[:context]).to all be(klass)
+    end
+    
+    it 'Invokes cli_hooks in the correct order' do
+      expect(klass.new.cli_opts[:call_order]).to eq call_order
+    end
+  end
+  
+  context 'When no options' do
+    let(:klass){ TestModel.new_class modular_options: true }
+    let(:call_order){ Array.new }
+    it_behaves_like TestModel
+  end
+  
+  context 'When included modules have options' do
+    let(:klass){ TestModel.new_class(
+      :modular_options => true, 
+      :feature_modules => ['One', 'Two', 'Three']
+    )}
+    let(:call_order){ ['One', 'Two', 'Three'] }
+    it_behaves_like TestModel
+  end
+  
+  context 'When both a class and its included modules have options' do
+    let(:klass){ TestModel.new_class(
+      :name => 'Base',
+      :modular_options => true,
+      :with_options => true,
+      :feature_modules => ['One', 'Two', 'Three']
+    )}
+    let(:call_order){ ['One', 'Two', 'Three', 'Base'] }
+    it_behaves_like TestModel
+  end
+
+  context 'When base class has options' do
+    let(:klass){ TestModel.new_class(
+      :name => 'Sub',
+      :base => TestModel.new_class(
+        :name => 'Base',
+        :modular_options => true,
+        :with_options => true
+      )
+    )}
+    let(:call_order){ ['Base'] }
+    it_behaves_like TestModel
+  end
+  
+  context 'When base class includes modules with options' do
+    let(:klass){ TestModel.new_class(
+      :base => TestModel.new_class(
+        :modular_options => true,
+        :feature_modules => ['One', 'Two', 'Three']
+      )
+    )}
+    let(:call_order){ ['One', 'Two', 'Three'] }
+    it_behaves_like TestModel
+  end
+  
+  context 'When base class both has and includes options' do
+    let(:klass){ TestModel.new_class(
+      :name => 'Sub',
+      :base => TestModel.new_class(
+        :name => 'Base',
+        :modular_options => true,
+        :with_options => true,
+        :feature_modules => ['One', 'Two', 'Three']
+      )
+    )}
+    let(:call_order){ ['One', 'Two', 'Three', 'Base'] }
+    it_behaves_like TestModel
+  end
+  
+  context 'When both base class and derived class have and include options' do
+    let(:klass){ TestModel.new_class(
+      :name => 'Sub',
+      :with_options => true,
+      :feature_modules => ['Four', 'Five', 'Six'],
+      :base => TestModel.new_class(
+        :name => 'Base',
+        :modular_options => true,
+        :with_options => true,
+        :feature_modules => ['One', 'Two', 'Three']
+      )
+    )}
+    let(:call_order){ Array[
+      'One', 'Two', 'Three', 'Base',
+      'Four', 'Five', 'Six', 'Sub'
+    ]}
+    it_behaves_like TestModel
+  end
+  
+  context 'When re-opening base class to include module with options' do
+    let(:klass){
+      base = TestModel.new_class(
+        :name => 'Base',
+        :modular_options => true,
+        :with_options => true,
+        :feature_modules => ['One', 'Two', 'Three']
+      )
+      sub = TestModel.new_class(
+        :name => 'Sub',
+        :with_options => true,
+        :feature_modules => ['Four', 'Five', 'Six'],
+        :base => base
+      )
+      base.send :include, TestModel.new_module(:name => 'Added')
+      sub
+    }
+    let(:call_order){ Array[
+      'One', 'Two', 'Three', 'Added', 'Base',
+      'Four', 'Five', 'Six', 'Sub'
+    ]}
+    it_behaves_like TestModel
+  end
+  
+  context 'When re-opening base class to declare options directly' do
+    let(:klass){
+      base = TestModel.new_class(
+        :name => 'Base',
+        :modular_options => true,
+        :with_options => true,
+        :feature_modules => ['One', 'Two', 'Three']
+      )
+      sub = TestModel.new_class(
+        :name => 'Sub',
+        :with_options => true,
+        :feature_modules => ['Four', 'Five', 'Six'],
+        :base => base
+      )
+      TestModel.new_cli_hook base, 'BaseAgain'
+      sub
+    }
+    let(:call_order){ Array[
+      'One', 'Two', 'Three', 'Base', 'BaseAgain',
+      'Four', 'Five', 'Six', 'Sub'
+    ]}
+    it_behaves_like TestModel
+  end
+  
+  context 'When re-opening derived class to include module with options' do
+    let(:klass){
+      base = TestModel.new_class(
+        :name => 'Base',
+        :modular_options => true,
+        :with_options => true,
+        :feature_modules => ['One', 'Two', 'Three']
+      )
+      sub = TestModel.new_class(
+        :name => 'Sub',
+        :with_options => true,
+        :feature_modules => ['Four', 'Five', 'Six'],
+        :base => base
+      )
+      sub.send :include, TestModel.new_module(:name => 'Added')
+      sub
+    }
+    let(:call_order){ Array[
+      'One', 'Two', 'Three', 'Base',
+      'Four', 'Five', 'Six', 'Added', 'Sub'
+    ]}
+    it_behaves_like TestModel
+  end
+  
+  context 'When re-opening derived class to declare options directly' do
+    let(:klass){
+      base = TestModel.new_class(
+        :name => 'Base',
+        :modular_options => true,
+        :with_options => true,
+        :feature_modules => ['One', 'Two', 'Three']
+      )
+      sub = TestModel.new_class(
+        :name => 'Sub',
+        :with_options => true,
+        :feature_modules => ['Four', 'Five', 'Six'],
+        :base => base
+      )
+      TestModel.new_cli_hook sub, 'SubAgain'
+      sub
+    }
+    let(:call_order){ Array[
+      'One', 'Two', 'Three', 'Base',
+      'Four', 'Five', 'Six', 'Sub', 'SubAgain'
+    ]}
+    it_behaves_like TestModel
+  end
+  
+  context 'When adding cli_hooks to module already included by base class' do
+    let(:klass){
+      mod = TestModel.new_module :name => 'Two'
+      base = TestModel.new_class(
+        :name => 'Base',
+        :modular_options => true,
+        :with_options => true,
+        :feature_modules => ['One', mod, 'Three']
+      )
+      sub = TestModel.new_class(
+        :name => 'Sub',
+        :with_options => true,
+        :feature_modules => ['Four', 'Five', 'Six'],
+        :base => base
+      )
+      TestModel.new_cli_hook mod, 'TwoAgain'
+      sub
+    }
+    let(:call_order){ Array[
+      'One', 'Two', 'TwoAgain', 'Three', 'Base',
+      'Four', 'Five', 'Six', 'Sub'
+    ]}
+    it_behaves_like TestModel
+  end
+  
+  context 'When adding cli_hooks to module already included by derived class' do
+    let(:klass){
+      mod = TestModel.new_module :name => 'Five'
+      base = TestModel.new_class(
+        :name => 'Base',
+        :modular_options => true,
+        :with_options => true,
+        :feature_modules => ['One', 'Two', 'Three']
+      )
+      sub = TestModel.new_class(
+        :name => 'Sub',
+        :with_options => true,
+        :feature_modules => ['Four', mod, 'Six'],
+        :base => base
+      )
+      TestModel.new_cli_hook mod, 'FiveAgain'
+      sub
+    }
+    let(:call_order){ Array[
+      'One', 'Two', 'Three', 'Base',
+      'Four', 'Five', 'FiveAgain', 'Six', 'Sub'
+    ]}
+    it_behaves_like TestModel
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,2 @@
+RSpec.configure do |config|
+end

data/spec/with_options_spec.rb

@@ -0,0 +1,24 @@
+require 'cli/modular_options'
+require 'helpers/test_model'
+
+describe CLI::WithOptions do
+  let(:mod){ TestModel.new_module :add_options => false }
+  
+  it "Doesn't create CLI_OPTS_HOOKS until necessary" do
+    expect(mod.const_defined? :CLI_OPTS_HOOKS).to eq false
+  end
+
+  it 'Requires a block to be given with cli_options' do
+    expect{ mod.cli_options }.to raise_error ArgumentError
+  end
+
+  it 'Adds hooks to modules' do
+    mod.cli_options do; end
+    expect(mod::CLI_OPTS_HOOKS).to be_an Array
+  end
+  
+  it 'Adds more hooks to modules' do
+    5.times{ mod.cli_options do; end }
+    expect(mod::CLI_OPTS_HOOKS.size).to be 5
+  end
+end

metadata

@@ -0,0 +1,70 @@
+--- !ruby/object:Gem::Specification
+name: cli-modular_options
+version: !ruby/object:Gem::Version
+  version: 0.0.0
+platform: ruby
+authors:
+- Erik Elmore
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-06-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+description: Facilitates modular application design by allowing you to declare CLI
+  options in the context of a class or module and consume them in the context of an
+  object instance using conventional ruby inheritance semantics.
+email: erik@erikelmore.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/cli/modular_options.rb
+- spec/helpers/test_model.rb
+- spec/modular_options_spec.rb
+- spec/spec_helper.rb
+- spec/with_options_spec.rb
+homepage: https://github.com/IronSavior/ModularOptions
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 1.9.3
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Modular Command-Line Options
+test_files:
+- spec/spec_helper.rb
+- spec/modular_options_spec.rb
+- spec/helpers/test_model.rb
+- spec/with_options_spec.rb