waves 0.7.7 → 0.8.0

data/lib/commands/waves-console.rb

@@ -1,21 +0,0 @@
-require 'choice'
-
-Choice.options do
-  header 'Run waves in console mode.'
-  header ''
-  option :mode do
-    short '-c'
-    long '--config=CONFIG'
-    desc 'Configuration to use.'
-    desc 'Defaults to development.'
-    cast Symbol
-  end
-  separator ''
-end
-
-console = Waves::Console.load( Choice.choices )
-Object.send(:define_method, :waves) { console }
-require 'irb'
-require 'irb/completion'
-ARGV.clear
-IRB.start

data/lib/controllers/base.rb

@@ -1,11 +0,0 @@
-module Waves
-  module Controllers
-    class Base
-
-      include Waves::Controllers::Mixin
-
-      def attributes; params[model_name.singular.intern]; end
-
-    end
-  end
-end

data/lib/controllers/mixin.rb

@@ -1,165 +0,0 @@
-module Waves
-
-  #
-  # Controllers in Waves are simply classes that provide a request / response
-  # context for operating on a model. While models are essentially just a way
-  # to manage data in an application, controllers manage data in response to
-  # a request. For example, a controller updates a model instance using
-  # parameters from the request.
-  #
-  # Public controller methods simply return data (a resource), if necessary, that
-  # can be then used by views to determine how to render that data.
-  # Controllers do not determine which view will be invoked. They are
-  # independent of the view; one controller method might be suitable for
-  # several different views. In some cases, controllers can choose to
-  # directly modify the response and possibly even short-circuit the view
-  # entirely. A good example of this is a redirect.
-  #
-  # Controllers, like Views and Mappings, use the Waves::ResponseMixin to
-  # provide a rich context for working with the request and response objects.
-  # They can even call other controllers or views using the controllers method.
-  # In addition, they provide some basic reflection (access to the model and
-  # model_name that corresponds to the class name for the given model) and
-  # automatic parameter destructuring. This allows controller methods to access
-  # the request parameters as a hash, so that a POST variable named
-  # <tt>entry.title</tt> is accessed as <tt>params[:entry][:title]</tt>.
-  #
-  # Controllers often do not have to be explicitly defined. Instead, one or more
-  # default controllers can be defined that are used as exemplars for a given
-  # model. By default, the +waves+ command generates a single default, placed in
-  # the application's <tt>controllers/default.rb</tt> file. This can be modified
-  # to change the default behavior for all controllers. Alternatively, the
-  # <tt>rake generate:controller</tt> command can be used to explicitly define a
-  # controller.
-  #
-  # As an example, the code for the default controller is below for the Blog application.
-  #
-  #   module Blog
-  #     module Controllers
-  #       class Default
-  #
-  #         # Pick up the default controller methods, like param, url, etc.
-  #         include Waves::Controllers::Mixin
-  #
-  #         # This gets me the parameters associated with this model
-  #         def attributes; params[model_name.singular.intern]; end
-  #
-  #         # A simple generic delegator to the model
-  #         def all; model.all; end
-  #
-  #         # Find a specific instance based on a name or raise a 404
-  #         def find( name ); model[ :name => name ] or not_found; end
-  #
-  #         # Create a new instance based on the request params
-  #         def create; model.create( attributes ); end
-  #
-  #         # Update an existing record. find will raise a 404 if not found.
-  #         def update( name )
-  #           instance = find( name )
-  #           instance.set( attributes )
-  #           instance.save_changes
-  #         end
-  #
-  #         # Find and delete - or will raise a 404 if it doesn't exist
-  #         def delete( name ); find( name ).destroy; end
-  #
-  #       end
-  #     end
-  #   end
-  #
-  # Since the mapping file handles "glueing" controllers to views, controllers
-  # don't have to be at all concerned with views. They don't have to set
-  # instance variables, layouts, or contain logic to select the appropriate
-  # view based on the request. All they do is worry about updating the model
-  # when necessary based on the request.
-
-  module Controllers
-
-    #
-    # Waves::Controllers::Mixin adapts a controller class for use in mappings and provides utility methods.     
-    # It is included in controllers autocreated by the Default foundation, so you do not need to include
-    # it in subclasses of the same. 
-    #
-    # The utility methods include simple reflection to allow controller methods
-    # to be written generically (i.e., without reference to a specific model) and
-    # parameter destructuring for the request parameters.
-    #
-
-    module Mixin
-
-      attr_reader :request
-
-      include Waves::ResponseMixin
-
-      # When this mixin is included it adds a class method named +process+,
-      # which accepts a request object and a block. The +process+ method initializes the
-      # controller with the request, then evaluates the block using +instance_eval+. This allows the
-      # controller to be used from within a mapping lambda (i.e. a ResponseProxy).
-
-      def self.included( mod )
-        def mod.process( request, &block )
-          self.new( request ).instance_eval( &block )
-        end
-      end
-
-      def initialize( request )
-        @request = request
-      end
-
-      # The params variable is taken from the request object and "destructured", so that
-      # a parameter named 'blog.title' becomes:
-      #
-      #   params['blog']['title']
-      #
-      # If you want to access the original parameters object, you can still do so using
-      # +request.params+ instead of simply +params+.
-      def params; @params ||= destructure(request.params); end
-
-      # Returns the name of the model corresponding to this controller by taking the basename
-      # of the module and converting it to snake case. If the model plurality is different than
-      # the controller, this will not, in fact, be the model name.
-      def model_name; self.class.basename.snake_case; end
-
-      # Returns the model corresponding to this controller by naively assuming that 
-      # +model_name+ must be correct. This allows you to write generic controller methods such as:
-      #
-      #   model.find( name )
-      #
-      # to find an instance of a given model. Again, the plurality of the controller and
-      # model must be the same for this to work.
-      def model; Waves.application.models[ model_name.intern ]; end
-
-      private
-
-      def destructure( hash )
-        destructured = {}
-        hash.keys.map { |key| key.split('.') }.each do |keys|
-          destructure_with_array_keys(hash, '', keys, destructured)
-        end
-        destructured
-      end
-
-      def destructure_with_array_keys( hash, prefix, keys, destructured )
-        if keys.length == 1
-          key = "#{prefix}#{keys.first}"
-          val = hash[key]
-          destructured[keys.first.intern] = case val
-          when String
-            val.strip
-          when Hash
-            val
-          when nil
-            raise key.inspect
-          end
-        else
-          destructured = ( destructured[keys.first.intern] ||= {} )
-          new_prefix = "#{prefix}#{keys.shift}."
-          destructure_with_array_keys( hash, new_prefix, keys, destructured )
-        end
-      end
-
-    end
-
-  end
-
-end

data/lib/foundations/default.rb

@@ -1,27 +0,0 @@
-module Waves
-  module Foundations
-# The Default foundation supports the common MVC development pattern, a la Rails and Merb. Models, controllers, views, templates, and helpers live in the corresponding directories. When your code calls for a specific M, V, C, or H, Waves tries to load it from a file matching the snake-case of the constant name.  If the file does not exist, Waves creates the constant from a sensible (and customizable) default.
-#
-# This foundation does not include any ORM configuration.  You can include Waves::Layers::ORM::Sequel or custom configure your model.
-
-    
-    module Default
-
-      def self.included( app )
-
-        app.instance_eval do
-
-          include Waves::Layers::Inflect::English
-          include Waves::Layers::Simple
-          include Waves::Layers::MVC          
-          include Waves::Layers::DefaultErrors
-          
-        end
-        
-        Waves << app
-        
-      end
-    end
-  end
-end
-

data/lib/foundations/simple.rb

@@ -1,30 +0,0 @@
-module Waves
-  
-  # A Waves Foundation provides enough functionality to allow a Waves application
-  # to run.  At the bare minimum, this means creating configuration classes in the Configurations
-  # namespace, as is done in the Simple foundation
-  #
-  # Typically, a Foundation will include several Layers, perform any necessary
-  # configuration, and register the application with the Waves module
-  module Foundations
-
-    # The Simple foundation provides the bare minimum needed to run a Waves application.
-    # It is intended for use as the basis of more fully-featured foundations, but you can
-    # use it as a standalone where all the request processing is done directly in a 
-    # mapping lambda.
-    module Simple
-
-      # On inclusion in a module, the Simple foundation includes Waves::Layers::Simple and 
-      # registers the module as a Waves application.
-      def self.included( app )
-
-        app.instance_eval do
-          include Waves::Layers::Simple
-        end
-        
-        Waves << app
-      end
-    end
-  end
-end
-

data/lib/helpers/asset_helper.rb

@@ -1,67 +0,0 @@
-module Waves
-  module Helpers
-    module AssetHelper
-      # Returns an html image tag for the +source+. The +source+ can be a full
-      # path or a file that exists in your public images directory. Note that 
-      # specifying a filename without the extension is now deprecated in Rails.
-      # You can add html attributes using the +options+. The +options+ supports
-      # two additional keys for convienence and conformance:
-      #
-      # * <tt>:alt</tt>  - If no alt text is given, the file name part of the 
-      #   +source+ is used (capitalized and without the extension)
-      # * <tt>:size</tt> - Supplied as "{Width}x{Height}", so "30x45" becomes 
-      #   width="30" and height="45". <tt>:size</tt> will be ignored if the
-      #   value is not in the correct format.
-      #
-      #  image_tag("icon.png")  # =>
-      #    <img src="/images/icon.png" alt="Icon" />
-      #  image_tag("icon.png", :size => "16x10", :alt => "Edit Entry")  # =>
-      #    <img src="/images/icon.png" width="16" height="10" alt="Edit Entry" />
-      #  image_tag("/icons/icon.gif", :size => "16x16")  # =>
-      #    <img src="/icons/icon.gif" width="16" height="16" alt="Icon" />
-      def image_tag(source, options = {})
-        options.symbolize_keys!
-          
-        options[:src] = image_path(source)
-        options[:alt] ||= File.basename(options[:src], '.*').split('.').first.capitalize
-  
-        if options[:size]
-          options[:width], options[:height] = options[:size].split("x") if options[:size] =~ %r{^\d+x\d+$}
-          options.delete(:size)
-        end
-
-        tag("img", options)
-      end
-
-      # Computes the path to an image asset in the public images directory.
-      # Full paths from the document root will be passed through.
-      # Used internally by image_tag to build the image path. Passing
-      # a filename without an extension is deprecated.
-      #
-      #   image_path("edit.png")  # => /images/edit.png
-      #   image_path("icons/edit.png")  # => /images/icons/edit.png
-      #   image_path("/icons/edit.png")  # => /icons/edit.png
-      def image_path(source)
-        compute_public_path(source, 'images', 'png')
-      end
-
-      private
-        def compute_public_path(source, dir, ext)
-          source = source.dup
-          source << ".#{ext}" if File.extname(source).blank?
-          unless source =~ %r{^[-a-z]+://}
-            source = "/#{dir}/#{source}" unless source[0] == ?/
-            asset_id = rails_asset_id(source)
-            source << '?' + asset_id if defined?(RAILS_ROOT) && !asset_id.blank?
-            # source = "#{ActionController::Base.asset_host}#{@controller.request.relative_url_root}#{source}"
-          end
-          source
-        end
-        
-        def rails_asset_id(source)
-          ENV["WAVES_ASSET_ID"] || File.mtime("public/#{source}").to_i.to_s rescue ""
-        end
-
-    end
-  end
-end

data/lib/helpers/common.rb

@@ -1,66 +0,0 @@
-module Waves
-  
-  # Helper methods can be defined for any view template by simply defining them within the default Helper module in <tt>helpers/default.rb</tt> of the generated application. Helpers specific to a particular View class can be explicitly defined by creating a helper module that corresponds to the View class. For examples, for the +User+ View class, you would define a helper module in <tt>user.rb</tt> named +User+.
-  #
-  # The default helper class initially includes a wide-variety of helpers, including helpers for layouts, Textile formatting, rendering forms, and nested views, as well as helpers for accessing the request and response objects. More helpers will be added in future releases, but in many cases, there is no need to include all of them in your application.
-  module Helpers
-
-    # Common helpers are helpers that are needed for just about any Web page. For example,
-    # each page will likely have a layout and a doctype.
-
-    module Common
-
-      DOCTYPES = {
-        :html3 => "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 3.2//EN\">\n",
-        :html4_transitional =>
-          "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\" " <<
-           "\"http://www.w3.org/TR/html4/loose.dtd\">\n",
-        :html4_strict =>
-          "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.01//EN\" " <<
-            "\"http://www.w3.org/TR/html4/strict.dtd\">\n",
-        :html4_frameset =>
-          "<!DOCTYPE html PUBLIC \"-//W3C//DTD HTML 4.01 Frameset//EN\" " <<
-            "\"http://www.w3.org/TR/html4/frameset.dtd\">\n",
-        :xhtml1_transitional =>
-          "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" " <<
-            "\"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">\n",
-        :xhtml1_strict =>
-          "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Strict//EN\" " <<
-            "\"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd\">\n",
-        :xhtml1_frameset =>
-          "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Frameset//EN\" " <<
-            "\"http://www.w3.org/TR/xhtml1/DTD/xhtml1-frameset.dtd\">\n",
-        :xhtml2 => "<!DOCTYPE HTML PUBLIC \"-//IETF//DTD HTML 2.0//EN\">\n"
-      }
-
-      # Invokes a layout view (i.e., a view from the layouts template directory), using
-      # the assigns parameter to define instance variables for the view. The block is
-      # evaluated and also passed into the view as the +layout_content+ instance variable.
-      #
-      # You can define a layout just by creating a template and then calling the
-      # +layout_content+ accessor when you want to embed the caller's content.
-      #
-      # == Example
-      #
-      #   doctype :html4_transitional
-      #   html do
-      #     title @title # passed as an assigns parameter
-      #   end
-      #   body do
-      #     layout_content
-      #   end
-      #
-      def layout( name, assigns = {}, &block )
-        assigns[ :layout_content ] = capture(&block)
-        self << Waves.application.views[:layouts].process( request ) do
-          send( name, assigns )
-        end
-      end
-
-      # The doctype method simply generates a valid DOCTYPE declaration for your page.
-      # Valid options are defined in the +DOCTYPES+ constant.
-      def doctype(type) ; self << DOCTYPES[type||:html4_strict] ; end
-
-    end
-  end
-end

data/lib/helpers/default.rb

@@ -1,13 +0,0 @@
-module Waves
-  module Helpers
-    module Default
-      attr_reader :request, :content
-      include Waves::ResponseMixin
-      include Waves::Helpers::Common
-      include Waves::Helpers::Formatting
-      include Waves::Helpers::Model
-      include Waves::Helpers::View
-      include Waves::Helpers::Form
-    end
-  end
-end

data/lib/helpers/number_helper.rb

@@ -1,25 +0,0 @@
-module Waves
-  module Helpers
-    module NumberHelper
-
-      # Formats a +number+ with grouped thousands using +delimiter+. You
-      # can customize the format in the +options+ hash.
-      # * <tt>:delimiter</tt>  - Sets the thousands delimiter, defaults to ","
-      # * <tt>:separator</tt>  - Sets the separator between the units, defaults to "."
-      #
-      #  number_with_delimiter(12345678)      => 12,345,678
-      #  number_with_delimiter(12345678.05)   => 12,345,678.05
-      #  number_with_delimiter(12345678, :delimiter => ".")   => 12.345.678
-      def number_with_delimiter(number, delimiter=",", separator=".")
-        begin
-          parts = number.to_s.split(separator)
-          parts[0].gsub!(/(\d)(?=(\d\d\d)+(?!\d))/, "\\1#{delimiter}")
-          parts.join separator
-        rescue
-          number
-        end
-      end
-
-    end
-  end
-end

data/lib/helpers/tag_helper.rb

@@ -1,58 +0,0 @@
-module Waves
-  module Helpers
-    module TagHelper
-      
-      ESCAPE_TABLE = { '&'=>'&amp;', '<'=>'&lt;', '>'=>'&gt;', '"'=>'&quot;', "'"=>'&#039;', }
-      def h(value)
-        value.to_s.gsub(/[&<>"]/) { |s| ESCAPE_TABLE[s] }
-      end
-      
-      # Returns an empty HTML tag of type +name+ which by default is XHTML 
-      # compliant. Setting +open+ to true will create an open tag compatible 
-      # with HTML 4.0 and below. Add HTML attributes by passing an attributes 
-      # hash to +options+. For attributes with no value like (disabled and 
-      # readonly), give it a value of true in the +options+ hash. You can use
-      # symbols or strings for the attribute names.
-      #
-      #   tag("br")
-      #    # => <br />
-      #   tag("br", nil, true)
-      #    # => <br>
-      #   tag("input", { :type => 'text', :disabled => true }) 
-      #    # => <input type="text" disabled="disabled" />
-      def tag(name, options = nil, open = false)
-        "<#{name}#{tag_options(options) if options}" + (open ? ">" : " />")
-      end
-      
-      # Returns the escaped +html+ without affecting existing escaped entities.
-      #
-      #   escape_once("1 > 2 &amp; 3")
-      #    # => "1 &lt; 2 &amp; 3"
-      def escape_once(html)
-        fix_double_escape(h(html.to_s))
-      end
-      
-      private
-        
-        def tag_options(options)
-          cleaned_options = convert_booleans(options.stringify_keys.reject {|key, value| value.nil?})
-          ' ' + cleaned_options.map {|key, value| %(#{key}="#{escape_once(value)}")}.sort * ' ' unless cleaned_options.empty?
-        end
-        
-        def convert_booleans(options)
-          %w( disabled readonly multiple ).each { |a| boolean_attribute(options, a) }
-          options
-        end
-        
-        def boolean_attribute(options, attribute)
-          options[attribute] ? options[attribute] = attribute : options.delete(attribute)
-        end
-        
-        # Fix double-escaped entities, such as &amp;amp;, &amp;#123;, etc.
-        def fix_double_escape(escaped)
-          escaped.gsub(/&amp;([a-z]+|(#\d+));/i) { "&#{$1};" }
-        end
-        
-    end
-  end
-end