bougyman-autumn 3.1.1

data/lib/autumn/stem_facade.rb

@@ -0,0 +1,176 @@
+# Defines the Autumn::StemFacade class, which provides additional convenience
+# methods to Autumn::Stem.
+
+module Autumn
+  
+  # A collection of convenience methods that are added to the Stem class. These
+  # methods serve two purposes; one, to allow easier backwards compatibility
+  # with Autumn Leaves 1.0 (which had a simpler one-stem-per-leaf approach), and
+  # two, to make it easier or more Ruby-like to perform certain IRC actions.
+  
+  module StemFacade
+    
+    # Sends a message to one or more channels or nicks. If no channels or nicks
+    # are specified, broadcasts the message to every channel the stem is in. If
+    # you are sending a message to a channel you must prefix it correctly; the
+    # "#" will not be added before the channel name for you.
+    #
+    #  message "Look at me!" # Broadcasts to all channels
+    #  message "I love kitties", '#kitties' # Sends a message to one channel or person
+    #  message "Learn to RTFM", '#help', 'NoobGuy' # Sends a message to two channels or people
+    
+    def message(msg, *chans)
+      return if msg.nil? or msg.empty?
+      chans = channels if chans.empty?
+      if @throttle then
+        Thread.exclusive { msg.each_line { |line| privmsgt chans.to_a, line.strip unless line.strip.empty? } }
+      else
+        msg.each_line { |line| privmsg chans.to_a, line.strip unless line.strip.empty? }
+      end
+    end
+    
+    # Sets the topic for one or more channels. If no channels are specified,
+    # sets the topic of every channel the stem is in.
+    #
+    #  set_topic "Bots sure are fun!", 'bots', 'morebots'
+    
+    def set_topic(motd, *chans)
+      return if motd.nil?
+      chans = chans.empty? ? channels : chans.map { |chan| normalized_channel_name chan }
+      chans.each { |chan| topic chan, motd }
+    end
+    
+    # Joins a channel by name. If the channel is password-protected, specify the
+    # +password+ parameter. Of course, you could always just call the +join+
+    # method (since each IRC command has a method named after it), but the
+    # advantage to using this method is that it will also update the
+    # <tt>@channel_passwords</tt> instance variable. Internal consistency is a
+    # good thing, so please use this method.
+    
+    def join_channel(channel, password=nil)
+      channel = normalized_channel_name(channel)
+      return if channels.include? channel
+      join channel, password
+      @channel_passwords[channel] = password if password
+    end
+
+    # Leaves a channel, specified by name.
+    
+    def leave_channel(channel)
+      channel = normalized_channel_name(channel)
+      return unless channels.include? channel
+      part channel
+    end
+
+    # Changes this stem's IRC nick. Note that the stem's original nick will
+    # still be used by the logger.
+    
+    def change_nick(new_nick)
+      nick new_nick
+    end
+
+    # Grants a privilege to a channel member, such as voicing a member. The stem
+    # must have the required privilege level to perform this command.
+    # +privilege+ can either be a symbol from the Daemon instance or a string
+    # with the letter code for the privilege.
+    #
+    #  grant_user_privilege 'mychannel', 'Somedude', :operator
+    #  grant_user_privilege '#mychannel', 'Somedude', 'oa'
+    
+    def grant_user_privilege(channel, nick, privilege)
+      channel = normalized_channel_name(channel)
+      privcode = server_type.privilege.index(privilege).chr if server_type.privilege.value? privilege
+      privcode ||= privilege
+      mode channel, "+#{privcode}", nick
+    end
+
+    # Removes a privilege to a channel member, such as voicing a member. The
+    # stem must have the required privilege level to perform this command.
+    # +privilege+ can either be a symbol from the Daemon instance or a string
+    # with the letter code for the privilege.
+    
+    def remove_user_privilege(channel, nick, privilege)
+      channel = normalized_channel_name(channel)
+      privcode = server_type.privilege.index(privilege).chr if server_type.privilege.value? privilege
+      privcode ||= privilege
+      mode channel, "-#{privcode}", nick
+    end
+    
+    # Grants a usermode to an IRC nick, such as making a nick invisible.
+    # The stem must have the required privilege level to perform this command.
+    # (Generally, one can only change his own usermode unless he is a server
+    # op.) +mode+ can either be a symbol from the Daemon instance or a string
+    # with the letter code for the usermode.
+    #
+    #  grant_usermode 'Spycloak', :invisible
+    #  grant_usermode 'UpMobility', 'os'
+    
+    def grant_usermode(nick, property)
+      propcode = server_type.usermode.index(property).chr if server_type.usermode.value? property
+      propcode ||= property
+      mode nick, "+#{property}"
+    end
+
+    # Revokes a usermode from an IRC nick, such as removing invisibility. The
+    # stem must have the required privilege level to perform this command.
+    # (Generally, one can only change his own usermode unless he is a server
+    # op.) +mode+ can either be a symbol from the Daemon instance or a string
+    # with the letter code for the usermode.
+    
+    def remove_usermode(nick, property)
+      propcode = server_type.usermode.index(property).chr if server_type.usermode.value? property
+      propcode ||= property
+      mode nick, "-#{property}"
+    end
+
+    # Sets a property of a channel, such as moderated. The stem must have the
+    # required privilege level to perform this command. +property+ can either be
+    # a symbol from the Daemon instance or a string with the letter code for the
+    # property. If the property takes an argument (such as when setting a
+    # channel password), pass it as the +argument+ paramter.
+    #
+    #  set_channel_property '#mychannel', :secret
+    #  set_channel_property 'mychannel', :keylock, 'mypassword'
+    #  set_channel_property '#mychannel', 'ntr'
+    
+    def set_channel_property(channel, property, argument=nil)
+      channel = normalized_channel_name(channel)
+      propcode = server_type.channel_property.index(property).chr if server_type.channel_property.value? property
+      propcode ||= property
+      mode channel, "+#{propcode}", argument
+    end
+
+    # Removes a property of a channel, such as moderated. The stem must have the
+    # required privilege level to perform this command. +property+ can either be
+    # a symbol from the Daemon instance or a string with the letter code for the
+    # property. If the property takes an argument (such as when removing a
+    # channel password), pass it as the +argument+ paramter.
+    
+    def unset_channel_property(channel, property, argument=nil)
+      channel = normalized_channel_name(channel)
+      propcode = server_type.channel_property.index(property).chr if server_type.channel_property.value? property
+      propcode ||= property
+      mode channel, "-#{propcode}", argument
+    end
+    
+    # Returns an array of nicks for users that are in a channel.
+    
+    def users(channel)
+      channel = normalized_channel_name(channel)
+      @chan_mutex.synchronize { @channel_members[channel] && @channel_members[channel].keys }
+    end
+  
+    # Returns the privilege level of a channel member. The privilege level will
+    # be a symbol from the Daemon instance. Returns nil if the channel member
+    # doesn't exist or if the bot is not on the given channel. Returns an array
+    # of privileges if the server supports multiple privileges per user, and the
+    # user has more than one privilege.
+    #
+    # +user+ can be a nick or a sender hash.
+    
+    def privilege(channel, user)
+      user = user[:nick] if user.kind_of? Hash
+      @chan_mutex.synchronize { @channel_members[channel] && @channel_members[channel][user] }
+    end
+  end
+end

data/lib/autumn/tool/bin.rb

@@ -0,0 +1,302 @@
+#!/usr/bin/env ruby
+require 'optparse'
+### This module offers the functionality to start, stop, restart, create,
+### Check status, or run a console of an autumn application
+### see autumn -h for usage
+module Autumn
+  module Tool
+    module Bin
+      module Helpers # Helper methods {{{
+
+        def default_pidfile # {{{
+          return @default_pidfile if @default_pidfile
+          al_root
+          pn = Pathname.new(AL_ROOT)
+          @default_pidfile = (pn.expand_path.join("tmp", pn.basename.to_s + ".pid")).strip
+        end # }}}
+
+        # We're really only concerned about win32ole, so we focus our check on its
+        # ability to load that
+        def is_windows?  # {{{
+          return @is_win if @is_win
+          begin
+            require "win32ole"
+          rescue LoadError
+          end
+          @is_win ||= Object.const_defined?("WIN32OLE")
+        end # }}}
+
+        def is_running?(pid) # {{{
+          if is_windows?
+            wmi = WIN32OLE.connect("winmgmts://")
+            processes, ours = wmi.ExecQuery("select * from win32_process where ProcessId = #{pid}"), []
+            processes.each { |process| ours << process.Name }
+            ours.first.nil?
+          else
+            begin
+              prio = Process.getpriority(Process::PRIO_PROCESS, pid)
+              true
+            rescue Errno::ESRCH
+              false
+            end
+          end
+        end # }}}
+
+        def check_running?(pid_file) # {{{
+          return false unless File.file?(pid_file)
+          is_running?(File.read(pid_file).to_i)
+        end # }}}
+
+        def find_pid(pid_file) # {{{
+          if pid_file.nil? or not File.file?(pid_file)
+            pid_file = default_pidfile
+          end
+          unless File.file?(pid_file)
+            $stderr.puts "Could not find running process id."
+            return false
+          end
+          pid_file
+        end # }}}
+      end # End helper methods }}}
+
+      class Cmd # This class contains the command methods {{{
+        include Helpers
+        attr_accessor :command
+
+        def initialize(args = nil)
+          args ||= ARGV
+          raise "arguments must be an array!" unless args.respond_to?(:detect)
+          @ourargs = args.dup
+          @command = args.detect { |arg| arg.match(/^(?:--?)?(?:start|stop|restart|create|h(?:elp)?|v(?:ersion)?|console|status)/) }
+          if command.nil?
+            @command = ""
+          else
+            args.delete(@command)
+          end
+          ARGV.replace(args)
+        end
+
+        # {{{ #run is called when we're interactive ($0 == __FILE__)
+        def self.run(args = nil)
+          cmd = new(args)
+          case cmd.command
+          when /^(?:--?)?status$/
+            cmd.status(cmd.command)
+          when /^(?:--?)?restart$/
+            cmd.stop(cmd.command)
+            cmd.start
+          when /^(?:--?)?start$/
+            cmd.start
+          when /^(?:--?)?create$/
+            cmd.create(cmd.command)
+          when /^(?:--?)?stop$/
+            if cmd.stop(cmd.command)
+              puts "Autumn session has ended."
+              $stdout.flush
+            else
+              puts "Autumn failed to stop (or was not running)"
+            end
+          when /^(?:--?)?console$/
+            require "irb"
+            require "irb/completion"
+            cmd.include_autumn
+            require "lib/genesis"
+            IRB.start
+            puts "Autumn session has ended."
+          when /^(?:--?)?h(elp)?$/
+            puts cmd.usage
+          when /^(?:--?)?v(ersion)?$/
+            cmd.include_autumn
+            puts Autumn::VERSION
+            exit
+          when /^$/
+            puts "Must supply a valid command"
+            puts cmd.usage
+            exit 1
+          else
+            puts "#{command} not implemented"
+            puts cmd.usage
+            exit 1
+          end
+        end # }}}
+
+        def include_autumn # {{{
+          begin
+            $LOAD_PATH.unshift File.join(File.dirname(__FILE__), '/../lib')
+            require 'autumn'
+          rescue LoadError
+            $LOAD_PATH.shift
+
+            begin
+              require 'rubygems'
+            rescue LoadError
+            end
+            require 'autumn'
+          end
+        end # }}}
+
+        def usage # {{{
+          txt = [
+            "\n  Usage:", 
+            "autumn <start|stop|restart|status|create|console> PROJECT [options]\n",
+            "Commands:\n",
+            " start   - Starts an instance of this application.\n",
+            " stop    - Stops a running instance of this application.\n",
+            " restart - Stops running instance of this application, then starts it back up.  Pidfile",
+            "           (if supplied) is used for both stop and start.\n",
+            " status  - Gives status of a running autumn instance\n",
+            " create  - Creates a new prototype Autumn application in a directory named PROJECT in",
+            "           the current directory.  autumn create foo would make ./foo containing an",
+            "           application prototype.\n",
+            " console - Starts an irb console with autumn (and irb completion) loaded.",
+            "           ARGV is passed on to IRB.\n\n"
+          ].join("\n\t")
+
+          txt <<  "* All commands which take an optional PIDFILE (-p/--pid) default to PROJECT.pid.\n"
+          txt <<  "* All commands take PROJECT as the directory the autumn bot lives in.\n"
+          txt << start_options.to_s << "\n"
+          txt << create_options.to_s << "\n"
+          #if is_windows?
+            #txt << %x{ruby #{rackup_path} --help}.split("\n").reject { |line| line.match(/^Usage:/) }.join("\n\t")
+          #else
+            #txt << %x{#{rackup_path} --help}.split("\n").reject { |line| line.match(/^Usage:/) }.join("\n\t")
+          #end
+        end # }}}
+
+        def start_options
+          @start_opts ||= OptionParser.new do |o|
+            o.banner = "Start/Restart Options"
+            o.on("-D", "--daemonize", "Daemonize the process") { |daem| @daemonize = true }
+          end
+        end
+
+        def al_root
+          require "pathname"
+          dir = nil
+          if ARGV.size == 1
+            dir = Pathname.new(ARGV.shift)
+          elsif ARGV.size > 1
+            $stderr.puts "Unknown options given #{ARGV.join(" ")}"
+            puts usage
+            exit 1
+          end
+          if dir.nil? or not dir.directory?
+            dir = Pathname.new(ENV["PWD"]).expand_path
+            $stderr.puts "Path to autumn tree not given or invalid, using #{dir}"
+          end
+          Object.const_set("AL_ROOT", dir.expand_path.to_s)
+          Dir.chdir(AL_ROOT)
+        end
+
+        ### Methods for commands {{{
+        def start # {{{
+          start_options.parse!(ARGV)
+          al_root
+          
+          # Find the name of this app
+          puts "starting autumn"
+          if @daemonize
+            require "daemons"
+            Daemons.run_proc(Pathname.new(AL_ROOT).basename, :ARGV => ["start"], :dir_mode => :normal, :dir => "tmp", :multiple => false) do
+              start_autumn
+            end
+            puts "Autumn started in the background"
+          else
+            start_autumn
+          end
+        end # }}}
+
+        def start_autumn
+          require "autumn/genesis"
+          puts "Loading Autumn #{Autumn::VERSION}"
+          Autumn::Genesis.new.boot!
+        end
+
+        def create_options(opts = {})
+          @create_opts ||= OptionParser.new do |o|
+            o.banner = "Create Options"
+            o.on("-f", "--force", "Force creation if dir already exists") { |yn| opts[:force] = true }
+            o.on("-a", "--amend", "Update a tree") { |yn| opts[:amend] = true }
+          end
+        end
+        
+        def create(command) # {{{
+          create_options(opts = {}).parse!(ARGV)
+          unless ARGV.size == 1
+            $stderr.puts "Invalid options given: #{ARGV.join(" ")}"
+            exit 1
+          end
+          project_name = ARGV.shift
+          if project_name.nil?
+            $stderr.puts "Must supply a valid project name, you gave none."
+            puts usage
+            exit 1
+          end
+          include_autumn
+          require 'autumn/tool/create'
+          Autumn::Tool::Create.create(project_name, opts)
+        end # }}}
+
+        def stop(command) # {{{
+          al_root
+          require "daemons"
+          Daemons.run_proc(Pathname.new(AL_ROOT).basename, :ARGV => ["stop"], :dir_mode => :normal, :dir => "tmp", :multiple => false) do
+            start_autumn
+          end
+        end # }}}
+
+        def status(command) # {{{
+          al_root
+          pn = Pathname.new(AL_ROOT)
+          unless pid_file = find_pid(pn.join("tmp", pn.basename.to_s + ".pid"))
+            $stderr.puts "No pid_file found! Autumn may not be started."
+            exit 1
+          end
+          puts "Pid file #{pid_file} found, PID is #{pid = File.read(pid_file).chomp}"
+          unless is_running?(pid.to_i)
+            $stderr.puts "PID #{pid} is not running"
+            exit 1
+          end
+          if is_windows?
+            wmi = WIN32OLE.connect("winmgmts://")
+            processes, ours = wmi.ExecQuery("select * from win32_process where ProcessId = #{pid}"), []
+            processes.each { |p| ours << [p.Name, p.CommandLine, p.VirtualSize, p.CreationDate, p.ExecutablePath, p.Status ] }
+            puts "Autumn is running!\n\tName: %s\n\tCommand Line: %s\n\tVirtual Size: %s\n\tStarted: %s\n\tExec Path: %s\n\tStatus: %s" % ours.first
+          else
+            require "pathname"
+            # Check for /proc
+            if File.directory?(proc_dir = Pathname.new("/proc"))
+              proc_dir = proc_dir.join(pid)
+              # If we have a "stat" file, we'll assume linux and get as much info
+              # as we can
+              if stat_file = proc_dir.join("stat") and stat_file.file?
+                stats = File.read(stat_file).split
+                puts "Autumn is running!\n\tCommand Line: %s\n\tVirtual Size: %s\n\tStarted: %s\n\tExec Path: %s\n\tStatus: %s" % [
+                  File.read(proc_dir.join("cmdline")).split("\000").join(" "),
+                  "%s k" % (stats[22].to_f / 1024),
+                  File.mtime(proc_dir),
+                  File.readlink(proc_dir.join("exe")),
+                  stats[2]
+                ]
+                exit
+              end
+            end
+            # Fallthrough status, just print a ps
+            puts "Autumn process #{pid} is running!"
+            begin
+              puts %x{ps l #{pid}}
+            rescue
+              puts "No further information available"
+            end
+          end
+        end # }}}
+
+        ### End of command methods }}}
+      end # }}}
+    end
+  end
+end
+
+if $0 == __FILE__
+  Autumn::Tool::Bin::Cmd.run(ARGV)
+end

data/lib/autumn/tool/create.rb

@@ -0,0 +1,48 @@
+#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+require 'autumn/tool/project_creator'
+
+module Autumn
+  module Tool
+
+    # Create is a simple class used to create new projects based on the proto
+    # directory.
+    #
+    # It is primarly used for this command:
+    #
+    #   ramaze --create project
+    #
+    # where project is the directory you want the content put into.
+
+    class Create
+
+      # Default options passed to Create::create
+      #   :proto  is the directory to duplicate
+      #   :amend  no files may be overwritten but missing files will be added
+      #   :force  will overwrite existing files
+      #   :layout copy one subdirectory in +proto+
+
+      DEFAULT = {
+        :proto => File.join(ROOT, 'skel'),
+        :amend => false,
+        :force => false,
+        :layout => '/',
+      }
+
+      # Using ProjectCreator to copy all files and directories from lib/proto
+      # to another location.
+      # +options+ are described in the DEFAULT constant and should be:
+      #   :force  => (true|false|nil)
+      #   :amend  => (true|false|nil)
+      #   :layout => (String|nil)
+      #   :proto  => String
+
+      def self.create(project, options = {})
+        options = DEFAULT.merge(options)
+        creator = ProjectCreator.new(project, options)
+        creator.create
+      end
+    end
+  end
+end

data/lib/autumn/tool/project_creator.rb

@@ -0,0 +1,110 @@
+#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+require 'fileutils'
+require 'find'
+
+class ProjectCreator
+  PROTO = []
+  PROTO << '~/.autumn_skel/' if ENV["HOME"] # Guard against Windows
+  attr_accessor :name, :options
+
+  def initialize(name, options = {})
+    @name, @options = name, options
+  end
+
+  def target
+    File.expand_path(name)
+  end
+
+  def proto
+    PROTO.map!{|pr| File.expand_path(pr) }
+    proto = options[:proto] ||= PROTO.find{|f| File.directory?(f) }
+    layout = options[:layout] ||= '/'
+    File.expand_path(File.join(proto, layout))
+  end
+
+  def create_root?
+    return true unless File.directory?(target)
+    return true if amend? or force?
+    fatal "%p is a directory, choose different project name or use --amend/--force" % target
+  end
+
+  def got_proto?
+    return true if File.directory?(proto)
+    fatal "Cannot create, %p doesn't exist, use --proto or create the proto directory" % proto
+  end
+
+  def create
+    got_proto?
+
+    puts "Found proto at: %p, proceeding...\n\n" % proto
+    mkdir(relate('/')) if create_root?
+    proceed
+  end
+
+  def proceed
+    files, directories = partition{|path| File.file?(path) }
+    proceed_directories(directories)
+    proceed_files(files)
+  end
+
+  def proceed_files(files)
+    files.each{|file| copy(file, relate(file)) }
+  end
+
+  def proceed_directories(dirs)
+    dirs.each{|dir| mkdir(relate(dir)) }
+  end
+
+  def mkdir(dir)
+    exists = File.directory?(dir)
+    return if exists and amend?
+    return if exists and not force?
+    puts "mkdir(%p)" % dir
+    FileUtils.mkdir_p(dir)
+  end
+
+  def copy(from, to)
+    return unless copy_check(to)
+    puts "copy(%p, %p)" % [from, to]
+    FileUtils.cp(from, to)
+    post_process(to)
+  end
+
+  def copy_check(to)
+    exists = File.file?(to)
+    return if exists and amend?
+    return if exists and not force?
+    return true
+  end
+
+  # Think about a useful way to process the generated files it should be
+  # possible to substitute some things like the project name in the
+  # configuration
+
+  def post_process(file)
+    source = File.read(file)
+    File.open(file, 'w+') do |io|
+      io.puts source.gsub('$${project}', @name)
+    end
+  end
+
+  def relate(path)
+    File.join(target, path.to_s.sub(proto, ''))
+  end
+
+  def amend?; options[:amend] end
+  def force?; options[:force] end
+
+  def fatal(message)
+    warn message
+    exit 1
+  end
+
+  def each
+    Dir["#{proto}/**/*"].each{|path| yield(path) }
+  end
+
+  include Enumerable
+end

data/lib/autumn/version.rb

@@ -0,0 +1,3 @@
+module Autumn
+  VERSION = "3.1.1"
+end

data/lib/autumn.rb

@@ -0,0 +1,6 @@
+require "pathname"
+module Autumn
+  ROOT = Pathname.new(__FILE__).dirname.expand_path
+end
+$LOAD_PATH.unshift Autumn::ROOT
+require "autumn/version"