Refactor formatting

Try to follow the general guidelines for style for Ruby. Here is a
pretty good guide to follow https://github.com/bbatsov/ruby-style-guide
Refactor class names

Class names should not use underscores, they should be CamelCased.
Refactor test formatting
Remove comments

Try not to commit code that’s commented out
Refactor Rectangle and Square

While it’s great that you’re playing around with inheritance, the
relationship between these classes is not ideal.

Your Polygon class is not really defining a generic Polygon, it’s more
defining a specific subset of polygons. It only allows the length of
two sides to be given. This means that the only polygons that it can
create are four sided or three sided.

It also doesn’t really fit to have your RightTriangle inheriting from
your Polygon. The only shared behavior is the initialize method, and
only part of that.

Your NGon implementation is also only allowing for regular n-gons so it
would probable be a good idea to label it as so. It also is only
inheriting the #initialize method of Polygon, so it doesn’t really give
you much to inherit there. Initializing a regular n-gon with multiple
side lengths doesn’t make sense.

Overall, I think it’s great that you were experimenting with
inheritance but you want to be careful that you don’t try to shove it
into places where it isn’t really a great fit. Forcing all of these
classes to tight to the same #initialize implementation doesn’t really
buy you anything here and ends up leaving you with classes that are
more coupled.
Refactor tests

You want to make sure that you’re not defining variables outside of
your `it` or `let` blocks. Defining variables this way means that they
won’t be reset between each test. If any of your tests modifies any of
these variables, it would affect the results of future tests.

`let` blocks will initialize a local variable for each of the tests
that are within scope. The benefit of using `let` vs a `before` block
with instance variables is that, in some cases, a `let` block will be
faster. The `let` block doesn’t actually initialize the variable for
you until it’s used somewhere.

It’s a good practice to use `describe` blocks to group tests by the
method that they’re for.

We can use `context` blocks to better describe the particular context
in which the nested behavior applies to.

It’s not always necessary to use a `let` block. You should start by
just defining the local var inside of the test so that you can tailor
the object that you’re testing for that particular test. If you find a
lot of duplication between tests, that’s when it’s a good idea to start
pulling out `let` blocks.

Since Square inherits from Rectangle, you don’t need to test those same
methods again. I would only add more tests for Square if you were
overriding those inherited methods or adding new ones.
Merge pull request #1 from HeroicEric/ek_shapes_review

Ek shapes review