hamdown-engine 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 545611a863e7ec88b985686d8c2c232a315e2fb853b3d6d2a428d178b63b2927
+  data.tar.gz: bb1ddc434f9e44f19ed78e692fe6624cbe6c028e2c02f785bd83f6e80c699605
+SHA512:
+  metadata.gz: c5ba580a8fa7f8eec6dc74fb24061d50b4254d1405041b3d1ba53d70b84e6f5ee1917337f02b3de2cc87f9a30353cc210c19c566525ca19729f786a6b090d24d
+  data.tar.gz: 849e35287c93cc0e3b598935f0cefeaaf9297a1dff75922104c5c75205b55f36e832c600bdf1b5c78369d5f450bc188ccf9ec38651cd36a4c61dd3fbf63b6c12

data/bin/hamdown

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+require './lib/hamdown'
+
+Hamdown::Cli.perform(ARGV)

data/lib/hamdown/cli.rb

@@ -0,0 +1,18 @@
+module Hamdown
+  # CLI module
+  # it takes args with file path and return text to STDOUT
+  module Cli
+    def self.perform(args)
+      file_path = args[0]
+      if file_path.nil? || file_path.size == 0
+        puts 'Error: No file.'
+        puts 'Use it like: "bin/hamdown path_to/file.hd > output.html"'
+        return nil
+      end
+
+      content = File.open(file_path, 'r').read
+      output = Engine.perform(content)
+      puts output
+    end
+  end
+end

data/lib/hamdown/engine.rb

@@ -0,0 +1,20 @@
+require_relative 'md_handler'
+require_relative 'haml_handler'
+
+module Hamdown
+  # Main module
+  # Mahine to compile hamdown text to html
+  module Engine
+    # It takes string with hamdown text and compile it to html
+    def self.perform(hd_text = '')
+      return '' if hd_text.size == 0
+
+      # step 1: hamdown to haml + html
+      haml_text = MdHandler.perform(hd_text)
+
+      # step 2: haml + html to html
+      html_text = HamlHandler.perform(haml_text)
+      return html_text
+    end
+  end
+end

data/lib/hamdown/haml_handler.rb

@@ -0,0 +1,15 @@
+require 'haml'
+
+module Hamdown
+  # module to compile text (haml + html) to html
+  module HamlHandler
+    def self.perform(haml_text = '')
+      return '' if haml_text.size == 0
+
+      haml_engine = Haml::Engine.new(haml_text)
+      html = haml_engine.render
+
+      return html
+    end
+  end
+end

data/lib/hamdown/md_handler.rb

@@ -0,0 +1,33 @@
+require 'markdown'
+Dir["lib/hamdown/md_regs/*.rb"].each do |f|
+  require_relative f.gsub('lib/hamdown/', '')
+end
+
+module Hamdown
+  # Module to recognize markdown patterns in text and compile it to html
+  module MdHandler
+    # list of objects with rules:
+    # how to recognize markdown patterns by reg_ex
+    # how to replace it by html
+    OBJECTS = [
+      # lists should be before fonts
+      MdRegs::OList,
+      MdRegs::UList,
+      MdRegs::Headers,
+      MdRegs::Images,
+      MdRegs::Code,
+      # font should be before fonts2
+      MdRegs::Fonts,
+      MdRegs::Fonts2,
+      MdRegs::Quotes
+    ].freeze
+
+    # render text (haml + html) to html
+    def self.perform(text = '')
+      OBJECTS.each do |object|
+        text = object.new.perform(text)
+      end
+      text
+    end
+  end
+end

data/lib/hamdown/md_regs/abstract_reg.rb

@@ -0,0 +1,38 @@
+require 'markdown'
+
+module Hamdown
+  module MdRegs
+    # Abstract class
+    # each child should consist logic how to
+    # recognize markdown's pattern
+    # and how to replace it to html
+    # it uses markdown gem
+    class AbstractReg
+      REGS = {}
+
+      def perform(text = '')
+        regs_arr.each do |reg|
+          scan_res = text.scan(reg).to_a
+          next if scan_res.size == 0
+
+          text = text_handler(text, scan_res)
+        end
+        text
+      end
+
+      private
+
+      def text_handler
+        raise 'Does not implemented'
+      end
+
+      def md_to_html(text = '')
+        Markdown.new(text, banner: false).to_html
+      end
+
+      def regs_arr
+        self.class::REGS.values
+      end
+    end
+  end
+end

data/lib/hamdown/md_regs/code.rb

@@ -0,0 +1,27 @@
+module Hamdown
+  module MdRegs
+    # class with logic of markdown's code block
+    class Code < AbstractReg
+      REGS = {
+        'code' => /```[^`]*```/
+      }.freeze
+
+      private
+
+      def text_handler(text, scan_res)
+        html_scan = scan_res.map do |i|
+          # delete spaces before last '```'
+          # and other unused symbols
+          s = md_to_html(i.gsub(/ *```$/, '```'))
+          s[0..s.size - 2].gsub(/\~*\n/, "\n")
+        end
+        scan_res.each_with_index do |str, index|
+          # replace \n by html symbol
+          text.gsub!(str, html_scan[index].gsub("\n", '&#10;'))
+        end
+
+        text
+      end
+    end
+  end
+end

data/lib/hamdown/md_regs/fonts.rb

@@ -0,0 +1,30 @@
+module Hamdown
+  module MdRegs
+    # class with logic of markdown's bold, link, bold italic text
+    class Fonts < AbstractReg
+      REGS = {
+        'bold' => /(?<!\*|\\\*)\*{2,2}[^\*\n].+?[^\*]\*{2,2}(?!\*|\\)/,
+        'b_italic' => /(?<!\*|\\)\*{3,3}[^\*\n].+?[^\*|\\]\*{3,3}(?!\*)/,
+        'link' => /[^!]\[[^\[\]]*?\]\(.*?\)|^\[*?\]\(.*?\)/,
+      }.freeze
+
+      private
+
+      def text_handler(text, scan_res)
+        scan_res = scan_res.map { |i| i.lstrip  }
+        html_scan = scan_res.map do |i|
+            s = md_to_html(i)
+            # delete <p> in start and end of line
+            s = s[3, s.size]
+            s = s[0..s.size - 6]
+            s
+          end
+        scan_res.each_with_index do |str, index|
+          text.gsub!(str, html_scan[index])
+        end
+
+        text
+      end
+    end
+  end
+end

data/lib/hamdown/md_regs/fonts2.rb

@@ -0,0 +1,30 @@
+module Hamdown
+  module MdRegs
+    # class with logic of markdown's italic and monospace text
+    class Fonts2 < AbstractReg
+      # TODO: add '?:' to unuseful group /learn(?:bydoing)/
+      REGS = {
+        'italic' => /((?<!\*|\\)\*[^\*\n].+?[^\*|\\]\*(?!\*))|(_.+?_)/,
+        'monospace' => /[^`](`[^`]+`)/
+      }.freeze
+
+      private
+
+      def text_handler(text, scan_res)
+        scan_res = scan_res.map { |i| i[0] }.reject{ |i| i.nil? }
+        html_scan = scan_res.map do |i|
+          s = md_to_html(i)
+          # delete <p> in start and end of line
+          s = s[3, s.size]
+          s = s[0..s.size - 6]
+          s
+        end
+        scan_res.each_with_index do |str, index|
+          text.gsub!(str, html_scan[index])
+        end
+
+        text
+      end
+    end
+  end
+end

data/lib/hamdown/md_regs/headers.rb

@@ -0,0 +1,39 @@
+module Hamdown
+  module MdRegs
+    # class with logic of markdown's headers
+    class Headers < AbstractReg
+      # TODO: add '?:' to unuseful group /learn(?:bydoing)/
+      REGS = {
+        'h1' => /^(\s*# .+)$/,
+        'h2' => /^(\s*\#{2,2} .+)$/,
+        'h3' => /^(\s*\#{3,3} .+)$/,
+        'h4' => /^(\s*\#{4,4} .+)$/,
+        'h5' => /^(\s*\#{5,5} .+)$/,
+        'h6' => /^(\s*\#{6,6} .+)$/,
+      }.freeze
+
+      private
+
+      def text_handler(text, scan_res)
+        scan_res = scan_res.map { |i| i[0] }
+        html_scan = scan_res.map do |i|
+          # delete whitespace character
+          s = md_to_html(i.gsub(/^\s*/, ''))
+          # delete \n at end of line
+          if s[-1..-1] == "\n"
+            s = s[0..s.size - 2]
+          end
+          s
+        end
+        scan_res.each_with_index do |str, index|
+          text.gsub!(
+            str.gsub(/^\s*/, ''),
+            html_scan[index]
+          )
+        end
+
+        text
+      end
+    end
+  end
+end

data/lib/hamdown/md_regs/images.rb

@@ -0,0 +1,23 @@
+module Hamdown
+  module MdRegs
+    # class with logic of markdown's images
+    class Images < AbstractReg
+      REGS = {
+        'image' => /!\[[^\[\]]*?\]\(.*?\)/
+      }.freeze
+
+      private
+
+      def text_handler(text, scan_res)
+        html_scan = scan_res.map { |i| md_to_html(i) }
+        scan_res.each_with_index do |str, index|
+          s = html_scan[index]
+          # delete \n at end of string
+          text.gsub!(str, s[0..s.size - 2])
+        end
+
+        text
+      end
+    end
+  end
+end

data/lib/hamdown/md_regs/o_list.rb

@@ -0,0 +1,34 @@
+module Hamdown
+  module MdRegs
+    # class with logic of markdown's ordered lists
+    # TODO: add nested lists support
+    class OList < AbstractReg
+      # TODO: add '?:' to unuseful group /learn(?:bydoing)/
+      REGS = {
+        'o_list' => /((^ *\d{1,3}\. .*\n)+)/
+      }.freeze
+
+      private
+
+      def text_handler(text, scan_res)
+        # crazy manipulation
+        scan_res = scan_res.map { |i| i[0] }
+        html_scan = scan_res
+                    .map { |i| i.gsub(/^ */, '') }
+                    .map { |i| i.gsub(/\n( )*/, "\n")}
+                    .map { |i| md_to_html(i) }
+
+        html_scan = html_scan
+                    .map { |i| i.split(/\n */).join('') }
+                    .map { |i| "#{i}\n" }
+        scan_res.each_with_index do |str, index|
+          space_size = str.scan(/^ */)[0].size
+          html = html_scan[index].split(/\n/).join("\n#{' ' * space_size}")
+          html = "#{' ' * space_size}#{html}\n"
+          text.gsub!(str, html)
+        end
+        text
+      end
+    end
+  end
+end

data/lib/hamdown/md_regs/quotes.rb

@@ -0,0 +1,31 @@
+module Hamdown
+  module MdRegs
+    # class with logic of markdown's quotes
+    class Quotes < AbstractReg
+      # TODO: add '?:' to unuseful group /learn(?:bydoing)/
+      REGS = {
+        'quotes' => /((^\s*>{1,4} .+\n)+)/
+      }.freeze
+
+      private
+
+      def text_handler(text, scan_res)
+        # crazy manipulation
+        scan_res = scan_res.map{ |i| i[0] }
+        html_scan = scan_res.map do |i|
+          md_to_html(i)
+        end
+        scan_res.each_with_index do |str, index|
+          space_size = str.scan(/^\n( *)\>/)[0][0].size
+          html = html_scan[index]
+                  .split(/\n/)
+                  .select { |i| i.size > 0 }
+                  .join(' ')
+          text.gsub!(str, "\n#{' ' * space_size}#{html}")
+        end
+
+        text
+      end
+    end
+  end
+end

data/lib/hamdown/md_regs/u_list.rb

@@ -0,0 +1,37 @@
+module Hamdown
+  module MdRegs
+    # class with logic of markdown's unordered lists
+    # TODO: add nested lists support
+    class UList < AbstractReg
+      # TODO: add '?:' to unuseful group /learn(?:bydoing)/
+      REGS = {
+        'u_list' => /((^\s*[\*|\+] .*\n)+)/
+      }.freeze
+
+      private
+
+      def text_handler(text, scan_res)
+        # crazy manipulation
+        scan_res = scan_res.map { |i| i[0] }
+        html_scan = scan_res
+                    .map { |i| i.gsub(/^ */, '') }
+                    .map { |i| i.gsub(/\n( )*/, "\n")}
+                    .map { |i| md_to_html(i) }
+
+        html_scan = html_scan
+                    .map { |i| i.split(/\n */).join('') }
+                    .map { |i| "#{i}\n" }
+        scan_res.each_with_index do |str, index|
+          space_size = 0
+          if (str.scan(/^\n? */)[0].size - 2) > 0
+            space_size = str.scan(/^\n? */)[0].size - 1
+          end
+          html = html_scan[index].split(/\n/).join("\n#{' ' * space_size}")
+          html = "#{' ' * space_size}#{html}\n"
+          text.gsub!(str, html)
+        end
+        text
+      end
+    end
+  end
+end

data/lib/hamdown.rb

@@ -0,0 +1,6 @@
+require_relative 'hamdown/cli'
+require_relative 'hamdown/engine'
+
+module Hamdown
+  VERSION = '0.1.0'.freeze
+end

metadata

@@ -0,0 +1,66 @@
+--- !ruby/object:Gem::Specification
+name: hamdown-engine
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Ivan Nemytchenko
+- Vlad Kopylov
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-12-11 00:00:00.000000000 Z
+dependencies: []
+description: Next generation template language for fans of Haml and Markdown
+email: nemytchenko@gmail.com
+executables:
+- hamdown
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/hamdown
+- lib/hamdown.rb
+- lib/hamdown/cli.rb
+- lib/hamdown/engine.rb
+- lib/hamdown/haml_handler.rb
+- lib/hamdown/md_handler.rb
+- lib/hamdown/md_regs/abstract_reg.rb
+- lib/hamdown/md_regs/code.rb
+- lib/hamdown/md_regs/fonts.rb
+- lib/hamdown/md_regs/fonts2.rb
+- lib/hamdown/md_regs/headers.rb
+- lib/hamdown/md_regs/images.rb
+- lib/hamdown/md_regs/o_list.rb
+- lib/hamdown/md_regs/quotes.rb
+- lib/hamdown/md_regs/u_list.rb
+homepage: http://github.com/inem/hamdown/
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options:
+- "--line-numbers"
+- "--inline-source"
+- "--title"
+- Hamdown
+- "--main"
+- Hamdown
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.7
+signing_key: 
+specification_version: 2
+summary: Next generation template language for fans of Haml and Markdown
+test_files: []