mdextab 0.1.0

data/Gemfile

@@ -0,0 +1,4 @@
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in mdextab.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2019 yasuo kominami
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,41 @@
+mainly extend table tag of HTML5 of Makrdown on Pandoc
+
+# Mdextab
+
+Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/mdextab`. To experiment with that code, run `bin/console` for an interactive prompt.
+
+TODO: Delete this and the text above, and describe your gem
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'mdextab'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install mdextab
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/ykominami/mdextab.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "mdextab"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/makemdtab

@@ -0,0 +1,304 @@
+#!/usr/bin/env ruby
+# -*- coding: utf-8 -*-
+
+require 'bundler/setup'
+require 'mdextab'
+require 'digest'
+
+require 'simpleoptparse'
+require 'byebug'
+
+EXIT_CODE_NORMAL_EXIT=0
+EXIT_CODE_CANNOT_FILE_FILE=101
+EXIT_CODE_CANNOT_WRITE_FILE=102
+EXIT_CODE_ARGV_SIZE=103
+EXIT_CODE_MISSING_REQUIRED_ARGUMENT=104
+EXIT_CODE_CANNOTFIND_YAMLFILE_OR_EMPTY=105
+EXIT_CODE_YAMLFILE_IS_EMPTY=106
+EXIT_CODE_CANNOTFIND_ERUBYFILE_OR_EMPTY=107
+EXIT_CODE_ERUBYFILE_IS_EMPTY=108
+EXIT_CODE_CANNOTFIND_MDFILE_OR_EMPTY=109
+EXIT_CODE_MDFILE_IS_EMPTY=110
+
+class Makemdtab
+  def initialize(opts, erubyfnames)
+    @dataop=opts["dataop"]
+    @datayamlfname=opts["data"]
+    @yamlop=opts["yamlop"]
+    @yamlfname=opts["setting"]
+    @auxyamlfname=opts["auxsetting"]
+    @erubyfnames=erubyfnames
+    @outputfname=opts["output"]
+
+    @exit_cannot_find_file=1
+    @exit_cannot_write_file=2
+
+    @erubies = {}
+
+    @logger=Logger.new(STDOUT)
+    @logger.level = Logger::INFO
+    @logger.level = Logger::DEBUG if opts["debug"]
+    @logger.formatter = proc do |severity, datetime, progname, msg|
+      "#{msg}\n"
+    end
+
+    [@datayamlfname, @yamlfname, @auxyamlfname, @erubyfnames].flatten.each do |fname|
+      next if File.exist?(fname)
+
+      mes="Can't find #{fname}"
+      outputError(mes)
+      exit(EXIT_CODE_CANNOT_FILE_FILE)
+    end
+
+    begin
+      @output = File.open(@outputfname, 'w')
+    rescue RuntimeError => ex
+      mes2 = "Can't write #{@outputfname}"
+      outputError(mes2)
+      exit(EXIT_CODE_CANNOT_WRITE_FILE)
+    end
+  end
+
+  def outputError(mes)
+    if @logger
+      @logger.error(mes)
+    else
+      STDERR.puts(mes)
+    end
+  end
+
+  def makeMd()
+    load(@dataop, @datayamlfname, @yamlop, @auxyamlfname, @yamlfname, @erubyfnames).map{|x| 
+      @output.puts(x)
+    }
+  end
+
+  def load(dataop, datayamlfname, yamlop, auxyamlfname, yamlfname, erubyfnames)
+    eruby0 = nil
+    eruby1 = nil
+    obj = {}
+    obj0 = YAML.load_file(auxyamlfname) if auxyamlfname
+    obj = obj0 if obj0
+
+    case yamlop
+    when :MERGE
+      obj2 = YAML.load_file(yamlfname)
+      if obj2
+        if obj
+          objx = obj.merge(obj2) 
+        else
+          objx = obj2
+        end
+      else
+        objx = obj
+      end
+    when :REPLACE
+      str = File.read(yamlfname)
+      str2 = Erubis::Eruby.new(str).result(obj)
+      objx0 = YAML.load(str2)
+      if objx0
+        objx = objx
+      else
+        objx = {}
+      end
+    else
+      # do nothing
+    end
+
+    erubystr=erubyfnames.map{|x| checkAndLoadErubyfile(x)}.join("\n")
+    if @dataop == :PATTERN_FOUR
+      mdfname=datayamlfname
+      objx["PARENT_DIR"] = ENV['MDEXTAB_MAKE']
+
+      mdstr=checkAndLoadMdfile(mdfname)
+
+      dx = [erubystr, mdstr].join("\n")
+      @erubies[mdfname] ||= Erubis::Eruby.new(dx)
+      array=[@erubies[mdfname].result(objx)]
+    else
+      puts "datayamlfname=#{datayamlfname}"
+      strdata2=checkAndExpandYamlfile(datayamlfname, objx) 
+      data = YAML.load(strdata2)
+if data.class != Hash
+  puts "strdata2=#{strdata2}"
+  p data
+  exit(300)
+end
+      erubyfname=erubyfnames.last
+      case dataop
+      when :PATTERN_ONE
+        array=loadWithPattern1(data, erubyfname, erubystr)
+      when :PATTERN_TWO
+        array=loadWithPattern2(data, erubyfname, erubystr)
+      when :PATTERN_THREE
+        dir=File.dirname(datayamlfname)
+        array=loadWithPattern3(data, erubyfname, erubystr, dir)
+      else
+        array=[]
+        # do nothing
+      end
+    end
+    array
+  end
+
+  def checkAndLoadErubyfile(erubyfname)
+    size=File.size?(erubyfname)
+    if size and size > 0
+      erubystr=File.read(erubyfname)
+    else
+      mes=%Q!Can not find #{erubyfname} or is empty!
+      outputError(mes)
+      exit(EXIT_CODE_CANNOTFIND_ERUBYFILE_OR_EMPTY)
+    end
+    if erubystr.strip.empty?
+      mes=%Q!#{erubyfname} is empty!
+      outputError(mes)
+      exit(EXIT_CODE_ERUBYFILE_IS_EMPTY)
+    end
+    erubystr
+  end
+
+  def checkAndLoadMdfile(mdfname) 
+    size2=File.size?(mdfname)
+    if size2 and size2 > 0
+      mdstr=File.read(mdfname)
+    else
+      mes=%Q!Can not find #{mdfname} or is empty!
+      outputError(mes)
+      exit(EXIT_CODE_CANNOTFIND_MDFILE_OR_EMPTY)
+    end
+    if mdstr.strip.empty?
+      mes=%Q!#{mdfname} is empty!
+      outputError(mes)
+      exit(EXIT_CODE_MDFILE_IS_EMPTY)
+    end
+    mdstr
+  end
+
+  def checkAndExpandYamlfile(yamlfname, objx) 
+    size=File.size?(yamlfname)
+    if size and size > 0
+      puts File.mtime(yamlfname)
+      strdata = File.read(yamlfname)
+    else
+      mes=%Q!Can not find #{yamlfname} or is empty!
+      outputError(mes)
+      exit(EXIT_CODE_CANNOTFIND_YAMLFILE_OR_EMPTY)
+    end
+
+    if strdata.strip.empty?
+      mes=%Q!#{yamlfname} is empty!
+      outputError(mes)
+      exit(EXIT_CODE_YAMLFILE_IS_EMPTY)
+    else
+      puts Digest::MD5.hexdigest(strdata)
+      #
+      strdata2 = Erubis::Eruby.new(strdata).result(objx)
+    end
+
+    strdata2
+  end
+ 
+  def loadWithPattern1(data, erubyfname, erubystr)
+    @erubies[erubyfname] ||= Erubis::Eruby.new(erubystr)
+    [@erubies[erubyfname].result(data)]
+  end
+
+  def loadWithPattern2(data, erubyfname, erubystr)
+    data.map{ |x|
+      @erubies[erubyfname] ||= Erubis::Eruby.new(erubystr)
+      @erubies[erubyfname].result(x)
+    }
+  end
+
+  def loadWithPattern3(data, erubyfname, erubystr, dir)
+    hs={}
+    data.each do |k,v|
+      if /items/.match(k)
+        hs[k]=[]
+        v.each do |v2|
+          if /^path=(.*)/.match(v2)
+            hs[k] << File.join(dir, $1)
+          else
+            hs[k] << v2
+          end
+        end
+      else
+        hs[k]=v
+      end
+    end
+    @erubies[erubyfname] ||= Erubis::Eruby.new(erubystr)
+    [@erubies[erubyfname].result(hs)]
+  end
+
+  def postProcess
+    @output.close if @output
+    @output = nil
+  end
+end
+
+opts = {}
+banner = "Usage: bundle exec ruby bin/makemdtab [--contest] [--debug] -o outfname -d datafname --y merge|replace -p pattern_one|pattern_two|pattern_three -s yamlfname [-a auxyamlfname] erubyfname [erubyfname2 *]"
+if ARGV.size == 0
+  puts(banner)
+  exit(EXIT_CODE_ARGV_SIZE)
+end
+
+Simpleoptparse::Simpleoptparse.parse(ARGV , opts , banner , Mdextab::VERSION , nil){ |parser|
+  parser.on('--debug'  ) {|x| opts["debug"] = true}
+  parser.on('--contest'  ) {|x| opts["kind"] = :contest}
+  parser.on('-d value', '--data' ,'data file') {|x| opts["data"] = x}
+  parser.on('-s value', '--setting') {|x| opts["setting"] = x}
+  parser.on('-a [value]', '--auxsetting') {|x| opts["auxsetting"] = x}
+  parser.on('-o value', '--output') {|x| opts["output"] = x}
+  parser.on('-y value', '--yamlop') {|x| 
+                                         case x.upcase
+                                         when /^MERGE/
+                                         opts["yamlop"] = :MERGE
+                                         when /^REPLACE/
+                                         opts["yamlop"] = :REPLACE
+                                         else
+                                           # do nothing
+                                         end
+                                       }
+  parser.on('-p value', '--dataop') {|x| 
+                                         case x.upcase
+                                         when /^PATTERN_ONE/
+                                           opts["dataop"] = :PATTERN_ONE
+                                         when /^PATTERN_TWO/
+                                           opts["dataop"] = :PATTERN_TWO
+                                         when /^PATTERN_THREE/
+                                           opts["dataop"] = :PATTERN_THREE
+                                         when /^PATTERN_FOUR/
+                                           opts["dataop"] = :PATTERN_FOUR
+                                         else
+                                           # do nothing
+                                         end
+                                       }
+}
+
+unless opts["output"] and opts["yamlop"] and opts["dataop"]
+  puts(banner)
+  puts "don't be specified -d output" unless opts["output"]
+  puts "don't be specified -y value" unless opts["yamlop"]
+  puts "don't be specified -p value" unless opts["dataop"]
+  p ARGV
+  p opts
+  exit(EXIT_CODE_MISSING_REQUIRED_ARGUMENT)
+end
+
+puts "# makemdtab Start #"
+puts "|||||||||||| opts['output']=#{opts['output']}"
+puts "|||||||||||| ARGV=#{ARGV}"
+opts.each do |k,v|
+  puts "|||||||||||| opts[#{k}]=#{v}"
+end
+
+x=Makemdtab.new(opts, ARGV)
+x.makeMd()
+x.postProcess
+puts "# makemdtab End #"
+exit(EXIT_CODE_NORMAL_EXIT)
+
+
+

data/bin/mdextab

@@ -0,0 +1,28 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'mdextab'
+
+require 'simpleoptparse'
+
+opts = {  }
+banner = "Usage: bundle exec ruby bin/mdextab in_md_fname out_md_fname settng_yaml auxiliary_setting_yaml"
+
+Simpleoptparse::Simpleoptparse.parse(ARGV , opts , banner , Mdextab::VERSION , nil){|parser|
+    parser.on('-d', '--debug'  ) {|x| opts["debug"] = true }
+}
+
+fname = ARGV[0]
+oFname = ARGV[1]
+yamlFname = ARGV[2]
+auxiliaryYamlFname = ARGV[3]
+m = Mdextab::Mdextab.new(opts,fname,oFname,yamlFname,auxiliaryYamlFname)
+m.parse
+m.end
+
+puts "##### Mdextab fname=#{fname}"
+puts "##### Mdextab oFname=#{oFname}"
+puts "##### Mdextab yamlFname=#{yamlFname}"
+puts "##### Mdextab auxiliaryYamlFname=#{auxiliaryYamlFname}"
+
+exit(0)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/exe/mdextab

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+
+require "mdextab"

data/lib/mdextab/loggerx.rb

@@ -0,0 +1,58 @@
+require 'logger'
+
+module Mdextab
+  class Loggerx
+    def initialize(fname)
+      @loggerSTDOUT = Logger.new(STDOUT)
+      @loggerSTDOUT.level = Logger::UNKNOWN
+      @loggerSTDOUT.formatter = proc do |severity, datetime, progname, msg|
+        "#{severity[0]}: #{msg}\n"
+#        "#{msg}\n"
+      end    
+      file = File.open( fname , 'w')
+      @loggerFILE = Logger.new(file)
+      @loggerFILE.level = Logger::INFO
+      @loggerFILE.formatter = proc do |severity, datetime, progname, msg|
+        "#{severity}: #{msg}\n"
+#       "#{msg}\n"
+      end    
+    end
+
+    def datetime_format=(format)
+      @loggerSTDOUT.datetime_format=format
+      @loggerFILE.datetime_format=format
+    end
+
+    def level=(value)
+      puts value
+      @loggerSTDOUT.level=value
+      @loggerFILE.level=value
+    end
+
+    def set_level(value)
+      puts value
+      @loggerSTDOUT.level=value
+      @loggerFILE.level=value
+    end
+
+    def debug(mes)
+      @loggerSTDOUT.debug(mes)
+      @loggerFILE.debug(mes)
+    end
+
+    def error(mes)
+      @loggerSTDOUT.error(mes)
+      @loggerFILE.error(mes)
+    end
+
+    def fatal(mes)
+      @loggerSTDOUT.fatal(mes)
+      @loggerFILE.fatal(mes)
+    end
+
+    def info(mes)
+      @loggerSTDOUT.info(mes)
+      @loggerFILE.info(mes)
+    end
+  end
+end

data/lib/mdextab/table.rb

@@ -0,0 +1,51 @@
+require 'forwardable'
+
+module Mdextab
+  class Table
+    extend Forwardable
+    def_delegators :@tbody, :add_th, :add_td, :tdAppend, :thAppend, :add
+    attr_reader :lineno, :tbody
+
+    def initialize(lineno, logger,attr=nil)
+      @lineno = lineno
+      @attr = attr
+      @tbody = nil
+      @logger = logger
+    end
+
+    def add_tbody(lineno)
+      @tbody = Tbody.new(lineno, @logger)
+    end
+
+    def tbody_end
+      @tbody.end
+    end
+
+    def end
+      table_end
+    end
+
+    def table_end
+      to_s
+    end
+
+    def to_s(debug=false)
+      if @attr
+        if debug
+          str_1 = %Q!<table #{@attr} lineno:#{@lineno}>! 
+        else
+          str_1 = %Q!<table #{@attr}>! 
+        end
+      else
+        if debug
+          str_1 = %Q!<table  lineno:#{@lineno}>!
+        else
+          str_1 = %Q!<table>!
+        end
+      end
+
+      [str_1, @tbody.to_s, "</table>"].join("\n")
+    end
+
+  end
+end

data/lib/mdextab/tbody.rb

@@ -0,0 +1,55 @@
+module Mdextab
+  class Tbody
+    attr_reader :lineno
+
+    def initialize(lineno, logger)
+      @array = []
+      @tr = nil
+      @th = nil
+      @td = nil
+      @lineno = lineno
+      @logger = logger
+    end
+
+    def add_th(lineno, content, nth, attr=nil, condense)
+      if nth == 1
+        @tr = Tr.new(lineno)
+        @array << @tr
+      end
+      @th = Th.new(lineno, attr)
+      @th.add(content, condense)
+      @tr.add(@th)
+    end
+
+    def add_td(lineno, content, nth, attr=nil, condense)
+      @logger.debug( "content=#{content}|nth=#{nth}|attr=#{attr}" )
+      if nth == 1
+        @tr = Tr.new(lineno)
+        @array << @tr
+      end
+      @td = Td.new(lineno,attr)
+      @td.add(content, condense)
+      @tr.add(@td)
+    end
+
+    def tdAppend(content, condense)
+      @td.add(content, condense)
+    end
+
+    def thAppend(content, condense)
+      @th.add(content, condense)
+    end
+
+    def add(cont)
+      @array << cont
+    end
+
+    def end
+      @tr = nil
+    end
+
+    def to_s
+      ["<tbody>" , @array.map{|x| x.to_s} , "</tbody>"].join("\n")
+    end
+  end
+end

data/lib/mdextab/td.rb

@@ -0,0 +1,31 @@
+  class Td
+    def initialize(lineno, attr=nil)
+      @lineno = lineno
+      @attr = attr
+      @content = ""
+    end
+
+    def add(content, condnese)
+      if condnese
+        if @content
+          if @contnet.match?(/^\s*$/)
+            @content=content.to_s
+          else
+            @content+=content.to_s
+          end
+        else
+          @content=content.to_s
+        end
+      else
+        @content = [@content, content].join("\n") if content
+      end
+    end
+
+    def to_s
+      if @attr != nil
+        %Q!<td #{@attr}>#{@content}</td>!
+      else
+        %Q!<td>#{@content}</td>!
+      end
+    end
+  end

data/lib/mdextab/th.rb

@@ -0,0 +1,33 @@
+module Mdextab
+  class Th
+    def initialize(lineno, attr=nil)
+      @lineno = lineno
+      @attr = attr
+      @content = ""
+    end
+
+    def add(content, condense)
+      if condense
+        if @content
+          if @content.match?(/^\s*$/)
+            @content = content.to_s
+          else
+            @content+=content.to_s
+          end
+        else
+          @content=content.to_s
+        end
+      else
+        @content = [@content , content].join("\n") if content
+      end
+    end
+
+    def to_s
+      if @attr != nil
+        %Q!<th #{@attr}>#{@content}</th>!
+      else
+        %Q!<th>#{@content}</th>!
+      end
+    end
+  end
+end

data/lib/mdextab/token.rb

@@ -0,0 +1,11 @@
+module Mdextab
+  class Token
+    attr_reader :kind, :opt
+
+    def initialize(kind , opt={})
+      @kind = kind
+      @opt = opt
+    end
+  end
+end
+

data/lib/mdextab/tr.rb

@@ -0,0 +1,16 @@
+module Mdextab
+  class Tr
+    def initialize(lineno)
+      @lineno = lineno
+      @array = []
+    end
+
+    def add(cont)
+      @array << cont
+    end
+
+    def to_s
+      ["<tr>", @array.map{|x| x.to_s} , "</tr>"].join("\n")
+    end
+  end
+end