tty-markdown 0.6.0 → 0.7.0

data/spec/spec_helper.rb

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-if ENV['COVERAGE'] || ENV['TRAVIS']
-  require 'simplecov'
-  require 'coveralls'
-
-  SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
-    SimpleCov::Formatter::HTMLFormatter,
-    Coveralls::SimpleCov::Formatter
-  ]
-
-  SimpleCov.start do
-    command_name 'spec'
-    add_filter 'spec'
-  end
-end
-
-require "bundler/setup"
-require "tty/markdown"
-
-RSpec.configure do |config|
-  # Enable flags like --only-failures and --next-failure
-  config.example_status_persistence_file_path = ".rspec_status"
-
-  # Disable RSpec exposing methods globally on `Module` and `main`
-  config.disable_monkey_patching!
-
-  config.expect_with :rspec do |c|
-    c.syntax = :expect
-  end
-end

data/spec/unit/parse/abbrev_spec.rb

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe TTY::Markdown, 'abbrev' do
-  it "abbreviates markdown" do
-    markdown =<<-TEXT
-*[HTML]: Hyper Text Markup Language
-test HTML
-    TEXT
-    parsed = TTY::Markdown.parse(markdown)
-    expect(parsed).to eq([
-      "test HTML\n"
-    ].join("\n"))
-  end
-
-  it "indents abbreviations correctly" do
-    markdown =<<-TEXT
-### header
-*[HTML]: Hyper Text Markup Language
-test HTML
-    TEXT
-    parsed = TTY::Markdown.parse(markdown)
-    expect(parsed).to eq([
-      "    \e[36;1mheader\e[0m",
-      "    test HTML\n"
-    ].join("\n"))
-  end
-end

data/spec/unit/parse/blockquote_spec.rb

@@ -1,77 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe TTY::Markdown, 'blockquote' do
-  let(:bar) { TTY::Markdown.symbols[:bar] }
-  let(:apos) { TTY::Markdown.symbols[:rsquo] }
-
-  it "converts single blockquote" do
-    markdown =<<-TEXT
-> Oh, you can *put* **Markdown** into a blockquote.
-    TEXT
-    parsed = TTY::Markdown.parse(markdown)
-    expect(parsed).to eq([
-      "\e[33m#{bar}\e[0m  Oh, you can \e[33mput\e[0m \e[33;1mMarkdown\e[0m into a blockquote.\n"
-    ].join)
-  end
-
-  it "indents blockquote within header" do
-    markdown =<<-TEXT
-### Quote
-> Oh, you can *put* **Markdown** into a blockquote.
-    TEXT
-    parsed = TTY::Markdown.parse(markdown)
-    expect(parsed).to eq([
-      "    \e[36;1mQuote\e[0m",
-      "    \e[33m#{bar}\e[0m  Oh, you can \e[33mput\e[0m \e[33;1mMarkdown\e[0m into a blockquote.\n"
-    ].join("\n"))
-  end
-
-  it "converts multiple blockquotes without header" do
-    markdown =<<-TEXT
-> one
-> two
-> three
-    TEXT
-    parsed = TTY::Markdown.parse(markdown)
-    expected_output =
-      "\e[33m#{bar}\e[0m  one\n" +
-      "\e[33m#{bar}\e[0m  two\n" +
-      "\e[33m#{bar}\e[0m  three\n"
-
-    expect(parsed).to eq(expected_output)
-  end
-
-  it "converts multiple blockquote" do
-    markdown =<<-TEXT
-### Quote
-> Blockquotes are very handy in email to emulate reply text.
-> This line is part of the same quote.
-> *Oh*, you can put **Markdown** into a blockquote.
-    TEXT
-    parsed = TTY::Markdown.parse(markdown)
-    expect(parsed).to eq([
-      "    \e[36;1mQuote\e[0m\n",
-      "    \e[33m#{bar}\e[0m  Blockquotes are very handy in email to emulate reply text.\n",
-      "    \e[33m#{bar}\e[0m  This line is part of the same quote.\n",
-      "    \e[33m#{bar}\e[0m  \e[33mOh\e[0m, you can put \e[33;1mMarkdown\e[0m into a blockquote.\n"
-    ].join)
-  end
-
-  it "converts blockquote into lines" do
-    markdown =<<-TEXT
-> This is a very long line that will still be quoted properly when it wraps. Oh boy let's keep writing to make sure this is long enough to actually wrap for everyone. Oh, you can *put* **Markdown** into a blockquote.
-> Last line to ensure all is fine.
-    TEXT
-
-    parsed = TTY::Markdown.parse(markdown, width: 50)
-    expected_output =
-      "\e[33m#{bar}\e[0m  This is a very long line that will still be \n" +
-      "\e[33m#{bar}\e[0m  quoted properly when it wraps. Oh boy let\n" +
-      "\e[33m#{bar}\e[0m  #{apos}s keep writing to make sure this is long enough \n" +
-      "\e[33m#{bar}\e[0m  to actually wrap for everyone. Oh, you can \n" +
-      "\e[33m#{bar}\e[0m  \e[33mput\e[0m \e[33;1mMarkdown\e[0m into a blockquote.\n" +
-      "\e[33m#{bar}\e[0m  Last line to ensure all is fine.\n"
-
-    expect(parsed).to eq(expected_output)
-  end
-end

data/spec/unit/parse/codeblock_spec.rb

@@ -1,130 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe TTY::Markdown, 'codeblock' do
-  it "highlights a fenced code without language" do
-    markdown =<<-TEXT
-```
-class Greeter
-  def say
-  end
-end
-```
-    TEXT
-    parsed = TTY::Markdown.parse(markdown, colors: 16)
-    expect(parsed).to eq([
-     "\e[33mclass Greeter\e[0m",
-     "\e[33m  def say\e[0m",
-     "\e[33m  end\e[0m",
-     "\e[33mend\e[0m\n"
-    ].join("\n"))
-  end
-
-  it "highlights code without language" do
-    markdown =<<-TEXT
-    class Greeter
-      def say
-      end
-    end
-    TEXT
-    parsed = TTY::Markdown.parse(markdown, colors: 16)
-    expect(parsed).to eq([
-     "\e[33mclass Greeter\e[0m",
-     "\e[33m  def say\e[0m",
-     "\e[33m  end\e[0m",
-     "\e[33mend\e[0m"
-    ].join("\n"))
-  end
-
-  it "highlights fenced code according to language" do
-    markdown =<<-TEXT
-```ruby
-class Greeter
-  def say
-  end
-end
-```
-    TEXT
-    parsed = TTY::Markdown.parse(markdown, colors: 16)
-    expect(parsed).to eq([
-     "\e[33mclass Greeter\e[0m",
-     "\e[33m  def say\e[0m",
-     "\e[33m  end\e[0m",
-     "\e[33mend\e[0m\n"
-    ].join("\n"))
-  end
-
-  it "indents immediate code correctly" do
-    markdown =<<-TEXT
-### header
-```
-class Greeter
-  def say
-  end
-end
-```
-    TEXT
-    parsed = TTY::Markdown.parse(markdown, colors: 16)
-    expect(parsed).to eq([
-     "    \e[36;1mheader\e[0m",
-     "    \e[33mclass Greeter\e[0m",
-     "    \e[33m  def say\e[0m",
-     "    \e[33m  end\e[0m",
-     "    \e[33mend\e[0m\n"
-    ].join("\n"))
-  end
-
-  it "indents code after blank correctly" do
-    markdown =<<-TEXT
-### header
-
-```
-class Greeter
-  def say
-  end
-end
-```
-    TEXT
-    parsed = TTY::Markdown.parse(markdown, colors: 16)
-    expect(parsed).to eq([
-     "    \e[36;1mheader\e[0m",
-     "",
-     "    \e[33mclass Greeter\e[0m",
-     "    \e[33m  def say\e[0m",
-     "    \e[33m  end\e[0m",
-     "    \e[33mend\e[0m\n"
-    ].join("\n"))
-  end
-
-  it "wraps code exceeding set width" do
-    markdown =<<-TEXT
-```
-lexer = Rouge::Lexer.find_fancy(lang, code) || Rouge::Lexers::PlainText
-```
-    TEXT
-    parsed = TTY::Markdown.parse(markdown, width: 50, colors: 16)
-
-    expected_output =
-      "\e[33mlexer = Rouge::Lexer.find_fancy(lang, code) || \e[0m\n" +
-      "\e[33mRouge::Lexers::PlainText\e[0m\n"
-
-    expect(parsed).to eq(expected_output)
-  end
-
-  it "wraps code exceeding set width preserving indentation" do
-    markdown =<<-TEXT
-### lexer
-
-```
-lexer = Rouge::Lexer.find_fancy(lang, code) || Rouge::Lexers::PlainText
-```
-    TEXT
-    parsed = TTY::Markdown.parse(markdown, width: 50, colors: 16)
-
-    expected_output =
-      "    \e[36;1mlexer\e[0m\n\n" +
-      "    \e[33mlexer = Rouge::Lexer.find_fancy(lang, code) || \e[0m\n" +
-      "    \e[33mRouge::Lexers::PlainText\e[0m\n"
-
-    expect(parsed).to eq(expected_output)
-  end
-end

data/spec/unit/parse/comment_spec.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe TTY::Markdown, 'comment' do
-  it "converts xml type comment" do
-    markdown =<<-TEXT
-text before
-<!-- TODO: this is a comment -->
-text after
-    TEXT
-
-    parsed = TTY::Markdown.parse(markdown)
-
-    expect(parsed).to eq([
-      "text before",
-      "<!-- TODO: this is a comment -->\n",
-      "text after\n"
-    ].join("\n"))
-  end
-end

data/spec/unit/parse/emphasis_spec.rb

@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe TTY::Markdown, 'emphasis' do
-  context 'when strong emphasis' do
-    it "converts asterisks to bold ansi codes" do
-      parsed = TTY::Markdown.parse("Some text with **bold** content.")
-
-      expect(parsed).to eq("Some text with \e[33;1mbold\e[0m content.\n")
-    end
-  end
-
-  context 'when italics emphasis' do
-    it "converts asterisks to bold ansi codes" do
-      parsed = TTY::Markdown.parse("Some text with *italic* content.")
-
-      expect(parsed).to eq("Some text with \e[33mitalic\e[0m content.\n")
-    end
-  end
-
-  context 'when strikethrough emphasis' do
-    it "converts two tildes to ansi codes" do
-      parsed = TTY::Markdown.parse("Some text with ~~scratched~~ content.")
-
-      expect(parsed).to eq("Some text with ~~scratched~~ content.\n")
-    end
-  end
-
-  context "when backticks" do
-    it "convertrs backtics to ansi codes" do
-      parsed = TTY::Markdown.parse("Some text with `important` content.", colors: 16)
-
-      expect(parsed).to eq("Some text with \e[33mimportant\e[0m content.\n")
-    end
-  end
-end

data/spec/unit/parse/entity_spec.rb

@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe TTY::Markdown, 'entity' do
-  it "converts html entities" do
-    markdown =<<-TEXT
-&copy; 2018 by me and &#x3bb;
-    TEXT
-    parsed = TTY::Markdown.parse(markdown)
-    expect(parsed).to eq("© 2018 by me and λ\n")
-  end
-end

data/spec/unit/parse/header_spec.rb

@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe TTY::Markdown, 'header' do
-  it "converts top level header" do
-    parsed = TTY::Markdown.parse("#Header1")
-
-    expect(parsed).to eq("\e[36;1;4mHeader1\e[0m\n")
-  end
-
-  it "converts headers" do
-    headers =<<-TEXT
-# Header1
-header1 content
-
-## Header2
-header2 content
-
-### Header3
-header3 content
-    TEXT
-    parsed = TTY::Markdown.parse(headers)
-
-    expect(parsed).to eq([
-      "\e[36;1;4mHeader1\e[0m",
-      "header1 content",
-      "",
-      "  \e[36;1mHeader2\e[0m",
-      "  header2 content",
-      "",
-      "    \e[36;1mHeader3\e[0m",
-      "    header3 content\n"
-    ].join("\n"))
-  end
-end
-

data/spec/unit/parse/hr_spec.rb

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe TTY::Markdown, 'horizontal rule' do
-  let(:symbols) { TTY::Markdown.symbols }
-
-  it "draws a horizontal rule" do
-    markdown =<<-TEXT
----
-    TEXT
-    parsed = TTY::Markdown.parse(markdown, width: 10)
-    expect(parsed).to eq("\e[33m#{symbols[:diamond]}#{symbols[:line]*8}#{symbols[:diamond]}\e[0m\n")
-  end
-
-  it "draws a horizontal rule within header indentation" do
-    markdown =<<-TEXT
-### header
----
-    TEXT
-    parsed = TTY::Markdown.parse(markdown, width: 20)
-    expect(parsed).to eq([
-      "    \e[36;1mheader\e[0m\n",
-      "    \e[33m#{symbols[:diamond]}#{symbols[:line]*10}#{symbols[:diamond]}\e[0m\n"
-    ].join)
-  end
-end

data/spec/unit/parse/link_spec.rb

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe TTY::Markdown, 'link' do
-  let(:symbols) { TTY::Markdown.symbols }
-
-  it "converts link" do
-    markdown =<<-TEXT
-[I'm an inline-style link](https://www.google.com)
-    TEXT
-    parsed = TTY::Markdown.parse(markdown)
-    expect(parsed).to eq([
-      "I#{symbols[:rsquo]}m an inline-style link #{symbols[:arrow]} \e[33;4mhttps://www.google.com\e[0m\n"
-    ].join)
-  end
-
-  it "converts link with title" do
-    markdown =<<-TEXT
-[I'm an inline-style link with title](https://www.google.com "Google's Homepage")
-    TEXT
-    parsed = TTY::Markdown.parse(markdown)
-    expect(parsed).to eq([
-      "Google's Homepage #{symbols[:arrow]} \e[33;4mhttps://www.google.com\e[0m\n"
-    ].join)
-  end
-end

data/spec/unit/parse/list_spec.rb

@@ -1,103 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe TTY::Markdown, 'list' do
-  let(:symbols) { TTY::Markdown.symbols }
-  let(:pastel) { Pastel.new}
-
-  it "converts unordered bulleted lists of nested items" do
-    markdown =<<-TEXT
-- Item 1
-  - Item 2
-  - Item 3
-    - Item 4
-    - Item 5
-- Item 6
-    TEXT
-    parsed = TTY::Markdown.parse(markdown)
-    expect(parsed).to eq([
-      "#{pastel.yellow(symbols[:bullet])} Item 1",
-      "  #{pastel.yellow(symbols[:bullet])} Item 2",
-      "  #{pastel.yellow(symbols[:bullet])} Item 3",
-      "    #{pastel.yellow(symbols[:bullet])} Item 4",
-      "    #{pastel.yellow(symbols[:bullet])} Item 5",
-      "#{pastel.yellow(symbols[:bullet])} Item 6\n"
-    ].join("\n"))
-  end
-
-  it "indents unordered list" do
-    markdown =<<-TEXT
-### header
-- Item 1
-  - Item 2
-  - Item 3
-    - Item 4
-    - Item 5
-- Item 6
-    TEXT
-    parsed = TTY::Markdown.parse(markdown)
-    expect(parsed).to eq([
-      "    \e[36;1mheader\e[0m",
-      "    #{pastel.yellow(symbols[:bullet])} Item 1",
-      "      #{pastel.yellow(symbols[:bullet])} Item 2",
-      "      #{pastel.yellow(symbols[:bullet])} Item 3",
-      "        #{pastel.yellow(symbols[:bullet])} Item 4",
-      "        #{pastel.yellow(symbols[:bullet])} Item 5",
-      "    #{pastel.yellow(symbols[:bullet])} Item 6\n"
-    ].join("\n"))
-  end
-
-  it "indents unordered list with multiline content" do
-    markdown =<<-TEXT
-### header
-- First multiline
-  Item 1
-  - Second multiline
-    Item 2
-  - Item 3
-- Item 4
-    TEXT
-    parsed = TTY::Markdown.parse(markdown)
-    expect(parsed).to eq([
-      "    \e[36;1mheader\e[0m",
-      "    #{pastel.yellow(symbols[:bullet])} First multiline",
-      "      Item 1",
-      "      #{pastel.yellow(symbols[:bullet])} Second multiline",
-      "        Item 2",
-      "      #{pastel.yellow(symbols[:bullet])} Item 3",
-      "    #{pastel.yellow(symbols[:bullet])} Item 4\n",
-    ].join("\n"))
-  end
-
-  it "displays inline codeblocks in lists correctly" do
-    markdown =<<-TEXT
-- Version: run `ruby -v` or `ruby --version`.
-- Help: run `ruby -h` or `ruby --help`.
-    TEXT
-
-    parsed = TTY::Markdown.parse(markdown, colors: 16)
-    expect(parsed).to eq([
-      "#{pastel.yellow(symbols[:bullet])} Version: run \e[33mruby -v\e[0m or \e[33mruby --version\e[0m.",
-      "#{pastel.yellow(symbols[:bullet])} Help: run \e[33mruby -h\e[0m or \e[33mruby --help\e[0m.\n"
-    ].join("\n"))
-  end
-
-  it "convert ordered numbered list of nested items" do
-    markdown =<<-TEXT
-1. Item 1
-    2. Item 2
-    3. Item 3
-        4. Item 4
-        5. Item 5
-6. Item 6
-    TEXT
-    parsed = TTY::Markdown.parse(markdown)
-    expect(parsed).to eq([
-      "#{pastel.yellow('1.')} Item 1",
-      "  #{pastel.yellow('1.')} Item 2",
-      "  #{pastel.yellow('2.')} Item 3",
-      "    #{pastel.yellow('1.')} Item 4",
-      "    #{pastel.yellow('2.')} Item 5",
-      "#{pastel.yellow('2.')} Item 6\n"
-    ].join("\n"))
-  end
-end