reac 0.1.0

data/README.rdoc

@@ -0,0 +1,2 @@
+= reac - Reactive Programming in Ruby
+

data/lib/reac/reactivize.rb

@@ -0,0 +1,69 @@
+#
+# Reac::Reactivize
+#
+class Reac
+  module Reactivize
+    # reactivize - make methods to take reactive values
+    # NOTE: currently supports one-arg method only
+    #
+    # exmaple:
+    #class String
+    #  alias __old_plus__ +
+    #  def +(other)
+    #    if other.kind_of?(Reac)
+    #      Reac(self) + other
+    #    else
+    #      self.__old_plus__(other)
+    #    end
+    #  end
+    #end
+    OLD_NAME = {
+      :+ => "plus",
+      :- => "minus",
+      :* => "mul",
+      :/ => "div"
+    }
+    def reactivize(*methods)
+      methods.each do |m|
+        old_name = OLD_NAME[m] || m
+        module_eval <<-EOD
+          alias __old_#{old_name}__ #{m}
+          def #{m}(arg)
+            if arg.kind_of?(Reac)
+              Reac(self).#{m}(arg)
+            else
+              __old_#{old_name}__(arg)
+            end
+          end
+        EOD
+      end
+    end
+
+    # reactivize singleton methods.
+    #
+    # example:
+    #   module Math
+    #    reactivize_singleton :sin, :cos
+    #   end
+    def reactivize_singleton(*methods)
+      method_list = methods.map{|m|m.inspect}.join(',')
+      instance_eval <<-EOD
+        class << self
+          reactivize #{method_list}
+        end
+      EOD
+    end
+  end
+end
+
+# now you can use 'reactivize' in all classes & modules
+Module.__send__(:include, Reac::Reactivize)
+
+class String
+  reactivize :+, :*
+end
+
+class Fixnum
+  reactivize :+, :-, :*, :/
+end
+

data/lib/reac/view/curses.rb

@@ -0,0 +1,33 @@
+require 'curses'
+
+class Reac
+  class CursesView < View
+    def initialize(&block)
+      @top_window = Curses.init_screen
+      @x = @y = 0
+      #Curses.noecho
+      #Curses.nocbreak  # disable buffering keyboard input
+      Curses.clear
+      Curses.refresh
+      @reacs = []
+      #@top_window = Curses::Window.new(Curses.cols-2, Curses.lines-1, 0, 0) #y, x = 0
+
+      instance_eval(&block) if block
+    end
+
+    def put(y, x, reac)
+      @reacs << [y, x, reac]
+    end
+
+    def main_loop(now)
+      @top_window.clear
+      @reacs.each do |y, x, reac|
+        yval = Reac.value(y, now)
+        xval = Reac.value(x, now)
+        @top_window.setpos(yval, xval)
+        @top_window << Reac.value(reac, now).to_s
+        @top_window.refresh
+      end
+    end
+  end
+end

data/lib/reac/view/sdl.rb

@@ -0,0 +1,92 @@
+require 'sdl'
+
+class Reac
+
+  class SDLView < View
+
+    def self.init(w=640, h=480, options={})
+      @@width, @@height = w, h
+      bpp   = options[:bpp] || 32
+      flags = options[:flags] || SDL::SWSURFACE
+
+      SDL.init(options[:init_flags] || SDL::INIT_EVERYTHING)
+      SDL::TTF.init unless options[:no_ttf]
+      @@screen = SDL.set_video_mode(w, h, bpp, flags)
+    end
+
+    def initialize(options={}, &block)
+      @reacs = {
+        :images => [],
+        :bmfonts => [],
+        :ttffonts => [],
+      }
+      @background_color = options[:background] || [0, 0, 0]
+
+      instance_eval(&block) if block
+    end
+
+    def put(_x, _y, _obj, *rest)
+      case _obj
+      when SDL::Surface
+        put_image(_x, _y, _obj)
+      else
+        put_string(_x, _y, _obj, *rest)
+        #raise ArgumentError, "unkown object type: #{_obj.class}"
+      end
+    end
+
+    def main_loop(now)
+      @@screen.fill_rect(0, 0, @@width, @@height, @background_color)
+      @reacs[:images].each do |_x, _y, _image|
+        x = Reac.value(_x, now)
+        y = Reac.value(_y, now)
+        image = Reac.value(_image, now)
+        @@screen.put(image, x, y)
+      end
+      @reacs[:bmfonts].each do |_x, _y, _str, font|
+        x = Reac.value(_x, now)
+        y = Reac.value(_y, now)
+        str = Reac.value(_str, now)
+        i = 0
+        str.each_line do |line|
+          font.textout(@@screen, line, x, y + font.height*i)
+          i += 1
+        end
+      end
+      col = [255,255,255]
+      @reacs[:ttffonts].each do |_x, _y, _str, font|
+        x = Reac.value(_x, now)
+        y = Reac.value(_y, now)
+        str = Reac.value(_str, now)
+        i = 0
+        str.each_line do |line|
+          font.draw_solid_utf8(@@screen, line, x, y + font.line_skip*i, *col)
+          i += 1
+        end
+      end
+      @@screen.flip
+    end
+
+    private
+
+    #TODO: rewrite in OOP style (use inheritance)
+    def put_image(_x, _y, _image)
+      @reacs[:images] << [_x, _y, _image]
+    end
+
+    def put_string(_x, _y, _str, font)
+      case font
+#      when SDL::BMFont
+#        @reacs[:bmfonts] << [_x, _y, _str, font]
+      when SDL::TTF
+        @reacs[:ttffonts] << [_x, _y, _str, font]
+      when SDL::Kanji
+        raise NotImplementedError, "this font type is not yet supported.."
+      else
+        raise ArgumentError, "unkown font type: #{font.class}"
+      end
+    end
+
+  end
+  
+end

data/lib/reac/view.rb

@@ -0,0 +1,26 @@
+class Reac
+
+  class View
+
+    WAIT = 0.1
+
+    def start(secs=nil)
+      if secs
+        start = Time.now
+        loop{
+          now = Time.now
+          main_loop(now)
+          break if now - start > secs
+          sleep WAIT
+        }
+      else
+        loop{ 
+          main_loop(Time.now)
+          sleep WAIT
+        }
+      end
+    end
+
+  end
+
+end

data/lib/reac.rb

@@ -0,0 +1,96 @@
+# 
+# reacruby - Reactive Programming on Ruby
+#
+# (c) 2008, yhara@kmc.gr.jp
+require 'reac/reactivize.rb'
+require 'reac/view.rb'
+
+class Reac
+  attr_accessor :last_update
+
+  # construct tree of Reac::*
+  #  (instead of call the method)
+  # to call it later
+  def method_missing(method, *args)
+    Call.new(self, method, args)
+  end
+
+  # caluculate the value
+  # (short-hand for Reac.value(x))
+  def value
+    Reac.value(self)
+  end
+
+  # caluculate the value by traversing the tree
+  def self.value(reac, tick=nil)
+    return reac if not reac.is_a?(Reac) 
+
+    # return cached data if already calculated
+    return reac.data if tick && (reac.last_update == tick)
+
+    reac.last_update = tick 
+    case reac
+    when Value
+      reac.data
+    when Call
+      receiver = Reac.value(reac.receiver, tick)
+      args = reac.args.map{|item|
+        Reac.value(item, tick)
+      }
+      reac.data = receiver.__send__(reac.method, *args)
+    when Proc
+      reac.data = reac.proc.call
+    when Array
+      reac.data = reac.ary.map{|item| Reac.value(item, tick)}
+    else
+      raise "must not happen"
+    end
+  end
+  undef :to_s
+  undef :inspect
+  undef :==
+
+  class Value < Reac
+    def initialize(data)
+      @data = data
+    end
+    attr_reader :data
+  end
+
+  class Call < Reac
+    def initialize(receiver, method, args)
+      @receiver, @method, @args = receiver, method, args
+    end
+    attr_accessor :data
+    attr_reader :receiver, :method, :args
+  end
+
+  class Proc < Reac
+    def initialize(proc)
+      @proc = proc
+    end
+    attr_accessor :data 
+    attr_reader :proc
+  end
+
+  class Array < Reac
+    def initialize(ary)
+      @ary = ary
+    end
+    attr_accessor :data
+    attr_reader :ary
+  end
+end
+
+# construct reactive value from normal value (or proc)
+def Reac(obj=nil, &block)
+  if block
+    Reac::Proc.new(block)
+  else
+    if obj.is_a?(Array)
+      Reac::Array.new(obj)
+    else
+      Reac::Value.new(obj)
+    end
+  end
+end

data/sample/clock.rb

@@ -0,0 +1,24 @@
+require 'reac'
+require 'reac/view/curses'
+
+module Math
+  reactivize_singleton :sin, :cos
+end
+
+def rad(phase)
+  phase * (2 * Math::PI)
+end
+
+SIZE = 20
+t = Reac{Time.now}
+
+deg = (t.sec.to_f - 15) / 60
+phase = rad(deg)
+y = Math.sin(phase) * SIZE/2 + SIZE/2
+x = Math.cos(phase) * SIZE + SIZE
+
+Reac::CursesView.new{
+  put SIZE/2, SIZE-2, t.strftime("%H:%M")
+  put y, x, t.sec.to_s
+}.start(30)
+

data/sample/reacirb.rb

@@ -0,0 +1,103 @@
+require 'readline'
+require 'reac'
+require 'reac/view/sdl'
+
+# ruby 1.8/1.9 compatible
+# ord(?a)   #=> returns 97
+def ord(x)
+  if x.is_a? String
+    x.ord
+  else
+    x
+  end
+end
+
+# call this before loading images, fonts, etc.
+Reac::SDLView.init
+view = Reac::SDLView.new
+
+#font = SDL::BMFont.open("font.bmp", SDL::BMFont::TRANSPARENT)
+font = SDL::TTF.open("ttf.ttf", 16)
+#font = SDL::TTF.open("/Library/Fonts/Osaka.dfont", 16)
+
+h = font.line_skip
+n_lines = 0
+
+#def method_missing(method, *args)
+#  eval("@#{method}")
+#end
+
+KEYS = {
+  SDL::Key::K1           => [ "1"  , "!"]  ,
+  SDL::Key::K2           => [ "2"  , "\""] ,
+  SDL::Key::K3           => [ "3"  , "#"]  ,
+  SDL::Key::K4           => [ "4"  , "$"]  ,
+  SDL::Key::K5           => [ "5"  , "%"]  ,
+  SDL::Key::K6           => [ "6"  , "&"]  ,
+  SDL::Key::K7           => [ "7"  , "'"]  ,
+  SDL::Key::K8           => [ "8"  , "("]  ,
+  SDL::Key::K9           => [ "9"  , ")"]  ,
+  SDL::Key::K0           => [ "0"  , "0"]  ,
+  SDL::Key::MINUS        => [ "-"  , "="]  ,
+  SDL::Key::CARET        => [ "^"  , "~"]  ,
+  SDL::Key::BACKSLASH    => [ "\\" , "_"]  ,
+
+  SDL::Key::AT           => [ "@"  , "`"]  ,
+  SDL::Key::LEFTBRACKET  => [ "["  , "{"]  ,
+
+  SDL::Key::SEMICOLON    => [ ";"  , "+"]  ,
+  SDL::Key::COLON        => [ ":"  , "*"]  ,
+  SDL::Key::RIGHTBRACKET => [ "]"  , "}"]  ,
+
+  SDL::Key::COMMA        => [ ","  , "<"]  ,
+  SDL::Key::PERIOD       => [ "."  , ">"]  ,
+  SDL::Key::SLASH        => [ "/"  , "?"]  ,
+}
+str = "(press ESCAPE to exit)\n" +
+      "example: > @t = Reac{ Time.now }\n" + 
+      "> "
+header_size = str.split(/\n/).size
+res = Reac{
+  while event = SDL::Event2.poll
+    if event.is_a?(SDL::Event2::KeyDown)
+      if KEYS.key?(event.sym)
+        if (event.mod & SDL::Key::MOD_SHIFT) == 0
+          str << KEYS[event.sym].first
+        else
+          str << KEYS[event.sym].last
+        end
+      else
+        case event.sym
+        when SDL::Key::BACKSPACE
+          str.chop!
+        when SDL::Key::A .. SDL::Key::Z
+          c = ord(?a) + (event.sym - SDL::Key::A)
+          if (event.mod & SDL::Key::MOD_SHIFT) != 0
+            c += (ord(?A) - ord(?a))
+          end
+          str << c.chr
+        when SDL::Key::COMMA .. SDL::Key::SEMICOLON
+          str << (ord(?,) + (event.sym - SDL::Key::COMMA)).chr
+        when SDL::Key::RETURN
+          code = str.split(/\n/).last[/^> (.*)/, 1]
+          y = h * (n_lines * 2 + header_size)
+          begin
+            view.put 0, y, self.instance_eval(code).inspect, font
+          rescue StandardError, ScriptError => e
+            view.put 0, y, "#{e.class}!"
+          end
+          n_lines += 1
+          str << "\n\n> "
+        when SDL::Key::SPACE
+          str << " "
+        when SDL::Key::ESCAPE
+          exit
+        end
+      end
+    end
+  end
+  str
+}
+
+view.put 0, 0, res, font
+view.start

data/sample/sample.rb

@@ -0,0 +1,29 @@
+require 'reac'
+require 'reac/view/curses.rb'
+
+x = Reac{rand(100)}
+y = x * 2 
+t = Reac{Time.now}
+
+#### Make a reactive world (declarative style):
+Reac::CursesView.new{
+  put 0, 0, "x : " + x.to_s
+  put 1, 0, "y : " + y.to_s
+  put 2, 0, "x and y : " + Reac([x, y]).inspect
+
+  put 4, 0, "now : " + t.strftime("%H:%M:%S")
+  put 5, 0, "second * 100 : " + (t.sec * 100).to_s
+
+}.start(3)
+
+#### Another way (imperative style):
+#
+#view = Reac::CursesView.new
+#view.put(0, 0, "x : " + x.to_s)
+#view.put(1, 0, "y : " + y.to_s)
+#view.put(2, 0, "x and y : " + Reac([x, y]).inspect)
+#
+#view.put(4, 0, "now : " + t.strftime("%H:%M:%S"))
+#view.put(5, 0, "second * 100 : " + (t.sec * 100).to_s)
+#
+#view.start(3)

data/sample/sdltest.rb

@@ -0,0 +1,12 @@
+require 'reac'
+require 'reac/view/sdl.rb'
+
+Reac::SDLView.init
+img = SDL::Surface.load_bmp("icon.bmp")
+
+x = Reac{ (Time.now.usec/5000) % 640 }
+y = (x * 3) % 480
+
+Reac::SDLView.new{
+  put x, y, img
+}.start(5)

metadata

@@ -0,0 +1,64 @@
+--- !ruby/object:Gem::Specification 
+name: reac
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- yhara (Yutaka HARA)
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-07-07 00:00:00 +09:00
+default_executable: 
+dependencies: []
+
+description: 
+email: yhara.at.kmc.gr.jp
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- README.rdoc
+- lib/reac/reactivize.rb
+- lib/reac/view/curses.rb
+- lib/reac/view/sdl.rb
+- lib/reac/view.rb
+- lib/reac.rb
+- sample/boxfont2.ttf
+- sample/clock.rb
+- sample/icon.bmp
+- sample/reacirb.rb
+- sample/sample.rb
+- sample/sdltest.rb
+has_rdoc: false
+homepage: 
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: reac
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: Reactive Programming in Ruby
+test_files: []
+