bitmapped 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 99702c03528a066944f878c4b91150111a57109c
-  data.tar.gz: bb7495610f144df0ed5ebbbf4073846add4a7984
+  metadata.gz: 6ae854b185764fafcc2611572e5f81ea11b88208
+  data.tar.gz: 018fab67547caaa3b04b021a37ed220c055623f5
 SHA512:
-  metadata.gz: 310a13fb27eb9a4124623c7088e2de83bf4e323fe414e2721c35bff6ddaa6e9067e95bb48296b6562410816eca7ad31455ab5ece03416b9a58262bad8ae604c1
-  data.tar.gz: 84f16acd5af696546e80aba724afa45d966dc0e1f7aed02643cf158c94b54d63b20acbfb21f98605fa868dc208eb6728b4d1283f86bca1ec9d16d853461daf42
+  metadata.gz: d52a23053a021241a06f78f5b8b73a2458a79d4ee5717762416915b06781ef354fcc05f908d0033395103a70b45758e605c1d42689e41032d11b0db4bf4af17c
+  data.tar.gz: 832a3211254842a262d95d5819312b383cc50d45c44f30c0827882c5f361c6a05866bad1b70c77394a19eefb6bca79cdc4b61f5317248fb7cf2655b67901769d

data/README.md

@@ -18,6 +18,11 @@ Bitmapped accepts various commands to create and edit bitmap-like text images:
 | Vertically Line     | Colors multiple cells on specified column between rows X Y | V   | Column:Int, Row:X, Row:Y, Color:String |
 | Horizontal Line     | Colors multiple cells on specified row between rows X Y    | H   | Row:X, Row:Y, Row:Int, Color:String    |
 | Fill (Paint Bucket) | Fills a given cell and surrounding cells of the same color | F   | Column:Int, Row:Int, Color:String      |
+| Show Table      | Displays the table on the CLI                                   | S   |                                        |
+| Show Pretty Table      | Displays a pretty table on the CLI                                   | T   |                                        |
+| Mirror          | Mirrors the image along the vertical axis                       | M   |                                        |
+| Rotate          | Rotates the image 90 degrees clockwise                          | R   |                                        |
+| Invert          | Inverts image swapping colors with opposites (Z>A, Y>B, X>C etc)| N   |                                        |
 | Exit                | Exits the program                                          | X   |                                        |
 
 
@@ -26,26 +31,51 @@ Bitmapped accepts various commands to create and edit bitmap-like text images:
     > I 5 6
     > L 2 3 A
     > S
-    +---+---+---+---+---+
-    | 0 | 0 | 0 | 0 | 0 |
-    | 0 | 0 | 0 | 0 | 0 |
-    | 0 | 0 | 0 | 0 | 0 |
-    | 0 | 0 | 0 | 0 | 0 |
-    | 0 | 0 | 0 | 0 | 0 |
-    | 0 | 0 | 0 | 0 | 0 |
-    +---+---+---+---+---+
+    OOOOO
+    OOOOO
+    OAOOO
+    OOOOO
+    OOOOO
+    OOOOO
     > F 3 3 J
     > V 2 3 4 W
     > H 3 4 2 Z
     > S
-    +---+---+---+---+---+
-    | J | J | J | J | J |
-    | J | J | Z | Z | J |
-    | J | W | J | J | J |
-    | J | W | J | J | J |
-    | J | J | J | J | J |
-    | J | J | J | J | J |
-    +---+---+---+---+---+
+    JJJJJ
+    JJZZJ
+    JWJJJ
+    JWJJJ
+    JJJJJ
+    JJJJJ
+    > R
+    > S
+    JJJJJJ
+    JJWWJJ
+    JJJJZJ
+    JJJJZJ
+    JJJJJJ
+    > M
+    > S
+    JJJJJJ
+    JJWWJJ
+    JZJJJJ
+    JZJJJJ
+    JJJJJJ
+    > N
+    > S
+    QQQQQQ
+    QQDDQQ
+    QAQQQQ
+    QAQQQQ
+    QQQQQQ
+    > T
+    +---+---+---+---+---+---+
+    | Q | Q | Q | Q | Q | Q |
+    | Q | Q | D | D | Q | Q |
+    | Q | A | Q | Q | Q | Q |
+    | Q | A | Q | Q | Q | Q |
+    | Q | Q | Q | Q | Q | Q |
+    +---+---+---+---+---+---+
 
 ## Requirements
     Ruby 2.0+
@@ -55,8 +85,7 @@ Bitmapped accepts various commands to create and edit bitmap-like text images:
 
 ## TODO
 
-* Custom commands
-* Refactor Bitmap commands into objects with tests
+* Refactor tests
 
 ### Copyright
 

data/bitmapped.gemspec

@@ -5,7 +5,7 @@ require File.expand_path('../lib/bitmapped/version', __FILE__)
 Gem::Specification.new do |gem|
   gem.name          = "bitmapped"
   gem.version       = Bitmapped::VERSION
-  gem.platform    = Gem::Platform::RUBY
+  gem.platform      = Gem::Platform::RUBY
   gem.summary       = %q{Bitmap CLI program}
   gem.description   = %q{Bitmap CLI program}
   gem.license       = "MIT"
@@ -19,5 +19,10 @@ Gem::Specification.new do |gem|
   gem.require_paths = ['lib']
 
   gem.required_ruby_version = ">= 2.0.0"
+  gem.add_development_dependency 'bundler', '~> 1.0'
+  gem.add_development_dependency 'rake', '~> 0.8'
+  gem.add_development_dependency 'rdoc', '~> 3.0'
+  gem.add_development_dependency 'rspec', '~> 2.4'
+  gem.add_development_dependency 'rubygems-tasks', '~> 0.2'
   gem.add_runtime_dependency 'terminal-table', '~> 1.4', '>= 1.4.5'
 end

data/lib/bitmapped/bitmap.rb

@@ -1,6 +1,6 @@
 Dir[File.join(File.dirname(__FILE__), 'validators', '*.rb')].each {|file| require file }
+Dir[File.join(File.dirname(__FILE__), 'commands', '*.rb')].each {|file| require file }
 
-require 'terminal-table'
 require 'bitmapped/exceptions'
 
 module Bitmapped
@@ -12,111 +12,39 @@ module Bitmapped
       begin
         case input.shift
         when "I"
-          self.columns, self.rows = Validators::ValidateColumnRowInput.parse_and_validate(input)
-          self.pixels = populate_pixels(self.columns, self.rows)
-        when "X"
-          raise Interrupt
-        when bitmap_available("C")
-          self.pixels = populate_pixels(self.columns, self.rows)
-        when bitmap_available("L")
-          column, row, color = Validators::ValidateFillInput.parse_and_validate(input)
-          color_command(column, row, color)
-        when bitmap_available("V")
-          column, start, finish, color = Validators::ValidateSegmentInput.parse_and_validate(input)
-          vertical_command(column, start, finish, color)
-        when bitmap_available("H")
-          start, finish, row, color = Validators::ValidateSegmentInput.parse_and_validate(input)
-          horizontal_command(start, finish, row, color)
-        when bitmap_available("F")
-          column, row, color = Validators::ValidateFillInput.parse_and_validate(input)
-          fill_command(column, row, color)
-        when bitmap_available("S")
-          formatted_table
-        when "C", "L", "V", "H", "F", "S"
-          "Bitmap has not been initialised, run command 'I' with valid arguments"
+          Commands::InitialiserCommand.new.process_command(self, input)
+        when "X", "exit"
+          Commands::ExitCommand.new.process_command(self, input)
+        when "C"
+          Commands::ClearCommand.new.process_command(self, input)
+        when "L"
+          Commands::PixelFillCommand.new.process_command(self, input)
+        when "V"
+          Commands::VerticalLineCommand.new.process_command(self, input)
+        when "H"
+          Commands::HorizontalLineCommand.new.process_command(self, input)
+        when "F"
+          Commands::FillCommand.new.process_command(self, input)
+        when "S"
+          Commands::PrintTableCommand.new.process_command(self, input)
+        when "T"
+          Commands::PrintFancyTableCommand.new.process_command(self, input)
+        when "R"
+          Commands::RotateCommand.new.process_command(self, input)
+        when "M"
+          Commands::MirrorCommand.new.process_command(self, input)
+        when "N"
+          Commands::InvertCommand.new.process_command(self, input)
         else
           "Invalid Command"
         end
-      rescue ParsingError => e
+      rescue BitmapNotInitialised => bni
+        "Bitmap has not been initialised, run command 'I' with valid arguments"
+      rescue ParsingError => pe
         "Invalid parameters"
-      rescue InvalidCoordinatesError => e
+      rescue InvalidCoordinatesError => ice
         "Invalid co-ordinates"
       end
     end
-
-    private
-      def populate_pixels(x, y)
-        Array.new(self.rows) { Array.new(self.columns) { "0" } }
-      end
-
-      def bitmap_available(command)
-        lambda { |option| option == command && self.pixels }
-      end
-
-      def formatted_table
-        self.table ||= Terminal::Table.new
-        self.table.rows = self.pixels
-        self.table
-        # self.pixels.each { |row| puts row.join("") } # no fancy table
-      end
-
-      def color_command(x, y, color)
-        x, y = coordinates_to_array_indexes(x, y)
-        self.pixels[y][x] = color
-      end
-
-      def vertical_command(column, x, y, color)
-        raise InvalidCoordinatesError unless (0 < column && column <= self.columns)
-        x, y = coordinates_to_array_indexes(x, y)
-        column = column - 1
-        self.pixels[x..y].each { |row| row[column] = color }
-      end
-
-      def horizontal_command(x, y, row, color)
-        raise InvalidCoordinatesError unless (0 < row && row <= self.rows)
-        x, y = coordinates_to_array_indexes(x, y)
-        row = row - 1
-        self.pixels[row][x..y] = Array.new((x..y).size, color)
-      end
-
-      def fill_command(x, y, replacement_color)
-        x, y = coordinates_to_array_indexes(x, y)
-        target_color = self.pixels[x][y]
-        queue = [[x,y]]
-
-        until queue.empty?
-          x, y = queue.pop
-          next if (!valid_cooridinates(x+1, y+1) || self.pixels[x][y] != target_color)
-          self.pixels[x][y] = replacement_color
-          queue << [x+1, y] # east
-          queue << [x-1, y] # west
-          queue << [x, y+1] # south
-          queue << [x, y-1] # north
-
-          # and if we are doing 8-direction flood-fill...
-          # queue << [x+1, y-1] # north-east
-          # queue << [x-1, y-1] # north-west
-          # queue << [x+1, y+1] # south-east
-          # queue << [x-1, y+1] # south-west
-        end
-      end
-
-      def valid_cooridinates(x, y)
-        if (0 <= x && x <= self.columns) && (0 <= y && y <= self.rows)
-          true
-        else
-          false
-        end
-      end
-
-      def coordinates_to_array_indexes(x, y)
-        x = x.to_i - 1
-        y = y.to_i - 1
-        if valid_cooridinates(x, y)
-          [x, y]
-        else
-          raise InvalidCoordinatesError
-        end
-      end
   end
 end

data/lib/bitmapped/cli.rb

@@ -12,7 +12,7 @@ module Bitmapped
 
           loop do
             input = split_input(Readline.readline("> "))
-            puts bitmap.command(input)
+            bitmap.command(input)
           end
         rescue Interrupt => interrupt
           puts "\nExiting..."

data/lib/bitmapped/commands/base_command.rb

@@ -0,0 +1,13 @@
+module Bitmapped
+  module Commands
+    class BaseCommand
+      def command_id
+        raise NotImplementedError.new("You must implement command_id.")
+      end
+
+      def process_command(pixels, args)
+        raise NotImplementedError.new("You must implement process_command.")
+      end
+    end
+  end
+end

data/lib/bitmapped/commands/clear_command.rb

@@ -0,0 +1,17 @@
+require 'bitmapped/commands/base_command'
+
+module Bitmapped
+  module Commands
+    class ClearCommand < BaseCommand
+
+      def command_id
+        "C"
+      end
+
+      def process_command(bitmap, input)
+        Validators::ValidateBitmapInitialised.parse_and_validate(bitmap)
+        bitmap.pixels = Array.new(bitmap.rows) { Array.new(bitmap.columns) { "O" } }
+      end
+    end
+  end
+end

data/lib/bitmapped/commands/commands_helper.rb

@@ -0,0 +1,25 @@
+require 'bitmapped/commands/base_command'
+
+module Bitmapped
+  module Commands
+    module CommandsHelper
+      def valid_cooridinates(bitmap, x, y)
+        if (0 <= x && x <= bitmap.columns) && (0 <= y && y <= bitmap.rows)
+          true
+        else
+          false
+        end
+      end
+
+      def coordinates_to_array_indexes(bitmap, x, y)
+        x = x.to_i - 1
+        y = y.to_i - 1
+        if valid_cooridinates(bitmap, x, y)
+          [x, y]
+        else
+          raise InvalidCoordinatesError
+        end
+      end
+    end
+  end
+end

data/lib/bitmapped/commands/exit_command.rb

@@ -0,0 +1,16 @@
+require 'bitmapped/commands/base_command'
+
+module Bitmapped
+  module Commands
+    class ExitCommand < BaseCommand
+
+      def command_id
+        "X"
+      end
+
+      def process_command(bitmap, input)
+        raise Interrupt
+      end
+    end
+  end
+end

data/lib/bitmapped/commands/fill_command.rb

@@ -0,0 +1,44 @@
+require 'bitmapped/commands/base_command'
+require 'bitmapped/commands/commands_helper'
+require 'bitmapped/exceptions'
+
+module Bitmapped
+  module Commands
+    class FillCommand < BaseCommand
+      include CommandsHelper
+
+      def command_id
+        "F"
+      end
+
+      def process_command(bitmap, input)
+        Validators::ValidateBitmapInitialised.parse_and_validate(bitmap)
+        column, row, color = Validators::ValidateFillInput.parse_and_validate(input)
+        fill_command(bitmap, column, row, color)
+      end
+
+      private
+        def fill_command(bitmap, x, y, replacement_color)
+          x, y = coordinates_to_array_indexes(bitmap, x, y)
+          target_color = bitmap.pixels[x][y]
+          queue = [[x,y]]
+
+          until queue.empty?
+            x, y = queue.pop
+            next if (!valid_cooridinates(bitmap, x+1, y+1) || bitmap.pixels[x][y] != target_color)
+            bitmap.pixels[x][y] = replacement_color
+            queue << [x+1, y] # east
+            queue << [x-1, y] # west
+            queue << [x, y+1] # south
+            queue << [x, y-1] # north
+
+            # and if we are doing 8-direction flood-fill...
+            # queue << [x+1, y-1] # north-east
+            # queue << [x-1, y-1] # north-west
+            # queue << [x+1, y+1] # south-east
+            # queue << [x-1, y+1] # south-west
+          end
+        end
+    end
+  end
+end

data/lib/bitmapped/commands/horizontal_line_command.rb

@@ -0,0 +1,29 @@
+require 'bitmapped/commands/base_command'
+require 'bitmapped/commands/commands_helper'
+require 'bitmapped/exceptions'
+
+module Bitmapped
+  module Commands
+    class HorizontalLineCommand < BaseCommand
+      include CommandsHelper
+
+      def command_id
+        "H"
+      end
+
+      def process_command(bitmap, input)
+        Validators::ValidateBitmapInitialised.parse_and_validate(bitmap)
+        column, start, finish, color = Validators::ValidateSegmentInput.parse_and_validate(input)
+        horizontal_command(bitmap, column, start, finish, color)
+      end
+
+      private
+        def horizontal_command(bitmap, x, y, row, color)
+          raise InvalidCoordinatesError unless (0 < row && row <= bitmap.rows)
+          x, y = coordinates_to_array_indexes(bitmap, x, y)
+          row = row - 1
+          bitmap.pixels[row][x..y] = Array.new((x..y).size, color)
+        end
+    end
+  end
+end

data/lib/bitmapped/commands/initialiser_command.rb

@@ -0,0 +1,18 @@
+require 'bitmapped/commands/base_command'
+
+module Bitmapped
+  module Commands
+    class InitialiserCommand < BaseCommand
+
+      def command_id
+        "I"
+      end
+
+      def process_command(bitmap, input)
+        Validators::ValidateBitmapSize.parse_and_validate(input)
+        bitmap.columns, bitmap.rows = Validators::ValidateColumnRowInput.parse_and_validate(input)
+        bitmap.pixels = Array.new(bitmap.rows) { Array.new(bitmap.columns) { "O" } }
+      end
+    end
+  end
+end

data/lib/bitmapped/commands/invert_command.rb

@@ -0,0 +1,26 @@
+require 'bitmapped/commands/base_command'
+
+module Bitmapped
+  module Commands
+    class InvertCommand < BaseCommand
+
+      ALPHABET = [*'A'..'Z']
+
+      def command_id
+        "N"
+      end
+
+      def process_command(bitmap, input)
+        Validators::ValidateBitmapInitialised.parse_and_validate(bitmap)
+        bitmap.pixels.each_with_index do |row, index|
+          bitmap.pixels[index] = row.collect{ |color| invert_color(color) }
+        end
+      end
+
+      private
+        def invert_color(color)
+          ALPHABET[-(ALPHABET.index(color)+1)]
+        end
+    end
+  end
+end

data/lib/bitmapped/commands/mirror_command.rb

@@ -0,0 +1,17 @@
+require 'bitmapped/commands/base_command'
+
+module Bitmapped
+  module Commands
+    class MirrorCommand < BaseCommand
+
+      def command_id
+        "R"
+      end
+
+      def process_command(bitmap, input)
+        Validators::ValidateBitmapInitialised.parse_and_validate(bitmap)
+        bitmap = bitmap.pixels.collect { |row| row.reverse! }
+      end
+    end
+  end
+end

data/lib/bitmapped/commands/pixel_fill_command.rb

@@ -0,0 +1,27 @@
+require 'bitmapped/commands/base_command'
+require 'bitmapped/commands/commands_helper'
+require 'bitmapped/exceptions'
+
+module Bitmapped
+  module Commands
+    class PixelFillCommand < BaseCommand
+      include CommandsHelper
+
+      def command_id
+        "L"
+      end
+
+      def process_command(bitmap, input)
+          Validators::ValidateBitmapInitialised.parse_and_validate(bitmap)
+          column, row, color = Validators::ValidateFillInput.parse_and_validate(input)
+          color_command(bitmap, column, row, color)
+      end
+
+      private
+        def color_command(bitmap, x, y, color)
+          x, y = coordinates_to_array_indexes(bitmap, x, y)
+          bitmap.pixels[y][x] = color
+        end
+    end
+  end
+end

data/lib/bitmapped/commands/print_fancy_table_command.rb

@@ -0,0 +1,22 @@
+require 'bitmapped/commands/base_command'
+
+require 'terminal-table'
+
+module Bitmapped
+  module Commands
+    class PrintFancyTableCommand < BaseCommand
+
+      def command_id
+        "T"
+      end
+
+      def process_command(bitmap, input)
+        Validators::ValidateBitmapInitialised.parse_and_validate(bitmap)
+        bitmap.table ||= Terminal::Table.new
+        bitmap.table.rows = bitmap.pixels
+        puts bitmap.table
+        bitmap.table
+      end
+    end
+  end
+end

data/lib/bitmapped/commands/print_table_command.rb

@@ -0,0 +1,19 @@
+require 'bitmapped/commands/base_command'
+
+module Bitmapped
+  module Commands
+    class PrintTableCommand < BaseCommand
+
+      def command_id
+        "S"
+      end
+
+      def process_command(bitmap, input)
+        Validators::ValidateBitmapInitialised.parse_and_validate(bitmap)
+        table = bitmap.pixels.collect { |row| row.join("") }.join("\n")
+        puts table
+        table
+      end
+    end
+  end
+end

data/lib/bitmapped/commands/rotate_command.rb

@@ -0,0 +1,17 @@
+require 'bitmapped/commands/base_command'
+
+module Bitmapped
+  module Commands
+    class RotateCommand < BaseCommand
+
+      def command_id
+        "R"
+      end
+
+      def process_command(bitmap, _)
+        Validators::ValidateBitmapInitialised.parse_and_validate(bitmap)
+        bitmap.pixels = bitmap.pixels.transpose.map &:reverse
+      end
+    end
+  end
+end

data/lib/bitmapped/commands/vertical_line_command.rb

@@ -0,0 +1,29 @@
+require 'bitmapped/commands/base_command'
+require 'bitmapped/commands/commands_helper'
+require 'bitmapped/exceptions'
+
+module Bitmapped
+  module Commands
+    class VerticalLineCommand < BaseCommand
+      include CommandsHelper
+
+      def command_id
+        "V"
+      end
+
+      def process_command(bitmap, input)
+        Validators::ValidateBitmapInitialised.parse_and_validate(bitmap)
+        column, start, finish, color = Validators::ValidateSegmentInput.parse_and_validate(input)
+        vertical_command(bitmap, column, start, finish, color)
+      end
+
+      private
+        def vertical_command(bitmap, column, x, y, color)
+          raise InvalidCoordinatesError unless (0 < column && column <= bitmap.columns)
+          x, y = coordinates_to_array_indexes(bitmap, x, y)
+          column = column - 1
+          bitmap.pixels[x..y].each { |row| row[column] = color }
+        end
+    end
+  end
+end

data/lib/bitmapped/exceptions.rb

@@ -1,4 +1,5 @@
 module Bitmapped
   class ParsingError < StandardError; end
   class InvalidCoordinatesError < StandardError; end
+  class BitmapNotInitialised < StandardError; end
 end

data/lib/bitmapped/validators/validate_bitmap_initialised.rb

@@ -0,0 +1,15 @@
+require 'bitmapped/exceptions'
+require 'bitmapped/validators/validation_helper'
+
+module Bitmapped
+  module Validators
+    class ValidateBitmapInitialised
+
+      class << self
+        def parse_and_validate(bitmap)
+          raise BitmapNotInitialised unless bitmap.pixels
+        end
+      end
+    end
+  end
+end

data/lib/bitmapped/validators/validate_column_row_input.rb

@@ -10,6 +10,7 @@ module Bitmapped
 
             columns = Integer(input[0])
             rows = Integer(input[1])
+
             [columns, rows]
           rescue ArgumentError => ae
             raise ParsingError

data/lib/bitmapped/validators/validate_coordinates.rb

@@ -0,0 +1,20 @@
+require 'bitmapped/exceptions'
+require 'bitmapped/validators/validation_helper'
+
+module Bitmapped
+  module Validators
+    class ValidateCoordinates
+      class << self
+        def parse_and_validate(bitmap, input)
+          begin
+            row = Integer(input[0])
+            column = Integer(input[1])
+            raise InvalidCoordinatesError unless bitmap.pixels[row][column]
+          rescue NoMethodError => nme
+            raise InvalidCoordinatesError
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bitmapped/validators/validated_bitmap_size.rb

@@ -0,0 +1,19 @@
+require 'bitmapped/exceptions'
+require 'bitmapped/validators/validation_helper'
+
+module Bitmapped
+  module Validators
+    class ValidateBitmapSize
+      class << self
+        def parse_and_validate(input)
+          begin
+            columns, rows = Validators::ValidateColumnRowInput.parse_and_validate(input)
+            raise ArgumentError unless ((0 < columns && columns <= 250) && (0 < rows && rows <= 250))
+          rescue ArgumentError => ae
+            raise ParsingError
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bitmapped/validators/validation_helper.rb

@@ -3,10 +3,13 @@ require 'bitmapped/exceptions'
 module Bitmapped
   module Validators
     module ValidationHelper
+
+      ALPHABET = [*'A'..'Z']
+
       class << self
         def parse_color(color)
           color = color.strip
-          if [*'A'..'Z'].include?(color)
+          if ALPHABET.include?(color)
             color
           else
             raise ParsingError

data/lib/bitmapped/version.rb

@@ -1,4 +1,4 @@
 module Bitmapped
   # bitmapped version
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/spec/bitmap_spec.rb

@@ -1,3 +1,8 @@
+# Since the refactoring this is more intergration test than unit test
+# I'm going to leave this as is but if I had time it would be broken
+# into indidual command unit tests, with all operations done in a few
+# integration tests
+
 require 'spec_helper'
 
 require 'bitmapped/bitmap'
@@ -13,11 +18,13 @@ describe Bitmap do
   end
 
   describe 'the I command' do
+    let(:args) { ["I", "2", "3"] }
+    let(:second_args) { ["I", "3", "2"] }
+
     it 'initializes a grid of that size' do
-      args = ["I", "2", "3"]
-      pixels = [["0", "0"],
-                ["0", "0"],
-                ["0", "0"]]
+      pixels = [["O", "O"],
+                ["O", "O"],
+                ["O", "O"]]
 
       subject.command(args)
 
@@ -27,12 +34,10 @@ describe Bitmap do
     end
 
     it 'overwrites the old bitmap given the I command again' do
-      first_args = ["I", "2", "3"]
-      second_args = ["I", "3", "2"]
-      pixels = [["0", "0", "0"],
-                ["0", "0", "0"]]
+      pixels = [["O", "O", "O"],
+                ["O", "O", "O"]]
 
-      subject.command(first_args)
+      subject.command(args)
       subject.command(second_args)
 
       expect(subject.columns).to eq(3)
@@ -55,8 +60,8 @@ describe Bitmap do
         setup_pixels(subject, 3, 2, "X")
         subject.command(["C"])
 
-        expect(subject.pixels).to eq([["0", "0", "0"],
-                                      ["0", "0", "0"]])
+        expect(subject.pixels).to eq([["O", "O", "O"],
+                                      ["O", "O", "O"]])
       end
     end
   end
@@ -73,8 +78,8 @@ describe Bitmap do
         subject.command(["L", "1", "2", "Z"])
         subject.command(["L", "2", "1", "Z"])
 
-        expect(subject.pixels).to eq([["0", "Z", "0"],
-                                      ["Z", "0", "0"]])
+        expect(subject.pixels).to eq([["O", "Z", "O"],
+                                      ["Z", "O", "O"]])
       end
 
       it 'returns an error when the coordinates are not valid' do
@@ -95,10 +100,10 @@ describe Bitmap do
         subject.command(["V", "3", "2", "4", "X"])
         subject.command(["V", "1", "1", "3", "Z"])
 
-        expect(subject.pixels).to eq([["Z","0","0","0"],
-                                      ["Z","0","X","0"],
-                                      ["Z","0","X","0"],
-                                      ["0","0","X","0"]]
+        expect(subject.pixels).to eq([["Z","O","O","O"],
+                                      ["Z","O","X","O"],
+                                      ["Z","O","X","O"],
+                                      ["O","O","X","O"]]
           )
       end
 
@@ -128,9 +133,9 @@ describe Bitmap do
         subject.command(["H", "2", "4", "2", "X"])
         subject.command(["H", "1", "4", "4", "Z"])
 
-        expect(subject.pixels).to eq([["0","0","0","0"],
-                                      ["0","X","X","X"],
-                                      ["0","0","0","0"],
+        expect(subject.pixels).to eq([["O","O","O","O"],
+                                      ["O","X","X","X"],
+                                      ["O","O","O","O"],
                                       ["Z","Z","Z","Z"]]
           )
       end
@@ -171,16 +176,46 @@ describe Bitmap do
   describe 'the S command' do
     it_should_behave_like "a command requiring an initialised bitmap", "S"
 
+    context 'when the bitmap is initialised' do
+      before(:example) do
+        setup_pixels(subject, 4, 4)
+      end
+
+      let(:formatted_table) { %{OOOO
+                                OOOO
+                                OOOO
+                                OOOO}.gsub(/[^\S\n]{2,}/, '')}
+
+      let(:filled_formatted_table) {%{JJJJ
+                                      JJJJ
+                                      JJJJ
+                                      JJJJ}.gsub(/[^\S\n]{2,}/, '')}
+
+      it 'should output a formatted table' do
+        expect(subject.command(["S"]).to_s).to eq(formatted_table)
+      end
+
+      it 'should output a correctly formatted table after fill command' do
+        subject.command(["F", "3", "3", "J"])
+
+        expect(subject.command(["S"]).to_s).to eq(filled_formatted_table)
+      end
+    end
+  end
+
+  describe 'the T command' do
+    it_should_behave_like "a command requiring an initialised bitmap", "T"
+
     context 'when the bitmap is initialised' do
       before(:example) do
         setup_pixels(subject, 4, 4)
       end
 
       let(:formatted_table) { %{+---+---+---+---+
-                                | 0 | 0 | 0 | 0 |
-                                | 0 | 0 | 0 | 0 |
-                                | 0 | 0 | 0 | 0 |
-                                | 0 | 0 | 0 | 0 |
+                                | O | O | O | O |
+                                | O | O | O | O |
+                                | O | O | O | O |
+                                | O | O | O | O |
                                 +---+---+---+---+}.gsub(/[^\S\n]{2,}/, '')}
 
       let(:filled_formatted_table) {%{+---+---+---+---+
@@ -191,18 +226,85 @@ describe Bitmap do
                                       +---+---+---+---+}.gsub(/[^\S\n]{2,}/, '')}
 
       it 'should output a formatted table' do
-        expect(subject.command(["S"]).to_s).to eq(formatted_table)
+        expect(subject.command(["T"]).to_s).to eq(formatted_table)
       end
 
       it 'should output a correctly formatted table after fill command' do
         subject.command(["F", "3", "3", "J"])
 
-        expect(subject.command(["S"]).to_s).to eq(filled_formatted_table)
+        expect(subject.command(["T"]).to_s).to eq(filled_formatted_table)
+      end
+    end
+  end
+
+  describe 'the rotate command' do
+    it_should_behave_like "a command requiring an initialised bitmap", "R"
+
+    context 'when the bitmap is initialised' do
+      before(:example) do
+        setup_pixels(subject, 4, 4)
+      end
+
+      it 'should rotate the bitmap 90 degrees clockwise' do
+        subject.command(["H", "1", "4", "1", "X"])
+        subject.command(["H", "1", "4", "4", "Z"])
+        subject.command(["R"])
+
+        expect(subject.pixels).to eq([["Z","O","O","X"],
+                                      ["Z","O","O","X"],
+                                      ["Z","O","O","X"],
+                                      ["Z","O","O","X"]])
+      end
+    end
+  end
+
+  describe 'the mirror command' do
+    it_should_behave_like "a command requiring an initialised bitmap", "M"
+
+    context 'when the bitmap is initialised' do
+      before(:example) do
+        setup_pixels(subject, 4, 4)
+      end
+
+      it 'should mirror the bitmap on the vertical axis' do
+        subject.command(["H", "1", "4", "1", "W"])
+        subject.command(["H", "1", "4", "4", "X"])
+        subject.command(["V", "1", "1", "4", "Y"])
+        subject.command(["V", "4", "1", "4", "Z"])
+        subject.command(["M"])
+
+        expect(subject.pixels).to eq([["Z","W","W","Y"],
+                                      ["Z","O","O","Y"],
+                                      ["Z","O","O","Y"],
+                                      ["Z","X","X","Y"]])
+      end
+    end
+  end
+
+  describe 'the invert command' do
+    it_should_behave_like "a command requiring an initialised bitmap", "N"
+
+    context 'when the bitmap is initialised' do
+      before(:example) do
+        setup_pixels(subject, 4, 4)
+      end
+
+      it 'should mirror the bitmap on the vertical axis' do
+        subject.command(["H", "1", "4", "1", "W"])
+        subject.command(["H", "1", "4", "4", "X"])
+        subject.command(["V", "1", "1", "4", "Y"])
+        subject.command(["V", "4", "1", "4", "Z"])
+        subject.command(["N"])
+
+        expect(subject.pixels).to eq([["B","D","D","A"],
+                                      ["B","L","L","A"],
+                                      ["B","L","L","A"],
+                                      ["B","C","C","A"]])
       end
     end
   end
 
-  def setup_pixels(subject, columns, rows, color="0")
+  def setup_pixels(subject, columns, rows, color="O")
     subject.columns = columns
     subject.rows = rows
     subject.pixels = Array.new(rows) { Array.new(columns) { color } }

data/spec/command/base_command_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe 'BaseCommand' do
+
+  subject { Commands::BaseCommand.new }
+
+  context 'as an abstract class' do
+    it 'raises a NotImplementedError on any methods called' do
+      expect{subject.command_id}.to raise_error(NotImplementedError)
+      expect{subject.process_command(nil, nil)}.to raise_error(NotImplementedError)
+    end
+  end
+end

data/spec/validators/validate_bitmap_initialised_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+require 'bitmapped/exceptions'
+
+describe Validators::ValidateBitmapInitialised do
+
+  subject { Validators::ValidateBitmapInitialised }
+
+  context 'given an initialised bitmap' do
+
+    let(:bitmap) { Bitmap.new }
+
+    it 'should not raise a BitmapNotInitialised error' do
+      bitmap.command(["I", "4", "4"])
+
+      expect{subject.parse_and_validate(bitmap)}.to_not raise_error
+    end
+  end
+
+  context 'given an uninitialised bitmap' do
+
+    let(:invalid_inputs) { [["A", "2"], ["2", "Z"], ["99"]] }
+
+    it 'should raise a BitmapNotInitialised error' do
+      invalid_inputs.each do |input|
+        expect{Validators::ValidateColumnRowInput.parse_and_validate(input)}.to raise_error(ParsingError)
+      end
+    end
+  end
+end

data/spec/validators/validate_column_row_input_spec.rb

@@ -3,6 +3,9 @@ require 'spec_helper'
 require 'bitmapped/exceptions'
 
 describe Validators::ValidateColumnRowInput do
+
+  subject { Validators::ValidateColumnRowInput }
+
   context 'given valid input' do
 
     let(:valid_inputs) { [["2", "2"], ["2", "3"], ["10", "99"]] }
@@ -10,7 +13,7 @@ describe Validators::ValidateColumnRowInput do
 
     it 'should return an array of parsed values' do
       valid_inputs.each_with_index do |input, index|
-        expect(Validators::ValidateColumnRowInput.parse_and_validate(input)).to eq(outputs[index])
+        expect(subject.parse_and_validate(input)).to eq(outputs[index])
       end
     end
   end
@@ -21,7 +24,7 @@ describe Validators::ValidateColumnRowInput do
 
     it 'should return an error' do
       invalid_inputs.each do |input|
-        expect{Validators::ValidateColumnRowInput.parse_and_validate(input)}.to raise_error(ParsingError)
+        expect{subject.parse_and_validate(input)}.to raise_error(ParsingError)
       end
     end
   end

data/spec/validators/validate_fill_input_spec.rb

@@ -3,6 +3,9 @@ require 'spec_helper'
 require 'bitmapped/exceptions'
 
 describe Validators::ValidateFillInput do
+
+  subject { Validators::ValidateFillInput }
+
   context 'given valid input' do
 
     let(:valid_inputs) { [["2", "2", "C"], ["2", "3", "X"], ["10", "99", "Y"]] }
@@ -10,7 +13,7 @@ describe Validators::ValidateFillInput do
 
     it 'should return an array of parsed values' do
       valid_inputs.each_with_index do |input, index|
-        expect(Validators::ValidateFillInput.parse_and_validate(input)).to eq(outputs[index])
+        expect(subject.parse_and_validate(input)).to eq(outputs[index])
       end
     end
   end
@@ -21,7 +24,7 @@ describe Validators::ValidateFillInput do
 
     it 'should return an error' do
       invalid_inputs.each do |input|
-        expect{Validators::ValidateFillInput.parse_and_validate(input)}.to raise_error(ParsingError)
+        expect{subject.parse_and_validate(input)}.to raise_error(ParsingError)
       end
     end
   end

data/spec/validators/validate_helper_spec.rb

@@ -3,6 +3,9 @@ require 'spec_helper'
 require 'bitmapped/exceptions'
 
 describe Validators::ValidationHelper do
+
+  subject { Validators::ValidationHelper }
+
   context 'given valid input' do
 
     let(:valid_inputs) { ["         A", "B", "C       "] }
@@ -10,7 +13,7 @@ describe Validators::ValidationHelper do
 
     it 'should return an array of parsed values' do
       valid_inputs.each_with_index do |input, index|
-        expect(Validators::ValidationHelper.parse_color(input)).to eq(outputs[index])
+        expect(subject.parse_color(input)).to eq(outputs[index])
       end
     end
   end
@@ -21,7 +24,7 @@ describe Validators::ValidationHelper do
 
     it 'should return an error' do
       invalid_inputs.each do |input|
-        expect{Validators::ValidationHelper.parse_color(input)}.to raise_error(ParsingError)
+        expect{subject.parse_color(input)}.to raise_error(ParsingError)
       end
     end
   end

data/spec/validators/validate_segment_input_spec.rb

@@ -3,6 +3,9 @@ require 'spec_helper'
 require 'bitmapped/exceptions'
 
 describe Validators::ValidateSegmentInput do
+
+  subject { Validators::ValidateSegmentInput }
+
   context 'given valid input' do
 
     let(:valid_inputs) { [["2", "2", "2", "C"], ["2", "3", "3", "X"], ["10", "99", "1000", "Y"]] }
@@ -10,7 +13,7 @@ describe Validators::ValidateSegmentInput do
 
     it 'should return an array of parsed values' do
       valid_inputs.each_with_index do |input, index|
-        expect(Validators::ValidateSegmentInput.parse_and_validate(input)).to eq(outputs[index])
+        expect(subject.parse_and_validate(input)).to eq(outputs[index])
       end
     end
   end
@@ -21,7 +24,7 @@ describe Validators::ValidateSegmentInput do
 
     it 'should return an error' do
       invalid_inputs.each do |input|
-        expect{Validators::ValidateSegmentInput.parse_and_validate(input)}.to raise_error(ParsingError)
+        expect{subject.parse_and_validate(input)}.to raise_error(ParsingError)
       end
     end
   end

metadata

@@ -1,15 +1,85 @@
 --- !ruby/object:Gem::Specification
 name: bitmapped
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Ashley Connor
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-02-26 00:00:00.000000000 Z
+date: 2015-02-27 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.4'
+- !ruby/object:Gem::Dependency
+  name: rubygems-tasks
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
 - !ruby/object:Gem::Dependency
   name: terminal-table
   requirement: !ruby/object:Gem::Requirement
@@ -51,16 +121,35 @@ files:
 - lib/bitmapped.rb
 - lib/bitmapped/bitmap.rb
 - lib/bitmapped/cli.rb
+- lib/bitmapped/commands/base_command.rb
+- lib/bitmapped/commands/clear_command.rb
+- lib/bitmapped/commands/commands_helper.rb
+- lib/bitmapped/commands/exit_command.rb
+- lib/bitmapped/commands/fill_command.rb
+- lib/bitmapped/commands/horizontal_line_command.rb
+- lib/bitmapped/commands/initialiser_command.rb
+- lib/bitmapped/commands/invert_command.rb
+- lib/bitmapped/commands/mirror_command.rb
+- lib/bitmapped/commands/pixel_fill_command.rb
+- lib/bitmapped/commands/print_fancy_table_command.rb
+- lib/bitmapped/commands/print_table_command.rb
+- lib/bitmapped/commands/rotate_command.rb
+- lib/bitmapped/commands/vertical_line_command.rb
 - lib/bitmapped/exceptions.rb
+- lib/bitmapped/validators/validate_bitmap_initialised.rb
 - lib/bitmapped/validators/validate_column_row_input.rb
+- lib/bitmapped/validators/validate_coordinates.rb
 - lib/bitmapped/validators/validate_fill_input.rb
 - lib/bitmapped/validators/validate_segment_input.rb
+- lib/bitmapped/validators/validated_bitmap_size.rb
 - lib/bitmapped/validators/validation_helper.rb
 - lib/bitmapped/version.rb
 - spec/bitmap_spec.rb
 - spec/bitmapped_spec.rb
+- spec/command/base_command_spec.rb
 - spec/exceptions_spec.rb
 - spec/spec_helper.rb
+- spec/validators/validate_bitmap_initialised_spec.rb
 - spec/validators/validate_column_row_input_spec.rb
 - spec/validators/validate_fill_input_spec.rb
 - spec/validators/validate_helper_spec.rb
@@ -92,8 +181,10 @@ summary: Bitmap CLI program
 test_files:
 - spec/bitmap_spec.rb
 - spec/bitmapped_spec.rb
+- spec/command/base_command_spec.rb
 - spec/exceptions_spec.rb
 - spec/spec_helper.rb
+- spec/validators/validate_bitmap_initialised_spec.rb
 - spec/validators/validate_column_row_input_spec.rb
 - spec/validators/validate_fill_input_spec.rb
 - spec/validators/validate_helper_spec.rb