perennial 0.2.2.2 → 1.0.0.1

data/lib/perennial/generator.rb

@@ -1,6 +1,7 @@
 require 'open-uri'
 require 'fileutils'
 require 'erb'
+require 'readline'
 
 module Perennial
   class Generator
@@ -32,12 +33,46 @@ module Perennial
     def initialize(destination, opts = {})
       @destination_path = destination
       @template_path    = opts[:template_path] || File.join(Settings.library_root, "templates")
-      puts "Starting generator for #{destination}"
+      @silent = !!opts[:silent]
+      describe "Initializing generator in #{destination}"
     end
     
-    def download(from, to)
+    # Helpers for testing file state
+    
+    def fu
+      FileUtils
+    end
+    
+    def chmod(permissions, path)
+      describe "Changing permissions for #{path} to #{permissions}"
+      FileUtils.chmod(permissions, expand_destination_path(path))
+    end
+    
+    def file?(path)
+      describe "Checking if #{path} is a file"
+      File.file?(expand_destination_path(path))
+    end
+    
+    def executable?(path)
+      describe "Checking if #{path} is an executable"
+      File.executable?(expand_destination_path(path))
+    end
+    
+    def directory?(path)
+      describe "Checking if #{path} is a directory"
+      File.directory?(expand_destination_path(path))
+    end
+    
+    alias folder? directory?
+    
+    def exists?(path)
+      describe "Checking if #{path} exists"
+      File.exits?(expand_destination_path(path))
+    end
+    
+    def download(from, to, append = false)
       describe "Downloading #{from}"
-      file to, open(from).read
+      file to, open(from).read, append
     end
     
     def folders(*args)
@@ -47,20 +82,20 @@ module Perennial
       end
     end
     
-    def file(name, contents)
+    def file(name, contents, append = false)
       dest_folder = File.dirname(name)
       folders(dest_folder) unless File.directory?(expand_destination_path(dest_folder))
       describe "Creating file #{name}"
-      File.open(expand_destination_path(name), "w+") do |f|
+      File.open(expand_destination_path(name), "#{append ? "a" : "w"}+") do |f|
         f.write(contents)
       end
     end
     
-    def template(source, destination, environment = {})
+    def template(source, destination, environment = {}, append = false)
       describe "Processing template #{source}"
       raw_template = File.read(expand_template_path(source))
       processed_template = ERB.new(raw_template).result(binding_for(environment))
-      file destination, processed_template
+      file destination, processed_template, append
     end
     
     protected
@@ -82,7 +117,7 @@ module Perennial
     end
     
     def describe(action)
-      puts "- #{action}"
+      puts "[generator] #{action}" unless @silent
     end
     
   end

data/lib/perennial/loader.rb

@@ -53,7 +53,10 @@ module Perennial
     end
     
     def current_controller
-      @current_controller ||= @@controllers[@@current_type.to_sym]
+      @current_controller ||= begin
+        c = @@controllers[@@current_type.to_sym]
+        c.is_a?(String) ? eval(c) : c
+      end
     end
     
     protected
@@ -70,6 +73,7 @@ module Perennial
       handler_directory = Settings.root / "handlers"
       if File.directory?(handler_directory)
         Dir[handler_directory / "**" / "*.rb"].each do |handler|
+          Perennial::Reloading.watch(handler, handler_directory)
           require handler
         end
       end

data/lib/perennial/logger.rb

@@ -5,8 +5,9 @@ module Perennial
     
     cattr_accessor :logger, :log_name
     
-    @@log_name = "perennial.log"
-    @@setup    = false
+    @@log_name            = "perennial.log"
+    @@setup               = false
+    @@default_logger_path = nil
     
     class << self
       
@@ -19,9 +20,18 @@ module Perennial
         setup!
       end
       
+      def default_logger_path=(value)
+        @@default_logger_path = value
+        # Rereun setup if setup is already done.
+        setup! if setup?
+      end
+      
+      def default_logger_path
+        @@default_logger_path || (Settings.root / "log" / @@log_name.to_str)
+      end
+      
       def setup!
-        log_path = Settings.root / "log" / @@log_name.to_str
-        @@logger = new(log_path, Settings.log_level, Settings.verbose?)
+        @@logger = new(self.default_logger_path, Settings.log_level, Settings.verbose?)
         @@setup = true
       end
       

data/lib/perennial/nash.rb

@@ -0,0 +1,217 @@
+require 'yaml'
+module Perennial
+  # A ninja hash. Like OpenStruct, but better
+  class Nash
+    
+    def self.load_file(path)
+      n = self.new
+      if File.file?(path) && File.readable?(path)
+        contents = YAML.load_file(path)
+      end
+      if contents.is_a?(Hash)
+        contents.to_nash
+      else
+        new(:data => contents).normalized
+      end
+    end
+    
+    attr_reader :table
+    
+    def initialize(initial = {})
+      @table = {}
+      initial.to_hash.each_pair { |k,v| self[k] = v }
+    end
+    
+    def [](key)
+      @table[real_key(key)]
+    end
+    
+    def []=(key, *values)
+      @table.send(:[]=, real_key(key), *values)
+    end
+    
+    def respond_to?(name, rec = nil)
+      true
+    end
+    
+    def id
+      self.has_key?(:id) ? self.id : super
+    end
+    
+    def dup
+      Nash.new(self.table)
+    end
+    
+    def to_hash
+      @table.dup
+    end
+    
+    def keys
+      @table.keys
+    end
+    
+    def values
+      @table.values
+    end
+    
+    def has_key?(key)
+      @table.has_key? real_key(key)
+    end
+    
+    def has_value?(value)
+      @table.has_value? value
+    end
+    
+    def each_pair
+      @table.each_pair { |k, v| yield k, v }
+    end
+    
+    def each_key
+      @table.each_key { |k| yield k }
+    end
+    
+    def each_value
+      @table.each_value { |v| yield v }
+    end
+    
+    def delete(key)
+      @table.delete(real_key(key))
+    end
+    
+    def merge!(hash_or_nash)
+      hash_or_nash.to_hash.each_pair do |k, v|
+        self[k] = v
+      end
+      return self
+    end
+    
+    def merge(hash_or_nash)
+      dup.merge! hash_or_nash
+    end
+    
+    def reverse_merge!(hash_or_nash)
+      replace Nash.new(hash_or_nash).merge!(self)
+    end
+    
+    def reverse_merge(hash_or_nash)
+      dup.reverse_merge(hash_or_nash)
+    end
+    
+    def replace(nash)
+      if nash.is_a?(self.class)
+        @table = nash.table
+      else
+        @table = {}
+        nash.to_hash.each_pair { |k, v| self[k] = v }
+      end
+      return self
+    end
+    
+    def blank?
+      @table.blank?
+    end
+    
+    def present?
+      @table.present?
+    end
+     
+    def inspect
+      str = ""
+      if Thread.current[:inspect_stack].nil?
+        Thread.current[:inspect_stack] = [self]
+        str = _inspect
+        Thread.current[:inspect_stack] = nil
+      else
+        if Thread.current[:inspect_stack].include?(self)
+          return "..."
+        else
+          Thread.current[:inspect_stack] << self
+          str = _inspect
+          Thread.current[:inspect_stack].pop
+        end
+      end
+      return str
+    end
+    
+    def _inspect
+      str = "#<Perennial::Nash:#{(object_id * 2).to_s(16)}"
+      if !blank?
+        str << " "
+        str << table.map { |k, v| "#{k}=#{v.inspect}" }.join(", ")
+      end
+      str << ">"
+      return str
+    end
+    
+    def hash
+      @table.hash
+    end
+    
+    def normalized(n = nil)
+      item = nil
+      if Thread.current[:normalized].nil?
+        n = self.class.new
+        Thread.current[:normalized] = {self => n}
+        item = normalize_nash(n)
+        Thread.current[:normalized] = nil
+      else
+        if Thread.current[:normalized].has_key?(self)
+          return Thread.current[:normalized][self]
+        else
+          n = self.class.new
+          Thread.current[:normalized][self] = n
+          item = normalize_nash(n)
+        end
+      end
+      item
+    end
+     
+    protected
+    
+    def normalize_nash(n = self.class.new)
+      each_pair do |k, v|
+        n[k] = normalize_item(v)
+      end
+      return n
+    end
+    
+    def normalize_item(i)
+      case i
+      when Hash
+        self.class.new(i).normalized
+      when Array
+        i.map { |v| normalize_item(v) }
+      when self.class
+        i.normalized
+      else
+        i
+      end
+    end
+    
+    def method_missing(name, *args, &blk)
+      name = name.to_s
+      case name.to_s[-1]
+      when ??
+        self[name[0..-2]].present?
+      when ?=
+        send(:[]=, real_key(name[0..-2]), *args)
+      when ?!
+        self[name[0..-2]] = self.class.new
+      else
+        self[name]
+      end
+    end
+    
+    def real_key(name)
+      name.to_sym
+    end
+    
+    
+  end
+end
+
+class Hash
+  def to_nash
+    Perennial::Nash.new(self)
+  end
+end

data/lib/perennial/option_parser.rb

@@ -52,9 +52,9 @@ module Perennial
     def add_defaults!
       return if defined?(@defaults_added) && @defaults_added
       logger_levels = Logger::LEVELS.keys.map { |k| k.to_s }
-      add(:daemon, 'Runs this application as a daemon') { Settings.daemon = true }
-      add(:verbose, 'Runs this application verbosely, writing to STDOUT') { Settings.verbose = true }
-      add(:log_level, "Sets this applications log level, one of: #{logger_levels.join(", ")}") do |level|
+      add(:daemon, 'Runs this application as a daemon', :shortcut => "d") { Settings.daemon = true }
+      add(:verbose, 'Runs this application verbosely, writing to STDOUT', :shortcut => "v") { Settings.verbose = true }
+      add(:log_level, "Sets this applications log level, one of: #{logger_levels.join(", ")}", :shortcut => "l") do |level|
         if logger_levels.include?(level)
           Settings.log_level = level.to_sym
         else

data/lib/perennial/reloading.rb

@@ -0,0 +1,45 @@
+module Perennial
+  class Reloading
+    
+    cattr_accessor :mapping, :mtimes
+    self.mapping = {}
+    self.mtimes = {}
+    
+    def self.watch(file, relative_to = File.dirname(file))
+      file = File.expand_path(file)
+      raise ArgumentError, "You must provide the path to a file" unless File.file?(file)
+      relative = file.gsub(/^#{File.expand_path(relative_to)}\//, '')
+      name = relative.gsub(/\.rb$/, '').split("/").map { |part|part.camelize }.join("::")
+      self.mapping[name] = file
+      self.mtimes[file] = File.mtime(file)
+    end
+    
+    def self.reload!
+      self.mapping.each_pair do |constant, file|
+        next unless File.mtime(file) > self.mtimes[file]
+        begin
+          # Get a relative name and namespace
+          parts = constant.split("::")
+          name = parts.pop
+          ns = parts.inject(Object) { |a, c| a.const_get(c) }
+          # Notify object pre-reload.
+          final = ns.const_get(name)
+          final.reloading! if final.respond_to?(:reloading!)
+          final = nil
+          # Remove the constant
+          ns.send(:remove_const, name)
+          load(file)
+          # Notify the object it was reloaded...
+          final = ns.const_get(name)
+          final.reloaded! if final.respond_to?(:reloaded!)
+          # Finally, update the mtime
+          self.mtimes[file] = File.mtime(file)
+        rescue Exception => e
+          logger.fatal "Exception reloading #{file} (for #{constant})"
+          Perennial::ExceptionTracker.log(e)
+        end
+      end
+    end
+    
+  end
+end

data/lib/perennial/settings.rb

@@ -4,10 +4,13 @@ module Perennial
   class Settings
     
     cattr_accessor :configuration, :log_level, :verbose, :daemon
-                   
-    @@verbose   = false
-    @@log_level = :info
-    @@daemon    = false
+  
+    @@configuration         = Perennial::Nash.new
+    @@verbose               = false
+    @@log_level             = :info
+    @@daemon                = false
+    @@default_settings_path = nil
+    @@lookup_key_path       = ["default"]
     
     class << self
       
@@ -39,57 +42,82 @@ module Perennial
         @@setup ||= false
       end
       
+      def default_settings_path
+        @@default_settings_path || (root / "config" / "settings.yml")
+      end
+      
+      def default_settings_path=(value)
+        @@default_settings_path = value
+        setup! if setup?
+      end
+      
+      def lookup_key_path
+        @@lookup_key_path ||= []
+      end
+      
+      def lookup_key_path=(value)
+        @@lookup_key_path = value
+      end
+      
       def setup(options = {})
         self.setup!(options) unless setup?
       end
       
       def setup!(options = {})
-        @@configuration = {}
-        settings_file = root / "config" / "settings.yml"
+        @@configuration ||= Perennial::Nash.new
+        settings_file = self.default_settings_path
         if File.exist?(settings_file)
           loaded_yaml = YAML.load(File.read(settings_file))
-          @@configuration.merge! loaded_yaml["default"]
+          @@configuration.merge!(lookup_settings_from(loaded_yaml))
         end
         @@configuration.merge! options
-        @@configuration.symbolize_keys!
-        # Generate a module 
-        mod = generate_settings_accessor_mixin
-        extend  mod
-        include mod
+        # Finally, normalize settings
+        @@configuration = @@configuration.normalized
         @@setup = true
       end
       
-      def [](key)
-        self.setup
-        return self.configuration[key.to_sym]
+      def update!(attributes = {})
+        return if attributes.blank?
+        settings_file = self.default_settings_path
+        settings = File.exist?(settings_file) ? YAML.load(File.read(settings_file)) : {}
+        namespaced_settings = lookup_settings_from(settings)
+        namespaced_settings.merge! attributes.stringify_keys
+        File.open(settings_file, "w+") { |f| f.write(settings.to_yaml) }
+        setup!
+        return true
       end
       
-      def []=(key, value)
-        self.setup
-        self.configuration[key.to_sym] = value
-        return value
+      def to_hash
+        @@configuration.to_hash
       end
       
-      def to_hash
-        self.configuration.dup
+      def method_missing(name, *args, &blk)
+        self.setup! unless self.setup?
+        @@configuration.send(name, *args, &blk)
+      end
+      
+      def respond_to?(name, rec = nil)
+        true
       end
       
       protected
       
-      def generate_settings_accessor_mixin
-        Module.new do
-          Settings.configuration.keys.each do |k|
-            define_method(k) do
-              return Settings.configuration[k]
-            end
-            define_method("#{k}=") do |val|
-              Settings.configuration[k] = val
-            end
-          end
+      def lookup_settings_from(settings_hash)
+        lookup_key_path.inject(settings_hash) do |h, k|
+          h[k.to_s] ||= {} 
         end
       end
       
     end
+    
+    def method_missing(name, *args, &blk)
+      self.class.setup
+      @@configuration.send(name, *args, &blk)
+    end
+    
+    def respond_to?(name, rec = nil)
+      true
+    end
 
   end
 end

data/lib/perennial.rb

@@ -1,6 +1,7 @@
 # Append the perennial lib folder onto the load path to make it
 # nicer to require perennial-related libraries.
-$LOAD_PATH.unshift(File.dirname(__FILE__))
+perennial_dir = File.dirname(__FILE__)
+$LOAD_PATH.unshift(perennial_dir) unless $LOAD_PATH.include?(perennial_dir)
 
 require 'pathname'
 require 'perennial/core_ext'
@@ -8,11 +9,12 @@ require 'perennial/exceptions'
 
 module Perennial
   
-  VERSION = "0.2.2.2"
+  VERSION = "1.0.0.1"
   
-  has_libary :dispatchable, :hookable, :loader, :logger,
-             :loggable, :manifest, :settings, :argument_parser,
-             :option_parser, :application, :generator, :daemon
+  has_library :dispatchable, :hookable, :loader, :logger, :nash,
+              :loggable, :manifest, :settings, :argument_parser,
+              :option_parser, :application, :generator, :daemon,
+              :delegateable, :reloading
   
   def self.included(parent)
     parent.extend(Manifest::Mixin)

data/templates/application.erb

@@ -1,4 +1,5 @@
-$LOAD_PATH.unshift(File.dirname(__FILE__))
+lib_path = File.dirname(__FILE__)
+$LOAD_PATH.unshift(lib_path) unless $LOAD_PATH.include?(lib_path)
 require 'perennial'
 
 module <%= @application_module %>
@@ -7,7 +8,7 @@ module <%= @application_module %>
   VERSION = "0.0.1"
   
   manifest do |m, l|
-    Settings.root = File.dirname(__FILE__)
+    Settings.root = __FILE__.to_pathname.dirname.dirname
     # Initialize your controllers, e.g:
     # l.register_controller :client, <%= @application_module %>::Client
   end

data/templates/rakefile.erb

@@ -26,6 +26,7 @@ task :gemspec do
     s.summary  = ""
     s.files    = FileList["{bin,vendor,lib,test}/**/*"].to_a
     s.platform = Gem::Platform::RUBY
+    s.add_dependency "Sutto-perennial", ">= <%= Perennial::VERSION %>"
   end
   File.open("<%= @application_path %>.gemspec", "w+") { |f| f.puts spec.to_ruby }
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: perennial
 version: !ruby/object:Gem::Version 
-  version: 0.2.2.2
+  version: 1.0.0.1
 platform: ruby
 authors: 
 - Darcy Laycock
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-08-09 00:00:00 +08:00
+date: 2009-09-25 00:00:00 +08:00
 default_executable: perennial
 dependencies: []
 
@@ -23,19 +23,17 @@ extra_rdoc_files: []
 
 files: 
 - bin/perennial
-- vendor/fakefs/lib/fakefs.rb
-- vendor/fakefs/LICENSE
-- vendor/fakefs/Rakefile
-- vendor/fakefs/README.markdown
-- vendor/fakefs/test/fakefs_test.rb
-- vendor/fakefs/test/verify.rb
 - lib/perennial/application.rb
 - lib/perennial/argument_parser.rb
 - lib/perennial/core_ext/attribute_accessors.rb
 - lib/perennial/core_ext/blank.rb
+- lib/perennial/core_ext/hash_key_conversions.rb
+- lib/perennial/core_ext/inflections.rb
 - lib/perennial/core_ext/misc.rb
+- lib/perennial/core_ext/proxy.rb
 - lib/perennial/core_ext.rb
 - lib/perennial/daemon.rb
+- lib/perennial/delegateable.rb
 - lib/perennial/dispatchable.rb
 - lib/perennial/exceptions.rb
 - lib/perennial/generator.rb
@@ -44,23 +42,18 @@ files:
 - lib/perennial/loggable.rb
 - lib/perennial/logger.rb
 - lib/perennial/manifest.rb
+- lib/perennial/nash.rb
 - lib/perennial/option_parser.rb
+- lib/perennial/reloading.rb
 - lib/perennial/settings.rb
 - lib/perennial.rb
-- test/dispatchable_test.rb
-- test/hookable_test.rb
-- test/loader_test.rb
-- test/loggable_test.rb
-- test/logger_test.rb
-- test/settings_test.rb
-- test/test_helper.rb
 - templates/application.erb
 - templates/boot.erb
 - templates/rakefile.erb
 - templates/setup.erb
 - templates/test.erb
 - templates/test_helper.erb
-has_rdoc: true
+has_rdoc: false
 homepage: http://sutto.net/
 licenses: []
 
@@ -84,7 +77,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.5
+rubygems_version: 1.3.2
 signing_key: 
 specification_version: 3
 summary: A simple (generally event-oriented) application library for Ruby