rstyx 0.2.0 → 0.3.0

data/tests/tc_styxservproto.rb

@@ -0,0 +1,596 @@
+#!/usr/bin/ruby
+#
+# Copyright (C) 2006, 2007 Rafael Sevilla
+# This file is part of RStyx
+#
+# RStyx is free software; you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as
+# published by the Free Software Foundation; either version 2.1
+# of the License, or (at your option) any later version.
+#
+# RStyx is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTIBILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with RStyx; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St., Fifth Floor, Boston, MA
+# 02110-1301 USA.
+#
+# $Id: tc_styxservproto.rb 222 2007-07-09 08:15:44Z dido $
+#
+require 'test/unit'
+require 'flexmock'
+require 'rstyx/server'
+
+##
+# A simple class that simply accepts any method on itself
+# and does nothing.
+#
+class Absorber
+  def method_missing(name, *args)
+    # do nothing
+  end
+end
+
+module RStyx
+  module Server
+    # Stub for sessions
+    class Session
+      def initialize
+      end
+
+      def self.mock=(m)
+        @@mock = m
+      end
+
+      def initialize(conn)
+      end
+
+      def reset_session(msize)
+        return(@@mock.reset_session(msize))
+      end
+
+      def version_negotiated?
+        return(@@mock.version_negotiated?)
+      end
+
+      def has_fid?(fid)
+        return(@@mock.has_fid?(fid))
+      end
+
+      def execute?(styxfile)
+        return(@@mock.execute?(styxfile))
+      end
+
+      def writable?(styxfile)
+        return(@@mock.writable?(styxfile))
+      end
+
+      def []=(fid, file)
+        return(@@mock[fid] = file)
+      end
+
+      def [](fid)
+        return(@@mock[fid])
+      end
+
+      def flush_tag(fid)
+        return(@@mock.flush_tag(fid))
+      end
+
+      def release_tag(fid)
+        return(@@mock.release_tag(fid))
+      end
+
+      def confirm_open(sf, mode)
+        return(@@mock.confirm_open(sf, mode))
+      end
+
+      def iounit
+        return(@@mock.iounit)
+      end
+
+    end
+  end
+end
+
+##
+# Fake connection object mixin used to mix the StyxServerProtocol
+# module or a copy thereof.
+#
+class FakeConnection
+  include RStyx::Server::StyxServerProtocol
+
+  ##
+  # Mock objects are required for:
+  #
+  # 1. Methods called to self
+  # 2. Methods called to the session object
+  # 3. Methods called to the root object
+  # 4. (Optionally) Methods called to the logger
+  #
+  def initialize(selfmock, sessionmock, rootmock, log=Absorber.new)
+    @selfmock = selfmock
+    RStyx::Server::Session.mock = sessionmock
+    self.root = rootmock
+    self.log = log
+    post_init
+  end
+
+  def getpeername
+    return(nil)
+  end
+
+  def method_missing(meth, *args)
+    @selfmock.call(meth, *args)
+  end
+end
+
+class TestStyxServProto < Test::Unit::TestCase
+  def test_tversion
+    FlexMock.use("sessmock") do |sessmock|
+      serv = FakeConnection.new(nil, sessmock, nil)
+      sessmock.should_receive(:reset_session).with(Integer).returns do |m|
+        assert_equal(1024, m)
+      end
+      resp = serv.tversion(RStyx::Message::Tversion.new(:version => "9P2000",
+                                                        :msize => 1024))
+      assert_equal(RStyx::Message::Rversion, resp.class)
+      assert_equal("9P2000", resp.version)
+      assert_equal(8216, resp.msize)
+    end
+
+    FlexMock.use("sessmock") do |sessmock|
+      serv = FakeConnection.new(nil, sessmock, nil)
+      resp = serv.tversion(RStyx::Message::Tversion.new(:version => "foo",
+                                                        :msize => 1024))
+      assert_equal(RStyx::Message::Rerror, resp.class)
+      assert_equal("Unsupported protocol version foo (must be 9P2000)", resp.ename)
+    end
+  end
+
+  def test_tauth
+    serv = FakeConnection.new(nil, nil, nil)
+    resp = serv.tauth(RStyx::Message::Tauth.new(:fid => 1,
+                                                :afid => 2,
+                                                :uname => "foo",
+                                                :aname => "bar"))
+    assert_equal(RStyx::Message::Rerror, resp.class)
+    assert_equal("Authentication methods through auth messages are not used.", resp.ename)
+  end
+
+  def test_tattach
+    # Test no version negotiation error
+    FlexMock.use("sessmock") do |sessmock|
+      sessmock.should_receive(:version_negotiated?).returns(false)
+      serv = FakeConnection.new(nil, sessmock, nil)
+      assert_raises(RStyx::StyxException) do
+        serv.tattach(RStyx::Message::Tattach.new(:fid => 1,
+                                                 :afid => 2,
+                                                 :uname => "foo",
+                                                 :aname => "bar"))
+      end
+    end
+
+    # Test used fid error
+    FlexMock.use("sessmock") do |sessmock|
+      sessmock.should_receive(:version_negotiated?).returns(true)
+      sessmock.should_receive(:has_fid?).with(1).returns(true)
+      serv = FakeConnection.new(nil, sessmock, nil)
+      assert_raises(RStyx::StyxException) do
+        serv.tattach(RStyx::Message::Tattach.new(:fid => 1,
+                                                 :afid => 2,
+                                                 :uname => "foo",
+                                                 :aname => "bar"))
+      end
+    end
+
+    # test successful condition
+    FlexMock.use("sessmock") do |sessmock|
+      FlexMock.use("rootmock") do |rootmock|
+        sessmock.should_receive(:version_negotiated?).returns(true)
+        sessmock.should_receive(:has_fid?).with(1).returns(false)
+        sessmock.should_receive(:[]=).with(1, rootmock)
+        # Return a phony QID with a distinctive pattern
+        rootmock.should_receive(:qid).returns(RStyx::Message::Qid.new(0x12345678, 0x87654321, 0xfeedfacec0ffeee))
+        serv = FakeConnection.new(nil, sessmock, rootmock)
+        resp = serv.tattach(RStyx::Message::Tattach.new(:fid => 1,
+                                                        :afid => 2,
+                                                        :uname => "foo",
+                                                        :aname => "bar"))
+        assert_equal(0x12345678, resp.qid.qtype)
+        assert_equal(0x87654321, resp.qid.version)
+        assert_equal(0xfeedfacec0ffeee, resp.qid.path)
+      end
+    end
+  end
+
+  def test_tflush
+    FlexMock.use("sessmock") do |sessmock|
+      sessmock.should_receive(:flush_tag).with(100)
+      serv = FakeConnection.new(nil, sessmock, nil)
+      resp = serv.tflush(RStyx::Message::Tflush.new(:oldtag => 100))
+      assert_equal(RStyx::Message::Rflush, resp.class)
+    end
+  end
+
+  def test_twalk
+    # Test for wnames > MAXWELEM
+    serv = FakeConnection.new(nil, nil, nil)
+    assert_raises(RStyx::StyxException) do
+      serv.twalk(RStyx::Message::Twalk.new(:fid => 1,
+                                           :newfid => 2,
+                                           :wnames => ["1", "2", "3",
+                                                       "4", "5", "6",
+                                                       "7", "8", "9",
+                                                       "10,", "11", "12",
+                                                       "13", "14", "15",
+                                                       "16", "17", "18"]))
+    end
+
+    # test for walking to an open fid
+    FlexMock.use("sessmock") do |sessmock|
+      FlexMock.use("filemock") do |filemock|
+        sessmock.should_receive(:[]).with(42).returns(filemock)
+        filemock.should_receive(:client).returns(:pwn3d)
+        serv = FakeConnection.new(nil, sessmock, nil)
+        assert_raises(RStyx::StyxException) do
+          serv.twalk(RStyx::Message::Twalk.new(:fid => 42,
+                                               :newfid => 43,
+                                               :wnames => ["1", "2"]))
+        end
+      end
+    end
+
+    # Test attempting to reassign a fid that is already in use
+    FlexMock.use("sessmock") do |sessmock|
+      FlexMock.use("filemock") do |filemock|
+        sessmock.should_receive(:[]).with(42).returns(filemock)
+        filemock.should_receive(:client).returns(nil)
+        sessmock.should_receive(:has_fid?).with(43).returns(true)
+        serv = FakeConnection.new(nil, sessmock, nil)
+        assert_raises(RStyx::StyxException) do
+          serv.twalk(RStyx::Message::Twalk.new(:fid => 42,
+                                               :newfid => 43,
+                                               :wnames => ["1", "2"]))
+        end
+      end
+    end
+
+    # Test walking to something which isn't a directory
+    FlexMock.use("sessmock") do |sessmock|
+      FlexMock.use("filemock") do |filemock|
+        sessmock.should_receive(:[]).with(42).returns(filemock)
+        filemock.should_receive(:client).returns(nil)
+        sessmock.should_receive(:has_fid?).with(43).returns(false)
+        filemock.should_receive(:directory?).returns(false)
+        filemock.should_receive(:name).returns("foo")
+        serv = FakeConnection.new(nil, sessmock, nil)
+        assert_raises(RStyx::StyxException) do
+          serv.twalk(RStyx::Message::Twalk.new(:fid => 42,
+                                               :newfid => 43,
+                                               :wnames => ["1", "2"]))
+        end
+      end
+    end
+
+    # Test for the case where file permissions are violated
+    FlexMock.use("sessmock") do |sessmock|
+      FlexMock.use("filemock") do |filemock|
+        sessmock.should_receive(:[]).with(42).returns(filemock)
+        filemock.should_receive(:client).returns(nil)
+        sessmock.should_receive(:has_fid?).with(43).returns(false)
+        filemock.should_receive(:directory?).returns(true)
+        filemock.should_receive(:name).returns("foo")
+        sessmock.should_receive(:execute?).returns(false)
+        serv = FakeConnection.new(nil, sessmock, nil)
+        assert_raises(RStyx::StyxException) do
+          serv.twalk(RStyx::Message::Twalk.new(:fid => 42,
+                                               :newfid => 43,
+                                               :wnames => ["..", "2"]))
+        end
+      end
+    end
+
+    # Test for the case where we are unable to walk further than the
+    # first element
+    FlexMock.use("sessmock") do |sessmock|
+      FlexMock.use("filemock") do |filemock|
+        sessmock.should_receive(:[]).with(42).returns(filemock)
+        filemock.should_receive(:client).returns(nil)
+        sessmock.should_receive(:has_fid?).with(43).returns(false)
+        filemock.should_receive(:directory?).returns(true)
+        filemock.should_receive(:name).returns("foo")
+        filemock.should_receive(:atime=)
+        filemock.should_receive(:[]).with("1").returns(nil)
+        serv = FakeConnection.new(nil, sessmock, nil)
+        assert_raises(RStyx::StyxException) do
+          serv.twalk(RStyx::Message::Twalk.new(:fid => 42,
+                                               :newfid => 43,
+                                               :wnames => ["1", "2"]))
+        end
+      end
+    end
+
+    # Test successful walk without fid assignment
+    FlexMock.use("sessmock") do |sessmock|
+      FlexMock.use("filemock") do |filemock|
+        sessmock.should_receive(:[]).with(42).returns(filemock)
+        filemock.should_receive(:client).returns(nil)
+        sessmock.should_receive(:has_fid?).with(43).returns(false)
+        filemock.should_receive(:directory?).returns(true)
+        filemock.should_receive(:name).returns("foo")
+        filemock.should_receive(:atime=)
+        filemock.should_receive(:[]).with("1").returns(filemock)
+        filemock.should_receive(:[]).with("2").returns(nil)
+        filemock.should_receive(:qid).returns(RStyx::Message::Qid.new(0x12345678, 0x87654321, 0xfeedfacec0ffeee))
+        filemock.should_receive(:refresh)
+        serv = FakeConnection.new(nil, sessmock, nil)
+        resp = serv.twalk(RStyx::Message::Twalk.new(:fid => 42,
+                                                    :newfid => 43,
+                                                    :wnames => ["1", "2"]))
+        assert_equal(RStyx::Message::Rwalk, resp.class)
+        assert_equal(1, resp.qids.length)
+        assert_equal(RStyx::Message::Qid.new(0x12345678,
+                                             0x87654321,
+                                             0xfeedfacec0ffeee),
+                     resp.qids[0])
+      end
+    end
+
+    # Test successful walk with fid assignment
+    FlexMock.use("sessmock") do |sessmock|
+      FlexMock.use("filemock") do |filemock|
+        sessmock.should_receive(:[]).with(42).returns(filemock)
+        filemock.should_receive(:client).returns(nil)
+        sessmock.should_receive(:has_fid?).with(43).returns(false)
+        filemock.should_receive(:directory?).returns(true)
+        filemock.should_receive(:name).returns("foo")
+        filemock.should_receive(:atime=)
+        filemock.should_receive(:[]).with("1").returns(filemock)
+        filemock.should_receive(:[]).with("2").returns(filemock)
+        qids = [ RStyx::Message::Qid.new(0x12345678,
+                                         0x87654321,
+                                         0xfeedfacec0ffeee),
+                 RStyx::Message::Qid.new(0x89abcdef,
+                                         0x01234567,
+                                         0x0123456789abcdef)
+               ]
+        filemock.should_receive(:qid).returns { qids.shift }
+        filemock.should_receive(:refresh)
+        sessmock.should_receive(:[]=).with(42, filemock)
+        serv = FakeConnection.new(nil, sessmock, nil)
+        resp = serv.twalk(RStyx::Message::Twalk.new(:fid => 42,
+                                                    :newfid => 43,
+                                                    :wnames => ["1", "2"]))
+        assert_equal(RStyx::Message::Rwalk, resp.class)
+        assert_equal(2, resp.qids.length)
+        assert_equal(RStyx::Message::Qid.new(0x12345678,
+                                             0x87654321,
+                                             0xfeedfacec0ffeee),
+                     resp.qids[0])
+        assert_equal(RStyx::Message::Qid.new(0x89abcdef,
+                                             0x01234567,
+                                             0x0123456789abcdef),
+
+                     resp.qids[1])
+      end
+    end
+
+
+  end
+
+  def test_topen
+    FlexMock.use("sessmock") do |sessmock|
+      FlexMock.use("filemock") do |filemock|
+        sessmock.should_receive(:[]).with(42).returns(filemock)
+        sessmock.should_receive(:confirm_open).with(filemock, RStyx::OTRUNC)
+        filemock.should_receive(:add_client)
+        filemock.should_receive(:set_mtime)
+        sessmock.should_receive(:user)
+        filemock.should_receive(:qid).returns(RStyx::Message::Qid.new(0x12345678, 0x87654321, 0xfeedfacec0ffeee))
+        sessmock.should_receive(:iounit).returns(0xdeadbeef)
+        serv = FakeConnection.new(nil, sessmock, nil)
+        resp = serv.topen(RStyx::Message::Topen.new(:fid => 42,
+                                                    :mode => RStyx::OTRUNC))
+        assert_equal(RStyx::Message::Qid.new(0x12345678, 0x87654321, 0xfeedfacec0ffeee), resp.qid)
+        assert_equal(0xdeadbeef, resp.iounit)
+      end
+    end
+  end
+
+  def test_tcreate
+    # First, test the error condition of trying to create a file
+    # inside a fid representing a file.
+    FlexMock.use("sessmock") do |sessmock|
+      FlexMock.use("filemock") do |filemock|
+        sessmock.should_receive(:[]).with(42).returns(filemock)
+        filemock.should_receive(:directory?).returns(false)
+        serv = FakeConnection.new(nil, sessmock, nil)
+        assert_raises(RStyx::StyxException) do
+          resp = serv.tcreate(RStyx::Message::Tcreate.new(:fid => 42,
+                                                          :mode => RStyx::OTRUNC))
+        end
+      end
+    end
+
+    # Second, test the error condition where we try to create a file
+    # where the connection does not have permission to write.
+    FlexMock.use("sessmock") do |sessmock|
+      FlexMock.use("filemock") do |filemock|
+        sessmock.should_receive(:[]).with(42).returns(filemock)
+        filemock.should_receive(:directory?).returns(true)
+        sessmock.should_receive(:writable?).returns(false)
+        serv = FakeConnection.new(nil, sessmock, nil)
+        assert_raises(RStyx::StyxException) do
+          resp = serv.tcreate(RStyx::Message::Tcreate.new(:fid => 42,
+                                                          :mode => RStyx::OTRUNC))
+        end
+      end
+    end
+
+    # Third, successful creation.
+    FlexMock.use("sessmock") do |sessmock|
+      FlexMock.use("filemock") do |filemock|
+        sessmock.should_receive(:[]).with(42).returns(filemock)
+        filemock.should_receive(:directory?).returns(true)
+        sessmock.should_receive(:writable?).returns(true)
+        filemock.should_receive(:newfile).with("foo", 0644).returns(filemock)
+        filemock.should_receive(:<<).with(filemock)
+        sessmock.should_receive(:[]=).with(42, filemock)
+        filemock.should_receive(:add_client)
+        filemock.should_receive(:qid).returns(RStyx::Message::Qid.new(0x12345678, 0x87654321, 0xfeedfacec0ffeee))
+        sessmock.should_receive(:iounit).returns(0xdeadbeef)
+        serv = FakeConnection.new(nil, sessmock, nil)
+        resp = serv.tcreate(RStyx::Message::Tcreate.new(:fid => 42,
+                                                        :name => "foo",
+                                                        :perm => 0644,
+                                                        :mode =>
+                                                        RStyx::OTRUNC))
+        assert_equal(RStyx::Message::Rcreate, resp.class)
+        assert_equal(RStyx::Message::Qid.new(0x12345678,
+                                             0x87654321,
+                                             0xfeedfacec0ffeee), resp.qid)
+        assert_equal(0xdeadbeef, resp.iounit)
+      end
+    end
+
+  end
+
+  def test_tread
+    # Test error condition -- file not open for reading
+    FlexMock.use("sessmock") do |sessmock|
+      FlexMock.use("filemock") do |filemock|
+        sessmock.should_receive(:[]).with(42).returns(filemock)
+        filemock.should_receive(:client).returns(nil)
+        serv = FakeConnection.new(nil, sessmock, nil)
+        assert_raises(RStyx::StyxException) do
+          resp = serv.tread(RStyx::Message::Tread.new(:fid => 42,
+                                                      :offset => 0xfeedfacec0ffeeee,
+                                                      :count => 100))
+        end
+      end
+    end
+
+    # Test trying to read more than the session iounit
+    FlexMock.use("sessmock") do |sessmock|
+      FlexMock.use("filemock") do |filemock|
+        sessmock.should_receive(:[]).with(42).returns(filemock)
+        filemock.should_receive(:client).returns(filemock)
+        filemock.should_receive(:readable?).returns(true)
+        sessmock.should_receive(:iounit).returns(8216)
+        serv = FakeConnection.new(nil, sessmock, nil)
+        assert_raises(RStyx::StyxException) do
+          resp = serv.tread(RStyx::Message::Tread.new(:fid => 42,
+                                                      :offset => 0xfeedfacec0ffeeee,
+                                                      :count => 10000))
+        end
+      end
+    end
+
+    # Test successful read
+    FlexMock.use("sessmock") do |sessmock|
+      FlexMock.use("filemock") do |filemock|
+        sessmock.should_receive(:[]).with(42).returns(filemock)
+        filemock.should_receive(:client).returns(filemock)
+        filemock.should_receive(:readable?).returns(true)
+        sessmock.should_receive(:iounit).returns(8216)
+        filemock.should_receive(:read).returns do |a1,a2,a3|
+          assert_equal(0xfeedfacec0ffeeee, a2)
+          assert_equal(1000, a3)
+          true
+        end
+        serv = FakeConnection.new(nil, sessmock, nil)
+        resp = serv.tread(RStyx::Message::Tread.new(:fid => 42,
+                                                    :offset => 0xfeedfacec0ffeeee,
+                                                    :count => 1000))
+        assert(resp)
+      end
+    end
+
+  end
+
+  def test_twrite
+    # Test error condition -- file not open for writing
+    FlexMock.use("sessmock") do |sessmock|
+      FlexMock.use("filemock") do |filemock|
+        sessmock.should_receive(:[]).with(42).returns(filemock)
+        filemock.should_receive(:client).returns(nil)
+        serv = FakeConnection.new(nil, sessmock, nil)
+        assert_raises(RStyx::StyxException) do
+          resp = serv.twrite(RStyx::Message::Twrite.new(:fid => 42,
+                                                        :offset => 0xfeedfacec0ffeeee,
+                                                        :data => "0" * 1000))
+        end
+      end
+    end
+
+    # Test trying to write more than the session iounit
+    FlexMock.use("sessmock") do |sessmock|
+      FlexMock.use("filemock") do |filemock|
+        sessmock.should_receive(:[]).with(42).returns(filemock)
+        filemock.should_receive(:client).returns(filemock)
+        filemock.should_receive(:writable?).returns(true)
+        sessmock.should_receive(:iounit).returns(8216)
+        serv = FakeConnection.new(nil, sessmock, nil)
+        assert_raises(RStyx::StyxException) do
+          resp = serv.twrite(RStyx::Message::Twrite.new(:fid => 42,
+                                                        :offset => 0xfeedfacec0ffeeee,
+                                                        :data => "0" * 10000))
+        end
+      end
+    end
+
+    # Test successful write
+    FlexMock.use("sessmock") do |sessmock|
+      FlexMock.use("filemock") do |filemock|
+        sessmock.should_receive(:[]).with(42).returns(filemock)
+        filemock.should_receive(:client).returns(filemock)
+        filemock.should_receive(:writable?).returns(true)
+        sessmock.should_receive(:iounit).returns(8216)
+        filemock.should_receive(:write).returns do |a1,a2,a3,a4|
+          assert_equal(0xfeedfacec0ffeeee, a2)
+          assert_equal("0" * 1000, a3)
+          assert(!a4)
+          true
+        end
+        filemock.should_receive(:truncate?).returns(false)
+        filemock.should_receive(:appendonly?).returns(false)
+        filemock.should_receive(:length).returns(42)
+        serv = FakeConnection.new(nil, sessmock, nil)
+        resp = serv.twrite(RStyx::Message::Twrite.new(:fid => 42,
+                                                      :offset => 0xfeedfacec0ffeeee,
+                                                      :data => "0" * 1000))
+        assert(resp)
+      end
+    end
+
+
+    # Test successful write on an append only file
+    FlexMock.use("sessmock") do |sessmock|
+      FlexMock.use("filemock") do |filemock|
+        sessmock.should_receive(:[]).with(42).returns(filemock)
+        filemock.should_receive(:client).returns(filemock)
+        filemock.should_receive(:writable?).returns(true)
+        sessmock.should_receive(:iounit).returns(8216)
+        filemock.should_receive(:write).returns do |a1,a2,a3,a4|
+          assert_equal(42, a2)
+          assert_equal("0" * 1000, a3)
+          assert(!a4)
+          true
+        end
+        filemock.should_receive(:truncate?).returns(false)
+        filemock.should_receive(:appendonly?).returns(true)
+        filemock.should_receive(:length).returns(42)
+        serv = FakeConnection.new(nil, sessmock, nil)
+        resp = serv.twrite(RStyx::Message::Twrite.new(:fid => 42,
+                                                      :offset => 0xfeedfacec0ffeeee,
+                                                      :data => "0" * 1000))
+        assert(resp)
+      end
+    end
+  end
+
+end

metadata

@@ -1,48 +1,73 @@
 --- !ruby/object:Gem::Specification 
-rubygems_version: 0.8.11
+rubygems_version: 0.9.4
 specification_version: 1
 name: rstyx
 version: !ruby/object:Gem::Version 
-  version: 0.2.0
-date: 2005-11-01 00:00:00 +08:00
-summary: RStyx is an implementation of the Styx/9P2000 distributed filesystem protocol for Ruby.
+  version: 0.3.0
+date: 2007-08-10 00:00:00 +08:00
+summary: RStyx is a Ruby implementation of the 9P2000/Styx distributed file protocol used on Plan 9 and Inferno.
 require_paths: 
-  - lib
+- lib
 email: dido@imperium.ph
 homepage: http://rubyforge.org/projects/rstyx
-rubyforge_project: 
-description: 
-autorequire: rstyx
+rubyforge_project: rstyx
+description: 9P2000/Styx for Ruby
+autorequire: 
 default_executable: 
 bindir: bin
 has_rdoc: true
 required_ruby_version: !ruby/object:Gem::Version::Requirement 
   requirements: 
-    - 
-      - ">"
-      - !ruby/object:Gem::Version 
-        version: 0.0.0
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
   version: 
 platform: ruby
 signing_key: 
 cert_chain: 
+post_install_message: 
 authors: 
-  - Rafael Sevilla
+- Rafael R. Sevilla
 files: 
-  - lib/rstyx
-  - lib/rstyx.rb
-  - lib/rstyx/messages.rb
-  - lib/rstyx/client.rb
-  - lib/rstyx/version.rb
-  - lib/rstyx/errors.rb
-  - tests/tc_client.rb
-  - tests/tc_message.rb
-test_files: []
+- COPYING
+- ChangeLog
+- Manifest.txt
+- NEWS
+- README
+- Rakefile
+- examples/readstyxfile.rb
+- lib/rstyx/authmodules.rb
+- lib/rstyx/client.rb
+- lib/rstyx/common.rb
+- lib/rstyx/errors.rb
+- lib/rstyx/messages.rb
+- lib/rstyx/server.rb
+- lib/rstyx/version.rb
+- lib/rstyx.rb
+- tests/tc_client.rb
+- tests/tc_message.rb
+test_files: 
+- tests/tc_client.rb
+- tests/tc_message.rb
+- tests/tc_styxservproto.rb
 rdoc_options: 
-  - "--title"
-  - "RStyx -- Styx/9P2000 for Ruby"
-extra_rdoc_files: []
+- --main
+- README.txt
+extra_rdoc_files: 
+- Manifest.txt
 executables: []
+
 extensions: []
+
 requirements: []
-dependencies: []
+
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: eventmachine
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ">"
+      - !ruby/object:Gem::Version 
+        version: 0.0.0
+    version: