carbonmu 0.0.1

data/lib/edge_router/edge_router_supervision_group.rb

@@ -0,0 +1,5 @@
+module CarbonMU
+  class EdgeRouterSupervisionGroup < Celluloid::SupervisionGroup
+    supervise EdgeRouter, as: :edge_router, args: ["0.0.0.0", 8421]
+  end
+end

data/lib/edge_router/telnet_connection.rb

@@ -0,0 +1,35 @@
+require 'forwardable'
+
+module CarbonMU
+  class TelnetConnection < EdgeConnection
+    extend Forwardable
+    def_delegators :@socket, :close, :write
+
+    attr_reader :socket
+
+    def after_initialize(socket)
+      @socket = socket
+      async.run
+    end
+
+    def run
+      info "*** Received telnet connection #{id} from #{socket.addr[2]}"
+      write "Connected. Your ID is #{id}\n"
+      loop do
+        async.handle_input(read)
+      end
+    rescue EOFError, Errno::ECONNRESET
+      info "*** Telnet connection #{id} disconnected"
+      close
+      terminate
+    end
+
+    def before_shutdown
+      @socket.close unless @socket.closed?
+    end
+
+    def read
+      @socket.readpartial(4096)
+    end
+  end
+end

data/lib/edge_router/telnet_receptor.rb

@@ -0,0 +1,30 @@
+require 'celluloid/autostart'
+require 'celluloid/io'
+
+module CarbonMU
+  class TelnetReceptor
+    include Celluloid::IO
+    include Celluloid::Logger
+
+    finalizer :shutdown
+
+    def initialize(host, port)
+      info "*** Starting Telnet receptor on #{host} #{port}."
+      @server = Celluloid::IO::TCPServer.new(host, port)
+      async.run
+    end
+
+    def shutdown
+      @server.close if @server
+    end
+
+    def run
+      loop { async.handle_connection @server.accept }
+    end
+
+    def handle_connection(socket)
+      tc = TelnetConnection.new(socket)
+      Actor[:edge_router].add_connection(tc)
+    end
+  end
+end

data/lib/errors.rb

@@ -0,0 +1,4 @@
+module CarbonMU
+  class ObjectNotFoundError < StandardError; end
+  class InvalidObjectError < StandardError; end
+end

data/lib/game_objects/container.rb

@@ -0,0 +1,10 @@
+module CarbonMU
+  module Container
+    extend ActiveSupport::Concern
+    included do
+      include Mongoid::Document
+
+      has_many :contents, class_name: "CarbonMU::GameObject", foreign_key: :location
+    end
+  end
+end

data/lib/game_objects/exit.rb

@@ -0,0 +1,8 @@
+module CarbonMU
+  class Exit < GameObject
+    include Mongoid::Document
+    include Movable
+
+    belongs_to :destination, class_name: "CarbonMU::Exit", inverse_of: :incoming_exits, index: true
+  end
+end

data/lib/game_objects/game_object.rb

@@ -0,0 +1,13 @@
+module CarbonMU
+  class GameObject
+    include Mongoid::Document
+
+    field :name, type: String
+    field :description, type: String, default: "You see nothing special."
+    field :_special, type: Symbol
+
+    index(_special: 1)
+
+    validates_uniqueness_of :_special, allow_blank: true
+  end
+end

data/lib/game_objects/movable.rb

@@ -0,0 +1,12 @@
+module CarbonMU
+  module Movable
+    extend ActiveSupport::Concern
+    included do
+      include Mongoid::Document
+
+      belongs_to :location, class_name: "CarbonMU::GameObject", inverse_of: :contents, index: true
+
+      validates_presence_of :location
+    end
+  end
+end

data/lib/game_objects/player.rb

@@ -0,0 +1,17 @@
+module CarbonMU
+  class Player < GameObject
+    include Mongoid::Document
+    include Movable
+    include Container
+
+    before_validation :default_location
+
+    def default_location
+      self.location ||= Room.starting
+    end
+
+    def self.superadmin
+      find_by(_special: :superadmin_player)
+    end
+  end
+end

data/lib/game_objects/room.rb

@@ -0,0 +1,16 @@
+module CarbonMU
+  class Room < GameObject
+    include Mongoid::Document
+    include Container
+
+    has_many :incoming_exits, class_name: "CarbonMU::Exit", foreign_key: :destination
+
+    def self.starting
+      find_by(_special: :starting_room)
+    end
+
+    def self.lostandfound
+      find_by(_special: :lostandfound_room)
+    end
+  end
+end

data/lib/game_objects/thing.rb

@@ -0,0 +1,7 @@
+module CarbonMU
+  class Thing < GameObject
+    include Mongoid::Document
+    include Movable
+    include Container
+  end
+end

data/lib/interactions/notify.rb

@@ -0,0 +1,11 @@
+module CarbonMU
+  class Notify
+    def self.all(text, opts = {})
+      CarbonMU.server.connections.each { |c| one(c, text, opts) }
+    end
+
+    def self.one(connection, text, opts = {})
+      connection.write_translated(text, opts)
+    end
+  end
+end

data/lib/interactions/reboot.rb

@@ -0,0 +1,8 @@
+module CarbonMU
+  class Reboot
+    def self.reboot
+      Notify.all("SERVER: ".white.on_red + "Rebooting, please wait...")
+      Server.trigger_reboot
+    end
+  end
+end

data/lib/ipc/carbon_ipc_socket.rb

@@ -0,0 +1,21 @@
+require 'celluloid/zmq'
+
+module CarbonMU
+  class CarbonIPCSocket
+    include Celluloid::ZMQ
+
+    attr_accessor :zmq_socket
+
+    def read
+      raise NotImplementedError
+    end
+
+    def send(message)
+      raise NotImplementedError
+    end
+
+    def close
+      @zmq_socket.close if @zmq_socket
+    end
+  end
+end

data/lib/ipc/ipc_message.rb

@@ -0,0 +1,54 @@
+require 'multi_json'
+
+module CarbonMU
+  class IPCMessage
+    def self.valid_ops
+      [:started, :command, :connect, :disconnect, :write, :reboot, :retrieve_existing_connections]
+    end
+
+    def self.required_parameters(op)
+      {
+        write: [:connection_id, :output],
+        connect: [:connection_id],
+        disconnect: [:connection_id],
+        command: [:command, :connection_id],
+      }[op]
+    end
+
+    def self.unserialize(text)
+      hash_with_symbol_keys = Hash[MultiJson.load(text).map{|(k,v)| [k.to_sym,v]}]
+      self.new(hash_with_symbol_keys[:op].to_sym, hash_with_symbol_keys)
+    end
+
+    attr_reader :params
+
+    def initialize(op, options={})
+      raise ArgumentError, "invalid op specified: #{op}" unless IPCMessage.valid_ops.include?(op)
+      required_parameters = IPCMessage.required_parameters(op) || []
+      provided_parameters = options.keys
+      raise ArgumentError, "missing parameters for #{op} op: #{required_parameters - provided_parameters}" unless (required_parameters & provided_parameters).size == required_parameters.size
+      @params = options.merge(op: op)
+    end
+
+    def method_missing(method_sym, *args, &block)
+      @params.has_key?(method_sym) ? @params[method_sym] : super
+    end
+
+    def respond_to?(method_sym, include_private = false)
+      @params.has_key?(method_sym) ? true : super
+    end
+
+    def serialize
+      MultiJson.dump(params)
+    end
+
+    def to_s
+      "<IPCMessage: #{params}>"
+    end
+
+    def ==(o)
+      o.class == self.class && o.params == self.params
+    end
+    alias_method :eql?, :==
+  end
+end

data/lib/ipc/read_socket.rb

@@ -0,0 +1,18 @@
+module CarbonMU
+  class ReadSocket < CarbonIPCSocket
+    def initialize(port = '*')
+      @zmq_socket = Celluloid::ZMQ::PullSocket.new
+      @zmq_socket.bind("tcp://127.0.0.1:#{port}")
+    end
+
+    def read
+      @zmq_socket.read
+    end
+
+    def port_number
+      raw_endpoint = @zmq_socket.get(::ZMQ::LAST_ENDPOINT) || nil
+      return nil if raw_endpoint.nil?
+      raw_endpoint.match(/\:(\d+)/)[1].to_i
+    end    
+  end
+end

data/lib/ipc/write_socket.rb

@@ -0,0 +1,12 @@
+module CarbonMU
+  class WriteSocket < CarbonIPCSocket
+    def initialize(port = '15000')
+      @zmq_socket = Celluloid::ZMQ::PushSocket.new
+      @zmq_socket.connect("tcp://127.0.0.1:#{port}")
+    end
+
+    def send(message)
+      @zmq_socket.send(message)
+    end
+  end
+end

data/lib/version.rb

@@ -0,0 +1,7 @@
+module CarbonMU
+  VERSION_MAJOR = 0
+  VERSION_MINOR = 0
+  VERSION_TINY = 1
+
+  VERSION = "#{VERSION_MAJOR}.#{VERSION_MINOR}.#{VERSION_TINY}"
+end

data/mongoid.yml

@@ -0,0 +1,12 @@
+production:
+  sessions:
+    default:
+      hosts:
+        - localhost
+      database: carbonmu
+testing:
+  sessions:
+    default:
+      hosts:
+        - localhost
+      database: carbonmu_test

data/spec/carbonmu_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe CarbonMU do
+  it "has color methods available" do
+    expect("string").to respond_to(:white)
+  end
+
+  it "has a translate method" do
+    str = "Hi there"
+    opts = {foo: "bar"}
+    expect(CarbonMU::Internationalization).to receive(:translate).with(str, [opts])
+    CarbonMU.t(str, opts)
+  end
+end

data/spec/i18n_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+require 'i18n/tasks'
+
+describe 'I18n', i18n: true do
+  let(:i18n) { I18n::Tasks::BaseTask.new }
+  let(:missing_keys) { i18n.missing_keys }
+  let(:unused_keys) { i18n.unused_keys }
+
+  skip 'does not have missing keys' do
+    expect(missing_keys).to be_empty,
+      "Missing #{missing_keys.leaves.count} i18n keys, run `i18n-tasks missing' to show them"
+  end
+
+  skip 'does not have unused keys' do
+    expect(unused_keys).to be_empty,
+      "#{unused_keys.leaves.count} unused i18n keys, run `i18n-tasks unused' to show them"
+  end
+end

data/spec/lib/commands/say_command_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe SayCommand do
+  context "syntax" do
+    it { expect(command_parse_results("say foo")).to eq(parse_to(SayCommand, {text: "foo"})) }
+
+    it "requires an argument" do
+      expect(command_parse_results("say")).to eq(parse_to(UnknownCommand))
+    end
+  end
+end

data/spec/lib/core/command_context_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe CommandContext do
+  it "should store its attributes" do
+    connection = double(Connection)
+    player = double(Player)
+    allow(connection).to receive(:player) { player }
+    command = "FOO"
+    params = {boo: "bot"}
+    cc = CommandContext.new(enacting_connection: connection, raw_command: command, params: params)
+    expect(cc.enacting_connection).to eq(connection)
+    expect(cc.enactor).to eq(player)
+    expect(cc.raw_command).to eq(command)
+    expect(cc.params).to eq(params)
+  end
+end

data/spec/lib/core/command_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+class TestCommand < Command
+  syntax "bar"
+  syntax /foo/
+end
+
+describe Command do
+  it "keeps track of defined syntaxes" do
+    expect(TestCommand.syntaxes).to eq(["bar", /foo/])
+  end
+
+  it "sends syntaxes to parser" do
+    expect(Parser).to receive(:register_syntax).with("baz", duck_type(:syntax))
+    expect(Parser).to receive(:register_syntax).with("bat", duck_type(:syntax))
+
+    class ParseTestCommand < Command
+      syntax "baz"
+      syntax "bat"
+    end
+  end
+
+  context "command contexts" do
+    before(:each) do
+      @context = double("Context").as_null_object
+    end
+
+    it "stores its context" do
+      my_command = Command.new(@context)
+      expect(my_command.context).to eq(@context)
+    end
+
+    it "raises if .execute called directly on Command" do
+      expect { Command.new(@context).execute}.to raise_exception(NotImplementedError)
+    end
+  end
+end

data/spec/lib/core/configuration_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe CarbonMU do
+  describe 'global configuration' do
+    it 'maintains app-wide configurations' do
+      mock_config = Struct.new(:test_setting).new
+      mock_setting = Object.new
+      CarbonMU.configuration = mock_config
+
+      CarbonMU.configure do |config|
+        config.test_setting = mock_setting
+      end
+
+      expect(CarbonMU.configuration.test_setting).to be(mock_setting)
+    end
+  end
+end
+
+describe Configuration do
+  let(:config) { Configuration.new }
+
+  describe '#logger' do
+    it 'has a logger' do
+      expect(config.logger).to be_a(Logger)
+    end
+
+    it "doesn't allow an invalid logger" do
+      expect { config.logger = Object.new }.to raise_error(ArgumentError)
+    end
+  end
+
+  describe '#log_ipc_traffic' do
+    it 'has a log_ipc_traffic setting' do
+      expect(config.log_ipc_traffic).to be_boolean
+    end
+  end
+end