lmt 0.1.3 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 20c0cdd948065ea59b76df0f83bd7abd0d7df99a55a8532a1a7368d3e6e46924
-  data.tar.gz: baff975ca361ba930e73a815283f824fb4f5d913a9f54b303a64ee0622be6b3a
+  metadata.gz: f420500a15df99a0e4ff1a102d69775f9ae1a12397480c4f49ba25953996596b
+  data.tar.gz: 9116d831ae2234dbda149f308b0c69950cb4f547e2bff43188493d965610a676
 SHA512:
-  metadata.gz: 2c415acb8d48be392624f7b64648b9873490cb6282e4f90969a63290e8aa13a4ee6c7cb6a03a05cc177339a3b917a66be894724621d65d1bd80018ddc2e49f6c
-  data.tar.gz: dec0d39c012cfa8c3f57955744a0cf9909c2f755c36ed0e893abdf684b20ebdd224bdbbd6c988129b9727c31947cabf5cf4fe468b64a7683efe1539e6349eb1e
+  metadata.gz: 37820ae837377fad18ea955dbdae4eac3c47e964da15fade0171573011761d84bf70b147e3eaf0a897fd957d12c316ea1c01a6bdf7302339b63c2651e28da703
+  data.tar.gz: 9aa7d8d3ab733f9263d0c116930d1e979c2b664002dde544de0e3a36bc4b3841f67d5897d09e8c9fbd7bc90efd52caa2f3cbb2b96ed89b9fb8b4224d21d5f8fc

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    lmt (0.1.3)
+    lmt (0.1.4)
       methadone (~> 1.9.5)
 
 GEM

data/README.md

@@ -29,13 +29,13 @@ Or install it yourself as:
 The tangle program takes input files and produces tangled output files.  It is used as follows:
 
 ``` bash
-lmt --file {input file} --output {tangled destination}
+lmt --file {input file} --output {tangled destination} --include-path {comma separated list of include paths}
 ```
 
 The weave program is similar but produces weaved output files.  It does not recurse down include statements, and so will need to be run independently for each included file.  An example usage:
 
 ``` bash
-lmw --file {input file} --output [weaved destination]
+lmw --file {input file} --output [weaved destination] --include-path {comma separated list of include paths}
 ```
 
 ## Development
@@ -53,10 +53,10 @@ bundle exec ruby bin/lmt --file src/lmt/lmt.rb.lmd --output lib/lmt/lmt.rb
 To test the weave you can use the following command which will weave the weaver and write it to the doc directory.
 
 ``` bash
-bundle exec ruby bin/lmt --file src/lmt/lmt.rb.lmd --output lib/lmt/lmt.rb; bundle exec ruby bin/lmw --file src/lmt/lmw.rb.lmd --output doc/lmt/lmw.rb.md
+bundle exec ruby bin/lmt --file src/lmt/lmw.rb.lmd --output lib/lmt/lmw.rb; bundle exec ruby bin/lmw --file src/lmt/lmw.rb.lmd --output doc/lmt/lmw.rb.md
 ```
 
-Since this is a self-bootstraping program, it is both tested and built by running itself on itself.  This means that if you add a bug, it won't run.  To fix this, check out the most recent version of the output file out of git.
+Since this is a self-bootstraping program, it is both tested and built by running itself on itself.  This means that if you add a bug, it won't run.  To fix this, check out the most recent version of the output file out of git.  To avoid lost work, it is recommended you commit especially often.
 
 ``` bash
 git co -- src/lmt/lmt.rb

data/doc/lmt/{lmt_expressions.md → include/lmt_expressions.md}

@@ -12,6 +12,16 @@ The first regular expression handles the detection of include directives.  It re
 /^!\s+include\s+\[.*\]\((.*)\)\s*$/
 ```
 
+## The Include Path Expression
+
+This regular expression handles the detection of include-path directives.  It recognizes lines like `! include-path some-path`  and extracts `some-path`.
+
+###### Code Block: Include Path Expression
+
+``` ruby
+/^!\s+include-path\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..

data/doc/lmt/include/lmt_include_path.md

@@ -0,0 +1,28 @@
+# Include Path
+
+This is the basic algorithm to look up an include on the include path.  If the file exists relative to the current file, it includes it.  If, not, it goes through the include path looking for the file.  When it finds it, it also calculates a relative path for the file from the current file.
+
+###### Code Block: Includes
+
+``` ruby
+require 'pathname'
+```
+
+###### Code Block: Resolve Include
+
+``` ruby
+def resolve_include(file, current_file)
+  include_file_loc = File.join(File.dirname(current_file), file)
+  if File.exist?(include_file_loc)
+    return [include_file_loc, file]
+  end
+  @include_path.each do |include_dir|
+    include_file_loc = File.join(include_dir, file)
+    if File.exist? (include_file_loc)
+      relative_path = Pathname.new(include_file_loc).relative_path_from(File.dirname(current_file)).to_s
+      return [include_file_loc, relative_path]
+    end
+  end
+  throw "include file: #{file} not found from #{current_file} or in #{@include_path}"
+end
+```

data/doc/lmt/lmt.rb.md

@@ -156,7 +156,7 @@ During tangle the link line will be replaced with the lines from the included fi
 included_string = "I am in lmt.lmd"
 ```
 
-**See include:** [lmt_include.lmd](include_file)
+**See include:** [included file](include/lmt_include.md)
 
 ### Extension
 
@@ -173,6 +173,14 @@ def parse_hook(main_block, blocks)
 end
 ```
 
+### Include Path
+
+It is possible to add directories to the include path using the `! include-path` directive like so:
+
+! include-path include
+
+The contents of that directive will be added to the include path.
+
 ### 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.
@@ -238,6 +246,7 @@ We need to know where to get the input from and where to send the output to.  Fo
 ``` ruby
 on("--file FILE", "-f", "Required: input file")
 on("--output FILE", "-o", "Required: output file")
+on("--include-path DIRECTORY,DIRECTORY", "-i", Array, "Include path")
 on("--dev", "disables self test failure for development")
 ```
 
@@ -324,7 +333,8 @@ The main body will first test itself then, invoke the library component, which i
 ``` ruby
 @dev = options[:dev]
 self_test()
-tangler = Tangle::Tangler.new(options[:file])
+include_path = (options[:"include-path"] or [])
+tangler = Tangle::Tangler.new(options[:file], include_path)
 tangler.tangle()
 tangler.write(options[:output])
 ```
@@ -366,6 +376,8 @@ class Tangler
   end
   ⦅tangle_class_privates⦆
 
+  ⦅resolve_include⦆
+
   ⦅conditional_processor⦆
 end
 ```
@@ -377,7 +389,8 @@ The initializer takes in the input file and sets up our state.  We are keeping t
 ###### Code Block: Initializer
 
 ``` ruby
-def initialize(input)
+def initialize(input, include_path = [])
+  @include_path = include_path
   @extension_context = Context.new()
   @extension_context.filters = ⦅filter_list⦆
   @input = input
@@ -427,20 +440,32 @@ end
 
 As our specification is a regular language (we do not support any kind of nesting), we will be using regular expressions to process it.  Those expressions are detailed in:
 
-**See include:** [lmt_expressions.lmd](include_file)
+**See include:** [included file](include/lmt_expressions.md)
+
+To resolve include paths we need:
+
+**See include:** [included file](include/lmt_include_path.md)
 
 Here we go through each line looking for an include statement.  When we find one, we replace it with the lines from that file.  Those lines will, of course, need to have includes processed as well.
 
+When we encounter an include-path directive, it needs to be added to the include path.
+
 ###### Code Block: Include Includes
 
 ``` ruby
 def include_includes(lines, current_file = @input, depth = 0)
   raise "too many includes" if depth > 1000
   include_exp = ⦅include_expression⦆
+  include_path_exp = ⦅include_path_expression⦆
   lines.map do |line|
-    match = include_exp.match(line)
-    if match
-      file = File.dirname(current_file) + '/' + match[1]
+    include_path_match = include_path_exp.match(line)
+    include_match = include_exp.match(line)
+    if include_path_match
+      path = resolve_include(include_path_match[1], current_file)[0]
+      @include_path << path
+      [line]
+    elsif include_match
+      file = resolve_include(include_match[1], current_file)[0]
       include_includes(read_file(file), file, depth + 1)
     else
       [line]
@@ -864,7 +889,7 @@ end
 
 Option verification is described here:
 
-**See include:** [option_verification.lmd](include_file)
+**See include:** [included file](include/option_verification.md)
 
 ## Self Test, Details
 
@@ -872,7 +897,7 @@ So, now we need to go into details of our self test and also include regressions
 
 First, we need a method to report test failures:
 
-**See include:** [error_reporting.lmd](include_file)
+**See include:** [included file](include/error_reporting.md)
 
 Then we need the tests we are doing.  The intentionally empty block is included both at the beginning and end to make sure that we handled all the edge cases related to empty blocks appropriately.
 

data/doc/lmt/lmw.rb.md

@@ -35,6 +35,7 @@ We need to know where to get the input from and where to send the output to.  Fo
 ``` ruby
 on("--file FILE", "-f", "Required: input file")
 on("--output FILE", "-o", "Required: output file")
+on("--include-path DIRECTORY,DIRECTORY", "-i", Array, "Include path")
 on("--dev", "disables self test failure for development")
 ```
 
@@ -115,12 +116,13 @@ The main body will first test itself then, invoke the library component, which i
 
 ``` ruby
 self_test()
-weave = Lmw::Weave.from_file(options[:file])
+include_path = (options[:"include-path"] or [])
+weave = Lmw::Weave.from_file(options[:file], include_path)
 weave.weave()
 weave.write(options[:output])
 ```
 
-Finally, we have the dependencies.  Optparse and methadone are used for cli argument handling and other niceties.
+We have the dependencies.  Optparse and methadone are used for cli argument handling and other niceties.
 
 ###### Code Block: Includes
 
@@ -131,6 +133,10 @@ require 'methadone'
 require 'pry'
 ```
 
+Finally, The include files are located in
+
+! include-path include
+
 There, now we are done with the boilerplate. On to:
 
 ## The Actual Weaver
@@ -151,17 +157,10 @@ class Weave
 
   private
   ⦅weave_class_privates⦆
+  ⦅resolve_include⦆
 end
 ```
 
-There may be some private methods, we need a block for them.  They will be inserted where needed.
-
-###### Code Block: Weave Class Privates
-
-``` ruby
-⦅include_includes⦆
-```
-
 ### Initializer
 
 The initializer takes the input file and sets up our state.  
@@ -169,7 +168,8 @@ The initializer takes the input file and sets up our state.
 ###### Code Block: Initializer
 
 ``` ruby
-def initialize(lines, file_name = "")
+def initialize(lines, file_name = "", include_path = [])
+  @include_path = include_path
   @file_name = file_name
   @lines = lines
   @weaved = false
@@ -187,9 +187,9 @@ This is fairly self explanatory, though note, we are storing the file in memory
 ###### Code Block: From File
 
 ``` ruby
-def from_file(file)
+def from_file(file, include_path = [])
   File.open(file, 'r') do |f|
-    Weave.new(f.readlines, file)
+    Weave.new(f.readlines, file, include_path)
   end
 end
 
@@ -216,7 +216,7 @@ end
 
 In order to find the blocks we will need the regular expressions defined in:
 
-**See include:** [lmt_expressions.lmd](include_file)
+**See include:** [included file](include/lmt_expressions.md)
 
 First, we get the lines from includes.  then we filter the lines for only the headers and footers and check for unmatched headers and footers.
 
@@ -263,19 +263,28 @@ end
 
 This depends on the expression in [lmt_expressions][lmt_expressions.md#The-Include-Expression]
 
+To resolve include paths we need:
+
+**See include:** [included file](include/lmt_include_path.md)
+
 Here we go through each line looking for an include statement.  When we find one, we replace it with the lines from that file.  Those lines will, of course, need to have includes processed as well.  For each line, we also need to add the file that it came from.
 
-###### Code Block: Include Includes
+###### Code Block: Weave Class Privates
 
 ``` ruby
 def include_includes(lines, current_file = @file_name, current_path = '', depth = 0)
   raise "too many includes" if depth > 1000
   include_exp = ⦅include_expression⦆
+  include_path_exp = ⦅include_path_expression⦆
   lines.map do |line|
-    match = include_exp.match(line)
-    if match
-      file = File.dirname(current_file) + '/' + match[1]
-      path = File.dirname(current_path) + '/' + match[1]
+    include_path_match = include_path_exp.match(line)
+    include_match = include_exp.match(line)
+    if include_path_match
+      path = resolve_include(include_path_match[1], current_file)[0]
+      @include_path << path
+      [[line,current_path]]
+    elsif include_match
+      file, path = resolve_include(include_match[1], current_file)
       new_lines = File.open(file, 'r') {|f| f.readlines}
       include_includes(new_lines, file, path, depth + 1)
     else
@@ -305,7 +314,8 @@ def substitute_directives_and_headers(lines)
     case line
     when include_expression
       include_file = $1
-      ["**See include:** [#{include_file}](include_file)\n"]
+      include_path = resolve_include(include_file, @file_name)[1]
+      ["**See include:** [included file](#{include_path.gsub(/\.lmd/, ".md")})\n"]
     when code_block_expression
       in_block = !in_block
       if in_block
@@ -379,7 +389,7 @@ end
 
 Option verification is described here:
 
-**See include:** [option_verification.lmd](include_file)
+**See include:** [included file](include/option_verification.md)
 
 ## Testing
 
@@ -387,7 +397,7 @@ Of course, we will also need a testing procedure.  In this case, we will be pass
 
 First, we need a method to report test failures:
 
-**See include:** [error_reporting.lmd](include_file)
+**See include:** [included file](include/error_reporting.md)
 
 ###### Code Block: Self Test
 

data/lib/lmt/lmt.rb

@@ -4,6 +4,7 @@
 require 'optparse'
 require 'methadone'
 require 'lmt/version'
+require 'pathname'
 
 module Lmt
 
@@ -18,7 +19,8 @@ class Tangle
     begin
       @dev = options[:dev]
       self_test()
-      tangler = Tangle::Tangler.new(options[:file])
+      include_path = (options[:"include-path"] or [])
+      tangler = Tangle::Tangler.new(options[:file], include_path)
       tangler.tangle()
       tangler.write(options[:output])
     rescue Exception => e
@@ -120,7 +122,8 @@ class Tangle
   end
 
   class Tangler
-    def initialize(input)
+    def initialize(input, include_path = [])
+      @include_path = include_path
       @extension_context = Context.new()
       @extension_context.filters = {
         'ruby_escape' => LineFilter.new do |line|
@@ -169,10 +172,16 @@ class Tangle
     def include_includes(lines, current_file = @input, depth = 0)
       raise "too many includes" if depth > 1000
       include_exp = /^!\s+include\s+\[.*\]\((.*)\)\s*$/
+      include_path_exp = /^!\s+include-path\s+(.*)\s*$/
       lines.map do |line|
-        match = include_exp.match(line)
-        if match
-          file = File.dirname(current_file) + '/' + match[1]
+        include_path_match = include_path_exp.match(line)
+        include_match = include_exp.match(line)
+        if include_path_match
+          path = resolve_include(include_path_match[1], current_file)[0]
+          @include_path << path
+          [line]
+        elsif include_match
+          file = resolve_include(include_match[1], current_file)[0]
           include_includes(read_file(file), file, depth + 1)
         else
           [line]
@@ -327,6 +336,21 @@ class Tangle
           end
     end
   
+    def resolve_include(file, current_file)
+      include_file_loc = File.join(File.dirname(current_file), file)
+      if File.exist?(include_file_loc)
+        return [include_file_loc, file]
+      end
+      @include_path.each do |include_dir|
+        include_file_loc = File.join(include_dir, file)
+        if File.exist? (include_file_loc)
+          relative_path = Pathname.new(include_file_loc).relative_path_from(File.dirname(current_file)).to_s
+          return [include_file_loc, relative_path]
+        end
+      end
+      throw "include file: #{file} not found from #{current_file} or in #{@include_path}"
+    end
+  
     class ConditionalProcessor
     
       def initialize(extension_context)
@@ -401,6 +425,7 @@ class Tangle
   description "A literate Markdown tangle tool written in Ruby."
   on("--file FILE", "-f", "Required: input file")
   on("--output FILE", "-o", "Required: output file")
+  on("--include-path DIRECTORY,DIRECTORY", "-i", Array, "Include path")
   on("--dev", "disables self test failure for development")
   required(:file, :output)
 

data/lib/lmt/lmw.rb

@@ -5,6 +5,7 @@ require 'optparse'
 require 'methadone'
 
 require 'pry'
+require 'pathname'
 
 module Lmt
 
@@ -18,7 +19,8 @@ class Lmw
     check_arguments()
     begin
       self_test()
-      weave = Lmw::Weave.from_file(options[:file])
+      include_path = (options[:"include-path"] or [])
+      weave = Lmw::Weave.from_file(options[:file], include_path)
       weave.weave()
       weave.write(options[:output])
     rescue Exception => e
@@ -50,15 +52,16 @@ class Lmw
 
   class Weave
     class << self
-      def from_file(file)
+      def from_file(file, include_path = [])
         File.open(file, 'r') do |f|
-          Weave.new(f.readlines, file)
+          Weave.new(f.readlines, file, include_path)
         end
       end
       
     end
   
-    def initialize(lines, file_name = "")
+    def initialize(lines, file_name = "", include_path = [])
+      @include_path = include_path
       @file_name = file_name
       @lines = lines
       @weaved = false
@@ -79,22 +82,6 @@ class Lmw
     
   
     private
-    def include_includes(lines, current_file = @file_name, current_path = '', depth = 0)
-      raise "too many includes" if depth > 1000
-      include_exp = /^!\s+include\s+\[.*\]\((.*)\)\s*$/
-      lines.map do |line|
-        match = include_exp.match(line)
-        if match
-          file = File.dirname(current_file) + '/' + match[1]
-          path = File.dirname(current_path) + '/' + match[1]
-          new_lines = File.open(file, 'r') {|f| f.readlines}
-          include_includes(new_lines, file, path, depth + 1)
-        else
-          [[line, current_path]]
-        end
-      end.flatten(1)
-    end
-    
     def find_blocks(lines)
       lines_with_includes = include_includes(lines)
       code_block_exp = /^(\s*)``` ?([\w]*) ?(=?)([-\w]*)?/
@@ -120,6 +107,27 @@ class Lmw
             {:count => count, :block_locations => block_locations}
           end
     end
+    def include_includes(lines, current_file = @file_name, current_path = '', depth = 0)
+      raise "too many includes" if depth > 1000
+      include_exp = /^!\s+include\s+\[.*\]\((.*)\)\s*$/
+      include_path_exp = /^!\s+include-path\s+(.*)\s*$/
+      lines.map do |line|
+        include_path_match = include_path_exp.match(line)
+        include_match = include_exp.match(line)
+        if include_path_match
+          path = resolve_include(include_path_match[1], current_file)[0]
+          @include_path << path
+          [[line,current_path]]
+        elsif include_match
+          file, path = resolve_include(include_match[1], current_file)
+          new_lines = File.open(file, 'r') {|f| f.readlines}
+          include_includes(new_lines, file, path, depth + 1)
+        else
+          [[line, current_path]]
+        end
+      end.flatten(1)
+    end
+    
     def substitute_directives_and_headers(lines)
       include_expression = /^!\s+include\s+\[.*\]\((.*)\)\s*$/
       code_block_expression = /^(\s*)``` ?([\w]*) ?(=?)([-\w]*)?/
@@ -130,7 +138,8 @@ class Lmw
         case line
         when include_expression
           include_file = $1
-          ["**See include:** [#{include_file}](include_file)\n"]
+          include_path = resolve_include(include_file, @file_name)[1]
+          ["**See include:** [included file](#{include_path.gsub(/\.lmd/, ".md")})\n"]
         when code_block_expression
           in_block = !in_block
           if in_block
@@ -166,6 +175,20 @@ class Lmw
     def replace_markdown_links(line)
       line
     end
+    def resolve_include(file, current_file)
+      include_file_loc = File.join(File.dirname(current_file), file)
+      if File.exist?(include_file_loc)
+        return [include_file_loc, file]
+      end
+      @include_path.each do |include_dir|
+        include_file_loc = File.join(include_dir, file)
+        if File.exist? (include_file_loc)
+          relative_path = Pathname.new(include_file_loc).relative_path_from(File.dirname(current_file)).to_s
+          return [include_file_loc, relative_path]
+        end
+      end
+      throw "include file: #{file} not found from #{current_file} or in #{@include_path}"
+    end
   end
 
   def self.required(*options)
@@ -184,6 +207,7 @@ class Lmw
   description "A literate Markdown weave tool written in Ruby."
   on("--file FILE", "-f", "Required: input file")
   on("--output FILE", "-o", "Required: output file")
+  on("--include-path DIRECTORY,DIRECTORY", "-i", Array, "Include path")
   on("--dev", "disables self test failure for development")
   required(:file, :output)
 

data/lib/lmt/version.rb

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

data/src/lmt/{lmt_expressions.lmd → include/lmt_expressions.lmd}

@@ -10,6 +10,14 @@ The first regular expression handles the detection of include directives.  It re
 /^!\s+include\s+\[.*\]\((.*)\)\s*$/
 ```
 
+## The Include Path Expression
+
+This regular expression handles the detection of include-path directives.  It recognizes lines like `! include-path some-path`  and extracts `some-path`.
+
+``` ruby include_path_expression
+/^!\s+include-path\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..

data/src/lmt/include/lmt_include_path.lmd

@@ -0,0 +1,24 @@
+# Include Path
+
+This is the basic algorithm to look up an include on the include path.  If the file exists relative to the current file, it includes it.  If, not, it goes through the include path looking for the file.  When it finds it, it also calculates a relative path for the file from the current file.
+
+``` ruby includes
+require 'pathname'
+```
+
+``` ruby resolve_include
+def resolve_include(file, current_file)
+  include_file_loc = File.join(File.dirname(current_file), file)
+  if File.exist?(include_file_loc)
+    return [include_file_loc, file]
+  end
+  @include_path.each do |include_dir|
+    include_file_loc = File.join(include_dir, file)
+    if File.exist? (include_file_loc)
+      relative_path = Pathname.new(include_file_loc).relative_path_from(File.dirname(current_file)).to_s
+      return [include_file_loc, relative_path]
+    end
+  end
+  throw "include file: #{file} not found from #{current_file} or in #{@include_path}"
+end
+```

data/src/lmt/lmt.rb.lmd

@@ -132,7 +132,7 @@ During tangle the link line will be replaced with the lines from the included fi
 included_string = "I am in lmt.lmd"
 ```
 
-! include [an include](lmt_include.lmd)
+! include [an include](include/lmt_include.lmd)
 
 ### Extension
 
@@ -147,6 +147,14 @@ def parse_hook(main_block, blocks)
 end
 ```
 
+### Include Path
+
+It is possible to add directories to the include path using the `! include-path` directive like so:
+
+! include-path include
+
+The contents of that directive will be added to the include path.
+
 ### 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.
@@ -200,6 +208,7 @@ We need to know where to get the input from and where to send the output to.  Fo
 ``` ruby options
 on("--file FILE", "-f", "Required: input file")
 on("--output FILE", "-o", "Required: output file")
+on("--include-path DIRECTORY,DIRECTORY", "-i", Array, "Include path")
 on("--dev", "disables self test failure for development")
 ```
 
@@ -280,7 +289,8 @@ The main body will first test itself then, invoke the library component, which i
 ``` ruby main_body
 @dev = options[:dev]
 self_test()
-tangler = Tangle::Tangler.new(options[:file])
+include_path = (options[:"include-path"] or [])
+tangler = Tangle::Tangler.new(options[:file], include_path)
 tangler.tangle()
 tangler.write(options[:output])
 ```
@@ -318,6 +328,8 @@ class Tangler
   end
   ⦅tangle_class_privates⦆
 
+  ⦅resolve_include⦆
+
   ⦅conditional_processor⦆
 end
 ```
@@ -327,7 +339,8 @@ end
 The initializer takes in the input file and sets up our state.  We are keeping the unnamed top level block separate from the rest.  Then we have a hash of blocks.  Finally, we need to make sure we have tangled before we write the output.
 
 ``` ruby initializer
-def initialize(input)
+def initialize(input, include_path = [])
+  @include_path = include_path
   @extension_context = Context.new()
   @extension_context.filters = ⦅filter_list⦆
   @input = input
@@ -375,16 +388,28 @@ As our specification is a regular language (we do not support any kind of nestin
 
 ! include [here](lmt_expressions.lmd)  
 
+To resolve include paths we need:
+
+! include [this](lmt_include_path.lmd)
+
 Here we go through each line looking for an include statement.  When we find one, we replace it with the lines from that file.  Those lines will, of course, need to have includes processed as well.
 
+When we encounter an include-path directive, it needs to be added to the include path.
+
 ``` ruby include_includes
 def include_includes(lines, current_file = @input, depth = 0)
   raise "too many includes" if depth > 1000
   include_exp = ⦅include_expression⦆
+  include_path_exp = ⦅include_path_expression⦆
   lines.map do |line|
-    match = include_exp.match(line)
-    if match
-      file = File.dirname(current_file) + '/' + match[1]
+    include_path_match = include_path_exp.match(line)
+    include_match = include_exp.match(line)
+    if include_path_match
+      path = resolve_include(include_path_match[1], current_file)[0]
+      @include_path << path
+      [line]
+    elsif include_match
+      file = resolve_include(include_match[1], current_file)[0]
       include_includes(read_file(file), file, depth + 1)
     else
       [line]

data/src/lmt/lmw.rb.lmd

@@ -31,6 +31,7 @@ We need to know where to get the input from and where to send the output to.  Fo
 ``` ruby options
 on("--file FILE", "-f", "Required: input file")
 on("--output FILE", "-o", "Required: output file")
+on("--include-path DIRECTORY,DIRECTORY", "-i", Array, "Include path")
 on("--dev", "disables self test failure for development")
 ```
 
@@ -105,12 +106,13 @@ The main body will first test itself then, invoke the library component, which i
 
 ``` ruby main_body
 self_test()
-weave = Lmw::Weave.from_file(options[:file])
+include_path = (options[:"include-path"] or [])
+weave = Lmw::Weave.from_file(options[:file], include_path)
 weave.weave()
 weave.write(options[:output])
 ```
 
-Finally, we have the dependencies.  Optparse and methadone are used for cli argument handling and other niceties.
+We have the dependencies.  Optparse and methadone are used for cli argument handling and other niceties.
 
 ``` ruby includes
 require 'optparse'
@@ -119,6 +121,10 @@ require 'methadone'
 require 'pry'
 ```
 
+Finally, The include files are located in
+
+! include-path include
+
 There, now we are done with the boilerplate. On to:
 
 ## The Actual Weaver
@@ -137,21 +143,17 @@ class Weave
 
   private
   ⦅weave_class_privates⦆
+  ⦅resolve_include⦆
 end
 ```
 
-There may be some private methods, we need a block for them.  They will be inserted where needed.
-
-``` ruby weave_class_privates
-⦅include_includes⦆
-```
-
 ### Initializer
 
 The initializer takes the input file and sets up our state.  
 
 ``` ruby initializer
-def initialize(lines, file_name = "")
+def initialize(lines, file_name = "", include_path = [])
+  @include_path = include_path
   @file_name = file_name
   @lines = lines
   @weaved = false
@@ -167,9 +169,9 @@ For testing, we want to be able to create an instance with a hard coded set of l
 This is fairly self explanatory, though note, we are storing the file in memory as an array of lines.
 
 ``` ruby from_file
-def from_file(file)
+def from_file(file, include_path = [])
   File.open(file, 'r') do |f|
-    Weave.new(f.readlines, file)
+    Weave.new(f.readlines, file, include_path)
   end
 end
 
@@ -237,17 +239,26 @@ end
 
 This depends on the expression in [lmt_expressions][lmt_expressions.md#The-Include-Expression]
 
+To resolve include paths we need:
+
+! include [this](include/lmt_include_path.lmd)
+
 Here we go through each line looking for an include statement.  When we find one, we replace it with the lines from that file.  Those lines will, of course, need to have includes processed as well.  For each line, we also need to add the file that it came from.
 
-``` ruby include_includes
+``` ruby weave_class_privates
 def include_includes(lines, current_file = @file_name, current_path = '', depth = 0)
   raise "too many includes" if depth > 1000
   include_exp = ⦅include_expression⦆
+  include_path_exp = ⦅include_path_expression⦆
   lines.map do |line|
-    match = include_exp.match(line)
-    if match
-      file = File.dirname(current_file) + '/' + match[1]
-      path = File.dirname(current_path) + '/' + match[1]
+    include_path_match = include_path_exp.match(line)
+    include_match = include_exp.match(line)
+    if include_path_match
+      path = resolve_include(include_path_match[1], current_file)[0]
+      @include_path << path
+      [[line,current_path]]
+    elsif include_match
+      file, path = resolve_include(include_match[1], current_file)
       new_lines = File.open(file, 'r') {|f| f.readlines}
       include_includes(new_lines, file, path, depth + 1)
     else
@@ -275,7 +286,8 @@ def substitute_directives_and_headers(lines)
     case line
     when include_expression
       include_file = $1
-      ["**See include:** [#{include_file}](include_file)\n"]
+      include_path = resolve_include(include_file, @file_name)[1]
+      ["**See include:** [included file](#{include_path.gsub(/\.lmd/, ".md")})\n"]
     when code_block_expression
       in_block = !in_block
       if in_block

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lmt
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.1.4
 platform: ruby
 authors:
 - Marty Gentillon
@@ -113,23 +113,25 @@ files:
 - bin/lmt
 - bin/lmw
 - bin/setup
-- doc/lmt/error_reporting.md
+- doc/lmt/include/error_reporting.md
+- doc/lmt/include/lmt_expressions.md
+- doc/lmt/include/lmt_include.md
+- doc/lmt/include/lmt_include_path.md
+- doc/lmt/include/option_verification.md
 - doc/lmt/lmt.rb.md
-- doc/lmt/lmt_expressions.md
-- doc/lmt/lmt_include.md
 - doc/lmt/lmw.rb.md
-- doc/lmt/option_verification.md
 - lib/lmt.rb
 - lib/lmt/lmt.rb
 - lib/lmt/lmw.rb
 - lib/lmt/version.rb
 - lmt.gemspec
-- src/lmt/error_reporting.lmd
+- src/lmt/include/error_reporting.lmd
+- src/lmt/include/lmt_expressions.lmd
+- src/lmt/include/lmt_include.lmd
+- src/lmt/include/lmt_include_path.lmd
+- src/lmt/include/option_verification.lmd
 - src/lmt/lmt.rb.lmd
-- src/lmt/lmt_expressions.lmd
-- src/lmt/lmt_include.lmd
 - src/lmt/lmw.rb.lmd
-- src/lmt/option_verification.lmd
 homepage: https://github.com/MartyGentillon/lmt-ruby
 licenses:
 - MIT