dyoder-waves 0.7.3

data/app/Rakefile

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+#
+# Warning:  This file is clobbered when you update your
+# application with the waves script.  Accordingly, you may
+# wish to keep your tasks in .rb or .rake files in lib/tasks
+require 'startup'
+Waves::Console.load(:mode => ENV['mode'])
+
+# load tasks from waves framework
+%w( cluster generate gem ).each { |task| require "tasks/#{task}.rb" }
+
+# load tasks from this app's lib/tasks
+Dir["lib/tasks/*.{rb,rake}"].each { |task| require task }
+

data/app/bin/waves-console

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+require 'startup'
+require 'commands/waves-console'

data/app/bin/waves-server

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+require 'startup'
+require 'commands/waves-server'

data/app/configurations/development.rb.erb

@@ -0,0 +1,31 @@
+module <%= name %>
+
+  module Configurations
+
+    class Development
+
+      database :host => 'localhost', :adapter => 'sqlite', :database => '<%= name.downcase %>',
+        :user => 'root', :password => ''
+
+      reloadable [ <%= name %> ]
+
+      log :level => :debug
+
+      host '127.0.0.1'
+
+      port 3000
+
+    handler ::Rack::Handler::Mongrel, :Host => host, :Port => port
+      # handler ::Rack::Handler::WEBrick, :BindAddress => host, :Port => port
+      # handler ::Rack::Handler::Thin, :Host => host, :Port => port
+
+      application do
+        use ::Rack::ShowExceptions
+        run ::Waves::Dispatchers::Default.new
+      end
+
+    end
+
+  end
+
+end

data/app/configurations/mapping.rb.erb

@@ -0,0 +1,14 @@
+module <%= name %>
+
+  module Configurations
+
+    module Mapping
+      extend Waves::Mapping
+      # your custom rules go here
+      include Waves::Mapping::PrettyUrls::RestRules
+      include Waves::Mapping::PrettyUrls::GetRules
+    end
+
+  end
+
+end

data/app/configurations/production.rb.erb

@@ -0,0 +1,30 @@
+module <%= name %>
+
+  module Configurations
+
+    class Production < Default
+
+      database :host => 'localhost', :adapter => 'mysql', :database => '<%= name.downcase %>',
+        :user => 'root', :password => ''
+
+      reloadable []
+
+      log :level => :error,
+        :output => ( :log / "waves.#{$$}" ),
+        :rotation => :weekly
+
+      host '0.0.0.0'
+
+      port 80
+
+    handler ::Rack::Handler::Mongrel, :Host => host, :Port => port
+      # handler ::Rack::Handler::WEBrick, :BindAddress => host, :Port => port
+      # handler ::Rack::Handler::Thin, :Host => host, :Port => port
+
+      application do
+        run ::Waves::Dispatchers::Default.new
+      end
+
+    end
+  end
+end

data/app/lib/application.rb.erb

@@ -0,0 +1,3 @@
+module <%= name %>
+  include Waves::Foundations::Default
+end

data/app/startup.rb

@@ -0,0 +1,5 @@
+lambda {
+  waves = ( ( WAVES if defined? WAVES ) || ENV['WAVES'] || File.join(File.dirname(__FILE__), 'waves') )
+  $:.unshift(File.join( waves, "lib" )) if File.exist? waves
+}.call
+require 'waves'

data/app/templates/errors/not_found_404.mab

@@ -0,0 +1,2 @@
+h1 '404'
+p %q( That URL does not exist on this server. )

data/app/templates/errors/server_error_500.mab

@@ -0,0 +1,2 @@
+h1 '500'
+p %q( Internal server error. Sorry, but your request could not be processed. )

data/app/templates/layouts/default.mab

@@ -0,0 +1,14 @@
+doctype :html4_strict
+
+html do
+
+  head do
+    title @title
+  end
+
+  body do
+    layout_content
+  end
+
+end
+

data/bin/waves

@@ -0,0 +1,66 @@
+#!/usr/bin/env ruby
+
+# rudimentary argument checks
+if ARGV.length != 1 || ARGV[0] == '--help'
+  $stderr.puts "Usage: waves {app_name}"
+  $stderr.puts "app_name may contain only letters, numbers, and underscores."
+  exit 1
+end
+
+app_path = ARGV[0]
+app_name = File.basename(app_path)
+if app_name =~ /[^\w\d_]/
+  raise ArgumentError, <<-TEXT
+  Unusable name: \"#{app_name}\"
+  Application names may contain only letters, numbers, and underscores."
+TEXT
+end
+
+
+require 'rubygems'
+require 'erubis'
+require 'extensions/all'
+begin
+  require 'utilities/string'
+rescue LoadError
+  require File.join(File.dirname(__FILE__), '..', 'lib', 'utilities', 'string')
+end
+
+require 'fileutils'
+include FileUtils
+
+# are we calling this script from within the waves framework source?
+script_path = File.expand_path(__FILE__)
+WAVES_SRC = File.dirname(File.dirname(script_path))
+IN_WAVES_SRC = Dir.pwd.match(WAVES_SRC) ? true : false
+
+
+puts "** Creating new Waves application ..."
+template = begin
+  File.join File.dirname(File.readlink(__FILE__)), '..', 'app'
+rescue Exception
+  File.join( File.dirname(__FILE__),'..','app')
+end
+mkdir(app_path)
+cp_r Dir["#{template}/*"], app_path
+
+# get rid of placeholder files left over from gem install
+Dir["#{app_path}/**/EMPTY"].each { |path| rm path }
+# Dir["#{app_path}/**/EMPTY"].each { |path| system "rm #{path}" }
+
+# next, process all template files ...
+Dir["#{app_path}/**/*.erb"].each do |path|
+  unless path =~ %r{^#{app_path}/(schema/migrations/templates|templates)}
+    name = app_name.camel_case
+    File.write( path.gsub(/\.erb$/,''),
+      Erubis::Eruby.new( File.read( path ) ).result( binding ) )
+    rm path
+  end
+end
+
+unless RUBY_PLATFORM =~ /mswin32/
+  # make the scripts executable
+  system "chmod ug+x #{app_path}/bin/waves-*"
+end
+
+puts "** Application created!"

data/bin/waves-console

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+require 'startup'
+
+require 'commands/waves-console'

data/bin/waves-server

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+require 'startup'
+
+require 'commands/waves-server'

data/lib/commands/waves-console.rb

@@ -0,0 +1,24 @@
+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 }
+Object.instance_eval do
+  include Waves::Verify::Helpers::Request
+end
+require 'irb'
+require 'irb/completion'
+ARGV.clear
+IRB.start

data/lib/commands/waves-server.rb

@@ -0,0 +1,55 @@
+require 'choice'
+
+Choice.options do
+  header 'Run a waves application server.'
+  header ''
+  option :port  do
+    short '-p'
+    long '--port=PORT'
+    desc 'Port to listen on.'
+    desc 'Defaults to value given in configuration.'
+    cast Integer
+  end
+  separator ''
+  option :host do
+    short '-h'
+    long '--host=HOST'
+    desc 'Host or IP address of the host to bind.'
+    desc 'Defaults to value given in configuration.'
+  end
+  separator ''
+  option :mode do
+    short '-c'
+    long '--config=CONFIG'
+    desc 'Configuration to use.'
+    desc 'Defaults to development.'
+    cast Symbol
+  end
+  separator ''
+  option :directory do
+    short '-D'
+    long '--dir=DIR'
+    desc 'Directory containing the application.'
+    desc 'Defaults to the current directory.'
+  end
+  separator ''
+  option :daemon do
+    short '-d'
+    long '--daemon'
+    desc 'Run as a daemon.'
+  end
+  separator ''
+  option :debugger do
+    short '-u'
+    long '--debugger'
+    desc 'Enable ruby-debug.'
+  end
+  separator ''
+  option :startup do
+    short '-s'
+    long '--startup'
+    desc 'Startup file to load.'
+    desc 'Defaults to "lib/startup.rb"'
+  end
+end
+Waves::Server.run( Choice.choices )

data/lib/controllers/mixin.rb

@@ -0,0 +1,158 @@
+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.
+  #
+  # 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
+
+    #
+    # This mixin provides some handy methods for Waves controllers. You will probably
+    # want to include it in any controllers you define for your application. The default
+    # controllers generated using the +wave+ command already do this.
+    #
+    # Basically, what the mixin does is adapt the class so that it can be used within
+    # mappings (see Waves::Mapping); add some simple reflection to allow controller methods
+    # to be written generically (i.e., without reference to a specific model); and provide
+    # parameter destructuring for the request parameters.
+    #
+
+    module Mixin
+
+      attr_reader :request
+
+      include Waves::ResponseMixin
+
+      # When you include this Mixin, a +process+ class method is added to your class,
+      # which accepts a request object and a block. The request object is used to initialize
+      # the controller and the block is evaluated using +instance_eval+. This allows the
+      # controller to be used within a mapping file.
+
+      def self.included( c )
+        def c.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.parameters+ instead of simply +params+.
+      def params; @params ||= destructure(request.params); end
+
+      # You can access the name of the model related to this controller using this method.
+      # It simply takes the basename of the module and converts it to snake case, so if the
+      # model uses a different plurality, this won't, in fact, be the model name.
+      def model_name; self.class.basename.snake_case; end
+
+      # This uses the model_name method to attempt to identify the model corresponding to this
+      # controller. 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)
+        rval = {}
+        hash.keys.map{ |key|key.split('.') }.each do |keys|
+          destructure_with_array_keys(hash,'',keys,rval)
+        end
+        rval
+      end
+
+      def destructure_with_array_keys(hash,prefix,keys,rval)
+        if keys.length == 1
+          val = hash[prefix+keys.first]
+          rval[keys.first.intern] = case val
+          when String then val.strip
+          when Hash then val
+          end
+        else
+          rval = ( rval[keys.first.intern] ||= {} )
+          destructure_with_array_keys(hash,(keys.shift<<'.'),keys,rval)
+        end
+      end
+
+    end
+
+  end
+
+end