markdownplus 0.1.0 → 0.2.0

data/lib/markdownplus/parser.rb

@@ -1,12 +1,10 @@
 require 'csv'
 require 'json'
 require 'open-uri'
-require 'pygments'
-require 'redcarpet'
 
 module Markdownplus
   class Parser
-    attr_reader :source
+    attr_reader :input
     attr_accessor :current_block
 
     def self.parse(value)
@@ -16,7 +14,7 @@ module Markdownplus
     end
 
     def initialize(value=nil)
-      @source = value
+      @input = value
     end
 
     def blocks
@@ -30,38 +28,42 @@ module Markdownplus
       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
+    def input_markdown
+      blocks.collect { |b| b.input_markdown }.join
+    end
+
+    def output_markdown
+      blocks.collect { |b| b.output_markdown }.join
     end
 
     def html
-      markdown_renderer.render(markdown)
+      markdown_renderer.render(output_markdown)
     end
 
     def markdown_renderer
-      Redcarpet::Markdown.new(Bootstrap2Renderer, fenced_code_blocks: true)
+      Redcarpet::Markdown.new(GithubRenderer, fenced_code_blocks: true)
     end
 
     def lines
-      @lines ||= source.split("\n")
+      @lines ||= input.split("\n")
     end
 
-    def errors
-      blocks.collect { |b| b.errors }.flatten
+    def variables
+      @variables ||= {}
     end
 
     def warnings
       blocks.collect { |b| b.warnings }.flatten
     end
 
+    def errors
+      blocks.collect { |b| b.errors }.flatten
+    end
+
     def each_line(&block)
       if block_given?
         lines.each do |line|
@@ -71,45 +73,52 @@ module Markdownplus
     end
 
     def parse
+      block_number = 0
       each_line do |line|
         matcher = line.match(/\s*`{3,}\s*(\S*)\s*/)
         if matcher
-          if self.current_block && self.current_block.class == CodeBlock
+          if self.current_block && self.current_block.is_a?(CodeBlock)
             self.blocks << self.current_block
             self.current_block = nil
+            block_number += 1
           else
             self.blocks << self.current_block if self.current_block
-            self.current_block = CodeBlock.new(matcher[1])
+            self.current_block = CodeBlock.new(block_number, matcher[1])
           end
         else
-          self.current_block ||= TextBlock.new
+          self.current_block ||= TextBlock.new(block_number)
           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
+    def execute
+      self.executable_blocks.each do |block|
+        block.execute(self.variables)
       end
     end
   end
 
   class Block
-    def source
-      @source ||= ""
+    attr_reader :block_number
+    def initialize(block_number)
+      @block_number = block_number
     end
-    def source=(value)
-      @source = value
+
+    def input
+      @input ||= ""
+    end
+    def input=(value)
+      @input = value
     end
 
     def lines
-      self.source.split("\n")
+      self.input.split("\n")
     end
 
     def append(line)
-      self.source += "#{line}\n"
+      self.input += "#{line}\n"
     end
 
     def errors
@@ -122,125 +131,66 @@ module Markdownplus
   end
 
   class TextBlock < Block
-    def markdown
-      self.source
+
+    def input_markdown
+      self.input
+    end
+
+    def output_markdown
+      self.input
     end
   end
 
   class CodeBlock < Block
-    attr_reader :directives
+    attr_reader :directive, :program
+    attr_accessor :output
 
-    def initialize(value=nil)
-      @directives = value.split("|").collect{|v| v.strip} if value
-    end
+    def initialize(block_number, value=nil)
+      @block_number = block_number
+      @directive = value
 
-    def markdown
-      s = source
-      if s.end_with?("\n")
-        result = "```#{directives.join("|")}\n#{source}```\n"
-      else
-        result = "```#{directives.join("|")}\n#{source}\n```\n"
+      if @directive.match(/\(/)
+        begin
+          @program ||= Markdownplus::DirectiveParser.parse(@directive)
+        rescue => e
+          errors << e.message
+        end
       end
     end
 
-    def includable?
-      first_directive == "include"
+    def functions
+      program.functions if program!=nil
     end
 
     def executable?
-      first_directive == "execute"
+      (functions!=nil && functions.size>0)
     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
+    def execute(variables)
+      self.output = self.input
+      if functions
+        self.functions.each do |function|
+          self.output = function.execute(self.output, variables, self.warnings, self.errors)
         end
-        directives.shift
       end
+      self.output
     end
 
-    def first_directive
-      directives.first if directives
+    def input_markdown
+      s = input
+      if s.end_with?("\n")
+        result = "```#{directive}\n#{input}```\n"
+      else
+        result = "```#{directive}\n#{input}\n```\n"
+      end
     end
 
-    # def method
-    #   matcher = directive.match(/(.*?)\((.*)\)/)
-    #   if matcher
-    #     method = matcher[1].strip
-    #     params = matcher[2].split(",").collect { |p| p.strip }
-    #   end
-    # end
-  end
+    def output_markdown
+      self.output
+    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
+    def output_lines
+      self.output.split("\n") if self.output
     end
   end
 end

data/lib/markdownplus/version.rb

@@ -1,3 +1,3 @@
 module Markdownplus
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/markdownplus.gemspec

@@ -24,4 +24,5 @@ Gem::Specification.new do |spec|
 
   spec.add_dependency "redcarpet"
   spec.add_dependency "pygments.rb"
+  spec.add_dependency "treetop"
 end

data/spec/directive_parser_spec.rb

@@ -0,0 +1,275 @@
+require 'markdownplus'
+require 'spec_helper'
+
+describe Markdownplus::DirectiveParser do
+  context "a simple function with no params" do
+    let(:value) { Markdownplus::DirectiveParser.parse("include()") }
+
+    it "should return a TransformationLiteral" do
+      expect(value.class).to eq(Markdownplus::Literals::TransformationLiteral)
+    end
+
+    it "should have a single function" do
+      expect(value.functions.count).to eq(1)
+    end
+
+    it "should have a function named 'include'" do
+      expect(value.functions.first.function_name).to eq("include")
+    end
+
+    it "should have no parameters" do
+      expect(value.functions.first.function_parameters.count).to eq(0)
+    end
+  end
+
+  context "a simple function with a single param" do
+    let(:value) { Markdownplus::DirectiveParser.parse("include(test)") }
+
+    it "should return a TransformationLiteral" do
+      expect(value.class).to eq(Markdownplus::Literals::TransformationLiteral)
+    end
+
+    it "should have a single function" do
+      expect(value.functions.count).to eq(1)
+    end
+
+    it "should have a function named 'include'" do
+      expect(value.functions.first.function_name).to eq("include")
+    end
+
+    it "should have a single parameter" do
+      expect(value.functions.first.function_parameters.count).to eq(1)
+    end
+
+    it "should have the parameter 'test'" do
+      expect(value.functions.first.function_parameters.first.to_s).to eq("test")
+    end
+  end
+  context "a simple function with a 3 params" do
+    let(:value) { Markdownplus::DirectiveParser.parse("include(test, 'this is a test', nil)") }
+
+    it "should return a TransformationLiteral" do
+      expect(value.class).to eq(Markdownplus::Literals::TransformationLiteral)
+    end
+
+    it "should have a single function" do
+      expect(value.functions.count).to eq(1)
+    end
+
+    it "should have a function named 'include'" do
+      expect(value.functions.first.function_name).to eq("include")
+    end
+
+    it "should have 3 parameters" do
+      expect(value.functions.first.function_parameters.count).to eq(3)
+    end
+
+    it "the first parameter should be correct" do
+      expect(value.functions.first.function_parameters[0].class).to eq(Markdownplus::Literals::SymbolLiteral)
+      expect(value.functions.first.function_parameters[0].to_s).to eq("test")
+    end
+
+    it "the second parameter should be correct" do
+      expect(value.functions.first.function_parameters[1].class).to eq(Markdownplus::Literals::StringLiteral)
+      expect(value.functions.first.function_parameters[1].to_s).to eq("this is a test")
+    end
+
+    it "the third parameter should be correct" do
+      expect(value.functions.first.function_parameters[2].class).to eq(Markdownplus::Literals::SymbolLiteral)
+      expect(value.functions.first.function_parameters[2].to_s).to eq("nil")
+    end
+  end
+
+  context "a series of two functions" do
+    let(:value) { Markdownplus::DirectiveParser.parse("include(), execute()") }
+
+    it "should return a TransformationLiteral" do
+      expect(value.class).to eq(Markdownplus::Literals::TransformationLiteral)
+    end
+
+    it "should have 2 functions" do
+      expect(value.functions.count).to eq(2)
+    end
+
+    context "the first function" do
+      let(:function) { value.functions[0] }
+
+      it "should be 'include'" do
+        expect(function.function_name).to eq("include")
+      end
+
+      it "should have no parameters" do
+        expect(function.function_parameters.count).to eq(0)
+      end
+    end
+
+    context "the second function" do
+      let(:function) { value.functions[1] }
+
+      it "should be 'include'" do
+        expect(function.function_name).to eq("execute")
+      end
+
+      it "should have no parameters" do
+        expect(function.function_parameters.count).to eq(0)
+      end
+    end
+  end
+
+  context "a function with a nested function" do
+    let(:value) { Markdownplus::DirectiveParser.parse("include(test, execute('nested test'))") }
+
+    it "should return a TransformationLiteral" do
+      expect(value.class).to eq(Markdownplus::Literals::TransformationLiteral)
+    end
+
+    it "should have a single function" do
+      expect(value.functions.count).to eq(1)
+    end
+
+    it "should have a function named 'include'" do
+      expect(value.functions.first.function_name).to eq("include")
+    end
+
+    it "should have 2 parameters" do
+      expect(value.functions.first.function_parameters.count).to eq(2)
+    end
+
+    context "the second function parameter" do
+      let(:param) { value.functions.first.function_parameters[1] }
+
+      it "should be a functionLiteral" do
+        expect(param.class).to eq(Markdownplus::Literals::FunctionLiteral)
+      end
+
+      it "should be a function named 'execute'" do
+        expect(param.function_name).to eq("execute")
+      end
+    end
+  end
+
+  context "a function with a url parameter" do
+    let(:value) { Markdownplus::DirectiveParser.parse("include('http://www.google.com')") }
+
+    it "should have a single function" do
+      expect(value.functions.count).to eq(1)
+    end
+
+    it "should have a function named 'include'" do
+      expect(value.functions.first.function_name).to eq("include")
+    end
+
+    it "should have 1 parameter" do
+      expect(value.functions.first.function_parameters.count).to eq(1)
+    end
+
+    context "the first parameter" do
+      let(:param) { value.functions.first.function_parameters.first }
+
+      it "should be google.com" do
+        expect(param.to_s).to eq("http://www.google.com")
+      end
+    end
+  end
+
+  context "a function with parameters that contain strange characters" do
+    let(:value) { Markdownplus::DirectiveParser.parse("include('this-is_a @test', so_is-this)") }
+
+    it "should have a single function" do
+      expect(value.functions.count).to eq(1)
+    end
+
+    it "should have a function named 'include'" do
+      expect(value.functions.first.function_name).to eq("include")
+    end
+
+    it "should have 2 parameters" do
+      expect(value.functions.first.function_parameters.count).to eq(2)
+    end
+
+    context "the first parameter" do
+      let(:param) { value.functions.first.function_parameters[0] }
+
+      it "should be correct" do
+        expect(param.to_s).to eq("this-is_a @test")
+      end
+    end
+
+    context "the second parameter" do
+      let(:param) { value.functions.first.function_parameters[1] }
+
+      it "should be correct" do
+        expect(param.to_s).to eq("so_is-this")
+      end
+    end
+  end
+
+  context "some specific cases" do
+    context "value 1" do
+      let(:value) { Markdownplus::DirectiveParser.parse("julia(dataFrame('my_variable', get('my_variable'))),strip_whitespace(),raw()") }
+  
+      it "should parse" do
+        expect(value.class).to eq(Markdownplus::Literals::TransformationLiteral)
+      end
+
+      it "should have a three functions" do
+        expect(value.functions.count).to eq(3)
+      end
+
+      it "should have a function named 'julia'" do
+        expect(value.functions.first.function_name).to eq("julia")
+      end
+
+      it "should have 1 parameter" do
+        expect(value.functions.first.function_parameters.count).to eq(1)
+      end
+
+      context "the function parameter" do
+        let(:param) { value.functions.first.function_parameters.first }
+
+        it "should be a functionLiteral" do
+          expect(param.class).to eq(Markdownplus::Literals::FunctionLiteral)
+        end
+
+        it "should be a function named 'dataFrame'" do
+          expect(param.function_name).to eq("dataFrame")
+        end
+
+        it "should have 2 parameters" do
+          expect(param.function_parameters.count).to eq(2)
+        end
+
+        context "the first parameter" do
+          let(:param1) { param.function_parameters.first }
+          it "should be a String" do
+            expect(param1.class).to eq(Markdownplus::Literals::StringLiteral)
+          end
+
+          it "should equal 'my_variable'" do
+            expect(param1.to_s).to eq("my_variable")
+          end
+        end
+
+        context "the second parameter" do
+          let(:param2) { param.function_parameters[1] }
+          it "should be a functionLiteral" do
+            expect(param2.class).to eq(Markdownplus::Literals::FunctionLiteral)
+          end
+          it "should be a function named 'get'" do
+            expect(param2.function_name).to eq("get")
+          end
+          it "should have a parameter 'my_variable'" do
+            expect(param2.function_parameters.first.to_s).to eq("my_variable")
+          end
+        end
+      end
+    end
+
+    context "value 2" do
+      let(:value) { Markdownplus::DirectiveParser.parse("sql('postgres://username1:password2@ec2-12-345-678-9.compute-1.amazonaws.com:1234/database'),set('my_variable'),empty()") }
+      it "should parse" do
+        expect(value.class).to eq(Markdownplus::Literals::TransformationLiteral)
+      end
+    end
+  end
+end