copland 0.8.0 → 1.0.0

data/doc/presentation/to_html.rb

@@ -0,0 +1,52 @@
+#!/usr/bin/env ruby
+
+require 'fileutils'
+require 'redcloth'
+
+$target_dir = "html"
+$resolution = "800x600"
+$presentation = "copland2.mgp"
+$image_format = "png"
+
+FileUtils.rm_rf $target_dir
+FileUtils.mkdir_p $target_dir
+system "mgp -g #{$resolution} -D #{$target_dir} -E #{$image_format} #{$presentation}"
+
+puts "======================================================="
+puts "inserting slide notes into generated HTML..."
+
+content = File.read( $presentation )
+pages = content.split( /%page/ ).map { |p| p.strip }
+head = pages.shift
+
+pages.each_with_index do |page, index|
+  if page =~ /^%%==*\n(.*)\n%%==*\n/m
+    note = $1.gsub( /^%% ?/, "" ).strip
+
+    if note.length > 0
+      slide_file = File.join( $target_dir, "mgp%05d.html" % (index+1) )
+      slide_html = File.read( slide_file )
+
+      note.gsub!( /(\S)\n([ \t]*\w)/, '\1 \2' )
+
+      if slide_html =~ /<IMG SRC=\"mgp.*png\".*><BR>/
+        before = $` + $&
+        after = $'
+        new_html = before + "\n" +
+          "<style type=\"text/css\">" +
+          "#notes h1 { font-size: large }\n" +
+          "#notes h2 { font-size: normal }\n" +
+          "#notes h3 { font-size: normal }\n" +
+          "</style>" +
+          "<h2>Slide Notes:</h2>" +
+          "<blockquote id=\"notes\">" +
+          RedCloth.new(note).to_html +
+          "</blockquote>" +
+          after
+        puts "  writing slide #{index+1}"
+        File.open( slide_file, "w" ) { |file| file.write new_html }
+      end
+    end
+  end
+end
+puts "done!"

data/lib/copland/configuration-point/common.rb

@@ -156,10 +156,11 @@ module Copland
       # for this configuration point; or if no schema exists, run the
       # values through the Copland::translate_values method.
       def process_values( values )
+        Thread.current[:disable_symbol_substitution] = true
         s = schema
         contributor = contributor_of( values )
         if s.respond_to?( :process )
-          if s.is_a?( Array )
+          if values.is_a?( Array )
             values = values.map! { |value|
               s.process( self, contributor, value )
             }
@@ -172,7 +173,37 @@ module Copland
         end
 
         return values
+      ensure
+        Thread.current[:disable_symbol_substitution] = false
+      end
+
+      # Processes all substitution symbols in the values of this configuration
+      # point, in place. This has a guard to ensure that it is only executed
+      # once.
+      def substitute_symbols!
+        Thread.critical = true
+        return if @substitution_processed
+        @substitution_processed = true
+        substitute_symbols( self )
+      ensure
+        Thread.critical = false
+      end
+
+      # The recursive portion of the symbol substitution step. This looks for
+      # substitution symbols in all of the values of the configuration point,
+      # substituting them as they are found.
+      def substitute_symbols( value )
+        case value
+          when Hash
+            value.each_pair { |k,v| value[k] = substitute_symbols( v ) }
+          when Array
+            value.map! { |v| substitute_symbols( v ) }
+          when String
+            Copland::substitute_symbols( owner.registry, value )
+        end
+        value
       end
+      private :substitute_symbols
 
       # Returns false. Once a configuration point is fixated, it will include
       # the Copland::ConfigurationPoint::ConfigurationPointFunctionality::Fixated

data/lib/copland/configuration/yaml/service-point.rb

@@ -62,7 +62,8 @@ module Copland
 
         # The list of valid keys that may exist on the input.
         VALID_KEYS = [ "description", "model", "implementor",
-                       "interceptors", "listen-to", "schema" ]
+                       "interceptors", "listen-to", "schema",
+                       "visibility" ]
 
         # The list of required keys that must exist on the input.
         REQUIRED_KEYS = [ "implementor" ]
@@ -101,6 +102,14 @@ module Copland
               when "schema"
                 point.schema = @schema.process( point, value )
 
+              when "visibility"
+                point.visibility = case value.downcase
+                  when "public" then :public
+                  when "private" then :private
+                  else raise ParserError,
+                    "invalid visibility value #{value.inspect}"
+                  end
+
               else
                 raise CoplandBug, "[BUG] invalid key discovered too late: #{key.inspect}"
             end

data/lib/copland/log-factory.rb

@@ -31,7 +31,7 @@
 # =============================================================================
 #++
 
-require 'logger'
+require 'copland/logger'
 require 'thread'
 require 'yaml'
 
@@ -51,6 +51,9 @@ module Copland
     # The default name of the log file to write to.
     DEFAULT_LOG_FILENAME = "./copland.log"
 
+    # The default format of the log messages (see Logger for more info)
+    DEFAULT_MESSAGE_FORMAT = "[%-5p] %d -- %C: %m"
+
     # Translate names of levels to their actual values.
     LEVEL_TRANSLATOR = {
       "DEBUG" => Logger::DEBUG,
@@ -61,8 +64,11 @@ module Copland
       "UNKNOWN" => Logger::UNKNOWN
     }
 
-    # The default (date) format string to use when logging.
-    attr_reader :default_format
+    # The default date format string to use when logging.
+    attr_reader :default_date_format
+
+    # The default message format string to use when logging.
+    attr_reader :default_message_format
 
     # The default log level to use for logs that are created.
     attr_reader :default_level
@@ -82,11 +88,14 @@ module Copland
     #   rolled.
     # * <tt>:roll_frequency</tt>: either 'daily', 'weekly', or 'monthly'.
     # * <tt>:roll_size</tt>: the maximum size of a log file.
-    # * <tt>:default_format</tt>: the default date format string for the log.
+    # * <tt>:default_date_format</tt>: the default date format string for the
+    #   log.
+    # * <tt>:default_message_format</tt>: the default message format string for
+    #   the log.
     # * <tt>:default_level</tt>: the default log level for the log.
     # * <tt>:levels</tt>: a hash of patterns that map to a hash of 'level'
-    #   and 'format' keys, specifying the log level and date format for any
-    #   log whose name matches the key.
+    #   'date_format', and 'message_format' keys, specifying the log level,
+    #   date format, and message format for any log whose name matches the key.
     def initialize( opts={} )
       opts[ :config_file ] ||= DEFAULT_CONFIG_FILE
       read_config opts
@@ -102,10 +111,13 @@ module Copland
                       :shift_size => roll_size )
       end
 
-      @default_format = opts[ :default_format ]
+      @default_date_format = opts[ :default_date_format ]
+      @default_message_format = opts[ :default_message_format ] ||
+        DEFAULT_MESSAGE_FORMAT
       @default_level = opts[ :default_level ]
 
-      @levels = Hash.new "level" => nil, "format" => nil 
+      @levels = Hash.new "level" => nil, "date-format" => nil,
+        "message-format" => nil
 
       ( opts[ :levels ] || Hash.new ).each_pair do |key, value|
         key = Regexp.new( "^" + key.gsub( /\./, "\\." ).gsub( /\*/, ".*" ) )
@@ -125,7 +137,8 @@ module Copland
       file = opts[ :config_file ]
       if File.exist?( file ) && File.readable?( file )
         config = YAML.load( File.read( file ) )
-        opts[ :default_format ] ||= config[ "default-format" ]
+        opts[ :default_date_format ] ||= config[ "default-date-format" ]
+        opts[ :default_message_format ] ||= config[ "default-message-format" ]
         opts[ :default_level ] ||=
           LEVEL_TRANSLATOR[ config[ "default-level" ] ] ||
           config[ "default-level" ]
@@ -169,14 +182,17 @@ module Copland
         definition = find_definition( name )
 
         level = definition[ "level" ] || @default_level
-        format = definition[ "format" ] || @default_format
+        date_format = definition[ "date-format" ] || @default_date_format
+        message_format = definition[ "message-format" ] ||
+          @default_message_format
 
         level = LEVEL_TRANSLATOR[ level ] || level
 
-        logger = Logger.new( @device )
+        logger = Copland::Logger.new( @device )
         logger.level = level if level
-        logger.datetime_format = format if format
         logger.progname = name
+        logger.datetime_format = date_format if date_format
+        logger.message_format = message_format if message_format
 
         @loggers[ name ] = logger
         return logger

data/lib/copland/logger.rb

@@ -0,0 +1,155 @@
+#--
+# =============================================================================
+# Copyright (c) 2004, Jamis Buck (jgb3@email.byu.edu)
+# All rights reserved.
+# 
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+# 
+#     * Redistributions of source code must retain the above copyright notice,
+#       this list of conditions and the following disclaimer.
+# 
+#     * Redistributions in binary form must reproduce the above copyright
+#       notice, this list of conditions and the following disclaimer in the
+#       documentation and/or other materials provided with the distribution.
+# 
+#     * The names of its contributors may not be used to endorse or promote
+#       products derived from this software without specific prior written
+#       permission.
+# 
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+# =============================================================================
+#++
+
+require 'logger'
+require 'strscan'
+require 'copland/errors'
+
+module Copland
+
+  # A specialization of the standard Logger class that comes with Ruby. This
+  # provides the additional functionality of a fully-customizable message
+  # format, whereas the original only provided a customizable date format.
+  class Logger < ::Logger
+
+    # The brief name of this logger (derived from #progname).
+    attr_reader :name
+
+    # The format string for the message (+nil+ if the default should be used)
+    attr_reader :message_format
+
+    # The map of specifier options supported by this class.
+    SPECIFIER_OPTIONS = {
+      "c" => { :type => "s", :value => "@name" },
+      "C" => { :type => "s", :value => "self.progname" },
+      "d" => { :type => "s", :value => "opts[:timestamp]" },
+      "F" => { :type => "s", :value => "opts[:caller_file]" },
+      "l" => { :type => "s", :value => "opts[:caller_info]" },
+      "L" => { :type => "d", :value => "opts[:caller_line]" },
+      "m" => { :type => "s", :value => "opts[:msg]" },
+      "M" => { :type => "s", :value => "opts[:caller_method]" },
+      "n" => { :type => "s", :value => "$/" },
+      "p" => { :type => "s", :value => "opts[:severity]" },
+      "t" => { :type => "d", :value => "Thread.current.__id__" },
+      "%" => { :type => "s", :value => "'%'" },
+      "P" => { :type => "s", :value => "opts[:progname]" },
+      "$" => { :type => "d", :value => "$$" }
+    }
+
+    # The regular expression for matching specifier patterns in the
+    # format strings.
+    SPECIFIER_PATTERN = /(.*?)%(-?\d*(?:\.\d+)?)?([cCdFlLmMnpt%$P])/
+
+    # Extracts the unqualified name from the progname, after setting the
+    # progname.
+    def progname=( progname )
+      super
+      @name = progname.split( /\./ ).last
+    end
+
+    # Set the message format string to the given string. This also pre-parses
+    # the format for faster processing.
+    #
+    # The format string is a printf-formatted string, which supports the following
+    # format specifiers:
+    #
+    # c:: the unqualified name of the logger
+    # C:: the fully-qualified name of the logger
+    # d:: the date/time string (as formatted by the #datetime_format string)
+    # F:: the filename of the calling routine
+    # l:: the location of the calling routine
+    # L:: the line number of the calling routine
+    # m:: the message to log
+    # M:: the name of the calling method
+    # n:: the newline character
+    # p:: the name of the priority (or severity) used to log this method
+    # t:: the id of the current thread
+    # %:: a percentage character
+    # P:: the progname that was passed to the logger method
+    # $:: the current process id
+    def message_format=( format )
+      @message_format = format
+      return unless format
+
+      @needs_caller_info = false
+
+      format_string = ""
+      format_parameters = []
+
+      @message_format_tokens = []
+      format.scan( SPECIFIER_PATTERN ) do |v|
+        format_string << v[0] if v[0].length > 0
+        opts = SPECIFIER_OPTIONS[ v[2] ]
+        format_string << "%#{v[1]}#{opts[:type]}"
+        format_parameters << opts[:value]
+        @needs_caller_info = true if v[2] =~ /[FlLM]/
+      end
+      format_string << $' if $'.length > 0
+      format_string << "\n"
+
+      definition = "proc { |opts| #{format_string.inspect} % [ #{format_parameters.join(',')} ] }"
+      @message_formatter = eval( definition )
+    end
+
+    # Format the message using the given parameters. If a message format has
+    # not been given, just call the superclass's implementation. Otherwise,
+    # process the tokens from the parsed message format.
+    def format_message( severity, timestamp, msg, progname )
+      if @message_format.nil?
+        super
+      else
+        opts = {
+          :severity => severity,
+          :timestamp => timestamp,
+          :msg => msg,
+          :progname => progname
+        }
+        
+        if @needs_caller_info
+          stack = caller
+          stack.shift while stack.first =~ /\blogger\.rb/
+          opts[:caller_info] = caller_info = stack.first
+          match = caller_info.match( /(.*):(\d+)(?::in `(.*)')?/ )
+          opts[:caller_file] = match[1]
+          opts[:caller_line] = match[2]
+          opts[:caller_method] = match[3]
+        end
+
+        @message_formatter.call( opts )
+      end
+    end
+    private :format_message
+
+  end
+
+end

data/lib/copland/models/singleton.rb

@@ -31,8 +31,9 @@
 # =============================================================================
 #++
 
+require 'copland/errors'
 require 'copland/models/abstract'
-require 'thread'
+require 'copland/thread'
 
 module Copland
 
@@ -47,7 +48,7 @@ module Copland
       # Create a new SingletonServiceModel on the given service point.
       def initialize( service_point )
         super
-        @mutex = Mutex.new
+        @mutex = QueryableMutex.new
       end
 
       # Return the singleton instance of the service point. This is
@@ -55,6 +56,11 @@ module Copland
       def instance( &init )
         return @instance if @instance
 
+        if @mutex.self_locked?
+          raise CoplandException,
+            "circular dependency on #{service_point.full_name} detected"
+        end
+
         @mutex.synchronize do
           return @instance if @instance
           new_instance( &init )

data/lib/copland/package.rb

@@ -78,14 +78,24 @@ module Copland
     end
 
     # Returns the service point with the given name. If no such service point
-    # exists, this returns +nil+.
-    def service_point( name )
-      @service_points[ name ]
+    # exists, this returns +nil+. If +include_private+ is false, then this will
+    # also return +nil+ if the point exists, but is marked private.
+    def service_point( name, include_private=false )
+      point = @service_points[ name ]
+      return nil if point.nil? || point.visibility == :private &&
+        !include_private
+      point
     end
 
-    # This returns the names of all service points in the package.
-    def service_points
-      @service_points.keys.freeze
+    # This returns the names of all service points in the package. If
+    # +include_private+ is true (the default), then only the public service
+    # points will be returned.
+    def service_points( include_private=false )
+      names = @service_points.keys.dup
+      if !include_private
+        names.reject! { |p| @service_points[p].visibility != :public }
+      end
+      names
     end
 
     # This instantiates the service point with the given name and returns the
@@ -95,15 +105,19 @@ module Copland
     # If a block is given, it will be used to initialize the service (but only
     # when the service is created--if the service is a singleton service and
     # it was created previously, the init block will be ignored).
-    def service( name, &init )
-      point = service_point( name ) or raise ServicePointNotFound, name
+    #
+    # If +include_private+ is true, then only public service points may be
+    # instantiated.
+    def service( name, include_private=false, &init )
+      point = service_point( name, include_private ) or
+        raise ServicePointNotFound, name
       point.instance( &init )
     end
 
     # Returns +true+ if the named service exists in this package, and +false+
     # otherwise.
-    def service_exist?( name )
-      return !service_point( name ).nil?
+    def service_exist?( name, include_private=false )
+      return !service_point( name, include_private ).nil?
     end
 
     # This is a convenience method for returning a service with the given name,
@@ -155,8 +169,10 @@ module Copland
     end
 
     # Iterates over each service point in the package.
-    def each_service_point( &block )
-      @service_points.each_value( &block )
+    def each_service_point( include_private=false, &block )
+      @service_points.each_value do |pt|
+        yield pt if pt.visibility == :public || include_private
+      end
       self
     end
 
@@ -171,8 +187,10 @@ module Copland
     end
 
     # Returns the number of service points in the package.
-    def service_point_count
-      @service_points.size
+    def service_point_count( include_private=false )
+      @service_points.
+        reject { |k,v| v.visibility == :private && !include_private }.
+        size
     end
 
     # Returns the number of configuration points in the package.