bitmapped 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 99702c03528a066944f878c4b91150111a57109c
+  data.tar.gz: bb7495610f144df0ed5ebbbf4073846add4a7984
+SHA512:
+  metadata.gz: 310a13fb27eb9a4124623c7088e2de83bf4e323fe414e2721c35bff6ddaa6e9067e95bb48296b6562410816eca7ad31455ab5ece03416b9a58262bad8ae604c1
+  data.tar.gz: 84f16acd5af696546e80aba724afa45d966dc0e1f7aed02643cf158c94b54d63b20acbfb21f98605fa868dc208eb6728b4d1283f86bca1ec9d16d853461daf42

data/.document

@@ -0,0 +1,4 @@
+lib/**/*.rb
+README.rdoc
+ChangeLog.rdoc
+LICENSE.txt

data/.gitignore

@@ -0,0 +1,5 @@
+Gemfile.lock
+html/
+pkg/
+vendor/cache/*.gem
+coverage/

data/.rspec

@@ -0,0 +1 @@
+--colour --format documentation

data/.travis.yml

@@ -0,0 +1,3 @@
+language: ruby
+rvm:
+  - 2.0.0-p247

data/ChangeLog.rdoc

@@ -0,0 +1,4 @@
+=== 0.1.0 / 2015-02-23
+
+* Initial release:
+

data/Gemfile

@@ -0,0 +1,10 @@
+source "https://rubygems.org"
+
+gemspec
+
+group :test do
+  gem 'rake'
+  gem 'rspec'
+  gem 'pry-byebug'
+  gem 'simplecov'
+end

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2015 Ashley Connor
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,65 @@
+# bitmapped
+
+[![Code Climate](https://codeclimate.com/github/ashleyconnor/bitmapped/badges/gpa.svg)](https://codeclimate.com/github/ashleyconnor/bitmapped) [![Build Status](https://travis-ci.org/ashleyconnor/bitmapped.svg)](https://travis-ci.org/ashleyconnor/bitmapped)
+
+## Description
+
+Bitmapped is an command-line editor which allows you to create and edit bitmap-like text images.
+
+## Features
+
+Bitmapped accepts various commands to create and edit bitmap-like text images:
+
+| Command             | Description                                                | Key | Parameters                             |
+|---------------------|------------------------------------------------------------|-----|----------------------------------------|
+| Initiate Bitmap     | Initiates a Bitmap of the given size                       | I   | Columns:Int, Rows:Int                  |
+| Clear               | Clears the Bitmap setting all cells to "0"                 | C   |                                        |
+| Color Cell          | Colors the cell at the given co-ordinates                  | L   | Column:Int, Row:Int, Color:String      |
+| 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      |
+| Exit                | Exits the program                                          | X   |                                        |
+
+
+## Examples
+    bundle exec bitmapped
+    > 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 |
+    +---+---+---+---+---+
+    > 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 |
+    +---+---+---+---+---+
+
+## Requirements
+    Ruby 2.0+
+## Install
+
+    $ gem install bitmapped
+
+## TODO
+
+* Custom commands
+* Refactor Bitmap commands into objects with tests
+
+### Copyright
+
+Copyright (c) 2015 **Ashley Connor**
+
+See LICENSE.txt for details.

data/Rakefile

@@ -0,0 +1,42 @@
+# encoding: utf-8
+
+require 'rubygems'
+
+begin
+  require 'bundler'
+rescue LoadError => e
+  warn e.message
+  warn "Run `gem install bundler` to install Bundler."
+  exit -1
+end
+
+begin
+  Bundler.setup(:development)
+rescue Bundler::BundlerError => e
+  warn e.message
+  warn "Run `bundle install` to install missing gems."
+  exit e.status_code
+end
+
+require 'rake'
+
+require 'rubygems/tasks'
+Gem::Tasks.new
+
+require 'rdoc/task'
+RDoc::Task.new do |rdoc|
+  rdoc.title = "bitmapped"
+end
+task :doc => :rdoc
+
+begin
+  require 'rspec/core/rake_task'
+  RSpec::Core::RakeTask.new
+rescue LoadError
+  task :spec do
+    abort "Please run `gem install rspec` to install RSpec."
+  end
+end
+
+task :test    => :spec
+task :default => :spec

data/bin/bitmapped

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+
+begin
+  require 'bitmapped/cli'
+rescue LoadError => e
+  abort 'Could not load "bitmapped/cli"'
+end
+
+Bitmapped::Cli.start

data/bitmapped.gemspec

@@ -0,0 +1,23 @@
+# encoding: utf-8
+
+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.summary       = %q{Bitmap CLI program}
+  gem.description   = %q{Bitmap CLI program}
+  gem.license       = "MIT"
+  gem.authors       = ["Ashley Connor"]
+  gem.email         = "ashconnor@me.com"
+  gem.homepage      = "https://rubygems.org/gems/bitmapped"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ['lib']
+
+  gem.required_ruby_version = ">= 2.0.0"
+  gem.add_runtime_dependency 'terminal-table', '~> 1.4', '>= 1.4.5'
+end

data/lib/bitmapped/bitmap.rb

@@ -0,0 +1,122 @@
+Dir[File.join(File.dirname(__FILE__), 'validators', '*.rb')].each {|file| require file }
+
+require 'terminal-table'
+require 'bitmapped/exceptions'
+
+module Bitmapped
+  class Bitmap
+
+    attr_accessor :pixels, :table, :rows, :columns
+
+    def command(input)
+      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"
+        else
+          "Invalid Command"
+        end
+      rescue ParsingError => e
+        "Invalid parameters"
+      rescue InvalidCoordinatesError => e
+        "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

@@ -0,0 +1,28 @@
+require 'bitmapped/bitmap'
+
+require 'readline'
+
+module Bitmapped
+  class Cli
+    class << self
+      def start
+        begin
+          bitmap = Bitmap.new
+          puts "Bitmapped Command Centre (Ctrl+C to exit):"
+
+          loop do
+            input = split_input(Readline.readline("> "))
+            puts bitmap.command(input)
+          end
+        rescue Interrupt => interrupt
+          puts "\nExiting..."
+          exit
+        end
+      end
+
+      def split_input(input)
+        input.strip.split(' ')
+      end
+    end
+  end
+end

data/lib/bitmapped/exceptions.rb

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

data/lib/bitmapped/validators/validate_column_row_input.rb

@@ -0,0 +1,21 @@
+require 'bitmapped/exceptions'
+
+module Bitmapped
+  module Validators
+    class ValidateColumnRowInput
+      class << self
+        def parse_and_validate(input)
+          begin
+            raise ArgumentError unless input.size == 2
+
+            columns = Integer(input[0])
+            rows = Integer(input[1])
+            [columns, rows]
+          rescue ArgumentError => ae
+            raise ParsingError
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bitmapped/validators/validate_fill_input.rb

@@ -0,0 +1,24 @@
+require 'bitmapped/exceptions'
+require 'bitmapped/validators/validation_helper'
+
+module Bitmapped
+  module Validators
+    class ValidateFillInput
+
+      class << self
+        def parse_and_validate(input)
+          begin
+            raise ArgumentError unless input.size == 3
+
+            columns = Integer(input[0])
+            rows = Integer(input[1])
+            color = ValidationHelper.parse_color(input[2].strip)
+            [columns, rows, color]
+          rescue ArgumentError => ae
+            raise ParsingError
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bitmapped/validators/validate_segment_input.rb

@@ -0,0 +1,24 @@
+require 'bitmapped/exceptions'
+require 'bitmapped/validators/validation_helper'
+
+module Bitmapped
+  module Validators
+    class ValidateSegmentInput
+      class << self
+        def parse_and_validate(input)
+          begin
+            raise ArgumentError unless input.size == 4
+
+            segement_a = Integer(input[0])
+            segement_b = Integer(input[1])
+            segement_c = Integer(input[2])
+            color = ValidationHelper.parse_color(input[3].strip)
+            [segement_a, segement_b, segement_c, color]
+          rescue ArgumentError => ae
+            raise ParsingError
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bitmapped/validators/validation_helper.rb

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

data/lib/bitmapped/version.rb

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

data/lib/bitmapped.rb

@@ -0,0 +1 @@
+require 'bitmapped/version'

data/spec/bitmap_spec.rb

@@ -0,0 +1,210 @@
+require 'spec_helper'
+
+require 'bitmapped/bitmap'
+
+describe Bitmap do
+
+  subject { Bitmap.new }
+
+  shared_examples_for "a command requiring an initialised bitmap" do |arg|
+    it "returns an error message" do
+      expect(subject.command([arg])).to eq("Bitmap has not been initialised, run command 'I' with valid arguments")
+    end
+  end
+
+  describe 'the I command' do
+    it 'initializes a grid of that size' do
+      args = ["I", "2", "3"]
+      pixels = [["0", "0"],
+                ["0", "0"],
+                ["0", "0"]]
+
+      subject.command(args)
+
+      expect(subject.columns).to eq(2)
+      expect(subject.rows).to eq(3)
+      expect(subject.pixels).to eq(pixels)
+    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"]]
+
+      subject.command(first_args)
+      subject.command(second_args)
+
+      expect(subject.columns).to eq(3)
+      expect(subject.rows).to eq(2)
+      expect(subject.pixels).to eq(pixels)
+    end
+  end
+
+  describe 'the X command' do
+    it 'raises an Interrupt exception' do
+      expect{ subject.command(["X"]) } .to raise_error(Interrupt)
+    end
+  end
+
+  describe 'the C command' do
+    it_should_behave_like "a command requiring an initialised bitmap", "C"
+
+    context 'when the bitmap is initialised' do
+      it 'replaces all of the bitmap colors with "0"' do
+        setup_pixels(subject, 3, 2, "X")
+        subject.command(["C"])
+
+        expect(subject.pixels).to eq([["0", "0", "0"],
+                                      ["0", "0", "0"]])
+      end
+    end
+  end
+
+  describe 'the L command' do
+    it_should_behave_like "a command requiring an initialised bitmap", "L"
+
+    context 'when the bitmap is initialised' do
+      before(:example) do
+        setup_pixels(subject, 3, 2)
+      end
+
+      it 'replaces the color at those coordinates' do
+        subject.command(["L", "1", "2", "Z"])
+        subject.command(["L", "2", "1", "Z"])
+
+        expect(subject.pixels).to eq([["0", "Z", "0"],
+                                      ["Z", "0", "0"]])
+      end
+
+      it 'returns an error when the coordinates are not valid' do
+        expect(subject.command(["L", "4", "4", "Z"])).to eq("Invalid co-ordinates")
+      end
+    end
+  end
+
+  describe 'the V command' do
+    it_should_behave_like "a command requiring an initialised bitmap", "V"
+
+    context 'when the bitmap is initialised' do
+      before(:example) do
+        setup_pixels(subject, 4, 4)
+      end
+
+      it 'should draw a vertical color segment between the 2 rows' 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"]]
+          )
+      end
+
+      it 'returns an error when the coordinates are invalid' do
+        [["V", "10", "1", "3", "Z"], ["V", "1", "10", "3", "Z"], ["V", "1", "1", "10", "Z"]].each do |args|
+          expect(subject.command(args)).to eq("Invalid co-ordinates")
+        end
+      end
+
+      it 'returns an error when the parameters are invalid' do
+        [["V", "10", "3", "Z"], ["V", "Z", "10", "3", "3"], ["V", "1", "1", "10", "1"]].each do |args|
+          expect(subject.command(args)).to eq("Invalid parameters")
+        end
+      end
+    end
+  end
+
+  describe 'the H command' do
+    it_should_behave_like "a command requiring an initialised bitmap", "H"
+
+    context 'when the bitmap is initialised' do
+      before(:example) do
+        setup_pixels(subject, 4, 4)
+      end
+
+      it 'should draw a horizontal color segment between the 2 columns' 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"],
+                                      ["Z","Z","Z","Z"]]
+          )
+      end
+
+      it 'returns an error when the coordinates are invalid' do
+        [["H", "10", "1", "3", "Z"], ["H", "1", "10", "3", "Z"], ["H", "1", "1", "10", "Z"]].each do |args|
+          expect(subject.command(args)).to eq("Invalid co-ordinates")
+        end
+      end
+
+      it 'returns an error when the parameters are invalid' do
+        [["H", "10", "3", "Z"], ["H", "Z", "10", "3", "3"], ["H", "1", "1", "10", "1", "Z"]].each do |args|
+          expect(subject.command(args)).to eq("Invalid parameters")
+        end
+      end
+    end
+  end
+
+  describe 'the F command' do
+    it_should_behave_like "a command requiring an initialised bitmap", "F"
+
+    context 'when the bitmap is initialised' do
+
+      before(:example) do
+        setup_pixels(subject, 4, 4)
+      end
+
+      it 'should fill region on the bitmap with the color given' do
+        subject.command(["F", "3", "3", "J"])
+        expect(subject.pixels).to eq([["J","J","J","J"],
+                                      ["J","J","J","J"],
+                                      ["J","J","J","J"],
+                                      ["J","J","J","J"]])
+      end
+    end
+  end
+
+  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) { %{+---+---+---+---+
+                                | 0 | 0 | 0 | 0 |
+                                | 0 | 0 | 0 | 0 |
+                                | 0 | 0 | 0 | 0 |
+                                | 0 | 0 | 0 | 0 |
+                                +---+---+---+---+}.gsub(/[^\S\n]{2,}/, '')}
+
+      let(:filled_formatted_table) {%{+---+---+---+---+
+                                      | J | J | J | J |
+                                      | J | J | J | J |
+                                      | J | J | J | J |
+                                      | J | J | J | J |
+                                      +---+---+---+---+}.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
+
+  def setup_pixels(subject, columns, rows, color="0")
+    subject.columns = columns
+    subject.rows = rows
+    subject.pixels = Array.new(rows) { Array.new(columns) { color } }
+  end
+end

data/spec/bitmapped_spec.rb

@@ -0,0 +1,8 @@
+require 'spec_helper'
+require 'bitmapped'
+
+describe Bitmapped do
+  it "should have a VERSION constant" do
+    expect(subject.const_get('VERSION')).not_to be_empty
+  end
+end

data/spec/exceptions_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+require 'bitmapped/exceptions'
+
+describe ParsingError do
+  subject { ParsingError }
+
+  it 'inherits from StandardError' do
+    expect(subject.superclass).to eq(StandardError)
+  end
+end
+
+describe InvalidCoordinatesError do
+  subject { InvalidCoordinatesError }
+
+  it 'inherits from StandardError' do
+    expect(subject.superclass).to eq(StandardError)
+  end
+end
+

data/spec/spec_helper.rb

@@ -0,0 +1,7 @@
+require 'rspec'
+require 'bitmapped/version'
+# require 'simplecov'
+
+include Bitmapped
+
+# SimpleCov.start

data/spec/validators/validate_column_row_input_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+require 'bitmapped/exceptions'
+
+describe Validators::ValidateColumnRowInput do
+  context 'given valid input' do
+
+    let(:valid_inputs) { [["2", "2"], ["2", "3"], ["10", "99"]] }
+    let(:outputs) { [[2, 2], [2, 3], [10, 99]] }
+
+    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])
+      end
+    end
+  end
+
+  context 'given invalid input' do
+
+    let(:invalid_inputs) { [["A", "2"], ["2", "Z"], ["99"]] }
+
+    it 'should return an 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_fill_input_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+require 'bitmapped/exceptions'
+
+describe Validators::ValidateFillInput do
+  context 'given valid input' do
+
+    let(:valid_inputs) { [["2", "2", "C"], ["2", "3", "X"], ["10", "99", "Y"]] }
+    let(:outputs) { [[2, 2, "C"], [2, 3, "X"], [10, 99, "Y"]] }
+
+    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])
+      end
+    end
+  end
+
+  context 'given invalid input' do
+
+    let(:invalid_inputs) { [["A", "2", "2"], ["2", "Z", "A"], ["99", "Z"]] }
+
+    it 'should return an error' do
+      invalid_inputs.each do |input|
+        expect{Validators::ValidateFillInput.parse_and_validate(input)}.to raise_error(ParsingError)
+      end
+    end
+  end
+end

data/spec/validators/validate_helper_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+require 'bitmapped/exceptions'
+
+describe Validators::ValidationHelper do
+  context 'given valid input' do
+
+    let(:valid_inputs) { ["         A", "B", "C       "] }
+    let(:outputs) { ["A", "B", "C"] }
+
+    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])
+      end
+    end
+  end
+
+  context 'given invalid input' do
+
+    let(:invalid_inputs) { ["2", "!", "a"] }
+
+    it 'should return an error' do
+      invalid_inputs.each do |input|
+        expect{Validators::ValidationHelper.parse_color(input)}.to raise_error(ParsingError)
+      end
+    end
+  end
+end

data/spec/validators/validate_segment_input_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+require 'bitmapped/exceptions'
+
+describe Validators::ValidateSegmentInput do
+  context 'given valid input' do
+
+    let(:valid_inputs) { [["2", "2", "2", "C"], ["2", "3", "3", "X"], ["10", "99", "1000", "Y"]] }
+    let(:outputs) { [[2, 2, 2, "C"], [2, 3, 3, "X"], [10, 99, 1000, "Y"]] }
+
+    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])
+      end
+    end
+  end
+
+  context 'given invalid input' do
+
+    let(:invalid_inputs) { [["A", "2", "2", "2"], ["2", "2", "2", "2"], ["99", "50","Z"]] }
+
+    it 'should return an error' do
+      invalid_inputs.each do |input|
+        expect{Validators::ValidateSegmentInput.parse_and_validate(input)}.to raise_error(ParsingError)
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,100 @@
+--- !ruby/object:Gem::Specification
+name: bitmapped
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Ashley Connor
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-02-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: terminal-table
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.4.5
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.4.5
+description: Bitmap CLI program
+email: ashconnor@me.com
+executables:
+- bitmapped
+extensions: []
+extra_rdoc_files: []
+files:
+- ".document"
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- ChangeLog.rdoc
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/bitmapped
+- bitmapped.gemspec
+- lib/bitmapped.rb
+- lib/bitmapped/bitmap.rb
+- lib/bitmapped/cli.rb
+- lib/bitmapped/exceptions.rb
+- lib/bitmapped/validators/validate_column_row_input.rb
+- lib/bitmapped/validators/validate_fill_input.rb
+- lib/bitmapped/validators/validate_segment_input.rb
+- lib/bitmapped/validators/validation_helper.rb
+- lib/bitmapped/version.rb
+- spec/bitmap_spec.rb
+- spec/bitmapped_spec.rb
+- spec/exceptions_spec.rb
+- spec/spec_helper.rb
+- spec/validators/validate_column_row_input_spec.rb
+- spec/validators/validate_fill_input_spec.rb
+- spec/validators/validate_helper_spec.rb
+- spec/validators/validate_segment_input_spec.rb
+homepage: https://rubygems.org/gems/bitmapped
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Bitmap CLI program
+test_files:
+- spec/bitmap_spec.rb
+- spec/bitmapped_spec.rb
+- spec/exceptions_spec.rb
+- spec/spec_helper.rb
+- spec/validators/validate_column_row_input_spec.rb
+- spec/validators/validate_fill_input_spec.rb
+- spec/validators/validate_helper_spec.rb
+- spec/validators/validate_segment_input_spec.rb