 
     it_inserts_component_into_the_last_nested_open_expression(
       name: 'addition'
-      manipulator: (test)-> test.manip.append_addition.build()
+      manipulator: -> @manip.append_addition.build()
       should_equal_after: (builder)-> builder(open_expression: {open_expression: ['+']}))
+
+
+
+  describe "appending subtraction", ->
+    it_plays_manipulation_role (test)->
+      @manip.append_subtraction.build()
+
+    it "adds subtraction to the end of the expression", ->
+      exp = @exp_builder(1)
+      new_exp = @manip.append_subtraction.build().invoke(exp)
+      expect(new_exp.last() instanceof @math.components.subtraction).toEqual true
+
+    it_inserts_component_into_the_last_nested_open_expression(
+      name: 'subtraction'
+      manipulator: -> @manip.append_subtraction.build()
+      should_equal_after: (builder)-> builder(open_expression: {open_expression: ['-']}))
+
+  describe "appending a decimal", ->
+    it_plays_manipulation_role ->
+      @manip.append_decimal.build(value: 5)
+
+    it "correctly adds a decimal to the value", ->
+      exp = @math.expression.build()
+      exp = @manip.append_number.build(value: 1).invoke(exp)
+      exp = @manip.append_decimal.build().invoke(exp)
+      exp = @manip.append_number.build(value: 1).invoke(exp)
+      @expect_value(exp, '1.1')
+
+    it_inserts_component_into_the_last_nested_open_expression(
+      name: 'decimal'
+      manipulator: -> @manip.append_decimal.build()
+      should_equal_after: (builder)-> builder(open_expression: {open_expression: ['0.']}))
 
 
   describe "square expression", ->

      @square = @manip.square.build()

    it_plays_manipulation_role (test)->
      test.square

    it "returns a squared expression", ->
      exp = @exp_builder(10)
      squared = @square.invoke(exp)
      @expect_value(squared, '100')


  describe "(moved over from other test file)", ->

    describe "the decimal manipulation", ->
      it "correctly adds a decimal to the value", ->
        exp = @math.expression.build()
        exp = @manip.append_number.build(value: 1).invoke(exp)
        exp = @manip.decimal.build().invoke(exp)
        exp = @manip.append_number.build(value: 1).invoke(exp)
        @expect_value(exp, '1.1')

    describe "NumberManipulation", ->
      it_plays_manipulation_role (test)->
        test.manip.append_number.build(value: 5)

    describe "DecimalManipulation", ->
      it_plays_manipulation_role (test)->
        test.manip.decimal.build(value: 5)

    describe "SubtractionManipulation", ->
      it_plays_manipulation_role (test)->
        test.manip.subtraction.build()

      it "adds subtraction to the end of the expression", ->
        exp = @math.expression.buildWithContent([
          @math.components.number.build(value: '1')
        ])

        new_exp = @manip.subtraction.build().invoke(exp)

        expect(new_exp.last() instanceof @math.components.subtraction).toEqual true

    describe "NegationManipulation", ->
      it_plays_manipulation_role (test)->
        test.manip.negate_last.build()

      it "will negate the last element", ->
        exp = @math.expression.buildWithContent([

it_plays_manipulation_role = (subject, math)->
  describe "acting as an expression manipulation", ->
    beforeEach ->
      @subject = subject.call(@)

    it "has an invoke method", ->
      expect(typeof @subject.invoke).toEqual "function"
