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

markdown_helper 2.2.0 → 2.3.0

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