lmt 0.1.2 → 0.1.3

data/doc/lmt/lmt_expressions.md

@@ -12,19 +12,57 @@ The first regular expression handles the detection of include directives.  It re
 /^!\s+include\s+\[.*\]\((.*)\)\s*$/
 ```
 
+## The Block Expressions
+
+These regular expression recognize if, elseif, else, and end directives.  The first group contains the conditional for blocks that have a conditional..
+
+###### Code Block: If Expression
+
+``` ruby
+/^!\s+if\s+(.*)$/
+```
+
+###### Code Block: Else Expression
+
+``` ruby
+/^!\s+else/
+```
+
+###### Code Block: Elsif Expression
+
+``` ruby
+/^!\s+elsif\s+(.*)$/
+```
+
+###### Code Block: End Expression
+
+``` ruby
+/^!\s+end$/
+```
+
 ## The Code Block Expression
 
-The second regular expression is intended to note when whe enter or leave a code block.  It detects markdown code fences and processes the special directives.  It has four groups.  The first identifies white space at the beginning of the line.  The second detects the language.  The third determines if this is a replacement.  The fourth is the name of the block (if applicable).
+This expression is intended to note when whe enter or leave a code block.  It detects markdown code fences and processes the special directives.  It has four groups.  The first identifies white space at the beginning of the line.  The second detects the language.  The third determines if this is a replacement.  The fourth is the name of the block (if applicable).
 
 ###### Code Block: Code Block Expression
 
 ``` ruby
-/^([s]*)``` ?([\w]*) ?(=?)([-\w]*)?/
+/^(\s*)``` ?([\w]*) ?(=?)([-\w]*)?/
+```
+
+## The Extension Expression
+
+This expression identifies blocks of code which are to be executed.  The first group identifies white space at the beginning of the line.
+
+###### Code Block: Extension Expression
+
+``` ruby
+/^(\s*)``` ruby !/
 ```
 
 ## The Macro Substitution Expression
 
-The third expression identifies macro expansions surrounded with `⦅` and `⦆`.  The first bit deals with making sure that the opening `⦅` isn't escaped.  Then there is one group which contains the name of the macro combined and any filters which are being used.
+This identifies macro expansions surrounded with `⦅` and `⦆`.  The first bit deals with making sure that the opening `⦅` isn't escaped.  Then there is one group which contains the name of the macro combined and any filters which are being used.
 
 ###### Code Block: Macro Substitution Expression
 

data/doc/lmt/lmw.rb.md

@@ -298,6 +298,7 @@ We will match the lines against the expressions and, when a match occurs, we wil
 def substitute_directives_and_headers(lines)
   include_expression = ⦅include_expression⦆
   code_block_expression = ⦅code_block_expression⦆
+  extension_block_expression = ⦅extension_expression⦆
   in_block = false
   block_name = ""
   lines.map do |line|
@@ -319,28 +320,34 @@ def substitute_directives_and_headers(lines)
 end
 ```
 
-#### The header for code blocks
+#### The Header for Code Blocks
 
 Code blocks need to be headed appropriately as markdown parsing eats the code block name.  Because of this we put it in a `h6` header.  When the block is repeated, we add a `(part n)` to the end.  We also should be adding links for the next and last version of this header.
 
 ###### Code Block: Make Code Block Header
 
 ``` ruby
-white_space, language, replacement_mark, name =
-  code_block_expression.match(line)[1..-1]
-human_name = name.gsub(/[-_]/, ' ').split(' ').map(&:capitalize).join(' ')
-replacing = if replacement_mark == "="
-      " Replacing"
-    else
-      ""
-    end
-header = if name != ""
-  "#######{replacing} Code Block: #{human_name}\n\n"
+if line =~ extension_block_expression
+  white_space = extension_block_expression.match(line)[1]
+  header = "###### Execute Extension Block\n\n"
+  [header, "#{white_space}``` ruby\n"]
 else
-  "#######{replacing} Output Block\n\n"
+  white_space, language, replacement_mark, name =
+    code_block_expression.match(line)[1..-1]
+  human_name = name.gsub(/[-_]/, ' ').split(' ').map(&:capitalize).join(' ')
+  replacing = if replacement_mark == "="
+        " Replacing"
+      else
+        ""
+      end
+  header = if name != ""
+    "#######{replacing} Code Block: #{human_name}\n\n"
+  else
+    "#######{replacing} Output Block\n\n"
+  end
+  [header,
+    "#{white_space}``` #{language}\n"]
 end
-[header,
-  "#{white_space}``` #{language}\n"]
 ```
 
 ### Replacing the Markdown Links

data/lib/lmt/lmt.rb

@@ -16,6 +16,7 @@ class Tangle
   main do
     check_arguments()
     begin
+      @dev = options[:dev]
       self_test()
       tangler = Tangle::Tangler.new(options[:file])
       tangler.tangle()
@@ -58,9 +59,39 @@ class Tangle
     report_self_test_failure("Should be able to place two macros on the same line") unless two_macros == "foo foo"
     string_with_backslash = "this string ends in \\."
     report_self_test_failure("ruby escape doesn't escape backslash") unless string_with_backslash =~ /\\.?/
+    some_text = "some text"
+    report_self_test_failure("Double quote doesn't double quote") unless some_text == "some text"
+    some_indented_text = "  some text"
+    report_self_test_failure("Indent lines should add two spaces to lines") unless some_indented_text == "  some text"
+    items = ["item 1",
+      "item 2",]
+    report_self_test_failure("Add comma isn't adding commas") unless items == ["item 1", "item 2"]
     included_string = "I came from lmt_include.lmd"
     report_self_test_failure("included replacements should replace blocks") unless included_string == "I came from lmt_include.lmd"
+    
+    from_extension = true
 
+    report_self_test_failure("extension hook should be able to add blocks") unless from_extension
+    conditional_output_else = true
+    conditional_output_elsif = true
+    report_self_test_failure("conditional output elseif should not be output when elseif is false") unless conditional_output_elsif
+    report_self_test_failure("conditional output else should not be output when if true") unless conditional_output_else
+    conditional_output_else = true
+    conditional_output_elsif = true
+    report_self_test_failure("conditional output elsif should not be output even if true when is also true") unless conditional_output_elsif
+    report_self_test_failure("conditional output else should not be output when if is true (if and elseif)") unless conditional_output_else
+    conditional_output_if = true
+    conditional_output_else = true
+    conditional_output_elsif = true
+    report_self_test_failure("conditional output if should not be output when false") unless conditional_output_if
+    report_self_test_failure("conditional output elseif should be output when elseif is true") unless conditional_output_elsif
+    report_self_test_failure("conditional output else should not be output when elseif is true") unless conditional_output_else
+    conditional_output_if = true
+    conditional_output_elsif = true
+    conditional_output_else = true
+    report_self_test_failure("conditional output if should not be output when false") unless conditional_output_if
+    report_self_test_failure("conditional output elseif should not be output when elseif is false") unless conditional_output_elsif
+    report_self_test_failure("conditional output else should be output when neither if nor elseif is true") unless conditional_output_else
   end
 
   def self.report_self_test_failure(message)
@@ -89,17 +120,29 @@ class Tangle
   end
 
   class Tangler
-    class << self
-      attr_reader :filters
-    end
-  
-    @filters = {
-      'ruby_escape' => LineFilter.new do |line|
-        line.dump[1..-2]
-      end
-    }
-  
     def initialize(input)
+      @extension_context = Context.new()
+      @extension_context.filters = {
+        'ruby_escape' => LineFilter.new do |line|
+          line.dump[1..-2]
+        end,
+        'double_quote' => LineFilter.new do |line|
+          before_white = /^\s*/.match(line)[0]
+          after_white = /\s*$/.match(line)[0]
+          "#{before_white}\"#{line.strip}\"#{after_white}"
+        end,
+        'add_comma' => LineFilter.new do |line|
+          before_white = /^\s*/.match(line)[0]
+          after_white = /\s*$/.match(line)[0]
+          "#{before_white}#{line.strip},#{after_white}"
+        end,
+        'indent_continuation' => Filter.new do |lines|
+          [lines[0], *lines[1..-1].map {|l| "  #{l}"}]
+        end,
+        'indent_lines' => LineFilter.new do |line|
+          "  #{line}"
+        end
+      }
       @input = input
       @block = ""
       @blocks = {}
@@ -107,8 +150,9 @@ class Tangle
     end
     
     def tangle()
-      contents = include_includes(read_file(@input))
-      @block, @blocks = parse_blocks(contents)
+      contents =  handle_extensions_and_conditionals(
+          include_includes(read_file(@input)))
+      @block, @blocks = @extension_context.parse_hook(*parse_blocks(contents))
       if @block
         @block = expand_macros(@block)
         @block = unescape_double_parens(@block)
@@ -136,8 +180,41 @@ class Tangle
       end.flatten(1)
     end
     
+    def handle_extensions_and_conditionals(lines)
+      extension_expression = /^(\s*)``` ruby !/
+      condition_processor = ConditionalProcessor.new(@extension_context)
+      extension_exit_expression = /```/
+      in_extension_block = false
+      current_extension_block = []
+    
+      other_lines = lines.lazy
+        .find_all do |line|
+          condition_processor.should_output(line)
+        end.find_all do |line|
+          unless in_extension_block
+            in_extension_block = line =~ extension_expression
+            if in_extension_block
+              current_extension_block = []
+            end
+            !in_extension_block
+          else
+            in_extension_block = !(line =~ extension_exit_expression)
+            if in_extension_block
+              current_extension_block << line
+            else
+              @extension_context.get_binding.eval(current_extension_block.join)
+            end
+            false
+          end
+        end.force
+    
+      condition_processor.check_block_balance()
+    
+      other_lines
+    end
+    
     def parse_blocks(lines)
-      code_block_exp = /^([s]*)``` ?([\w]*) ?(=?)([-\w]*)?/
+      code_block_exp = /^(\s*)``` ?([\w]*) ?(=?)([-\w]*)?/
       in_block = false
       blocks = lines.find_all do |line|
         in_block = !in_block if line =~ code_block_exp
@@ -176,7 +253,7 @@ class Tangle
     
     def apply_filters(strings, filters)
       filters.map do |filter_name|
-        Tangler.filters[filter_name]
+        filters_map[filter_name]
       end.inject(strings) do |strings, filter|
         filter.filter(strings)
       end
@@ -199,6 +276,9 @@ class Tangle
     
   
     private
+    def filters_map
+      @extension_context.filters
+    end
     def get_last_replacement_index(bodies)
       last_replacement = bodies.each_with_index
           .select do |((_, replacement_mark, _), _)|
@@ -246,7 +326,64 @@ class Tangle
             end
           end
     end
+  
+    class ConditionalProcessor
+    
+      def initialize(extension_context)
+        @if_expression = /^!\s+if\s+(.*)$/
+        @elsif_expression = /^!\s+elsif\s+(.*)$/
+        @else_expression = /^!\s+else/
+        @end_expression = /^!\s+end$/
+        @output_enabled = true
+        @stack = []
+        @extension_context = extension_context
+      end
+    
+      def should_output(line)
+        case line
+          when @if_expression
+            condition = $1
+            prior_state = @output_enabled
+            @output_enabled = !!@extension_context.get_binding.eval(condition)
+            @stack.push([:if, prior_state, !@output_enabled])
+          when @elsif_expression
+            throw "elsif statement missing if"  if @stack.empty?
+            condition = $1
+            type, prior_state, execute_else = @stack.pop()
+            @output_enabled = execute_else && !!@extension_context.get_binding.eval(condition)
+            @stack.push([type, prior_state, execute_else && !@output_enabled])
+          when @else_expression
+            throw "else statement missing if" if @stack.empty?
+            type, prior_state, execute_else = @stack.pop()
+            @output_enabled = execute_else
+            @stack.push([type, prior_state, execute_else])
+          when @end_expression
+            throw "end statement missing begin" if @stack.empty?
+            type, prior_state, execute_else = @stack.pop()
+            @output_enabled = prior_state
+        end
+        @output_enabled
+      end
+      
+      def check_block_balance
+        throw "unbalanced blocks" unless @stack.empty?
+      end
+    end
+    
+  end
+
+  class Context
+    attr_accessor :filters
+  
+    def get_binding
+      binding
+    end
+  
+    def parse_hook(main_block, blocks)
+      [main_block, blocks]
+    end
   end
+  
 
   def self.required(*options)
     @required_options = options

data/lib/lmt/lmw.rb

@@ -97,7 +97,7 @@ class Lmw
     
     def find_blocks(lines)
       lines_with_includes = include_includes(lines)
-      code_block_exp = /^([s]*)``` ?([\w]*) ?(=?)([-\w]*)?/
+      code_block_exp = /^(\s*)``` ?([\w]*) ?(=?)([-\w]*)?/
       headers_and_footers = lines_with_includes.filter do |(line, source_file)|
         code_block_exp =~ line
       end
@@ -122,7 +122,8 @@ class Lmw
     end
     def substitute_directives_and_headers(lines)
       include_expression = /^!\s+include\s+\[.*\]\((.*)\)\s*$/
-      code_block_expression = /^([s]*)``` ?([\w]*) ?(=?)([-\w]*)?/
+      code_block_expression = /^(\s*)``` ?([\w]*) ?(=?)([-\w]*)?/
+      extension_block_expression = /^(\s*)``` ruby !/
       in_block = false
       block_name = ""
       lines.map do |line|
@@ -133,21 +134,27 @@ class Lmw
         when code_block_expression
           in_block = !in_block
           if in_block
-            white_space, language, replacement_mark, name =
-              code_block_expression.match(line)[1..-1]
-            human_name = name.gsub(/[-_]/, ' ').split(' ').map(&:capitalize).join(' ')
-            replacing = if replacement_mark == "="
-                  " Replacing"
-                else
-                  ""
-                end
-            header = if name != ""
-              "#######{replacing} Code Block: #{human_name}\n\n"
+            if line =~ extension_block_expression
+              white_space = extension_block_expression.match(line)[1]
+              header = "###### Execute Extension Block\n\n"
+              [header, "#{white_space}``` ruby\n"]
             else
-              "#######{replacing} Output Block\n\n"
+              white_space, language, replacement_mark, name =
+                code_block_expression.match(line)[1..-1]
+              human_name = name.gsub(/[-_]/, ' ').split(' ').map(&:capitalize).join(' ')
+              replacing = if replacement_mark == "="
+                    " Replacing"
+                  else
+                    ""
+                  end
+              header = if name != ""
+                "#######{replacing} Code Block: #{human_name}\n\n"
+              else
+                "#######{replacing} Output Block\n\n"
+              end
+              [header,
+                "#{white_space}``` #{language}\n"]
             end
-            [header,
-              "#{white_space}``` #{language}\n"]
           else
             [line]
           end

data/lib/lmt/version.rb

@@ -1,3 +1,3 @@
 module Lmt
-  VERSION = "0.1.2"
+  VERSION = "0.1.3"
 end

data/src/lmt/lmt.rb.lmd

@@ -22,15 +22,15 @@ In order to be useful for literate programming we need a few features:
 4. The ability to to identify code blocks which will be expanded when referenced
 5. The ability to append to or replace code blocks
 6. The ability to include another file.
+7. The ability to extend the tangler with Ruby code from a block.
+8. Simple conditional logic to enable output only under certain circumstances
 
 There are also a few potentially useful features that are not implemented but might be in the future:
 
-1. The ability to extend the tangler with Ruby code from a block.
-2. The ability to write out other files.
-3. Source mapping
-4. Further source verification.  For instance, all instances of the same block should be in the same language.  Also, detect and prevent double inclusion.
-
-Also, the only filter currently existing just escapes strings for ruby code.  There are many more that could be useful.
+1. The ability to write out other files.
+2. Source mapping
+3. Further source verification.  For instance, all instances of the same block should be in the same language.  Also, detect and prevent double inclusion.
+4. include path semantics.
 
 ### Blocks
 
@@ -38,7 +38,7 @@ Markdown already supports code blocks expressed with code fences starting with t
 
 There are two types of blocks: the default block and macro blocks.
 
-Ouput begins with the default block.  It is simply a markdown code block which has no macro name.  with no further information.  It looks like this.
+Output begins with the default block.  It is simply a markdown code block which has no macro name.  with no further information.  It looks like this.
 
 ``` ruby
 #Output starts here
@@ -114,7 +114,11 @@ There are a few built in filters:
 
 ``` ruby filter_list
 {
-  'ruby_escape' => ⦅ruby_escape⦆
+  'ruby_escape' => ⦅ruby_escape⦆,
+  'double_quote' => ⦅double_quote⦆,
+  'add_comma' => ⦅add_comma⦆,
+  'indent_continuation' => ⦅indent_continuation⦆,
+  'indent_lines' => ⦅indent_lines⦆
 }
 ```
 
@@ -130,6 +134,55 @@ included_string = "I am in lmt.lmd"
 
 ! include [an include](lmt_include.lmd)
 
+### Extension
+
+In order to extend the tangler, it must be possible to mark a block for evaluation.  To do so we will extend the mechanism to indicate replacement.  Let's use `!`.  A block simply named `!` will just be executed within a contained scope.  Within this scope, it will be possible to access the map of filters through the `@filters` variable.  All of these blocks are executed and removed from the stream before any further processing is done.
+
+However, after blocks have been parsed, the map of blocks will be passed to the `parse_hook` method which an extension may define.  It will be passed a two arguments.  The first is an array with the lines of the main block, the second is a map of block name to line arrays.  It is expected to return the same data structure in a two value array.  An example parse hook which adds a block to the list of know blocks follows:
+
+``` ruby !
+def parse_hook(main_block, blocks)
+  blocks["from_extension"] = ["from_extension = true\n"]
+  [main_block, blocks]
+end
+```
+
+### Conditional Output
+
+Under certain circumstances it is useful to have certain output only happen under certain circumstances.  For instance, a file prepared for Windows might have slightly different content than the same file prepared for Linux.  In order to enable this, a variable may be set within an extension block and then output may be enabled / disabled using directives based on them.
+
+``` ruby !
+@a_variable = true
+@another_variable = false
+```
+
+We can then disable and enable output using the if, else, elsif, and end directives.  The if directive takes a line of ruby code, executes it.
+
+! if @a_variable
+
+Since a_variable is true, the next block will be processed.
+
+``` ruby conditional_output
+conditional_output_else = true
+conditional_output_elsif = true
+```
+
+! elsif @another_variable
+
+``` ruby conditional_output
+conditional_output_elsif = false
+```
+
+! else
+
+And the following block will have no effect.
+
+``` ruby conditional_output
+conditional_output_else = false
+```
+
+! end
+
 ### Self Test
 
 Of course, we will also need a testing procedure.  Since this is written as a literate program, our test procedure is: can we tangle ourself.  If the output of the tangler run on this file can tangle this file, then we know that the tangler works.
@@ -202,6 +255,8 @@ class Tangle
 
   ⦅tangle_class⦆
 
+  ⦅context_class⦆
+
   ⦅option_verification⦆
 
   description "⦅description⦆"
@@ -223,6 +278,7 @@ This is a basic template using the [Ruby methadone](https://github.com/davetron5
 The main body will first test itself then, invoke the library component, which isn't in lib as traditional because it is in this file and I don't want to move it around.
 
 ``` ruby main_body
+@dev = options[:dev]
 self_test()
 tangler = Tangle::Tangler.new(options[:file])
 tangler.tangle()
@@ -245,16 +301,11 @@ The tangler is defined within a class that contains the tangling implementation.
 
 ``` ruby tangle_class
 class Tangler
-  class << self
-    attr_reader :filters
-  end
-
-  @filters = ⦅filter_list⦆
-
   ⦅initializer⦆
   ⦅tangle⦆
   ⦅read_file⦆
   ⦅include_includes⦆
+  ⦅handle_extensions_and_conditionals⦆
   ⦅parse_blocks⦆
   ⦅expand_macros⦆
   ⦅apply_filters⦆
@@ -262,7 +313,12 @@ class Tangler
   ⦅write⦆
 
   private
+  def filters_map
+    @extension_context.filters
+  end
   ⦅tangle_class_privates⦆
+
+  ⦅conditional_processor⦆
 end
 ```
 
@@ -272,6 +328,8 @@ The initializer takes in the input file and sets up our state.  We are keeping t
 
 ``` ruby initializer
 def initialize(input)
+  @extension_context = Context.new()
+  @extension_context.filters = ⦅filter_list⦆
   @input = input
   @block = ""
   @blocks = {}
@@ -282,12 +340,13 @@ end
 
 ### Tangle
 
-Now we have the basic tangle process wherein a file is read, includes are substituted, the blocks extracted, macros expanded recursively, and escaped double parentheses unescaped.  If there is no default block, then there is no further work to be done.
+Now we have the basic tangle process wherein a file is read, includes are substituted, extensions and conditionals are processed, the blocks extracted, the extension hook called, macros expanded recursively, and escaped double parentheses unescaped.  If there is no default block, then there is no further work to be done.
 
 ``` ruby tangle
 def tangle()
-  contents = include_includes(read_file(@input))
-  @block, @blocks = parse_blocks(contents)
+  contents =  handle_extensions_and_conditionals(
+      include_includes(read_file(@input)))
+  @block, @blocks = @extension_context.parse_hook(*parse_blocks(contents))
   if @block
     @block = expand_macros(@block)
     @block = unescape_double_parens(@block)
@@ -335,6 +394,116 @@ end
 
 ```
 
+### Evaling the Extensions and Processing the Conditionals
+
+The extensions are executed within the following context.  This context is also
+used to evaluate conditionals.
+
+``` ruby context_class
+class Context
+  attr_accessor :filters
+
+  def get_binding
+    binding
+  end
+
+  def parse_hook(main_block, blocks)
+    [main_block, blocks]
+  end
+end
+
+```
+
+Because conditional processing must occur concurrently with bock evaling, we have to build up each block and eval it the moment it is complete.  To do so, we find all the lines that are not in an extension block.  When we enter a new extension block, we clear the current extension block, and when we leave an extension block, we eval it.
+
+``` ruby handle_extensions_and_conditionals
+def handle_extensions_and_conditionals(lines)
+  extension_expression = ⦅extension_expression⦆
+  condition_processor = ConditionalProcessor.new(@extension_context)
+  extension_exit_expression = /```/
+  in_extension_block = false
+  current_extension_block = []
+
+  other_lines = lines.lazy
+    .find_all do |line|
+      condition_processor.should_output(line)
+    end.find_all do |line|
+      unless in_extension_block
+        in_extension_block = line =~ extension_expression
+        if in_extension_block
+          current_extension_block = []
+        end
+        !in_extension_block
+      else
+        in_extension_block = !(line =~ extension_exit_expression)
+        if in_extension_block
+          current_extension_block << line
+        else
+          @extension_context.get_binding.eval(current_extension_block.join)
+        end
+        false
+      end
+    end.force
+
+  condition_processor.check_block_balance()
+
+  other_lines
+end
+
+```
+
+### Processing The Conditionals
+
+To process the conditionals, we need a stack.  Given that we are handling if, elsif, and else, we will need to track: 1) the type of statement (in case we want to add loops later), 2) the state before we encounter the if and, 3) if the else should be executed.  For if statements, we can store these in an array like `[type, prior_state, execute_else]`
+
+Since this process happens concurrently with evaling the included blocks, it's process is represented by a class.  Should_output is the inside of the filter statement which is used to filter the lines.
+
+``` ruby conditional_processor
+class ConditionalProcessor
+
+  def initialize(extension_context)
+    @if_expression = ⦅if_expression⦆
+    @elsif_expression = ⦅elsif_expression⦆
+    @else_expression = ⦅else_expression⦆
+    @end_expression = ⦅end_expression⦆
+    @output_enabled = true
+    @stack = []
+    @extension_context = extension_context
+  end
+
+  def should_output(line)
+    case line
+      when @if_expression
+        condition = $1
+        prior_state = @output_enabled
+        @output_enabled = !!@extension_context.get_binding.eval(condition)
+        @stack.push([:if, prior_state, !@output_enabled])
+      when @elsif_expression
+        throw "elsif statement missing if"  if @stack.empty?
+        condition = $1
+        type, prior_state, execute_else = @stack.pop()
+        @output_enabled = execute_else && !!@extension_context.get_binding.eval(condition)
+        @stack.push([type, prior_state, execute_else && !@output_enabled])
+      when @else_expression
+        throw "else statement missing if" if @stack.empty?
+        type, prior_state, execute_else = @stack.pop()
+        @output_enabled = execute_else
+        @stack.push([type, prior_state, execute_else])
+      when @end_expression
+        throw "end statement missing begin" if @stack.empty?
+        type, prior_state, execute_else = @stack.pop()
+        @output_enabled = prior_state
+    end
+    @output_enabled
+  end
+  
+  def check_block_balance
+    throw "unbalanced blocks" unless @stack.empty?
+  end
+end
+
+```
+
 ### Parsing The Blocks
 
 Now we get to the meat of the algorithm.  This uses the regular expression in [lmt_expressions](lmt_expressions.lmd#The-Code-Block-Expression)
@@ -534,14 +703,13 @@ Filters are applied by the following method:
 ``` ruby apply_filters
 def apply_filters(strings, filters)
   filters.map do |filter_name|
-    Tangler.filters[filter_name]
+    filters_map[filter_name]
   end.inject(strings) do |strings, filter|
     filter.filter(strings)
   end
 end
 ```
 
-
 ### Ruby Escape
 
 Ruby escape escapes strings appropriately for Ruby.  
@@ -552,6 +720,50 @@ LineFilter.new do |line|
 end
 ```
 
+### Double Quote
+
+Double quote surrounds strings in double quotes
+
+``` ruby double_quote
+LineFilter.new do |line|
+  before_white = /^\s*/.match(line)[0]
+  after_white = /\s*$/.match(line)[0]
+  "#{before_white}\"#{line.strip}\"#{after_white}"
+end
+```
+
+### Add Commas
+
+Add commas adds comma to the end of each line.
+
+``` ruby add_comma
+LineFilter.new do |line|
+  before_white = /^\s*/.match(line)[0]
+  after_white = /\s*$/.match(line)[0]
+  "#{before_white}#{line.strip},#{after_white}"
+end
+```
+
+### Indent continuation
+
+Adds two spaces to the front of each line after the first
+
+``` ruby indent_continuation
+Filter.new do |lines|
+  [lines[0], *lines[1..-1].map {|l| "  #{l}"}]
+end
+```
+
+### Indent Lines
+
+Adds two spaces to the front of each line
+
+``` ruby indent_lines
+LineFilter.new do |line|
+  "  #{line}"
+end
+```
+
 ## Option Verification
 
 Option verification is described here:
@@ -574,6 +786,8 @@ Then we need the tests we are doing.  The intentionally empty block is included
 ⦅test_filters⦆
 ⦅test_inclusion⦆
 ⦅intentionally_empty_block⦆
+⦅test_extensions⦆
+⦅test_conditional_output⦆
 ```
 
 ### Testing: Macros
@@ -612,9 +826,24 @@ foo
 
 At the [top of the file](Filters) we described the usage of filters.  Let's make sure that works.  The extra `.?` in the regular expression is a workaround for an editor bug in Visual Studio Code, where, apparently, `/\\/` escapes the `/` rather than the `\`.... annoying.
 
+``` text some_text
+some text
+```
+
+``` text a_list
+item 1
+item 2
+```
+
 ``` ruby test_filters
 ⦅filter_use_description⦆
 report_self_test_failure("ruby escape doesn't escape backslash") unless string_with_backslash =~ /\\.?/
+some_text = ⦅some_text | double_quote⦆
+report_self_test_failure("Double quote doesn't double quote") unless some_text == "⦅some_text⦆"
+some_indented_text = "⦅some_text | indent_lines⦆"
+report_self_test_failure("Indent lines should add two spaces to lines") unless some_indented_text == "  ⦅some_text⦆"
+items = [⦅a_list | double_quote | add_comma | indent_continuation⦆]
+report_self_test_failure("Add comma isn't adding commas") unless items == ["item 1", "item 2"]
 ```
 
 ### Testing: Inclusion
@@ -624,6 +853,135 @@ report_self_test_failure("ruby escape doesn't escape backslash") unless string_w
 report_self_test_failure("included replacements should replace blocks") unless included_string == "I came from lmt_include.lmd"
 ```
 
+### Testing: Extensions
+
+``` ruby test_extensions
+⦅from_extension⦆
+report_self_test_failure("extension hook should be able to add blocks") unless from_extension
+```
+
+### Testing: Conditional Output
+
+In the description, the if statement was to be executed.
+
+``` ruby test_conditional_output
+⦅conditional_output⦆
+report_self_test_failure("conditional output elseif should not be output when elseif is false") unless conditional_output_elsif
+report_self_test_failure("conditional output else should not be output when if true") unless conditional_output_else
+```
+
+#### If and elsif
+
+Neither the elsif or elsif statement are output when if is true.
+
+``` ruby test_conditional_output
+⦅conditional_output_if_and_elsif⦆
+report_self_test_failure("conditional output elsif should not be output even if true when is also true") unless conditional_output_elsif
+report_self_test_failure("conditional output else should not be output when if is true (if and elseif)") unless conditional_output_else
+```
+
+``` ruby !
+@a_variable = true
+@another_variable = true
+```
+
+! if @a_variable
+
+``` ruby conditional_output_if_and_elsif
+conditional_output_else = true
+conditional_output_elsif = true
+```
+
+! elsif @another_variable
+
+``` ruby conditional_output_if_and_elsif
+conditional_output_elsif = false
+```
+
+! else
+
+``` ruby conditional_output_if_and_elsif
+conditional_output_else = false
+```
+
+! end
+
+#### Elsif
+
+When the if is false but the elsif true, only the elsif is output.
+
+``` ruby test_conditional_output
+conditional_output_if = true
+⦅conditional_output_elsif⦆
+report_self_test_failure("conditional output if should not be output when false") unless conditional_output_if
+report_self_test_failure("conditional output elseif should be output when elseif is true") unless conditional_output_elsif
+report_self_test_failure("conditional output else should not be output when elseif is true") unless conditional_output_else
+```
+
+``` ruby !
+@a_variable = false
+@another_variable = true
+```
+
+! if @a_variable
+
+``` ruby conditional_output_elsif
+conditional_output_if = false
+```
+
+! elsif @another_variable
+
+``` ruby conditional_output_elsif
+conditional_output_else = true
+conditional_output_elsif = true
+```
+
+! else
+
+``` ruby conditional_output_elsif
+conditional_output_else = false
+```
+
+! end
+
+#### Else
+
+The else is output when none of the if or elsif statements are true.
+
+``` ruby test_conditional_output
+conditional_output_if = true
+conditional_output_elsif = true
+⦅conditional_output_else⦆
+report_self_test_failure("conditional output if should not be output when false") unless conditional_output_if
+report_self_test_failure("conditional output elseif should not be output when elseif is false") unless conditional_output_elsif
+report_self_test_failure("conditional output else should be output when neither if nor elseif is true") unless conditional_output_else
+```
+
+``` ruby !
+@a_variable = false
+@another_variable = false
+```
+
+! if @a_variable
+
+``` ruby conditional_output_else
+conditional_output_if = false
+```
+
+! elsif @another_variable
+
+``` ruby conditional_output_else
+conditional_output_elsif = false
+```
+
+! else
+
+``` ruby conditional_output_else
+conditional_output_else = true
+```
+
+! end
+
 ### Regressions
 
 Some regressions / edge cases that we need to watch for.  These should not break our tangle operation.