mdspell 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 557ab534f964bbd18e0453ddcbe9561698441d5b
+  data.tar.gz: bb03a5b7f5a40b1e1fe689d383abd1a35a4ccaa8
+SHA512:
+  metadata.gz: 21066ee2957e17175a5c353dacd2d9aea1a0a7067ef83813fad211c4548705027867509cfed1a4195893840013e2e92986b9ab8a34ffe6f22c66c81bc3562299
+  data.tar.gz: c96d072fc81fb88d458807e34953dcae4c01f96d3ec997f8269e527025ee5f1b6b4f4216ce1a9ffc50875b25efdf26b97478e5510833b888cde9ddf0777ecb1f

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2015 Marek Tuchowski
+
+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,44 @@
+# MdSpell
+
+[![Build Status](https://travis-ci.org/mtuchowski/mdspell.svg)](
+https://travis-ci.org/mtuchowski/mdspell)
+[![Code Climate](https://codeclimate.com/github/mtuchowski/mdspell/badges/gpa.svg)](
+https://codeclimate.com/github/mtuchowski/mdspell)
+[![Test Coverage](https://codeclimate.com/github/mtuchowski/mdspell/badges/coverage.svg)](
+https://codeclimate.com/github/mtuchowski/mdspell/coverage)
+
+A Ruby markdown spell checking tool.
+
+## Installation
+
+To install from [rubygems.org](http://rubygems.org/), run:
+
+```console
+gem install mdspell
+```
+
+## Usage
+
+To spell-check markdown files, simply run `mdspell` with the filenames as a parameter:
+
+```console
+mdspell README.md
+```
+
+To check all markdown files within the directory:
+
+```console
+mdspell docs/
+```
+
+For each spelling error found, MdSpell will display the misspelled word, filename and line number:
+
+```console
+Spell-checking ./README.md...
+./README.md:10: actualy
+```
+
+## MIT Licensed
+
+See [LICENSE](https://github.com/mtuchowski/mdspell/blob/master/LICENSE) file for full license
+text.

data/bin/mdspell

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+begin
+  require 'mdspell'
+rescue LoadError
+  # For running in development without bundler
+  $LOAD_PATH << File.expand_path('../lib', File.dirname(__FILE__))
+  require 'mdspell'
+end
+
+MdSpell.run

data/lib/mdspell.rb

@@ -0,0 +1,37 @@
+require_relative 'mdspell/cli'
+require_relative 'mdspell/configuration'
+require_relative 'mdspell/spell_checker'
+require_relative 'mdspell/text_line'
+require_relative 'mdspell/typo'
+require_relative 'mdspell/version'
+
+require 'rainbow'
+
+# This module holds all the MdSpell code (except mdspell shell command).
+module MdSpell
+  def self.run
+    cli = MdSpell::CLI.new
+    cli.run
+
+    # Spell-check each file.
+    cli.files.each do |filename|
+      verbose "Spell-checking #{filename}..."
+
+      SpellChecker.new(filename).typos.each do |typo|
+        error "#{filename}:#{typo.line.location}: #{typo.word}"
+      end
+    end
+  end
+
+  # Private class methods
+
+  def self.verbose(str)
+    puts str if Configuration[:verbose]
+  end
+  private_class_method :verbose
+
+  def self.error(str)
+    puts Rainbow(str).red
+  end
+  private_class_method :error
+end

data/lib/mdspell/cli.rb

@@ -0,0 +1,58 @@
+require 'mixlib/cli'
+
+module MdSpell
+  # Class responsible for parsing all of command line arguments.
+  class CLI
+    include Mixlib::CLI
+
+    banner "Usage: #{File.basename($PROGRAM_NAME)} [options] [FILE.md|DIR ...]"
+
+    option :config_file,
+           short: '-c',
+           long: '--config FILE',
+           description: 'The configuration file to use',
+           default: '~/.mdspell'
+
+    option :language,
+           short: '-l',
+           long: '--language LANG',
+           description: 'Set documents language',
+           default: 'en_US'
+
+    option :verbose,
+           short: '-v',
+           long: '--[no-]verbose',
+           description: 'Be more/less verbose',
+           boolean: true
+
+    option :version,
+           on: :tail,
+           short: '-V',
+           long: '--version',
+           description: 'Show version',
+           boolean: true,
+           proc: proc { puts MdSpell::VERSION },
+           exit: 0
+
+    def run(argv = ARGV)
+      parse_options(argv)
+
+      # Load optional config file if it's present.
+      config_filename = File.expand_path(config[:config_file])
+      MdSpell::Configuration.from_file(config_filename) if File.exist?(config_filename)
+
+      # Store command line configuration options.
+      MdSpell::Configuration.merge!(config)
+    end
+
+    # List of markdown files from argument list.
+    def files
+      cli_arguments.each_with_index do |filename, index|
+        if Dir.exist?(filename)
+          cli_arguments[index] = Dir["#{filename}/**/*.md"]
+        end
+      end
+      cli_arguments.flatten!
+    end
+  end
+end

data/lib/mdspell/configuration.rb

@@ -0,0 +1,8 @@
+require 'mixlib/config'
+
+module MdSpell
+  # Stores configuration from both command line and config file.
+  class Configuration
+    extend Mixlib::Config
+  end
+end

data/lib/mdspell/spell_checker.rb

@@ -0,0 +1,39 @@
+require_relative 'configuration'
+
+require 'kramdown'
+require 'ffi/aspell'
+
+module MdSpell
+  # A class for finding spelling errors in document.
+  class SpellChecker
+    # Name of the file this object was created from.
+    attr_reader :filename
+
+    # A Kramdown::Document object containing the parsed markdown document.
+    attr_reader :document
+
+    # Create a new instance from specified file.
+    # @param filename [String] a name of file to load.
+    def initialize(filename)
+      @filename = filename
+      @document = Kramdown::Document.new(File.read(filename), input: 'GFM')
+    end
+
+    # Returns found spelling errors.
+    def typos
+      results = []
+
+      FFI::Aspell::Speller.open(Configuration[:language]) do |speller|
+        TextLine.scan(document).each do |line|
+          line.words.each do |word|
+            unless speller.correct? word
+              results << Typo.new(line, word, speller.suggestions(word))
+            end
+          end
+        end
+      end
+
+      results
+    end
+  end
+end

data/lib/mdspell/text_line.rb

@@ -0,0 +1,113 @@
+require 'kramdown'
+
+module MdSpell
+  # Containing concatenated text from single document line.
+  class TextLine
+    # Accepted types of elements.
+    ELEMENT_TYPES = [:text, :smart_quote]
+
+    # Line number of the element in document.
+    attr_reader :location
+
+    # Textual content of the element.
+    attr_reader :content
+
+    # Create a new TextLine from Kramdown::Element object.
+    # @param element [Kramdown::Element]
+    def initialize(element)
+      TextLine.assert_element_type element
+
+      @content = ''
+      @location = element.options[:location]
+      self << element
+    end
+
+    # Return all words in this element.
+    def words
+      @content.scan(/[\w\']+/)
+    end
+
+    # Append Kramdown::Element's content to this element.
+    # @param element [Kramdown::Element]
+    # @raise ArgumentError if element is in different location.
+    def <<(element)
+      TextLine.assert_element_type element
+
+      return self unless ELEMENT_TYPES.include? element.type
+      return self unless element.options[:location] == @location
+
+      value = element.value
+
+      if element.type == :smart_quote
+        appent_quote(value)
+      else
+        append_text(value)
+      end
+
+      self
+    end
+
+    # Scan Kramdown::Document for TextLines.
+    # @param document [Kramdown::Document]
+    def self.scan(document)
+      results = []
+
+      get_all_textual_elements(document.root.children).each do |element|
+        matching_element_found = results.any? do |text_element|
+          if text_element.location == element.options[:location]
+            text_element << element
+            true
+          else
+            false
+          end
+        end
+
+        results << TextLine.new(element) unless matching_element_found
+      end
+
+      results
+    end
+
+    private
+
+    def append_text(value)
+      return if value.nil? || value.empty?
+
+      value = value.strip
+      if @content.empty? || @content[-1] == "'"
+        @content += value
+      else
+        @content += ' ' + value
+      end
+    end
+
+    def appent_quote(type)
+      case type
+      when :lsquo, :rsquo
+        @content += "'"
+      when :ldquo, :rdquo
+        @content += '"'
+      end
+    end
+
+    # Private class methods
+
+    def self.assert_element_type(elem)
+      fail ArgumentError, 'expected Kramdown::Element' unless elem.instance_of? Kramdown::Element
+    end
+
+    def self.get_all_textual_elements(elements)
+      result = []
+
+      elements.each do |element|
+        if ELEMENT_TYPES.include? element.type
+          result << element
+        else
+          result |= get_all_textual_elements(element.children)
+        end
+      end
+
+      result
+    end
+  end
+end

data/lib/mdspell/typo.rb

@@ -0,0 +1,44 @@
+module MdSpell
+  # A wrapper class for single, misspelled word.
+  class Typo
+    # A TextLine that contains this error.
+    attr_reader :line
+
+    # A misspelled word.
+    attr_reader :word
+
+    # A list of suggestions for this error.
+    attr_reader :suggestions
+
+    # Create a new SpellingError.
+    # @param line [TextLine] the TextLine that contains the error.
+    # @param word [String] the misspelled word.
+    # @param suggestions [Array] an array of suggestions for the word.
+    def initialize(line, word, suggestions)
+      assert_proper_line_type(line)
+      assert_proper_word_type(word)
+      assert_proper_suggestions_type(suggestions)
+
+      @line = line
+      @word = word
+      @suggestions = suggestions
+    end
+
+    private
+
+    def assert_proper_line_type(line)
+      fail ArgumentError, "expected TextLine, got #{line.class.inspect}" unless
+        line.class == TextLine
+    end
+
+    def assert_proper_word_type(word)
+      fail ArgumentError, "expected String, got #{word.class.inspect}" unless
+        word.class == String
+    end
+
+    def assert_proper_suggestions_type(suggestions)
+      fail ArgumentError, "expected Array, got #{suggestions.class.inspect}" unless
+        suggestions.class == Array
+    end
+  end
+end

data/lib/mdspell/version.rb

@@ -0,0 +1,3 @@
+module MdSpell
+  VERSION = '0.1.0'
+end

data/spec/examples.cache

@@ -0,0 +1,39 @@
+example_id                                    | status  | run_time        |
+--------------------------------------------- | ------- | --------------- |
+./spec/mdspell/spell_checker_spec.rb[1:1:1]   | passed  | 0.00141 seconds |
+./spec/mdspell/spell_checker_spec.rb[1:1:2]   | passed  | 0.00088 seconds |
+./spec/mdspell/spell_checker_spec.rb[1:1:3]   | passed  | 0.00055 seconds |
+./spec/mdspell/spell_checker_spec.rb[1:2:1]   | passed  | 0.00014 seconds |
+./spec/mdspell/spell_checker_spec.rb[1:2:2]   | passed  | 0.00048 seconds |
+./spec/mdspell/spell_checker_spec.rb[1:2:3]   | failed  | 0.01636 seconds |
+./spec/mdspell/spell_checker_spec.rb[1:3:1]   | passed  | 0.03322 seconds |
+./spec/mdspell/spell_checker_spec.rb[1:3:2:1] | failed  | 0.00015 seconds |
+./spec/mdspell/spell_checker_spec.rb[1:4:1]   | passed  | 0.00181 seconds |
+./spec/mdspell/spell_checker_spec.rb[1:5:1]   | failed  | 0.00789 seconds |
+./spec/mdspell/spell_checker_spec.rb[1:5:2]   | passed  | 0.00703 seconds |
+./spec/mdspell/spell_checker_spec.rb[1:5:3]   | pending | 0.00001 seconds |
+./spec/mdspell/text_line_spec.rb[1:1:1]       | passed  | 0.00007 seconds |
+./spec/mdspell/text_line_spec.rb[1:1:2]       | passed  | 0.00008 seconds |
+./spec/mdspell/text_line_spec.rb[1:1:3]       | passed  | 0.00008 seconds |
+./spec/mdspell/text_line_spec.rb[1:1:4]       | passed  | 0.00009 seconds |
+./spec/mdspell/text_line_spec.rb[1:2:1]       | passed  | 0.0004 seconds  |
+./spec/mdspell/text_line_spec.rb[1:3:1]       | passed  | 0.00008 seconds |
+./spec/mdspell/text_line_spec.rb[1:4:1]       | passed  | 0.00009 seconds |
+./spec/mdspell/text_line_spec.rb[1:5:1]       | passed  | 0.0001 seconds  |
+./spec/mdspell/text_line_spec.rb[1:6:1]       | passed  | 0.00014 seconds |
+./spec/mdspell/text_line_spec.rb[1:6:2:1]     | passed  | 0.00008 seconds |
+./spec/mdspell/text_line_spec.rb[1:6:3:1]     | passed  | 0.00011 seconds |
+./spec/mdspell/text_line_spec.rb[1:6:3:2]     | passed  | 0.0001 seconds  |
+./spec/mdspell/text_line_spec.rb[1:6:4:1]     | passed  | 0.00009 seconds |
+./spec/mdspell/text_line_spec.rb[1:7:1]       | passed  | 0.00012 seconds |
+./spec/mdspell/text_line_spec.rb[1:7:2]       | passed  | 0.00086 seconds |
+./spec/mdspell/typo_spec.rb[1:1:1]            | passed  | 0.00011 seconds |
+./spec/mdspell/typo_spec.rb[1:1:2]            | passed  | 0.0001 seconds  |
+./spec/mdspell/typo_spec.rb[1:1:3]            | passed  | 0.00008 seconds |
+./spec/mdspell/typo_spec.rb[1:2:1]            | passed  | 0.00012 seconds |
+./spec/mdspell/typo_spec.rb[1:2:2]            | passed  | 0.00016 seconds |
+./spec/mdspell/typo_spec.rb[1:2:3]            | passed  | 0.00014 seconds |
+./spec/mdspell/typo_spec.rb[1:3:1]            | passed  | 0.00044 seconds |
+./spec/mdspell/typo_spec.rb[1:4:1]            | passed  | 0.00007 seconds |
+./spec/mdspell/typo_spec.rb[1:5:1]            | passed  | 0.00008 seconds |
+./spec/mdspell/typo_spec.rb[1:5:2]            | passed  | 0.0001 seconds  |

data/spec/examples/simple.md

@@ -0,0 +1,5 @@
+# Simple
+
+markdown
+
+*file*

data/spec/examples/with_errors.md

@@ -0,0 +1,5 @@
+# This file has mispelled words
+
+And qiute few of them actualy.
+
+Four tobe precise.

data/spec/mdspell/spell_checker_spec.rb

@@ -0,0 +1,70 @@
+describe MdSpell::SpellChecker do
+  let(:simple) { MdSpell::SpellChecker.new('spec/examples/simple.md') }
+  let(:with_errors) { MdSpell::SpellChecker.new('spec/examples/with_errors.md') }
+  let(:from_stdin) do
+    allow(STDIN).to receive(:read) { '# Header' }
+    MdSpell::SpellChecker.new('-')
+  end
+
+  context 'attributes' do
+    subject { simple }
+
+    it { is_expected.to respond_to :filename }
+    it { is_expected.to respond_to :document }
+    it { is_expected.to respond_to :typos }
+  end
+
+  context '#initialize' do
+    it 'should expect filename' do
+      expect {  MdSpell::SpellChecker.new }.to raise_error ArgumentError
+    end
+
+    it 'should fail if given wrong filename' do
+      expect { MdSpell::SpellChecker.new('not_existing.md') }.to raise_error Errno::ENOENT
+    end
+
+    it "should read from stdin if given '-' as filename" do
+      allow(STDIN).to receive(:read) { '# Header' }
+      expect { MdSpell::SpellChecker.new('-') }.not_to raise_error
+    end
+  end
+
+  context '#filename' do
+    it 'should return proper path' do
+      expect(simple.filename).to eq 'spec/examples/simple.md'
+      expect(with_errors.filename).to eq 'spec/examples/with_errors.md'
+    end
+
+    context 'if initialized from stdin' do
+      it "should return 'stdin'" do
+        expect(stdin_md.filename).to eq 'stdin'
+      end
+    end
+  end
+
+  context '#document' do
+    it 'should be of proper type' do
+      expect(simple.document).to be_instance_of Kramdown::Document
+      expect(with_errors.document).to be_instance_of Kramdown::Document
+    end
+  end
+
+  context '#typos' do
+    it 'should return empty array if there are no errors' do
+      expect(simple.typos).to have(0).items
+      expect(from_stdin.typos).to have(0).items
+    end
+
+    it 'should return proper results' do
+      typos = with_errors.typos
+
+      expect(typos).to have(4).items
+      expect(typos[0].word).to eq 'mispelled'
+      expect(typos[1].word).to eq 'qiute'
+      expect(typos[2].word).to eq 'actualy'
+      expect(typos[3].word).to eq 'tobe'
+    end
+
+    it 'should use configured language'
+  end
+end

data/spec/mdspell/text_line_spec.rb

@@ -0,0 +1,111 @@
+describe MdSpell::TextLine do
+  let(:md_p_element) { Kramdown::Element.new(:p) }
+  let(:md_header_element) { Kramdown::Element.new(:header) }
+  let(:md_text_element) { Kramdown::Element.new(:text, "Joe's shop", nil, location: 42) }
+  let(:md_other_text_element) { Kramdown::Element.new(:text, 'text', nil, location: 42) }
+  let(:md_quote_element) { Kramdown::Element.new(:smart_quote, :lsquo, nil, location: 42) }
+  let(:md_empty_text_element) { Kramdown::Element.new(:text, nil, nil, location: 42) }
+  let(:md_empty_quote_element) { Kramdown::Element.new(:smart_quote, nil, nil, location: 42) }
+  let(:md_text_element_diff_location) { Kramdown::Element.new(:text, 'test', nil, location: 41) }
+
+  subject { MdSpell::TextLine.new(md_text_element) }
+
+  context 'attributes' do
+    it { is_expected.to respond_to :location }
+    it { is_expected.to respond_to :content }
+    it { is_expected.to respond_to :words }
+    it { is_expected.to respond_to :<< }
+  end
+
+  context '#initialize' do
+    it 'should expect Kramdown::Element as argument' do
+      expect { MdSpell::TextLine.new }.to raise_error ArgumentError
+      expect { MdSpell::TextLine.new('test') }.to raise_error ArgumentError
+    end
+  end
+
+  context '#location' do
+    it 'should return proper value' do
+      expect(subject.location).to eq 42
+    end
+  end
+
+  context '#content' do
+    it 'should contain proper text' do
+      expect(subject.content).to eq "Joe's shop"
+    end
+  end
+
+  context '#words' do
+    it 'should return proper content' do
+      expect(subject.words).to eq ["Joe's", 'shop']
+    end
+  end
+
+  context '#<<' do
+    it 'should accept only Kramdown::Element' do
+      expect { subject << 'p_element' }.to raise_error ArgumentError
+      expect { subject << nil }.to raise_error ArgumentError
+      expect { subject << md_empty_text_element }.not_to raise_error
+      expect { subject << md_empty_quote_element }.not_to raise_error
+    end
+
+    context 'when given text element' do
+      it 'should update content' do
+        subject << md_other_text_element
+        expect(subject.content).to eq "Joe's shop text"
+      end
+    end
+
+    context 'when given smart quote element' do
+      let(:lsquo_element) { Kramdown::Element.new(:smart_quote, :lsquo, nil, location: 42) }
+      let(:rsquo_element) { Kramdown::Element.new(:smart_quote, :rsquo, nil, location: 42) }
+      let(:ldquo_element) { Kramdown::Element.new(:smart_quote, :ldquo, nil, location: 42) }
+      let(:rdquo_element) { Kramdown::Element.new(:smart_quote, :rdquo, nil, location: 42) }
+
+      it 'should translate to content properly' do
+        subject << lsquo_element
+        expect(subject.content).to eq "Joe's shop'"
+        subject << ldquo_element
+        expect(subject.content).to eq "Joe's shop'\""
+        subject << rsquo_element
+        expect(subject.content).to eq "Joe's shop'\"'"
+        subject << rdquo_element
+        expect(subject.content).to eq "Joe's shop'\"'\""
+      end
+
+      it 'should properly concatenate words' do
+        subject << md_quote_element
+        subject << md_other_text_element
+        expect(subject.content).to eq "Joe's shop'text"
+        subject << md_other_text_element
+        expect(subject.content).to eq "Joe's shop'text text"
+      end
+    end
+
+    context 'when given element from different location' do
+      it 'should not update content' do
+        subject << md_text_element_diff_location
+        expect(subject.content).to eq "Joe's shop"
+      end
+    end
+  end
+
+  context '::scan' do
+    let(:simple_md) { Kramdown::Document.new(File.read('spec/examples/simple.md'), input: 'GFM') }
+
+    it 'should expect Kramdown::Document as argument' do
+      expect { MdSpell::TextLine.scan }. to raise_error ArgumentError
+    end
+
+    it 'should find proper lines' do
+      lines = MdSpell::TextLine.scan(simple_md)
+
+      expect(lines).to have(3).items
+
+      expect(lines[0].content).to eq 'Simple'
+      expect(lines[1].content).to eq 'markdown'
+      expect(lines[2].content).to eq 'file'
+    end
+  end
+end

data/spec/mdspell/typo_spec.rb

@@ -0,0 +1,83 @@
+describe MdSpell::Typo do
+  let(:text_line) do
+    MdSpell::TextLine.new(Kramdown::Element.new(:text, 'black rabit', nil, location: 42))
+  end
+  let(:misspelled_word) { 'rabit' }
+  let(:suggested_word) { 'rabbit' }
+
+  subject { MdSpell::Typo.new(text_line, misspelled_word, [suggested_word]) }
+
+  context 'attributes' do
+    it { is_expected.to respond_to :line }
+    it { is_expected.to respond_to :word }
+    it { is_expected.to respond_to :suggestions }
+  end
+
+  context '#initialize' do
+    it 'should expect TextLine as first argument' do
+      expect do
+        MdSpell::Typo.new(nil, misspelled_word, [suggested_word])
+      end.to raise_error ArgumentError, 'expected TextLine, got NilClass'
+
+      expect do
+        MdSpell::Typo.new('black rabit', misspelled_word, [suggested_word])
+      end.to raise_error ArgumentError, 'expected TextLine, got String'
+
+      expect do
+        MdSpell::Typo.new(text_line, misspelled_word, [suggested_word])
+      end.not_to raise_error
+    end
+
+    it 'should expect word as second argument' do
+      expect do
+        MdSpell::Typo.new(text_line, nil, [suggested_word])
+      end.to raise_error ArgumentError, 'expected String, got NilClass'
+
+      expect do
+        MdSpell::Typo.new(text_line, :c, [suggested_word])
+      end.to raise_error ArgumentError, 'expected String, got Symbol'
+
+      expect do
+        MdSpell::Typo.new(text_line, misspelled_word, [suggested_word])
+      end.not_to raise_error
+    end
+
+    it 'should expect array as third argument' do
+      expect do
+        MdSpell::Typo.new(text_line, misspelled_word, nil)
+      end.to raise_error ArgumentError, 'expected Array, got NilClass'
+
+      expect do
+        MdSpell::Typo.new(text_line, misspelled_word, 'a')
+      end.to raise_error ArgumentError, 'expected Array, got String'
+
+      expect { MdSpell::Typo.new(text_line, misspelled_word, []) }.not_to raise_error
+      expect do
+        MdSpell::Typo.new(text_line, misspelled_word, [suggested_word])
+      end.not_to raise_error
+    end
+  end
+
+  context '#line' do
+    it 'should return proper object' do
+      expect(subject.line).to be text_line
+    end
+  end
+
+  context '#word' do
+    it 'should return proper word' do
+      expect(subject.word).to eq misspelled_word
+    end
+  end
+
+  context '#suggestions' do
+    it 'should be an array' do
+      expect(subject.suggestions).to be_instance_of Array
+    end
+
+    it 'should return proper items' do
+      expect(subject.suggestions).to have(1).item
+      expect(subject.suggestions).to eq [suggested_word]
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,68 @@
+# Conventionally, all specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# The generated `.rspec` file contains `--require spec_helper` which will cause this file to always
+# be loaded, without a need to explicitly require it in any files.
+#
+# Given that it is always loaded, keep this file as light-weight as possible. Requiring heavyweight
+# dependencies from this file will add to the boot time of test suite on EVERY test run, even for
+# an individual file that may not need all of that loaded. Instead, consider making a separate
+# helper file that requires the additional dependencies and performs the additional setup,
+# and require it from the spec files that actually need it.
+#
+# The `.rspec` file also contains a few flags that are not defaults but that are commonly wanted.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+
+# Setup Code Climate test reporter.
+require 'codeclimate-test-reporter'
+
+CodeClimate::TestReporter.start
+
+# For checking arrays.
+require 'rspec/collection_matchers'
+
+# The whole lib is not that big, requiring it here cleans up the specs a little bit.
+require 'mdspell'
+
+RSpec.configure do |config|
+  # rspec-expectations config goes here.
+  config.expect_with :rspec do |expectations|
+    # This option will default to `true` in RSpec 4. It makes the `description` and
+    # `failure_message` of custom matchers include text for helper methods defined using
+    # `chain`, e.g.:
+    #     be_bigger_than(2).and_smaller_than(4).description
+    #     # => "be bigger than 2 and smaller than 4"
+    # ...rather than:
+    #     # => "be bigger than 2"
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+
+    # Only allow expect syntax.
+    expectations.syntax = :expect
+  end
+
+  # rspec-mocks config goes here.
+  config.mock_with :rspec do |mocks|
+    # Prevents from mocking or stubbing a method that does not exist on a real object.
+    # This is generally recommended, and will default to `true` in RSpec 4.
+    mocks.verify_partial_doubles = true
+  end
+
+  # Allows RSpec to persist some state between runs in order to support the `--only-failures` and
+  # `--next-failure` CLI options. Source control system should be configured to ignore this file.
+  config.example_status_persistence_file_path = 'spec/examples.cache'
+
+  # Run specs in random order to surface order dependencies. To debug an order dependency after
+  # finding one, fix the order by providing the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = :random
+
+  # Seed global randomization in this process using the `--seed` CLI option. Setting this allows
+  # to use `--seed` to deterministically reproduce test failures related to randomization
+  # by passing the same `--seed` value as the one that triggered the failure.
+  Kernel.srand config.seed
+
+  # Allow filtering specs with `focus: true`.
+  config.filter_run focus: true
+
+  # Run all specs if none are filtered.
+  config.run_all_when_everything_filtered = true
+end

metadata

@@ -0,0 +1,100 @@
+--- !ruby/object:Gem::Specification
+name: mdspell
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Marek Tuchowski
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-08-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: kramdown
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+- !ruby/object:Gem::Dependency
+  name: ffi-aspell
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+description: Check markdown files for spelling errors.
+email: marek@tuchowski.com.pl
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.md
+- LICENSE
+files:
+- LICENSE
+- README.md
+- bin/mdspell
+- lib/mdspell.rb
+- lib/mdspell/cli.rb
+- lib/mdspell/configuration.rb
+- lib/mdspell/spell_checker.rb
+- lib/mdspell/text_line.rb
+- lib/mdspell/typo.rb
+- lib/mdspell/version.rb
+- spec/examples.cache
+- spec/examples/simple.md
+- spec/examples/with_errors.md
+- spec/mdspell/spell_checker_spec.rb
+- spec/mdspell/text_line_spec.rb
+- spec/mdspell/typo_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/mtuchowski/mdspell
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options:
+- "--charset"
+- UTF-8
+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.4.8
+signing_key: 
+specification_version: 4
+summary: A Ruby markdown spell checking tool.
+test_files:
+- spec/spec_helper.rb
+- spec/examples/with_errors.md
+- spec/examples/simple.md
+- spec/mdspell/text_line_spec.rb
+- spec/mdspell/typo_spec.rb
+- spec/mdspell/spell_checker_spec.rb
+- spec/examples.cache
+has_rdoc: