wick 0.1

data/examples/calculator

@@ -0,0 +1,22 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH << File.expand_path('../../lib', __FILE__)
+
+require 'wick/io'
+
+Wick::IO.bind(read: $stdin, write: $stdout) do |input|
+  initial = {total: 0}
+
+  state = input.scan(initial) { |s, line|
+    if line.strip.empty?
+      {total: 0, message: "Total: #{s[:total]}"}
+    else
+      {total: s[:total] + line.to_f}
+    end
+  }
+  
+  output = state.select { |s| s.has_key?(:message) }
+                .map    { |s| s[:message] + "\n\n" }
+
+  output
+end

data/examples/echo

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+$LOAD_PATH << File.expand_path('../../lib', __FILE__)
+
+require 'wick/io'
+
+Wick::IO.bind(read: $stdin, write: $stdout) do |input|
+  input.map { |line| "Haha! You said “#{line.chomp}”." }
+end

data/examples/irc/basic

@@ -0,0 +1,73 @@
+#!/usr/bin/env ruby
+
+unless ARGV.length >= 1
+  $stderr.puts "Usage: #{$0} HOST [PORT [NICK]]"
+  exit 1
+end
+
+$LOAD_PATH << File.expand_path('../../../lib', __FILE__)
+$LOAD_PATH << File.expand_path('../lib', __FILE__)
+
+require 'wick/io'
+require 'irc_event'
+require 'socket'
+require 'colored'
+
+def main
+  host = ARGV.fetch(0)
+  port = ARGV.fetch(1) { "6667"     }
+  nick = ARGV.fetch(2) { "frippery" }
+
+  socket = TCPSocket.new(host, port)
+
+  Wick::IO.bind(
+    read:  [socket, $stdin],
+    write: [socket, $stdout]
+  ) do |network_in, user_in|
+    server_events = network_in.map { |line| IRCEvent.parse(line) }
+
+    client          = Client.new(nick)
+    client_commands = client.transform(server_events)
+    network_out     = user_in.merge(client_commands)
+
+    ui       = UI.new
+    user_out = ui.transform(client_commands, server_events)
+
+    [network_out, user_out]
+  end
+end
+
+class Client < Struct.new(:nick)
+  def transform(server_events)
+    nick_and_user = Wick.from_array([
+      "NICK #{nick}",
+      "USER #{nick} () * #{nick}"
+    ])
+
+    ping = server_events.select { |msg| msg.command == "PING" }
+    pong = ping.map { |msg| "PONG " + msg.params.join(" ") }
+
+    nick_and_user.merge(pong)
+  end
+end
+
+class UI
+  def transform(client_commands, server_events)
+    incoming_messages = server_events.select { |event| event.command == "PRIVMSG" }
+    other_events      = server_events.select { |event| event.command != "PRIVMSG" }
+
+    message_lines = incoming_messages.map { |event|
+      channel = event.params[0]
+      user    = "<#{event.user}>"
+      message = event.params[1]
+
+      "#{channel.green} #{user.yellow} #{message}"
+    }
+
+    message_lines
+      .merge(other_events.map { |event| "< #{event.line}".magenta })
+      .merge(client_commands.map { |line| "> #{line}".magenta })
+  end
+end
+
+main

data/examples/irc/lib/irc_event.rb

@@ -0,0 +1,60 @@
+# Copied from https://github.com/Nerdmaster/ruby-irc-yail/blob/develop/lib/net/yail/message_parser.rb
+
+class IRCEvent
+  attr_reader :line, :nick, :user, :host, :prefix, :command, :params, :servername
+
+  USER        = /\S+?/
+  NICK        = /[\w\d\\|`'^{}\]\[-]+?/
+  HOST        = /\S+?/
+  SERVERNAME  = /\S+?/
+
+  # This is automatically grouped for ease of use in the parsing.  Group 1 is
+  # the full prefix; 2, 3, and 4 are nick/user/host; 1 is also servername if
+  # there was no match to populate 2, 3, and 4.
+  PREFIX      = /((#{NICK})!(#{USER})@(#{HOST})|#{SERVERNAME})/
+  COMMAND     = /(\w+|\d{3})/
+  TRAILING    = /\:\S*?/
+  MIDDLE      = /(?: +([^ :]\S*))/
+
+  MESSAGE     = /^(?::#{PREFIX} +)?#{COMMAND}(.*)$/
+
+  def self.parse(line)
+    new(line)
+  end
+
+  def initialize(line)
+    line = line.sub(/[\r\n]+$/, '')
+
+    @line = line
+    @params = []
+
+    if line =~ MESSAGE
+      matches = Regexp.last_match
+
+      @prefix = matches[1]
+      if (matches[2])
+        @nick = matches[2]
+        @user = matches[3]
+        @host = matches[4]
+      else
+        @servername = matches[1]
+      end
+
+      @command = matches[5]
+
+      # Args are a bit tricky.  First off, we know there must be a single
+      # space before the arglist, so we need to strip that.  Then we have to
+      # separate the trailing arg as it can contain nearly any character. And
+      # finally, we split the "middle" args on space.
+      arglist = matches[6].sub(/^ +/, '')
+      arglist.sub!(/^:/, ' :')
+      (middle_args, trailing_arg) = arglist.split(/ +:/, 2)
+      @params.push(middle_args.split(/ +/)) if middle_args
+      @params.push(trailing_arg) if trailing_arg
+      @params.compact!
+      @params.flatten!
+    end
+
+    freeze
+  end
+end

data/examples/irc/lib/nice.rb

@@ -0,0 +1,23 @@
+require 'wick/io'
+require 'socket'
+
+require 'nice/client'
+require 'nice/ui'
+require 'nice/manager'
+
+module Nice
+  def self.run!(host, port, nick)
+    client  = Client.new(nick)
+    ui      = UI.new(nick)
+    manager = Manager.new(client, ui)
+
+    socket = TCPSocket.new(host, port)
+
+    Wick::IO.bind(
+      read:  [socket, $stdin],
+      write: [socket, $stdout]
+    ) do |network_in, user_in|
+      manager.transform(network_in, user_in)
+    end
+  end
+end

data/examples/irc/lib/nice/client.rb

@@ -0,0 +1,58 @@
+require 'irc_event'
+
+module Nice
+  class Client < Struct.new(:nick)
+    def initialize(*args)
+      super(*args)
+      freeze
+    end
+
+    def transform(network_in, user_commands)
+      server_events = network_in.map { |line| IRCEvent.parse(line) }
+
+      nick_and_user = Wick.from_array([
+        "NICK #{nick}",
+        "USER #{nick} () * #{nick}"
+      ])
+
+      ping = server_events.select { |msg| msg.command == "PING" }
+      pong = ping.map { |msg| "PONG " + msg.params.join(" ") }
+
+      outgoing = process_user_commands(user_commands)
+
+      network_out = outgoing.merge(nick_and_user).merge(pong)
+
+      server_events.log!("server_events")
+      network_out.log!("network_out")
+
+      [network_out, server_events]
+    end
+
+    def process_user_commands(user_commands)
+      user_commands.map { |cmd|
+        case cmd.action
+        when nil
+          if cmd.channel
+            "PRIVMSG #{cmd.channel} :#{cmd.argument}"
+          else
+            cmd.argument
+          end
+        when :me
+          cmd.channel && "PRIVMSG #{cmd.channel} :\x01ACTION #{cmd.argument}\x01"
+        when :msg
+          "PRIVMSG #{cmd.channel} :#{cmd.argument}"
+        when :join
+          "JOIN #{cmd.channel}"
+        when :part
+          "PART #{cmd.channel}"
+        when :quit
+          "QUIT :#{cmd.argument}"
+        when :raw
+          cmd.argument
+        else
+          nil
+        end
+      }.compact
+    end
+  end
+end

data/examples/irc/lib/nice/manager.rb

@@ -0,0 +1,23 @@
+module Nice
+  class Manager
+    def initialize(client, ui)
+      @client = client
+      @ui = ui
+      freeze
+    end
+
+    def transform(network_in, user_in)
+      server_events_bus = Wick::Bus.new
+      user_commands_bus = Wick::Bus.new
+
+      network_out, server_events = @client.transform(network_in, user_commands_bus)
+      user_out,    user_commands = @ui.transform(user_in, server_events_bus)
+
+      server_events_bus.consume!(server_events)
+      user_commands_bus.consume!(user_commands)
+
+      [network_out, user_out]
+    end
+  end
+end
+

data/examples/irc/lib/nice/ui.rb

@@ -0,0 +1,135 @@
+require 'nice/user_command'
+require 'colored'
+
+module Nice
+  class UI
+    class ChannelState < Struct.new(:joined_channels, :channel_index)
+      def current_channel_name
+        channel_index && joined_channels[channel_index]
+      end
+
+      def update_channel_index(inc)
+        ChannelState.new(
+          joined_channels,
+          (channel_index + inc) % joined_channels.length)
+      end
+
+      def join_channel(name)
+        new_list = joined_channels | [name]
+        new_idx  = new_list.length-1
+
+        ChannelState.new(new_list, new_idx)
+      end
+
+      def part_channel(name)
+        new_list = joined_channels - [name]
+        new_idx  = [channel_index, new_list.length-1].min
+
+        ChannelState.new(new_list, new_idx)
+      end
+    end
+
+    def initialize(username)
+      @username = username
+      freeze
+    end
+
+    def transform(user_in, server_events)
+      user_commands_without_channel = user_in.map { |line| UserCommand.parse(line) }.log!("user_commands_without_channel")
+
+      channel_state = get_channel_state(user_commands_without_channel, server_events).log!("channel_state")
+
+      user_commands = user_commands_without_channel.sampling(channel_state) { |cmd, cs|
+        cmd.with_channel(cs.current_channel_name)
+      }.log!("user_commands")
+
+      message_log = get_message_log(user_commands, server_events).log!("message log")
+
+      user_out = render_output(channel_state, message_log)
+
+      [user_out, user_commands]
+    end
+
+    def get_channel_state(user_commands_without_channel, server_events)
+      manual_changes    = get_manual_state_changes(user_commands_without_channel)
+      automatic_changes = get_automatic_state_changes(server_events)
+
+      initial_state = ChannelState.new([], nil)
+
+      manual_changes.merge(automatic_changes)
+                    .scan(initial_state) { |cs, change| change.call(cs) }
+    end
+
+    def get_manual_state_changes(user_commands_without_channel)
+      user_commands_without_channel.select { |cmd| cmd.action == :next or cmd.action == :prev }
+                   .map { |cmd|
+                     proc { |cs|
+                       if cmd.action == :next
+                         cs.update_channel_index(+1)
+                       elsif cmd.action == :prev
+                         cs.update_channel_index(-1)
+                       end
+                     }
+                   }
+    end
+
+    def get_automatic_state_changes(server_events)
+      server_events.select { |event| event.user == @username }
+                   .select { |event| event.command == "JOIN" or event.command == "PART" }
+                   .map { |event|
+                     proc { |cs|
+                       if event.command == "JOIN"
+                         cs.join_channel(event.params.first)
+                       elsif event.command == "PART"
+                         cs.part_channel(event.params.first)
+                       end
+                     }
+                   }
+    end
+
+    def get_message_log(user_commands, server_events)
+      outgoing_messages = user_commands.select { |cmd| cmd.action.nil? }
+                                       .map { |cmd| [cmd.channel, @username, cmd.argument] }
+
+      incoming_messages = server_events.select { |event| event.command == "PRIVMSG" }
+                                       .map { |event| [event.params[0], event.user, event.params[1]] }
+
+      outgoing_messages.merge(incoming_messages).scan(Hash.new([])) { |map, triple|
+        channel, user, message = *triple
+        map.merge(channel => map[channel] + ["<#{user}>".yellow + " #{message}"])
+      }
+    end
+
+    def render_output(channel_state, message_log)
+      message_log.combine(channel_state) { |current_log, cs|
+        if current_log and cs
+          tabs = cs.joined_channels.map { |c|
+            if c == cs.current_channel_name
+              c.green
+            else
+              c
+            end
+          }
+
+          channel_log = current_log[cs.current_channel_name].last(20)
+
+          clear_screen + move_to(1,1) + tabs.join(" ") + "\n" + channel_log.join("\n")
+        else
+          ""
+        end
+      }
+    end
+
+    def clear_screen
+      ansi("2J")
+    end
+
+    def move_to(x, y)
+      ansi("#{x};#{y}H")
+    end
+
+    def ansi(str)
+      "\e[#{str}"
+    end
+  end
+end

data/examples/irc/lib/nice/user_command.rb

@@ -0,0 +1,45 @@
+module Nice
+  class UserCommand < Struct.new(:action, :argument, :channel)
+    REGEX = /
+      ^
+      \/     # leading slash
+      (\w+)  # action
+      (
+        \s+  # space
+        (.+) # argument
+      )?
+      $
+    /x
+
+    def self.parse(line)
+      line = line.chomp
+
+      if match = line.match(REGEX)
+        action   = match[1].downcase.to_sym
+        argument = match[3]
+        channel  = nil
+
+        if [:msg, :join, :part].include?(action)
+          channel, argument = argument.split(/\s+/, 2)
+        end
+
+        new(action, argument, channel)
+      else
+        new(nil, line, nil)
+      end
+    end
+
+    def initialize(*args)
+      super(*args)
+      freeze
+    end
+
+    def with_channel(channel_name)
+      if channel
+        self
+      else
+        UserCommand.new(action, argument, channel_name)
+      end
+    end
+  end
+end

data/examples/irc/nice

@@ -0,0 +1,38 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH << File.expand_path('../../../lib', __FILE__)
+$LOAD_PATH << File.expand_path('../lib', __FILE__)
+
+require 'slop'
+require 'nice'
+
+opts = Slop.parse(help: true) do
+  banner "Usage: #{$0} HOST [OPTIONS]"
+
+  on 'port=', 'Port to connect to',               default: '6667'
+  on 'nick=', 'Nick (and username) to use',       default: 'frippery'
+  on 'log=',  'Filename to log to (default: irc.log, stderr if blank)', default: 'irc.log'
+end
+
+if ARGV.length != 1
+  puts opts
+  exit 1
+end
+
+host = ARGV.fetch(0)
+
+if opts[:log] != ''
+  $stderr.reopen File.open(opts[:log], 'a')
+  $stderr.sync = true
+end
+
+begin
+  Nice.run!(host, opts[:port], opts[:nick])
+rescue
+  if $stderr.is_a?(File)
+    puts "Something went wrong. Check #{$stderr.path}, or run again with --log '' to output to stderr."
+  end
+
+  raise
+end
+

data/examples/telnet

@@ -0,0 +1,20 @@
+#!/usr/bin/env ruby
+
+unless ARGV.length >= 1
+  $stderr.puts "Usage: #{$0} HOST [PORT]"
+  exit 1
+end
+
+$LOAD_PATH << File.expand_path('../../lib', __FILE__)
+
+require 'wick/io'
+require 'socket'
+
+socket = TCPSocket.new(ARGV[0], ARGV[1] || 23)
+
+Wick::IO.bind(
+  read:  [socket, $stdin],
+  write: [socket, $stdout]
+) do |network_in, user_in|
+  [user_in, network_in]
+end

data/lib/wick.rb

@@ -0,0 +1,39 @@
+require 'wick/stream'
+require 'wick/bus'
+
+module Wick
+  START = Object.new.freeze
+
+  class << self
+    def from_array(array)
+      s = Stream.new
+      on_next_tick do
+        array.each do |item|
+          s << item
+        end
+      end
+      s
+    end
+
+    def run_loop!(&block)
+      while true
+        tick!
+        block.call()
+      end
+    end
+
+    def on_next_tick(&callback)
+      @tick_callbacks ||= []
+      @tick_callbacks.push(callback)
+    end
+
+    private
+
+    def tick!
+      return unless @tick_callbacks
+      while callback = @tick_callbacks.shift
+        callback.call()
+      end
+    end
+  end
+end

data/lib/wick/bus.rb

@@ -0,0 +1,8 @@
+module Wick
+  class Bus < Stream
+    def consume!(stream)
+      stream.pipe!(self)
+    end
+  end
+end
+

data/lib/wick/io.rb

@@ -0,0 +1,41 @@
+require 'wick'
+
+module Wick
+  module IO
+    def self.bind(options, &block)
+      readables_array = [options[:read]].flatten
+      writables_array = [options[:write]].flatten
+
+      read_map = {}
+      readables_array.each do |io|
+        read_map[io] = Stream.new
+      end
+
+      block_arg = read_map.values
+
+      write_streams = [block.call(*block_arg)].flatten
+      write_map = Hash[writables_array.zip(write_streams)]
+
+      write_map.each_pair do |io, stream|
+        stream.each do |line|
+          io.puts(line)
+        end
+      end
+
+      read_map.values.each do |stream|
+        stream.start!
+      end
+
+      Wick.run_loop! do
+        ready = ::IO.select(read_map.keys)
+        ready[0].each do |io|
+          io.read_nonblock(1_000_000).each_line do |line|
+            read_map[io] << line
+          end
+        end
+      end
+    rescue EOFError
+      puts "A connection was closed. Shutting down."
+    end
+  end
+end

data/lib/wick/stream.rb

@@ -0,0 +1,125 @@
+module Wick
+  class Stream
+    def initialize
+      @handlers = []
+      @start_callbacks = []
+
+      Wick.on_next_tick do
+        self.start!
+      end
+    end
+
+    def <<(data)
+      @handlers.each do |handler|
+        handler.call(data)
+      end
+    end
+
+    def each(&handler)
+      @handlers << handler
+    end
+
+    def at_start
+      s = Stream.new
+      @start_callbacks.push(proc { s << Wick::START })
+      s
+    end
+
+    def start!
+      @start_callbacks.each(&:call)
+    end
+
+    def map(&transformer)
+      s = Stream.new
+      self.each do |msg|
+        s << transformer.call(msg)
+      end
+      s
+    end
+
+    def flat_map(&transformer)
+      s = Stream.new
+      self.each do |msg|
+        transformer.call(msg).pipe!(s)
+      end
+      s
+    end
+
+    def select(&predicate)
+      s = Stream.new
+      self.each do |msg|
+        s << msg if predicate.call(msg)
+      end
+      s
+    end
+
+    def compact
+      select { |msg| not msg.nil? }
+    end
+
+    def merge(other)
+      s = Stream.new
+      self.pipe!(s)
+      other.pipe!(s)
+      s
+    end
+
+    def combine(other, &combiner)
+      latest_self  = nil
+      latest_other = nil
+
+      s = Stream.new
+
+      self.each do |msg|
+        latest_self = msg
+        s << combiner.call(msg, latest_other)
+      end
+
+      other.each do |msg|
+        latest_other = msg
+        s << combiner.call(latest_self, msg)
+      end
+
+      s
+    end
+
+    def sampling(other, &combiner)
+      latest_other = nil
+
+      other.each do |msg|
+        latest_other = msg
+      end
+
+      s = Stream.new
+
+      self.each do |msg|
+        s << combiner.call(msg, latest_other)
+      end
+
+      s
+    end
+
+    def scan(initial, &scanner)
+      s = Wick.from_array([initial])
+      last = initial
+      self.each do |msg|
+        last = scanner.call(last, msg)
+        s << last
+      end
+      s
+    end
+
+    def log!(prefix)
+      self.each do |msg|
+        $stderr.puts("[#{prefix}] " + msg.inspect)
+      end
+      self
+    end
+
+    def pipe!(other)
+      self.each do |msg|
+        other << msg
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,59 @@
+--- !ruby/object:Gem::Specification
+name: wick
+version: !ruby/object:Gem::Version
+  version: '0.1'
+  prerelease: 
+platform: ruby
+authors:
+- Aanand Prasad
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-04-03 00:00:00.000000000 Z
+dependencies: []
+description: 
+email: aanand.prasad@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- examples/calculator
+- examples/echo
+- examples/irc/basic
+- examples/irc/lib/irc_event.rb
+- examples/irc/lib/nice.rb
+- examples/irc/lib/nice/client.rb
+- examples/irc/lib/nice/manager.rb
+- examples/irc/lib/nice/ui.rb
+- examples/irc/lib/nice/user_command.rb
+- examples/irc/nice
+- examples/telnet
+- lib/wick.rb
+- lib/wick/bus.rb
+- lib/wick/io.rb
+- lib/wick/stream.rb
+homepage: https://github.com/aanand/wick
+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.23
+signing_key: 
+specification_version: 3
+summary: Functional reactive programming library
+test_files: []