markdownplus 0.0.1.pre → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b5a4a83c2a959add9e237fd781aae968f8bdc567
-  data.tar.gz: cbb9b6fd9e7fd12cd228db7037e00f8288e4a33b
+  metadata.gz: 59b5fb6c0a410a172db5e2aeba391eac6653eaff
+  data.tar.gz: 42154e62a00f5ec65919c512ad6398be9498fc64
 SHA512:
-  metadata.gz: 1e4c4d3e0ff8cfe3dc2f5221b1cda3b4c8ebe1a933b9f28b7dc2978c701010984a9128df443849618c9fe6fdbe3bae4219b5afe7d122aa1ab92cd53d428ed10d
-  data.tar.gz: 83852530992abfa1ee32ede91545a36f64f674397e534e3c86e64000aebb2276e14ea8ebe16a3ded01de003aea58ffe01cd5258273f8976021191f0e6867c93b
+  metadata.gz: c25d9c37887e2d41a4a3a12796fcb19badf60a4615c0e437c3ad2f5d1d0db6710a55b94f524c2fe76494d8c062180290c752309a374f9135c7bf8749724b575b
+  data.tar.gz: 97334f94d603ac07051958b58a074703a798485943f9a5b1dccc556517c02eb3301d3c7addf5405040e44c3b1be45353cd7b1af0dd4c36dd47fed65e03163a6b

data/LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright (c) 2014 Christopher Petersen
+Copyright (c) 2015 Christopher Petersen
 
 MIT License
 

data/README.md

@@ -15,3 +15,15 @@ And then execute:
 Or install it yourself as:
 
     $ gem install markdownplus
+
+# Syntax
+
+## Include external files
+
+Use a fenced code block:
+
+```markdown
+  ```include|csv
+  https://gist.githubusercontent.com/cpetersen/b5a473ddf0b796cd9502/raw/e140bdc32ff2f6a600e357c2575220c0312a88ee/fake.csv
+  ```
+```

data/Rakefile

@@ -1 +1,8 @@
+#!/usr/bin/env rake
 require "bundler/gem_tasks"
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec)
+
+task :test => :spec
+task :default => :spec

data/lib/markdownplus/parser.rb

@@ -0,0 +1,247 @@
+require 'csv'
+require 'json'
+require 'open-uri'
+require 'pygments'
+require 'redcarpet'
+
+module Markdownplus
+  class Parser
+    attr_reader :source
+    attr_accessor :current_block
+
+    def self.parse(value)
+      parser = Parser.new(value)
+      parser.parse
+      parser
+    end
+
+    def initialize(value=nil)
+      @source = value
+    end
+
+    def blocks
+      @blocks ||= []
+    end
+    def blocks=(value)
+      @blocks = value
+    end
+
+    def code_blocks
+      blocks.select { |b| b.class == CodeBlock }
+    end
+
+    def includable_blocks
+      code_blocks.select(&:includable?)
+    end
+
+    def executable_blocks
+      code_blocks.select(&:executable?)
+    end
+
+    def markdown
+      blocks.collect { |b| b.markdown }.join
+    end
+
+    def html
+      markdown_renderer.render(markdown)
+    end
+
+    def markdown_renderer
+      Redcarpet::Markdown.new(Bootstrap2Renderer, fenced_code_blocks: true)
+    end
+
+    def lines
+      @lines ||= source.split("\n")
+    end
+
+    def errors
+      blocks.collect { |b| b.errors }.flatten
+    end
+
+    def warnings
+      blocks.collect { |b| b.warnings }.flatten
+    end
+
+    def each_line(&block)
+      if block_given?
+        lines.each do |line|
+          block.call(line)
+        end
+      end
+    end
+
+    def parse
+      each_line do |line|
+        matcher = line.match(/\s*`{3,}\s*(\S*)\s*/)
+        if matcher
+          if self.current_block && self.current_block.class == CodeBlock
+            self.blocks << self.current_block
+            self.current_block = nil
+          else
+            self.blocks << self.current_block if self.current_block
+            self.current_block = CodeBlock.new(matcher[1])
+          end
+        else
+          self.current_block ||= TextBlock.new
+          self.current_block.append line
+        end
+      end
+      self.blocks << self.current_block if self.current_block      
+    end
+
+    def include
+      includable_blocks.each do |block|
+        block.include
+      end
+    end
+  end
+
+  class Block
+    def source
+      @source ||= ""
+    end
+    def source=(value)
+      @source = value
+    end
+
+    def lines
+      self.source.split("\n")
+    end
+
+    def append(line)
+      self.source += "#{line}\n"
+    end
+
+    def errors
+      @errors ||= []
+    end
+
+    def warnings
+      @warnings ||= []
+    end
+  end
+
+  class TextBlock < Block
+    def markdown
+      self.source
+    end
+  end
+
+  class CodeBlock < Block
+    attr_reader :directives
+
+    def initialize(value=nil)
+      @directives = value.split("|").collect{|v| v.strip} if value
+    end
+
+    def markdown
+      s = source
+      if s.end_with?("\n")
+        result = "```#{directives.join("|")}\n#{source}```\n"
+      else
+        result = "```#{directives.join("|")}\n#{source}\n```\n"
+      end
+    end
+
+    def includable?
+      first_directive == "include"
+    end
+
+    def executable?
+      first_directive == "execute"
+    end
+
+    def include
+      if includable?
+        if lines.count == 0
+          self.warnings << "No url given"
+        else
+          self.warnings << "More than one line given" if lines.count > 1
+          begin
+            self.source = open(lines.first).read
+          rescue => e
+            self.errors << "Error opening [#{lines.first}] [#{e.message}]"
+          end
+        end
+        directives.shift
+      end
+    end
+
+    def first_directive
+      directives.first if directives
+    end
+
+    # def method
+    #   matcher = directive.match(/(.*?)\((.*)\)/)
+    #   if matcher
+    #     method = matcher[1].strip
+    #     params = matcher[2].split(",").collect { |p| p.strip }
+    #   end
+    # end
+  end
+
+  # class Value
+  #   def self.parse(string)
+  #     items = string.split(",").collect do |item|
+  #       matcher = item.match(/(.*?)\((.*)\)/)
+  #       if matcher
+  #         name = matcher[1].strip
+  #         params = parse(matcher[2])
+  #         Method.new(name: name, params: params)
+  #       else
+  #         Param.new(item.strip)
+  #       end
+  #     end
+  #   end
+  # end
+
+  # class Param < Value
+  #   def initialize(v)
+  #     @value = value
+  #   end
+
+  #   def value
+  #     @value
+  #   end
+  # end
+
+  # class Method < Value
+  #   attr_reader :name
+  #   attr_reader :params
+
+  #   def initialize(opts={})
+  #     @name = opts[:name]
+  #     @params = opts[:params]
+  #   end
+  # end
+
+  class Bootstrap2Renderer < Redcarpet::Render::HTML
+    # alias_method :existing_block_code, :block_code
+    def block_code(code, language)
+      if language == "csv"
+        result = "<table class='table table-striped'>"
+        row_num = 0
+        CSV.parse(code) do |row|
+          if row_num == 0
+            result += "<thead><tr>#{row.collect { |c| "<th>#{c}</th>"}.join}</tr></thead>\n<tbody>\n"
+          else
+            result += "<tr>#{row.collect { |c| "<td>#{c}</td>"}.join}</tr>\n"
+          end
+          row_num += 1
+        end
+        result += "</tbody></table>"
+      elsif language == "formatted_json"
+        begin
+          obj = JSON.parse(code)
+          result = Pygments.highlight(JSON.pretty_generate(obj), lexer: "json")
+        rescue => e
+          result = Pygments.highlight(code, lexer: "json")
+        end
+      else
+        result = Pygments.highlight(code, lexer: language)
+      end
+      result
+    end
+  end
+end
+

data/lib/markdownplus/version.rb

@@ -1,3 +1,3 @@
 module Markdownplus
-  VERSION = "0.0.1.pre"
+  VERSION = "0.1.0"
 end

data/lib/markdownplus.rb

@@ -1,4 +1,5 @@
 require "markdownplus/version"
+require "markdownplus/parser"
 
 module Markdownplus
   # Your code goes here...

data/markdownplus.gemspec

@@ -8,8 +8,8 @@ Gem::Specification.new do |spec|
   spec.version       = Markdownplus::VERSION
   spec.authors       = ["Christopher Petersen"]
   spec.email         = ["chris@petersen.io"]
-  spec.description   = %q{A pre and post processor for markdown which adds programmable features and charting}
-  spec.summary       = %q{Markdown plus charts and scripting}
+  spec.description   = %q{Pre processors that allows the inclusion of external files and post processors for csn and json data.}
+  spec.summary       = %q{Pre and post processors for markdown}
   spec.homepage      = ""
   spec.license       = "MIT"
 
@@ -20,4 +20,8 @@ Gem::Specification.new do |spec|
 
   spec.add_development_dependency "bundler", "~> 1.3"
   spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+
+  spec.add_dependency "redcarpet"
+  spec.add_dependency "pygments.rb"
 end

data/spec/fixtures/include.mdp

@@ -0,0 +1,33 @@
+This is a markdown plus document illustrating include conditions
+
+```include
+https://gist.githubusercontent.com/cpetersen/b5a473ddf0b796cd9502/raw/e140bdc32ff2f6a600e357c2575220c0312a88ee/fake.csv
+```
+
+```include|csv
+https://gist.githubusercontent.com/cpetersen/b5a473ddf0b796cd9502/raw/e140bdc32ff2f6a600e357c2575220c0312a88ee/fake.csv
+```
+
+```include
+```
+
+```include|csv
+https://gist.githubusercontent.com/cpetersen/b5a473ddf0b796cd9502/raw/e140bdc32ff2f6a600e357c2575220c0312a88ee/fake.csv
+this
+should
+be
+a
+warning
+```
+
+```include|formatted_json
+https://gist.githubusercontent.com/cpetersen/c6571117df132443ac81/raw/e5ac97e8e0665a0e4014ebc85ecef214763a7729/fake.json
+```
+
+```include|formatted_json
+https://gist.githubusercontent.com/cpetersen/4ac0ab5fb4d1fda22322/raw/3856ed58d5cdfd07800067fc9fb8fcbcfc631d65/bad_json.json
+```
+
+```include
+this should just be an error
+```

data/spec/fixtures/simple.mdp

@@ -0,0 +1,21 @@
+This is a test markdown document.
+
+```
+This is a a code block
+```
+
+```ruby
+This is a ruby code block
+```
+
+```include
+This is a include block
+```
+
+```include|json
+This is a include block with a filter
+```
+
+```execute|julia
+This is an execute block with a language
+```

data/spec/parser_spec.rb

@@ -0,0 +1,181 @@
+require 'markdownplus'
+require 'spec_helper'
+
+describe Markdownplus::Parser do
+  context "a simple file" do
+    let(:file) { File.read(File.join(File.dirname(__FILE__), "..", "spec", "fixtures", "simple.mdp")) }
+
+    it "should read the file" do
+      expect(file).not_to be_empty
+    end
+
+    context "the parser" do
+      let(:parser) { Markdownplus::Parser.parse(file) }
+      
+      it "should have the correct number of lines" do
+        expect(parser.lines.count).to eq(21)
+      end
+
+      it "should have the correct number of blocks" do
+        expect(parser.blocks.count).to eq(10)
+      end
+
+      it "should have the correct number of code blocks" do
+        expect(parser.code_blocks.count).to eq(5)
+      end
+
+      it "should have the correct number of include blocks" do
+        expect(parser.includable_blocks.count).to eq(2)
+      end
+
+      it "should have the correct number of execute blocks" do
+        expect(parser.executable_blocks.count).to eq(1)
+      end
+
+      context "the markdown method" do
+        let(:markdown) { parser.markdown }
+
+        it "should match the contents of the original file" do
+          expect(markdown).to eq(file)
+        end
+      end
+
+      context "the first block" do
+        let(:block) { parser.blocks.first }
+        it "should be a text block" do
+          expect(block.class).to eq(Markdownplus::TextBlock)
+        end
+      end
+
+      context "the second block" do
+        let(:block) { parser.blocks[1] }
+        it "should be a code block" do
+          expect(block.class).to eq(Markdownplus::CodeBlock)
+        end
+
+        it "should have no directives" do
+          expect(block.directives).to eq([])
+        end
+      end
+
+      context "the fourth block" do
+        let(:block) { parser.blocks[3] }
+        it "should be a code block" do
+          expect(block.class).to eq(Markdownplus::CodeBlock)
+        end
+
+        it "should have the proper directives" do
+          expect(block.directives).to eq(["ruby"])
+        end
+      end
+
+      context "the sixth block" do
+        let(:block) { parser.blocks[5] }
+        it "should be a code block" do
+          expect(block.class).to eq(Markdownplus::CodeBlock)
+        end
+
+        it "should have the proper directives" do
+          expect(block.directives).to eq(["include"])
+        end
+
+        it "should be an include block" do
+          expect(block).to be_includable
+        end
+      end
+
+      context "the eighth block" do
+        let(:block) { parser.blocks[7] }
+        it "should be a code block" do
+          expect(block.class).to eq(Markdownplus::CodeBlock)
+        end
+
+        it "should have the proper directives" do
+          expect(block.directives).to eq(["include", "json"])
+        end
+
+        it "should be an include block" do
+          expect(block).to be_includable
+        end
+      end
+
+      context "the tenth block" do
+        let(:block) { parser.blocks[9] }
+        it "should be a code block" do
+          expect(block.class).to eq(Markdownplus::CodeBlock)
+        end
+
+        it "should have the proper directives" do
+          expect(block.directives).to eq(["execute", "julia"])
+        end
+
+        it "should be an execute block" do
+          expect(block).to be_executable
+        end
+      end
+    end
+  end
+
+  context "include directives" do
+    let(:parser) { 
+      parser = Markdownplus::Parser.parse(File.read(File.join(File.dirname(__FILE__), "..", "spec", "fixtures", "include.mdp")))
+      parser.include
+      parser
+    }
+    it "should have the right number of blocks" do
+      expect(parser.blocks.count).to eq(14)
+    end
+
+    it "should have 2 warnings" do
+      expect(parser.warnings.count).to eq(2)
+    end
+
+    it "should have 1 error" do
+      expect(parser.errors.count).to eq(1)
+    end
+
+    context "the second block" do
+      let(:block) { parser.blocks[1] }
+
+      it "should include the proper number of lines" do
+        expect(block.lines.count).to eq(21)
+      end
+    end
+
+    context "the sixth block" do
+      let(:block) { parser.blocks[5] }
+
+      it "should have a warning" do
+        expect(block.warnings.count).to eq(1)
+      end
+
+      it "should have the missing url warning" do
+        expect(block.warnings.first).to eq("No url given")
+      end
+    end
+
+    context "the eighth block" do
+      let(:block) { parser.blocks[7] }
+
+      it "should have a warning" do
+        expect(block.warnings.count).to eq(1)
+      end
+
+      it "should have the multi line warning" do
+        expect(block.warnings.first).to eq("More than one line given")
+      end
+    end
+
+    context "the fourteenth block" do
+      let(:block) { parser.blocks[13] }
+
+      it "should have an error" do
+        expect(block.errors.count).to eq(1)
+      end
+
+      it "should have the multi line warning" do
+        expect(block.errors.first).to eq("Error opening [this should just be an error] [No such file or directory - this should just be an error]")
+      end
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: markdownplus
 version: !ruby/object:Gem::Version
-  version: 0.0.1.pre
+  version: 0.1.0
 platform: ruby
 authors:
 - Christopher Petersen
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-12-02 00:00:00.000000000 Z
+date: 2015-03-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -38,8 +38,50 @@ dependencies:
     - - '>='
       - !ruby/object:Gem::Version
         version: '0'
-description: A pre and post processor for markdown which adds programmable features
-  and charting
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: redcarpet
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pygments.rb
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Pre processors that allows the inclusion of external files and post processors
+  for csn and json data.
 email:
 - chris@petersen.io
 executables: []
@@ -52,8 +94,13 @@ files:
 - README.md
 - Rakefile
 - lib/markdownplus.rb
+- lib/markdownplus/parser.rb
 - lib/markdownplus/version.rb
 - markdownplus.gemspec
+- spec/fixtures/include.mdp
+- spec/fixtures/simple.mdp
+- spec/parser_spec.rb
+- spec/spec_helper.rb
 homepage: ''
 licenses:
 - MIT
@@ -69,14 +116,18 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>'
+  - - '>='
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubyforge_project: 
 rubygems_version: 2.4.2
 signing_key: 
 specification_version: 4
-summary: Markdown plus charts and scripting
-test_files: []
+summary: Pre and post processors for markdown
+test_files:
+- spec/fixtures/include.mdp
+- spec/fixtures/simple.mdp
+- spec/parser_spec.rb
+- spec/spec_helper.rb
 has_rdoc: