cheap-impression-presenter 1.0.0

data/README.md

@@ -0,0 +1,71 @@
+CHIMP - Cheap IMpression Presenter
+==================================
+
+           __        _____
+      ___ / /___    / _ \ \ ___
+     / __| |/ _ \  | | | | |__ \
+    | (__| | (_) | | |_| | |__) |
+     \___| |\_!!(_|_)!!__| |___/
+          \_\           /_/
+
+Make a cheap impression. Present via terminal.
+
+```gem install chimp```
+
+It has a simple syntax:
+
+    #what: the title of presentation
+
+    --- splits slides
+
+    +++ slides parts to appear
+
+    !!Bold Text!!
+    ``Red Text``
+    %%Blue Text%%
+
+Everything else is in plugins. The following plugins are existing for now:
+
+* Sixel: display graphics in the terminal: `` ```sixel name.png``.
+* Figlet: display fancy ascii text: `` ```figlet FANCY_TEXT``.
+* Line Numbers: display line numbers beforce any text.
+~~~text
+```figlet
+Line
+Line
+Line
+```
+~~~
+
+During presenting you can use the usual button for navigating. In addition, you
+can use ``q`` to quit the presentation, and ``r`` to refresh the screen.
+
+Check out the examples.
+
+History & Thanks
+================
+
+Amy Hoy allowed me to use the logo for CHIMP all the way back in 2009. The
+CHIMP was written as an icebreaker for the curucamp, which was a ruby
+un-conference in 2009 in Vienna. We had fun, and many cool people from the
+community attended.
+
+I am still using the CHIMP for scientifc presentations, and as sixel terminals
+finally are more common, I tried to polish it up (2025) and make it available
+for easy consumption. Maybe you like it. I use it because I can create
+presentations faster than in PP, KN, other programs. Most of the work goes
+into graphics anyway, which I create with dedicated tools.
+
+Drop me a note if you want to be a contributor, or send me merge request if you
+have created some plugins. Creating plugins is very simple :-)
+
+Missing Features
+================
+
+Presenting is nice. A PDF output mode would be useful. To send the presentation
+to people in one file.
+
+LICENSE
+=======
+
+GPL 3.0 or later.

data/Rakefile

@@ -0,0 +1,26 @@
+require 'rake'
+require 'rubygems/package_task'
+
+spec = eval(File.read('chimp.gemspec'))
+Gem::PackageTask.new(spec) do |pkg|
+  pkg.need_zip = true
+  pkg.need_tar = true
+  puts `ls -al pkg/*`
+  `rm pkg/* -rf`
+  `ln -sf #{pkg.name}.gem pkg/chimp.gem`
+end
+
+task :push => :gem do |r|
+  `gem push pkg/chimp.gem`
+end
+
+task :install => :gem do |r|
+  `gem install pkg/chimp.gem`
+end
+
+# task :release => :gem do |r|
+#   GIT_COMMITTER_DATE="$(git show develop --format=%aD | head -1)" \
+#   git tag -a "v1.7.0" develop -m "tag v1.7.0" \
+#   && git push --tags origin develop \
+#   && git --no-pager tag --list --format='%(refname)   %(taggerdate)'
+# end

data/chimp.gemspec

@@ -0,0 +1,25 @@
+Gem::Specification.new do |s|
+  s.name             = "cheap-impression-presenter"
+  s.version          = "1.0.0"
+  s.platform         = Gem::Platform::RUBY
+  s.license          = "GPL-3.0-or-later"
+  s.summary          = "CHIMP - Make a cheap impression. Present via terminal."
+
+  s.description      = "see https://github.com/etm/chimp"
+
+  s.files            = Dir['{example/*.txt,example/*.png,example/*.svg,tools/**/*,lib/**/*,}'] + %w(LICENSE INSTALL.md Rakefile chimp.gemspec AUTHORS)
+  s.require_path     = 'lib'
+  s.extra_rdoc_files = ['README.md','INSTALL.md']
+  s.bindir           = 'tools'
+  s.executables      = ['chimp']
+
+  s.required_ruby_version = '>=2.7.0'
+
+  s.authors          = ['Juergen eTM Mangler']
+
+  s.email            = 'juergen.mangler@gmail.com'
+  s.homepage         = 'https://github.com/etm/chimp'
+
+  s.add_runtime_dependency 'tty-screen', '~> 0.8'
+  s.add_runtime_dependency 'pastel', '~> 0.8'
+end

data/lib/ChimpParser-Grammar.rb

@@ -0,0 +1,60 @@
+require_relative 'ChimpParser'
+
+module Chimp
+  class Parser
+
+    class SimpleGrammar < Grammar
+      #### Patterns ####
+      #### Name of pattern has to be the first parameter to pattern ####
+      #### According to the names the methods are selected ####
+
+      P_SLIDES      = Pattern.new("P_SLIDES",      /---+.*?(\z|\n)|\A/,                  /^(?=---+)|\z/)
+      P_WHAT        = Pattern.new("P_WHAT",        /^#\s*what:\s*/,                      /[\t ]*(\n|\z)/)
+      P_INCREMENTAL = Pattern.new("P_INCREMENTAL", /\+\+\++.*?(\z|\n)|\A/,               /^(?=\+\+\++)|\z/)
+      P_RANGE       = Pattern.new("P_RANGE",       /^```([a-z0-9_]+,)*[a-z0-9_]+[\t ]*/, /^```[\t ]*(\n|\z)/)
+      P_INCLUDE     = Pattern.new("P_INCLUDE",     /^```([a-z0-9_]+,)*[a-z0-9_]+[\t ]+/, /[\t ]*(\n|\z)/)
+      P_CENTER      = Pattern.new("P_CENTER",     /^~~/,                                /[\t ]*(\n|\z)/)
+      P_STRONG      = Pattern.new("P_STRONG",      /!!/,                                 /!!/)
+      P_RED         = Pattern.new("P_RED",         /''/,                                 /''/)
+      P_BLUE        = Pattern.new("P_BLUE",        /%%/,                                 /%%/)
+      P_STRONGRED   = Pattern.new("P_STRONGRED",   /(!!''|''!!)/,                        /(''!!|!!'')/)
+      P_STRONGBLUE  = Pattern.new("P_STRONGBLUE",  /(!!%%|%%!!)/,                        /(%%!!|!!%%)/)
+
+      #### Grammar ####
+      #### ROOT must exist and holds the main first level patterns ####
+      #### G + patternname is selected to look up nested patterns ####
+      #### If G + patternname not exists, [] is assumend ####
+
+      ROOT           = [ P_WHAT, P_SLIDES ]
+      GP_SLIDES      = [ P_INCREMENTAL ]
+      GP_INCREMENTAL = [ P_CENTER, P_RANGE, P_INCLUDE, P_STRONGRED, P_STRONGBLUE, P_STRONG, P_RED, P_BLUE ]
+
+      ### Optional functions called when a pattern occurs (m + patternname) ####
+      def mP_CENTER(ts,ti,te)
+        @tree.last.data = ti.length
+        ti
+      end
+
+      def mP_INCLUDE(ts,ti,te)
+        @tree.last.data = {}
+        @tree.last.data[:name] = ts[3..-1].strip.split(',')[0]
+        @tree.last.data[:parameters] = ts[3..-1].strip.split(',')[1..-1]
+        @tree.last.data[:additional] = @parameters
+        @tree.last.data[:what] = ti.lstrip
+        ''
+      end
+      def mP_RANGE(ts,ti,te)
+        @tree.last.data = {}
+        @tree.last.data[:name] = ts[3..-1].strip.split(',')[0]
+        @tree.last.data[:parameters] = ts[3..-1].strip.split(',')[1..-1]
+        @tree.last.data[:what] = ti.lstrip
+        ''
+      end
+      def mP_WHAT(ts,ti,te)
+        @tree.last.data = ti
+        ''
+      end
+    end
+
+  end
+end

data/lib/ChimpParser.rb

@@ -0,0 +1,215 @@
+require 'strscan'
+require 'pp'
+
+module Chimp
+  class Parser
+    class OpenTag
+      attr_reader :ttype, :level
+      attr_accessor :data, :close, :userdata
+      def initialize(ttype,level)
+        @ttype = ttype
+        @data = nil
+        @close = -1
+        @userdata = nil
+        @level = level
+      end
+    end
+    class CloseTag
+      attr_reader :ttype, :open, :position_in_markup, :level
+      def initialize(ttype,open,position_in_markup,level)
+        @ttype = ttype
+        @open = open
+        @position_in_markup = position_in_markup
+        @level = level
+      end
+    end
+
+    class TagEvent < Exception; end
+    class TagSkipEvent < Exception; end
+    class TagMoveEvent < Exception; end
+    class TagContentSkipEvent < Exception; end
+
+    class Output
+      def finish_prepare
+      end
+      def finish_output
+        ""
+      end
+      def string(data)
+        data
+      end
+    end
+
+    class Grammar
+      attr_reader :tree # a list which pretends to be a tree :-)
+
+      class Pattern
+        attr_reader :ptype, :pstart, :pend, :bol
+        def initialize(ptype, pstart, pend, bol=false)
+          @ptype = ptype
+          @pstart = pstart
+          @pend = pend
+          @bol = bol
+        end
+      end
+
+      def initialize
+        @tree = []
+        @parameters = {}
+      end
+
+      def Grammar.parse(text,params = {})
+        new.parse(text,params)
+      end
+
+      def parse(text,params = {})
+        @parameters = params
+        gparse(text,self.class::constants.include?(:ROOT) ? self.class::ROOT : [])
+        self
+      end
+
+      def inspect
+        out = ""; indent = ""
+        @tree.each do |c|
+          indent = indent[0..-3] if c.class == CloseTag
+          out << indent + c.inspect + "\n"
+          indent << "  " if c.class == OpenTag
+        end
+        out
+      end
+
+      def output(output)
+        out = ''; i = 0
+        while @tree.length > i
+          c = @tree[i]
+          begin
+            met = case
+              when c.class == String
+                data = c
+                output.method("string")
+              when c.class == OpenTag
+                data = c.data
+                output.method("mO" + c.ttype)
+              when c.class == CloseTag
+                data = @tree[c.open].data
+                output.method("mC" + c.ttype)
+            end
+            out << case met.arity
+              when 0; met.call
+              when 1; met.call(data)
+              when 2; met.call(c,@tree)
+              when 3; met.call(c,@tree,i)
+              when 4; met.call(c,@tree,i,data)
+              else
+                ""
+            end.to_s
+
+            i += 1
+          rescue NameError => e
+            i += 1
+          rescue TagSkipEvent
+            i = c.close + 1 if c.class == OpenTag
+          rescue TagContentSkipEvent
+            i = c.close if c.class == OpenTag
+          rescue TagMoveEvent => e
+            i = e.message.to_i
+          ensure
+            begin
+              unless @tree.length > i
+                met = output.method("finish_output")
+                out << case met.arity
+                  when 0; met.call
+                  when 1; met.call(@tree)
+                  else
+                    ""
+                end.to_s
+              end
+            rescue TagMoveEvent => e
+              i = e.message.to_i
+            end
+          end
+        end
+        out
+      end
+
+      def prepare(output)
+        @tree.each_with_index do |c,i|
+          begin
+            if c.class == OpenTag
+              met = output.method("mP" + c.ttype)
+              case met.arity
+                when 0; met.call
+                when 1; met.call(c.data)
+                when 2; met.call(c,@tree)
+                when 3; met.call(c,@tree,i)
+              end
+            end
+          rescue NameError
+          rescue TagSkipEvent
+          rescue TagContentSkipEvent
+          rescue TagMoveEvent
+          end
+        end
+        output.method("finish_prepare").call
+        self
+      end
+
+      def gparse(text,grammar,position_in_markup=0,level=0)
+        return if text.nil?
+        s = StringScanner.new(text)
+        while !s.eos?
+          success = false
+          grammar.each do |pat|
+            if s.match?(pat.pstart)
+              pos = s.pos
+              bol = (pos == 0) ? true : s.string[pos-1] == "\n"
+              ts  = s.scan(pat.pstart)
+              te = if s.eos?
+                "" =~ pat.pend ? "" : nil
+              else
+                (pat.bol && !bol) ? nil : s.scan_until(pat.pend)
+              end
+
+              if te.nil?
+                s.pos = pos
+              else
+                ti = te.sub(pat.pend,"")
+                te = te[ti.length..-1]
+                @tree << ot = OpenTag.new(pat.ptype,level)
+                tpos = @tree.length-1
+                inner = begin
+                  self.method("m" + pat.ptype).call(ts,ti,te)
+                rescue NameError
+                  ti
+                rescue TagEvent
+                  @tree.pop
+                  s.pos = pos
+                  next
+                rescue TagSkipEvent
+                  @tree.pop
+                  success = true
+                  next
+                end
+                gparse(inner,self.class::constants.include?(("G" + pat.ptype).to_sym) ? self.class::const_get(("G" + pat.ptype).to_sym) : [],position_in_markup+pos+ts.length,level+1)
+                @tree << CloseTag.new(pat.ptype,tpos,position_in_markup+s.pos,level)
+                ot.close = @tree.length-1
+                success = true
+                break
+              end
+            end
+          end
+          unless success
+            if @tree.last.class == String
+              @tree.last << s.getch
+            else
+              @tree << s.getch
+            end
+          end
+        end
+      end
+
+      private :gparse
+    end
+
+  end
+end

data/lib/ChimpPlugin.rb

@@ -0,0 +1,7 @@
+module Chimp
+  module Plugin
+    class Base
+      def initialize; end
+    end
+  end
+end

data/lib/output/screen.rb

@@ -0,0 +1,248 @@
+require 'pastel'
+require 'tty-screen'
+require 'io/console'
+
+module Window #{{{
+  class WinchError < Exception; end
+  def self::init()
+    self::clear
+    $stdout << "\e[?25l"
+    $stdout.flush
+    Signal.trap("WINCH") do
+      raise WinchError, 'nope'
+    end
+    nil
+  end
+  def self::finish()
+    self::clear
+    self::set_pos 0, 0
+    $stdout << "\e[?25h"
+    $stdout.flush
+    nil
+  end
+  def self::getch()
+    loop do
+      case $stdin.getch
+        when 'r' then return :refresh
+        when 'q' then return :exit
+        when "\r" then return :enter
+        when "\e"
+          case $stdin.getch
+          when '['
+            case $stdin.getch
+              when 'A' then return :previous
+              when 'B' then return :next
+              when 'C' then return :next
+              when 'D' then return :previous
+            end
+          end
+      end
+    end
+  end
+  def self::lines()
+    TTY::Screen.lines
+  end
+  def self::columns()
+    TTY::Screen.columns
+  end
+  def self::clear()
+    $stdout << "\e[2J"
+    $stdout.flush
+    self
+  end
+  def self::set_pos(x,y)
+    $stdout << "\e[#{y};#{x}H"
+    $stdout.flush
+    self
+  end
+  def self::print(a)
+    $stdout.write a
+    $stdout.flush
+  end
+  def self::get_pos
+    res = ''
+    $stdin.raw do |stdin|
+      $stdout << "\e[6n"
+      $stdout.flush
+      while (c = $stdin.getc) != 'R'
+        res << c if c
+      end
+    end
+    m = res.match /(?<column>\d+);(?<row>\d+)/
+    [ Integer(m[:row]), Integer(m[:column]) ]
+  rescue WinchErrror
+    [0,0]
+  end
+end #}}}
+
+module Chimp
+  class Parser
+
+    class Screen < Output
+      #### Optional functions called when a tree is tranformed to output ####
+      #### mO + patternname for opening tags ####
+      #### mC + patternname for closing tags ####
+
+      def initialize() #{{{
+        @scounter = @ccounter = 0
+        @what = ''
+        @last = 0
+        @skip = -1
+
+        @format = Pastel.new
+        @screen = Window
+
+        @screen.init
+      end #}}}
+
+      def finish_output #{{{
+        @screen.set_pos 0,  @screen.lines
+        @screen.print ' ' * (@screen.columns - 5)
+        @screen.set_pos 0, @screen.lines
+      end #}}}
+
+      def mPP_WHAT(data)
+        @what = data
+      end
+
+      def mPP_SLIDES(c,tree)
+        #{{{
+        @scounter += 1
+        @ccounter += 1
+        c.userdata = @ccounter
+        #}}}
+      end
+      def mOP_SLIDES(c,tree)
+        #{{{
+        @screen.clear
+        lines = @screen.lines
+        columns = @screen.columns
+        ### print mark
+        @screen.set_pos columns-1, 30
+        @screen.print "\e[1;37m^\e[0m"
+        ### print footer
+        @screen.set_pos 0, lines-1
+        @screen.print "-"*columns
+        @screen.set_pos 0, lines
+        @screen.print @what
+        num = "#{c.userdata}/#{@scounter}"
+        @screen.set_pos columns-num.length, lines
+        @screen.print num
+        @screen.set_pos 0, 0
+        #}}}
+      end
+
+      def mPP_INCREMENTAL(c,tree,i)
+        @last = c.close
+      end
+      def mOP_INCREMENTAL(c,tree)
+        x, y = @screen.get_pos
+        c.userdata = { :x => x, :y => y }
+      end
+      def mCP_INCREMENTAL(c,tree,i)
+        return if @skip > i
+        @skip = -1
+        begin
+          if @last == i
+            lines = @screen.lines
+            columns = @screen.columns
+            @screen.set_pos 0, lines
+            @screen.print "Press 'q' to finish making a cheap impression..."
+          end
+          begin
+          ch = @screen.getch
+          rescue Window::WinchError
+            ch = :refresh
+          end
+        end while @last == i && ![:previous, :exit, :refresh].include?(ch)
+        case ch
+          when :previous
+            #{{{
+            pos = c.open-1
+            tag = tree[pos]
+            if tag.ttype == "P_SLIDES"
+              if pos ==  0
+                raise TagMoveEvent, pos
+              else
+                raise TagMoveEvent, tree[pos-1].open
+              end
+            end
+            if tag.ttype == "P_INCREMENTAL"
+              pos = tag.open
+              tag = tree[pos]
+              columns = @screen.columns
+              #### get current position
+              x, y = @screen.get_pos
+              #### how many spaces needed
+              howmuch = ((y - tag.userdata[:y] + 1) * columns) - (columns - x) - tag.userdata[:x]
+              @screen.set_pos tag.userdata[:x], tag.userdata[:y]
+              @screen.print x.to_s + ',' + y.to_s
+              @screen.print ' ' * howmuch
+              @screen.set_pos tag.userdata[:x], tag.userdata[:y]
+              ####
+              raise TagMoveEvent, pos
+            end
+            #}}}
+          when :refresh
+            #{{{
+            (c.open-1).downto(0) do |b|
+              if tree[b].class == OpenTag && tree[b].ttype == "P_SLIDES"
+                @skip = i
+                raise TagMoveEvent, b
+              end
+            end
+            #}}}
+          when :exit
+            @screen.finish
+            exit
+        end
+      end
+      def mOP_INCLUDE(data)
+        require File::dirname(__FILE__) + "/../plugins/#{data[:name]}.rb"
+        eval('Chimp::Plugin::' + data[:name].upcase).new.process(data[:what],data[:parameters],@screen,data[:additional])
+      end
+      def mOP_RANGE(data)
+        require File::dirname(__FILE__) + "/../plugins/#{data[:name]}.rb"
+        eval('Chimp::Plugin::' + data[:name].upcase).new.process(data[:what],data[:parameters],@screen,data[:additional])
+      end
+
+      def mOP_STRONG(data); @screen.print "\e[1m"; end
+      def mCP_STRONG(data); @screen.print "\e[0m"; end
+      def mOP_RED(data); @screen.print "\e[0;31m"; end
+      def mCP_RED(data); @screen.print "\e[0m"; end
+      def mOP_BLUE(data); @screen.print "\e[0;34m"; end
+      def mCP_BLUE(data); @screen.print "\e[0m"; end
+      def mOP_STRONGRED(data); @screen.print "\e[1;31m"; end
+      def mCP_STRONGRED(data); @screen.print "\e[0m"; end
+      def mOP_STRONGBLUE(data); @screen.print "\e[1;34m"; end
+      def mCP_STRONGBLUE(data); @screen.print "\e[0m"; end
+
+      def mOP_CENTER(data)
+        len = @screen.columns
+        if len-data > 0
+          @screen.print ' ' * ((len - data) / 2)
+        end
+      end
+      def mCP_CENTER(data)
+        @screen.print "\n"
+      end
+
+      def string(data)
+        @screen.print(data)
+      end
+
+      def p(what)
+        #{{{
+        lines = @screen.lines
+        @screen.set_pos 0, lines-1
+        @screen.print what.inspect
+        x, y = @screen.get_pos
+        @screen.set_pos x, y
+        @screen.getch
+        #}}}
+      end
+      private :p
+
+    end
+  end
+end

data/lib/plugins/figlet.rb

@@ -0,0 +1,23 @@
+module Chimp
+  module Plugin
+    class FIGLET < Base
+      def process(what,parameters,screen,additional)
+        if parameters.include? 'right'
+          pos = screen.get_pos
+          len = screen.columns
+          `figlet #{what}`.each_line do |l|
+            screen.print " " * (len-l.length+1) + l
+          end
+          screen.set_pos *pos
+        elsif parameters.include? 'center'
+          len = screen.columns
+          `figlet #{what}`.each_line do |l|
+            screen.print " " * ((len-l.length+1)/2) + l
+          end
+        else
+          screen.print `figlet #{what}`
+        end
+      end
+    end
+  end
+end

data/lib/plugins/lnums.rb

@@ -0,0 +1,14 @@
+module Chimp
+  module Plugin
+    class LNUMS < Base
+      def process(what,parameters,screen,additional)
+        i = 0
+        res = what.each_line.map do |l|
+          i += 1
+          ("%02i: " % i) + l
+        end.join('')
+        screen.print res
+      end
+    end
+  end
+end