daemon-kit 0.1.7.12 → 0.1.8pre

data/lib/daemon_kit/application.rb

@@ -104,7 +104,6 @@ module DaemonKit
       protected
 
       def parse_arguments( args )
-        Arguments.parser_available = true
         DaemonKit.arguments = Arguments.new
         DaemonKit.arguments.parse( args )
       end

data/lib/daemon_kit/arguments.rb

@@ -19,15 +19,10 @@ module DaemonKit
                  'run'
                 ]
 
-    # We don't parse arguments by default
-    @parser_available = false
-
     class << self
 
       attr_reader :default_command, :commands
 
-      attr_accessor :parser_available
-
       # Parse the argument values and return an array with the command
       # name, config values and argument values
       def parse( argv )
@@ -88,7 +83,7 @@ module DaemonKit
             next
           end
 
-          if argv[i] == "--pid"
+          if argv[i] == "--pidfile"
             argv.delete_at( i )
             configs << "pid_file=#{argv.delete_at(i)}"
             next

data/lib/daemon_kit/commands/destroy.rb

@@ -0,0 +1,10 @@
+require 'daemon_kit/generators'
+DaemonKit::Generators.configure!
+
+if ARGV.size == 0
+  DaemonKit::Generators.help
+  exit
+end
+
+name = ARGV.shift
+DaemonKit::Generators.invoke name, ARGV, :behaviour => :revoke, :destination_root => DaemonKit.root

data/lib/daemon_kit/commands/generate.rb

@@ -0,0 +1,10 @@
+require 'daemon_kit/generators'
+DaemonKit::Generators.configure!
+
+if ARGV.size == 0
+  DaemonKit::Generators.help
+  exit
+end
+
+name = ARGV.shift
+DaemonKit::Generators.invoke name, ARGV, :behaviour => :invoke, :destination_root => DaemonKit.root

data/lib/daemon_kit/config.rb

@@ -59,8 +59,13 @@ module DaemonKit
 
     def method_missing( method_name, *args ) #:nodoc:
       unless method_name.to_s =~ /[\w_]+=$/
-        if @data.keys.include?( method_name.to_s )
+        #if @data.keys.include?( method_name.to_s )
+        #  return @data.send( method_name.to_s )
+        #end
+        if @data.respond_to?( method_name.to_s )
           return @data.send( method_name.to_s )
+        elsif @date.respond_to?( method_name.to_s.gsub(/\-/, '_') )
+          return @data.send( method_name.to_s.gsub(/\-/, '_') )
         end
       end
 
@@ -92,7 +97,7 @@ module DaemonKit
     def extend_hash( hash )
       hash.keys.each do |k|
         hash.instance_eval <<-KEY
-          def #{k}
+          def #{k.gsub(/\-/, '_')}
             fetch("#{k}")
           end
         KEY

data/lib/daemon_kit/generators.rb

@@ -0,0 +1,67 @@
+# TODO: Don't always depend on bundled thor
+$:.unshift File.dirname(__FILE__) + '/vendor/thor-0.12.3/lib'
+
+require 'daemon_kit/generators/base'
+
+module DaemonKit
+  module Generators
+    autoload :AppGenerator,         'generators/daemon_kit/app/app_generator'
+    autoload :CucumberGenerator,    'generators/daemon_kit/cucumber/cucumber_generator'
+    autoload :AmqpGenerator,        'generators/daemon_kit/amqp/amqp_generator'
+    autoload :CronGenerator,        'generators/daemon_kit/cron/cron_generator'
+    autoload :CapistranoGenerator,  'generators/daemon_kit/capistrano/capistrano_generator'
+    autoload :NaniteAgentGenerator, 'generators/daemon_kit/nanite_agent/nanite_agent_generator'
+    autoload :SpecGenerator,        'generators/daemon_kit/rspec/rspec_generator'
+    autoload :TestUnitGenerator,    'generators/daemon_kit/test_unit/test_unit_generator'
+    autoload :RuoteGenerator,       'generators/daemon_kit/ruote/ruote_generator'
+    autoload :XmppGenerator,        'generators/daemon_kit/xmpp/xmpp_generator'
+
+    class << self
+
+      def configure!
+      end
+
+      def invoke( namespace, args = ARGV, config = {} )
+        klass_name = constants.detect do |sym|
+          klass = const_get( sym )
+          klass.respond_to?( :namespace ) && klass.namespace == namespace
+        end
+
+        if klass_name.nil?
+          raise Error, "Could not find generator #{namespace}."
+        end
+
+        klass = const_get( klass_name )
+
+        args << '--help' if args.empty? && klass.arguments.any? { |a| a.required? }
+        klass.start( args, config )
+      end
+
+      def help
+        namespaces = constants.inject([]) do |list, sym|
+          unless sym == :Base || sym == :AppGenerator
+            klass = const_get( sym )
+            list << klass.namespace if klass.respond_to?( :namespace )
+          end
+
+          list
+        end
+
+        puts "Usage:"
+        puts "  script/generate GENERATOR [args] [options]"
+        puts
+        puts "General options:"
+        puts "  -h, [--help]     # Print generators options and usage"
+        puts "  -p, [--pretend]  # Run but do not make any changes"
+        puts "  -f, [--force]    # Overwrite files that already exist"
+        puts "  -s, [--skip]     # Skip files that already exist"
+        puts "  -q, [--quiet]    # Supress status output"
+        puts
+        puts "Available generators:"
+
+        namespaces.each { |ns| puts "  " + ns }
+        puts
+      end
+    end
+  end
+end

data/lib/daemon_kit/generators/base.rb

@@ -0,0 +1,60 @@
+require 'thor'
+
+module DaemonKit
+  module Generators
+    class Error < Thor::Error
+    end
+
+    class Base < Thor::Group
+      include Thor::Actions
+
+      add_runtime_options!
+
+      # Tries to get the description from a USAGE file one folder above the source
+      # root otherwise uses a default description.
+      def self.desc(description=nil)
+        return super if description
+        usage = File.expand_path(File.join(source_root, "..", "USAGE"))
+
+        @desc ||= if File.exist?(usage)
+          File.read(usage)
+        else
+          "Description:\n    Create #{base_name.humanize.downcase} files for #{generator_name} generator."
+        end
+      end
+
+      protected
+
+      def app_name
+        @app_name = File.basename( destination_root )
+      end
+
+      # Small macro to add ruby as an option to the generator with proper
+      # default value plus an instance helper method called shebang.
+      #
+      def self.add_shebang_option!
+        class_option :ruby, :type => :string, :aliases => "-r", :default => Thor::Util.ruby_command,
+                            :desc => "Path to the Ruby binary of your choice", :banner => "PATH"
+
+        no_tasks {
+          define_method :shebang do
+            @shebang ||= begin
+              command = if options[:ruby] == Thor::Util.ruby_command
+                "/usr/bin/env #{File.basename(Thor::Util.ruby_command)}"
+              else
+                options[:ruby]
+              end
+              "#!#{command}"
+            end
+          end
+        }
+      end
+
+      def self.namespace(name = nil)
+        return super if name
+        @namespace ||= super.sub(/_generator$/, '').sub(/:generators:/, ':').sub(/^daemon_kit:/, '')
+      end
+
+    end
+  end
+end

data/lib/daemon_kit/initializer.rb

@@ -445,7 +445,7 @@ module DaemonKit
     # arguments to be parsed cause they will interfere with the
     # script encapsulating DaemonKit, like capistrano
     def own_args?
-      Arguments.parser_available
+      !%w( rake cap spec cucumber ).include?( File.basename( $0 ) )
     end
   end
 

data/lib/daemon_kit/jabber.rb

@@ -28,6 +28,7 @@ module DaemonKit
       private :new
 
       def run
+        DaemonKit.logger.warn "Please use the new XMPP daemons, this class is deprecated"
         DaemonKit.logger.info "Starting jabber loop"
 
         loop do

data/lib/daemon_kit/tasks/framework.rake

@@ -76,7 +76,7 @@ namespace :daemon_kit do
   desc "Upgrade your local files for a daemon after upgrading daemon-kit"
   task :upgrade => 'environment' do
     # Run these
-    %w{ initializers rakefile scripts }.each do |t|
+    %w{ initializers rakefile scripts gemfile }.each do |t|
       Rake::Task["daemon_kit:upgrade:#{t}"].invoke
     end
 
@@ -111,6 +111,11 @@ namespace :daemon_kit do
         copy_framework_template( "script", s )
       end
     end
+
+    # Upgrade the Gemfile
+    task :gemfile do
+      copy_framework_template( 'Gemfile' )
+    end
   end
 end
 

data/lib/daemon_kit/vendor/thor-0.12.3/CHANGELOG.rdoc

@@ -0,0 +1,80 @@
+== 0.12, released 2010-01-02
+
+* Removed rr in favor to rspec mock framework
+* Improved output for thor -T
+* [#7] Do not force white color on status
+* [#8] Yield a block with the filename on directory
+
+== 0.11, released 2009-07-01
+
+* Added a rake compatibility layer. It allows you to use spec and rdoc tasks on
+  Thor classes.
+
+* BACKWARDS INCOMPATIBLE: aliases are not generated automatically anymore
+  since it wrong behavior to the invocation system.
+
+* thor help now show information about any class/task. All those calls are
+  possible:
+  
+    thor help describe
+    thor help describe:amazing
+
+  Or even with default namespaces:
+
+    thor help :spec
+
+* Thor::Runner now invokes the default task if none is supplied:
+
+    thor describe # invokes the default task, usually help
+
+* Thor::Runner now works with mappings:
+
+    thor describe -h
+
+* Added some documentation and code refactoring.
+
+== 0.9.8, released 2008-10-20
+
+* Fixed some tiny issues that were introduced lately.
+
+== 0.9.7, released 2008-10-13
+
+* Setting global method options on the initialize method works as expected:
+  All other tasks will accept these global options in addition to their own.
+* Added 'group' notion to Thor task sets (class Thor); by default all tasks
+  are in the 'standard' group. Running 'thor -T' will only show the standard
+  tasks - adding --all will show all tasks. You can also filter on a specific
+  group using the --group option: thor -T --group advanced
+  
+== 0.9.6, released 2008-09-13
+
+* Generic improvements
+
+== 0.9.5, released 2008-08-27
+
+* Improve Windows compatibility
+* Update (incorrect) README and task.thor sample file
+* Options hash is now frozen (once returned)
+* Allow magic predicates on options object. For instance: `options.force?`
+* Add support for :numeric type
+* BACKWARDS INCOMPATIBLE: Refactor Thor::Options. You cannot access shorthand forms in options hash anymore (for instance, options[:f])
+* Allow specifying optional args with default values: method_options(:user => "mislav")
+* Don't write options for nil or false values. This allows, for example, turning color off when running specs.
+* Exit with the status of the spec command to help CI stuff out some.
+
+== 0.9.4, released 2008-08-13
+
+* Try to add Windows compatibility.
+* BACKWARDS INCOMPATIBLE: options hash is now accessed as a property in your class and is not passed as last argument anymore
+* Allow options at the beginning of the argument list as well as the end.
+* Make options available with symbol keys in addition to string keys.
+* Allow true to be passed to Thor#method_options to denote a boolean option.
+* If loading a thor file fails, don't give up, just print a warning and keep going.
+* Make sure that we re-raise errors if they happened further down the pipe than we care about.
+* Only delete the old file on updating when the installation of the new one is a success
+* Make it Ruby 1.8.5 compatible.
+* Don't raise an error if a boolean switch is defined multiple times.
+* Thor::Options now doesn't parse through things that look like options but aren't.
+* Add URI detection to install task, and make sure we don't append ".thor" to URIs
+* Add rake2thor to the gem binfiles.
+* Make sure local Thorfiles override system-wide ones.

data/lib/daemon_kit/vendor/thor-0.12.3/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2008 Yehuda Katz
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/lib/daemon_kit/vendor/thor-0.12.3/README.rdoc

@@ -0,0 +1,234 @@
+= thor
+
+Map options to a class. Simply create a class with the appropriate annotations
+and have options automatically map to functions and parameters.
+
+Example:
+
+    class App < Thor                                                 # [1]
+      map "-L" => :list                                              # [2]
+      
+      desc "install APP_NAME", "install one of the available apps"   # [3]
+      method_options :force => :boolean, :alias => :string           # [4]
+      def install(name)
+        user_alias = options[:alias]
+        if options.force?
+          # do something
+        end
+        # other code
+      end
+      
+      desc "list [SEARCH]", "list all of the available apps, limited by SEARCH"
+      def list(search="")
+        # list everything
+      end
+    end
+
+Thor automatically maps commands as such:
+
+    thor app:install myname --force
+
+That gets converted to:
+
+    App.new.install("myname")
+    # with {'force' => true} as options hash
+
+1. Inherit from Thor to turn a class into an option mapper
+2. Map additional non-valid identifiers to specific methods. In this case, convert -L to :list
+3. Describe the method immediately below. The first parameter is the usage information, and the second parameter is the description
+4. Provide any additional options that will be available the instance method options.
+
+== Types for <tt>method_options</tt>
+
+* :boolean - is parsed as <tt>--option</tt> or <tt>--option=true</tt>
+* :string  - is parsed as <tt>--option=VALUE</tt>
+* :numeric - is parsed as <tt>--option=N</tt>
+* :array   - is parsed as <tt>--option=one two three</tt>
+* :hash    - is parsed as <tt>--option=name:string age:integer</tt>
+
+Besides, method_option allows a default value to be given, examples:
+
+    method_options :force => false
+    #=> Creates a boolean option with default value false
+
+    method_options :alias => "bar"
+    #=> Creates a string option with default value "bar"
+
+    method_options :threshold => 3.0
+    #=> Creates a numeric option with default value 3.0
+
+You can also supply <tt>:option => :required</tt> to mark an option as required. The
+type is assumed to be string. If you want a required hash with default values
+as option, you can use <tt>method_option</tt> which uses a more declarative style:
+
+    method_option :attributes, :type => :hash, :default => {}, :required => true
+
+All arguments can be set to nil (except required arguments), by suppling a no or
+skip variant. For example:
+
+    thor app name --no-attributes
+
+In previous versions, aliases for options were created automatically, but now
+they should be explicit. You can supply aliases in both short and declarative
+styles:
+
+    method_options %w( force -f ) => :boolean
+
+Or:
+
+    method_option :force, :type => :boolean, :aliases => "-f"
+
+You can supply as many aliases as you want.
+
+NOTE: Type :optional available in Thor 0.9.0 was deprecated. Use :string or :boolean instead.
+
+== Namespaces
+
+By default, your Thor tasks are invoked using Ruby namespace. In the example
+above, tasks are invoked as:
+
+    thor app:install name --force
+
+However, you could namespace your class as:
+
+    module Sinatra
+      class App < Thor
+        # tasks
+      end
+    end
+
+And then you should invoke your tasks as:
+
+    thor sinatra:app:install name --force
+
+If desired, you can change the namespace:
+
+    module Sinatra
+      class App < Thor
+        namespace :myapp
+        # tasks
+      end
+    end
+
+And then your tasks hould be invoked as:
+
+    thor myapp:install name --force
+
+== Invocations
+
+Thor comes with a invocation-dependency system as well which allows a task to be
+invoked only once. For example:
+
+    class Counter < Thor
+      desc "one", "Prints 1, 2, 3"
+      def one
+        puts 1
+        invoke :two
+        invoke :three
+      end
+      
+      desc "two", "Prints 2, 3"
+      def two
+        puts 2
+        invoke :three
+      end
+      
+      desc "three", "Prints 3"
+      def three
+        puts 3
+      end
+    end
+
+When invoking the task one:
+
+    thor counter:one
+
+The output is "1 2 3", which means that the three task was invoked only once.
+You can even invoke tasks from another class, so be sure to check the
+documentation.
+
+== Thor::Group
+
+Thor has a special class called Thor::Group. The main difference to Thor class
+is that it invokes all tasks at once. The example above could be rewritten in
+Thor::Group as this:
+
+    class Counter < Thor::Group
+      desc "Prints 1, 2, 3"
+      
+      def one
+        puts 1
+      end
+     
+      def two
+        puts 2
+      end
+      
+      def three
+        puts 3
+      end
+    end
+
+When invoked:
+
+    thor counter
+
+It prints "1 2 3" as well. Notice you should describe (using the method <tt>desc</tt>)
+only the class and not each task anymore. Thor::Group is a great tool to create
+generators, since you can define several steps which are invoked in the order they
+are defined (Thor::Group is the tool use in generators in Rails 3.0).
+
+Besides, Thor::Group can parse arguments and options as Thor tasks:
+
+    class Counter < Thor::Group
+      # number will be available as attr_accessor
+      argument :number, :type => :numeric, :desc => "The number to start counting"
+      desc "Prints the 'number' given upto 'number+2'"
+      
+      def one
+        puts number + 0
+      end
+      
+      def two
+        puts number + 1
+      end
+      
+      def three
+        puts number + 2
+      end
+    end
+
+The counter above expects one parameter and has the folling outputs:
+
+    thor counter 5
+    # Prints "5 6 7"
+
+    thor counter 11
+    # Prints "11 12 13"
+
+You can also give options to Thor::Group, but instead of using <tt>method_option</tt>
+and <tt>method_options</tt>, you should use <tt>class_option</tt> and <tt>class_options</tt>.
+Both argument and class_options methods are available to Thor class as well.
+
+== Actions
+
+Thor comes with several actions which helps with script and generator tasks. You
+might be familiar with them since some came from Rails Templates. They are:
+<tt>say</tt>, <tt>ask</tt>, <tt>yes?</tt>, <tt>no?</tt>, <tt>add_file</tt>,
+<tt>remove_file</tt>, <tt>copy_file</tt>, <tt>template</tt>, <tt>directory</tt>,
+<tt>inside</tt>, <tt>run</tt>, <tt>inject_into_file</tt> and a couple more.
+
+To use them, you just need to include Thor::Actions in your Thor classes:
+
+    class App < Thor
+      include Thor::Actions
+      # tasks
+    end
+
+Some actions like copy file requires that a class method called source_root is
+defined in your class. This is the directory where your templates should be
+placed. Be sure to check the documentation.
+
+== License
+
+See MIT LICENSE.