djinn 0.1.1 → 0.1.2

data/README.rdoc

@@ -65,6 +65,10 @@ called _file_djinn.rb_
           end
         end
       end
+      
+      stop do
+        log "Djinn is stopping.."
+      end
 
       exit do
         if @file
@@ -165,53 +169,68 @@ There are a few options available to us if we want to pass configuration informa
 to our Djinn.
 
 First, we can do it using command line switches, which we can define as part of our
-Djinn definition block.
+Djinn definition block. Taken from the example above:
 
   djinn do
   
     configure do
-    
-    end
-    
+      add :output_file do
+        short_switch  "-o"
+        long_switch   "--output-file"
+        description   "File to output stuff to"
+        required      true
+      end
+
+      add_flag :create_file do
+        short_switch  "-c"
+        long_switch   "--create-file"
+        description   "Create output file if it doesn't exist"
+      end
+    end   
+     
   end
-  
-  
-= OMG I LOST INTEREST IN WRITING THIS
 
-(Everything past this point is old shit, will update soon)
- 
+This is pretty straight-forward. The nice thing about doing it like this is that
+these options will show up in the usage banner if you pass the "--help" command line
+argument, or screw something up.
+
+By default the daemon will look for a config YAML file in same directory as you executed 
+it from, named the same as the Djinn class, so in this case *my_djinn.yml*. It will by
+default create the pid and log files in the same way. You can change this by
+putting it in the config file or supplying an options hash:
 
   options = {
     'pid_file_path' => 'path/to/pid/file',
     'log_file_path' => 'path/to/log/file'
   }
   
-  djinn.start(options)
+  MyDjinn.djinnify(options)
 
-Available actions to the *on* method are :start, :stop and :exit
+This also illustrates that you can pass config to the *djinnify* method as well, so now
+you have two additional ways to set configuration values.
 
-The actions are executed in the context of the Djinn itself, so you can
+The actions (start, run, etc) are executed in the context of the Djinn itself, so you can
 get at the config without having to pass it around:
 
   djinn do
-    on :start do
+    start do
       my_setting = config[:omghax]
     end
   end
 
   ...
 
-  djinn.run { :omghax => "Groovy, baby" }
+  djinn.djinnify(:omghax => "Groovy, baby")
   
 You can also give it a block to work with:
 
-  djinn.run do
+  djinn.djinnify do
     puts "This will happen before calling the :start action"
   end
 
 If you need to man-handle the internals and stuff, it yields itself:
 
-  djinn.run do |djinn|
+  djinn.djinnify do |djinn|
     djinn.config[:omghax] = "Groovy, baby"
   end
   
@@ -223,7 +242,7 @@ you check the code out of git, but here's the gist of it. Assumes a scenario
 where you have a Book model that keeps a count of how many times a book has 
 been read..
 
-Create a file in RAILS_ROOT/lib or somewhere similar in your load path:
+Create a file in RAILS_ROOT/lib or somewhere similarly convenient:
 
   require 'djinn/rails'
   require 'eventmachine'
@@ -236,7 +255,7 @@ Create a file in RAILS_ROOT/lib or somewhere similar in your load path:
 
     djinn do
     
-      on :start do
+      start do
         EM.run do
           log "Workers will run every #{BOOK_WORKER_INTERVAL} secs"
           EM::PeriodicTimer.new(BOOK_WORKER_INTERVAL) do
@@ -247,7 +266,7 @@ Create a file in RAILS_ROOT/lib or somewhere similar in your load path:
         end
       end
 
-      on :exit do
+      exit do
         EM.stop
       end
       
@@ -255,20 +274,19 @@ Create a file in RAILS_ROOT/lib or somewhere similar in your load path:
 
   end
 
-Right, now you need to start it somehow. The easiest way is to create a file 
-in RAILS_ROOT/scripts and pop this in it:
+Right, now you need to start it somehow. The easiest way is to create a file, lets
+call it _book_djinn_, in RAILS_ROOT/scripts and pop this in it:
 
   #!/usr/bin/env ruby
   require 'rubygems'
   require File.join(File.dirname(__FILE__), '../lib/book_djinn')
-  BookDjinn.go ARGV
- 
+  BookDjinn.djinnify_rails
+
 Righto, now start it from RAILS_ROOT:
 
   ruby script/book_djinn
   
-Okay, but that defaults to _run_, which starts it in the foreground and also 
-uses the rails development environment by default. Try this:
+This functions exactly like the non-Rails Djinn did. Try this:
 
   ruby script/book_djinn --help
   
@@ -276,16 +294,24 @@ That should give you a better idea of what's going on, then try this:
 
   ruby script/book_djinn start -e production
   
-Yay, we have a daemon running in the background! To stop it:
+Yay, we have a daemon running in the background! As you can see above, the Rails
+implementation automatically adds a switch for the environment for you - this will
+default to _development_ if you don't supply a value for it.
 
-  ruby script/book_djinn stop
+To stop the Djinn:
+
+  ruby script/book_djinn --stop
   
 That gives you more-or-less everything you need to build something basic
 and monitor it with god or a similar process monitor.
 
+Rails Djinns look for their configuration in a different location - the RAILS_ROOT/config
+folder. Similarly they write their logs to your RAILS_ROOT/log folder, rather than
+to the Djinn's home folder.
+
 == TODO
 
-Update this documentation.
+Update this documentation. Make the code cooler.
 
 == Copyright
 

data/VERSION

@@ -1 +1 @@
-0.1.1
+0.1.2

data/djinn.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{djinn}
-  s.version = "0.1.1"
+  s.version = "0.1.2"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Craig Paterson"]
-  s.date = %q{2010-07-30}
+  s.date = %q{2010-08-24}
   s.description = %q{Helper for creating simple custom daemons}
   s.email = %q{darksavant@gmail.com}
   s.extra_rdoc_files = [

data/lib/djinn/base/dsl.rb

@@ -37,11 +37,11 @@ module Djinn
       # Used internally to read configuration blocks
       class ConfigHelper
         
-        attr_accessor :config
+        attr_accessor :config, :config_items
         
         def initialize &block
           @config_items = []
-          instance_eval(&block)
+          instance_eval(&block) if block_given?
         end
         
         # Add a posix-style switch to your Djinn
@@ -56,8 +56,8 @@ module Djinn
         
         # Parses the configuration items created by executing the
         # configuration block
-        def parse_config!(config)
-          opts = OptionParser.new do |opts|
+        def parse_config!(config, &block)
+          options = OptionParser.new do |opts|
             opts.banner = "Usage: djinn_file [OPTIONS]"
             opts.on("--no-daemon", "Don't run in the background") do
               config[:__daemonize] = false
@@ -71,7 +71,8 @@ module Djinn
             end
             @config_items.each { |c| c.parse!(opts, config) }
           end
-          opts.parse!
+          yield options if block_given?
+          options.parse!
           @config_items.each do |ci|
             if ci.required?
               puts "Missing argument: #{ci.key}\n\n#{opts}"
@@ -92,7 +93,7 @@ module Djinn
         
         def initialize t, key, &block
           @type, @key = t, key
-          instance_eval(&block)
+          instance_eval(&block) if block_given?
         end
         
         # Short configuration switch 
@@ -143,7 +144,9 @@ module Djinn
       
         def initialize &block
           @actions = {}
-          instance_eval(&block)
+          instance_eval(&block) if block_given?
+          # create in case there was no configuration block
+          @config_helper = ConfigHelper.new unless defined?(@config_helper)
         end
       
         # Define configuration for a Djinn, adding ARGV switches that
@@ -151,15 +154,7 @@ module Djinn
         def configure &block
           @config_helper = ConfigHelper.new(&block)
         end
-      
-        # Define an action that will be performed by a Djinn
-        def on action, &block
-          acceptable_actions = %w(start stop exit)
-          raise DjinnActionError.new("\"#{action}\" is unrecognized, please use one of: #{acceptable_actions.join(', ')}") \
-            unless acceptable_actions.include?(action.to_s)
-          @actions[action] = block
-        end
-                
+                      
         # Runs when the Djinn starts
         def start &block
           @actions[:start] = block
@@ -175,7 +170,7 @@ module Djinn
           @actions[:stop] = block
         end
         
-        # Preare the Djinn configuration based on informations passed in
+        # Prepare the Djinn configuration based on informations passed in
         # in the configuration block
         def prepare(config)
           @config_helper.parse_config!(config)

data/lib/djinn/rails/handlers.rb

@@ -2,19 +2,38 @@ module Djinn
   module Rails
     module Handlers
       
-      require 'optparse'
-      
-      def djinnify_rails args=[]
-        action = parse_args(args)
-        self.new.__send__(action.intern) do
-          load_rails unless %w(stop restart).include?(action)
+      # Create an instance of your Djinn, interpret any command line switches
+      # defined in your configuration block, loads Rails environment and starts
+      # the Djinn in the background
+      def djinnify_rails config={}
+        djinn = new
+        
+        # handle rails environment
+        env = Djinn::Base::Dsl::ConfigItem.new(:posix, :rails_env)
+        env.short_switch "-e"
+        env.long_switch "--environment"
+        env.description "Run in specific Rails environment"
+        @definition.config_helper.config_items << env
+        
+        @definition.prepare(djinn.config.update(config))
+        
+        unless djinn.config[:__stop]
+          if djinn.config[:__daemonize]
+            djinn.start do
+              ENV["RAILS_ENV"] = djinn.config[:rails_env] || "development"
+              load_rails
+            end
+          else
+            djinn.run do
+              ENV["RAILS_ENV"] = djinn.config[:rails_env] || "development"
+              load_rails
+            end
+          end
+        else
+          djinn.stop
         end
       end
-            
-      def go args=[]
-        djinnify_rails(args)
-      end
-    
+
       private
   
         def load_rails
@@ -22,27 +41,6 @@ module Djinn
           require File.join(RAILS_ROOT, 'config', 'environment')
         end
         
-        def parse_args args
-          action = "run" # this is the default
-          environment = ENV["RAILS_ENV"] || "development"
-          opts = OptionParser.new do |opts|
-            opts.banner = "Usage: djinn_name [options] {start|stop|restart|run}"
-            opts.on("-e", "--environment ENV", "Run in specific Rails environment") do |e|
-              environment = e
-            end
-            opts.on_tail("-h", "--help", "Show this message") do
-              puts opts
-              exit
-            end            
-            action = opts.permute!(args)
-            action = action.first || "run"
-            (puts opts; exit(1)) unless %w(start stop restart run).include?(action)
-          end
-          opts.parse!(args)
-          ENV["RAILS_ENV"] = environment
-          action
-        end
-  
     end
   end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: djinn
 version: !ruby/object:Gem::Version 
-  hash: 25
+  hash: 31
   prerelease: false
   segments: 
   - 0
   - 1
-  - 1
-  version: 0.1.1
+  - 2
+  version: 0.1.2
 platform: ruby
 authors: 
 - Craig Paterson
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-07-30 00:00:00 +02:00
+date: 2010-08-24 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency