ramaze 2011.07.25 → 2011.10.23

data/examples/app/blog/app.rb

@@ -1,71 +1,32 @@
+# This file contains your application, it requires dependencies and necessary
+# parts of the application.
+#
+# It will be required from either `config.ru` or `start.rb`
+#
+# Note that the require 'rubygems' line is only required if you're running a
+# Ruby implementation that's based on 1.8 such as REE or Rubinius (although I'm
+# not sure if the latter actually requires this).
 require 'rubygems'
 require 'ramaze'
 
-Ramaze.setup :verbose => true do
-  gem 'sequel', '3.9.0'
-  gem 'maruku', '0.6.0'
-  gem 'sqlite3-ruby', :lib => 'sqlite3'
-  gem 'nagoro'
+# This block of code automatically downloads and installs all the specified
+# Gems. This is similar to how Bundler and Isolate work but in a much simpler
+# way.
+Ramaze.setup(:verbose => false) do
+  gem 'sequel'
+  gem 'sqlite3'
+  gem 'bcrypt-ruby', :lib => 'bcrypt'
+  gem 'rdiscount'
 end
 
-module Blog
-  include Ramaze::Optioned
+# Make sure that Ramaze knows where you are. Without this layouts and such
+# wouldn't be rendered. While Ramaze.options.roots includes "." (the current
+# directory) you should not rely on this path as it changes depending from what
+# directory this script was called.
+Ramaze.options.roots = [__DIR__]
 
-  options.dsl do
-    o 'Title of this blog', :title,
-      'Ramaze Blog'
+# Initialize controllers and models
+require __DIR__('model/init')
+require __DIR__('controller/init')
 
-    o 'Subtitle of the blog', :subtitle,
-      'manveru.thoughts.to_html'
-
-    sub :author do
-      o 'Your name', :name,
-        'Michael Fellinger'
-
-      o 'Your email address', :email,
-        'm.fellinger@gmail.com'
-
-      o 'URL pointing to you, uses the url of this blog if nil', :url,
-        'http://github.com/manveru'
-    end
-
-    sub :admin do
-      o "Admin username", :name,
-        'manveru'
-
-      o "Admin password", :password,
-        'letmein'
-    end
-
-    sub :sidebar do
-      o "Elements to display in the sidebar", :elements,
-        [:bio, :tagcloud, :history, :admin]
-
-      sub :bio do
-        o 'Describe yourself, you may use html', :text,
-          "My name is Forrest, Forrest Gump.<br />
-           I enjoy running, chocolate, talking, and Jenny."
-      end
-
-      sub :history do
-        o "How many past entries should be shown in the history", :size,
-          20
-      end
-    end
-
-    o 'Number of entries shown in entry listings', :list_size,
-      10
-
-    o 'How many entries are shown in the feeds', :feed_size,
-      100
-
-    o 'Feed UUID', :uuid,
-      'ramaze_blog'
-
-    o "Time format used throughout the blog, see `ri Time.strftime`", :time_format,
-      '%A, %d.%m.%Y at %R'
-  end
-end
-
-require 'model/init'
-require 'controller/init'
+Ramaze::Log.info('Logging in can be done by going to /users/login')

data/examples/app/blog/config.ru

@@ -1,17 +1,19 @@
 #!/usr/bin/env rackup
 #
 # config.ru for ramaze apps
-# use thin >= 1.0.0
-# thin start -R config.ru
 #
-# rackup is a useful tool for running Rack applications, which uses the
+# Rackup is a useful tool for running Rack applications, which uses the
 # Rack::Builder DSL to configure middleware and build up applications easily.
 #
-# rackup automatically figures out the environment it is run in, and runs your
-# application as FastCGI, CGI, or standalone with Mongrel or WEBrick—all from
+# Rackup automatically figures out the environment it is run in, and runs your
+# application as FastCGI, CGI, or standalone with Mongrel or WEBrick -- all from
 # the same configuration.
+#
+# Do not set the adapter.handler in here, it will be ignored.
+# You can choose the adapter like `ramaze start -s mongrel` or set it in the
+# 'start.rb' and use `ruby start.rb` instead.
+require ::File.expand_path('../app', __FILE__)
+
+Ramaze.start(:root => Ramaze.options.roots, :started => true)
 
-cwd = File.dirname(__FILE__)
-require "#{cwd}/start"
-Ramaze.start(:started => true)
-run Innate
+run Ramaze

data/examples/app/blog/controller/init.rb

@@ -1,88 +1,31 @@
-module Blog
-  class Controller < Ramaze::Controller
-    engine :Nagoro
-    layout(:default){|path, wish| wish !~ /rss|atom/ }
-    map_layouts '/'
-    map nil, :blog
-    app.location = '/'
-    trait :app => :blog
-    helper :form, :auth, :formatting
-
-    trait :auth_table => lambda{
-      password = Digest::SHA1.hexdigest(Blog.options.admin.password)
-      {Blog.options.admin.name => password}
-    }
-
-    private
-
-    def author_url
-      Blog.options.author.url || request.domain(Main.r('/'))
-    end
-
-    def sidebar
-      out = Ramaze::Gestalt.new
-
-      Blog.options.sidebar.elements.each do |element|
-        name, title, *contents = __send__("sidebar_#{element}")
-
-        out.ul(:class => name) do
-          out.li(:class => :title){ title }
-          contents.flatten.each do |content|
-            out.li{ content.to_s }
-          end
-        end
-      end
-
-      out.to_s
-    end
-
-    def sidebar_bio
-      return :bio, 'About me', Blog.options.sidebar.bio.text.to_s
-    end
-
-    def sidebar_admin
-      if logged_in?
-        links =  [ a('New entry', Entries.r(:new)),
-                   a('Logout', Main.r(:logout))   ]
-        return :actions, 'Administration', links
-      else
-        return :login, 'Login', <<FORM.strip
-<form method="post" action="#{r :login}">
-  #{form_text 'Username', :username}
-  #{form_password 'Password', :password}
-  #{form_submit 'Login'}
-</form>
-FORM
-      end
-    end
-
-    def sidebar_history
-      limit = 4; Blog.options.sidebar.history.size
-      entries = Entry.select(:id, :title).order(:published.desc).limit(limit)
-
-      return :history, 'History',
-        entries.map{|e| a(e.title, e.href) }
-    end
-
-    # Don't rel="tag" them, this is bad practice according to microformats
-    #
-    # The query makes sure that we only select tags that have entries
-    # associated with them.
-    def sidebar_tagcloud
-      tags = Tag.filter(:id => EntriesTags.select(:tag_id)).select(:name).map(:name)
-      cloud = []
-
-      tagcloud(tags, 0.8, 2.0).each do |tag, weight|
-        style = "font-size: %0.2fem" % weight
-        cloud << "<a href='#{Tags.r(tag)}' style='#{style}'>#{h(tag)}</a>"
-      end
-
-      return :tagcloud, 'Tags', cloud.sort.join("\n")
-    end
-  end
+##
+# Base controller that provides a few things used by sub controllers throughout
+# this example application.
+#
+# @author Yorick Peterse
+# @since  26-09-2011
+#
+class BaseController < Ramaze::Controller
+  engine :etanni
+  layout :default
+  helper :blue_form, :user, :xhtml, :paginate
+
+  # Configures the Paginate helper so that it shows a maximum of 10 posts per
+  # page and uses the "page" query string key to determine the current page.
+  # This will result in URLs such as /posts?page=2. Note that when calling the
+  # paginate() method you can override these settings.
+  trait :paginate => {
+    :var   => 'page',
+    :limit => 10
+  }
+
+  # Tells the User helper what model class should be used for the authenticate()
+  # method. By default this is already set to "User" so technically this isn't
+  # required but to make it easier to understand what's going on I decided to
+  # put it here.
+  trait :user_model => User
 end
 
-require 'controller/main'
-require 'controller/entry'
-require 'controller/tag'
-require 'controller/comment'
+# Load all other controllers
+require __DIR__('posts')
+require __DIR__('users')

data/examples/app/blog/controller/posts.rb

@@ -0,0 +1,232 @@
+##
+# The Posts controller is used to display a list of all the posts that have been
+# added as well as providing a way of adding, removing and updating posts.
+#
+# @author Yorick Peterse
+# @since  26-09-2011
+#
+class Posts < BaseController
+  map '/'
+
+  # Sets the content type and view name based on the extension in the URL. For
+  # example, a request to /posts/feed.rss would render the view feed.rss.xhtml
+  # and set the content type to application/rss+xml.
+  provide(:atom, :type => 'application/atom+xml') do |action, body|
+    # Disable the layout.
+    action.layout = false
+
+    # Let's make sure the body is actually rendered. Using "return" would cause
+    # a local jumper error.
+    body
+  end
+
+  # These methods require the user to be logged in. If this isn't the case the
+  # user will be redirected back to the previous page and a message is
+  # displayed.
+  before(:edit, :new, :save, :delete) do
+    # "unless logged_in?" is the same as "if !logged_in?" but in my opinion is a
+    # bit nicer to the eyes.
+    unless logged_in?
+      flash[:error] = 'You need to be logged in to view that page'
+
+      # Posts.r() is a method that generates a route to a given method and a set
+      # of parameters. Calling #to_s on this object would produce a string
+      # containing a URL. For example, Posts.r(:edit, 10).to_s would result in
+      # "/edit/10".
+      redirect(Posts.r(:index))
+    end
+  end
+
+  ##
+  # Shows an overview of all the posts that have been added. These posts are
+  # paginated using the Paginate helper.
+  #
+  # @author Yorick Peterse
+  # @since  26-09-2011
+  #
+  def index
+    @posts = paginate(Post.eager(:comments, :user))
+    @title = 'Posts'
+  end
+
+  ##
+  # Returns a list of all posts as either an RSS feed or an Atom feed.
+  #
+  # @author Yorick Peterse
+  # @since  27-09-2011
+  #
+  def feed
+    @posts = Post.all
+
+    render_view(:feed)
+  end
+
+  ##
+  # Shows a single post along with all it's comments.
+  #
+  # @author Yorick Peterse
+  # @since  26-09-2011
+  # @param  [Fixnum] id The ID of the post to view.
+  #
+  def view(id)
+    @post = Post[id]
+
+    if @post.nil?
+      flash[:error] = 'The specified post is invalid'
+      redirect_referrer
+    end
+
+    @title       = @post.title
+    @created_at  = @post.created_at.strftime('%Y-%m-%d')
+    @new_comment = flash[:form_data] || Comment.new
+  end
+
+  ##
+  # Allows users to create a new post, given the user is logged in.
+  #
+  # @author Yorick Peterse
+  # @since  26-09-2011
+  #
+  def new
+    @post  = flash[:form_data] || Post.new
+    @title = 'New post'
+
+    render_view(:form)
+  end
+
+  ##
+  # Allows a user to edit an existing blog post.
+  #
+  # @author Yorick Peterse
+  # @since  26-09-2011
+  # @param  [Fixnum] id The ID of the blog post to edit.
+  #
+  def edit(id)
+    @post = flash[:form_data] || Post[id]
+
+    # Make sure the post is valid
+    if @post.nil?
+      flash[:error] = 'The specified post is invalid'
+      redirect_referrer
+    end
+
+    @title = "Edit #{@post.title}"
+
+    render_view(:form)
+  end
+
+  ##
+  # Adds a new comment to an existing post and redirects the user back to the
+  # post.
+  #
+  # @author Yorick Peterse
+  # @since  27-09-2011
+  #
+  def add_comment
+    data    = request.subset(:post_id, :username, :comment)
+    comment = Comment.new
+
+    # If the user is logged in the user_id field should be set instead of the
+    # username field.
+    if logged_in?
+      data.delete('username')
+      data['user_id'] = user.id
+    end
+
+    begin
+      comment.update(data)
+      flash[:success] = 'The comment has been added'
+    rescue => e
+      Ramaze::Log.error(e)
+
+      flash[:form_errors] = comment.errors
+      flash[:error]       = 'The comment could not be added'
+    end
+
+    redirect_referrer
+  end
+
+  ##
+  # Saves the changes made by Posts#edit() and Posts#new(). While these two
+  # methods could have their own methods for saving the data the entire process
+  # is almost identical and thus this would be somewhat useless.
+  #
+  # @author Yorick Peterse
+  # @since  26-09-2011
+  #
+  def save
+    # Fetch the POST data to use for a new Post object or for updating an
+    # existing one.
+    data            = request.subset(:title, :body)
+    id              = request.params['id']
+    data['user_id'] = user.id
+
+    # If an ID is given it's assumed the user wants to edit an existing post,
+    # otherwise a new one will be created.
+    if !id.nil? and !id.empty?
+      post = Post[id]
+
+      # Let's make sure the post is valid
+      if post.nil?
+        flash[:error] = 'The specified post is invalid'
+        redirect_referrer
+      end
+
+      success = 'The post has been updated'
+      error   = 'The post could not be updated'
+    # Create a new post
+    else
+      post    = Post.new
+      success = 'The post has been created'
+      error   = 'The post could not be created'
+    end
+
+    # Now that we have a Post object and the messages to display it's time to
+    # actually insert/update the data. This is wrapped in a begin/rescue block
+    # so that any errors can be handled nicely.
+    begin
+      # Post#update() can be used for both new objects and existing ones. In
+      # case the object doesn't exist in the database it will be automatically
+      # created.
+      post.update(data)
+
+      flash[:success] = success
+
+      # Redirect the user back to the correct page.
+      redirect(Posts.r(:edit, post.id))
+    rescue => e
+      Ramaze::Log.error(e)
+
+      # Store the submitted data and the errors. The errors are used by
+      # BlueForm, the form data is used so that the user doesn't have to
+      # re-enter all data every time something goes wrong.
+      flash[:form_data]   = post
+      flash[:form_errors] = post.errors
+      flash[:error]       = error
+
+      redirect_referrer
+    end
+  end
+
+  ##
+  # Removes a single post from the database.
+  #
+  # @author Yorick Peterse
+  # @since  26-09-2011
+  # @param  [Fixnum] id The ID of the post to remove.
+  #
+  def delete(id)
+    # The call is wrapped in a begin/rescue block so any errors can be handled
+    # properly. Without this the user would bump into a nasty stack trace and
+    # probably would have no clue as to what's going on.
+    begin
+      Post.filter(:id => id).destroy
+      flash[:success] = 'The specified post has been removed'
+    rescue => e
+      Ramaze::Log.error(e.message)
+      flash[:error] = 'The specified post could not be removed'
+    end
+
+    redirect(Posts.r(:index))
+  end
+end # Posts