RubyGems - markdown_helper - Versions diffs - 2.2.0 → 2.3.0 - Mend

markdown_helper 2.2.0 → 2.3.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (46) hide show

data/markdown/use_cases/include_files/diagnose_circular_includes/use_case_builder.rb DELETED Viewed

@@ -1,64 +0,0 @@
-require_relative '../include_use_case'
-class DiagnoseCircularIncludes < IncludeUseCase
-  def self.build
-    use_case = self.new
-    use_case.write_ruby_file(pristine = true)
-    [
-        [0, 1],
-        [1, 2],
-        [2, 0],
-    ].each do |indexes|
-      includer_index, includee_index = *indexes
-      includer_file_name = "includer_#{includer_index}.md"
-      includee_file_name = "includer_#{includee_index}.md"
-      if includer_index == 0
-        include_description = "@[:markdown](#{includer_file_name})\n"
-        File.write(INCLUDER_FILE_NAME, include_description)
-      end
-      include_description = "@[:markdown](#{includee_file_name})\n"
-      File.write(includer_file_name, include_description)
-    end
-    File.write(
-        TEMPLATE_FILE_NAME,
-        <<EOT
-### Diagnose Circular Includes
-Use the backtrace of inclusions to diagnose and correct circular inclusions:  that is inclusions that directly or indirectly cause a file to include itself.
-#### Files To Be Included
-These files demonstrate nested inclusion, with circular inclusions.
-@[markdown](includer_0.md)
-@[markdown](includer_1.md)
-@[markdown](includer_2.md)
-#### Includer File
-This file initiates the nested inclusions.
-@[markdown](#{INCLUDER_FILE_NAME})
-@[:markdown](../interface.md)
-#### Error and Backtrace
-Here's the resulting backtrace of inclusions.
-@[:code_block](diagnose_circular_includes.err)
-EOT
-    )
-    use_case.build
-  end
-end

data/markdown/use_cases/include_files/diagnose_missing_includee/include.rb DELETED Viewed

@@ -1,5 +0,0 @@
-require 'markdown_helper'
-# Option :pristine suppresses comment insertion.
-markdown_helper = MarkdownHelper.new(:pristine => true)
-markdown_helper.include('includer.md', 'included.md')

data/markdown/use_cases/include_files/diagnose_missing_includee/use_case_builder.rb DELETED Viewed

@@ -1,66 +0,0 @@
-require_relative '../include_use_case'
-class DiagnoseMissingIncludee < IncludeUseCase
-  def self.build
-    use_case = self.new
-    use_case.write_ruby_file(pristine = true)
-    [
-        [0, 1],
-        [1, 2],
-        [2, 3],
-    ].each do |indexes|
-      includer_index, includee_index = *indexes
-      includer_file_name = "includer_#{includer_index}.md"
-      includee_file_name = "includer_#{includee_index}.md"
-      if includer_index == 0
-        include_description = "@[:markdown](#{includer_file_name})\n"
-        File.write(INCLUDER_FILE_NAME, include_description)
-      end
-      include_description = "@[:markdown](#{includee_file_name})\n"
-      File.write(includer_file_name, include_description)
-    end
-    File.write(
-        TEMPLATE_FILE_NAME,
-        <<EOT
-### Diagnose Missing Includee
-Use the backtrace of inclusions to diagnose and correct a missing or otherwise unreadable includee file.
-The backtrace is especially useful for errors in nested includes.
-#### Files To Be Included
-These files demonstrate nested inclusion, with a missing includee file.
-@[markdown](includer_0.md)
-@[markdown](includer_1.md)
-@[markdown](includer_2.md)
-#### Includer File
-This file initiates the nested inclusions.
-@[markdown](#{INCLUDER_FILE_NAME})
-@[:markdown](../interface.md)
-#### Error and Backtrace
-Here's the resulting backtrace of inclusions.
-@[:code_block](diagnose_missing_includee.err)
-EOT
-    )
-    use_case.build
-  end
-end

data/markdown/use_cases/include_files/include_code_block/use_case_builder.rb DELETED Viewed

@@ -1,78 +0,0 @@
-require_relative '../include_use_case'
-class IncludeCodeBlock < IncludeUseCase
-  def self.build
-    use_case = self.new
-    includee_file_name = 'hello.rb'
-    use_case.files_to_write.store(
-        includee_file_name,
-        <<EOT
-class HelloWorld
-   def initialize(name)
-      @name = name.capitalize
-   end
-   def sayHi
-      puts "Hello #{@name}!"
-   end
-end
-EOT
-    )
-    use_case.files_to_write.store(
-        INCLUDER_FILE_NAME,
-        <<EOT
-This file includes the code as a code block.
-@[:code_block](#{includee_file_name})
-EOT
-    )
-    use_case.files_to_write.store(
-        TEMPLATE_FILE_NAME,
-        <<EOT
-### Include Code Block
-Use file inclusion to include text as a code block.
-#### File to Be Included
-Here's a file containing code to be included:
-@[markdown](#{includee_file_name})
-#### Includer File
-Here's a template file that includes it:
-@[markdown](#{INCLUDER_FILE_NAME})
-The treatment token ```:code_block``` specifies that the included text is to be treated as a code block.
-@[:markdown](../interface.md)
-#### File with Inclusion
-Here's the finished file with the included code block:
-@[:pre](#{INCLUDED_FILE_NAME})
-And here's the finished markdown, as rendered on this page:
----
-@[:markdown](#{INCLUDED_FILE_NAME})
----
-EOT
-    )
-    use_case.build
-  end
-end

data/markdown/use_cases/include_files/include_generated_text/use_case_builder.rb DELETED Viewed

@@ -1,37 +0,0 @@
-require_relative '../include_use_case'
-class IncludeGeneratedText < IncludeUseCase
-  def self.build
-    use_case = self.new
-    use_case.files_to_write.store(
-        TEMPLATE_FILE_NAME,
-        <<EOT
-### Include Generated Text
-#### Generate Includable Text
-A handy use of file inclusion is seen in including generated text.
-That is, the markdown "build" generates files that are then included in the finished markdown document.
-The use cases documented here take advantage of that.  Each use case has an executable Ruby file that has [Here Documents](https://ruby-doc.org/core-2.2.0/doc/syntax/literals_rdoc.html#label-Here+Documents) containing all the relevant text.  The build emits the files that are them used to illustrate the use case.
-#### Keeping Example Code "Green"
-An especially handy use of file inclusion is seen in including example code and output.
-1.  Example code in its own file is executed, and its output captured into another file.
-2.  Then both are included in markdown that uses the example.
-Running the example each time the markdown is built keeps the example code "green," because it confirms that the code still works.
-EOT
-    )
-    use_case.build
-  end
-end

data/markdown/use_cases/include_files/include_highlighted_code/use_case_builder.rb DELETED Viewed

@@ -1,82 +0,0 @@
-require_relative '../include_use_case'
-class IncludeHighlightedCode < IncludeUseCase
-  def self.build
-    use_case = self.new
-    use_case.write_includer_file
-    includee_file_name = 'hello.rb'
-    use_case.files_to_write.store(
-        includee_file_name,
-        <<EOT
-class HelloWorld
-   def initialize(name)
-      @name = name.capitalize
-   end
-   def sayHi
-      puts "Hello #{@name}!"
-   end
-end
-EOT
-    )
-    use_case.files_to_write.store(
-        INCLUDER_FILE_NAME,
-        <<EOT
-This file includes the code as highlighted code.
-@[ruby](#{includee_file_name})
-EOT
-    )
-    use_case.files_to_write.store(
-        TEMPLATE_FILE_NAME,
-        <<EOT
-### Include Highlighted Code
-Use file inclusion to include text as highlighted code.
-#### File to Be Included
-Here's a file containing Ruby code to be included:
-@[markdown](#{includee_file_name})
-#### Includer File
-Here's a template file that includes it:
-@[markdown](#{INCLUDER_FILE_NAME})
-The treatment token ```ruby``` specifies that the included text is to be highlighted as Ruby code.
-The treatment token can be any Ace mode mentioned in [GitHub Languages](https://github.com/github/linguist/blob/master/lib/linguist/languages.yml).  The file lists about 100 Ace modes, covering just about every language and format.
-@[:markdown](../interface.md)
-#### File with Inclusion
-Here's the finished file with the included highlighted code:
-@[:pre](#{INCLUDED_FILE_NAME})
-And here's the finished markdown, as rendered on this page:
----
-@[:markdown](#{INCLUDED_FILE_NAME})
----
-EOT
-    )
-    use_case.build
-  end
-end

data/markdown/use_cases/include_files/include_markdown/use_case_builder.rb DELETED Viewed

@@ -1,80 +0,0 @@
-require_relative '../include_use_case'
-class IncludeMarkdown < IncludeUseCase
-  def self.build
-    use_case = self.new
-    includee_file_name = 'markdown.md'
-    use_case.files_to_write.store(
-        includee_file_name,
-        <<EOT
-This fiie, to be included, is markdown.
-### This is a level-three title.
-Here's a [link](http://yahoo.com).
-This is an unordered list:
-* One.
-* Two.
-* Three.
-EOT
-    )
-    use_case.files_to_write.store(
-        INCLUDER_FILE_NAME,
-        <<EOT
-This file includes the markdown file.
-@[:markdown](#{includee_file_name})
-EOT
-    )
-    use_case.files_to_write.store(
-        TEMPLATE_FILE_NAME,
-        <<EOT
-### Include Markdown
-Use file inclusion to include markdown.  The whole page, includer and includee, will be rendered when it's pushed to GitHub.
-#### File to Be Included
-Here's a file containing markdown to be included:
-@[markdown](#{includee_file_name})
-#### Includer File
-Here's a template file that includes it:
-@[markdown](#{INCLUDER_FILE_NAME})
-The treatment token ```:markdown``` specifies that the included text is to be treated as markdown.
-@[:markdown](../interface.md)
-#### File with Inclusion
-Here's the finished file with the inclusion:
-@[markdown](#{INCLUDED_FILE_NAME})
-And here's the finished markdown, as rendered on this page:
----
-@[:markdown](#{includee_file_name})
----
-EOT
-    )
-    use_case.build
-  end
-end

data/markdown/use_cases/include_files/include_page_toc/use_case_builder.rb DELETED Viewed

@@ -1,121 +0,0 @@
-require_relative '../include_use_case'
-class IncludePageToc < IncludeUseCase
-  def self.build
-    use_case = self.new
-    include_command = IncludeUseCase.construct_include_command(INCLUDER_FILE_NAME, INCLUDED_FILE_NAME, pristine = false)
-    use_case.commands_to_execute.unshift(include_command)
-    includee_0_file_name = 'markdown_0.md'
-    includee_1_file_name = 'markdown_1.md'
-    use_case.files_to_write.store(
-        includee_0_file_name,
-        <<EOT
-## Includee 0 level-two title.
-### Includee 0 level-three title.
-### Another includee 0 level-three title.
-## Another includee 0 level-two title.
-EOT
-    )
-    use_case.files_to_write.store(
-        includee_1_file_name,
-        <<EOT
-## Includee 1 level-two title.
-### Includee 1 level-three title.
-### Another includee 1 level-three title.
-## Another includee 1 level-two title.
-EOT
-    )
-    use_case.files_to_write.store(
-        INCLUDER_FILE_NAME,
-        <<EOT
-# Page Title
-@[:page_toc](## Page Contents)
-## Includer level-two title.
-### Includer level-three title.
-### Another includer level-three title.
-## Another includer level-two title.
-@[:markdown](#{includee_0_file_name})
-@[:markdown](#{includee_1_file_name})
-EOT
-    )
-    use_case.files_to_write.store(
-        TEMPLATE_FILE_NAME,
-        <<EOT
-### Include Page TOC
-Use file inclusion to include a page table of contents (page TOC).
-The page TOC is a tree of links:
-- Each link goes to a corresponding markdown title.
-- The tree structure reflects the relative depths of the linked headers.
-Below are files to be included and an includer file that will generate the page TOC.
-Note that all file inclusion (even nested inclusions) will be performed before the page TOC is built, so the page TOC covers all the included material.
-#### Files to Be Included
-Here's a file containing markdown to be included:
-@[markdown](#{includee_0_file_name})
-Here's another:
-@[markdown](#{includee_1_file_name})
-#### Includer File
-Here's a template file that includes them:
-@[markdown](#{INCLUDER_FILE_NAME})
-The treatment token ```:page_toc``` specifies where the page TOC is to be inserted.
-@[:markdown](../interface.md)
-#### File with Inclusion
-Here's the finished file with the inclusion:
-@[markdown](#{INCLUDED_FILE_NAME})
-And here's the finished markdown, as rendered on this page:
----
-@[:markdown](#{INCLUDED_FILE_NAME})
----
-EOT
-    )
-    use_case.build
-  end
-end

data/markdown/use_cases/include_files/include_text_as_comment/use_case_builder.rb DELETED Viewed

@@ -1,71 +0,0 @@
-require_relative '../include_use_case'
-class IncludeTextAsComment < IncludeUseCase
-  def self.build
-    use_case = self.new
-    includee_file_name = 'hello.rb'
-    use_case.files_to_write.store(
-        includee_file_name,
-        <<EOT
-class HelloWorld
-   def initialize(name)
-      @name = name.capitalize
-   end
-   def sayHi
-      puts "Hello #{@name}!"
-   end
-end
-EOT
-    )
-    use_case.files_to_write.store(
-        INCLUDER_FILE_NAME,
-        <<EOT
-This file includes the code as a comment.
-@[:comment](#{includee_file_name})
-EOT
-    )
-    use_case.files_to_write.store(
-        TEMPLATE_FILE_NAME,
-        <<EOT
-### Include Text As Comment
-Use file inclusion to include text (or even code) as a comment.
-#### File to Be Included
-Here's a file containing code to be included:
-@[markdown](#{includee_file_name})
-#### Includer File
-Here's a template file that includes it:
-@[markdown](#{INCLUDER_FILE_NAME})
-The treatment token ```:comment``` specifies that the included text is to be treated as a comment.
-@[:markdown](../interface.md)
-#### File with Inclusion
-Here's the finished file with the included comment:
-@[markdown](#{INCLUDED_FILE_NAME})
-EOT
-    )
-    use_case.build
-  end
-end

data/markdown/use_cases/include_files/include_text_as_pre/use_case_builder.rb DELETED Viewed

@@ -1,68 +0,0 @@
-require_relative '../include_use_case'
-class IncludeTextAsPre < IncludeUseCase
-  def self.build
-    use_case = self.new
-    includee_file_name = 'triple_backtick.md'
-    use_case.files_to_write.store(
-        includee_file_name,
-        <<EOT
-This file uses triple-backtick to format a ```symbol```, which means that it cannot be included as a code block.
-EOT
-    )
-    use_case.files_to_write.store(
-        INCLUDER_FILE_NAME,
-        <<EOT
-This file includes the backticked content as pre(formatted).
-@[:pre](#{includee_file_name})
-EOT
-    )
-    use_case.files_to_write.store(
-        TEMPLATE_FILE_NAME,
-        <<EOT
-### Include Text As Pre
-Use file inclusion to include text as pre-formatted (rather than as a code block).
-You might need to do this if you have text to include that has triple-backticks.
-#### File to Be Included
-Here's a file containing text to be included; the text has triple-backticks.:
-@[markdown](#{includee_file_name})
-#### Includer File
-Here's a template file that includes it:
-@[markdown](#{INCLUDER_FILE_NAME})
-The treatment token ```:pre``` specifies that the included text is to be treated as pre-formatted.
-@[:markdown](../interface.md)
-#### File with Inclusion
-Here's the finished file with the included preformatted text:
-@[markdown](#{INCLUDED_FILE_NAME})
-EOT
-    )
-    system(INCLUDE_COMMAND)
-    use_case.build
-  end
-end