termular 0.1.0

data/bin/termular

@@ -0,0 +1,2 @@
+#!/usr/bin/env ruby
+require "termular/bootstrap"

data/lib/termular/bootstrap.rb

@@ -0,0 +1,33 @@
+require "termular/parser"
+require "termular/context"
+require "termular/console"
+require "termular/graph"
+require "termular/ui"
+require "ncurses"
+require "paint"
+
+Termular::Console.init
+ui = Termular::UI.new
+ui.render
+
+loop do
+  c = nil
+  if ui.needs_tick?
+    hack = Thread.new { c = STDIN.getc }
+    hack.join 0.1
+    hack.kill
+    if c.nil?
+      ui.tick
+      next
+    end
+  else
+    c = STDIN.getc
+  end
+  if c.ord == 27
+    hack = Thread.new { c << STDIN.getc; c << STDIN.getc; c << STDIN.getc }
+    hack.join 0.001
+    hack.kill
+  end
+  ui.dispatch_keypress c
+  ui.render
+end

data/lib/termular/console.rb

@@ -0,0 +1,46 @@
+module Termular
+  module Console    
+    def self.init
+      Ncurses.initscr
+      Ncurses.raw
+      Ncurses.noecho
+      Ncurses.keypad Ncurses.stdscr, true
+      Ncurses.refresh
+      at_exit { Ncurses.endwin }
+    end
+    
+    def self.move(x, y)
+      "\e[#{y.to_i};#{x.to_i}H"
+    end
+    
+    def self.clear
+      "\e[H\e[2J"
+    end
+    
+    def self.clear_line
+      "\e[0G\e[2K"
+    end
+    
+    def self.color(*col)
+      Paint["|", *col].split("|").first
+    end
+    
+    def self.reset
+      "\e[m"
+    end
+    
+    def self.cols
+      Ncurses.getmaxx Ncurses.stdscr
+    end
+
+    def self.rows
+      Ncurses.getmaxy Ncurses.stdscr
+    end
+
+    def self.buffered_print
+      buff = ""
+      yield buff
+      print buff
+    end
+  end
+end

data/lib/termular/context.rb

@@ -0,0 +1,54 @@
+module Termular  
+  class Context
+    def self.global
+      @@global ||= begin
+        ctx = Context.new
+        %w( acos acosh asin asinh atan atan2 atanh cbrt cos cosh erf erfc exp
+            log log10 log2 sin sinh sqrt tan tanh ).each do |m|
+          ctx[m] = Math.method m
+        end
+        %w( PI E ).each do |c|
+          ctx[c.downcase] = Math.const_get c
+        end
+        ctx["ln"]     = ctx["log"]
+        ctx["abs"]    = ->x { x.abs }
+        ctx["arg"]    = ->x { x.arg }
+        ctx["ceil"]   = ->x { x.ceil }
+        ctx["floor"]  = ->x { x.floor }
+        ctx["int"]    = ->x { x.to_i }
+        ctx["mod"]    = ->a,b { a % b }
+        ctx
+      end
+    end
+    
+    attr_accessor :vars, :parent
+    
+    def initialize(parent = nil)
+      @vars, @parent = {}, parent
+    end
+    
+    def [](var)
+      if vars.key? var
+        vars[var]
+      elsif parent
+        parent[var]
+      else
+        raise "undefined variable '#{var}'"
+      end        
+    end
+    
+    def []=(var, val)
+      if vars.key? var
+        vars[var] = val
+      elsif parent and parent.has? val
+        parent[var] = val
+      else
+        vars[var] = val
+      end
+    end
+    
+    def has?(var)
+      vars.key?(var) or parent && parent.has?(var)
+    end
+  end
+end

data/lib/termular/graph.rb

@@ -0,0 +1,152 @@
+module Termular
+  class Graph
+    attr_accessor :expression, :max_x, :max_y, :min_x, :min_y, :needs_redraw, :start_time, :options
+    
+    def initialize(expression)
+      @expression = expression
+      @max_x = 10
+      @min_x = -10
+      factor = (Console.rows * 2.4 / Console.cols.to_f)
+      @max_y = factor * @max_x
+      @min_y = factor * @min_x
+      @start_time = Time.now.to_f
+      @options = {}
+      invalidate
+    end
+    
+    def invalidate
+      @needs_redraw = true
+    end
+    
+    def pan(fx, fy)
+      x = (max_x - min_x) * fx
+      y = (max_y - min_y) * fy
+      @min_x += x
+      @max_x += x
+      @min_y += y
+      @max_y += y
+      invalidate
+    end
+    
+    def center
+      w = max_x - min_x
+      h = max_y - min_y
+      
+      @max_x = w/2.0
+      @min_x = -@max_x
+      @max_y = h/2.0
+      @min_y = -@max_y
+      invalidate
+    end
+    
+    def zoom(factor)
+      w = max_x - min_x
+      h = max_y - min_y
+      
+      cx = min_x + w/2.0
+      cy = min_y + h/2.0
+      
+      w /= factor.to_f
+      h /= factor.to_f
+      
+      @min_x = cx - w/2.0
+      @max_x = cx + w/2.0
+      @min_y = cy - h/2.0
+      @max_y = cy + h/2.0
+      invalidate
+    end
+    
+    def point_to_screen(x, y)
+      sw = Console.cols
+      sh = Console.rows
+      pw = max_x - min_x
+      ph = max_y - min_y
+      sx = (((x - min_x) / pw.to_f) * sw).round
+      sy = sh - (((y - min_y) / ph.to_f) * sh).round
+      [sx, sy]
+    end
+    
+    def screen_to_point(x, y)
+      sw = Console.cols
+      sh = Console.rows
+      pw = max_x - min_x
+      ph = max_y - min_y
+      sx = ((x / sw.to_f) * pw) + min_x
+      sy = ((y / sh.to_f) * ph) + min_y
+      [sx, sy]
+    end
+    
+    def render_axes
+      buff = Console.clear
+      scr_origin = point_to_screen 0, 0
+      buff << Console.color(:white)
+      if scr_origin[0] >= 0 and scr_origin[0] <= Console.cols
+        0.upto(Console.rows).each do |y|
+          buff << Console.move(scr_origin[0], y)
+          buff << "|"
+        end
+      end
+      if scr_origin[1] >= 0 and scr_origin[1] <= Console.rows
+        buff << Console.move(0, scr_origin[1])
+        buff << "-" * Console.cols
+        if scr_origin[0] >= 0 and scr_origin[0] <= Console.cols
+          buff << Console.move(scr_origin[0], scr_origin[1])
+          buff << "+"
+        end
+      end
+      buff
+    end
+    
+    class Cartesian < Graph
+      def render
+        @needs_redraw = false
+        Console.buffered_print do |buff|
+          buff << render_axes
+          # render actual graph
+          ctx = Context.new Context.global
+          buff << Console.color(:green)
+          ctx["time"] = Time.now.to_f - @start_time
+          old_y = nil
+          0.upto(Console.cols).map { |x| screen_to_point(x, 0)[0] }.each do |x|
+            ctx["x"] = x
+            py = expression.eval ctx
+            scr_pt = point_to_screen(x, py)
+            new_y = scr_pt[1]
+            (old_y ? (old_y > new_y ? (old_y - 1).downto(new_y) : (old_y < new_y ? (old_y + 1).upto(new_y) : [new_y])) : [new_y]).each do |y|
+              if scr_pt[0] >= 0 and scr_pt[0] <= Console.cols and y >= 0 and y <= Console.rows
+                buff << Console.move(scr_pt[0], y)
+                buff << "+"
+              end
+            end
+            old_y = new_y
+          end
+          buff << Console.reset
+        end
+      end
+    end
+  
+    class Polar < Graph
+      def render
+        @needs_redraw = false
+        Console.buffered_print do |buff|
+          buff << render_axes
+          # render actual graph
+          ctx = Context.new Context.global
+          buff << Console.color(:green)
+          ctx["time"] = Time.now.to_f - @start_time
+          old_y = nil
+          (options["tmin"] || 0).upto(((options["tmax"] || 2 * Math::PI) * 100).round).map { |t| t / 100.0 }.each do |theta|
+            ctx["t"] = theta
+            radius = expression.eval ctx
+            scr_pt = point_to_screen(radius*Math.cos(theta), radius*Math.sin(theta))
+            if scr_pt[0] >= 0 and scr_pt[0] <= Console.cols and scr_pt[1] >= 0 and scr_pt[1] <= Console.rows
+              buff << Console.move(scr_pt[0], scr_pt[1])
+              buff << "+"
+            end
+          end
+          buff << Console.reset
+        end
+      end
+    end
+  end
+end

data/lib/termular/parser.rb

@@ -0,0 +1,218 @@
+module Termular
+  class SyntaxError < StandardError; end
+  
+  module AST
+    class Base
+      def initialize(hash = {})
+        hash.each { |k,v| send "#{k}=", v }
+      end
+    end
+    
+    class Binary < Base
+      attr_accessor :left, :right
+    end
+    
+    class Add < Binary;       def eval(ctx) left.eval(ctx) + right.eval(ctx) end end
+    class Subtract < Binary;  def eval(ctx) left.eval(ctx) - right.eval(ctx) end end
+    class Multiply < Binary;  def eval(ctx) left.eval(ctx) * right.eval(ctx) end end
+    class Divide < Binary;    def eval(ctx) left.eval(ctx) / right.eval(ctx) end end
+    class Power < Binary;     def eval(ctx) left.eval(ctx) ** right.eval(ctx) end end
+    
+    class Negate < Base
+      attr_accessor :expression
+      def eval(ctx)
+        -expression.eval(ctx)
+      end
+    end
+    
+    class Variable < Base
+      attr_accessor :name
+      def eval(ctx)
+        ctx[name]
+      end
+    end
+    
+    class Number < Base
+      attr_accessor :number
+      def eval(ctx)
+        number
+      end
+    end
+    
+    class Call < Base
+      attr_accessor :callee
+      attr_accessor :args
+      def eval(ctx)
+        callee.eval(ctx).call *args.map { |a| a.eval(ctx) }
+      end
+    end
+    
+    class CartesianCommand < Base
+      attr_accessor :expression
+    end
+    
+    class PolarCommand < Base
+      attr_accessor :expression
+    end
+    
+    class OptionCommand < Base
+      attr_accessor :option, :expression
+    end
+    
+    class QuitCommand < Base; end
+  end
+  
+  class Lexer
+    TOKENS = [
+        [ :WHITESPACE,    /\s+/ ],
+        [ :NUMBER,        /\d+(\.\d+)?/, ->m { m[0].to_f } ],
+        [ :BAREWORD,      /[a-z][a-z0-9]*/, ->m { m[0] } ],
+        [ :PLUS,          /\+/ ],
+        [ :MINUS,         /-/ ],
+        [ :TIMES,         /\*/ ],
+        [ :DOT,           /\./ ],
+        [ :DIVIDE,        /\// ],
+        [ :POWER,         /\^/ ],
+        [ :OPEN_PAREN,    /\(/ ],
+        [ :CLOSE_PAREN,   /\)/ ],
+        [ :OPEN_BRACKET,  /\[/ ],
+        [ :CLOSE_BRACKET, /\]/ ],
+        [ :COMMA,         /\,/ ],
+        [ :COMMAND,       /:([a-z][a-z0-9]*)/, ->m { m[1] } ]
+      ].map { |a| [a[0], Regexp.new("\\A#{a[1].source}", Regexp::MULTILINE), a[2]] }
+      
+    def self.lex!(original_src)
+      tokens = []
+      offset = 0
+      src = original_src
+      until src.empty?
+        match = nil
+        tok, re, conv = TOKENS.find { |tok, re, conv| match = re.match(src, offset) }
+        raise SyntaxError, "illegal character at position #{original_src.length - src.length}" unless match
+        tokens << [tok, conv && conv[match]] unless tok == :WHITESPACE
+        src = match.post_match
+      end
+      tokens << [:END]
+    end
+  end
+  
+  class Parser
+    def self.parse!(src)
+      Parser.new(src).parse
+    end
+    
+    def initialize(src)
+      @src = src
+      @tokens = Lexer.lex! src
+      @i = -1
+    end
+    
+    def token
+      @tokens[@i]
+    end
+    
+    def peek_token
+      @tokens[@i + 1]
+    end
+    
+    def next_token
+      @tokens[@i += 1]
+    end
+    
+    def assert_type(token, *types)
+      unless types.include? token[0]
+        raise SyntaxError, "Expected one of #{types.join ", "}, found #{token[0]}"
+      end
+    end
+    
+    def parse
+      cmd = if peek_token[0] == :COMMAND
+              command
+            else
+              AST::CartesianCommand.new expression: expression
+            end
+      assert_type next_token, :END
+      cmd
+    end
+    
+    def command
+      assert_type next_token, :COMMAND
+      case token[1]
+      when "q";   AST::QuitCommand.new
+      when "c";   AST::CartesianCommand.new expression: expression
+      when "p";   AST::PolarCommand.new expression: expression
+      when "opt"; option_command
+      end
+    end
+    
+    def option_command
+      assert_type next_token, :BAREWORD
+      opt = token[1]
+      AST::OptionCommand.new option: opt, expression: expression
+    end
+    
+    def expression
+      additive_expression
+    end
+    
+    def additive_expression
+      expr = multiplicative_expression
+      while [:PLUS, :MINUS].include? peek_token[0]
+        case next_token[0]
+        when :PLUS;   expr = AST::Add.new       left: expr, right: multiplicative_expression
+        when :MINUS;  expr = AST::Subtract.new  left: expr, right: multiplicative_expression
+        end
+      end
+      expr
+    end
+    
+    def multiplicative_expression
+      expr = power_expression
+      while [:TIMES, :DIVIDE].include? peek_token[0]
+        case next_token[0]
+        when :TIMES;  expr = AST::Multiply.new  left: expr, right: power_expression
+        when :DIVIDE; expr = AST::Divide.new    left: expr, right: power_expression
+        end
+      end
+      expr
+    end
+    
+    def power_expression
+      expr = call_expression
+      if peek_token[0] == :POWER
+        next_token
+        expr = AST::Power.new left: expr, right: power_expression
+      end
+      expr
+    end
+    
+    def call_expression
+      expr = unary_expression
+      while peek_token[0] == :OPEN_BRACKET
+        next_token
+        args = []
+        args << expression
+        while peek_token[0] == :COMMA
+          next_token
+          args << expression
+        end
+        expr = AST::Call.new callee: expr, args: args
+        assert_type next_token, :CLOSE_BRACKET
+      end
+      expr
+    end
+    
+    def unary_expression
+      case next_token[0]
+      when :MINUS;      AST::Negate.new expression: unary_expression
+      when :BAREWORD;   AST::Variable.new name: token[1]
+      when :NUMBER;     AST::Number.new number: token[1]
+      when :OPEN_PAREN; expr = expression
+                        assert_type next_token, :CLOSE_PAREN
+                        expr
+      else
+        raise SyntaxError, "Unexpected #{token[0]}"
+      end
+    end
+  end
+end

data/lib/termular/ui.rb

@@ -0,0 +1,166 @@
+module Termular
+  class UI
+    attr_accessor :current_graph, :current_command, :insert_mode, :expression, :cursor_offset, :invalidate_next
+    
+    def draw_status_line
+      Console.buffered_print do |s|
+        s <<  Console.move(0, Console.rows) <<
+              Console.clear_line <<
+              Console.color(:black, :white) <<
+              (" " * Console.cols) <<
+              Console.move(0, Console.rows) <<
+              expression
+        if insert_mode
+          msg = "--INSERT--"
+          s <<  Console.move(Console.cols - msg.length + 1, Console.rows) << 
+                Console.color(:black, :white) << msg <<
+                Console.move(cursor_offset + 1, Console.rows)
+        else
+          s << Console.move(Console.cols, Console.rows)
+        end
+        s << Console.reset
+      end
+    end
+    
+    def dispatch_keypress(k)
+      if invalidate_next
+        current_graph and current_graph.invalidate
+        @invalidate_next = false
+      end
+      return dispatch_insert_keypress k if insert_mode
+      case k[0]
+      when "h" # move left
+        current_graph.pan -0.2, 0
+      when "H"
+        current_graph.pan -0.05, 0
+      when "l" # move right
+        current_graph.pan 0.2, 0
+      when "L"
+        current_graph.pan 0.05, 0
+      when "j" # move down
+        current_graph.pan 0, -0.2
+      when "J"
+        current_graph.pan 0, -0.05
+      when "k" # move up
+        current_graph.pan 0, 0.2
+      when "K"
+        current_graph.pan 0, 0.05
+      when " " # center
+        current_graph.center
+      when "]" # zoom in
+        current_graph.zoom 2
+      when "[" # zoom out
+        current_graph.zoom 0.5
+      when "i"
+        @insert_mode = true
+      when ":"
+        @insert_mode = true
+        @expression = ":"
+        @cursor_offset = 1
+      when "o"
+        @insert_mode = true
+        @expression = ""
+        @cursor_offset = 0
+      else
+        print Console.move 0, 0
+        print k.ord
+      end
+
+      #print Termular::Console.move 0, Termular::Console.rows
+      #print c.ord
+      exit if k[0] == "\3"
+    end
+    
+    def dispatch_insert_keypress(k)
+      case k[0].ord
+      when 127 # backspace
+        unless cursor_offset.zero?
+          @cursor_offset -= 1
+          expression[cursor_offset..cursor_offset] = ""
+        end
+      when 10 # enter
+        begin
+          @current_command = Parser.parse! expression
+          if current_command.is_a? AST::CartesianCommand
+            @current_graph = Graph::Cartesian.new current_command.expression
+            @needs_tick = expression =~ /time/
+          elsif current_command.is_a? AST::PolarCommand
+            @current_graph = Graph::Polar.new current_command.expression
+            @needs_tick = expression =~ /time/
+          elsif current_command.is_a? AST::OptionCommand
+            if current_graph
+              current_graph.options[current_command.option] = current_command.expression.eval(Context.global)
+              current_graph.invalidate
+            end
+          elsif current_command.is_a? AST::QuitCommand
+            exit
+          end
+        rescue => e
+          show_exception "#{e.class.name} #{e.message}"
+        end
+      when 27 # special key
+        if k == "\e"
+          # legit escape
+          @insert_mode = false
+          return
+        end
+        case k[1..-1]
+        when "OH" # home
+          @cursor_offset = 0
+        when "OF" # end
+          @cursor_offset = expression.length
+        when "OD" # arrow left
+          @cursor_offset -= 1 unless cursor_offset.zero?
+        when "OC" # arrow right
+          @cursor_offset += 1 unless cursor_offset == expression.length
+        when "[3~"  
+          expression[cursor_offset..cursor_offset] = ""
+        else
+#          print k.each_byte.to_a.join ","
+#          raise k[1..-1]#k.each_byte.to_a.join ","
+        end
+      when 0x20..0x7E
+#        expression << k.ord.to_s << " "
+        expression[cursor_offset, 0] = k
+        @cursor_offset += 1
+      end
+    end
+    
+    def show_exception(msg)
+      Console.buffered_print do |s|
+        s <<  Console.move(0, Console.rows - 1) <<
+              Console.color(:bright, :white, :red) <<
+              msg <<
+              Console.reset
+      end
+      # this writes over where the graph goes, so invalidate it
+      # however if we invalidate it now, it gets immediately dismissed, so set
+      # a special flag
+      @invalidate_next = true
+    end
+    
+    def render
+      Console.clear
+      begin
+        current_graph.render if current_graph and current_graph.needs_redraw
+      rescue => e
+        show_exception e.message
+      end
+      draw_status_line
+    end
+    
+    def tick
+      current_graph and current_graph.invalidate
+      render
+    end
+    
+    def needs_tick?
+      @needs_tick
+    end
+    
+    def initialize
+      @cursor_offset = 0
+      @expression = ""
+    end
+  end
+end

metadata

@@ -0,0 +1,76 @@
+--- !ruby/object:Gem::Specification
+name: termular
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Charlie Somerville
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-01-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ncurses-ruby
+  requirement: &2152096840 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *2152096840
+- !ruby/object:Gem::Dependency
+  name: paint
+  requirement: &2152095940 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *2152095940
+description: Termular Grapher is a simple graphing program that's capable of cartesian
+  and polar graphs
+email:
+- charlie@charliesomerville.com
+executables:
+- termular
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/termular
+- lib/termular/bootstrap.rb
+- lib/termular/console.rb
+- lib/termular/context.rb
+- lib/termular/graph.rb
+- lib/termular/parser.rb
+- lib/termular/ui.rb
+homepage: http://github.com/charliesome/termular
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Simple terminal grapher with vim-like keybindings
+test_files: []