md_inc 0.2.9 → 0.3.0

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    md_inc (0.2.6)
+    md_inc (0.2.9)
 
 GEM
   remote: https://rubygems.org/

data/README.md

@@ -16,6 +16,11 @@ Or install it yourself as:
 
     $ gem install md_inc
 
+**Note that with version 0.3.0 the API for adding
+new commands has changed. You command methodss
+should be ordinary methods, not module methods
+as before.**
+
 ## Usage
 
 MdInc is a simple text inclusion filter intended for use
@@ -61,7 +66,22 @@ And you can exclude lines based on a regular expression:
     lines that contain DONTWANT
     .skip(/DONTWANT/, inc('file1'))
 
-As you can probably guess from this last example,
+Along with .commands there are also ..commands. The
+difference is that ..command can handle inline text.
+Here's an example that makes all the lines uppercase:
+
+    ..upcase_content
+    some text
+    that will
+    become uppercase
+    ..end
+
+If your command starts with an .., md\_inc will gather up
+all of the following lines until it hits a ..end and
+makes those lines available to the command via the
+`content` method.
+
+As you can probably guess from the examples,
 the MdInc dot commands are really just inline Ruby
 code that gets executed during file processing.
 Because of this it's easy to extend MdInc with

data/lib/md_inc/md_inc_commands.rb

@@ -1,6 +1,5 @@
 module MdInc
   module Commands
-    class << self
       def root(path)
         @root = path
       end
@@ -9,15 +8,64 @@ module MdInc
         @root ? File.join(@root, path) : path
       end
 
+      def content
+        @content
+      end
+
+      def process_file(file_name)
+        process(File.read(file_name))
+      end
+
       def process(content)
         output = process_lines(content.split("\n"))
         output.flatten.join("\n")
       end
 
       def process_lines(lines)
-        lines.map do |line|
-          (line.length > 1 && line[0] == '.') ? instance_eval(line[1..-1]) : line
+        result = []
+        until lines.empty?
+          line = lines.shift
+          ltype = line_type(line)
+
+          if ltype == :multi_line_cmd
+            result +=process_multiline_cmd(line, lines)
+          elsif ltype == :single_line_cmd
+            result << process_single_line_cmd(line)
+          else
+            result << line
+          end
         end
+        result
+      end
+
+      def line_type(line)
+        if %{. ..}.include?(line)
+          :text
+        elsif line[0,2] == '..'
+          :multi_line_cmd
+        elsif line[0,1] == '.'
+          :single_line_cmd
+        else
+          :text
+        end
+      end
+
+      def process_single_line_cmd(line)
+        #puts "single line cmd: #{line}"
+        instance_eval(line[1..-1])
+      end
+
+      def process_multiline_cmd(line, lines)
+        content_lines = []
+        until lines.empty? || (lines.first =~ /^..end/)
+          content_lines << lines.shift
+        end
+        lines.shift unless lines.empty?
+        save_content = @content
+        @content = content_lines
+        result = instance_eval(line[2..-1])
+        @content = @save_content
+        result
       end
 
       def x(*args)
@@ -42,7 +90,7 @@ module MdInc
         if language.nil?
           lines.map {|l| l.rstrip.prepend('    ')}
         else
-          ["```#{language}"] + lines + ["```"]          
+          ["```#{language}"] + lines + ["```"]
         end
       end
 
@@ -75,6 +123,10 @@ module MdInc
         lines.map {|l| l[min_indent..-1]}
       end
 
+      def upcase_content
+        content.map {|l| l.upcase}
+      end
+
       private
 
       def min_indent(lines)
@@ -85,6 +137,6 @@ module MdInc
       def indent_depth(s)
         /^ */.match(s).end(0)
       end
+
     end
-  end
 end

data/lib/md_inc/version.rb

@@ -1,3 +1,3 @@
 module MdInc
-  VERSION = "0.2.9"
+  VERSION = "0.3.0"
 end

data/lib/md_inc.rb

@@ -1,22 +1,32 @@
 require 'md_inc/version'
 require 'md_inc/md_inc_commands'
+require 'ostruct'
 
 module MdInc
   class TextProcessor
-    def root(path)
-      Commands.root(path)
+    attr_accessor :root
+
+    def initialize(options={})
+      @options = options
     end
 
     def process(string)
-      Commands.process(string)
+      context = OpenStruct.new(@options)
+      context.root = root
+      context.options = @options
+      context.extend Commands
+      if @options[:modules]
+        @options[:modules].each {|m| context.extend m}
+      end
+      context.process(string)
     end
 
     def process_stream(stream)
-      Commands.process(stream.read)
+      process(stream.read)
     end
 
     def process_file(path)
-      Commands.process(File.read(path))
+      process(File.read(path))
     end
   end
 end

data/spec/md_inc_spec.rb

@@ -2,14 +2,20 @@ require 'md_inc'
 require 'fileutils'
 
 describe MdInc::Commands do
+  let(:context) do
+    o = Object.new
+    o.extend MdInc::Commands
+    o
+  end
+
   context '#code' do
     it 'uses git style tagging if a language is supplied' do
-      output = MdInc::Commands.code("java", %w{foo})
+      output = context.code("java", %w{foo})
       output.should == [ "```java", "foo", "```"]
     end
 
     it 'uses traditional code indenting if a language is not supplied' do
-      output = MdInc::Commands.code(nil, %w{foo})
+      output = context.code(nil, %w{foo})
       output.should == [ "    foo"]
     end
   end
@@ -18,12 +24,12 @@ describe MdInc::Commands do
     let(:lines) { %w{foo skip1 skip2 bar skip3 baz skip4 skip5} }
 
     it 'skips the lines that match the regular expression' do
-      output = MdInc::Commands.skip(/skip/, lines)
+      output = context.skip(/skip/, lines)
       output.should == %w{foo bar baz}
     end
 
     it 'doesnt skip the lines that down match the regular expression' do
-      output = MdInc::Commands.skip(/no match/, lines)
+      output = context.skip(/no match/, lines)
       output.should == lines
     end
   end
@@ -32,12 +38,12 @@ describe MdInc::Commands do
     let(:lines) { %w{aaa bbb ccc ddd eee} }
 
     it 'returns the lines between the patterns, exclusive' do
-      output = MdInc::Commands.between(/aaa/, /ddd/, lines)
+      output = context.between(/aaa/, /ddd/, lines)
       output.should == %w{bbb ccc}
     end
 
     it 'will skip the whole output if first re doesnt match' do
-      output = MdInc::Commands.between(/no match/, /ccc/, lines)
+      output = context.between(/no match/, /ccc/, lines)
       output.should == []
     end
   end
@@ -45,24 +51,33 @@ describe MdInc::Commands do
   context '#normalize_indent' do
     it 'does nothing to non-indented lines' do
       lines = %w{aaa, bbb, ccc}
-      output = MdInc::Commands.normalize_indent(lines)
+      output = context.normalize_indent(lines)
       output.should == lines
     end
 
     it 'does nothing to lines with at least one non-indented line' do
       lines = ['  aaa', 'bbb', '         ccc']
-      output = MdInc::Commands.normalize_indent(lines)
+      output = context.normalize_indent(lines)
       output.should == lines
     end
 
     it 'unindents so that the least indented line has no indent' do
       lines = [' aaa', '  bbb', '   ccc']
-      output = MdInc::Commands.normalize_indent(lines)
+      output = context.normalize_indent(lines)
       output.should == ['aaa', ' bbb', '  ccc']
     end
 
   end
+end
+
+module TestModule
+  def test_cmd
+    ['line 1 from module', 'line 2 from module']
+  end
 
+  def return_option(name)
+    [options[name]]
+  end
 end
 
 describe MdInc::TextProcessor do
@@ -141,7 +156,39 @@ describe MdInc::TextProcessor do
     it 'can do recursive inclusion' do
       text = "first\n.inc 'temp3'\nlast"
       output = mdi.process(text)
-      output.should == "first\ntemp3 line1\naaa\nbbb\ntemp3 line3\nlast"      
+      output.should == "first\ntemp3 line1\naaa\nbbb\ntemp3 line3\nlast"
+    end
+
+    it 'can optionally include other modules for commands' do
+      processor = MdInc::TextProcessor.new :modules => [TestModule]
+      text = "first\n.test_cmd\nlast"
+      output = processor.process(text)
+      output.should == "first\nline 1 from module\nline 2 from module\nlast"
+    end
+
+    it 'can asscess the options hash from inside of a command' do
+      processor = MdInc::TextProcessor.new :modules => [TestModule], :color => "GREEN"
+      text = "first\n.return_option :color\nlast"
+      output = processor.process(text)
+      output.should == "first\nGREEN\nlast"
+    end
+
+    it 'has a working multiline example command in upcase_content' do
+      text = "first\n..upcase_content\naaa\nbbb\nccc\n..end\nlast"
+      output = mdi.process(text)
+      output.should == "first\nAAA\nBBB\nCCC\nlast"
+    end
+
+    it 'handles multiline commands correctly' do
+      text = ".x require 'new_commands'\nfirst\n..multi_up\naaa\nbbb\n..end\nccc"
+      output = mdi.process(text)
+      output.should == "first\nAAA\nBBB\nccc"
+    end
+
+    it 'handles .. as text, not as a multiline command' do
+      text = "\nfirst\n..\nlast"
+      output = mdi.process(text)
+      output.should == text
     end
   end
 end

data/spec/new_commands.rb

@@ -4,8 +4,12 @@
 # module and off you go.
 module MdInc
   module Commands
-    def self.inc_up(path)
+    def inc_up(path)
       inc(path).map {|s| s.upcase!}
     end
+
+    def multi_up
+      content.map {|l| l.upcase}
+    end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: md_inc
 version: !ruby/object:Gem::Version
-  version: 0.2.9
+  version: 0.3.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-03-11 00:00:00.000000000 Z
+date: 2013-03-16 00:00:00.000000000 Z
 dependencies: []
 description: MdInc is a simple text inclusion utility (it sucks in files) intended
   for use with markdown and similar utilities.