dockly-util 0.0.4

data/.cane

@@ -0,0 +1,3 @@
+--no-doc
+--abc-max 30
+--style-measure 120

data/.gitignore

@@ -0,0 +1,2 @@
+Gemfile.lock
+*.swp

data/.rspec

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

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2013 Swipely, Inc.
+
+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/Rakefile

@@ -0,0 +1,18 @@
+# Copyright Swipely, Inc.  All rights reserved.
+
+$LOAD_PATH.unshift( File.join( File.dirname(__FILE__), 'lib' ) )
+
+require 'rake'
+require 'dockly/util'
+require 'rspec/core/rake_task'
+require 'cane/rake_task'
+
+task :default => [:spec, :quality]
+
+RSpec::Core::RakeTask.new do |t|
+  t.pattern = 'spec/**/*_spec.rb'
+end
+
+Cane::RakeTask.new(:quality) do |cane|
+  cane.canefile = '.cane'
+end

data/dockly-util.gemspec

@@ -0,0 +1,20 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/dockly/util/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Swipely, Inc."]
+  gem.email         = %w{tomhulihan@swipely.com bright@swipely.com toddlunter@swipely.com}
+  gem.description   = %q{DSL made easy}
+  gem.summary       = %q{DSL made easy}
+  gem.homepage      = "https://github.com/swipely/dockly-util"
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "dockly-util"
+  gem.require_paths = %w{lib}
+  gem.version       = Dockly::Util::VERSION
+  gem.add_development_dependency 'rake'
+  gem.add_development_dependency 'rspec'
+  gem.add_development_dependency 'cane'
+  gem.add_development_dependency 'pry'
+end

data/lib/dockly.rb

@@ -0,0 +1,4 @@
+module Dockly
+end
+
+require 'dockly/util'

data/lib/dockly/util.rb

@@ -0,0 +1,8 @@
+module Dockly
+  module Util
+  end
+end
+
+require 'dockly/util/delegate'
+require 'dockly/util/logger'
+require 'dockly/util/dsl'

data/lib/dockly/util/delegate.rb

@@ -0,0 +1,6 @@
+module Dockly::Util::Delegate
+  def delegate(*syms, options)
+    target = options[:to]
+    syms.each { |sym| define_method(sym) { |*args, &block| send(target).send(sym, *args, &block) } }
+  end
+end

data/lib/dockly/util/dsl.rb

@@ -0,0 +1,118 @@
+module Dockly::Util::DSL
+  def self.included(base)
+    base.instance_eval do
+      extend ClassMethods
+      dsl_attribute :name
+    end
+  end
+
+  module ClassMethods
+    def new!(options = {}, &block)
+      inst = new(options, &block)
+      instances[inst.name] = inst
+    end
+
+    def dsl_attribute(*names)
+      names.each do |name|
+        define_method(name) do |val = nil|
+          val.nil? ? instance_variable_get(:"@#{name}")
+                   : instance_variable_set(:"@#{name}", val)
+        end
+      end
+    end
+    private :dsl_attribute
+
+    def dsl_class_attribute(name, klass)
+      unless klass.ancestors.include?(Dockly::Util::DSL)
+        raise "#{self.class}.dsl_class_attribute requires a class that includes DSL"
+      end
+      define_method(name) do |sym = nil, &block|
+        new_value = case
+                    when !block.nil? && !sym.nil? then klass.new!(:name => sym, &block)
+                    when block.nil?               then klass.instances[sym]
+                    when sym.nil?                 then klass.new!(:name => :"#{self.name}_#{klass}", &block)
+                    end
+        instance_variable_set(:"@#{name}", new_value) unless new_value.nil?
+        instance_variable_get(:"@#{name}")
+      end
+    end
+    private :dsl_class_attribute
+
+    def default_value(name, val = nil)
+      default_values[name] = block_given? ? yield : val
+    end
+    private :default_value
+
+    def default_values
+      @default_values ||= {}
+    end
+
+    def instances
+      @instances ||= {}
+    end
+
+    def demodulize(path)
+      if i = path.rindex('::')
+        path[(i+2)..-1]
+      else
+        path
+      end
+    end
+
+    def generate_unique_name
+      name = nil
+      (0..(1.0 / 0.0)).each do |n|
+        name = :"#{demodulize(self.name)}_#{n}"
+        break unless instances.has_key?(name)
+      end
+      name
+    end
+
+    def [](sym)
+      instances[sym]
+    end
+  end
+
+  def to_s
+    "#{self.class.name} (#{
+      instance_variables.map { |var|
+        "#{var} = #{instance_variable_get(var)}"
+      }.join(', ')
+    })"
+  end
+
+  def [](var)
+    instance_variable_get(:"@#{var}")
+  end
+
+  def []=(var, val)
+    instance_variable_set(:"@#{var}", val)
+  end
+
+  def ==(other_dsl)
+    (other_dsl.class == self.class) && (other_dsl.name == self.name)
+  end
+  def initialize(options = {}, &block)
+    self.class.default_values.merge(options).each do |k, v|
+      v = v.dup rescue v unless v.class.ancestors.include?(Dockly::Util::DSL)
+      public_send(k, v)
+    end
+    instance_eval(&block) unless block.nil?
+    name(self.class.generate_unique_name) if name.nil?
+    self.instance_variable_get(:@name).freeze
+  end
+
+  def to_hash
+    Hash[instance_variables.map { |ivar| [ivar.to_s[1..-1].to_sym, instance_variable_get(ivar)] }]
+  end
+
+  def ensure_present!(*syms)
+    syms.each do |sym|
+      if instance_variable_get(:"@#{sym}").nil?
+        method_name = /.*`(?<method_name>.+)'$/.match(caller[2])[:method_name]
+        raise "The following must be present to use #{self.class}##{method_name}: #{sym}"
+      end
+    end
+  end
+  private :ensure_present!
+end

data/lib/dockly/util/logger.rb

@@ -0,0 +1,96 @@
+class Dockly::Util::Logger
+  attr_accessor :prefix, :print_method, :output
+  alias_method :print_method?, :print_method
+
+  LEVELS = [:debug, :info, :warn, :error, :fatal, :unknown].freeze
+
+  def initialize(prefix = "", output = Dockly::Util::Logger.output, print_method = Dockly::Util::Logger.print_method)
+    @prefix = prefix
+    @print_method = print_method
+    @output = output
+  end
+
+  def log(level, message)
+    output.puts(format_message(level, message)) if self.class.enabled?
+  end
+
+  LEVELS.each do |level|
+    define_method(level) { |message| log(level, message) }
+  end
+
+  def format_message(level, message)
+    [
+      format_level(level),
+      Thread.current[:rake_task].to_s,
+      prefix,
+      get_last_method,
+      message
+    ].compact.reject(&:empty?).join(' ')
+  end
+
+  def format_level(level)
+    (char = level.to_s[0]) ? char.upcase : nil
+  end
+
+  def get_last_method
+    if print_method?
+      file_and_method = caller.reject { |trace| trace =~ /deployz\/logger\.rb|block \(\d+ levels\)/ }.first
+      file_and_method.match(/:in `(.+)'$/)[1]
+    end
+  end
+
+  def with_prefix(new_prefix = "", output = nil, print_method = nil)
+    output ||= self.output
+    print_method ||= self.print_method
+    yield(self.class.new([prefix, new_prefix].compact.reject(&:empty?).join(' '), output, print_method))
+  end
+
+  module Mixin
+    extend Dockly::Util::Delegate
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    def logger
+      @logger ||= Dockly::Util::Logger.new(self.class.logger_prefix)
+    end
+
+    delegate(*(LEVELS + [:log, :with_prefix]), :to => :logger)
+
+    module ClassMethods
+      def logger_prefix(val = nil)
+        val.nil? ? (@logger_prefix ||= self.name) : (@logger_prefix = val)
+      end
+    end
+  end
+
+
+  class << self
+    include Mixin
+
+    alias_method :default, :logger
+    attr_writer :print_method, :output
+
+    def disable!
+      @logger_enabled = false
+    end
+
+    def enable!
+      @logger_enabled = true
+    end
+
+    def enabled?
+      enable! if @logger_enabled.nil?
+      @logger_enabled
+    end
+
+    def print_method
+      (@print_method == false) ? false : true
+    end
+
+    def output
+      @output ||= STDOUT
+    end
+  end
+end

data/lib/dockly/util/version.rb

@@ -0,0 +1,5 @@
+module Dockly
+  module Util
+    VERSION = '0.0.4'
+  end
+end

data/spec/dockl/util/dsl_spec.rb

@@ -0,0 +1,171 @@
+require 'spec_helper'
+
+describe Dockly::Util::DSL do
+  let(:included_class) do
+    Class.new do
+      include Dockly::Util::DSL
+
+      dsl_attribute :ocean
+    end
+  end
+
+  let(:test_class) do
+    klass = included_class
+    Class.new do
+      include Dockly::Util::DSL
+
+      dsl_attribute :chips
+      dsl_class_attribute :meta, klass
+    end
+  end
+
+  subject { test_class.new!(:name => 'Tony') }
+
+  describe '.dsl_attribute' do
+    it 'defines a method for each name given' do
+      subject.should respond_to :chips
+    end
+
+    context 'the defined method(s)' do
+      context 'with 0 arguments' do
+        let(:test_val) { 'lays' }
+        before { subject.instance_variable_set(:@chips, test_val) }
+
+        it 'returns the value of the instance variable with a matching name' do
+          subject.chips.should == test_val
+        end
+      end
+
+      context 'with one argument' do
+        it 'sets the corresponding instance variable to the passed-in value' do
+          expect { subject.chips('bbq') }
+              .to change { subject.instance_variable_get(:@chips) }
+              .to 'bbq'
+        end
+      end
+    end
+  end
+
+  describe '.dsl_class_attribute' do
+    context 'when the sceond argument is not a DSL' do
+      it 'raises an error' do
+        expect do
+          Class.new do
+            include Dockly::Util::DSL
+
+            dsl_class_attribute :test, Array
+          end
+        end.to raise_error
+      end
+    end
+
+    context 'when the second argument is a DSL' do
+      it 'defines a new method with the name of the first argument' do
+        subject.should respond_to :meta
+      end
+
+      context 'the method' do
+        let(:meta) { subject.instance_variable_get(:@meta) }
+
+        context 'when a symbol is given' do
+          context 'and a block is given' do
+            before { subject.meta(:yolo) { ocean 'Indian' } }
+
+            it 'creates a new instance of the specified Class with the name set' do
+              meta.name.should == :yolo
+              meta.ocean.should == 'Indian'
+            end
+          end
+
+          context 'and a block is not given' do
+            before { included_class.new!(:name => :test_name) { ocean 'Pacific' } }
+
+            it 'looks up the instance in its Class\'s .instances hash' do
+              subject.meta(:test_name).ocean.should == 'Pacific'
+            end
+          end
+        end
+
+        context 'when a symbol is not given' do
+          context 'and a block is given' do
+            before { subject.meta { ocean 'Atlantic' } }
+
+            it 'creates a new instance of the specified Class' do
+              meta.ocean.should == 'Atlantic'
+            end
+
+            it 'generates a name' do
+              meta.name.should == :"#{subject.name}_#{meta.class}"
+            end
+          end
+
+          context 'and a block is not given' do
+            before { subject.meta(:test) { ocean 'Artic' } }
+
+            it 'returns the corresponding instance variable' do
+              subject.meta.should == meta
+            end
+          end
+        end
+      end
+    end
+  end
+
+  describe '#ensure_present!' do
+    context 'when at least one of the symbols is nil' do
+      it 'raises an error' do
+        expect { subject.send(:ensure_present!, :meta) }.to raise_error
+      end
+    end
+
+    context 'when each symbol is present' do
+      it 'does nothing' do
+        expect { subject.send(:ensure_present!, :name) }.to_not raise_error
+      end
+    end
+  end
+
+  describe '.default_value' do
+    context 'when a block is given' do
+      it 'calls the block and adds it to he default_values hash' do
+        test_class.send(:default_value, :meta) { included_class.new!(:name => :joey) }
+        test_class.default_values[:meta].name.should == :joey
+      end
+    end
+
+    context 'when a value is given' do
+      it 'adds the pair to the default_values hash' do
+        test_class.send(:default_value, :chips, 'Cool Ranch')
+        test_class.default_values[:chips].should == 'Cool Ranch'
+      end
+    end
+  end
+
+  describe '#initialize' do
+    context 'when a block is given' do
+      it 'is instance evaluated' do
+        test_class.new! { name :timmy }.name.should == :timmy
+      end
+    end
+
+    context 'when a hash is given' do
+      it 'sends each key value pair to the object as a message' do
+        test_class.new!(:name => :tommy).name.should == :tommy
+      end
+    end
+
+    context 'when there is no name' do
+      it 'raises an error' do
+        expect { test_class.new! { chips 'Tortilla' } }.to raise_error
+      end
+    end
+
+    context 'when there is a name' do
+      it 'adds the current instance to the class\'s instances hash' do
+        test_class.instances[:jillian].should be_nil
+        test_class.new! { name :jillian }
+        test_class.instances[:jillian].name.should == :jillian
+      end
+    end
+  end
+end

data/spec/dockl/util/logger_spec.rb

@@ -0,0 +1,193 @@
+require 'spec_helper'
+
+describe Dockly::Util::Logger do
+  before(:all) { Dockly::Util::Logger.enable! }
+  after(:all) { Dockly::Util::Logger.disable! unless ENV['ENABLE_LOGGER'] == 'true' }
+
+  describe '#initialize' do
+    its(:prefix) { should be_empty }
+    its(:print_method?) { should be_true }
+    its(:output) { should == STDOUT }
+  end
+
+  describe '#log' do
+    context 'when the logger is enabled' do
+      let(:level) { :debug }
+      let(:message) { 'hey mom' }
+      let(:formatted) { 'T hey mom' }
+
+      before { subject.stub(:format_message).with(level, message).and_return(formatted) }
+
+      it 'sends a formatted level and message to the output' do
+        subject.output.should_receive(:puts).with(formatted)
+        subject.log(level, message)
+      end
+    end
+
+    context 'when the logger is disabled' do
+      before(:all) { Dockly::Util::Logger.disable! }
+      after(:all) { Dockly::Util::Logger.enable! }
+
+      it 'does nothing' do
+        subject.output.should_not_receive(:puts)
+        subject.log(:debug, 'this wont be printed')
+      end
+    end
+  end
+
+  Dockly::Util::Logger::LEVELS.each do |level|
+    describe "##{level}" do
+      let(:message) { "message for #{level}" }
+
+      it "sends the message to #log with #{level} as the level" do
+        subject.should_receive(:log).with(level, message)
+        subject.public_send(level, message)
+      end
+    end
+  end
+
+  describe '#format message' do
+    before do
+      subject.stub(:prefix).and_return(prefix)
+      subject.stub(:get_last_method).and_return(method)
+      subject.stub(:format_level).with(level).and_return(formatted_level)
+    end
+
+    context 'when all of the fields are present' do
+      let(:level) { :debug }
+      let(:formatted_level) { 'D' }
+      let(:prefix) { '[deployz logger]' }
+      let(:method) { 'test' }
+      let(:message) { 'here i am' }
+
+      it 'returns each of them with a space in the middle' do
+        subject.format_message(level, message).should == "#{formatted_level} #{prefix} #{method} #{message}"
+      end
+    end
+
+    context 'when one of the fields returns nil' do
+      let(:level) { :info }
+      let(:formatted_level) { 'I' }
+      let(:prefix) { '[deployz logger]' }
+      let(:method) { nil }
+      let(:message) { 'there you are' }
+
+      it 'does not insert an extra space' do
+        subject.format_message(level, message).should == "#{formatted_level} #{prefix} #{message}"
+      end
+    end
+  end
+
+  describe '#format_level' do
+    context 'when the level is nil or empty' do
+      it 'returns nil' do
+        [nil, '', :''].should be_all { |level| subject.format_level(level).nil?  }
+      end
+    end
+
+    context 'when the level is present' do
+      it 'returns the first character upper-cased' do
+        { :info => 'I',
+          :debug => 'D',
+          '>>=' => '>'
+        }.should be_all { |level, formatted|
+          subject.format_level(level) == formatted
+        }
+      end
+    end
+  end
+
+  describe '#get_last_method' do
+    def test_get_last_method
+      subject.get_last_method
+    end
+
+    context 'when calls are not nested' do
+      it 'returns the calling method' do
+        test_get_last_method.should == 'test_get_last_method'
+      end
+    end
+
+    context 'when calls are nested' do
+      def outer_method
+        test_get_last_method
+      end
+
+      it 'still returns the calling method' do
+        outer_method.should == 'test_get_last_method'
+      end
+    end
+  end
+
+  describe '#with_prefix' do
+    context 'when the new prefix is empty' do
+      context 'and the old prefix is empty' do
+        it 'yields a new logger with an empty prefix' do
+          subject.with_prefix(nil) { |logger| logger.prefix.should be_empty }
+        end
+      end
+
+      context 'and the old prefix is present' do
+        let(:prefix) { 'hello' }
+        subject { described_class.new(prefix) }
+
+        it 'yields a new logger with the old prefix' do
+          subject.with_prefix(nil) { |logger| logger.prefix.should == prefix }
+        end
+      end
+    end
+
+    context 'when the new prefix is present' do
+      context 'and the old prefix is empty' do
+        let(:prefix) { 'hola' }
+
+        it 'yields a new logger with the new prefix' do
+          subject.with_prefix(prefix) { |logger| logger.prefix.should == prefix }
+        end
+      end
+
+      context 'and the old prefix is present' do
+        let(:old_prefix) { 'hello' }
+        let(:new_prefix) { 'hola' }
+        let(:prefix) { "#{old_prefix} #{new_prefix}" }
+
+        subject { described_class.new(old_prefix) }
+
+        it 'yields a new logger with the old prefix' do
+          subject.with_prefix(new_prefix) { |logger| logger.prefix.should == prefix }
+        end
+      end
+    end
+  end
+
+  describe 'the meta class' do
+    subject { described_class }
+
+    (Dockly::Util::Logger::LEVELS + [:default, :logger, :log, :with_prefix]).each do |method|
+      it { should respond_to method }
+    end
+  end
+
+  describe Dockly::Util::Logger::Mixin do
+    let(:test_class) { Class.new { include Dockly::Util::Logger::Mixin } }
+
+    subject { test_class.new }
+
+    describe '#logger' do
+      its(:logger) { should be_a Dockly::Util::Logger }
+
+      it 'has the class name as the prefix' do
+        subject.logger.prefix.should == test_class.name
+      end
+    end
+
+    (Dockly::Util::Logger::LEVELS + [:log, :with_prefix]).each do |method|
+      describe "##{method}" do
+        it "sends ##{method} to #logger" do
+          subject.logger.should_receive(method)
+          subject.public_send(method)
+        end
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,11 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+
+require 'rspec'
+require 'dockly/util'
+
+RSpec.configure do |config|
+  config.mock_with :rspec
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.tty = true
+end

metadata

@@ -0,0 +1,131 @@
+--- !ruby/object:Gem::Specification
+name: dockly-util
+version: !ruby/object:Gem::Version
+  version: 0.0.4
+  prerelease: 
+platform: ruby
+authors:
+- Swipely, Inc.
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-11-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: cane
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: DSL made easy
+email:
+- tomhulihan@swipely.com
+- bright@swipely.com
+- toddlunter@swipely.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .cane
+- .gitignore
+- .rspec
+- Gemfile
+- LICENSE.txt
+- Rakefile
+- dockly-util.gemspec
+- lib/dockly.rb
+- lib/dockly/util.rb
+- lib/dockly/util/delegate.rb
+- lib/dockly/util/dsl.rb
+- lib/dockly/util/logger.rb
+- lib/dockly/util/version.rb
+- spec/dockl/util/dsl_spec.rb
+- spec/dockl/util/logger_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/swipely/dockly-util
+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: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: DSL made easy
+test_files:
+- spec/dockl/util/dsl_spec.rb
+- spec/dockl/util/logger_spec.rb
+- spec/spec_helper.rb
+has_rdoc: