ropet 1.0.0.rc1

data/.autotest

@@ -0,0 +1 @@
+require 'autotest/bundler'

data/.gitignore

@@ -0,0 +1,3 @@
+doc/
+.yardoc/
+*.bak

data/.rspec

@@ -0,0 +1 @@
+--color --format documentation

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in ropet.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,30 @@
+PATH
+  remote: .
+  specs:
+    ropet (0.1.0)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    diff-lcs (1.1.3)
+    metaclass (0.0.1)
+    mocha (0.10.0)
+      metaclass (~> 0.0.1)
+    rspec (2.7.0)
+      rspec-core (~> 2.7.0)
+      rspec-expectations (~> 2.7.0)
+      rspec-mocks (~> 2.7.0)
+    rspec-core (2.7.1)
+    rspec-expectations (2.7.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.7.0)
+    yard (0.7.4)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  mocha (>= 0.10.0)
+  ropet!
+  rspec
+  yard (>= 0.7.4)

data/README.md

@@ -0,0 +1,78 @@
+# Ropet
+
+Ropet is a helper library for easy integration of options in methods.
+
+## Concept
+
+An **option** can be a *flag*, for example:
+
+      :debug
+      :no_debug
+
+or a standard *hash option*:
+
+      :debug
+      {threads: 3}
+      # or, if you prefer:
+      {:toolkit => :gcc}
+
+## Quick usage
+
+In a method accepting `*options` as the last argument, you can use:
+
+      # remember to pass `*options` (with an asterisk), because it
+      # passes `options.length` instead of an array in one argument
+      # and #parser doesn't expect one array
+      Ropet.parser *options
+      
+      # or manual options
+      parser = Ropet.parser :debug, threads: 2
+      
+      parser[:debug]  #=> true
+      parser[:threads]#=> 2
+      
+      parser.inject *options
+      parser.inject :no_debug, toolkit: :gcc
+
+
+## Detailed usage
+
+In addition to standard `*options` in `Ropet#parser`, you can also pass a block with configuration, which executes before injecting/interpreting options.
+
+{Ropet::Config} provides a small *DSL* for basic configuration, like this:
+
+      parser = Ropet.parser :without_debug do
+        prefix 'without_'                 # flags starting with 'without_' will be interpreted
+                                          # as false booleans
+        default :library_path, './lib'    # when `library_path` is not set,
+                                          # it will be taken from defaults list
+      end
+       
+      parser[:debug]                      #=> false
+      parser[:library_path]               #=> "./lib"
+      
+      parser.inject library_path: "../library"
+                                          # `#inject` accepts the same kind of
+                                          # *options that `Ropet#parser`
+                                       
+      parser[:library_path]               #=> "../library"
+      
+      parser.inject :without_without_templates
+                                          # for extreme cases, when key names include prefixes
+                                          # it is advisable to change false_prefix with dsl method
+                                          # but you probably won't have a key names no_no_*
+
+      parser.has_key? :without_templates  #=> true
+      
+      parser.settings                     #=> {:debug=>false, :library_path=>"../library", :without_templates=>false}
+      
+      # you can also access defaults whenever you want,
+      # they're not treated in the same way as other options
+      # (which are overwritten in case of conflicts)
+      parser.config.defaults            #=> {:library_path=>"./lib"}
+
+## Copyright
+
+Copyright © 2012 Jakub Okoński
+
+<a rel="license" href="http://creativecommons.org/licenses/by-sa/3.0/"><img alt="Creative Commons License" style="border-width:0" src="http://i.creativecommons.org/l/by-sa/3.0/88x31.png" /></a><br /><span xmlns:dct="http://purl.org/dc/terms/" property="dct:title">Ropet</span> by <span xmlns:cc="http://creativecommons.org/ns#" property="cc:attributionName">Jakub Okoński</span> is licensed under a <a rel="license" href="http://creativecommons.org/licenses/by-sa/3.0/">Creative Commons Attribution-ShareAlike 3.0 Unported License</a>.

data/Rakefile

@@ -0,0 +1,5 @@
+require "bundler/gem_tasks"
+
+require "yard"
+require "yard/rake/yardoc_task"
+YARD::Rake::YardocTask.new

data/lib/ropet.rb

@@ -0,0 +1,17 @@
+require "ropet/version"
+require 'ropet/parser'
+
+# Top level module holding all objects
+module Ropet
+  # Helper for easy creation of parsers
+  # @param options Arguments to parse after initializing
+  # @param block Block to pass for {Ropet::Config.from_dsl}
+  # @return [Parser]
+  def self.parser(*options, &block)
+    if block
+      Parser.new(Config.from_dsl(&block)).tap {|o| o.inject *options }
+    else
+      Parser.new(Config.new).tap {|o| o.inject *options }
+    end
+  end
+end

data/lib/ropet/config.rb

@@ -0,0 +1,46 @@
+module Ropet
+  # Customizes parser settings
+  class Config
+    # Keeps all the defaults to use when
+    # there's no value assigned
+    # @return [Hash]
+    attr_reader :defaults
+    
+    # Stores prefix to match false flags with
+    # @return [String]
+    attr_reader :false_prefix
+    
+    # Sets @defaults and default @false_prefix
+    def initialize
+      @defaults = {}
+      @false_prefix = 'no_'
+    end
+    
+    # Creates new instance of Config and executes
+    # dsl methods on it
+    # @param &block Block to execute
+    # @return [Config] Initialized config
+    def self.from_dsl(&block)
+      c = self.new
+      c.instance_exec(&block)
+      return c
+    end
+    
+    # Adds a default `value` for `key`
+    # @param [#to_sym] Key for default
+    # @param [Object] Value to assign for default
+    # @return [nil]
+    def default(key, value)
+      @defaults[key.to_sym] = value
+      return nil
+    end
+    
+    # Sets the false prefix for a parser
+    # @param [#to_s] Prefix
+    # @return [nil]
+    def prefix(prefix)
+      @false_prefix = prefix.to_s
+      return nil
+    end
+  end
+end

data/lib/ropet/parser.rb

@@ -0,0 +1,89 @@
+require 'ropet/config'
+
+module Ropet
+  # Main class for Ropet, handles all injecting logic,
+  # parsing flags and setting options
+  class Parser
+    # @return [Hash] Assigned options
+    attr_reader :settings
+    
+    # @return [Config] Config
+    attr_reader :config
+    
+    # Initializes new parser
+    # Sets up @settings
+    # @param [Config, nil] Config to use for the parser
+    def initialize(config = nil)
+      @settings = {}
+      @config = config || Config.new
+      
+      return self
+    end
+    
+    # Creates new Parser with a block of dsl
+    # methods to pass for Config initialization
+    # @deprecated
+    # @param &block Block to pass
+    # @return [Parser] New parser created from initialized Config
+    def self.let(&block)
+      self.new(Config.from_dsl(&block))
+    end
+    
+    # Main method of Ropet.
+    # Parses options and flags and stores them
+    # properly.
+    # @param [<Symbol,String>,Hash] *options Options to parse
+    # @example Injecting flags mixed with hash options
+    #   parser.inject :debug, toolchain: 'gcc-4.0'
+    # @return [Parser] Self
+    def inject(*options)
+      options.each do |option|
+        if option.is_a?(Symbol) || option.is_a?(String)
+          flag = option.to_s
+          prefix_range = 0...(config.false_prefix.length)
+          if flag[prefix_range] == config.false_prefix
+            flag.slice! prefix_range # remove prefix from string if it exists there
+            @settings[flag.to_sym] = false
+          else
+            @settings[option] = true
+          end
+        elsif option.is_a? Hash
+          @settings.merge! option
+        end
+      end
+    
+      return self
+    end
+    
+    # Creates new Parser with default Config.
+    # Calls Parser#inject on `*options`.
+    # @param [<Symbol,String>,Hash] *options Options to parse
+    # @deprecated
+    # @return [Parser] New Parser
+    def self.inject(*options)
+      obj = self.new(Config.new)
+      obj.inject options
+    end
+    
+    # Checks existence of `key` in defined settings
+    # or defaults.
+    # @param [String,Symbol] key Key to search for
+    # @return [Boolean] Boolean telling if Parser has this key
+    def has_key?(key)
+      key = key.to_sym
+      @settings.has_key?(key) or config.defaults.has_key?(key)
+    end
+    
+    # Retrieves value for given `key`.
+    # @param [Symbol,String] index Key to search for
+    # @return [Object] Value stored for given key
+    def [](index)
+      index = index.to_sym
+      unless @settings[index] == nil
+        @settings[index]
+      else
+        config.defaults[index]
+      end
+    end
+  end
+end

data/lib/ropet/version.rb

@@ -0,0 +1,4 @@
+module Ropet
+  # Stores version of the app
+  VERSION = "1.0.0.rc1"
+end

data/opts.rb

@@ -0,0 +1,94 @@
+#!/usr/bin/env ruby
+
+class Options
+  attr_reader :settings, :config
+  
+  class Config
+    attr_reader :defaults, :false_prefix
+    
+    def initialize
+      @defaults = {}
+      @false_prefix = 'no'
+    end
+    
+    def default(key, value)
+      @defaults[key.to_sym] = value
+    end
+    
+    def prefix(prefix)
+      @false_prefix = prefix
+    end
+  end
+  
+  def initialize(config)
+    @settings = {}
+    @config = config || Config.new
+    
+    return self
+  end
+  
+  def self.let(&block)
+    config = Config.new
+    config.instance_exec(&block)
+    self.new(config)
+  end
+  
+  def inject(*options)
+    options.each do |option|
+      if option.is_a?(Symbol) || option.is_a?(String)
+        flag = option.to_s
+        prefix_range = 0...(config.false_prefix.length)
+        if flag[prefix_range] == config.false_prefix
+          flag.slice! prefix_range # remove prefix from string if it exists there
+          @settings[flag.to_sym] = false
+        else
+          @settings[option] = true
+        end
+      elsif option.is_a? Hash
+        @settings.merge! option
+      end
+    end
+    
+    return self
+  end
+  
+  def self.inject(*options)
+    obj = self.new(Config.new)
+    obj.inject options
+  end
+  
+  def has_key?(key)
+    @settings.has_key?(key) or config.defaults.has_key?(key)
+  end
+  
+  def [](index)
+    unless @settings[index] == nil
+      @settings[index]
+    else
+      config.defaults[index]
+    end
+  end
+end
+
+class Greeter
+  attr_reader :options
+  
+  def initialize(*opts)
+    @options = Options.let{prefix 'without_'; default :name, 'Kot'}.inject(opts)
+    
+    greet
+  end
+  
+  def greet
+    return puts "Hello unknown" unless @options.has_key? :name
+    return puts "Hello noname" if @options[:name] == false
+    return puts "Hello #{@options[:name]}" if @options[:name].is_a? String
+  end
+end
+
+g = Greeter.new
+g.options.inject :without_name; g.greet
+g.options.inject :name => "Kuba"; g.greet
+
+puts Options.inject(:nodebug).inject(threads: 3).inject(:debug => :gdb).settings ==
+Options.inject(:nodebug, threads: 3, debug: :gdb).settings

data/ropet.gemspec

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "ropet/version"
+
+Gem::Specification.new do |s|
+  s.name        = "ropet"
+  s.version     = Ropet::VERSION
+  s.authors     = ["Jakub Okoński"]
+  s.email       = ["jakub@okonski.org"]
+  s.homepage    = "http://github.com/farnoy/ropet"
+  s.summary     = %q{Parse your method options easily}
+  s.description = %q{Ropet parses options and provides easy API for developer}
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_development_dependency "rspec"
+  s.add_development_dependency "mocha", ">= 0.10.0"
+  s.add_development_dependency "yard", ">= 0.7.4"
+end

data/spec/config_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+describe Ropet::Config do
+  let :config do
+    Ropet::Config.new
+  end
+  
+  describe "constructor" do
+    it "assigns @defaults hash" do
+      config.instance_variable_get(:@defaults).should eq({})
+    end
+    
+    it "assigns @false_prefix to default `no`" do
+      config.instance_variable_get(:@false_prefix).should eq('no_')
+    end
+  end
+  
+  describe "#default" do
+    it "assings default value for key" do
+      config.default :name, false
+      config.defaults.should include(name: false)
+    end
+  end
+  
+  describe "#prefix" do
+    it "assings prefix for false flags" do
+      config.prefix :without_
+      config.false_prefix.should eq('without_')
+    end
+  end
+  
+  describe "#from_dsl" do
+    it "provides simple dsl interface" do
+      config = Ropet::Config.from_dsl do
+        prefix 'without_'
+        default :name, false
+        default :age, 20
+      end
+      
+      config.false_prefix.should == 'without_'
+      config.defaults.should include(name: false)
+      config.defaults.should include(age: 20)
+    end
+  end
+end

data/spec/parser_spec.rb

@@ -0,0 +1,139 @@
+require 'spec_helper'
+
+describe Ropet::Parser do
+  let :vanilla_parser do
+    Ropet::Parser.new
+  end
+  
+  let :config do
+    mock("Config")
+  end
+  
+  describe "constructor" do
+    it "assigns empty hash to @settings" do
+      vanilla_parser.instance_variable_get(:@settings).should eq({})
+    end
+    
+    it "assigns @config when passing argument" do
+      config = mock("Anything")
+      parser = Ropet::Parser.new(config)
+      parser.instance_variable_get(:@config).should be(config)
+    end
+    
+    it "assings @config to default value without `config` argument" do
+      Ropet::Config.expects(:new).returns(config)
+      vanilla_parser.instance_variable_get(:@config).should be(config)
+    end
+  end
+  
+  describe "let" do
+    let :block do
+      -> {prefix "test"}
+    end
+    
+    it "creates Config from given block with #from_dsl" do
+      Ropet::Config.expects(:from_dsl)
+      Ropet::Parser.let(&block)
+    end
+    
+    it "creates and returns new Parser" do
+      value = mock
+      Ropet::Config.expects(:from_dsl).returns(config)
+      Ropet::Parser.expects(:new).with(config).returns(value)
+      Ropet::Parser.let(&block).should be(value)    
+    end
+  end
+  
+  describe "static #inject" do
+    let :mock_parser do
+      mock_parser = mock
+      mock_parser.stubs :inject
+      mock_parser
+    end
+    
+    before do
+      Ropet::Config.expects(:new).returns(config)
+      Ropet::Parser.expects(:new).with(config).returns(mock_parser)
+    end
+    
+    it "creates Parser with default Config" do
+      Ropet::Parser.inject(:test)
+    end
+    
+    it "triggers instanced #inject" do
+      mock_parser.expects(:inject).with([:test])
+      Ropet::Parser.inject(:test)      
+    end
+  end
+  
+  describe "instanced #inject" do    
+    it "evaluates all arguments" do
+      first = mock().tap {|m| m.expects(:is_a?).times(3) }
+      second = first.dup
+      vanilla_parser.inject first, second
+    end
+    
+    describe "flags parser" do
+      it "recognizes true flag" do
+        vanilla_parser.inject something: true
+        vanilla_parser.settings.should include(:something => true)
+      end
+      
+      describe "with a false flag" do
+        it "correctly recognizes default prefix" do
+          vanilla_parser.inject :no_auto
+          vanilla_parser.settings[:auto].should eq(false)
+        end
+        
+        it "correctly recognizes custom prefix" do
+          parser = Ropet::Parser.new(Ropet::Config.from_dsl {prefix 'without_'})
+          parser.inject :without_auto
+          parser.settings.should include(:auto => false)
+        end
+        
+        it "assigns correct name as a key" do
+          vanilla_parser.inject :no_auto
+          vanilla_parser.settings.keys.should include(:auto)
+        end
+      end
+    end
+    
+    describe "hash settings" do
+      it "merges them to existing ones" do
+        vanilla_parser.instance_variable_set(:@settings, {:first => false})
+        vanilla_parser.inject second: true
+        vanilla_parser.settings.should include(:first => false, :second => true)
+      end
+      
+      it "merges hash settings overwriting them" do
+        vanilla_parser.inject something: false
+        vanilla_parser.inject something: true
+        vanilla_parser.settings.should include(:something => true)
+      end
+    end
+  end
+  
+  describe "#has_key?" do
+    it "asks @settings for a key" do
+      vanilla_parser.settings.expects(:has_key?).once.with(:auto)
+      vanilla_parser.has_key? 'auto'
+    end
+    
+    it "asks @config.defaults for a key" do
+      vanilla_parser.config.defaults.expects(:has_key?).once.with(:auto)
+      vanilla_parser.has_key? 'auto'
+    end
+  end
+  
+  describe "#[]" do
+    it "asks parsed @settings when available" do
+      vanilla_parser.settings.expects(:[]).with(:auto)
+      vanilla_parser['auto']
+    end
+    
+    it "falls back to @config.defaults otherwise" do
+      vanilla_parser.config.defaults.expects(:[]).with(:auto)
+      vanilla_parser['auto']
+    end
+  end
+end

data/spec/ropet_helpers_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe 'Ropet Helpers' do
+  describe "#parser" do
+    let :options do
+      [:debug, threads: 5]
+    end
+    
+    it "creates a proper config when providing a block" do
+      config = Ropet::Config.new.tap {|c| c.defaults[:name] = "Jakub"}
+      Ropet::Config.expects(:new).returns(
+        config.tap {|o| o.expects(:instance_exec).once }
+      )
+      Ropet.parser { default :name, "Jakub" }
+    end
+    
+    it "creates a proper parser without a block" do
+      double = mock().tap {|o| o.expects(:tap).returns(o) }
+      [:Config, :Parser].each do |sym|
+        Ropet.const_get(sym).expects(:new).returns(double)
+      end
+      Ropet.parser.should eq(double)
+    end
+    
+    it "evaluates options with a block" do
+      Ropet::Parser.any_instance.expects(:inject).with(*options)
+      Ropet.parser *options do
+        default :name, "Jakub"
+      end
+    end
+    
+    it "evaluates options without a block" do
+      Ropet::Parser.any_instance.expects(:inject).with(*options)
+      Ropet.parser *options
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,7 @@
+#require 'rspec/autorun'
+require 'bundler/setup'
+require 'ropet'
+
+RSpec.configure do |config|
+  config.mock_with :mocha
+end

metadata

@@ -0,0 +1,100 @@
+--- !ruby/object:Gem::Specification
+name: ropet
+version: !ruby/object:Gem::Version
+  version: 1.0.0.rc1
+  prerelease: 6
+platform: ruby
+authors:
+- Jakub Okoński
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-01-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &27968640 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *27968640
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: &27967900 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.10.0
+  type: :development
+  prerelease: false
+  version_requirements: *27967900
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: &27967400 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.7.4
+  type: :development
+  prerelease: false
+  version_requirements: *27967400
+description: Ropet parses options and provides easy API for developer
+email:
+- jakub@okonski.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .autotest
+- .gitignore
+- .rspec
+- Gemfile
+- Gemfile.lock
+- README.md
+- Rakefile
+- lib/ropet.rb
+- lib/ropet/config.rb
+- lib/ropet/parser.rb
+- lib/ropet/version.rb
+- opts.rb
+- ropet.gemspec
+- spec/config_spec.rb
+- spec/parser_spec.rb
+- spec/ropet_helpers_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/farnoy/ropet
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>'
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.12
+signing_key: 
+specification_version: 3
+summary: Parse your method options easily
+test_files:
+- spec/config_spec.rb
+- spec/parser_spec.rb
+- spec/ropet_helpers_spec.rb
+- spec/spec_helper.rb
+has_rdoc: