nutshell-crm 0.0.1 → 0.0.2

data/vendor/bundle/gems/yard-0.7.4/lib/yard/verifier.rb

@@ -0,0 +1,148 @@
+module YARD
+  # Similar to a Proc, but runs a set of Ruby expressions using a small
+  # DSL to make tag lookups easier.
+  #
+  # The syntax is as follows:
+  # * All syntax is Ruby compatible
+  # * +object+ (+o+ for short) exist to access the object being verified
+  # * +@TAGNAME+ is translated into +object.tag('TAGNAME')+
+  # * +@@TAGNAME+ is translated into +object.tags('TAGNAME')+
+  # * +object+ can be omitted as target for method calls (it is implied)
+  #
+  # @example Create a verifier to check for objects that don't have @private tags
+  #   verifier = Verifier.new('!@private')
+  #   verifier.call(object) # => true (no @private tag)
+  # @example Create a verifier to find any return tag with an empty description
+  #   Verifier.new('@return.text.empty?')
+  #   # Equivalent to:
+  #   Verifier.new('object.tag(:return).text.empty?')
+  # @example Check if there are any @param tags
+  #   Verifier.new('@@param.empty?')
+  #   # Equivalent to:
+  #   Verifier.new('object.tags(:param).empty?')
+  # @example Using +object+ or +o+ to look up object attributes directly
+  #   Verifier.new('object.docstring == "hello world"')
+  #   # Equivalent to:
+  #   Verifier.new('o.docstring == "hello world"')
+  # @example Without using +object+ or +o+
+  #   Verifier.new('tag(:return).size == 1 || has_tag?(:author)')
+  # @example Specifying multiple expressions
+  #   Verifier.new('@return', '@param', '@yield')
+  #   # Equivalent to:
+  #   Verifier.new('@return && @param && @yield')
+  class Verifier
+    # @return [Array<String>] a list of all expressions the verifier checks for
+    # @since 0.5.6
+    attr_reader :expressions
+
+    def expressions=(value)
+      @expressions = value
+      create_method_from_expressions
+    end
+
+    # Creates a verifier from a set of expressions
+    #
+    # @param [Array<String>] expressions a list of Ruby expressions to
+    #   parse.
+    def initialize(*expressions)
+      @expressions = []
+      add_expressions(*expressions)
+    end
+
+    # Adds a set of expressions and recompiles the verifier
+    #
+    # @param [Array<String>] expressions a list of expressions
+    # @return [void]
+    # @since 0.5.6
+    def add_expressions(*expressions)
+      self.expressions += expressions.flatten
+    end
+
+    # Passes any method calls to the object from the {#call}
+    def method_missing(sym, *args, &block)
+      if object.respond_to?(sym)
+        object.send(sym, *args, &block)
+      else
+        super
+      end
+    end
+
+    # Tests the expressions on the object.
+    #
+    # @note If the object is a {CodeObjects::Proxy} the result will always be true.
+    # @param [CodeObjects::Base] object the object to verify
+    # @return [Boolean] the result of the expressions
+    def call(object)
+      return true if object.is_a?(CodeObjects::Proxy)
+      modify_nilclass
+      @object = object
+      retval = __execute ? true : false
+      unmodify_nilclass
+      retval
+    end
+
+    # Runs a list of objects against the verifier and returns the subset
+    # of verified objects.
+    #
+    # @param [Array<CodeObjects::Base>] list a list of code objects
+    # @return [Array<CodeObjects::Base>] a list of code objects that match
+    #   the verifier.
+    def run(list)
+      list.reject {|item| call(item).is_a?(FalseClass) }
+    end
+
+    protected
+
+    # @return [CodeObjects::Base] the current object being tested
+    attr_reader :object
+    alias o object
+
+    private
+
+    # @private
+    NILCLASS_METHODS = [:type, :method_missing]
+
+    # Modifies nil to not throw NoMethodErrors. This allows
+    # syntax like object.tag(:return).text to work if the #tag
+    # call returns nil, which means users don't need to perform
+    # stringent nil checking
+    #
+    # @return [void]
+    def modify_nilclass
+      NILCLASS_METHODS.each do |meth|
+        NilClass.send(:define_method, meth) {|*args| }
+      end
+    end
+
+    # Returns the state of NilClass back to normal
+    # @return [void]
+    def unmodify_nilclass
+      NILCLASS_METHODS.each do |meth|
+        NilClass.send(:remove_method, meth)
+      end
+    end
+
+    # Creates the +__execute+ method by evaluating the expressions
+    # as Ruby code
+    # @return [void]
+    def create_method_from_expressions
+      expr = expressions.map {|e| "(#{parse_expression(e)})" }.join(" && ")
+
+      instance_eval(<<-eof, __FILE__, __LINE__ + 1)
+        def __execute; #{expr}; end
+      eof
+    end
+
+    # Parses a single expression, handling some of the DSL syntax.
+    #
+    # The syntax "@tag" should be turned into object.tag(:tag),
+    # and "@@tag" should be turned into object.tags(:tag)
+    #
+    # @return [String] the parsed expression
+    def parse_expression(expr)
+      expr = expr.gsub(/@@(\w+)/, 'object.tags("\1")')
+      expr = expr.gsub(/@(\w+)/, 'object.tag("\1")')
+      expr
+    end
+  end
+end

data/vendor/bundle/gems/yard-0.7.4/spec/cli/command_parser_spec.rb

@@ -0,0 +1,43 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe YARD::CLI::CommandParser do
+  describe '#run' do
+    before do
+      @cmd = CLI::CommandParser.new
+    end
+    
+    it "should show help if --help is provided" do
+      command = mock(:command)
+      command.should_receive(:run).with('--help')
+      CLI::CommandParser.commands[:foo] = command
+      @cmd.class.default_command = :foo
+      @cmd.run *%w( foo --help )
+    end
+    
+    it "should use default command if first argument is a switch" do
+      command = mock(:command)
+      command.should_receive(:run).with('--a', 'b', 'c')
+      CLI::CommandParser.commands[:foo] = command
+      @cmd.class.default_command = :foo
+      @cmd.run *%w( --a b c )
+    end
+    
+    it "should use default command if no arguments are provided" do
+      command = mock(:command)
+      command.should_receive(:run)
+      CLI::CommandParser.commands[:foo] = command
+      @cmd.class.default_command = :foo
+      @cmd.run
+    end
+    
+    it "should list commands if command is not found" do
+      @cmd.should_receive(:list_commands)
+      @cmd.run *%w( unknown_command --args )
+    end
+
+    it "should list commands if --help is provided as sole argument" do
+      @cmd.should_receive(:list_commands)
+      @cmd.run *%w( --help )
+    end
+  end
+end

data/vendor/bundle/gems/yard-0.7.4/spec/cli/command_spec.rb

@@ -0,0 +1,36 @@
+require File.dirname(__FILE__) + "/../spec_helper"
+require 'optparse'
+
+describe YARD::CLI::Command do
+  describe '#parse_options' do
+    before do
+      @options = OptionParser.new
+      @saw_foo = false
+      @options.on('--foo') { @saw_foo = true }
+    end
+    
+    def parse(*args)
+      CLI::Command.new.send(:parse_options, @options, args)
+      args
+    end
+
+    it "should skip unrecognized options but continue to next option" do
+      log.should_receive(:warn).with(/Unrecognized.*--list/)
+      log.should_receive(:warn).with(/Unrecognized.*--list2/)
+      parse('--list', '--list2', '--foo')
+      @saw_foo.should be_true
+    end
+    
+    it "should skip unrecognized options and any extra non-option arg that follows" do
+      log.should_receive(:warn).with(/Unrecognized.*--list/)
+      parse('--list', 'foo', '--foo')
+      @saw_foo.should be_true
+    end
+    
+    it "should stop retrying to parse at non-switch argument" do
+      log.should_receive(:warn).with(/Unrecognized.*--list/)
+      args = parse('--list', 'foo', 'foo', 'foo')
+      args.should == %w(foo foo)
+    end
+  end
+end

data/vendor/bundle/gems/yard-0.7.4/spec/cli/config_spec.rb

@@ -0,0 +1,92 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+require 'yaml'
+
+describe YARD::CLI::Config do
+  before do
+    @config = YARD::CLI::Config.new
+    YARD::Config.options = YARD::Config::DEFAULT_CONFIG_OPTIONS.dup
+    YARD::Config.stub!(:save)
+  end
+  
+  def run(*args)
+    @config.run(*args)
+  end
+  
+  describe 'Listing configuration' do
+    it "should accept --list" do
+      opts = YARD::Config.options
+      YAML.should_receive(:dump).twice.and_return("--- foo\nbar\nbaz")
+      @config.should_receive(:puts).twice.with("bar\nbaz")
+      run
+      run('--list')
+      YARD::Config.options.should == opts
+    end
+  end
+  
+  describe 'Viewing an item' do
+    it "should view item if no value is given" do
+      YARD::Config.options[:foo] = 'bar'
+      @config.should_receive(:puts).with('"bar"')
+      run 'foo'
+      YARD::Config.options[:foo].should == 'bar'
+    end
+  end
+  
+  describe 'Modifying an item' do
+    it "should accept --reset to set value" do
+      YARD::Config.options[:load_plugins] = 'foo'
+      run('--reset', 'load_plugins')
+      YARD::Config.options[:load_plugins].should == false
+    end
+    
+    it "should accept --as-list to force single item as list" do
+      run('--as-list', 'foo', 'bar')
+      YARD::Config.options[:foo].should == ['bar']
+    end
+    
+    it "should accept --append to append values to existing key" do
+      YARD::Config.options[:foo] = ['bar']
+      run('--append', 'foo', 'baz', 'quux')
+      YARD::Config.options[:foo].should == ['bar', 'baz', 'quux']
+      run('-a', 'foo', 'last')
+      YARD::Config.options[:foo].should == ['bar', 'baz', 'quux', 'last']
+    end
+    
+    it "should turn key into list if --append is used on single item" do
+      YARD::Config.options[:foo] = 'bar'
+      run('-a', 'foo', 'baz')
+      YARD::Config.options[:foo].should == ['bar', 'baz']
+    end
+    
+    it "should modify item if value is given" do
+      run('foo', 'xxx')
+      YARD::Config.options[:foo].should == 'xxx'
+    end
+    
+    it "should turn list of values into array of values" do
+      run('foo', 'a', 'b', '1', 'true', 'false')
+      YARD::Config.options[:foo].should == ['a', 'b', 1, true, false]
+    end
+    
+    it "should turn number into numeric Ruby type" do
+      run('foo', '1')
+      YARD::Config.options[:foo].should == 1
+    end
+    
+    it "should turn true into TrueClass" do
+      run('foo', 'true')
+      YARD::Config.options[:foo].should == true
+    end
+    
+    it "should turn false into FalseClass" do
+      run('foo', 'false')
+      YARD::Config.options[:foo].should == false
+    end
+    
+    it "should save on modification" do
+      YARD::Config.should_receive(:save)
+      run('foo', 'true')
+    end
+  end
+end

data/vendor/bundle/gems/yard-0.7.4/spec/cli/diff_spec.rb

@@ -0,0 +1,172 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+require 'stringio'
+require 'open-uri'
+
+describe YARD::CLI::Diff do
+  before do
+    CLI::Yardoc.stub!(:run)
+    CLI::Gems.stub!(:run)
+    @diff = CLI::Diff.new
+  end
+  
+  describe 'Argument handling' do
+    it "should exit if there is only one gem name" do
+      @diff.should_receive(:exit)
+      @diff.should_receive(:puts).with(/Usage/)
+      @diff.run
+    end
+  end
+  
+  describe 'Diffing' do
+    before do
+      @objects1 = nil
+      @objects2 = nil
+    end
+
+    def run(*args)
+      @data = StringIO.new
+      @objects1 ||= %w( C#fooey C#baz D.bar )
+      @objects2 ||= %w( A A::B A::B::C A.foo A#foo B C.foo C.bar C#baz )
+      @diff.should_receive(:load_gem_data).ordered.with('gem1').and_return(true)
+      @diff.should_receive(:load_gem_data).ordered.with('gem2').and_return(true)
+      Registry.should_receive(:all).ordered.and_return(@objects1.map {|o| P(o) })
+      Registry.should_receive(:all).ordered.and_return(@objects2.map {|o| P(o) })
+      @diff.stub!(:print) {|data| @data << data }
+      @diff.stub!(:puts) {|*args| @data << args.join("\n"); @data << "\n" }
+      @diff.run(*(args + ['gem1', 'gem2']))
+    end
+
+    it "should show differences between objects" do
+      run
+      @data.string.should == <<-eof
+Added objects:
+
+  A (...)
+  B
+  C.bar
+  C.foo
+
+Removed objects:
+
+  C#fooey
+  D.bar
+
+eof
+    end
+
+    it "should accept -a/--all" do
+      ['-a', '--all'].each do |opt|
+        run(opt)
+        @data.string.should == <<-eof
+Added objects:
+
+  A
+  A#foo
+  A.foo
+  A::B
+  A::B::C
+  B
+  C.bar
+  C.foo
+
+Removed objects:
+
+  C#fooey
+  D.bar
+
+eof
+      end
+    end
+  end
+  
+  describe 'File searching' do
+    before do
+      @diff.stub!(:generate_yardoc)
+    end
+    
+    it "should search for gem/.yardoc" do
+      File.should_receive(:directory?).with('gem1/.yardoc').and_return(true)
+      File.should_receive(:directory?).with('gem2/.yardoc').and_return(true)
+      Registry.should_receive(:load_yardoc).with('gem1/.yardoc')
+      Registry.should_receive(:load_yardoc).with('gem2/.yardoc')
+      @diff.run('gem1', 'gem2')
+    end
+    
+    it "should search for argument as yardoc" do
+      File.should_receive(:directory?).with('gem1/.yardoc').and_return(false)
+      File.should_receive(:directory?).with('gem2/.yardoc').and_return(false)
+      File.should_receive(:directory?).with('gem1').and_return(true)
+      File.should_receive(:directory?).with('gem2').and_return(true)
+      Registry.should_receive(:load_yardoc).with('gem1')
+      Registry.should_receive(:load_yardoc).with('gem2')
+      @diff.run('gem1', 'gem2')
+    end
+
+    it "should search for installed gem" do
+      File.should_receive(:directory?).with('gem1-1.0.0.gem/.yardoc').and_return(false)
+      File.should_receive(:directory?).with('gem2-1.0.0/.yardoc').and_return(false)
+      File.should_receive(:directory?).with('gem1-1.0.0.gem').and_return(false)
+      File.should_receive(:directory?).with('gem2-1.0.0').and_return(false)
+      gemmock = mock(:gemmock)
+      spec1 = mock(:spec)
+      spec2 = mock(:spec)
+      gemmock.should_receive(:find_name).at_least(1).times.and_return([spec1, spec2])
+      Gem.should_receive(:source_index).at_least(1).times.and_return(gemmock)
+      spec1.stub!(:full_name).and_return('gem1-1.0.0')
+      spec1.stub!(:name).and_return('gem1')
+      spec1.stub!(:version).and_return('1.0.0')
+      spec2.stub!(:full_name).and_return('gem2-1.0.0')
+      spec2.stub!(:name).and_return('gem2')
+      spec2.stub!(:version).and_return('1.0.0')
+      Registry.should_receive(:yardoc_file_for_gem).with('gem1', '= 1.0.0').and_return('/path/to/file')
+      Registry.should_receive(:yardoc_file_for_gem).with('gem2', '= 1.0.0').and_return(nil)
+      Registry.should_receive(:load_yardoc).with('/path/to/file')
+      CLI::Gems.should_receive(:run).with('gem2', '1.0.0').and_return(nil)
+      Dir.stub!(:chdir)
+      @diff.run('gem1-1.0.0.gem', 'gem2-1.0.0')
+    end
+    
+    it "should search for .gem file" do
+      iomock = mock(:io)
+      File.should_receive(:directory?).with('gem1/.yardoc').and_return(false)
+      File.should_receive(:directory?).with('gem2.gem/.yardoc').and_return(false)
+      File.should_receive(:directory?).with('gem1').and_return(false)
+      File.should_receive(:directory?).with('gem2.gem').and_return(false)
+      File.should_receive(:directory?).any_number_of_times
+      File.should_receive(:exist?).with('gem1.gem').and_return(true)
+      File.should_receive(:exist?).with('gem2.gem').and_return(true)
+      File.should_receive(:exist?).any_number_of_times
+      File.should_receive(:open).with('gem1.gem', 'rb').and_yield(iomock)
+      File.should_receive(:open).with('gem2.gem', 'rb')
+      FileUtils.should_receive(:mkdir_p)
+      Gem::Package.should_receive(:open).with(iomock)
+      FileUtils.should_receive(:rm_rf)
+      @diff.run('gem1', 'gem2.gem')
+    end
+    
+    it "should search for .gem file on rubygems.org" do
+      iomock = mock(:io)
+      File.should_receive(:directory?).with('gem1/.yardoc').and_return(false)
+      File.should_receive(:directory?).with('gem2.gem/.yardoc').and_return(false)
+      File.should_receive(:directory?).with('gem1').and_return(false)
+      File.should_receive(:directory?).with('gem2.gem').and_return(false)
+      File.should_receive(:directory?).any_number_of_times
+      File.should_receive(:exist?).with('gem1.gem').and_return(false)
+      File.should_receive(:exist?).with('gem2.gem').and_return(false)
+      File.should_receive(:exist?).any_number_of_times
+      @diff.should_receive(:open).with('http://rubygems.org/downloads/gem1.gem').and_yield(iomock)
+      @diff.should_receive(:open).with('http://rubygems.org/downloads/gem2.gem')
+      FileUtils.should_receive(:mkdir_p)
+      Gem::Package.should_receive(:open).with(iomock)
+      FileUtils.should_receive(:rm_rf)
+      @diff.run('gem1', 'gem2.gem')
+    end
+    
+    it "should error if gem is not found" do
+      log.should_receive(:error).with("Cannot find gem gem1")
+      log.should_receive(:error).with("Cannot find gem gem2.gem")
+      @diff.stub!(:load_gem_data).and_return(false)
+      @diff.run('gem1', 'gem2.gem')
+    end
+  end
+end