rubygem-rspec-expectations-3_5-3.5.0-bp153.1.16

- created versioned gem for version 3.5

- updated to version 2.14.5
  see installed Changelog.md
  [#]## 2.14.5 / 2014-02-01
  [full changelog](http://github.com/rspec/rspec-expectations/compare/v2.14.4...v2.14.5)
  Bug fixes
  * Fix wrong matcher descriptions with falsey expected value (yujinakayama)

- changed package name with suffix -2_14, renamed spec and changes file

- changed naming of the package, as this is a versioned gem

- regenerate with new template

- move to SLE 12 packaging schema

- updated to version 2.14.4
  [full changelog](http://github.com/rspec/rspec-expectations/compare/v2.14.3...v2.14.4)
  Bug fixes
  * Make the `match` matcher produce a diff output. (Jon Rowe, Ben Moss)
  * Choose encoding for diff's more intelligently, and when all else fails fall
  back to default internal encoding with replacing characters. (Jon Rowe)

- updated to version 2.14.3
  Bug fixes
  * Fix operator matchers (`should` syntax) when `method` is redefined on target.
  (Brandon Turner)
  * Fix diffing of hashes with object based keys. (Jon Rowe)
  * Fix operator matchers (`should` syntax) when operator is defined via
  `method_missing` (Jon Rowe)

- updated to version 2.14.2
  Bug fixes
  * Fix `be_<predicate>` matcher to not support operator chaining like the
  `be` matcher does (e.g. `be == 5`). This led to some odd behaviors
  since `be_<predicate> == anything` returned a `BeComparedTo` matcher
  and was thus always truthy. This was a consequence of the implementation
  (e.g. subclassing the basic `Be` matcher) and was not intended behavior.
  (Myron Marston).
  * Fix `change` matcher to compare using `==` in addition to `===`. This
  is important for an expression like:
  `expect {}.to change { a.class }.from(ClassA).to(ClassB)` because
  `SomeClass === SomeClass` returns false. (Myron Marston)
  [#]## 2.14.1 / 2013-08-08
  [full changelog](http://github.com/rspec/rspec-expectations/compare/v2.14.0...2.14.1)
  Bug fixes
  * Ensure diff output uses the same encoding as the encoding of
  the string being diff'd to prevent `Encoding::UndefinedConversionError`

- updated to version 2.14.0
  Bug fixes
  * Values that are not matchers use `#inspect`, rather than `#description` for
  documentation output (Andy Lindeman, Sam Phippen).
  * Make `expect(a).to be_within(x).percent_of(y)` work with negative y
  (Katsuhiko Nishimra).
  * Make the `be_predicate` matcher work as expected used with `expect{...}.to
  change...`  (Sam Phippen).
  [#]## 2.14.0.rc1 / 2013-05-27
  [full changelog](http://github.com/rspec/rspec-expectations/compare/v2.13.0...v2.14.0.rc1)
  Enhancements
  * Enhance `yield_control` so that you can specify an exact or relative
  number of times: `expect { }.to yield_control.exactly(3).times`,
  `expect { }.to yield_control.at_least(2).times`, etc (Bartek
  Borkowski).
  * Make the differ that is used when an expectation fails better handle arrays
  by splitting each element of the array onto its own line. (Sam Phippen)
  * Accept duck-typed strings that respond to `:to_str` as expectation messages.
  (Toby Ovod-Everett)
  Bug fixes
  * Fix differ to not raise errors when dealing with differently-encoded
  strings (Jon Rowe).
  * Fix `expect(something).to be_within(x).percent_of(y)` where x and y are both
  integers (Sam Phippen).
  * Fix `have` matcher to handle the fact that on ruby 2.0,
  `Enumerator#size` may return nil (Kenta Murata).
  * Fix `expect { raise s }.to raise_error(s)` where s is an error instance
  on ruby 2.0 (Sam Phippen).
  * Fix `expect(object).to raise_error` passing. This now warns the user and
  fails the spec (tomykaira).
  Deprecations
  * Deprecate `expect { }.not_to raise_error(SpecificErrorClass)` or
  `expect { }.not_to raise_error("some specific message")`. Using
  these was prone to hiding failures as they would allow _any other
  error_ to pass. (Sam Phippen and David Chelimsky)

- updated to version 2.13.0
  Enhancements
  * Add support for percent deltas to `be_within` matcher:
  `expect(value).to be_within(10).percent_of(expected)`
  (Myron Marston).
  * Add support to `include` matcher to allow it to be given a list
  of matchers as the expecteds to match against (Luke Redpath).
  Bug fixes
  * Fix `change` matcher so that it dups strings in order to handle
  mutated strings (Myron Marston).
  * Fix `should be =~ /some regex/` / `expect(...).to be =~ /some regex/`.
  Previously, these either failed with a confusing `undefined method
  matches?' for false:FalseClass` error or were no-ops that didn't
  actually verify anything (Myron Marston).
  * Add compatibility for diff-lcs 1.2 and relax the version
  constraint (Peter Goldstein).
  * Fix DSL-generated matchers to allow multiple instances of the
  same matcher in the same example to have different description
  and failure messages based on the expected value (Myron Marston).
  * Prevent `undefined method #split for Array` error when dumping
  the diff of an array of multiline strings (Myron Marston).
  * Don't blow up when comparing strings that are in an encoding
  that is not ASCII compatible (Myron Marston).
  * Remove confusing "Check the implementation of #==" message
  printed for empty diffs (Myron Marston).

- updated to version 2.12.1
  [full changelog](http://github.com/rspec/rspec-expectations/compare/v2.12.0...v2.12.1)
  Bug fixes
  * Improve the failure message for an expression like
  `{}.should =~ {}`. (Myron Marston and Andy Lindeman)
  * Provide a `match_regex` alias so that custom matchers
  built using the matcher DSL can use it (since `match`
  is a different method in that context).
  (Steven Harman)

- updated to version 2.12.0
  Enhancements
  * Colorize diffs if the `--color` option is configured. (Alex Coplan)
  * Include backtraces in unexpected errors handled by `raise_error`
  matcher (Myron Marston)
  * Print a warning when users accidentally pass a non-string argument
  as an expectation message (Sam Phippen)
  * `=~` and `match_array` matchers output a more useful error message when
  the actual value is not an array (or an object that responds to `#to_ary`)
  (Sam Phippen)
  Bug fixes
  * Fix `include` matcher so that `expect({}).to include(:a => nil)`
  fails as it should (Sam Phippen).
  * Fix `be_an_instance_of` matcher so that `Class#to_s` is used in the
  description rather than `Class#inspect`, since some classes (like
  `ActiveRecord::Base`) define a long, verbose `#inspect`.
  (Tom Stuart)

- updated to version 2.11.3
  [full changelog](http://github.com/rspec/rspec-expectations/compare/v2.11.2...v.2.11.3)
  Bug fixes
  * Fix (and deprecate) `expect { }.should` syntax so that it works even
    though it was never a documented or intended syntax. It worked as a
    consequence of the implementation of `expect` in RSpec 2.10 and
    earlier. (Myron Marston)
  * Ensure #== is defined on build in matchers so that they can be composed.
    For example:
    expect {
    user.emailed!
    }.to change { user.last_emailed_at }.to be_within(1.second).of(Time.zone.now)

- initial package