Failing end-to-end tests in "Displaying Price Details" in chapter 15.

The tests are failing because the table row has no details, only status
text :-

    NativeException: java.lang.AssertionError:
    Tried to look for...
        exactly 1 JTable (ANYTHING)
        in exactly 1 JFrame (with name "Auction Sniper Main" and showing
on screen)
        in all top level windows
    and check that it is table with row with cells <label with text
"item-54321">, <label with text "1000">, <label with text "1098">,
<label with text "bidding">
    but...
        all top level windows
        contained 1 JFrame (with name "Auction Sniper Main" and showing
on screen)
        contained 1 JTable (ANYTHING)
       it is not table with row with cells <label with text
"item-54321">, <label with text "1000">, <label with text "1098">,
<label with text "bidding">
        because
          in row 0: component 0 text was "bidding"

It is unclear, but in the book it looks like
`AuctionSniperDriver#shows_sniper_status` may have been overloaded so
there were different implementations for different sets of parameters.
I've decided to introduce `AuctionSniperDriver#driver.shows_sniper_status_text`
to avoid confusion and to reduce the number of changes needed in this
commit.
New unit test passing in "Sending State out of Sniper" in chapter 15.

The end-to-end tests are still failing as expected, because only the
status text is being shown, not the full details.

Note that I derived SniperState from the Ruby standard library Struct
class instead of using the Apache commons.lang library in JRuby.
Make assertions more specific now JTable has a name.

This is still slightly divergent from the code in the book which seems
to be using a different version of JTableDriver i.e. one which allows a
single constructor parameter.
Progress on end-to-end test in "Showing a Bidding Sniper" in chapter 15.

- The first step is to pass the new state parameter, which we've been
  ignoring,through `MainWindow` to a new method in `SnipersTableModel`.
- To get the new values visible on screen, we need to fix
  `SnipersTableModel` so that it makes them available to its `JTable`,
  starting with a unit test.
- We introduce a `Column` class to represent the columns in the table
  (it's more meaningful than just using integers).
- The `Column` class is an `enum` in the Java version, but I've just
  used a simple Ruby class derived from `Struct`.
- The table model needs to do two things when its state changes: hold
  onto the new values and notify the table that they've changed. The
  unit test drives out this behaviour using a mock `TableModelListener`.
- I've used a Mocha expectation matcher block to compare the properties
  of the event. This is a bit clumsier than
  `org.hamcrest.Matchers.samePropertyValuesAs`, but it'll do for now.
- Even thought it doesn't effect the tests, I changed the order in
  which the user interface components are added to the content pane
  so that the table is visible.
Rename `SniperState` in "Listening to the Mood Music" in chapter 15.

- `SniperState` is renamed to `SniperSnapshot`.
- `Column::SNIPER_STATUS` is renamed to `Column::SNIPER_STATE`.
- The book makes this sound like a trivial operation, but it's slightly
  more involved when using a text editor and a dynamically-typed
  language!
"Simplifying Sniper Events" in chapter 15.

- Introduced `SniperState` "enum" and added it as an attribute on
  newly renamed `SniperShapshot`.
- I've used another `Struct` for the newly introduced `SniperState`
  "enum" with the same style `.values` and `#ordinal` method as for
  `Column`.
- Removed the sniper_state parameter from the method signature.
- Rename `#sniper_bidding` to `#sniper_state_changed` to match its
  intended new role - a description of the sniper's relationship with
  the auction at a moment in time.
- In the table model, we use simple indexing to translate the "enum" into
  displayable text.
- Introduced a custom parameter matcher to check just the state of a
  snapshot. I've done this by converting a lambda into a block to pass
  to `Mocha::Expectation#with` which I think works quite nicely. This is
  instead of using JMock's `FeatureMatcher`. One possible disadvantage
  is that I think the error message probably isn't as good.
- Changed `#sniper_winning` to `#sniper_state_changed`.
- Changed `AuctionSniper` to retain its most recent values by holding
  on to the last snapshot.
- Remove `#sniper_winning` and add a value for "winning" to
  `SnipersTableModel::STATUS_TEXT`.
- End-to-end test now passes.
Extract custom Mocha parameter matcher into a method.

- Revisited 829549000749c30ce9159016a3dcc524a8d29643.
- Pass a lambda converted into a block into
  `Mocha::Expectation#with` to make the code more readable and more
  similar to the JMock custom matcher `aRowChangedEvent`.
Remove JLabel which was replaced by the JTable some time ago.

I suspect this was supposed to happen a while ago, but I don't think it
is mentioned in the book.
Use a SniperSnapshot builder method instead of direct construction.
"Follow Through - Converting Won and Lost" in chapter 15.

- Replace calls to `#sniper_won` and `#sniper_lost` with calls to
  `#sniper_state_changed`.
- No longer any need for `@is_winning` in `AuctionSniper`. I changed
  back to using a `case` statement so code is more similar to Java the
  Java code. Moved some decision-making into `SniperSnapshot` which
  will know whether sniper is winning or losing.
- `AuctionSniper` no longer refers to `SniperState`; it's hidden in
  `SniperSnapshot`.
- I've gone for a fairly literal translation of the Java
  `SniperState#when_auction_closed` method implmentations. I'm not sure
  this is the best or as Ruby-ish as it could be.
- Added a test for `SniperState` as per "Not Too Small to Test"
  call-out.