Bluebie-legs 0.6

data/README.rdoc

@@ -0,0 +1,62 @@
+= About Legs
+
+This is Legs, the little networking doodad somewhat inspired by Camping but not all that much really. It uses a lot of ruby trickery to give you one class, Legs, which can act as a server, a client, or a peer depending on how you use it. Oh, and the protocol it uses is {JSON-RPC 1.0}[http://json-rpc.org/wiki/specification], so quite platform and language agnostic. :)
+
+If you give Legs some methods, then anyone you connect to will be able to make calls back to those methods to notify you of things. Otherwise, your instance of legs will only be able to connect out to a legs server and call methods in that server, but not the other way around. If that's all you need, learning Camping[http://github.com/why/camping/tree/master] and using http might be a better way to go, as http is a more popular and more standard protocol. :)
+
+== To connect to a Legs server running on your own computer
+
+  server = Legs.new
+   - OR -
+  server = Legs.new('localhost')
+
+== To connect to a remote server
+
+  server = Legs.new('web.address.to.server')
+
+== To connect to a server on port 1234
+
+  server = Legs.new('web.address', 1234)
+
+== To create a legs server
+
+  Legs.start do
+    def callable_method(a, b, c = 'default')
+      return "You called with params #{a}, #{b}, and #{c}"
+    end
+  end
+  
+  sleep # Stops ruby from closing as soon as Legs starts.
+  # don't put sleep if you're embedding the server in a shoes UI or something.
+
+== To add methods to legs, without creating a server
+
+  Legs.start(false) do
+    def callable_method(a, b, c = 'default')
+      return "You called with params #{a}, #{b}, and #{c}"
+    end
+  end
+
+You should do this before creating instances of Legs with Legs.new. Adding methods like this is useful, because the "TCP" network connections Legs makes work in both directions, so if you have some methods, server's you connect to will be able to call your methods to notify you of events and stuff. If you don't give it +false+ on that first line, it will start up a server as well, so other instances of Legs can connect in to you, deliciously peery. It's important to know, though, that the <tt>Legs.users</tt> only includes connections who connected to you, not outgoing connections you make with Legs.new syntax. You could make your own array of outgoing connections to keep track ot them if you want. :)
+
+Inside of your Legs.start block, there are two magic methods you can use in your code, these are +server+ and +caller+. +server+ references the Legs server object, which has methods like +users+ and some other stuff you can use to your advantage. The +caller+ method gives you the Legs instance representing that network connection (doesn't matter if they connected to you or vice versa).
+
+Legs instances, like the one you get from +caller+, and the array of them you get from <tt>server.users</tt> have a useful method called +meta+ which gives you a hash you can store whatever you like inside of. Things you might put in there include the user's name, or if they have any special powers, so you can control which methods they can use and what they can do. Here's an example: :)
+
+  Legs.start do
+    def count
+      caller.meta[:counter] ||= 0
+      caller.meta[:counter] += 1
+    end
+  end
+  
+  sleep
+
+When you connect to this server, you can call the +count+ method. Each time you call it, it will give you a number, starting with 1 and growing higher each time. Because it stores the 'counter' in the caller's meta hash, if another person connects, they will start out with the number 1 as well. You could connect to this with :)
+
+  server = Legs.new('localhost')
+  puts "#{server.count}, #{server.count}, #{server.count}"
+
+And if you run that script, you should see in your terminal: "1, 2, 3". That's pretty much how Legs works. An instance of legs has a few of it's own special methods: <tt>close!</tt>, <tt>notify!</tt>, <tt>send!</tt>, <tt>send_async!</tt>, <tt>connected?</tt>, +socket+, +parent+, +meta+, and <tt>send_data!</tt>. If you need to actually run a method on your server with one of these names, do: <tt>server.send!(:connected?, a_param, another_param)</tt> or whatever, and it'll run that method on the server for you. If you want to let the server know something, but don't care about the method's response, or any errors, you can do the same thing with <tt>legs.notify!</tt>, which will make your program run faster, especially if it's running through the web. :)
+
+Finally, if you're making a program for running over the internet, and want to make your app more responsive, you can call methods asyncronously. What this means is that the method won't return immidiately, but instead will send the request out to your network, and your program will continue to run, and then when the server responds, a block you provide will be run. The block is passed an object, call that object's +result+ or +value+ method to get the server response, or it will raise an error if the server had an error, so you can use it as though it were a syncronous response. Error is only raised the first time you call it

data/examples/chat-server.rb

@@ -0,0 +1,119 @@
+require '../lib/legs'
+
+# this is a work in progress, api's will change and break, one day there will be a functional matching
+# client in shoes or something
+class User; attr_accessor :id, :name; end
+
+Legs.start do
+  def initialize
+    @rooms = Hash.new { {'users' => [], 'messages' => [], 'topic' => 'No topic set'} }
+    @rooms['Lobby'] = {'topic' => 'General Chit Chat', 'messages' => [], 'users' => []}
+  end
+  # returns a list of available rooms
+  def rooms
+    room_list = Hash.new
+    @rooms.keys.each { |rn| room_list[rn] = room_object rn, :remote, :topic, :users, :messages }
+    room_list
+  end
+  
+  # joins/creates a room
+  def join(room_name)
+    unless @rooms.keys.include?(room_name)
+      @rooms[room_name.to_s] = @rooms[room_name]
+      server.broadcast :room_created, room_name
+    end
+    
+#     room = room_object(room_name)
+#     
+#     unless room['users'].include?(caller)
+#       broadcast_to room, 'user_joined', room_name, user_object(caller)
+#       room['users'].push(caller)
+#     end
+    
+    room_object room_name, :remote
+  end
+  
+  # leaves a room
+  def leave(room_name)
+    room = @rooms[room_name.to_s]
+    room['users'].delete(caller)
+    broadcast_to room, 'user_left', room_name, user_object(caller)
+    true
+  end
+  
+  # sets the room topic message
+  def set_topic(room, message)
+    @rooms[room.to_s]['topic'] = message.to_s
+    broadcast_to room, 'room_changed', room_object(room, :remote, :name, :topic)
+  end
+  
+  # sets the user's name
+  def set_name(name)
+    caller.meta[:name] = name.to_s
+    user_rooms(caller).each do |room_name|
+      broadcast_to room_name, 'user_changed', user_object(caller)
+    end
+    true
+  end
+  
+  # returns information about ones self, clients thusly can find out their user 'id' number
+  def get_user(object_id = nil)
+    user = user_object( object_id.nil? ? caller : users.select { |u| u.object_id == object_id.to_i }.first )
+    user['rooms'] = user_rooms(user)
+    return user
+  end
+  
+  # posts a message to a room
+  def post_message(room_name, message)
+    room = room_object(room_name)
+    room['messages'].push(msg = {'user' => user_object(caller), 'time' => Time.now.to_i, 'message' => message.to_s} )
+    trim_messages room
+    broadcast_to room, 'message', room_name.to_s, msg
+    return msg
+  end
+  
+  private
+  
+  # trims the message backlog
+  def trim_messages room
+    room = room_object(room) if room.is_a?(String)
+    while room['messages'].length > 250
+      room['messages'].shift
+    end
+  end
+  
+  # sends a notification to members of a room
+  def broadcast_to room, *args
+    room = @rooms[room.to_s] if room.is_a? String
+    room['users'].each do |user|
+      user.notify! *args
+    end
+    return true
+  end
+  
+  # makes a user object suitable for sending back with meta info and stuff
+  def user_object user
+    object = {'id' => user.object_id}
+    user.meta.each_pair do |key, value|
+      object[key.to_s] = value
+    end
+    return object
+  end
+  
+  def room_object room_name, target = :local, *only
+    object = @rooms[room_name.to_s].dup
+    object['users'].delete_if {|user| user.connected? == false }
+    object['users'] = object['users'].map { |user| user_object(user) } if target == :remote
+    object['topic'] = 'No topic set' if object['topic'].nil? or object['topic'].empty?
+    object['name'] = room_name.to_s if target == :remote
+    object.delete_if { |key, value| only.include?(key.to_sym) == false } unless only.empty?
+    object
+  end
+  
+  # returns all the room names the user is in.
+  def user_rooms user
+    @rooms.values.select { |room| room['users'].include?(user) }.map { |room| @rooms.index(room) }
+  end
+end
+
+sleep

data/examples/echo-server.rb

@@ -0,0 +1,24 @@
+require '../lib/legs'
+
+# This is how simple a Legs server can look.
+
+Legs.start do
+  def echo(text)
+    return text
+  end
+end
+
+sleep
+
+# To test this server, first, run it in ruby, and then open another terminal, telnet localhost 30274
+# Then enter:
+#   {"method":"echo","params":["Hello World"],"id":1}
+# result should be:
+#   {"result":"Hello World","id":1}
+# however the properties may appear in a different order, this makes no difference.
+
+# Test to ensure there are no security flaws...
+# Try {"method":"object_id","params":[],"id":1}
+# Should return: {"error":"Cannot run 'object_id' because it is not defined in this server","id":1}
+# And try: {"method":"caller","params":[],"id":1}
+# Should recieve a similar error response. :)

data/examples/shoes-chat-client.rb

@@ -0,0 +1,159 @@
+# Shoes Chat Client is a generic irc-like chat system, made in Legs and Shoes, as a way to find
+# any troublesome parts in Legs and learn stuff about Shoes. :)
+
+#HOSTNAME = 'localhost'
+HOSTNAME = 'bluebie.creativepony.com'
+
+
+Shoes.setup do
+  gem 'json_pure >= 1.1.1'
+end
+
+require 'json/pure.rb'
+require '../lib/legs'
+
+# This add's some methods the server can call on to notify us of events like a new message
+Legs.start false do
+  attr_accessor :app, :rooms
+  
+  def user_left room_name, user
+    @rooms[room_name]['users'].delete_if { |u| u['id'] == user['id'] }
+  end
+  
+  def user_joined room_name, user
+    @rooms[room_name]['users'].push user unless @rooms[room_name]['users'].include?(user)
+  end
+  
+  def room_created room
+    @app.add_room room
+  end
+  
+  def room_changed room
+    @app.update_room room.delete('name'), room
+  end
+  
+  def user_changed user
+    @rooms.each do |room|
+      room['users'].map! do |room_user|
+        if user['id'] == room_user['id']
+          user
+        else
+          room_user
+        end
+      end
+    end
+    #@app.update_user_list
+  end
+  
+  def room_message room, message
+    @app.add_message message
+  end
+end
+
+
+class LegsChat < Shoes
+  url '/', :index
+  url '/room/(\w+)', :room
+  
+  Chat = Legs.new(HOSTNAME)
+  
+  def index
+    #Legs.server_object.app = self
+    #name = ask("What's your name?")
+    #Chat.notify! :set_name, name
+    
+    @@room_data = Chat.rooms
+    @@joined_rooms = []
+    @@available_rooms = @@room_data.keys
+    visit('/room/Lobby')
+  end
+  
+  def room name
+    unless @@joined_rooms.include? name
+      @@room_data[name] = Chat.join(name)
+      @@joined_rooms.push name
+    end
+    
+    @room = name
+    timer(0.5) { layout } # don't know why I need this, but layout goes all weird without delay
+  end
+  
+  def layout
+    clear do
+      background white
+      
+      @rooms_list = stack :width => 180, :height => 1.0
+      stack do
+        @log = stack :width => -360, :height => -30, :scroll => true, :margin_right => gutter
+        
+        flow :margin_right => gutter, :height => 30 do
+          @msg_input = edit_line(:width => -100)
+          
+          submit = Proc.new do
+            add_message @room, Chat.post_message(@room, @msg_input.text)
+            @msg_input.text = ''
+          end
+          
+          button("Send", :width => 100, &submit)
+        end
+
+      end
+      @users_list = stack :width => 180, :height => 1.0
+    end
+    
+    @@available_rooms.each { |r| add_room r }
+    @@room_data[@room]['messages'].each { |m| add_message @room, m }
+  end
+  
+  
+  # adds a message to the display
+  def add_message room_name, message
+    unless @@room_data[room_name]['messages'].include? message
+      messages = @@room_data[room_name]['messages']
+      messages.push message
+      @@room_data[room_name]['messages'] = messages[-500,500] if messages.length > 500
+    end
+    
+    return if room_name != @room
+    scroll_down = @log.scroll_top >= @log.scroll_max - 10
+    @log.append do
+      flow do
+        para strong(message['user']['name'] || message ['user']['id']), ':  ', message['message']
+      end
+    end
+    
+    while @log.contents.length > 500
+      @log.contents.first.remove
+    end
+    
+    @log.scroll_top = @log.scroll_max
+  end
+  
+  
+  # adds a room to the sidebar
+  def add_room room_name
+    @@available_rooms.push room_name unless @@available_rooms.include? room_name
+    @rooms_list.append do
+      flow :margin => 5 do
+        # _why assures me the :checked style will work in the next release
+        joined = check :checked => @@joined_rooms.include?(room_name) do |chk|
+          @@joined_rooms.push(room_name) and @@room_data[room_name].merge! Chat.join(room_name) if chk.checked?
+          Chat.leave(room_name) and @@joined_rooms.delete(room_name) unless chk.checked?
+        end
+        
+        para room_name, :underline => (@room == room_name ? :one : false)
+        
+        click do
+          visit("/room/#{room_name}")
+        end unless @room == room_name
+      end
+    end
+  end
+  
+  def update_room room_name, data
+    @@room_data[room_name].merge! data
+  end
+end
+
+Shoes.app(:title => "Legs Chat", :width => 700, :height => 350)
+

data/legs.gemspec

@@ -0,0 +1,13 @@
+Gem::Specification.new do |s|
+  s.name = "legs"
+  s.version = "0.6"
+  s.date = "2008-07-12"
+  s.summary = "Simple fun open networking for newbies and quick hacks"
+  s.email = "blue@creativepony.com"
+  s.homepage = "http://github.com/Bluebie/legs"
+  s.description = "Legs is a really simple fun networking library that uses 'json-rpc' formated messages over a tcp connection to really easily built peery or server-clienty sorts of apps, for ruby newbies and hackers to build fun little things."
+  s.has_rdoc = false
+  s.authors = ["Jenna 'Bluebie' Fox"]
+  s.files = ["README.rdoc", "legs.gemspec", "lib/legs.rb", "examples/echo-server.rb", "examples/chat-server.rb", "examples/shoes-chat-client.rb", "test/tester.rb"]
+  s.add_dependency("json_pure", ["> 1.1.0"])
+end

data/lib/legs.rb

@@ -0,0 +1,351 @@
+# Legs take you places, a networking companion to Shoes
+require 'rubygems'
+require 'json' unless self.class.const_defined? 'JSON'
+require 'socket'
+require 'thread'
+
+Thread.abort_on_exception = true # Should be able to run without this, hopefully. Helps with debugging though
+
+class Legs
+  attr_reader :socket, :parent, :meta
+  
+  # Legs.new for a client, subclass to make a server, .new then makes server and client!
+  def initialize(host = 'localhost', port = 30274)
+    self.class.start(port) if self.class != Legs && !self.class.started?
+    ObjectSpace.define_finalizer(self) { self.close! }
+    @socket = TCPSocket.new(host, port) and @parent = false if host.instance_of?(String)
+    @socket = host and @parent = port if host.instance_of?(TCPSocket)
+    @responses = Hash.new; @meta = {}; @closed = false
+    @responses_mutex = Mutex.new; @socket_mutex = Mutex.new
+    
+    @handle_data = Proc.new do |data|
+      data = self.__json_restore(JSON.parse(data))
+      
+      if data['method'] == '**remote__disconnecting**'
+        self.close!
+      elsif @parent and data['method']
+        @parent.__data!(data, self)
+      elsif data['error'] and data['id'].nil?
+        raise data['error']
+      else
+        @responses_mutex.synchronize { @responses[data['id']] = data }
+      end
+    end
+    
+    @thread = Thread.new do
+      while connected?
+        begin
+          self.close! if @socket.eof?
+          data = nil
+          @socket_mutex.synchronize { data = @socket.gets(self.class.terminator) }
+          if data.nil?
+            self.close!
+          else
+            @handle_data[data]
+          end
+        rescue JSON::ParserError => e
+          self.send_data!({"error" => "JSON provided is invalid. See http://json.org/ to see how to format correctly."})
+        rescue IOError => e
+          self.close!
+        end
+      end
+    end
+  end
+  
+  # I think you can guess this one
+  def connected?; @socket.closed? == false and @closed == false; end
+  
+  # closes the connection and the threads and stuff for this user
+  def close!
+    @closed = true
+    puts "User #{self.inspect} disconnecting" if self.class.log?
+    @parent.event(:disconnect, self) if @parent
+    
+    # notify the remote side
+    notify!('**remote__disconnecting**') rescue nil
+    
+    @parent.users_mutex.synchronize { @parent.users.delete(self) } if @parent
+    
+    @socket.close rescue nil
+  end
+  
+  # send a notification to this user
+  def notify!(method, *args)
+    puts "Notify #{self.__inspect}: #{method}(#{args.map { |i| i.inspect }.join(', ')})" if self.__class.log?
+    self.__send_data!({'method' => method.to_s, 'params' => args, 'id' => nil})
+  end
+  
+  # sends a normal RPC request that has a response
+  def send!(method, *args)
+    puts "Call #{self.__inspect}: #{method}(#{args.map { |i| i.inspect }.join(', ')})" if self.__class.log?
+    id = self.__get_unique_number
+    self.send_data! 'method' => method.to_s, 'params' => args, 'id' => id
+    
+    while @responses_mutex.synchronize { @responses.keys.include?(id) } == false
+      sleep(0.01)
+    end
+    
+    data = @responses_mutex.synchronize { @responses.delete(id) }
+    
+    error = data['error']
+    raise error unless error.nil?
+    
+    puts ">> #{method} #=> #{data['result'].inspect}" if self.__class.log?
+    
+    return data['result']
+  end
+  
+  def inspect
+    "<Legs:#{__object_id} Meta: #{@meta.inspect}>"
+  end
+  
+  # does an async request which calls a block when response arrives
+  def send_async!(method, *args, &blk)
+    puts "Call #{self.__inspect}: #{method}(#{args.map { |i| i.inspect }.join(', ')})" if self.__class.log?
+    id = self.__get_unique_number
+    self.send_data! 'method' => method.to_s, 'params' => args, 'id' => id
+    
+    Thread.new do
+      while @responses_mutex.synchronize { @responses.keys.include?(id) } == false
+        sleep(0.05)
+      end
+      
+      data = @responses_mutex.synchronize { @responses.delete(id) }
+      puts ">> #{method} #=> #{data['result'].inspect}" if self.__class.log? unless data['error']
+      blk[Legs::AsyncData.new(data)]
+    end
+  end
+  
+  # maps undefined methods in to rpc calls
+  def method_missing(method, *args)
+    return self.send(method, *args) if method.to_s =~ /^__/
+    send!(method, *args)
+  end
+  
+  # hacks the send method so ancestor methods instead become rpc calls too
+  # if you want to use a method in a Legs superclass, prefix with __
+  def send(method, *args)
+    return super(method.to_s.sub(/^__/, ''), *args) if method.to_s =~ /^__/
+    return super(method, *args) if self.__public_methods(false).include?(method)
+    super('send!', method.to_s, *args)
+  end
+
+  # sends raw object over the socket
+  def send_data!(data)
+    raise "Lost remote connection" unless connected?
+    @socket_mutex.synchronize { @socket.write(JSON.generate(__json_marshal(data)) + self.__class.terminator) }
+  end
+  
+  
+  private
+  
+  # takes a ruby object, and converts it if needed in to marshalled hashes
+  def json_marshal(object)
+    case object
+    when Bignum, Fixnum, Integer, Float, TrueClass, FalseClass, String, NilClass
+      return object
+    when Hash
+      out = Hash.new
+      object.each_pair { |k,v| out[k.to_s] = __json_marshal(v) }
+      return out
+    when Array
+      return object.map { |v| __json_marshal(v) }
+    else
+      return {'__jsonclass__' => [object.class.name, object._dump]} if object.respond_to?(:_dump)
+      
+      # the default marshalling behaviour
+      instance_vars = {}
+      object.instance_variables.each do |var_name|
+        instance_vars[var_name.to_s.sub(/@/, '')] = self.__json_marshal(object.instance_variable_get(var_name))
+      end
+      
+      return {'__jsonclass__' => [object.class.name]}.merge(instance_vars)
+    end
+  end
+  
+  # takes an object from the network, and decodes any marshalled hashes back in to ruby objects
+  def json_restore(object)
+    case object
+    when Hash
+      if object.keys.include? '__jsonclass__'
+        constructor = object.delete('__jsonclass__')
+        class_name = constructor.shift.to_s
+        object_class = Module.const_get(class_name) rescue false
+        
+        if object_class.name == class_name
+          return object_class._load(*constructor) if object_class.respond_to?(:_load) unless constructor.empty?
+          
+          instance = object_class.allocate
+          object.each_pair do |key, value|
+            instance.instance_variable_set("@#{key}", self.__json_restore(value))
+          end
+          return instance
+        else
+          raise "Response contains a #{class_name} but that class is not loaded locally."
+        end
+      else
+        hash = Hash.new
+        object.each_pair { |k,v| hash[k] = self.__json_restore(v) }
+        return hash
+      end
+    when Array
+      return object.map { |i| self.__json_restore(i) }
+    else
+      return object
+    end
+  end
+  
+  # gets a unique number that we can use to match requests to responses
+  def get_unique_number; @unique_id ||= 0; @unique_id += 1; end
+end
+
+
+# the server is started by subclassing Legs, then SubclassName.start
+class << Legs
+  attr_accessor :terminator, :log
+  attr_reader :users, :server_object, :users_mutex, :messages_mutex
+  alias_method :log?, :log
+  
+  def initializer
+    ObjectSpace.define_finalizer(self) { self.stop! }
+    @users = []; @messages = Queue.new; @terminator = "\n"; @log = true
+    @users_mutex = Mutex.new
+  end
+  
+  
+  # starts the server, pass nil for port to make a 'server' that doesn't actually accept connections
+  # This is useful for adding methods to Legs so that systems you connect to can call methods back on you
+  def start(port=30274, &blk)
+    return if started?
+    raise "Legs.start requires a block" unless blk
+    @started = true
+    
+    # make the fake class
+    @server_class = Class.new
+    @server_class.module_eval { private; attr_reader :server, :caller; public }
+    @server_class.module_eval(&blk)
+    @server_object = @server_class.allocate
+    @server_object.instance_variable_set(:@server, self)
+    @server_object.instance_eval { initialize }
+    
+    @message_processor = Thread.new do
+      while started?
+        sleep(0.01) and next if @messages.empty?
+        data, from = @messages.deq
+        method = data['method']; params = data['params']
+        methods = @server_object.public_methods(false)
+        
+        begin
+          raise "Supplied method is not a String" unless method.is_a?(String)
+          raise "Supplied params object is not an Array" unless params.is_a?(Array)
+          raise "Cannot run '#{method}' because it is not defined in this server" unless methods.include?(method.to_s) or methods.include? :method_missing
+          
+          puts "Call #{method}(#{params.map { |i| i.inspect }.join(', ')})" if log?
+          
+          @server_object.instance_variable_set(:@caller, from)
+          
+          result = nil
+          
+          @users_mutex.synchronize do
+            if methods.include?(method.to_s)
+              result = @server_object.__send__(method.to_s, *params)
+            else
+              result = @server_object.method_missing(method.to_s, *params)
+            end
+          end
+          
+          puts ">> #{method} #=> #{result.inspect}" if log?
+          
+          from.send_data!({'id' => data['id'], 'result' => result}) unless data['id'].nil?
+          
+        rescue Exception => e
+          from.send_data!({'error' => e, 'id' => data['id']}) unless data['id'].nil?
+          puts "Backtrace: \n" + e.backtrace.map { |i| "   #{i}" }.join("\n") if log?
+        end
+      end
+    end
+    
+    unless port.nil? or port == false
+      @listener = TCPServer.new(port)
+      
+      @acceptor_thread = Thread.new do
+        while started?
+          user = Legs.new(@listener.accept, self)
+          @users_mutex.synchronize { @users.push user }
+          puts "User #{user.object_id} connected, number of users: #{@users.length}" if log?
+          self.event :connect, user
+        end
+      end
+    end
+  end
+  
+  # stops the server, disconnects the clients
+  def stop
+    @started = false
+    @users.each { |user| user.close! }
+  end
+  
+  # sends a notification message to all connected clients
+  def broadcast(method, *args)
+    @users.each { |user| user.notify!(method, *args) }
+  end
+  
+  # Finds a user by the value of a certain property... like find_user_by :object_id, 12345
+  def find_user_by property, value
+    @users.find { |user| user.__send(property) == value }
+  end
+  
+  def find_users_by property, *values
+    @users.select { |user| user.__send(property) == value }
+  end
+  
+  # gives you an array of all the instances of Legs which are still connected
+  # direction can be :both, :in, or :out
+  def connections direction = :both
+    return @users if direction == :in
+    list = Array.new
+    ObjectSpace.each_object(self) do |leg|
+      next if list.include?(leg) unless leg.connected?
+      next unless leg.parent == false if direction == :out
+      list.push leg
+    end
+    return list
+  end
+  
+  # add an event call to the server's message queue
+  def event(name, sender, *extras)
+    return unless @server_object.respond_to?("on_#{name}")
+    __data!({'method' => "on_#{name}", 'params' => extras.to_a, 'id' => nil}, sender)
+  end
+  
+  # gets called to handle all incomming messages (RPC requests)
+  def __data!(data, from)
+    @messages.enq [data, from]
+  end
+  
+  # returns true if server is running
+  def started?; @started; end
+  
+  # creates a legs client, and passes it to supplied block, closes client after block finishes running
+  # I wouldn't have added this method to keep shoes small, but users insist comedic value makes it worthwhile
+  def open(*args, &blk)
+    client = Legs.new(*args)
+    blk[client]
+    client.close!
+  end
+end
+
+Legs.initializer
+
+
+class Legs::AsyncData
+  def initialize(data); @data = data; end
+  def result
+    @errored = true and raise @data['error'] if @data['error'] unless @errored
+    return @data['result']
+  end
+  alias_method :value, :result
+end
+
+class Legs::StartBlockError < StandardError; end
+class Legs::RequestError < StandardError; end

data/test/tester.rb

@@ -0,0 +1,108 @@
+require '../lib/legs.rb'
+
+# class to test the marshaling
+class Testing
+  attr_accessor :a, :b, :c
+end
+
+Legs.log = false
+
+# a simple server to test with
+Legs.start(6425) do
+  def echo(text)
+    return text
+  end
+  
+  def count
+    caller.meta[:counter] ||= 0
+    caller.meta[:counter] += 1
+  end
+  
+  def error
+    raise StandardError.new("This is a fake error")
+  end
+  
+  def test_notify
+    puts "Success"
+  end
+  
+  def marshal
+    obj = Testing.new
+    obj.a = 1; obj.b = 2; obj.c = 3
+    return obj
+  end
+  
+  def on_disconnect
+    puts "#{caller.inspect} disconnected"
+  end
+  
+  def on_connect
+    $server_instance = caller
+  end
+end
+
+## connects and tests a bunch of things
+puts "Testing syncronous echo"
+i = Legs.new('localhost',6425)
+i.meta[:name] = 'first tester client'
+puts i.echo('Hello World') == 'Hello World' ?"Success":"Failure"
+
+puts "Testing Count"
+puts i.count==1 && i.count == 2 && i.count == 3 ?'Success':'Failure'
+
+puts "Testing count resets correctly"
+ii = Legs.new('localhost',6425)
+ii.meta[:name] = 'second tester client'
+puts ii.count == 1 && ii.count == 2 && ii.count == 3 ?'Success':'Failure'
+ii.close!
+
+sleep(0.5)
+puts "Testing disconnection went well"
+puts ii.connected? == false && $server_instance.connected? == false ?'Success':'Failure'
+
+ii = nil
+ObjectSpace.garbage_collect
+
+puts "Testing server disconnect worked correctly"
+sleep(0.5)
+puts Legs.users.length == 1 ?'Success':"Failure: #{Legs.users.length}"
+
+puts "Testing async call..."
+i.send_async!(:echo, 'Testing') do |r|
+  puts r.result == 'Testing' ?'Success':'Failure'
+end
+sleep(0.5)
+
+puts "Testing async error..."
+i.send_async!(:error) do |r|
+  begin
+    v = r.result
+    puts "Failure"
+  rescue
+    puts "Success"
+  end
+end
+sleep(0.5)
+
+puts "Testing regular error"
+v = i.error rescue :good
+puts v == :good ?'Success':'Failure'
+
+puts "Testing notify!"
+i.test_notify
+
+puts "Testing marshalling"
+m = i.marshal
+puts m.a == 1 && m.b == 2 && m.c == 3 ?'Success':'Failure'
+
+puts "Testing Legs.connections"
+puts (Legs.connections(:out) == i and Legs.connections.length == 2 and Legs.connections(:in) == Legs.users.first) ?'Success':'Failure'
+puts ":in => #{Legs.connections(:in).map{ |l| l.inspect }}"
+puts ":out => #{Legs.connections(:out).map{ |l| l.inspect }}"
+puts ":both => #{Legs.connections.map{ |l| l.inspect }}"
+
+puts "All: "
+ObjectSpace.each_object(Legs) { |l| puts "  #{l.inspect}" }
+
+puts
+puts "Done"

metadata

@@ -0,0 +1,67 @@
+--- !ruby/object:Gem::Specification 
+name: Bluebie-legs
+version: !ruby/object:Gem::Version 
+  version: "0.6"
+platform: ruby
+authors: 
+- Jenna 'Bluebie' Fox
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-07-12 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: json_pure
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">"
+      - !ruby/object:Gem::Version 
+        version: 1.1.0
+    version: 
+description: Legs is a really simple fun networking library that uses 'json-rpc' formated messages over a tcp connection to really easily built peery or server-clienty sorts of apps, for ruby newbies and hackers to build fun little things.
+email: blue@creativepony.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- README.rdoc
+- legs.gemspec
+- lib/legs.rb
+- examples/echo-server.rb
+- examples/chat-server.rb
+- examples/shoes-chat-client.rb
+- test/tester.rb
+has_rdoc: false
+homepage: http://github.com/Bluebie/legs
+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: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: Simple fun open networking for newbies and quick hacks
+test_files: []
+