em-simple_telnet_server 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5404a8e42d38865f170a211f1abbce3ea34507a4
+  data.tar.gz: 70e576cbe3a4ea0cba867dd0a9f9d7563b5e3dd7
+SHA512:
+  metadata.gz: 8dd5559a1bf310e77da155f67d0b83b09153f6d4ed4f7d7ed93cf7596c505d46c6d38262c077ab76cc4e67b3155f271bd0332b85c5741bc23829bbd628047fb1
+  data.tar.gz: 425b2379c7be3923c0d98d519618069abfe3954f15b269802a641d5291f1487d65b585a15e2cf0b53f2ff331a1105fdc8a582fc79a4f608f8a91a5aca43205e0

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 2.3.0
+before_install: gem install bundler -v 1.11.2

data/Gemfile

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in em-telnet_server.gemspec
+gemspec
+
+gem "em-simple_telnet", git: "https://github.com/paddor/em-simple_telnet.git"

data/LICENSE

@@ -0,0 +1,5 @@
+Copyright (c) 2016, Patrik Wenger
+
+Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted, provided that the above copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

data/Makefile

@@ -0,0 +1,2 @@
+README.md: README.gsl test/fake_machine.rb
+	gsl README

data/README.gsl

@@ -0,0 +1,58 @@
+.output "README.md"
+.template 1
+[![Build Status on Travis CI](https://travis-ci.org/paddor/em-simple_telnet_server.svg?branch=master)](https://travis-ci.org/paddor/em-simple_telnet_server?branch=master)
+
+# SimpleTelnetServer
+
+This gem provides a simple way to implement your own telnet server. It's useful
+for example if you want to mock a telnet server in your telnet-related
+integration tests.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'em-simple_telnet_server'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install em-simple_telnet_server
+
+## Usage
+
+Here's an example, right from [test/fake_machine.rb](https://github.com/paddor/em-simple_telnet_server/blob/master/test/fake_machine.rb).
+
+```ruby
+.include "test/fake_machine.rb"
+```
+
+You can run it as follows. By default, it'll start listening on "localhost" and port 10023.
+
+```ruby
+EventMachine.run do
+  FakeMachine.start_server
+end
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/paddor/em-simple_telnet_server.
+
+
+## License
+
+The gem is available as open source under the terms of the [ISC License](http://opensource.org/licenses/ISC).
+See the [LICENSE](https://github.com/paddor/em-simple_telnet_server/blob/master/LICENSE) file.
+.endtemplate

data/README.md

@@ -0,0 +1,141 @@
+[![Build Status on Travis CI](https://travis-ci.org/paddor/em-simple_telnet_server.svg?branch=master)](https://travis-ci.org/paddor/em-simple_telnet_server?branch=master)
+
+# SimpleTelnetServer
+
+This gem provides a simple way to implement your own telnet server. It's useful
+for example if you want to mock a telnet server in your telnet-related
+integration tests.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'em-simple_telnet_server'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install em-simple_telnet_server
+
+## Usage
+
+Here's an example, right from [test/fake_machine.rb](https://github.com/paddor/em-simple_telnet_server/blob/master/test/fake_machine.rb).
+
+```ruby
+require 'em-simple_telnet_server'
+
+##
+# This should just demonstrate what you can do with SimpleTelnetServer.
+#
+class FakeMachine < SimpleTelnetServer::Connection
+  # adds simple authentication and authorization
+  include SimpleTelnetServer::HasLogin
+
+  has_option :command_prompt, "fake$ "
+  has_option :login_prompt, "fakelogin: "
+  has_option :password_prompt, "fakepassword: "
+
+  has_login "fakeuser", "fakepass" # default is ":user" role
+  has_login "fakeroot", "fakerootpass", role: :admin
+
+  # Echo command.
+  has_command(/^s*echo (.*)/) do |what|
+    send_output(what) # this also sends a prompt back
+  end
+
+  # Send command prompt on return.
+  has_command(/^s*$/, :send_command_prompt)
+
+  # This is the callback that is called right after authorization. You could
+  # initialize your code here.
+  def on_authorization
+    send_output "Hello #{entered_username}! You're authorized now."
+  end
+
+  # Just to demonstrate the ability to use methods as command actions instead
+  # of blocks. This method will be called directly if the command "count up"
+  # is called.  It also supports commands in the form of "count up 5".
+  #
+  # See the call to {.has_command} below.
+  def count_up(step)
+    step ||= 1
+    @count_up_number ||= 0
+    @count_up_number += step
+    send_output "The new number is #@count_up_number."
+  end
+  has_command("count up(?:s+(d+))", :count_up)
+
+  # Simulates a slow command which could be used to test timeouts.
+  # This can be invoked using "slow command".
+  def slow_command
+    EventMachine::Timer.new(3) { send_output "This is the output." }
+  end
+
+  # Recognizes commands like "sleep 3" and "sleep 1.5" and actually performs
+  # the sleep.
+  has_command(/^sleeps+(d+(?:.d+)?)s*$/) do |seconds|
+    EventMachine::Timer.new(seconds.to_f) do
+      send_output "This is the output."
+    end
+  end
+
+  # Simulates a command that ends in a very weird prompt.
+  #
+  # This is just to demonstrate the use of {#send_data}. It won't send the
+  # default command prompt like {#send_output} would.
+  has_command(/^weirds*$/) do
+    send_data("some
+output
+weird-prompt| ")
+  end
+
+  # logout
+  has_command(/^byes*$/, :close_connection)
+
+  # tanslate every command to a method call, if the method exists
+  # @note This is probably dangerous. But whatever, it's telnet.
+  has_command(/^([w ]+)$/) do |command|
+    method = command.gsub(/ /, '_')
+    if self.respond_to? method
+      self.send method
+    else
+      raise UnknownCommand, command
+    end
+  end
+
+  # Simplest test command ever. This will only be invokable because of the
+  # catch-all-and-translate-to-method-calls block above.
+  def foo
+    send_output("bar")
+  end
+end
+```
+
+You can run it as follows. By default, it'll start listening on "localhost" and port 10023.
+
+```ruby
+EventMachine.run do
+  FakeMachine.start_server
+end
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/paddor/em-simple_telnet_server.
+
+
+## License
+
+The gem is available as open source under the terms of the [ISC License](http://opensource.org/licenses/ISC).
+See the [LICENSE](https://github.com/paddor/em-simple_telnet_server/blob/master/LICENSE) file.

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList['test/**/*_test.rb']
+end
+
+task :default => :test

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "em-simple_telnet_server"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/em-simple_telnet_server.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'em-simple_telnet_server/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "em-simple_telnet_server"
+  spec.version       = SimpleTelnetServer::VERSION
+  spec.authors       = ["Patrik Wenger"]
+  spec.email         = ["paddor@gmail.com"]
+
+  spec.summary       = "Simple telnet server on EventMachine"
+  spec.description   = "A simple way to implement your own telnet server on" +
+                       " EventMachine"
+  spec.homepage      = "http://github.com/paddor/em-simple_telnet_server"
+  spec.license       = "ISC"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.11"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "minitest", "~> 5.0"
+  spec.add_development_dependency 'minitest-reporters'
+  spec.add_dependency('eventmachine', '>= 1.0.0')
+end

data/lib/em-simple_telnet_server.rb

@@ -0,0 +1,274 @@
+require_relative "em-simple_telnet_server/version"
+require_relative "em-simple_telnet_server/has_login"
+require 'eventmachine'
+
+# A basic Telnet server implemented with EventMachine.
+class SimpleTelnetServer::Connection < EventMachine::Connection
+  # @return [Hash<Symbol, Object>] default values for (telnet) options
+  DEFAULT_OPTIONS = {
+    port: 10023,
+    command_prompt: "$ ",
+    login_prompt: "login: ",
+    password_prompt: "password: ",
+  }
+
+  class << self
+
+    # Starts the server on address _addr_ and port _port_.
+    def start_server(addr = 'localhost', port = options[:port])
+      EventMachine.start_server(addr, port, self)
+    end
+
+    # Sets the option _opt_ to value.
+    # @param opt [Symbol] option key
+    # @param value [Object] anything
+    def has_option(opt, value)
+      options[opt] = value
+    end
+
+    # Returns the (telnet) options for this class. If they are not initialized
+    # yet, the ones from superclass (or SimpleTelnetServer) are duplicated.
+    def options
+      @options ||= if top_class?
+        DEFAULT_OPTIONS
+      else
+        superclass.options
+      end.dup
+    end
+
+    # Registers an action for the command _cmd_ (which can be a Regexp, #===
+    # will be used). _action_ can be a Symbol referring to an instance method
+    # or an instance of Proc. If _action_ is not specified, the given block is
+    # used.
+    #
+    # If _cmd_ is a Regexp, all captures (MatchData#captures) will be passed
+    # to the block/method call (see {#run_command}).
+    #
+    # @param cmd [String, Regexp] fixed command or regular expression that
+    #   matches a command and its arguments in capture groups
+    # @param action [Symbol] the method to call. if given, the block passed is
+    #   ignored
+    def has_command(cmd, action = nil, &blk)
+      commands[cmd] = action || blk
+    end
+
+    # Returns the Hash of registered commands. If they are not initialized
+    # yet (@commands), the one from superclass is used. If we're TelnetServer
+    # itself, an empty Hash is used.
+    #
+    # @return [Hash{String, Regexp => Symbol, Proc}]
+    def commands
+      @commands ||= if top_class?
+        {}
+      else
+        superclass.commands.dup # copy from superclass
+      end
+    end
+
+    # @return [Boolean] whether we've reached the top of the relevant
+    #   hieararchy
+    def top_class?
+      self == SimpleTelnetServer::Connection
+    end
+  end
+
+#  def send_data(data)
+#    warn "Server: >>> #{data.inspect}"
+#    super
+#  end
+
+
+  # custom handler of buffer content
+  # @return [Proc, #call] will be passed the content of the buffer
+  attr_accessor :custom_handler
+
+  # Called by EventMachine when a new connection attempt is made to this
+  # server (immediately after calling {#initialize}).
+  #
+  # Checks if {#needs_authentication?}, which returns +false+ if not
+  # overridden. If it authentication is needed, it'll initiate the login
+  # procedure (send login prompt, get username, get password, ...).
+  #
+  # Otherwise, any peer is authorized right away.
+  def post_init
+    @buffer = ""
+    if needs_authentication?
+      initiate_authentication
+    else
+      authorize # login anybody
+    end
+  end
+
+  # @abstract
+  # If authentication is not required, there won't be a login procedure and
+  # any peer is automatically logged in after connecting.
+  # @return [Boolean] whether this telnet server requires authentication
+  def needs_authentication?
+    false
+  end
+
+  # Called by EventMachine when new data is received. Appends _data_ to the
+  # buffer (@buffer). Calls {#process_buffer} if @buffer content ends with
+  # newline.
+  def receive_data data
+#    warn "Server: <<< #{data.inspect}"
+    @buffer << data
+
+    # work only with complete commands (ending with newline)
+    process_buffer if @buffer.end_with? "\n"
+  end
+
+  # @return [Boolean] whether the user is logged in
+  def authorized?
+    @connection_state == :authorized
+  end
+
+  # @abstract
+  # Called by EventMachine after the connection has been closed.
+  def unbind
+  end
+
+  # @abstract
+  # Called automatically when a received command is not known (no matching
+  # entry in @commands) and sends back an error message.
+  #
+  # @param command [String] the command that is not known
+  def command_not_known(command)
+    send_output "Command #{command.inspect} is not known."
+  end
+
+  # Returns the telnet options for this telnet server.
+  def options
+    self.class.options
+  end
+
+  # Returns the recognized commands for this telnet server.
+  def commands
+    self.class.commands
+  end
+
+  private
+
+  # Sends the command prompt.
+  def send_command_prompt
+    send_data options[:command_prompt]
+  end
+
+  # Sends _output_ and then the command prompt.
+  # Appens new line to output first, if it doesn't have one yet, unless it's
+  # the empty string.
+  # @param output [String] output to send before command prompt
+  def send_output(output)
+    output += "\n" unless output.end_with? "\n" or output.empty?
+    send_data output
+    send_command_prompt
+  end
+
+  # Processes the content of @buffer.
+  #
+  # If a {#custom_handler} is defined, it's called with the current buffer
+  # contents. The handler will be removed, so if it has to stay, it has to
+  # re-add itself.
+  #
+  # If the user is authorized, the commands in the buffer are executed.
+  #
+  # If the user isn't authorized, {#process_spam} is called, which does
+  # nothing by default.
+  #
+  # Ensures that the buffer is cleared.
+  def process_buffer
+    if handler = custom_handler
+      self.custom_handler = nil
+      handler.(@buffer)
+
+    elsif authorized?
+      run_commands
+    else
+      process_spam
+    end
+  ensure
+    @buffer.clear
+  end
+
+  # Authorizes the user. This is done by setting @connection_state to
+  # +:authorized+, calling the {#on_authorization} hook method, and sendng him
+  # the command prompt.
+  def authorize
+    @connection_state = :authorized
+    on_authorization
+    send_command_prompt
+  end
+
+  # @abstract
+  # Called right after authorization. You can override this method to
+  # initialize your code.
+  #
+  # Using {#initialize} instead is a bit clunky because it's expected to take
+  # EventMachine-specific arguments and happens before the user is authorized.
+  # Same goes for {#post_init}. For both you'd have to remember to call
+  # +super+.
+  def on_authorization
+  end
+
+  # Raised when a command has been received that doesn't match any registered
+  # command.
+  class UnknownCommand < RuntimeError
+    def initialize(command) @command = command end
+    attr_reader :command
+  end
+
+  # Runs the commands in the buffer. Will call {#run_command} for each command
+  # (line), no matter if it is recognized or not. If {UnknownCommand} is
+  # raised, it's handled using {#command_not_known}.
+  def run_commands
+    @buffer.lines.each do |command|
+      run_command(command.chomp)
+    end
+  rescue UnknownCommand
+    command_not_known $!.command
+  end
+
+  # Runs a command.
+  #
+  # Stores _command_ into @current_command for later use and looks it up. If
+  # it finds an action for it, executes the action.
+  #
+  # If the matching command pattern is a Regexp, the captures are passed to
+  # the action.
+  #
+  # @param command [String] command to run
+  # @raise [UnknownCommand] if the command is unknown
+  def run_command(command)
+    @current_command = command
+    if pair = commands.find { |pattern,| pattern === command }
+      pattern, action = pair
+      args = $~.captures if pattern.is_a? Regexp
+      execute_action(action, args) if action
+    else
+      raise UnknownCommand, command
+    end
+  end
+
+  # Invokes _action_ along with the given arguments.
+  #
+  # @param action [Proc, Symbol] code or a method on this server to call
+  # @param params [Array<Object>, nil] arguments for action (passed with splat
+  #   operator)
+  # @raise [ArgumentError] if action is invalid
+  def execute_action(action, args = nil)
+    case action
+    when Proc
+      self.instance_exec(*args, &action)
+    when Symbol
+      self.send(action, *args)
+    else
+      raise ArgumentError, "invalid action #{action.inspect}"
+    end
+  end
+
+  # @abstract
+  # Called when data has been received while user isn't authorized. This could
+  # be used to {#close_connection}.
+  def process_spam
+  end
+end

data/lib/em-simple_telnet_server/has_login.rb

@@ -0,0 +1,140 @@
+# Adds functionality for simple authentication and authorization.
+#
+# By default, login credentials are defined right in the class definition
+# using {ClassMethods::has_login}. If something more dynamic is needed, just
+# override {#authenticate}.
+#
+# After authentication, {#entered_username}, {#entered_password}, and
+# {#authorized_role} are set.
+module SimpleTelnetServer::HasLogin
+  # Extends klass with {ClassMethods}.
+  def self.included(klass)
+    klass.extend ClassMethods
+  end
+
+  module ClassMethods
+
+    # @return [Hash{login_type Symbol => Array<(username String, password
+    #   String)>}] registered (read/write) login credentials
+    def login_credentials
+      options[:login_credentials] ||= {}
+    end
+
+    # Adds a pair of login credentials.
+    # @param username [String] username
+    # @param password [String] password
+    # @param role [Symbol] (:user) the associated role name
+    def has_login(username, password, role: :user)
+      login_credentials[role] = [ username, password ]
+    end
+  end
+
+  # @return [String] the entered username
+  # @note This doesn't necessarily mean the user is logged in. Use
+  #   {#authorized?} to check for that.
+  attr_reader :entered_username
+
+  # @return [String] the password username
+  attr_reader :entered_password
+
+  # @return [Symbol] the associated role of the valid login credentials
+  attr_reader :authorized_role
+
+  # @return [true] true, as this module is about authentication
+  def needs_authentication?
+    true
+  end
+
+  # Initiates authentication. This means setting the connection state to
+  # +waiting_for_username+ and sending the login prompt.
+  def initiate_authentication
+    @connection_state = :waiting_for_username
+    send_login_prompt
+  end
+
+  # If the user was requested to enter his username, the username is read.
+  # If the user was requested to enter his password, the password is read.
+  #
+  # Otherwise, the normal (+super+) behavior proceeds.
+  #
+  # In all cases, it ensures that the buffer is cleared at the end.
+  #
+  def process_buffer
+    if waiting_for_username?
+      read_username_from_buffer
+
+    elsif waiting_for_password?
+      read_password_from_buffer
+
+    else
+      super
+    end
+  ensure
+    @buffer.clear
+  end
+
+  # Sends the login prompt.
+  def send_login_prompt
+    send_data options[:login_prompt]
+  end
+
+  # Sends the password prompt.
+  def send_password_prompt
+    send_data options[:password_prompt]
+  end
+
+  # @return [Boolean] whether we are waiting for the user to enter the username
+  def waiting_for_username?
+    @connection_state == :waiting_for_username
+  end
+
+  # @return [Boolean] whether we are waiting for the user to enter the password
+  def waiting_for_password?
+    @connection_state == :waiting_for_password
+  end
+
+  # Reads the password from buffer and authorizes the user
+  # if he can be authenticated. Otherwise the
+  # connection state is set back to +:waiting_for_username+ and the login
+  # prompt is sent.
+  def read_password_from_buffer
+    @entered_password = @buffer.chomp
+    if role = authenticate(@entered_username, @entered_password)
+      @authorized_role = role
+      authorize
+    else
+      @connection_state = :waiting_for_username
+      @entered_username = @entered_password = nil
+      send_login_failed
+      send_login_prompt
+    end
+  end
+
+  # Reads the username from buffer. Sends the password prompt
+  # afterwards ({#send_password_prompt}) and sets the connection state to
+  # +:waiting_for_password+.
+  def read_username_from_buffer
+    @entered_username = @buffer.strip
+    send_password_prompt
+    @connection_state = :waiting_for_password
+  end
+
+  # Sends the message "Sorry, please try again." and the login prompt.
+  def send_login_failed
+    send_data "Sorry, please try again.\n"
+  end
+
+
+  # Checks _user_ and _pass_ against all known login credentials.
+  #
+  # @param user [String] entered username
+  # @param pass [String] entered password
+  # @return [Symbol] associated role, if credentials are known
+  # @return [nil] if credentials are not known
+  def authenticate(user, pass)
+    self.class.login_credentials.each do |role, credentials|
+      return role if credentials == [ user, pass ]
+    end
+    return nil
+  end
+end

data/lib/em-simple_telnet_server/version.rb

@@ -0,0 +1,3 @@
+module SimpleTelnetServer
+  VERSION = "0.1.0"
+end

metadata

@@ -0,0 +1,129 @@
+--- !ruby/object:Gem::Specification
+name: em-simple_telnet_server
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Patrik Wenger
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-01-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: minitest-reporters
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: eventmachine
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+description: A simple way to implement your own telnet server on EventMachine
+email:
+- paddor@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- LICENSE
+- Makefile
+- README.gsl
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- em-simple_telnet_server.gemspec
+- lib/em-simple_telnet_server.rb
+- lib/em-simple_telnet_server/has_login.rb
+- lib/em-simple_telnet_server/version.rb
+homepage: http://github.com/paddor/em-simple_telnet_server
+licenses:
+- ISC
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: Simple telnet server on EventMachine
+test_files: []
+has_rdoc: