waves 0.7.7 → 0.8.0

data/lib/mapping/pretty_urls.rb

@@ -1,96 +0,0 @@
-module Waves
-  module Mapping
-
-    # A set of pre-packed mapping rules for dealing with pretty URLs (that use names instead
-    # of numbers to identify resources). There are two modules.
-    # - GetRules, which defines all the GET methods for dealing with named resources
-    # - RestRules, which defines add, update, and delete rules using a REST style interface
-    #
-    module PrettyUrls
-
-      #
-      # GetRules defines the following URL conventions:
-      #
-      #   /resources            # => get a list of all instances of resource
-      #   /resource/name        # => get a specific instance of resource with the given name
-      #   /resource/name/editor # => display an edit page for the given resource
-      #
-      module GetRules
-
-        def self.included(target)
-
-          target.module_eval do
-
-            extend Waves::Mapping
-
-            name = '([\w\-\_\.\+\@]+)'; model = '([\w\-]+)'
-
-            # get all resources for the given model
-            path %r{^/#{model}/?$}, :method => :get do | model |
-              resource( model.singular ) { controller { all } | view { |data| list( model => data ) } }
-            end
-
-            # get the given resource for the given model
-            path %r{^/#{model}/#{name}/?$}, :method => :get do | model, name |
-              resource( model ) { controller { find( name ) } | view { |data| show( model => data ) } }
-            end
-
-            # display an editor for the given resource / model
-            path %r{^/#{model}/#{name}/editor/?$}, :method => :get do | model, name |
-              resource( model ) {  controller { find( name ) } | view { |data| editor( model => data ) } }
-            end
-
-          end
-
-        end
-
-      end
-
-      #
-      # RestRules defines the following URL conventions:
-      #
-      #   POST /resources            # => add a new resource
-      #   PUT  /resource/name        # => update the given resource
-      #   DELETE /resource/name      # => delete the given resource
-      #
-      module RestRules
-
-        def self.included(target)
-
-          target.module_eval do
-
-            extend Waves::Mapping
-
-            name = '([\w\-\_\.\+\@]+)'; model = '([\w\-]+)'
-
-            # create a new resource for the given model
-            path %r{^/#{model}/?$}, :method => :post do | model |
-              resource( model.singular ) do
-                controller do 
-                  instance = create
-                  redirect( "/#{model_name}/#{instance.name}/editor" )
-                end
-              end
-            end
-
-            # update the given resource for the given model
-            path %r{^/#{model}/#{name}/?$}, :method => :put do | model, name |
-              resource( model ) { controller { update( name ); redirect( url ) }  }
-            end
-
-            # delete the given resource for the given model
-            path %r{^/#{model}/#{name}/?$}, :method => :delete do | model, name |
-              resource( model ) { controller { delete( name ) } }
-            end
-
-          end
-
-        end
-
-      end
-
-    end
-
-  end
-
-end

data/lib/renderers/markaby.rb

@@ -1,33 +0,0 @@
-require 'markaby'
-
-::Markaby::Builder.set( :indent, 2 )
-
-module Waves
-
-  module Renderers
-
-    class Markaby
-
-      include Renderers::Mixin
-
-      extension :mab
-
-      # capture needed here for content fragments, otherwise
-      # you'll just get the last tag's output ...
-      # def self.capture( template )
-      #  "capture { #{template} }"
-      # end
-
-      def self.render( path, assigns )
-        builder = ::Markaby::Builder.new( assigns )
-        helper = helper( path )
-        builder.meta_eval { include( helper ) }
-        builder.instance_eval( template( path ) )
-        builder.to_s
-      end
-
-    end
-
-  end
-
-end

data/lib/runtime/application.rb

@@ -1,69 +0,0 @@
-# See the README for an overview.
-module Waves
-
-  class << self
-
-    # Access the principal Waves application.
-    attr_reader :application
-
-    # Register a module as a Waves application.
-    def << ( app )
-      @application = app if Module === app
-    end
-
-    def instance ; Waves::Application.instance ; end
-
-    def method_missing(name,*args,&block)
-      instance.send(name,*args,&block)
-    end
-
-  end
-
-  # An application in Waves is anything that provides access to the Waves
-  # runtime and the registered Waves applications. This includes both
-  # Waves::Server and Waves::Console. Waves::Application is *not* the actual
-  # application module(s) registered as Waves applications. To access the
-  # main Waves application, you can use +Waves+.+application+.
-  class Application
-
-    class << self; attr_accessor :instance; end
-
-    # Accessor for options passed to the application.
-    attr_reader :options
-
-    # Create a new Waves application instance.
-    def initialize( options={} )
-      @options = options
-      Dir.chdir options[:directory] if options[:directory]
-      Application.instance = self
-      Kernel.load( :lib / 'application.rb' ) if Waves.application.nil?
-    end
-
-    def synchronize( &block )
-      ( @mutex ||= Mutex.new ).synchronize( &block )
-    end
-
-    # The 'mode' of the application determines which configuration it will run under.
-    def mode
-      @mode ||= @options[:mode]||:development
-    end
-    
-    # Debug is true if debug is set to true in the current configuration.
-    def debug? ; config.debug ; end
-
-    # Access the current configuration. *Example:* +Waves::Server.config+
-    def config
-      Waves.application.configurations[ mode ]
-    end
-
-    # Access the mappings for the application.
-    def mapping ; Waves.application.configurations[ :mapping ] ; end
-
-    # Reload the modules specified in the current configuration.
-    def reload ; config.reloadable.each { |mod| mod.reload } ; end
-
-    # Returns the cache set for the current configuration
-    def cache ; config.cache ; end
-  end
-
-end

data/lib/runtime/blackboard.rb

@@ -1,57 +0,0 @@
-module Waves
-
-  # Encapsulates the blackboard associated with a given request. The scope of the blackboard is
-  # the same as the request object it gets attached to.
-  #
-  # The Waves blackboard is a very simple shared storaged usable during the request processing.
-  # It is available within:
-  #    - mappings
-  #    - controllers
-  #    - helpers
-  #
-  # Adding a value:
-  #   blackboard.value1 = 1
-  #   blackboard[:value2] = 2
-  #
-  # Retrieving values
-  #   blackboard.value1
-  #   blackboard[:value2]
-  #
-  # see also blackboard_verify.rb  
-  
-  class Blackboard
-
-    # Create a new blackboard object using the given request.
-    def initialize( request )
-      @request = request
-      @data = {}
-    end
-
-    # Access a given data element of the blackboard using the given key.
-    def [](key)
-      @data[key]
-    end
-
-    # Set the given data element of the blackboard using the given key and value.
-    def []=(key,val)
-      @data[key] = val
-    end
-    
-    def each(&block)
-      @data.each(&block)
-    end
-
-    # also allow things like
-    # blackboard.test1 instead of blackboard[:test1]
-    # blackboard.test1 = 2 instead of blackboard[:test1] = 2
-    def method_missing(name,*args)
-      if (name.to_s =~ /=$/)
-        self[name.to_s.gsub('=', '')] = args[0]
-      else
-        self[name.to_s]
-      end
-    end
-
-  end
-  
-end

data/lib/runtime/debugger.rb

@@ -1,9 +0,0 @@
-module Kernel
-  unless respond_to?(:debugger)
-    # Starts a debugging session if ruby-debug has been loaded (call waves-server --debugger to do load it).
-    def debugger
-      puts "debugger called"
-      Waves::Logger.info "\n***** Debugger requested, but was not available: Start server with --debugger to enable *****\n"
-    end
-  end
-end

data/lib/runtime/response_proxy.rb

@@ -1,30 +0,0 @@
-module Waves
-
-  # Mapping actions are evaluated in the context of a ResponseProxy.
-  class ResponseProxy
-
-    attr_reader :request
-
-    include ResponseMixin
-
-    def initialize(request)
-      @request = request
-    end
-
-    def resource( resource, &block )
-      @resource = resource; yield.call
-    end
-
-    def controller( &block )
-      lambda { Waves.application.controllers[ @resource ].process( @request, &block ) }
-    end
-
-    def view( &block )
-      lambda { |val| Waves.application.views[ @resource ].process( @request, val, &block ) }
-    end
-
-    def redirect(path, status = '302'); @request.redirect(path, status); end
-
-  end
-
-end

data/lib/tasks/cluster.rb

@@ -1,26 +0,0 @@
-namespace :cluster do
-
-  desc 'Start a cluster of waves applications.'
-  task :start do |task|
-    using_waves_src = defined?(WAVES) || ENV['WAVES'] || File.exist?( File.dirname(__FILE__) / :waves )
-    script = using_waves_src ? :bin / 'waves-server' : 'waves-server'
-    ( Waves::Console.config.ports || [ Waves::Console.config.port ] ).each do |port|
-      cmd = "#{script} -p #{port} -c #{ENV['mode']||'development'} -d"
-      puts cmd ; `#{cmd}`
-    end
-  end
-
-  desc 'Stop a cluster of waves applications.'
-  task :stop do |task|
-     Dir[ :log / '*.pid' ].each do |pidfile|
-       pid = File.read(pidfile).to_i
-       puts "Stopping process #{pid} ..."
-       Process.kill( 'INT', pid ) rescue nil
-    end
-  end
-
-  desc 'Restart a cluster of waves applications.'
-  task :restart => [ :stop, :start ] do |task|
-  end
-
-end

data/lib/utilities/inflect.rb

@@ -1,110 +0,0 @@
-# Much love to Facets (more specifically English) for this module
-# http://english.rubyforge.org/
-# changed slightly in the hopes of one day implementing a different set
-# of rules for different languages
-# NOTE: this is NOT implemented yet.
-# plural and singular work directly with the English class
-module Waves
-  module Inflect # :nodoc:
-    module InflectorMethods
-      
-      # Define a general exception.
-      def word(singular, plural=nil)
-        plural = singular unless plural
-        singular_word(singular, plural)
-        plural_word(singular, plural)
-      end
-
-      # Define a singularization exception.
-      def singular_word(singular, plural)
-        @singular_of ||= {}
-        @singular_of[plural] = singular
-      end
-
-      # Define a pluralization exception.
-      def plural_word(singular, plural)
-        @plural_of ||= {}
-        @plural_of[singular] = plural
-      end
-
-      # Define a general rule.
-      def rule(singular, plural)
-        singular_rule(singular, plural)
-        plural_rule(singular, plural)
-      end
-
-      # Define a singularization rule.
-      def singular_rule(singular, plural)
-        (@singular_rules ||= []) << [singular, plural]
-      end
-
-      # Define a plurualization rule.
-      def plural_rule(singular, plural)
-        (@plural_rules ||= []) << [singular, plural]
-      end
-
-      # Read prepared singularization rules.
-      def singularization_rules
-        @singular_rules ||= []
-        return @singularization_rules if @singularization_rules
-        sorted = @singular_rules.sort_by{ |s, p| "#{p}".size }.reverse
-        @singularization_rules = sorted.collect do |s, p|
-          [ /#{p}$/, "#{s}" ]
-        end
-      end
-
-      # Read prepared pluralization rules.
-      def pluralization_rules
-        @plural_rules ||= []
-        return @pluralization_rules if @pluralization_rules
-        sorted = @plural_rules.sort_by{ |s, p| "#{s}".size }.reverse
-        @pluralization_rules = sorted.collect do |s, p|
-          [ /#{s}$/, "#{p}" ]
-        end
-      end
-
-      #
-      def plural_of
-        @plural_of ||= {}
-      end
-
-      #
-      def singular_of
-        @singular_of ||= {}
-      end
-
-      # Convert an English word from plural to singular.
-      #
-      #   "boys".singular      #=> boy
-      #   "tomatoes".singular  #=> tomato
-      #
-      def singular(word)
-        if result = singular_of[word]
-          return result.dup
-        end
-        result = word.dup
-        singularization_rules.each do |(match, replacement)|
-          break if result.gsub!(match, replacement)
-        end
-        return result
-      end
-
-      # Convert an English word from singular to plurel.
-      #
-      #   "boy".plural     #=> boys
-      #   "tomato".plural  #=> tomatoes
-      #
-      def plural(word)
-        if result = plural_of[word]
-          return result.dup
-        end
-        #return self.dup if /s$/ =~ self # ???
-        result = word.dup
-        pluralization_rules.each do |(match, replacement)|
-          break if result.gsub!(match, replacement)
-        end
-        return result
-      end
-    end
-  end
-end

data/lib/utilities/module.rb

@@ -1,21 +0,0 @@
-module Waves
-  module Utilities
-    module Module
-      # This comes in handy when you are trying to do meta-programming with modules / classes
-      # that may be nested within other modules / classes. I think I've seen it defined in
-      # facets, but I'm not relying on facets just for this one method.
-      def basename
-        self.name.split('::').last || ''
-      end
-
-      # Just a convenience method for accessing a const within a Module
-      def []( cname )
-        const_get( cname.to_s.camel_case )
-      end
-    end
-  end  
-end
-
-class Module # :nodoc:
-  include Waves::Utilities::Module
-end