waves 0.8.2 → 0.9.0

data/lib/caches/memcached.rb

@@ -1,40 +0,0 @@
-require 'memcached'
-module Waves
-  module Caches
-    class Memcached < Simple
-
-      def initialize( args )
-        raise ArgumentError, ":servers is nil" if args[ :servers ].nil?
-        @cache = ::Memcached.new( args[ :servers ], args[ :options ] || {} )
-      end
-
-      def store( key,value, ttl = 0, marshal = true )
-        cache = @cache.clone;  cache.add( key.to_s, value, ttl, marshal );  cache.destroy
-      end
-
-      def fetch( key )
-        cache = @cache.clone;  cache.get( key.to_s );  cache.destroy
-      rescue ::Memcached::NotFound => e
-        nil
-      end
-
-      def delete( key )
-        cache = @cache.clone; cache.delete( key.to_s );  cache.destroy
-      end
-
-      def clear
-        cache = @cache.clone;  cache.flush;  cache.destroy
-      end
-
-    end
-    
-    class SynchronizedMemcached < Synchronized
-      
-      def initialize( args )
-        super( Memcached.new( args ) )
-      end
-      
-    end
-
-  end
-end

data/lib/dispatchers/default.rb

@@ -1,25 +0,0 @@
-module Waves
-
-  module Dispatchers
-
-    class Default < Base
-
-      # Takes a Waves::Request and returns a Waves::Response    
-      def safe( request  )
-        # set a default content type -- this can be overridden by the resource
-        request.response.content_type = request.accept.default
-        resource = Waves.config.resource.new( request )
-        if request.response.body.empty?
-          request.response.body << resource.process.to_s
-        else
-          resource.process
-        end
-        # okay, we've handled the request, now write the response unless it was already done
-        request.response.finish
-      end
-
-    end
-
-  end
-
-end

data/lib/ext/string.rb

@@ -1,20 +0,0 @@
-# Utility methods mixed into String.
-    
-class String
-  
-  # Syntactic sugar for using File.join to concatenate the argument to the receiver.
-  #
-  #   require "lib" / "utilities" / "string"
-  #
-  # The idea is not original, but we can't remember where we first saw it.
-  # Waves::Ext::Symbol defines the same method, allowing for :files / 'afilename.txt'
-  #
-  
-  def / ( s ) ; File.join( self, s.to_s ); end
-  
-  alias_method :lower_camel_case, :subcamelcase
-  alias_method :camel_case, :camelcase
-  alias_method :snake_case, :snakecase
-  alias_method :title_case, :titlecase
-
-end

data/lib/helpers/basic.rb

@@ -1,11 +0,0 @@
-module Waves
-  module Helpers
-    module Basic
-      attr_reader :request
-      include Waves::ResponseMixin
-      
-      def app ; Waves.main ; end
-      
-    end
-  end
-end

data/lib/helpers/extended.rb

@@ -1,21 +0,0 @@
-require 'helpers/basic'
-require 'helpers/doc_type'
-require 'helpers/layouts'
-require 'helpers/formatting'
-require 'helpers/model'
-require 'helpers/view'
-require 'helpers/form'
-
-module Waves
-  module Helpers
-    module Extended
-      include Waves::Helpers::Basic
-      include Waves::Helpers::DocType
-      include Waves::Helpers::Layouts
-      include Waves::Helpers::Formatting
-      include Waves::Helpers::Model
-      include Waves::Helpers::View
-      include Waves::Helpers::Form
-    end
-  end
-end

data/lib/helpers/form.rb

@@ -1,42 +0,0 @@
-module Waves
-
-  module Helpers
-
-    # Form helpers are used in generating forms. Since Markaby already provides Ruby
-    # methods for basic form generation, the focus of this helper is on providing templates
-    # to handle things that go beyond the basics. You must define a form template
-    # directory with templates for each type of form element you wish to use. The names
-    # of the template should match the +type+ option provided in the property method.
-    #
-    # For example, this code:
-    #
-    #   property :name => 'blog.title', :type => :text, :value => @blog.title
-    #
-    # will invoke the +text+ form view (the template in +templates/form/text.mab+),
-    # passing in the name ('blog.title') and the value (@blog.title) as instance variables.
-    #
-    # These helpers work best with Markaby, but may work for other Renderers.
-    # 
-    
-    module Form
-
-      # This method really is a place-holder for common wrappers around groups of
-      # properties. You will usually want to override this. As is, it simply places
-      # a DIV element with class 'properties' around the block.
-      def properties(&block)
-        div.properties do
-          yield
-        end
-      end
-
-      # Invokes the form view for the +type+ given in the option.
-      def property( options )
-        self << view( :form, options[:type], options )
-      end
-
-
-    end
-
-  end
-
-end

data/lib/helpers/formatting.rb

@@ -1,30 +0,0 @@
-require 'redcloth'
-module Waves
-  module Helpers
-
-    # Formatting helpers are used to convert specialized content, like Markaby or
-    # Textile, into valid HTML. It also provides common escaping functions.
-    module Formatting
-
-      # Escape a string as HTML content.
-      def escape_html(s); Rack::Utils.escape_html(s); end
-
-      # Escape a URI, converting quotes and spaces and so on.
-      def escape_uri(s); Rack::Utils.escape(s); end
-
-      # Treat content as Markaby and evaluate (only works within a Markaby template).
-      # Used to pull Markaby content from a file or database into a Markaby template.
-      def markaby( content ); self << eval( content ); end
-
-      # Treat content as Textile.
-      def textile( content )
-        return if content.nil? or content.empty?
-        #( ::RedCloth::TEXTILE_TAGS  << [ 96.chr, '&8216;'] ).each do |pat,ent|
-        #  content.gsub!( pat, ent.gsub('&','&#') )
-        #end
-        self << ::RedCloth.new( content ).to_html
-      end
-
-    end
-  end
-end

data/lib/helpers/layouts.rb

@@ -1,37 +0,0 @@
-module Waves
-  
-  module Helpers
-
-    module Layouts
-
-      # 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.main::Views[:layouts].process( request ) do
-          send( name, assigns )
-        end
-      end
-      
-      def layout_content
-        self << @layout_content
-      end
-
-    end
-  end
-end

data/lib/helpers/model.rb

@@ -1,37 +0,0 @@
-module Waves
-  module Helpers
-
-    # Model helpers allow you to directly access a model from within a view.
-    # This is useful when creating things like select boxes that need data
-    # from anther model. For example, a Markaby select box for authors might look like:
-    #
-    #   select do
-    #     all(:user).each do |user|
-    #       option user.full_name, :value => user.id
-    #     end
-    #   end
-    #
-    # You could also use these within a view class to keep model-based logic out
-    # of the templates themselves. For example, in the view class you might define
-    # a method called +authors+ that returns an array of name / id pairs. This could
-    # then be called from the template instead of the model helper.
-    #
-    module Model
-      
-      def model( name )
-        Waves.main::Models[ name ][ domain ]
-      end
-      
-      # Just like model.all. Returns all the instances of that model.
-      def all( model )
-        model( model ).all
-      end
-      
-      # Finds a specific instance using the name field
-      def find( model, name )
-        model( model )[name ] rescue nil
-      end
-
-    end
-  end
-end

data/lib/helpers/view.rb

@@ -1,22 +0,0 @@
-module Waves
-  module Helpers
-
-    # View helpers are intended to help reuse views from within other views.
-    # Both the +layout+ method in the common helpers and the +property+ method
-    # of the form helpers are specialized instance of this.
-    #
-    # The star of our show here is the +view+ method. This takes a model, view,
-    # and assigns hash (which are converted into instance variables in the target
-    # view) and returns the result of evaluating the view as content in the current
-    # template.
-    module View
-      
-      # Invokes the view for the given model, passing the assigns as instance variables.
-      def view( model, view, assigns = {} )
-        self << Waves.main::Views[ model ].new( request ).send( view, assigns )
-      end
-
-
-    end
-  end
-end

data/lib/layers/inflect/english.rb

@@ -1,67 +0,0 @@
-module Waves
-  module Layers
-    module Inflect
-      
-      # Adds plural/singular methods for English to String
-      module English
-        
-        def self.included(app)
-          
-          require 'english/inflect'
-                    
-          Waves::Resources::Mixin::ClassMethods.module_eval do
-            def singular ; basename.snake_case.singular ; end
-            def plural ; basename.snake_case.plural ; end
-          end
-            
-          Waves::Resources::Mixin.module_eval do
-            def singular ; self.class.singular ; end
-            def plural ; self.class.plural ; end
-          end
-          
-          Waves::Resources::Paths.module_eval do
-            def resource ; self.class.resource.singular ; end
-            def resources ; self.class.resource.plural ; end
-
-            # TODO: be nice to DRY this up ... basically the same code 
-            # as the mixin except with the singular / plural stuff
-            # mixed in ...
-            def generate( template, args )
-              return "/#{ args * '/' }" unless template.is_a?( Array ) and not template.empty?
-              path = []
-              ( "/#{ path * '/' }" ) if template.all? do | want |
-                case want
-                when true then path += args
-                when String then path << want
-                when Symbol
-                  case want
-                  when :resource then path << resource
-                  when :resources then path << resources
-                  else path << args.shift
-                  end
-                when Regexp then path << args.shift
-                when Hash
-                  key, value = want.to_a.first
-                  case key
-                  when :resource then path << resource
-                  when :resources then path << resources
-                  else 
-                    case value
-                    when true then path += args
-                    when String, Symbol, RegExp then path << args.unshift
-                    end
-                  end
-                end
-              end
-            end
-          end
-          
-        end
-        
-      end
-    end
-  end
-end
-
-
-

data/lib/layers/mvc.rb

@@ -1,54 +0,0 @@
-module Waves
-  module Layers
-    module MVC
-
-      def self.included( app )
-        
-        require 'layers/mvc/extensions'
-        require 'layers/mvc/controllers'
-        
-        app.auto_create_module( :Models ) do
-          include AutoCode
-          auto_create_class :Default
-          auto_load :Default, :directories => [ :models ]
-        end
-        
-        app.auto_eval( :Models ) do
-          auto_create_class true, app::Models::Default
-          auto_load true, :directories => [ :models ]
-        end
-
-        app.auto_create_module( :Views ) do
-          include AutoCode
-          auto_create_class :Default, Waves::Views::Base
-          auto_load :Default, :directories => [ :views ]
-        end
-        
-        app.auto_eval( :Views ) do
-          auto_create_class true, app::Views::Default
-          auto_load true, :directories => [ :views ]
-        end
-
-        app.auto_create_module( :Controllers ) do
-          include AutoCode
-          auto_create_class :Default, Waves::Controllers::Base
-          auto_load :Default, :directories => [ :controllers ]
-        end
-        
-        app.auto_eval( :Controllers ) do
-          auto_create_class true, app::Controllers::Default
-          auto_load true, :directories => [ :controllers ]          
-        end
-
-        app.auto_create_module( :Helpers ) do
-          include AutoCode
-          auto_create_module( :Default ) { include Waves::Helpers::Extended }
-          auto_load :Default, :directories => [ :helpers ]
-          auto_create_module( true ) { include app::Helpers::Default }
-          auto_load true, :directories => [ :helpers ]
-        end
-        
-      end
-    end
-  end
-end

data/lib/layers/renderers/erubis.rb

@@ -1,60 +0,0 @@
-require 'erubis'
-
-module Erubis # :nodoc:
-
-  # This is added to the Erubis Content class to allow the same helper methods
-  # to be used with both Markaby and Erubis.
-  class Context
-    
-    def <<(s) 
-      eval("_buf << '#{s}'", @binding)
-    end
-    
-    def capture
-      eval("_context.push(_buf); _buf = ''", @binding) #ignore output from that eval, will be added via "<<"
-      result = Erubis::Eruby.new(yield).result @binding
-      eval("_buf = _context.pop", @binding)
-      result
-    end
-    
-    def to_s(eruby)
-      unless @binding
-        @binding = binding
-        eval("_buf = ''; _context = []", @binding)
-      end
-      eruby.result @binding
-    end
-
-  end
-
-end
-
-module Waves
-  
-  module Renderers
-
-    module Erubis
-      
-      Extension = :erb
-      
-      extend Waves::Renderers::Mixin
-      
-      def self.render( path, assigns )
-        eruby = ::Erubis::Eruby.new( template( path ) )
-        helper = helper( path )
-        context = ::Erubis::Context.new
-        context.meta_eval { include( helper ) ; }
-        context.instance_eval do
-          assigns.each do |key,val|
-            instance_variable_set("@#{key}",val)
-          end
-        end
-        context.to_s(eruby)
-      end
-
-
-    end
-  
-  end
-
-end