carps 0.2.1

data/lib/carps/mod/sheet/new_sheet.rb

@@ -0,0 +1,71 @@
+# Copyright 2010 John Morrice
+
+# This file is part of CARPS.
+
+# CARPS is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+
+# CARPS is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+
+# You should have received a copy of the GNU General Public License
+# along with CARPS.  If not, see <http://www.gnu.org/licenses/>.
+
+require "carps/protocol"
+
+require "carps/util"
+
+require "carps/mod"
+
+require "yaml"
+
+require "drb"
+
+module CARPS
+
+   module Sheet 
+      # A character sheet filled in by a user, sent across the net
+      class NewSheet < Message
+
+         # Extend the protocol
+         protoval :character_sheet
+
+         # Write the sheet 
+         def initialize sheet
+            @sheet = sheet
+         end
+
+         # Parse from the void
+         def NewSheet.parse blob
+            sheet, blob = find K.character_sheet, blob
+            y = nil
+            begin
+               y = YAML.load sheet
+            rescue ArgumentError => e
+            end
+            if y
+               [NewSheet.new(y), blob]
+            else
+               raise Expected, "Expected valid YAML segment."
+            end
+         end
+
+         # Emit
+         def emit
+            V.character_sheet @sheet.to_yaml
+         end
+
+         # Dump the sheet!
+         def dump
+            @sheet
+         end
+
+      end
+
+   end
+
+end

data/lib/carps/mod/sheet/schema.rb

@@ -0,0 +1,84 @@
+# Copyright 2010 John Morrice
+
+# This file is part of CARPS.
+
+# CARPS is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+
+# CARPS is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+
+# You should have received a copy of the GNU General Public License
+# along with CARPS.  If not, see <http://www.gnu.org/licenses/>.
+
+module CARPS
+
+   module Sheet
+
+      # This isn't really the schema, but an object that wraps it
+      # and uses it to perform syntactic validations on character sheets
+      class Schema
+
+         # Create a new schema
+         def initialize schema
+            @schema = schema
+         end
+
+
+         # Verify the sheet's syntax.
+         #
+         # Produce errors if it's invalid, nil if it's valid
+         def produce_errors sheet
+            errs = []
+            @schema.each do |field, type|
+               valid, coerced = verify_type sheet[field], type
+               if valid
+                  sheet[field] = coerced
+               else
+                  errs.push field + " was not " + type
+               end
+            end
+            if errs.empty?
+               nil
+            else
+               errs
+            end
+         end
+
+         # Create sheet text for the user to edit 
+         def create_sheet_text user_sheet
+            current = {}
+            if user_sheet
+               current = user_sheet.attributes
+            end
+
+            @schema.each_key do |field|
+               unless current.include? field
+                  current[field] = nil
+               end
+            end
+            sheet = "# Character sheet\n"
+            current.each do |field, value|
+               type = @schema[field]
+               sheet += "# #{field} is #{type}\n"
+               sheet += "#{field}: #{value}\n"
+            end
+            return sheet
+         end
+
+         protected
+
+         def verify_type val, type_str
+            type = TypeParser.parse type_str
+            type.verify val
+         end
+
+      end
+
+   end
+
+end

data/lib/carps/mod/sheet/type.rb

@@ -0,0 +1,161 @@
+# Copyright 2010 John Morrice
+
+# This file is part of CARPS.
+
+# CARPS is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+
+# CARPS is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+
+# You should have received a copy of the GNU General Public License
+# along with CARPS.  If not, see <http://www.gnu.org/licenses/>.
+
+require "set"
+
+module CARPS
+
+   module Sheet
+
+      # Types available in character sheets
+      #
+      # Subclasses must provide a method called valid, which takes a value and determines if it is valid.
+      #
+      # Subclasses may provide a method called coercion, which should return a symbol referring to a method which coerces a value into a different type (example, :to_s)
+      #
+      # Subclasses may provide a method called empty which should determine if a value is empty
+      class Type
+
+         def initialize optional
+            @optional = optional
+         end
+
+         def verify val
+            if val == nil
+               if @optional
+                  return [true, nil]
+               end
+            end
+            ok = false
+            if coercion
+               ok = valid(val) && val.respond_to?(coercion)
+            else
+               ok = valid(val)
+            end
+
+            if ok
+               if empty(val) and @optional
+                  return [true, nil]
+               else
+                  coerced = nil
+                  if coercion
+                     coerced = val.send coercion
+                  else
+                     coerced = val
+                  end
+                  [true, coerced]
+               end
+            else
+               [false, nil]
+            end
+         end
+
+         # No coercion
+         def coercion
+         end
+
+         # Can't be empty
+         def empty val
+            false
+         end
+
+      end
+
+      # Accept Fixnums
+      class Int < Type
+
+         def valid val
+            val.class == Fixnum
+         end
+
+      end
+
+      # Accept Strings
+      class Text < Type
+
+         def valid val
+            true
+         end
+
+         def coercion
+            :to_s
+         end
+
+         def empty val
+            if val.class == String
+               return val.empty?
+            else
+               return false
+            end
+         end
+
+      end
+
+      # Accept one of a Set of possible values
+      class Choice < Type
+
+         # The second argument is the Set of possible values
+         def initialize optional, choices
+            super optional
+            @choices = choices
+         end
+
+         # Only true for a member of the Set of possible values
+         def valid val
+            @choices.member? val.downcase
+         end
+
+      end
+
+      # Accept booleans
+      class Bool < Type
+
+         # Only true for if val.class is TrueClass or FalseClass
+         def valid val
+            val.class == TrueClass or val.class == FalseClass
+         end
+
+      end
+
+      # Parse the sheet types from strings
+      class TypeParser
+         def TypeParser.parse type_name
+            type_name.downcase!
+            optional_match = type_name.match /^\s*optional\s+((\S+\s+)*?\S+)\s*$/
+               optional = false
+            if optional_match
+               type_name = optional_match[1]
+               optional = true
+            end
+            if type_name == "integer"
+               return Int.new optional 
+            elsif type_name == "text"
+               return Text.new optional
+            elsif type_name == "boolean"
+               return Bool.new optional
+            elsif match = type_name.match(/^choice (.+)$/)
+               choices = Set.new match[1].split
+               return Choice.new optional, choices
+            else
+               raise StandardError, "Could not parse type name: " + type_name
+            end
+         end
+      end
+
+   end
+
+end

data/lib/carps/mod/sheet/verifier.rb

@@ -0,0 +1,41 @@
+# Copyright 2010 John Morrice
+
+# This file is part of CARPS.
+
+# CARPS is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+
+# CARPS is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+
+# You should have received a copy of the GNU General Public License
+# along with CARPS.  If not, see <http://www.gnu.org/licenses/>.
+
+require "carps/ui/question"
+
+require "yaml"
+
+module CARPS
+
+   module Sheet
+
+      # Character sheet semantic verifier that asks the user if the sheet is true
+      class UserVerifier
+
+         # Produce errors if the sheet is incorrect
+         def produce_errors sheet
+            text = sheet.emit
+            puts text
+            unless UI::confirm("Is the above character sheet correct?")
+               ["User refused to accept sheet."]
+            end
+         end
+      end
+
+   end
+
+end

data/lib/carps/mod/status_report.rb

@@ -0,0 +1,51 @@
+# Copyright 2010 John Morrice
+
+# This file is part of CARPS.
+
+# CARPS is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+
+# CARPS is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+
+# You should have received a copy of the GNU General Public License
+# along with CARPS.  If not, see <http://www.gnu.org/licenses/>.
+
+require "carps/protocol"
+
+module CARPS
+
+   # Text sent by the server to be viewed on the client.
+   class StatusReport < Message
+
+      # Extend the protocol
+      protoval :status_report
+
+      # Create a status report
+      def initialize text
+         @text = text
+      end
+
+      # Parse from the void
+      def StatusReport.parse blob
+         status, blob = find K.status_report, blob
+         [StatusReport.new(status), blob]
+      end
+
+      # Emit
+      def emit
+         V.status_report @text
+      end
+
+      # Display the text
+      def display
+         puts @text
+      end
+
+   end
+
+end

data/lib/carps/mod.rb

@@ -0,0 +1,40 @@
+# Copyright 2010 John Morrice
+ 
+# This file is part of CARPS.
+
+# CARPS is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+
+# CARPS is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+
+# You should have received a copy of the GNU General Public License
+# along with CARPS.  If not, see <http://www.gnu.org/licenses/>.
+
+require "carps/mod/interface"
+require "carps/mod/mod"
+require "carps/mod/dm/interface"
+require "carps/mod/dm/mod"
+require "carps/mod/dm/reporter"
+require "carps/mod/dm/resource"
+require "carps/mod/dm/room"
+require "carps/mod/player/interface"
+require "carps/mod/player/mod"
+require "carps/mod/answers"
+require "carps/mod/client_turn"
+require "carps/mod/dice"
+require "carps/mod/question"
+require "carps/mod/sheet/editor"
+require "carps/mod/sheet/type"
+require "carps/mod/sheet/verifier"
+require "carps/mod/sheet/schema"
+require "carps/mod/sheet/character"
+require "carps/mod/sheet/new_sheet"
+require "carps/mod/status_report"
+require "carps/mod/launch"
+require "carps/mod/rule"
+require "carps/mod/action"

data/lib/carps/protocol/keyword.rb

@@ -0,0 +1,104 @@
+# Copyright 2010 John Morrice
+
+# This file is part of CARPS.
+
+# CARPS is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+
+# CARPS is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+
+# You should have received a copy of the GNU General Public License
+# along with CARPS.  If not, see <http://www.gnu.org/licenses/>.
+
+# Class containing message keywords.  Its name is short :)
+class K
+end
+
+# Class containing message keywords which are associated with values.
+class V
+end
+
+
+# Declare a new protocol keyword which is associated with a value
+def protoval keyword
+   # Use the OLD SKOOL for ruby 1.8 support
+   K.class_eval <<-"END"
+   def K.#{keyword.to_s}
+      prefix + "#{keyword.to_s}" + keyword_end
+   end
+   END
+
+   V.class_eval <<-"END"
+   def V.#{keyword.to_s} data
+      prefix + "#{keyword.to_s}" + keyword_end + data + K.end
+   end
+   END
+end
+
+# Declare a new protocol keyword which is a flag or marker 
+def protoword keyword
+   K.class_eval <<-"END"
+   def K.#{keyword.to_s}
+      mark_prefix + "#{keyword.to_s}" + keyword_end
+   end
+   END
+end
+
+# End keyword 
+protoword "end"
+
+module CARPS
+
+   # CARP protocol keywords associated with values are prefixed by ASCII start of text.
+   def prefix
+   "\2"
+   end
+
+   # CARP protocol markers are associated with ASCII start of heading
+   def mark_prefix
+   "\1"
+   end
+
+   # End the prefix, so there are no ambiguities
+   def keyword_end
+   "\3"
+   end
+
+   class Expected < StandardError
+   end
+
+   module Protocol
+
+      # Check that the first argument is not nil, if so, raise an 'expected' parse error, using the second argument
+      def Protocol.check result, expected
+         if result == nil
+            raise Expected, expected
+         end
+      end
+
+   end
+
+   # Find a field in semi-structured text
+   def find field, text
+      Protocol::check text, "Expected String for input"
+      if field.start_with? mark_prefix
+         forget, blob = text.split field, 2
+         Protocol::check blob, field
+         return ["", blob]
+      elsif field.start_with? prefix
+         forget, blob = text.split field, 2
+         Protocol::check blob, field
+         value, blob = blob.split K.end, 2
+         Protocol::check value, K.end
+         return [value, blob] 
+      else
+         raise StandardError, "Invalid keyword"
+      end
+   end
+
+end

data/lib/carps/protocol/message.rb

@@ -0,0 +1,138 @@
+# Copyright 2010 John Morrice
+
+# This file is part of CARPS.
+
+# CARPS is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+
+# CARPS is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+
+# You should have received a copy of the GNU General Public License
+# along with CARPS.  If not, see <http://www.gnu.org/licenses/>.
+
+require "carps/protocol/keyword"
+
+require "carps/ui/warn"
+
+require "drb"
+
+require "fileutils"
+
+module CARPS
+
+   # Parse a message from a block of unformatted text
+   class MessageParser
+
+      # Create a new parser from a list of choices
+      def initialize choices
+         @choices = choices
+      end
+
+      # Parse, choosing from a number of alternative messages, return the first one that suceeds
+      def choose_parser blob 
+         @choices.each do |message|
+            begin
+               result, text = message.parse blob
+               return [result, text] 
+            rescue Expected
+            end
+         end
+         raise Expected
+      end
+
+      # Parse the text into a message 
+      def parse text
+         input = text
+         begin
+            msg, blob = choose_parser text
+            return msg
+         rescue Expected
+            UI::warn "An invalid email was received:", input
+            return nil
+         end
+      end
+   end
+
+   # A message
+   class Message
+
+      # Set cryptography information
+      def crypt= sig
+         @delayed_crypt = sig
+      end
+
+      # Cryptography information
+      def crypt
+         @delayed_crypt
+      end
+
+      # set who we're from
+      def from= addr
+         @from = addr
+      end
+
+      # Who we're from
+      def from
+         @from
+      end
+
+      # Set the session
+      def session= session
+         @session = session
+      end
+
+      # Get the session
+      def session
+         @session
+      end
+
+      # Set the path
+      def path= path
+         @path = path
+      end
+
+      # Save a blob, associated with this mail
+      #
+      # Only use once.  Raises exception if called multiple times.
+      def save blob
+         if @path
+            raise StandardError, "#{self} has already been saved!"
+         else
+            begin
+               @path = write_file_in ".mail/", blob
+            rescue StandardError => e
+               UI::put_error "Could not save #{self.class} in .mail/:\n#{e.message}"
+            end
+         end
+         @path
+      end
+
+      # Delete the path
+      def delete
+         if @path
+            if File.exists?(@path)
+               begin
+                  FileUtils.rm @path
+               rescue StandardError => e
+                  UI::put_error "Could not delete message: #{e}"
+               end
+            end
+         end
+      end
+
+      # Parse.
+      #
+      # The first parameter is the email address this text is from
+      # The second parameter is the text itself.
+      def parse text
+         nil
+      end
+
+   end
+
+end