muding 0.1.1 → 0.2.0

data/CHANGELOG

@@ -1,3 +1,20 @@
+*** 0.2.0 / 2006-08-02
+
++ 1 major enhancement
+	+Unit Testing
+
++ 2 minor enhancements
+	+ redirect_to
+	+ abbreviations
+	+ generators now work
+
++ 1 change
+	+ .rhtml is now .eruby, the standard ERB file suffix
+
++ 2 bug fixes
+	+fixed some issues with Controller::Base
+	+removed redirect_to method due to it's non-functioning
+
 *** 0.1.1 / 2006-07-25
 
 + 2 bug fixes

data/MANIFEST

@@ -11,6 +11,7 @@ bin/console
 bin/destroy
 configs/
 configs/boot.rb
+configs/environment.rb
 configs/databases/
 configs/databases/mysql.yml
 configs/databases/oracle.yml
@@ -24,13 +25,21 @@ helpers/mud.rb
 helpers/mud_helper.rb
 helpers/test_helper.rb
 lib/
+lib/initializer.rb
+lib/code_statistics.rb
+lib/version.rb
+lib/test_help.rb
 lib/controller.rb
 lib/handle.rb
 lib/model.rb
 lib/muding.rb
 lib/muding_generator.rb
 lib/ruby_version_check.rb
-lib/tasks/migrate.rake
+lib/tasks/muding.rb
+lib/tasks/databases.rake
+lib/tasks/documentation.rake
+lib/tasks/statistics.rake
+lib/tasks/testing.rake
 lib/acts/expireable.rb
 lib/acts/container.rb
 lib/commands/

data/README

@@ -10,12 +10,3 @@ common to all multi-user environments into a separate framework that can
 be developed through open-source. Developers using the framework can then
 build their multi-user environment on top of the framework, and update the
 framework code independantly of their own code.
-
-** SETUP:
-muding mudname 
-- creates a new directory at your current path for the mud you are 
-	developing
-
-** INSTALL:
-
-sudo gem install muding

data/configs/boot.rb

@@ -1,4 +1,46 @@
-require 'rubygems'
-require_gem 'muding'
-MUDING_ROOT = File.dirname(__FILE__) + "/../"
+# Don't change this file. Configuration is done in config/environment.rb and config/environments/*.rb
+
+unless defined?(MUDING_ROOT)
+  root_path = File.join(File.dirname(__FILE__), '..')
+
+  unless RUBY_PLATFORM =~ /mswin32/
+    require 'pathname'
+    root_path = Pathname.new(root_path).cleanpath(true).to_s
+  end
+
+  MUDING_ROOT = root_path
+end
+
+unless defined?(Muding::Initializer)
+  if File.directory?("#{MUDING_ROOT}/vendor/rails")
+    require "#{MUDING_ROOT}/vendor/muding/railties/lib/initializer"
+  else
+    require 'rubygems'
+
+    environment_without_comments = IO.readlines(File.dirname(__FILE__) + '/environment.rb').reject { |l| l =~ /^#/ }.join
+    environment_without_comments =~ /[^#]MUDING_GEM_VERSION = '([\d.]+)'/
+    muding_gem_version = $1
+
+    if version = defined?(MUDING_GEM_VERSION) ? MUDING_GEM_VERSION : muding_gem_version
+      muding_gem = Gem.cache.search('muding', "=#{version}").first
+
+      if muding_gem
+        require_gem "muding", "=#{version}"
+        require muding_gem.full_gem_path + '/lib/initializer'
+      else
+        STDERR.puts %(Cannot find gem for muding =#{version}:
+    Install the missing gem with 'gem install -v=#{version} muding', or
+    change environment.rb to define MUDING_GEM_VERSION with your desired version.
+  )
+        exit 1
+      end
+    else
+      require_gem "muding"
+      require 'initializer'
+    end
+  end
+
+  Muding::Initializer.run(:set_load_path)
+end
+
 

data/configs/environment.rb

@@ -0,0 +1,49 @@
+# Be sure to restart your server when you modify this file.
+
+# Use this if you want to move your muding server into production mode.
+# ENV['MUDING_ENV'] ||= 'production'
+
+# Specifies gem version of Rails to use when vendor/rails is not present
+<%= '# ' if freeze %>MUDING_GEM_VERSION = '<%= Muding::VERSION::STRING %>'
+
+# Bootstrap the Rails environment, frameworks, and default configuration
+require File.join(File.dirname(__FILE__), 'boot')
+
+Muding::Initializer.run do |config|
+  # Settings in config/environments/* take precedence those specified here
+  
+  # Add additional load paths for your own custom dirs
+  # config.load_paths += %W( #{MUDING_ROOT}/extras )
+
+  # Force all environments to use the same logger level 
+  # (by default production uses :info, the others :debug)
+  # config.log_level = :debug
+
+  # Use the database for sessions instead of the file system
+  # (create the session table with 'rake db:sessions:create')
+  # config.action_controller.session_store = :active_record_store
+
+  # Use SQL instead of Active Record's schema dumper when creating the test database.
+  # This is necessary if your schema can't be completely dumped by the schema dumper, 
+  # like if you have constraints or database-specific column types
+  # config.active_record.schema_format = :sql
+
+  # Activate observers that should always be running
+  # config.active_record.observers = :cacher, :garbage_collector
+
+  # Make Active Record use UTC-base instead of local time
+  # config.active_record.default_timezone = :utc
+  
+  # See Muding::Configuration for more options
+end
+
+# Add new inflection rules using the following format 
+# (all these examples are active by default):
+# Inflector.inflections do |inflect|
+#   inflect.plural /^(ox)$/i, '\1en'
+#   inflect.singular /^(ox)en/i, '\1'
+#   inflect.irregular 'person', 'people'
+#   inflect.uncountable %w( fish sheep )
+# end
+
+# Include your application configuration below

data/fresh_rakefile

@@ -1,4 +1,7 @@
+require(File.join(File.dirname(__FILE__), 'config', 'boot'))
+
 require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
 
-#We get our tasks from lib/tasks
-Dir["./lib/tasks/**/*.rake"].sort.each { |ext| load ext }
+require 'tasks/muding'

data/helpers/test_helper.rb

@@ -1,5 +1,5 @@
-ENV["RAILS_ENV"] = "test"
-require File.expand_path(File.dirname(__FILE__) + "/../config/environment")
+ENV["MUDING_ENV"] = "test"
+#require File.expand_path(File.dirname(__FILE__) + "/../config/environment")
 require 'test_help'
 
 class Test::Unit::TestCase

data/lib/acts/container.rb

@@ -44,9 +44,10 @@ module Acts #:nodoc:
 			end
 
 			def <<(content)
+				content.container = nil
 				self.containables.each do |containable|
-					begin
-						self.send(containable).<< content
+					begin				
+						 self.send(containable).<< content
 						return # if it successfully adds we are done with this method.
 						
 					# there is probably a better way to do this. right now if it can't be added to the container

data/lib/code_statistics.rb

@@ -0,0 +1,107 @@
+class CodeStatistics #:nodoc:
+
+  TEST_TYPES = %w(Units Functionals Unit\ tests Functional\ tests Integration\ tests)
+
+  def initialize(*pairs)
+    @pairs      = pairs
+    @statistics = calculate_statistics
+    @total      = calculate_total if pairs.length > 1
+  end
+
+  def to_s
+    print_header
+    @pairs.each { |pair| print_line(pair.first, @statistics[pair.first]) }
+    print_splitter
+  
+    if @total
+      print_line("Total", @total)
+      print_splitter
+    end
+
+    print_code_test_stats
+  end
+
+  private
+    def calculate_statistics
+      @pairs.inject({}) { |stats, pair| stats[pair.first] = calculate_directory_statistics(pair.last); stats }
+    end
+
+    def calculate_directory_statistics(directory, pattern = /.*\.rb$/)
+      stats = { "lines" => 0, "codelines" => 0, "classes" => 0, "methods" => 0 }
+
+      Dir.foreach(directory) do |file_name| 
+        if File.stat(directory + "/" + file_name).directory? and (/^\./ !~ file_name)
+          newstats = calculate_directory_statistics(directory + "/" + file_name, pattern)
+          stats.each { |k, v| stats[k] += newstats[k] }
+        end
+
+        next unless file_name =~ pattern
+
+        f = File.open(directory + "/" + file_name)
+
+        while line = f.gets
+          stats["lines"]     += 1
+          stats["classes"]   += 1 if line =~ /class [A-Z]/
+          stats["methods"]   += 1 if line =~ /def [a-z]/
+          stats["codelines"] += 1 unless line =~ /^\s*$/ || line =~ /^\s*#/
+        end
+      end
+
+      stats
+    end
+
+    def calculate_total
+      total = { "lines" => 0, "codelines" => 0, "classes" => 0, "methods" => 0 }
+      @statistics.each_value { |pair| pair.each { |k, v| total[k] += v } }
+      total
+    end
+
+    def calculate_code
+      code_loc = 0
+      @statistics.each { |k, v| code_loc += v['codelines'] unless TEST_TYPES.include? k }
+      code_loc
+    end
+
+    def calculate_tests
+      test_loc = 0
+      @statistics.each { |k, v| test_loc += v['codelines'] if TEST_TYPES.include? k }
+      test_loc
+    end
+
+    def print_header
+      print_splitter
+      puts "| Name                 | Lines |   LOC | Classes | Methods | M/C | LOC/M |"
+      print_splitter
+    end
+
+    def print_splitter
+      puts "+----------------------+-------+-------+---------+---------+-----+-------+"
+    end
+
+    def print_line(name, statistics)
+      m_over_c   = (statistics["methods"] / statistics["classes"])   rescue m_over_c = 0
+      loc_over_m = (statistics["codelines"] / statistics["methods"]) - 2 rescue loc_over_m = 0
+
+      start = if TEST_TYPES.include? name
+        "|   #{name.ljust(18)} "
+      else
+        "| #{name.ljust(20)} " 
+      end
+
+      puts start + 
+           "| #{statistics["lines"].to_s.rjust(5)} " +
+           "| #{statistics["codelines"].to_s.rjust(5)} " +
+           "| #{statistics["classes"].to_s.rjust(7)} " +
+           "| #{statistics["methods"].to_s.rjust(7)} " +
+           "| #{m_over_c.to_s.rjust(3)} " +
+           "| #{loc_over_m.to_s.rjust(5)} |"
+    end
+
+    def print_code_test_stats
+      code  = calculate_code
+      tests = calculate_tests
+
+      puts "  Code LOC: #{code}     Test LOC: #{tests}     Code to Test Ratio: 1:#{sprintf("%.1f", tests.to_f/code)}"
+      puts ""
+    end
+  end

data/lib/commands/destroy.rb

@@ -1,7 +1,9 @@
-require "#{MUDING_ROOT}/config/environment"
+#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

@@ -1,4 +1,4 @@
-require "#{MUDING_ROOT}/config/environment"
+#require "#{MUDING_ROOT}/config/environment"
 require 'muding_generator'
 require 'muding_generator/scripts/generate'
 

data/lib/commands/server.rb

@@ -1,9 +1,31 @@
 %w[socket handle].each { |lib| require lib }
+require "optparse"
+
+# Specified for sake of cleanliness, as it is repeated.
+DEFAULT_PORT = 4000
+
+options = {
+	:port => DEFAULT_PORT
+}
+
+optparse = OptionParser.new do |opt|
+	opt.banner = "Usage: #{$0} [OPTIONS]"
+	opt.separator ""
+	opt.on "-p", "--port [PORT]", "Select the server port, defaults to #{DEFAULT_PORT}" do |port|
+		options[:port] = port
+	end
+	opt.on_tail "-h", "--help", "Display this help message" do
+		puts optparse
+		exit
+	end
+end
+
+optparse.parse! ARGV
 
 log = Log4r::Logger.new 'main'
 log.outputters = Log4r::Outputter.stdout
 begin
-	server = TCPServer.new('localhost', 4000)
+	server = TCPServer.new('localhost', options[:port])
 	threads = []
 
 	#The procedures for shuting down the server
@@ -25,7 +47,7 @@ begin
 		Signal.trap sig, handle_signalled_shutdown
 	end
 
-	log.info "Accepting Connections..."
+	log.info "Accepting Connections on port #{options[:port]}..."
 	while session = server.accept
 		threads << Thread.new(session) do |s|
 			begin

data/lib/commands/update.rb

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

data/lib/controller.rb

@@ -1,15 +1,17 @@
+require 'abbrev'
+
 module Controller
 	Log = Log4r::Logger.new 'controller'
 	Log.outputters = Log4r::Outputter.stdout
 	
 	class NoCommandException < Exception;end
-
-
+	class NoViewException < Exception;end
 
 	class Base
+
 		alias :route :class
 		attr_accessor :input, :body, :rendered
-		attr_accessor :new_route, :default_command, :prompt
+		attr_accessor :new_route, :default_command, :prompt, :redirect, :args
 
 		@@before_view = {}
 
@@ -41,10 +43,15 @@ module Controller
 
 		#TODO: Implement this.
 		#Should jump to next controller method right after this one finishes
-		#def redirect_to(options={})	
-		#	config = {:route => self.class, :command => nil, :prompt => "", :view => :default}
-		#	config.update options if options.is_a?(Hash)
-		#end
+		def redirect_to(options={})
+			config = {:route => self.class, :command => nil, :prompt => "", :view => :default, :args => ""}
+			config.update options if options.is_a?(Hash)
+			raise Exception.new("Could not redirect to nil. Please supply a command to redirect to.") if config[:command] == nil
+			
+			self.redirect = true
+			self.args = config[:args]
+			route_to(config)
+		end
 
 		#render sets the text that will be sent back as a response to this command
 		#you can only render once per controller. This is in place to avoid magical
@@ -52,50 +59,80 @@ module Controller
 		#
 		#render called with no options yields the view file rendered if one exists.
 		#  
-		#  render    #=> renders /mud/views/controller/view.rhtml
+		#  render    #=> renders /mud/views/controller/view.eruby
 		#
 		#  render :text => "send this to them" #=> send this to them
 		def render(options = {})
 			raise "Double Render Error" if self.rendered
 			self.rendered = true
-			return if options[:nothing]
-			if options[:text]
-				@body = options[:text] 
+			config = {:view => @method}
+			config.update options if options.is_a?(Hash)
+
+			return if config[:nothing]
+
+			if config[:text]
+				@body = config[:text]
 				return
 			end
-			@body = render_template(view_file(@method))
+
+			@body = render_template(view_file(config[:view]))
 		end
 		
+		def rendered?
+			@rendered
+		end
+
 		def initialize(command, s = {}) #:nodoc:
-			@method = command.downcase
+			@method_string = command.downcase
 			@session = s
+			self.redirect = false
+		end
+
+		#simple begins with abbreviation with alphabetical order
+		def find_method(method_string)
+			methods = self.command_methods.sort
+			methods.abbrev[method_string]
 		end
+		
+
 
 		#service is the main method that controlls the flow through the controller.
 		#first it runs the method,
 		#then it renders the view if something hasn't already been rendered
 		#then it tacks the prompt onto the end of the command.
 		def service(*a)
-			if respond_to? @method
-				if self.method(@method).arity >= 1
-					send(@method, *a) 
-				else
-					send(@method)
+
+			@method = find_method(@method_string)
+      if @method == nil
+				render :view=>@method_string
+			else
+				if respond_to? @method
+					if self.method(@method).arity >= 1
+						send(@method, *a) 
+					else
+						send(@method)
+					end
+				end
+				if !self.rendered
+					begin
+						render
+					rescue NoViewException
+						if self.redirect
+							return self
+						end
+						raise
+					end
 				end
 			end
-			if !self.rendered
-				render
-			end
-			
+
 			@body += self.prompt if self.prompt
-			
-			session[:handle].puts(@body)
 
+			session[:handle].puts @body
 			self
 		end
 
 		def view_file(method)
-			command_file = method + ".rhtml"
+			command_file = method.to_s + ".eruby"
 			load_and_read_file(command_file)
 		end
 
@@ -109,7 +146,8 @@ module Controller
 			file.read
 		rescue Errno::ENOENT
 				#if we haven't at least rendered something, we are going to through a nocommand exception here..
-				raise Controller::NoCommandException
+				raise Controller::NoCommandException if !@method
+				raise Controller::NoViewException
 		end
 
 		def view_dir
@@ -131,6 +169,23 @@ module Controller
 		def Base.before_view
 			return @@before_view
 		end
+
+		class << self
+			def hidden_commands
+				write_inheritable_attribute(:hidden_commands, Controller::Base.public_instance_methods) unless read_inheritable_attribute(:hidden_commands)
+				read_inheritable_attribute(:hidden_commands)
+			end
+			def hide_action(*names)
+				write_inheritable_attribute(:hidden_actions, 
+																		hidden_actions | names.collect { |n| n.to_s })
+			end
+		end
+		def command_methods
+        self.class.command_methods
+    end
+		def self.command_methods
+			@command_methods ||= Set.new(public_instance_methods - hidden_commands)
+		end
 	end
 	
 	class NotFound < Base