autumn 3.1.8

data/lib/autumn/datamapper_hacks.rb

@@ -0,0 +1,290 @@
+# A set of hacks to make DataMapper play more nicely with classes within
+# modules.
+
+module DataMapper # :nodoc:
+    
+  #HACK Add module names to auto-generated class names in relationships
+  #
+  # When a class name is automatically inferred from a relationship name (e.g.,
+  # guessing that has_many :widgets refers to a Widget class), it is necessary
+  # to enclose these class names in the same modules as the calling class. For
+  # example, if MyLeaf::Factory has_many :widgets, this hack will ensure the
+  # inferred class name is MyLeaf::Widget, instead of just ::Widget.
+  #
+  # This hack is performed for each of the association types in DataMapper. An
+  # :old_behavior option is given to revert to the unhacked method.
+  
+  module Associations # :nodoc:
+    module OneToMany # :nodoc:
+      class << self
+        alias_method :old_setup, :setup
+        def setup(name, model, options={})
+          class_name = options.fetch(:class_name, Extlib::Inflection.classify(name))
+          if not options[:old_behavior] and not class_name.include?('::') then
+            modules = model.to_s.split('::')
+            modules.pop
+            modules << class_name
+            options[:class_name] = modules.join('::')
+          end
+          old_setup(name, model, options)
+        end
+      end
+    end
+     
+    module OneToOne # :nodoc:
+      class << self
+        alias_method :old_setup, :setup
+        def setup(name, model, options={})
+          class_name = options.fetch(:class_name, Extlib::Inflection.classify(name))
+          if not options[:old_behavior] and not class_name.include?('::') then
+            modules = model.to_s.split('::')
+            modules.pop
+            modules << class_name
+            options[:class_name] = modules.join('::')
+          end
+          old_setup(name, model, options)
+        end
+      end
+    end
+        
+    module ManyToOne # :nodoc:
+      class << self
+        alias_method :old_setup, :setup
+        def setup(name, model, options={})
+          class_name = options.fetch(:class_name, Extlib::Inflection.classify(name))
+          if not options[:old_behavior] and not class_name.include?('::') then
+            modules = model.to_s.split('::')
+            modules.pop
+            modules << class_name
+            options[:class_name] = modules.join('::')
+          end
+          old_setup(name, model, options)
+        end
+      end
+    end
+  end
+end
+
+#HACK Strip module names when auto-generating table names for has-many-through
+#     relationships.
+#
+# By default, DataMapper will not strip module names when creating the join
+# tables for has-many-through relationships. So, if MyLeaf::Post has and belongs
+# to many MyLeaf::Category, the join table will be called
+# "my_leaf/categories_my_leaf/posts", which is clearly an invalid table name.
+# This hack strips module components from a class name before generating the
+# join table's name.
+#
+# A side effect of this hack is that no two DataMapper models for the same
+# repository can share the same name, even if they are in separate modules.
+#
+# This also fixes a bug that can occur when script/console is launched. The
+# double assignment of the relationship variable seems to mess up IRb, so it has
+# been split into two assignments.
+
+DataMapper::Associations::ManyToMany.module_eval do # :nodoc:
+  def self.setup(name, model, options={})
+    class_name = options.fetch(:class_name, Extlib::Inflection.classify(name))
+    if not options[:old_behavior] and not class_name.include?('::') then
+      modules = model.to_s.split('::')
+      modules.pop
+      modules << class_name
+      options[:class_name] = modules.join('::')
+    end
+    
+    assert_kind_of 'name',    name,    Symbol
+    assert_kind_of 'model',   model,   DataMapper::Model
+    assert_kind_of 'options', options, Hash
+
+    repository_name = model.repository.name
+
+    model.class_eval <<-EOS, __FILE__, __LINE__
+      def #{name}(query = {})
+        #{name}_association.all(query)
+      end
+
+      def #{name}=(children)
+        #{name}_association.replace(children)
+      end
+
+      private
+
+      def #{name}_association
+        @#{name}_association ||= begin
+          unless relationship = model.relationships(#{repository_name.inspect})[#{name.inspect}]
+            raise ArgumentError, "Relationship #{name.inspect} does not exist in \#{model}"
+          end
+          association = Proxy.new(relationship, self)
+          parent_associations << association
+          association
+        end
+      end
+    EOS
+
+    opts = options.dup
+    opts.delete(:through)
+    opts[:child_model]              ||= opts.delete(:class_name)  || Extlib::Inflection.classify(name)
+    opts[:parent_model]             =   model
+    opts[:repository_name]          =   repository_name
+    opts[:remote_relationship_name] ||= opts.delete(:remote_name) || Extlib::Inflection.tableize(opts[:child_model])
+    opts[:parent_key]               =   opts[:parent_key]
+    opts[:child_key]                =   opts[:child_key]
+    opts[:mutable]                  =   true
+
+    names        = [ opts[:child_model].demodulize, opts[:parent_model].name.demodulize ].sort
+    model_name   = names.join.gsub("::", "")
+    storage_name = Extlib::Inflection.tableize(Extlib::Inflection.pluralize(names[0]) + names[1])
+    model_module = model.to_s.split('::')
+    model_module.pop
+    model_module = model_module.join('::')
+    model_module = model_module.empty? ? Object : eval("::#{model_module}")
+    
+    opts[:near_relationship_name] = Extlib::Inflection.tableize(model_name).to_sym
+    
+    model.has(model.n, opts[:near_relationship_name], :old_behavior => true)
+
+    relationship = DataMapper::Associations::RelationshipChain.new(opts)
+    model.relationships(repository_name)[name] = relationship
+
+    unless model_module.const_defined?(model_name)
+      model = DataMapper::Model.new(storage_name)
+
+      model.class_eval <<-EOS, __FILE__, __LINE__
+        def self.name; #{model_name.inspect} end
+        def self.default_repository_name; #{repository_name.inspect} end
+        def self.many_to_many; true end
+      EOS
+
+      names.each do |n|
+        model.belongs_to(Extlib::Inflection.underscore(n).gsub("/", "_").to_sym, :class_name => n)
+      end
+
+      model_module.const_set(model_name, model)
+    end
+
+    relationship
+  end
+end
+
+#HACK Update methods in RelationshipChain to use the scoped repository.
+#
+# This hack will update methods to use the currently-scoped repository, instead
+# of always using the default repository.
+
+module DataMapper # :nodoc:
+  module Associations # :nodoc:
+    class RelationshipChain # :nodoc:
+      def near_relationship
+        parent_model.relationships(repository.name)[@near_relationship_name]
+      end
+  
+      def remote_relationship
+        return nil unless near_relationship
+        near_relationship.child_model.relationships(repository.name)[@remote_relationship_name] ||
+          near_relationship.child_model.relationships(repository.name)[@remote_relationship_name.to_s.singularize.to_sym]
+      end
+    end
+  end
+end
+
+DataMapper::Model.class_eval do
+  
+  #HACK Determine the child key from the given repository, not the default one.
+  #
+  # Updates this method to use the hacked child_key method.
+  
+  def properties_with_subclasses(repository_name = default_repository_name)
+    properties = DataMapper::PropertySet.new
+    ([ self ].to_set + (respond_to?(:descendants) ? descendants : [])).each do |model|
+      model.relationships(repository_name).each_value { |relationship| relationship.child_key(repository_name) }
+      model.many_to_one_relationships.each do |relationship| relationship.child_key(repository_name) end
+      model.properties(repository_name).each do |property|
+        properties << property unless properties.has_property?(property.name)
+      end
+    end
+    properties
+  end
+end
+
+DataMapper::Associations::Relationship.class_eval do
+  
+  #HACK Determine the child key from the given repository, not the default one.
+  #
+  # Updates this method to take a repository name. The child key will be
+  # determined from the properties scoped to the given repository.
+  #
+  # The @child_key class variable is changed to a hash that maps repository
+  # names to the appropriate key.
+  
+  def child_key(repository_name=nil)
+    repository_name ||= repository.name
+    @child_key ||= Hash.new
+    @child_key[repository_name] ||= begin
+      child_key = nil
+      repository(repository_name).scope do |r|
+        model_properties = child_model.properties(repository_name)
+
+        child_key = parent_key(repository_name).zip(@child_properties || []).map do |parent_property,property_name|
+          # TODO: use something similar to DM::NamingConventions to determine the property name
+          parent_name = Extlib::Inflection.underscore(Extlib::Inflection.demodulize(parent_model.base_model.name))
+          property_name ||= "#{parent_name}_#{parent_property.name}".to_sym
+
+          if model_properties.has_property?(property_name)
+            model_properties[property_name]
+          else
+            options = {}
+
+            [ :length, :precision, :scale ].each do |option|
+              options[option] = parent_property.send(option)
+            end
+
+            # NOTE: hack to make each many to many child_key a true key,
+            # until I can figure out a better place for this check
+            if child_model.respond_to?(:many_to_many)
+              options[:key] = true
+            end
+
+            child_model.property(property_name, parent_property.primitive, options)
+          end
+        end
+      end
+      DataMapper::PropertySet.new(child_key)
+    end
+    return @child_key[repository_name]
+  end
+  
+  #HACK Determine the parent key from the given repository, not the default one.
+  #
+  # Updates this method to take a repository name. The parent key will be
+  # determined from the properties scoped to the given repository.
+  #
+  # The @parent_key class variable is changed to a hash that maps repository
+  # names to the appropriate key.
+  
+  def parent_key(repository_name=nil)
+    repository_name ||= repository.name
+    @parent_key ||= Hash.new
+    @parent_key[repository_name] ||= begin
+      parent_key = nil
+      repository(repository_name).scope do |r|
+        parent_key = if @parent_properties
+          parent_model.properties(repository_name).slice(*@parent_properties)
+        else
+          parent_model.key(repository_name)
+        end
+      end
+      DataMapper::PropertySet.new(parent_key)
+    end
+    return @parent_key[repository_name]
+  end
+end
+
+# Add a method to return all models defined for a repository.
+
+DataMapper::Repository.class_eval do
+  def models
+    DataMapper::Resource.descendants.select { |cl| not cl.properties(name).empty? or not cl.relationships(name).empty? }
+    #HACK we are assuming that if a model has properties or relationships
+    #     defined for a repository, then it must be contextual to that repo
+  end
+end

data/lib/autumn/foliater.rb

@@ -0,0 +1,231 @@
+# Defines the Autumn::Foliater class, which instantiates stems and leaves and
+# keeps watch over their threads.
+
+module Autumn
+
+  # Loads Stems and Leaves and executes them in their own threads. Manages the
+  # threads and oversees all leaves. This is a singleton class.
+
+  class Foliater
+    include Singleton
+  
+    # The Speciator singleton.
+    attr_reader :config
+    # A hash of all Stem instances by their config names.
+    attr_reader :stems
+    # A hash of all Leaf instances by their config names.
+    attr_reader :leaves
+  
+    def initialize # :nodoc:
+      @config = Speciator.instance
+      @stems = Hash.new
+      @leaves = Hash.new
+      @ctcp = Autumn::CTCP.new
+    end
+    
+    # Loads the config files and their classes, initializes all stems and leaves
+    # and begins the stems' execution processes in their own threads. You must
+    # pass the stem and leaf config hashes (from the stems.yml and leaves.yml
+    # files).
+    #
+    # If +invoke+ is set to false, start_stems will not be called.
+    
+    def load(stem_config, leaf_config, invoke=true)
+      load_configs stem_config, leaf_config
+      load_leaf_classes
+      load_leaves
+      load_all_leaf_models
+      load_stems
+      start_stems if invoke
+    end
+    
+    # Reloads a leaf while it is running. Re-opens class definition files and
+    # runs them to redefine the classes. Does not work exactly as it should,
+    # but well enough for a rough hot-reload capability.
+    
+    def hot_reload(leaf)
+      type = leaf.class.to_s.split('::').first
+      load_leaf_controller type
+      load_leaf_helpers type
+      load_leaf_models leaf
+      load_leaf_views type
+    end
+
+    # Returns true if there is at least one stem still running.
+  
+    def alive?
+      @stem_threads and @stem_threads.any? { |name, thread| thread.alive? }
+    end
+    
+    # This method yields each Stem that was loaded, allowing you to iterate over
+    # each stem. For instance, to take attendance:
+    #
+    #  Foliater.instance.each_stem { |stem| stem.message "Here!" }
+  
+    def each_stem
+      @leaves.each { |leaf| yield leaf }
+    end
+
+    # This method yields each Leaf subclass that was loaded, allowing you to
+    # iterate over each leaf. For instance, to take attendance:
+    #
+    #  Foliater.instance.each_leaf { |leaf| leaf.stems.message "Here!" }
+  
+    def each_leaf
+      @leaves.each { |leaf| yield leaf }
+    end
+
+    private
+    
+    def load_configs(stem_config, leaf_config)
+      leaf_config.each do |name, options|
+        global_config_file = "#{AL_ROOT}/leaves/#{options['class'].snakecase}/config.yml"
+        if File.exist? global_config_file then
+          config.leaf name, YAML.load(File.open(global_config_file))
+        end
+        config.leaf name, options
+        config.leaf name, :logger => LogFacade.new(config.global(:logfile), 'Leaf', name)
+      end
+      stem_config.each do |name, options|
+        config.stem name, options
+        config.stem name, :logger => LogFacade.new(config.global(:logfile), 'Stem', name)
+      end
+    end
+    
+    def load_leaf_classes
+      config.all_leaf_classes.each do |type|
+        Object.class_eval "module #{type}; end"
+        
+        config.leaf type, :module => Object.const_get(type)
+        
+        load_leaf_controller(type)
+        load_leaf_helpers(type)
+        load_leaf_views(type)
+      end
+    end
+    
+    def load_leaf_controller(type)
+      controller_file = "#{AL_ROOT}/leaves/#{type.snakecase}/controller.rb"
+      raise "controller.rb file for leaf #{type} not found" unless File.exist? controller_file
+      controller_code = nil
+      begin
+        File.open("#{AL_ROOT}/leaves/#{type.snakecase}/controller.rb", 'r') { |f| controller_code = f.read }
+      rescue Errno::ENOENT
+        raise "controller.rb file for leaf #{type} not found"
+      end
+      config.leaf(type, :module).module_eval controller_code
+    end
+    
+    def load_leaf_helpers(type)
+      mod = config.leaf(type, :module)
+      helper_code = nil
+      Dir.glob("#{AL_ROOT}/leaves/#{type.snakecase}/helpers/*.rb").each do |helper_file|
+        File.open(helper_file, 'r') { |f| helper_code = f.read }
+        mod.module_eval helper_code
+      end
+      
+      leaf_class = nil
+      begin
+        leaf_class = mod.const_get('Controller')
+      rescue NameError
+        raise NameError, "Couldn't find Controller class for leaf #{type}"
+      end
+      
+      config.leaf type, :helpers => Set.new
+      mod.constants.select { |const_name| const_name =~ /Helper$/ }.map { |helper_name| mod.const_get helper_name }.each do |helper|
+        config.leaf(type, :helpers) << helper
+      end
+    end
+    
+    def load_leaf_views(type)
+      views = Hash.new
+      view_text = nil
+      Dir.glob("#{AL_ROOT}/leaves/#{type.snakecase}/views/*.txt.erb").each do |view_file|
+        view_name = File.basename(view_file).match(/^(.+)\.txt\.erb$/)[1]
+        File.open(view_file, 'r') { |f| view_text = f.read }
+        views[view_name] = view_text
+      end
+      config.leaf type, :views => views
+    end
+    
+    def load_leaves
+      config.each_leaf do |name, options|
+        options = config.options_for_leaf(name)
+        options[:root] = "#{config.global :root}/leaves/#{options[:class].snakecase}"
+        begin
+          leaf_class = options[:module].const_get('Controller')
+        rescue NameError
+          raise NameError, "Couldn't find Controller class for leaf #{name}"
+        end
+        @leaves[name] = leaf_class.new(options)
+        formatter = Autumn::Formatting.const_get options[:formatter].to_sym if options[:formatter] and (Autumn::Formatting.constants.include? options[:formatter] or Autumn::Formatting.constants.include? options[:formatter].to_sym)
+        formatter ||= Autumn::Formatting::DEFAULT
+        @leaves[name].extend formatter
+        options[:helpers].each { |helper| @leaves[name].extend helper }
+        # extend the formatter first so helper methods override its methods if necessary
+      end
+    end
+    
+    def load_all_leaf_models
+      @leaves.each { |name, instance| load_leaf_models instance }
+    end
+    
+    def load_leaf_models(leaf)
+      model_code = nil
+      mod = config.leaf(leaf.options[:class], :module)
+      leaf.database do
+        Dir.glob("#{AL_ROOT}/leaves/#{leaf.options[:class].snakecase}/models/*.rb").each do |model_file|
+          File.open(model_file, 'r') { |f| model_code = f.read }
+          mod.module_eval model_code
+        end
+        # Need to manually set the table names of the models because we loaded
+        # them inside a module
+        unless $NO_DATABASE
+          mod.constants.map { |const_name| mod.const_get(const_name) }.select { |const| const.ancestors.include? DataMapper::Resource }.each do |model|
+            model.storage_names[leaf.database_name] = model.to_s.demodulize.snakecase.pluralize
+          end
+        end
+      end
+    end
+    
+    def load_stems
+      config.each_stem do |name, options|
+        options = config.options_for_stem(name)
+        server = options[:server]
+        nick = options[:nick]
+        
+        @stems[name] = Stem.new(server, nick, options)
+        leaves = options[:leaves]
+        leaves ||= [ options[:leaf] ]
+        leaves.each do |leaf|
+          raise "Unknown leaf #{leaf} in configuration for stem #{name}" unless @leaves[leaf]
+          @stems[name].add_listener @leaves[leaf]
+          @stems[name].add_listener @ctcp
+          #TODO a configurable way of specifying listeners to add by default
+          @leaves[leaf].stems << @stems[name]
+        end
+      end
+    end
+    
+    def start_stems
+      @leaves.each { |name, leaf| leaf.preconfigure }
+      @leaves.each { |name, leaf| leaf.will_start_up }
+      @stem_threads = Hash.new
+      config.each_stem do |name, options|
+        @stem_threads[name] = Thread.new(@stems[name], Thread.current) do |stem, parent_thread|
+          # The thread will run the stem until it exits, then inform the main
+          # thread that it has exited. When the main thread wakes, it checks if
+          # all stems have terminated; if so, it terminates itself.
+          begin
+            stem.start
+          rescue
+            options[:logger].fatal $!
+          ensure
+            parent_thread.wakeup # Schedule the parent thread to wake up after this thread finishes
+          end
+        end
+      end
+    end
+    
+  end
+end