muding 0.1.0

data/lib/acts/expireable.rb

@@ -0,0 +1,82 @@
+#TODO: rewrite this class to allow individual objects to have their own configurations..
+module Acts #:nodoc:
+	module Expireable
+		def self.included(base) # :nodoc:
+			base.extend ClassMethods
+		end
+
+		module ClassMethods
+			def acts_as_expireable(options = {})
+					config = {:respawn => false, :lifespan => 10.seconds, :delay=> 0.seconds}
+					config.update options if options.is_a?(Hash)
+
+					unless expireable? # don't let AR call this twice
+						cattr_accessor :respawn, :lifespan, :delay
+						self.respawn = config[:respawn]
+						self.lifespan = config[:lifespan]
+						self.delay = config[:delay]
+						Thread.new do
+							while true
+
+									#puts "Checking Expireables."
+									#self.find(:all).each do |s|
+									#	puts "Expires at:" + s.expires_at.to_s
+									#	s.destroy
+									#end
+
+									puts Time.now.to_s
+
+									self.find(:all, :conditions => ["spawn_at <= ? and expires_at >= ?", Time.now, Time.now]).each do |expireable|
+										expireable.spawn
+									end
+									self.find(:all, :conditions => ["expires_at <= ?", Time.now]).each do |expireable|
+										expireable.expire
+									end
+									sleep 0.5
+							end
+						end
+					end
+					before_create :setup_expireable
+					include InstanceMethods
+			rescue
+				puts $!
+			end
+
+			def expireable?
+				self.included_modules.include?(InstanceMethods)
+			end
+		end
+
+		module InstanceMethods #:nodoc:
+			def self.included(base) # :nodoc:
+				base.extend ClassMethods
+			end
+
+			def expire
+				self.on_expire if respond_to? :on_expire
+				self.destroy
+				if self.class.respawn
+					self.on_respawn if respond_to? :on_respawn
+					self.class.new.save 
+				end
+			end
+
+			def spawn
+				if !spawned?
+					self.on_spawn if respond_to? :on_spawn
+					self.spawn_at = nil
+					save
+				end
+			end
+
+			def setup_expireable
+				self.expires_at = Time.now + self.class.lifespan
+				self.spawn_at = Time.now + self.class.delay
+			end
+			
+			def spawned?
+				self.spawn_at == nil
+			end
+		end
+	end
+end

data/lib/commands/destroy.rb

@@ -0,0 +1,7 @@
+require "#{MUDING_ROOT}/config/environment"
+require 'muding_generator'
+require 'muding_generator/scripts/destroy'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+Muding::Generator::Scripts::Destroy.new.run(ARGV)
+

data/lib/commands/generate.rb

@@ -0,0 +1,7 @@
+require "#{MUDING_ROOT}/config/environment"
+require 'muding_generator'
+require 'muding_generator/scripts/generate'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+Muding::Generator::Scripts::Generate.new.run(ARGV)
+

data/lib/commands/server.rb

@@ -0,0 +1,45 @@
+%w[socket handle].each { |lib| require lib }
+
+log = Log4r::Logger.new 'main'
+log.outputters = Log4r::Outputter.stdout
+
+begin
+	server = TCPServer.new('localhost', 4000)
+	threads = []
+
+	#The procedures for shuting down the server
+	graceful_shutdown = Proc.new do
+		#shuting down the game right now is as simple as exiting.
+		#later we probably want to backup save the active records
+		#or something
+		exit
+	end
+
+	#what to do if our server receives a OS signal to shut down
+	handle_signalled_shutdown = Proc.new do |sig|
+		log.warn "Caught " + Signal.list.invert[sig] + " Signal... Shutting Down"
+		graceful_shutdown.call
+	end
+
+	#trap the signals we want to handle a shutdown for.
+	[:INT,:TERM,:KILL].each do |sig|
+		Signal.trap sig, handle_signalled_shutdown
+	end
+
+	log.info "Accepting Connections..."
+	while session = server.accept
+		threads << Thread.new(session) do |s|
+			begin
+				Handle.this session
+			rescue
+				log.error "Top Level Thread Error. You should never see this."
+				log.error $!
+			end
+		end
+	end
+
+	graceful_shutdown.call
+rescue
+	log.fatal "Top Level Server Error. You should never see this."
+	log.fatal $!
+end

data/lib/commands/update.rb

@@ -0,0 +1,5 @@
+require "#{MUDING_ROOT}/config/environment"
+require 'muding_generator'
+require 'muding_generator/scripts/update'
+Muding::Generator::Scripts::Update.new.run(ARGV)
+

data/lib/controller.rb

@@ -0,0 +1,132 @@
+module Controller
+	Log = Log4r::Logger.new 'controller'
+	Log.outputters = Log4r::Outputter.stdout
+
+	class Base
+		attr_accessor :input, :body, :rendered
+		attr_accessor :new_route, :default_command, :prompt
+
+		@@before_view = {}
+
+		#route_to is the command that routes a connection's input to the 
+		#next command controller, or default command. 
+		#
+		#   route_to :route =>StartController, :command=>:begin, :prompt=>">"
+		#   This will make the user's next input goto the StartController
+		#   with the command "begin". After rendering the command 
+		#   it will output ">" to the user.
+		#
+		#   route_to :view=>"password"
+		#   
+		#   This will keep the user's route the same. After rendering the command
+		#   it will output the content of the password view rendered in the context
+		#   of the command's binding. The directory for the password view will
+		#   be the same as the Controller.
+		def route_to(options={})
+			config = {:controller => self.class, :command => nil, :prompt => "", :view => :default}
+			config.update options if options.is_a?(Hash)
+			
+			self.new_route = config[:controller]
+			self.default_command = config[:command]
+			self.prompt = config[:prompt] if config[:prompt] != ""
+			self.prompt = render_template(before_view_file) if config[:view] == :default && @@before_view[config[:command]]
+		end
+
+		#TODO: Implement this.
+		#Should jump to next controller method right away, instead of waiting for new input.
+		#r(302,'','Location'=>URL(*a))
+		#by right away I mean after the command finishes running.
+		def redirect_to(options={})	
+			config = {:route => self.class, :command => nil, :prompt => "", :view => :default}
+			config.update options if options.is_a?(Hash)
+
+		end
+
+		def render(options = {})
+			raise "Double Render Error" if self.rendered
+
+			self.rendered = true
+			return if options[:nothing]
+			if options[:text]
+				@body = options[:text] 
+				return
+			end
+			@body = render_template(view_file)
+
+			@body += self.prompt if self.prompt
+		end
+
+		def initialize(command, s = {}) #:nodoc:
+			@method = command.downcase
+			@session = s
+		end
+
+		def route
+			return self.class
+		end
+		
+		def view_file
+			command_file = @method + ".rhtml"
+			load_and_read_file(command_file)
+		end
+
+		def before_view_file
+			command_file = @@before_view[default_command].to_s + ".rhtml" 
+			load_and_read_file(command_file)
+		end
+
+		def load_and_read_file(file_name)
+			file = File.open(File.join(view_dir, file_name))
+			file.read
+			rescue Errno::ENOENT
+				puts $!
+				return "Could not find the proper view for this command" 
+		end
+
+		def view_dir
+			File.join("mud","views",route.to_s.downcase.chomp("controller"))
+		end
+
+		def render_template(vf)
+			ERB.new(vf, nil, '-').result(binding)
+		end
+
+		def service(*a)
+			send(@method, *a) if respond_to? @method
+			if !self.rendered
+				render
+			end
+			self
+		end
+
+		def session()
+			return @session
+		end
+
+		def to_s
+			"#{@body}"
+		end
+
+		def Base.before_view
+			return @@before_view
+		end
+	end
+	
+	class NotFound < Base
+		def get(p)
+			render :text=>"#{p} Could not be found."
+		end 
+	end
+
+	class ServerError < Base
+		def get
+			render :text=>"Command problem, check the logs."
+		end 
+	end
+
+        #Load all the controllers.
+        load "./mud/controllers/mud.rb"
+        Dir["./mud/controllers/*_controller.rb"].sort.each { |ext| load ext.to_s }
+end
+
+

data/lib/handle.rb

@@ -0,0 +1,42 @@
+require 'muding'
+
+#This class handles connections. It stores session information 
+#about the connection. It keeps track of where the connection is currently sending it's input to.
+class Handle
+	Log = Log4r::Logger.new 'handle'
+	Log.outputters = Log4r::Outputter.stdout
+
+	@@handles = [] #All of the connections.
+
+	attr_accessor :route, :session, :default_command, :peer
+
+	def Handle.this s
+		@@handles << h = Handle.new(s)
+		h.start_handling
+	end
+	
+	def initialize peer
+		self.session = {:handle=>self}
+		self.peer = peer
+		self.route = MudController
+	end
+
+	def start_handling
+		response = Muding.run("begin", self)
+
+		while true
+			peer.puts response.body
+			self.route = response.new_route if response.new_route
+
+			self.default_command = nil
+			self.default_command = response.default_command if response.default_command
+			response = Muding.run(peer.gets, self)
+		end
+	rescue Errno::EPIPE
+		Log.info "Connection " + self.object_id.to_s + " Severed"
+	end
+
+	def message(message_string)
+		peer.puts message_string
+	end
+end

data/lib/model.rb

@@ -0,0 +1,11 @@
+Dir["./lib/acts/*.rb"].sort.each { |ext| load ext.to_s }
+
+ActiveRecord::Base.establish_connection(YAML.load_file("config/database.yml")["development"])
+
+ActiveRecord::Base.send :include, Acts::Expireable
+ActiveRecord::Base.send :include, Acts::Container
+
+Base = ActiveRecord::Base
+Base.logger =  Log4r::Logger.new 'ActiveRecord::Base' #not outputing anywhere?
+
+Dir["./mud/models/*.rb"].sort.each { |ext| load ext.to_s }

data/lib/muding.rb

@@ -0,0 +1,46 @@
+%w[active_record socket erb log4r].each { |lib| require lib }
+%w[model controller].each { |lib| require(lib) }
+
+module Muding
+	Log = Log4r::Logger.new 'muding'
+	Log.outputters = Log4r::Outputter.stdout
+
+	class << self
+		def run(input, handle)
+			unless input
+				raise Errno::EPIPE.new("Nil String to Pipe")
+			end
+			default_command = handle.default_command
+			session = handle.session
+			route = handle.route
+
+			reload_controller_code
+			
+
+			# if we don't have a default command we need to figure 
+			# out what the command is.
+			#
+			# format: "command [args]"
+			unless default_command 
+				string_array = input.split(" ")
+				command = string_array.shift
+				args = string_array.to_s 
+			else
+				command = default_command.to_s
+				args = input
+			end
+
+			return route.new(command, session).service(*args)
+
+		rescue Errno::EPIPE
+			raise
+		rescue Exception => x
+			Log.warn x
+			return Controllers::ServerError.new("get",session).service()
+		end
+		def reload_controller_code
+			load "./mud/controllers/mud.rb"
+			Dir["./mud/controllers/*_controller.rb"].sort.each { |ext| load ext }
+		end
+	end
+end

data/lib/muding_generator.rb

@@ -0,0 +1,22 @@
+$:.unshift(File.dirname(__FILE__))
+$:.unshift(File.dirname(__FILE__) + "/../../activesupport/lib")
+
+begin
+  require 'active_support'
+rescue LoadError
+  require 'rubygems'
+  require_gem 'activesupport'
+end
+
+require 'muding_generator/base'
+require 'muding_generator/lookup'
+require 'muding_generator/commands'
+
+Muding::Generator::Base.send(:include, Muding::Generator::Lookup)
+Muding::Generator::Base.send(:include, Muding::Generator::Commands)
+
+# Set up a default logger for convenience.
+require 'muding_generator/simple_logger'
+Muding::Generator::Base.logger = Muding::Generator::SimpleLogger.new(STDOUT)
+
+

data/lib/muding_generator/base.rb

@@ -0,0 +1,162 @@
+require File.dirname(__FILE__) + '/options'
+require File.dirname(__FILE__) + '/manifest'
+require File.dirname(__FILE__) + '/spec'
+
+module Muding
+  module Generator
+    class GeneratorError < StandardError; end
+    class UsageError < GeneratorError; end
+		
+    class Base
+      include Options
+
+      default_options :collision => :ask, :quiet => false
+
+      cattr_accessor :logger
+
+      class_inheritable_accessor :spec
+
+      attr_reader :source_root, :destination_root, :args
+
+      def initialize(runtime_args, runtime_options = {})
+        @args = runtime_args
+        parse!(@args, runtime_options)
+
+        # Derive source and destination paths.
+        @source_root = options[:source] || File.join(spec.path, 'templates')
+        if options[:destination]
+          @destination_root = options[:destination]
+        elsif defined? ::RAILS_ROOT
+          @destination_root = ::RAILS_ROOT
+        end
+
+        # Silence the logger if requested.
+        logger.quiet = options[:quiet]
+
+        # Raise usage error if help is requested.
+        usage if options[:help]
+      end
+
+      # Generators must provide a manifest.  Use the record method to create
+      # a new manifest and record your generator's actions.
+      def manifest
+        raise NotImplementedError, "No manifest for '#{spec.name}' generator."
+      end
+
+      # Return the full path from the source root for the given path.
+      # Example for source_root = '/source':
+      #   source_path('some/path.rb') == '/source/some/path.rb'
+      #
+      # The given path may include a colon ':' character to indicate that
+      # the file belongs to another generator.  This notation allows any
+      # generator to borrow files from another.  Example:
+      #   source_path('model:fixture.yml') = '/model/source/path/fixture.yml'
+      def source_path(relative_source)
+        # Check whether we're referring to another generator's file.
+        name, path = relative_source.split(':', 2)
+
+        # If not, return the full path to our source file.
+        if path.nil?
+          File.join(source_root, name)
+
+        # Otherwise, ask our referral for the file.
+        else
+          # FIXME: this is broken, though almost always true.  Others'
+          # source_root are not necessarily the templates dir.
+          File.join(self.class.lookup(name).path, 'templates', path)
+        end
+      end
+
+      # Return the full path from the destination root for the given path.
+      # Example for destination_root = '/dest':
+      #   destination_path('some/path.rb') == '/dest/some/path.rb'
+      def destination_path(relative_destination)
+        File.join(destination_root, relative_destination)
+      end
+
+      protected
+        # Convenience method for generator subclasses to record a manifest.
+        def record
+          Muding::Generator::Manifest.new(self) { |m| yield m }
+        end
+
+        # Override with your own usage banner.
+        def banner
+          "Usage: #{$0} #{spec.name} [options]"
+        end
+
+        # Read USAGE from file in generator base path.
+        def usage_message
+          File.read(File.join(spec.path, 'USAGE')) rescue ''
+        end
+    end
+
+
+    # The base generator for named components: models, controllers, mailers,
+    # etc.  The target name is taken as the first argument and inflected to
+    # singular, plural, class, file, and table forms for your convenience.
+    # The remaining arguments are aliased to actions for controller and
+    # mailer convenience.
+    #
+    # If no name is provided, the generator raises a usage error with content
+    # optionally read from the USAGE file in the generator's base path.
+    #
+    # See Rails::Generator::Base for a discussion of Manifests and Commands.
+    class NamedBase < Base
+      attr_reader   :name, :class_name, :singular_name, :plural_name, :table_name
+      attr_reader   :class_path, :file_path, :class_nesting, :class_nesting_depth
+      alias_method  :file_name,  :singular_name
+      alias_method  :actions, :args
+
+      def initialize(runtime_args, runtime_options = {})
+        super
+
+        # Name argument is required.
+        usage if runtime_args.empty?
+
+        @args = runtime_args.dup
+        base_name = @args.shift
+        assign_names!(base_name)
+      end
+
+      protected
+        # Override with your own usage banner.
+        def banner
+          "Usage: #{$0} #{spec.name} #{spec.name.camelize}Name [options]"
+        end
+
+      private
+        def assign_names!(name)
+          @name = name
+          base_name, @class_path, @file_path, @class_nesting, @class_nesting_depth = extract_modules(@name)
+          @class_name_without_nesting, @singular_name, @plural_name = inflect_names(base_name)
+          @table_name = ActiveRecord::Base.pluralize_table_names ? plural_name : singular_name
+          if @class_nesting.empty?
+            @class_name = @class_name_without_nesting
+          else
+            @class_name = "#{@class_nesting}::#{@class_name_without_nesting}"
+          end
+        end
+
+        # Extract modules from filesystem-style or ruby-style path:
+        #   good/fun/stuff
+        #   Good::Fun::Stuff
+        # produce the same results.
+        def extract_modules(name)
+          modules = name.include?('/') ? name.split('/') : name.split('::')
+          name    = modules.pop
+          path    = modules.map { |m| m.underscore }
+          file_path = (path + [name.underscore]).join('/')
+          nesting = modules.map { |m| m.camelize }.join('::')
+          [name, path, file_path, nesting, modules.size]
+        end
+
+        def inflect_names(name)
+          camel  = name.camelize
+          under  = camel.underscore
+          plural = under.pluralize
+          [camel, under, plural]
+        end
+    end
+  end
+end