ro 1.4.6 → 4.4.0

data/lib/ro/script.rb

@@ -0,0 +1,189 @@
+module Ro
+  def self.script(*args, &block)
+    Script.run!(*args, &block)
+  end
+
+  class Script
+    attr_accessor :cls, :env, :argv, :options, :mode, :stdout, :stdin, :stderr, :help
+
+    def run!(env = ENV, argv = ARGV)
+      initialize!(env, argv)
+      parse_command_line!
+      run_mode!
+    end
+
+    def initialize!(env, argv)
+      @cls = self.class
+      @env = env.to_hash.dup
+      @argv = argv.map { |arg| arg.dup }
+      @options = {}
+      @mode = nil
+      @stdout = $stdout.dup
+      @stdin = $stdin.dup
+      @stderr = $stderr.dup
+      @help = @cls.help
+    end
+
+    def parse_command_line!
+      argv = []
+      head = []
+      tail = []
+
+      %w[--].each do |stop|
+        next unless (i = @argv.index(stop))
+
+        head = @argv.slice(0...i)
+        tail = @argv.slice((i + 1)...@argv.size)
+        @argv = head
+        break
+      end
+
+      @argv.each do |arg|
+        if arg =~ /^\s*--([^\s-]+)=(.+)/
+          key = ::Regexp.last_match(1)
+          val = ::Regexp.last_match(2)
+          @options[key.to_sym] = val
+        elsif arg =~ /^\s*(-+)(.+)/
+          switch = ::Regexp.last_match(1)
+          key = ::Regexp.last_match(2)
+          val = switch.size.even?
+          @options[key.to_sym] = val
+        else
+          argv.push(arg)
+        end
+      end
+
+      argv += tail
+
+      @argv.replace(argv)
+
+      @mode = (@argv.shift if respond_to?("run_#{@argv[0]}!"))
+    end
+
+    def run_mode!
+      if @mode
+        send("run_#{@mode}!")
+      else
+        run
+      end
+    end
+
+    def run
+      help!
+    end
+
+    def run_help!
+      @stdout.puts(@help)
+    end
+
+    def help!
+      @stderr.puts(@help)
+      abort
+    end
+
+    def log(*messages, io: $stdout)
+      ts = Time.now.utc.iso8601
+      prefix = File.basename($0)
+      msg = messages.join("\n\s\s").strip
+
+      io.write "---\n[#{prefix}@#{ts}]\n\s\s#{msg}\n\n\n"
+
+      begin
+        io.flush
+      rescue StandardError
+        nil
+      end
+    end
+
+    def err(*messages)
+      log(*messages, io: @stderr)
+    end
+
+    @@SAY = {
+      clear: "\e[0m",
+      reset: "\e[0m",
+      erase_line: "\e[K",
+      erase_char: "\e[P",
+      bold: "\e[1m",
+      dark: "\e[2m",
+      underline: "\e[4m",
+      underscore: "\e[4m",
+      blink: "\e[5m",
+      reverse: "\e[7m",
+      concealed: "\e[8m",
+      black: "\e[30m",
+      red: "\e[31m",
+      green: "\e[32m",
+      yellow: "\e[33m",
+      blue: "\e[34m",
+      magenta: "\e[35m",
+      cyan: "\e[36m",
+      white: "\e[37m",
+      on_black: "\e[40m",
+      on_red: "\e[41m",
+      on_green: "\e[42m",
+      on_yellow: "\e[43m",
+      on_blue: "\e[44m",
+      on_magenta: "\e[45m",
+      on_cyan: "\e[46m",
+      on_white: "\e[47m"
+    }
+
+    def say(phrase, *args)
+      options = args.last.is_a?(Hash) ? args.pop : {}
+      options[:color] = args.shift.to_s.to_sym unless args.empty?
+      keys = options.keys
+      keys.each { |key| options[key.to_s.to_sym] = options.delete(key) }
+
+      color = options[:color]
+      bold = options.has_key?(:bold)
+
+      parts = [phrase]
+      parts.unshift(@@SAY[color]) if color
+      parts.unshift(@@SAY[:bold]) if bold
+      parts.push(@@SAY[:clear]) if parts.size > 1
+
+      method = options[:method] || :puts
+
+      if STDOUT.tty?
+        ::Kernel.send(method, parts.join)
+      else
+        ::Kernel.send(method, phrase)
+      end
+    end
+
+    def self.help(*args)
+      @help = args.join("\n") unless args.empty?
+      @help
+    end
+
+    def self.run(*args, &block)
+      modes =
+        if args.empty?
+          [nil]
+        else
+          args
+        end
+
+      modes.each do |mode|
+        method_name =
+          if mode
+            "run_#{mode}!"
+          else
+            'run'
+          end
+
+        define_method(method_name, &block)
+      end
+    end
+
+    def self.run!(&block)
+      STDOUT.sync = true
+      STDERR.sync = true
+
+      %w[PIPE INT].each { |signal| Signal.trap(signal, 'EXIT') }
+
+      Class.new(Script, &block).new.run!(ENV, ARGV)
+    end
+  end
+end

data/lib/ro/slug.rb

@@ -1,27 +1,28 @@
 module Ro
   class Slug < ::String
-    Join = '-'
+    @@JOIN = '-'
 
-    def Slug.for(*args)
+    class << Slug
+      def for(arg, *args, &block)
+        return arg if arg.is_a?(Slug) && args.empty? && block.nil?
+        new(arg, *args, &block)
+      end
+    end
+
+    def initialize(*args)
       options = args.last.is_a?(Hash) ? args.pop : {}
-      join = (options[:join]||options['join']||Join).to_s
+
+      join = (options[:join] || options['join'] || @@JOIN).to_s
+
       string = args.flatten.compact.join(join)
-      string = unidecode(string)
-      words = string.to_s.scan(%r|[/\w]+|)
-      words.map!{|word| word.gsub %r|[_-]|, join}
-      words.map!{|word| word.gsub %r|[^/0-9a-zA-Z_-]|, ''}
-      words.delete_if{|word| word.nil? or word.strip.empty?}
-      new(words.join(join).downcase.gsub('/', (join * 2)))
-    end
+      words = string.to_s.scan(%r{[/\w]+})
+      words.map! { |word| word.gsub(/[_-]/, join) }
+      words.map! { |word| word.gsub %r{[^/0-9a-zA-Z_-]}, '' }
+      words.delete_if { |word| word.nil? or word.strip.empty? }
 
-    unless defined?(Stringex::Unidecoder)
-      def Slug.unidecode(string)
-        string
-      end
-    else
-      def Slug.unidecode(string)
-        Stringex::Unidecoder.decode(string)
-      end
+      slug = words.join(join).downcase.gsub('/', (join * 2))
+
+      super(slug)
     end
   end
 end

data/lib/ro/template/rouge_formatter.rb

@@ -0,0 +1,42 @@
+module Ro
+  class Template
+    require 'rouge'
+
+    class RougeFormatter < ::Rouge::Formatters::HTMLInline
+      def initialize(opts)
+        theme = if opts.is_a?(Hash)
+                  opts[:theme] || opts['theme']
+                elsif opts.is_a?(Symbol)
+                  opts.to_s
+                else
+                  opts
+                end
+
+        super(theme)
+      end
+
+      def stream(tokens)
+        lineno = 1
+        yield "<code class='code' style='white-space:pre;'>"
+        token_lines(tokens).each do |line_tokens|
+          yield "<div class='code-line code-line-#{lineno}'>"
+          line_tokens.each do |token, value|
+            yield span(token, value)
+          end
+          yield "\n"
+          yield '</div>'
+          lineno += 1
+        end
+        yield '</code>'
+      end
+
+      def safe_span(tok, safe_val)
+        # return safe_val if tok == ::Rouge::Token::Tokens::Text
+        return safe_val.gsub(/\s/, '&nbsp;').gsub(/\n/, '<br />') if tok == ::Rouge::Token::Tokens::Text
+
+        rules = @theme.style_for(tok).rendered_rules
+        "<span style=\"#{rules.to_a.join(';')}\">#{safe_val}</span>"
+      end
+    end
+  end
+end

data/lib/ro/template.rb

@@ -1,77 +1,171 @@
 module Ro
   class Template
-    def Template.render(path, node = nil)
-      parts = File.basename(path).split('.')
-      base = parts.shift
-      exts = parts.reverse
+    require 'erb'
+    require 'rouge'
+    require 'kramdown'
+    require 'kramdown-parser-gfm'
+
+    require_relative 'html.rb'
+    require_relative 'template/rouge_formatter.rb'
+
+    def Template.render(*args, &block)
+      render_file(*args, &block)
+    end
+
+    def Template.render_file(path, options = {})
+      path = File.expand_path(path.to_s.strip)
+      options = Map.for(options.is_a?(Hash) ? options : { context: options })
 
       content = IO.binread(path).force_encoding('utf-8')
+      engines = File.basename(path).split('.')[1..-1]
+      context = options[:context]
 
-      loop do
-        break if exts.empty?
-        ext = exts.shift
+      begin
+        render_string(content, path: path, engines: engines, context: context)
+      rescue Ro::Error => e
+        msg = e.message
+        Ro.error! "failed to render #{ path } with `#{ msg }`"
+      end
+    end
 
-        case ext.to_s.downcase
-          when 'erb', 'eruby'
-            content = Ro.erb(content, node)
+    def Template.render_string(content, options = {})
+      content = String(content).force_encoding('utf-8')
+      options = Map.for(options.is_a?(Hash) ? options : { context: options })
+      engines = Array(options.fetch(:engines) { ['md'] }).flatten.compact
+      path = options.fetch(:path) { '(string)' }
+      context = options[:context]
 
-          when 'yml'
-            content = YAML.load(content)
+      loop do
+        break if engines.empty?
 
-          else
-            tilt = Tilt[ext] || Tilt['txt']
+        engine = engines.shift.to_s.strip.downcase
 
-            if tilt.nil?
-              content
+        content =
+          case engine
+            when 'html'
+              render_html(content)
+            when 'txt', 'text'
+              render_text(content)
+            when 'erb'
+              render_erb(content, context:)
+            when 'md', 'markdown'
+              render_markdown(content)
+            when 'yml', 'yaml'
+              render_yaml(content)
+            when 'json'
+              render_json(content)
+            when 'rb'
+              render_ruby(content)
+            when 'txt', 'text'
+              render_text(content)
             else
-              content = tilt.new{ content }.render(node)
-            end
-        end
+              Ro.error!("no engine found for engine=#{ engine.inspect } engines=#{ engines.inspect }")
+          end
       end
 
       content
     end
 
-    def Template.render_source(path, node = nil)
-      parts = File.basename(path).split('.')
-      base = parts.shift
-      exts = parts.reverse
+    def Template.render_html(html)
+      HTML.new(html)
+    end
 
-      content = IO.binread(path).force_encoding('utf-8')
+    def Template.render_json(json)
+      data = JSON.parse(json)
+      Ro.mapify(data)
+    end
 
-      loop do
-        break if exts.empty?
-        ext = exts.shift
-
-        if exts.empty?
-          code = content
-          language = ext
-          content = 
-            begin
-              ::Pygments.highlight(code, :lexer => language, :options => {:encoding => 'utf-8'})
-            rescue
-              content
-            end
+    def Template.render_yaml(yaml)
+      data = YAML.load(yaml)
+      Ro.mapify(data)
+    end
+
+    def Template.render_ruby(code)
+      string = IO.popen('ruby', 'w+'){|ruby| ruby.puts(code); ruby.close_write; ruby.read}
+
+      if $? == 0
+        string
+      else
+        Ro.error!("ruby:\n\n#{ code }")
+      end
+    end
+
+    def Template.render_text(text)
+      html = Text.render(text)
+      HTML.new(html)
+    end
+
+    def Template.render_erb(content, options = {})
+      content = String(content).force_encoding('utf-8')
+      options = Map.for(options.is_a?(Hash) ? options : { context: options })
+      context = options[:context]
+
+      erb = ERB.new(content, trim_mode: '%<>')
+
+      html =
+        if context.respond_to?(:to_hash)
+          hash = context.to_hash
+          erb.result_with_hash(hash)
         else
-          case ext.to_s.downcase
-            when 'erb', 'eruby'
-              content = Ro.erb(content, node)
-            when 'yml'
-              content = YAML.load(content)
-            else
-              tilt = Tilt[ext].new{ content  }
-              content = tilt.render(node)
-          end
+          binding = context ? context.instance_eval{ binding } : ::Kernel.binding
+          erb.result(binding)
         end
-      end
 
-      content
+      HTML.new(html)
     end
 
-    fattr :path
+    def Template.render_markdown(content, options = {})
+      content = String(content).force_encoding('utf-8')
+      options = Map.for(options.is_a?(Hash) ? options : { context: options })
+
+      theme = options.fetch(:theme) { Ro.config.md_theme }
+
+      parsed = FrontMatterParser::Parser.new(:md).call(content)
+      front_matter = parsed.front_matter
+      content = parsed.content
+
+      opts = {
+        input: 'GFM',
+        hard_wrap: false,
+        syntax_highlighter_opts: { formatter: RougeFormatter, theme: theme }
+      }
+
+      div =
+        <<~_____
+          <div class="ro markdown">
+            #{ ::Kramdown::Document.new(content, opts).to_html }
+          </div>
+        _____
+
+      html = Rinku.auto_link(div, :all, 'target="_blank"')
+
+      HTML.new(html, front_matter:)
+    end
+
+    def Template.render_src(path, options = {})
+      path = File.expand_path(path.to_s.strip)
+      options = Map.for(options.is_a?(Hash) ? options : { context: options })
+
+      content = IO.binread(path).force_encoding('utf-8')
+      engines = File.basename(path).split('.')[1..-1].reverse
+      context = options[:context]
+
+      theme = options.fetch(:theme) { Ro.config.md_theme }
+      formatter = RougeFormatter.new(theme: theme)
+
+      language = engines.shift
+
+      lexer = Rouge::Lexer.find(language) || Ro.error!('no lexer found for ')
+
+      content = render_string(content, path: path, engines: engines, context: context) if engines.size.nonzero?
 
-    def initialize(path)
-      @path = Ro.realpath(path)
+      HTML.new(
+        <<~_____
+          <div class="ro markdown src">
+            #{ formatter.format(lexer.lex(content)) }
+          </div>
+        _____
+      )
     end
   end
 end

data/lib/ro/text.rb

@@ -0,0 +1,120 @@
+module Ro
+  require 'cgi'
+
+  module Text
+    def render(text)
+      text = text.to_s.strip
+      return '' if text.empty?
+
+      text = escape_html(text)
+      text = auto_link_urls(text)
+      text = auto_link_email_addresses(text)
+      text = paragraphs_for(text)
+
+      return text
+    end
+
+    def paragraphs_for(text)
+      paragraphs = text.split(%r`\n\n+`).map{|chunk| lines_for(chunk)}
+      paragraphs.map{|p| "<p>\n#{ p }\n</p>"}.join("\n\n").strip
+    end
+
+    def lines_for(text)
+      text.strip.gsub(/\n/, "<br />\n")
+    end
+
+    def escape_html(text)
+      CGI.escapeHTML(text)
+    end
+
+    AUTO_LINK_RE = %r{
+        (?: ((?:ed2k|ftp|http|https|irc|mailto|news|gopher|nntp|telnet|webcal|xmpp|callto|feed|svn|urn|aim|rsync|tag|ssh|sftp|rtsp|afs|file):)// | www\.\w )
+        [^\s<\u00A0"]+
+      }ix
+
+    # regexps for determining context, used high-volume
+    AUTO_LINK_CRE = [/<[^>]+$/, /^[^>]*>/, /<a\b.*?>/i, /<\/a>/i]
+
+    AUTO_EMAIL_LOCAL_RE = /[\w.!#\$%&'*\/=?^`{|}~+-]/
+    AUTO_EMAIL_RE = /(?<!#{AUTO_EMAIL_LOCAL_RE})[\w.!#\$%+-]\.?#{AUTO_EMAIL_LOCAL_RE}*@[\w-]+(?:\.[\w-]+)+/
+
+    BRACKETS = { ']' => '[', ')' => '(', '}' => '{' }
+
+    WORD_PATTERN = '\p{Word}'
+
+    # Turns all urls into clickable links.  If a block is given, each url
+    # is yielded and the result is used as the link text.
+    def auto_link_urls(text)
+      text.gsub(AUTO_LINK_RE) do
+        scheme, href = $1, $&
+        punctuation = []
+        trailing_gt = ""
+
+        if auto_linked?($`, $')
+          # do not change string; URL is already linked
+          href
+        else
+          # don't include trailing punctuation character as part of the URL
+          while href.sub!(/[^#{WORD_PATTERN}\/\-=;]$/, '')
+            punctuation.push $&
+            if opening = BRACKETS[punctuation.last] and href.scan(opening).size > href.scan(punctuation.last).size
+              href << punctuation.pop
+              break
+            end
+          end
+
+          # don't include trailing &gt; entities as part of the URL
+          trailing_gt = $& if href.sub!(/&gt;$/, '')
+          href = 'http://' + href unless scheme
+          link = escape_html(href)
+          "<a href='#{ link }'>#{ link }</a>" + punctuation.reverse.join('') + trailing_gt
+        end
+      end
+    end
+
+    # Turns all email addresses into clickable links.  If a block is given,
+    # each email is yielded and the result is used as the link text.
+    def auto_link_email_addresses(text)
+      text.gsub(AUTO_EMAIL_RE) do
+        text = $&
+
+        if auto_linked?($`, $')
+          text
+        else
+          email = escape_html(text)
+          "<a href='mailto:#{ email }'>#{ email }</a>"
+        end
+      end
+    end
+
+    # Detects already linked context or position in the middle of a tag
+    def auto_linked?(left, right)
+      (left =~ AUTO_LINK_CRE[0] and right =~ AUTO_LINK_CRE[1]) or
+        (left.rindex(AUTO_LINK_CRE[2]) and $' !~ AUTO_LINK_CRE[3])
+    end
+
+    extend self
+  end
+end
+
+
+if $0 == __FILE__
+  text = <<~____
+    this is a paragraph that is very long this is a paragraph that is very long this is a paragraph that is very long this is a paragraph that is very long
+    this is a paragraph that is very long this is a paragraph that is very long this is a paragraph that is very long this is a paragraph that is very long
+
+    this is a paragraph that is very long this is a paragraph that is very long this is a paragraph that is very long this is a paragraph that is very long
+
+    - a
+    - b
+    - c
+
+    & < > me
+
+    http://drawohara.io>
+
+    ara.t.howard@gmail.com
+  ____
+
+  puts Ro::Text.render(text)
+end