legal_markdown 0.1.1 → 0.1.2

data/Gemfile

@@ -2,5 +2,4 @@ source 'https://rubygems.org'
 
 # Specify your gem's dependencies in legal_markdown.gemspec
 gemspec
-
 gem "rake"

data/README.md

@@ -88,8 +88,10 @@ Then you can describe the functionality that you require in the YAML front-matte
     4. `level-1: (A)` will format the same as the above only with the capital letters in a parentetical;
     5. `level-1: a.` will format with lowercase letters followed by a period;
     6. `level-1: (a)` will format with lowercase letters within a parentethical;
-    7. `level-1: I.` will format with Roman numerals followed by a period;
-    8. `level-1: (I)` will format with Roman numerals within a parententical.
+    7. `level-1: I.` will format with capital Roman numerals followed by a period;
+    8. `level-1: (I)` will format with capital Roman numerals within a parententical;
+    9. `level-1: i.` will format with lowercase Roman numerals followed by a period;
+    10. `level-1: (i)` will format with lowercase Roman numerals within a parententical..
 
 Obviously you will replace `level-1` with `level-2`, etc. Although this functionality was built into the gem, it is generally not the best practice. A better practice is to let the gem make the replacements and reformat the markdown and then use your rendering system and its default reference documents to set the styles you need. 
 
@@ -152,6 +154,25 @@ In Libreoffice you would modify your template reference.odt as you need it. You
 
 Then you would save the reference.odt as a new name perhaps contract-reference.odt in your Pandoc reference folder. 
 
+### Step 3(a): Add Precursors to Headers
+
+*Note*: I only use these when I'm using pandoc to move directly to html or pdf files (a fuller suite of this is what we're working towards at Watershed, along with the fantastic team at [FrontlineSMS](http://www.frontlinesms.com/about-us/) and others hopefully). If you want to use `legal_markdown` along with .odt or .docx files probably better to utilize the workflow described *supra*.
+
+Now that you've been warned, here's how you use precursors. Within the text of the document nothing changes. In the YAML front matter you will leave it as it was before. All you need to do is add any word or other marker before the trigger. What `legal_markdown` will do is to look at the last two characters if the marker ends in a period or three if it ends in a paren, and then everything else it will place into a precursor. If you want to reference the preceding level (like 1.1.1 in the example above) then simply put in {pre}. I'll try to make this less fragile down the road, but for now it is what it is. So, your YAML front matter will look like this:
+
+    ```yaml
+    ---
+    title: Wonderful Contract
+    author: Your Name
+    date: today
+    level-1: Article 1.
+    level-2: pre 1.
+    level-3: pre a.
+    ---
+    ```
+
+The other thing you need to be aware of if you use this method is that when `legal_markdown` parses the input markdown it have to hardcode in the numbering. This means that you'll lose any features of automatic lists and list nesting which your markdown renderer may give you if you simply placed the triggers without any precursors.
+
 ### Step 4: Run Legal-Markdown and Pandoc
 
 Make sure when you run Pandoc you use the new reference document that you created as the basis. 
@@ -170,7 +191,11 @@ Also, if you use the reference.odt or reference.docx to override the default for
 
 [ ] - Definitions. For now these can be used as mixins but that functionality needs to improve.
 
-[ ] - Parsing. At this point legal_markdown cannot take a markdown document and parse it to build structured headers. Legal_markdown only works with a renderer to *create* documents but not to *import* documents. I want to build this functionality out at a later date. 
+[ ] - Parsing. At this point legal_markdown cannot take a markdown document and parse it to build structured headers. Legal_markdown only works with a renderer to *create* documents but not to *import* documents. I want to build this functionality out at a later date. Legal_markdown is not meant as an importer for files types, there are other tools for that but I would like it to be able to parse text that is already in markdown. 
+
+[ ] - Markdown post-processing. This will cure some of the issues (class establishment and proper list nesting of structure documents) that are currently lost when using precurors.
+
+[ ] - Different input and output files
 
 # Contributing
 

data/bin/legalmd

@@ -4,4 +4,4 @@
 #  legalmd file.md
 
 require 'legal_markdown'
-LegalMarkdown.execute(ARGV)
+LegalMarkdown.markdown_preprocess(ARGV)

data/legal_markdown.gemspec

@@ -18,7 +18,7 @@ Gem::Specification.new do |s|
   s.test_files        = s.files.grep(%r{^(test|spec|features)/})
   s.require_paths     = ["lib"]
 
-  #s.add_dependency ""
+  s.add_dependency      "roman-numerals"
 
   s.description       = <<desc
   This gem will parse YAML Front Matter of Markdown Documents. Typically, this gem would be called with a md renderer, such as Pandoc, that would turn the md into a document such as a .pdf file or a .docx file. By combining this pre-processing with a markdown renderer, you can ensure that both the structured content and the structured styles necessary for your firm or organization are more strictly enforced. Plus you won't have to deal with Word any longer, and every lawyer should welcome that. Why? Because Word is awful. 

data/lib/legal_markdown/version.rb

@@ -1,3 +1,3 @@
 module LegalMarkdown
-  VERSION = "0.1.1"
+  VERSION = "0.1.2"
 end

data/lib/legal_markdown.rb

@@ -1,22 +1,24 @@
 #! ruby
 require 'yaml'
 require 'English'
+require 'roman-numerals'
 require "legal_markdown/version"
 
 module LegalMarkdown
   extend self
-  def execute(*args)
+
+  def markdown_preprocess(*args)
     # Get the Content & Yaml Data
     data = load(*args)
     parsed_content = parse_file(data[0])
     # Run the Mixins
     mixed_content = mixing_in(parsed_content[0], parsed_content[1])
-    #REMOVE THESE LATER
-    content = mixed_content[0]
-    yaml_data = mixed_content[1]
-    puts content
-    puts "What's left"
-    yaml_data.each{|k,v| puts "#{k}: #{v}"}
+    # Run the Pandoc Title Block
+    pandoc_content = pandoc_title_block( mixed_content[1] ) + mixed_content[0]
+    # Run the Headers
+    headed_content = headers_on(mixed_content[1], pandoc_content)
+    # Write the file
+    file = write_it( @filename, headed_content )
   end
 
   private
@@ -50,8 +52,9 @@ module LegalMarkdown
     # ARGV.each{ |fn| output_file(OPTS, fn) }
 
     # Load Source File
-    source_file = File::read(ARGV[-1]) if File::exists?(ARGV[-1])
-    return[source_file, '']
+    @filename = ARGV[-1]
+    source_file = File::read(@filename) if File::exists?(@filename) && File::readable?(@filename)
+    return [source_file, '']
   end
 
   # ----------------------
@@ -72,7 +75,7 @@ module LegalMarkdown
     rescue => e 
       puts "Error reading file #{File.join(ARGV[0])}: #{e.message}"
     end
-    return[data, content]
+    return [data, content]
   end
 
   # ----------------------
@@ -93,43 +96,256 @@ module LegalMarkdown
         end
       end
     end
-    return[content, mixins]
+    return [content, mixins]
   end
 
   # ----------------------
   # |      Step 4        |
   # ----------------------
-  # Headers
-
+  # Special YAML fields
 
-  #  Step 4a: Find the block starting and finishing lines
+  def pandoc_title_block( headers )
+    title_block = ""
+    headers.each do | header |
+      if header[0].casecmp("title") == 0
+        title_block << "% " + header[1] + "\n"
+        headers.delete( header )
+      elsif header[0].casecmp("author") == 0
+        title_block << "% " + header[1] + "\n"
+        headers.delete( header )
+      elsif header[0].casecmp("date") == 0
+        title_block << "% " + header[1] + "\n\n"
+        headers.delete( header )
+      end
+    end
+    return title_block
+  end
 
+  # ----------------------
+  # |      Step 5        |
+  # ----------------------
+  # Headers
 
-  #  Step 4b: Set the alignment and the nesting structure
+  def headers_on( headers, content )
+
+    def get_the_substitutions( headers )
+      # find the headers in the remaining YAML 
+      # parse out the headers into level-X and pre-X headers
+      # then combine them into a coherent package
+      # returns a hash with the keys as the l., ll. searches
+      # and the values as the replacements in the form of 
+      # an array where the first value is a symbol and the 
+      # second value is the precursor
+
+      def set_the_subs_arrays(value)
+        # takes a core value from the hash pulled from the yaml
+        # returns an array with a type symbol and a precursor string
+        if value =~ /I\.\z/            # type1 : {{ I. }}
+          return[:type1, value[0..-3]]
+        elsif value =~ /\(I\)\z/       # type2 : {{ (I) }}
+          return[:type2, value[0..-4]]
+        elsif value =~ /i\.\z/         # type3 : {{ i. }}
+          return[:type3, value[0..-3]]
+        elsif value =~ /\(i\)\z/       # type4 : {{ (i) }}
+          return[:type4, value[0..-4]]
+        elsif value =~ /[A-Z]\.\z/     # type5 : {{ A. }}
+          return[:type5, value[0..-3]]
+        elsif value =~ /\([A-Z]\)\z/   # type6 : {{ (A) }}
+          return[:type6, value[0..-4]]
+        elsif value =~ /[a-z]\.\z/     # type7 : {{ a. }}
+          return[:type7, value[0..-3]]
+        elsif value =~ /\([a-z]\)\z/   # type8 : {{ (a) }}
+          return[:type8, value[0..-4]]
+        elsif value =~ /\(\d\)\z/      # type9 : {{ (1) }}
+          return[:type9, value[0..-3]]
+        else value =~ /\d\.\z/         # type0 : {{ 1. }} ... also default
+          return[:type0, value[0..-4]]
+        end
+      end
 
+      substitutions = {}
+      headers.each do | header, value |
+        if header =~ /level-\d/
+          level = header[-1].to_i
+          base = "l"
+          search = base * level + "."
+          # substitutions hash example {"ll."=>[:type8,"Article"],}
+          substitutions[search]= set_the_subs_arrays(value.to_s)
+        end
+      end
 
-  #  Step 4c: Set the requested list styling per the YAML front-matter
+      return substitutions
+    end
 
+    def find_the_block( content )
+      # finds the block of text that will be processed
+      # returns an array with the first element as the block 
+      # to be processed and the second element as the rest of the document
+      if content =~ /(^l+\.\s.+^$)/m
+        block = $1.chomp
+        content = $PREMATCH + "{{block}}\n" + $POSTMATCH
+      end
+      return[ block, content ]
+    end
 
-  #  Step 4d: Pull out the ll. tags & strip the leading whitespace
-  #   but keep the proper nesting alignment.
+    def chew_on_the_block( substitutions, block )
+      # takes a hash of substitutions to make from the #get_the_substitutions method
+      # and a block of text returned from the #find_the_block method
+      # iterates over the block to make the appropriate substitutions
+      # returns a block of text
+
+      def get_the_subs_arrays( value )
+        # returns a new array for the replacements
+        if value[0] == :type1       # :type1 : {{ I. }}
+          return[:type1, value[1], "", "I", "."] 
+        elsif value[0] == :type2    # :type2 : {{ (I) }}
+          return[:type2, value[1], "(", "I", ")"]
+        elsif value[0] == :type3    # :type3 : {{ i. }}
+          return[:type3, value[1], "", "i", "."]
+        elsif value[0] == :type4    # :type4 : {{ (i) }}
+          return[:type4, value[1], "(", "i", ")"]
+        elsif value[0] == :type5    # :type5 : {{ A. }}
+          return[:type5, value[1], "", "A", "."]
+        elsif value[0] == :type6    # :type6 : {{ (A) }}
+          return[:type6, value[1], "(", "A", ")"]
+        elsif value[0] == :type7    # :type7 : {{ a. }}
+          return[:type7, value[1], "", "a", "."]
+        elsif value[0] == :type8    # :type8 : {{ (a) }}
+          return[:type8, value[1], "(", "a", ")"]
+        elsif value[0] == :type9    # :type9 : {{ (1) }}
+          return[:type9, value[1], "(", "1", ")"]
+        else value[0] == :type0     # :type0 : {{ 1. }} ... also default
+          return[:type0, value[1], "", 1, "."]
+        end
+      end
 
+      def log_the_line( new_block, selector, line, array_to_sub )
+        substitute = array_to_sub[1..4].join
+        spaces = ( " " * ( (selector.size) - 1 ) * 4 )
+        new_block << spaces + line.gsub(selector, substitute)
+      end
 
-  # ----------------------
-  # |      Step 5        |
-  # ----------------------
-  # Special YAML fields
+      def increment_the_branch( hash_of_subs, array_to_sub, selector )
+        romans_uppers = [ :type1, :type2 ]
+        romans_lowers = [ :type3, :type4 ]
+        romans = romans_uppers + romans_lowers
+        if romans.any?{ |e| e == array_to_sub[0] }
+          if romans_lowers.any?{ |e| e == array_to_sub[0] }
+            r_l = true
+          else
+            r_u = true
+          end
+        end
+        if r_l == true
+          array_to_sub[3] = array_to_sub[3].upcase
+        end
+        if r_l == true || r_u == true
+          array_to_sub[3] = RomanNumerals.to_decimal(array_to_sub[3]) 
+        end
+        array_to_sub[3] = array_to_sub[3].next
+        if r_l == true || r_u == true
+          array_to_sub[3] = RomanNumerals.to_roman(array_to_sub[3]) 
+        end
+        if r_l == true
+          array_to_sub[3] = array_to_sub[3].downcase
+        end
+        hash_of_subs[selector]= array_to_sub
+        return hash_of_subs
+      end
 
+      def reset_the_sub_branches( hash_of_subs, array_to_sub, selector )
+        hash_of_subs = increment_the_branch( hash_of_subs, array_to_sub, selector )
+        leaders_to_reset = []
+        hash_of_subs.each_key{ |k| leaders_to_reset << k if k > selector }
+        leaders_to_reset.each do | leader |
+          unless hash_of_subs[leader][5] == :pre
+            hash_of_subs[leader]= get_the_subs_arrays(hash_of_subs[leader])
+          else
+            hash_of_subs[leader]= get_the_subs_arrays(hash_of_subs[leader])
+            hash_of_subs[leader]= pre_setup(hash_of_subs[leader])
+          end
+        end
+        return hash_of_subs
+      end
 
-  # Step 6: Strip the YAML front-matter
+      def pre_setup( array_to_sub )
+        array_to_sub[5] = :pre
+        array_to_sub[1] = ""
+        return array_to_sub
+      end
 
+      def reform_the_block( old_block, substitutions )
+        # method will take the old_block and iterate through the lines.
+        # First it will find the leading indicator. Then it will
+        # find the appropriate substitution from the substitutions 
+        # hash. After that it will rebuild the leading matter from the
+        # sub hash. It will drop markers if it is going down the tree.
+        # It will reset the branches if it is going up the tree. 
+        # sub_it is an array w/ type[0] & lead_string[1] & id's[2..4]
+        new_block = ""
+        leader_before = ""
+        leader_above = ""
+        selector_before = ""
+        old_block.each_line do | line | 
+          selector = $1.chop if line =~ /(^l+.\s)/ 
+          sub_it = substitutions[selector]
+          if sub_it[5] == :pre || sub_it[1] =~ /pre/
+            sub_it = pre_setup(sub_it) 
+            if selector_before < selector     # Going down the tree, into pre
+              leader_above = substitutions[selector_before][1..4].join
+              sub_it[1] = leader_above = leader_before
+            elsif selector_before > selector && substitutions[selector_before][5] == :pre
+              sub_it[1] = leader_above[0..-3]
+            else
+              sub_it[1] = leader_above
+            end
+          end
+          log_the_line( new_block, selector, line, sub_it )
+          leader_before = sub_it[1..4].join
+          if selector_before > selector     # We are going up the tree.
+            substitutions = reset_the_sub_branches(substitutions, sub_it, selector)
+          else                              # We are at the same level.
+            substitutions = increment_the_branch(substitutions, sub_it, selector)
+          end
+          selector_before = selector
+        end
+        return new_block
+      end
 
-  # Step 7: Write the file 
+      if block != nil && block != "" && substitutions != nil && substitutions != {}
+        substitutions.each_key{ |k| substitutions[k]= get_the_subs_arrays(substitutions[k]) }
+        new_block = reform_the_block( block, substitutions )
+      end
+    end
 
+    headers = get_the_substitutions( headers )
+    block_noted = find_the_block( content )
+    block = block_noted[0]
+    not_the_block = block_noted[1]
+    block_noted = ""   # Really only for long documents so they don't use too much memory
 
-  #   Step 7a: Where an output file was specified
+    if headers == {} 
+      block_redux = block
+    end
+    if block == nil || block == ""
+      block_redux = ""
+    else
+      block_redux = chew_on_the_block( headers, block )
+    end
 
+    headed = not_the_block.gsub("{{block}}", block_redux )
+  end
 
-  #   Step 7b: Where an output file was not specified
+  # ----------------------
+  # |      Step 6        |
+  # ----------------------
+  # Write the file 
 
+  def write_it( filename, final_content )
+    if File.writable?( filename )
+      File::open filename, 'w' do |f|
+        f.write final_content
+      end
+    end
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: legal_markdown
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,8 +9,24 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-02-18 00:00:00.000000000 Z
-dependencies: []
+date: 2013-02-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: roman-numerals
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 description: ! "  This gem will parse YAML Front Matter of Markdown Documents. Typically,
   this gem would be called with a md renderer, such as Pandoc, that would turn the
   md into a document such as a .pdf file or a .docx file. By combining this pre-processing
@@ -47,7 +63,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 1250125497917414480
+      hash: 2506371109805164331
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -56,7 +72,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 1250125497917414480
+      hash: 2506371109805164331
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.25