frypan 0.0.1 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fb8a7b23f1048487bc5ab065783383c02ce47b1d
-  data.tar.gz: 93c85039222d259ad54acab69dadb06e653811f6
+  metadata.gz: 041c764b352e067de7265cb532797f1b3b5d5b7a
+  data.tar.gz: d0f5212808ffb5d2eb2b6d7ea6d863c61c238e0d
 SHA512:
-  metadata.gz: 7af33ae5164675458049fd5be4bc2c7ca67333ca1ca4dd6e525e6575074c905367d092383a5c4bdde9d53269494c76ff8335aa2f86215a86accc1f0152df47df
-  data.tar.gz: c52cf2274ac18309bf4ecbc09164511dcba3ec2149fb5fd118713f1e66828d78631be153de21a29516920cb1bd1a3d4857e23b581b34bc2b4fbb542fa88adc1a
+  metadata.gz: 9e66378e9eb9f02eec905f668abe9da03271f13d09a6899c0ff6a8b039775dd39498d089f994bb2450bec754b85f56ce828d8e6f1e43d381b88cb11065c7b2e6
+  data.tar.gz: 7b1df425490c8575c91498ae9da32fe7d03232b6a7c915d669020431619bc4173140a88cd4514f131d28ab25602bdc46c618cff2e50e3fb556f4cbcf78d3d3d4

data/.gitignore

@@ -11,6 +11,6 @@
 *.so
 *.o
 *.a
+mkmf.log
 *~
 *#
-mkmf.log

data/README.md

@@ -0,0 +1,33 @@
+# Frypan
+
+Very small and simple library to do Functional Reactive Programming in Ruby in a similar way to Elm.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'frypan'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install frypan
+
+## Short Tutorial
+
+To experience FRP and understand how to use this library, we make an imitation of Linux's atd(8) and at(1).
+
+[Click here to jump to Short Tutorial page.](https://github.com/sawaken/frypan/blob/master/tutorial/tutorial.md "Frypan - Short Tutorial")
+
+## Contributing
+
+1. Fork it ( https://github.com/sawaken/frypan/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -1,3 +1,5 @@
+# -*- mode:ruby -*-
+
 require "bundler/gem_tasks"
 require "rake/testtask"
 

data/frypan.gemspec

@@ -1,4 +1,4 @@
-# -*- mode: ruby -*-
+#-*- mode:ruby -*-
 # coding: utf-8
 lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
@@ -9,9 +9,8 @@ Gem::Specification.new do |spec|
   spec.version       = Frypan::VERSION
   spec.authors       = ["sawaken"]
   spec.email         = ["sasasawada@gmail.com"]
-  spec.summary       = %q{Yet another recording scheduler.}
-  spec.description   = %q{}
-  spec.homepage      = ""
+  spec.summary       = %q{Very small and simple library to do Functional Reactive Programming in Ruby in a similar way to Elm.}
+  spec.homepage      = "https://github.com/sawaken/tiny_frp2"
   spec.license       = "MIT"
 
   spec.files         = `git ls-files -z`.split("\x0")

data/lib/frypan.rb

@@ -1,57 +1,196 @@
 require "frypan/version"
 
 module Frypan
-  # TODO
-  #  imp APIServer
-  #  imp EpgParser
-
-  def self.main_signal(db, tuner_config=nil)
-    dbsync_ui_res        = DBSyncList.new("ui_response",   db)
-    dbsync_recording_log = DBSyncList.new("recording_log", db)
-    dbsync_program       = DBSyncList.new("program",       db)
-    dbsync_recorded      = DBSyncList.new("recorded",      db)
-
-    dbsync_reserve1 = DBSyncList.new("reserve1", db)
-    dbsync_reserve2 = DBSyncList.new("reserve2", db)
-    dbsync_reserve3 = DBSyncList.new("reserve3", db)
-    dbsync_reserve4 = DBSyncList.new("reserve4", db)
-
-    api_server = APIServer.new(db) # fork webrick. only op-command throw.
-
-    command = TinyFRP.lift{ api_server.get_next_command } # one-unit-command OR nil
-    #com = {
-    #  command_id: 1024,
-    #  target_tuner: 1
-    #  operations: [
-    #               {:kind => :remove, ::target => {reserve data (something including start_time)}},
-    #               {:kind => :add,    :target => {reserve data}}
-    #              ]
-    #}
-      
-    current_time = TinyFRP.lift{ Time.now.strftime("%Y%m%d%H%M%S") }
-
-    s1 = TinyFRP.bundle(command, current_time) >> Node.ReserveListFoldp("tuner1", dbsync_reserve1.to_a)
-    s2 = TinyFRP.bundle(command, current_time) >> Node.ReserveListFoldp("tuner2", dbsync_reserve2.to_a)
-    s3 = TinyFRP.bundle(command, current_time) >> Node.ReserveListFoldp("tuner3", dbsync_reserve3.to_a)
-    s4 = TinyFRP.bundle(command, current_time) >> Node.ReserveListFoldp("tuner4", dbsync_reserve4.to_a)
-
-    ui_res = Node.UIresponseFoldp(dbsync_ui_res) <<  TinyFRP.bundle(s1, s2, s3, s4)
-
-    ps1 = s1 >> Node.PersistantReserveListFoldp("tuner1", dbsync_reserve1)
-    ps2 = s2 >> Node.PersistantReserveListFoldp("tuner2", dbsync_reserve2)
-    ps3 = s3 >> Node.PersistantReserveListFoldp("tuner3", dbsync_reserve3)
-    ps4 = s4 >> Node.PersistantReserveListFoldp("tuner4", dbsync_reserve4)
-
-    t1 = s1 >> Node.RecordingAsyncFoldp(Tuner.new("fmt1"))
-    t2 = s2 >> Node.RecordingAsyncFoldp(Tuner.new("fmt2"))
-    t3 = s3 >> Node.RecordingAsyncFoldp(Tuner.new("fmt2"))
-    t4 = s4 >> Node.RecordingAsyncFoldp(Tuner.new("fmt2"))
-
-    recording_log = TinyFRP.bundle(t1, t2, t3, t4) >> Node.RecordingLogFoldp(dbsync_recording_log)
-    epg_extract   = recording_log >> Node.EpgExtractAsyncFoldp(EpgParser.new)
-    program_list  = epg_extract >> Node.ProgramListFoldp(dbsync_program)
-    recorded_list = recording_log >> Node.RecordedListFoldp(dbsync_recorded)
-
-    return TinyFRP.bundle(ui_res, ps1, ps2, ps3, ps4, program_list, recorded_list) >> TinyFRP.bottom
+
+  # Reactor : Object to calculate (Signal -> Value)
+  # ----------------------------------------
+
+  class Reactor
+    include Enumerable
+
+    def initialize(signal, init_memos=[{}, {}])
+      @signal = signal
+      @init_memos = init_memos
+    end
+
+    def loop(&block)
+      memos = @init_memos
+      while true
+        last_memo = @signal.__pull({}, *memos)
+        memos = [last_memo, memos[0]]
+        block.call(last_memo[@signal])
+      end
+    end
+    
+    def each(&block)
+      loop(&block)
+    end
+  end
+
+  # Signal : Abstraction of time-varing value
+  # ----------------------------------------
+
+  class Signal
+
+    # Utility Class methods (public to library-user)
+    # ----------------------------------------
+
+    def self.const(val)
+      Const.new(val)
+    end
+
+    def self.input(&proc)
+      Input.new(&proc)
+    end
+
+    def self.async_input(buf_size=1, &proc)
+      InputThread.new(buf_size, &proc)[0]
+    end
+
+    def self.lift(*arg_signals, &proc)
+      Lift.new(*arg_signals, &proc)
+    end
+
+    def self.foldp(init_state, *arg_signals, &proc)
+      Foldp.new(init_state, *arg_signals, &proc)
+    end
+
+    # Utility Instance methods (public to library-user)
+    # ----------------------------------------
+
+    def method_missing(name, *args, &proc)
+      Lift.new(self){|a| a.send(name, *args, &proc)}
+    end
+
+    def lift(&proc)
+      Lift.new(self, &proc)
+    end
+
+    def foldp(init_state, &proc)
+      Foldp.new(init_state, self, &proc)
+    end
+
+    # Implementation of each Signals (library-user need not understand)
+    # ----------------------------------------
+
+    def __pull(memo0, memo1, memo2)
+      if memo0.has_key?(self)
+        memo0
+      else
+        __calc(__pull_deps(memo0, memo1, memo2), memo1, memo2)
+      end
+    end
+
+    def __pull_deps(memo0, memo1, memo2)
+      memo0
+    end
+
+    def __same(memo_a, memo_b)
+      memo_a.has_key?(self) && memo_b.has_key?(self) && memo_a[self] == memo_b[self]
+    end
+
+    class Const < Signal
+      def initialize(val)
+        @val = val
+      end
+
+      def __calc(memo0, memo1, memo2)
+        memo0.merge(self => @val)
+      end
+    end
+
+    class Input < Signal
+      def initialize(&proc)
+        @input_proc = proc
+      end
+
+      def __calc(memo0, memo1, memo2)
+        memo0.merge(self => @input_proc.call)
+      end
+    end
+
+    class InputThread < Signal
+      def initialize(buf_size=1, &proc)
+        @buf_size = buf_size
+        @proc = proc
+      end
+
+      def atom(thread, &block)
+        thread[:mutex].synchronize(&block)
+      end
+
+      def make_thread
+        thread = ::Thread.new(@proc) do |proc| 
+          sleep
+          while true
+            input = proc.call
+            size = atom(Thread.current){
+              Thread.current[:inputs] << input
+              Thread.current[:inputs].size
+            }
+            sleep if size >= @buf_size
+          end
+        end
+        thread[:mutex] = Mutex.new
+        thread[:inputs] = []
+        thread.run
+        return thread
+      end
+
+      def get_inputs(thread)
+        atom(thread){
+          inputs = thread[:inputs]
+          thread[:inputs] = []
+          return inputs
+        }
+      end
+
+      def __calc(memo0, memo1, memo2)
+        unless memo1.has_key?(self)
+          memo0.merge(self => [[], make_thread])
+        else
+          inputs = get_inputs(memo1[self][1])
+          memo1[self][1].run
+          return memo0.merge(self => [inputs, memo1[self][1]])
+        end
+      end
+    end
+
+    class Lift < Signal
+      def initialize(*arg_signals, &proc)
+        @arg_signals, @proc = arg_signals, proc
+      end
+
+      def __pull_deps(memo0, memo1, memo2)
+        @arg_signals.inject(memo0){|acc, sig| sig.__pull(acc, memo1, memo2)}
+      end
+
+      def __calc(memo0, memo1, memo2)
+        if @arg_signals.all?{|sig| sig.__same(memo0, memo1)}
+          memo0.merge(self => memo1[self])
+        else
+          memo0.merge(self => @proc.call(*@arg_signals.map{|sig| memo0[sig]}))
+        end
+      end
+    end
+    
+    class Foldp < Signal
+      def initialize(init_state, *arg_signals, &proc)
+        @init_state, @arg_signals, @proc = init_state, arg_signals, proc
+      end
+
+      def __pull_deps(memo0, memo1, memo2)
+        @arg_signals.inject(memo0){|acc, sig| sig.__pull(acc, memo1, memo2)}
+      end
+
+      def __calc(memo0, memo1, memo2)
+        if __same(memo1, memo2) && @arg_signals.all?{|sig| sig.__same(memo0, memo1)}
+          memo0.merge(self => memo1[self])
+        else
+          state = memo1.has_key?(self) ? memo1[self] : @init_state
+          memo0.merge(self => @proc.call(state, *@arg_signals.map{|sig| memo0[sig]}))
+        end
+      end
+    end
   end
 end

data/lib/frypan/version.rb

@@ -1,3 +1,3 @@
 module Frypan
-  VERSION = "0.0.1"
+  VERSION = "1.0.0"
 end

data/tutorial/my_at.rb

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+
+require 'socket'
+
+loop do
+  print "execution-command> "
+  com = STDIN.gets
+  print "execution-time> "
+  time = STDIN.gets
+  
+  break unless com && time
+
+  socket = TCPSocket.open("localhost", 20000)
+  socket.write(com + time)
+  puts "response: #{socket.gets}"
+  socket.close
+end

data/tutorial/my_atd.rb

@@ -0,0 +1,85 @@
+#!/usr/bin/env ruby
+
+require 'frypan'
+require 'socket'
+require 'time'
+
+S = Frypan::Signal
+
+socket = TCPServer.new(20000)
+puts "my_atd listening port: 20000..."
+
+accepter = proc do
+  connection = socket.accept
+  c, t = connection.gets, connection.gets
+  {command_str: c.chomp, time_str: t.chomp, connection: connection}
+end
+
+timer = proc do
+  Time.now
+end
+
+update_commands = proc do |commands, ct, cs|
+  {
+    waitings: commands[:waitings].select{|c| c[:time] > ct} +
+    cs.select{|c| acceptable?(c)}.map{|c| c.update(time: Time.parse(c[:time_str]))},
+    launcheds: commands[:waitings].select{|c| c[:time] <= ct},
+    rejecteds: cs.reject{|c| acceptable?(c)}
+  }
+end
+
+output_formatize = proc do |coms, cs|
+  ress = cs.map do |c|
+    if coms[:rejecteds].include?(c)
+      msg = "Your specified time '#{c[:time_str]}' seems invalid.\n"
+    else
+      msg = "OK.\n"
+    end
+    {message: msg, connection: c[:connection]}
+  end
+  {commands: coms[:launcheds].map{|c| c[:command_str]}, responses: ress}
+end
+
+exec_commands = proc do |commands|
+  commands.each do |command|
+    puts "execute command '#{command}'"
+    pid =  Process.spawn(command, :out => STDOUT, :err => STDERR)
+    puts "PID = #{pid}"
+  end
+end
+
+respond = proc do |responses|
+  responses.each do |res|
+    res[:connection].write(res[:message])
+    res[:connection].close
+  end
+end
+
+output_processor = proc do |out|
+  exec_commands.call(out[:commands])
+  respond.call(out[:responses])
+end
+
+# helper method (pure function)
+def acceptable?(c)
+  Time.parse(c[:time_str])
+rescue
+  nil
+end
+
+# Input-Signal representing new clients.
+new_clients = S.async_input(5, &accepter)
+
+# Input-Signal representing current time.
+current_time = S.input(&timer)
+
+# Foldp-Signal representing registered commands.
+initial = {waitings: [], launcheds: [], rejecteds: []}
+commands = S.foldp(initial, current_time, new_clients, &update_commands)
+
+# Lift-Signal representing output datas.
+main = S.lift(commands, new_clients, &output_formatize)
+
+# FRP's main-loop.
+Frypan::Reactor.new(main).loop(&output_processor)
+

data/tutorial/sample_tcp_client.rb

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+
+require 'socket'
+
+socket = TCPSocket.open("localhost", 20000)
+socket.write(STDIN.gets)
+puts socket.gets
+socket.close