hobo 0.8.8 → 0.8.9

data/CHANGES.txt

@@ -1,3 +1,37 @@
+=== Hobo 0.8.9 ===
+
+Enhancements:
+
+ -
+    [precompile_taglibs](http://groups.google.com/group/hobousers/browse_thread/thread/29694e75f60c0870/6b05f75f2f7e91f5)
+    allows you to precompile taglibs during application startup rather
+    than on demand.
+
+ - `--invite-only` options added ti generator
+
+Major bug fixes:
+
+ - [Bug
+   461](https://hobo.lighthouseapp.com/projects/8324-hobo/tickets/461-hobo-is-not-compatible-with-firefox-35):
+   Firefox 3.5 problems were caused by lowpro.  For existing projects,
+   you will have to update your copy of [public/javascripts/lowpro.js](http://github.com/tablatom/hobo/raw/master/hobo/rails_generators/hobo_rapid/templates/lowpro.js)
+
+ - [Bug
+   477](http://groups.google.com/group/hobousers/browse_thread/thread/5a15288f9703a8a4/58a8dee62b237d29)
+   caused problems when the user submitted a form from the index page.
+
+ - "collection" was renamed to "collection-heading" in the Rapid
+   generated show-page.
+
+ - [Bug
+   473](https://hobo.lighthouseapp.com/projects/8324/tickets/473-use-timezonenow-instead-of-timenow#ticket-473-5):
+   Hobo now uses any time zone's configured for the application rather
+   than using the server's time zone.
+
+Minor bug fixes and enhancements:
+
+See the [github log](http://github.com/bryanlarsen/hobo/commits/v0.8.5)
+
 === Hobo 0.8.8 ===
 
 Hobo 0.8.8 comes with some slight changes to the colour scheme for the

data/Rakefile

@@ -2,6 +2,13 @@ require 'rake'
 require 'rake/rdoctask'
 require 'rake/testtask'
 
+require 'activerecord'
+ActiveRecord::ActiveRecordError # hack for https://rails.lighthouseapp.com/projects/8994/tickets/2577-when-using-activerecordassociations-outside-of-rails-a-nameerror-is-thrown
+$:.unshift File.join(File.expand_path(File.dirname(__FILE__)), '/lib')
+$:.unshift File.join(File.expand_path(File.dirname(__FILE__)), '/../hobofields/lib')
+$:.unshift File.join(File.expand_path(File.dirname(__FILE__)), '/../hobosupport/lib')
+require 'hobo'
+
 desc "Default Task"
 task :default => [ :test ]
 
@@ -35,28 +42,27 @@ Rake::RDocTask.new(:rdoc) do |rdoc|
 end
 
 
-# --- Packaging and Rubyforge --- #
-
-require 'echoe'
-
-Echoe.new('hobo') do |p|
-  p.author  = "Tom Locke"
-  p.email   = "tom@tomlocke.com"
-  p.summary = "The web app builder for Rails"
-  p.url     = "http://hobocentral.net/"
-  p.project = "hobo"
-
-  p.changelog = "CHANGES.txt"
-  p.version   = "0.8.8"
-
-  p.dependencies = [
-    'hobosupport =0.8.8',
-    'hobofields =0.8.8',
-    'rails >=2.2.2',
-    'mislav-will_paginate >=2.2.1']
-    
-  p.development_dependencies = []
+# --- Packaging and Rubyforge & gemcutter & github--- #
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.version      = Hobo::VERSION
+    gemspec.name         = "hobo"
+    gemspec.email        = "tom@tomlocke.com"
+    gemspec.summary      = "The web app builder for Rails"
+    gemspec.homepage     = "http://hobocentral.net/"
+    gemspec.authors      = ["Tom Locke"]
+    gemspec.rubyforge_project = "hobo"
+    gemspec.add_dependency("rails", [">= 2.2.2"])
+    gemspec.add_dependency("mislav-will_paginate", [">= 2.2.1"])
+    gemspec.add_dependency("hobosupport", ["= #{Hobo::VERSION}"])
+    gemspec.add_dependency("hobofields", ["= #{Hobo::VERSION}"])    
+  end
+  Jeweler::GemcutterTasks.new
+  Jeweler::RubyforgeTasks.new do |rubyforge|
+    rubyforge.doc_task = false
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
 end
-
-
-

data/bin/hobo

@@ -1,6 +1,9 @@
 #!/usr/bin/env ruby
 
 require 'fileutils'
+require 'pathname'
+require 'activesupport'
+
 Signal.trap("INT") { puts; exit }
 
 hobo_src = File.join(File.dirname(__FILE__), "../hobo_files/plugin")
@@ -14,6 +17,7 @@ Options:
   -d | --database <database>         # e.g. mysql, sqlite
   -r | --rails <version>             # rails version to use
   -n | --no-rails                    # don't run 'rails'.  Assumes app-path=='.'
+  --invite-only                      # add features for an invite-ony website (admin site, no signup)
 "
 
 
@@ -36,11 +40,10 @@ def command(*s)
   exit(1) unless ok
 end
 
-user_model  = "user"
-create_db   = false
-run_rails   = true
-
-puts ARGV
+user_model = "user"
+create_db  = false
+run_rails  = true
+invite_ony = ""
 
 while true
   case arg_name = ARGV.shift
@@ -50,13 +53,16 @@ while true
   when "--db-create"
     create_db = true
   when "--hobo-src"
-    hobo_src = "../" + ARGV.shift
+    hobo_src = ARGV.shift
+    hobo_src = "../" + hobo_src unless Pathname.new(hobo_src).absolute?
   when "-d", "--database"
     database_type = ARGV.shift
   when "-r", "--rails"
     rails_version = ARGV.shift
   when "-n", "--no-rails"
     run_rails = false
+  when "--invite-only"
+    invite_ony = "--invite-only"
   when "--help"
     puts USAGE
     exit
@@ -100,16 +106,16 @@ Dir.chdir(app_path) do
   command(gen, "hobo --add-gem --add-routes")
 
   puts "\nInstalling Hobo Rapid and default theme...\n"
-  command("#{gen} hobo_rapid --import-tags")
+  command("#{gen} hobo_rapid --import-tags #{invite_ony}")
 
   if user_model
     puts "\nCreating #{user_model} model and controller...\n"
-    command("#{gen} hobo_user_model #{user_model}")
-    command("#{gen} hobo_user_controller #{user_model}")
+    command("#{gen} hobo_user_model #{user_model} #{invite_ony}")
+    command("#{gen} hobo_user_controller #{user_model} #{invite_ony}")
   end
 
   puts "\nCreating standard pages...\n"
-  command("#{gen} hobo_front_controller front --delete-index --add-routes")
+  command("#{gen} hobo_front_controller front --delete-index --add-routes #{invite_ony}")
 
   if create_db
     puts "\nCreating databases"
@@ -117,3 +123,17 @@ Dir.chdir(app_path) do
   end
 end
 
+if invite_ony.present?
+  puts %(
+Invite-only website
+  If you wish to prevent all access to the site to non-members, add 'before_filter :login_required'
+  to the relevant controllers, e.g. to prevent all access to the site, add
+  
+    include Hobo::AuthenticationSupport
+    before_filter :login_required
+  
+  to application_controller.rb (note that the include statement is not required for hobo_controllers)
+  
+  NOTE: You might want to sign up as the administrator before adding this!
+)
+end

data/doctest/hobo/hobo_helper.rdoctest

@@ -0,0 +1,92 @@
+# Hobo::HoboHelper
+
+Various view helpers
+
+        doctest_require: 'rubygems'
+        doctest_require: 'active_support'
+        doctest_require: 'mocha'
+        doctest_require: '../../../hobosupport/lib/hobosupport'
+        doctest_require: '../../../hobofields/lib/hobofields'
+        doctest_require: '../../lib/hobo'
+
+Create a mock view layer:
+
+        >> 
+         class View
+           extend Hobo::HoboHelper
+           class << self
+             protected_instance_methods.each {|m| public m }
+
+             def params; {} ;end
+             def subsite; "" ;end
+             def base_url; "" ;end
+           end
+         end
+        >> RAILS_ROOT = "test-app"
+
+Useful stuff
+
+        >> def init_mocha; $stubba = Mocha::Central.new; end
+        >>
+         class Thing
+           class Mocks; extend Mocha::AutoVerify; end
+             def self.mock(hash)
+             Mocks.mock(hash.update(:class => self))
+           end
+         end
+
+
+## `object_url`
+
+Returns a canonical restful URL for a given object. THe Hobo routing is checked and URLs are only returned for routes that exist.
+
+Note that `object_url` doesn't perform "reverse routing". It knows nothing about attractive URLs you may have declared in your routes file.
+
+Something to link to:
+
+        >> init_mocha
+        >> thing = Thing.mock(:to_url_path => "things/1")
+
+### Simple 'show' URLs
+
+        >> Hobo::ModelRouter.expects(:linkable?).with(Thing, :show, {:subsite => ''}).returns(true)
+        >> View.object_url(thing)
+        => "/things/1"
+
+Returns nil if ModelRouter says it's not linkable
+
+        >> Hobo::ModelRouter.expects(:linkable?).with(Thing, :show, {:subsite => ''}).returns(false)
+        >> View.object_url(thing)
+        => nil
+
+A URL to the 'edit' page:
+
+        >> Hobo::ModelRouter.expects(:linkable?).with(Thing, :edit, {:subsite => ''}).returns(true)
+        >> View.object_url(thing, :edit)
+        => "/things/1/edit"
+
+
+### POST URLs for creating new items in collections:
+
+        >> collection = mock(:origin => thing, :origin_attribute => "parts")
+        >> Hobo::ModelRouter.expects(:linkable?).with(Thing, :create_part, {:subsite => '', :method => :post}).returns(true)
+        >> View.object_url(collection, :method => :post)
+        => "/things/1/parts"
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

data/doctest/hobo/lifecycles.rdoctest

@@ -0,0 +1,261 @@
+# Hobo Lifecycles
+
+In the REST style, which is popular with Rails coders, we view our objects a bit like documents: you can post them to a website, get them again later, make changes to them and delete them. Of course, these objects also have behaviour, which we typically implement by hooking functionality to the create / update / delete events (e.g. using callbacks such as `after_create` in ActiveRecord).
+
+This works great for many situations, but some objects are *not* best thought of as documents that we create and edit. In particular, web apps often contain objects that model some kind of *process*. A good example is *friendship* in a social app. Here's a description of how friendship might work:
+
+ * Any user can **request** friendship with another user
+ * The other user can **accept** or **reject** (or perhaps **ignore**) the request.
+ * The friendship is only **active** once it's been accepted
+ * An active friendship can be **cancelled** by either user.
+
+Not a create, update or delete in sight. Those bold words capture the way we think about the friendship much better. Of course we *could* implement friendship in a RESTful style, but we'd be doing just that -- *implementing* it, not *declaring* it. The life-cycle of the friendship would be hidden in our code, scattered across a bunch of callbacks, permission methods and state variables. Experience has shown this type of code to be tedious to write, *extremely* error prone and fragile when changing.
+
+Hobo lifecycles is a mechanism for declaring the life-cycle of a model in a natural manner. It's a bit like `acts_as_state_machine`, but Hobo-style :-)
+
+First the junk to get us started:
+
+    doctest_require: 'rubygems'
+    doctest_require: 'activerecord'
+    >> $:.unshift '/home/blarsen/dev/agility-master/vendor/plugins/hobo/hobo/lib'
+    >> $:.unshift '/home/blarsen/dev/agility-master/vendor/plugins/hobo/hobo/lib'
+    >> $:.unshift '/home/blarsen/dev/agility-master/vendor/plugins/hobo/hobofields/lib'
+    >> $:.unshift '/home/blarsen/dev/agility-master/vendor/plugins/hobo/hobosupport/lib'
+    >> require 'hobo'
+    >> require 'hobo/model'
+    >> ActiveRecord::Base.establish_connection(:adapter => "sqlite3",
+                                               :database => "lifecycle_doctest")
+
+
+A user model for our example:
+
+       >>
+        class User < ActiveRecord::Base
+          hobo_model
+          fields do
+            name :string
+          end
+        end
+
+Now the friendship. For now we'll just declare the *invite* part of the lifecycle. We first declare the *states* -- there's only one for now. We then declare the *invite* action. This is the action that first creates the friendship, so we declare it with `create`:
+
+    >>
+     class Friendship < ActiveRecord::Base
+       hobo_model
+       belongs_to :requester, :class_name => "User"
+       belongs_to :requestee, :class_name => "User"
+
+       lifecycle do
+         state :requested
+         create :request, :params => [ :requestee ], :become => :requested, :user_becomes => :requester
+       end
+     end
+
+Now let's get the DB ready:
+
+        doctest_require: '../../../hobofields/lib/hobo_fields/migration_generator'
+        >> up, down = HoboFields::MigrationGenerator.run
+        >> ActiveRecord::Migration.class_eval up
+        >> User.delete_all
+        >> Friendship.delete_all
+
+We need some users to be friends:
+
+        >> tom = User.create(:name => "Tom")
+        >> bob = User.create(:name => "Bob")
+
+Tom is allowed to request friendship:
+
+        >> Friendship::Lifecycle.can_request?(tom)
+        => true
+
+Tom does so:
+
+        >> f = Friendship::Lifecycle.request(tom, :requestee => bob)
+        >> f.requester.name
+        => "Tom"
+        >> f.requestee.name
+        => "Bob"
+        >> f.state
+        => "requested"
+
+To continue modeling the friendship lifecycle, we add some *transitions*:
+
+        >>
+         class Friendship
+            lifecycle do
+              state :active
+              transition :accept, { :requested => :active}, :available_to => :requestee 
+              transition :reject, { :requested => :destroy}, :available_to => :requestee 
+            end
+         end
+
+Note:
+
+ * Part of the transition declaration is *who* that transition is for. These two were only for the `requestee`:
+
+ * `:destroy` is a special pseudo state: entering this state causes the record to be destroyed
+
+We can test which transitions are available:
+
+        >> f.lifecycle.available_transitions_for(tom).*.name
+        => []
+        >> f.lifecycle.available_transitions_for(bob).*.name
+        => ["accept", "reject"]
+        >> f.lifecycle.can_accept?(tom)
+        => false
+        >> f.lifecycle.can_reject?(tom)
+        => false
+        >> f.lifecycle.can_accept?(bob)
+        => true
+        >> f.lifecycle.can_reject?(bob)
+        => true
+
+Accept the friendship
+
+        >> f.lifecycle.accept(bob)
+        >> f.state
+        => "active"
+
+And now there's nowhere to go:
+
+        >> f.lifecycle.available_transitions_for(tom).*.name
+        => []
+        >> f.lifecycle.available_transitions_for(bob).*.name
+        => []
+
+Cleanup
+
+        >> Friendship.delete_all
+
+Let's try a rejected friendship:
+
+        >> f = Friendship::Lifecycle.request(tom, :requestee => bob)
+        >> f.state
+        => "requested"
+        >> f.lifecycle.can_reject?(bob)
+        => true
+        >> Friendship.count
+        => 1
+        >> f.lifecycle.reject(bob)
+        >> Friendship.count
+        => 0
+
+Cleanup
+
+        >> User.delete_all
+        >> Friendship.delete_all
+        >> Friendship::Lifecycle.reset
+
+## A bigger example
+
+We'll run through the same example again, but we'll add some features
+
+Transitions and states can have actions associated with them. A common use might be to send an email. We'll simulate that with a global variable `$emails`
+
+        >> $emails = []
+
+We'll extend the lifecycle to allow:
+
+ * the requester to back out of the request
+
+ * the requestee to ignore the request
+
+ * either party to cancel the active friendship
+
+Here is the entire lifecycle
+
+        >>
+    class Friendship < ActiveRecord::Base
+      hobo_model
+      belongs_to :requester, :class_name => "User"
+      belongs_to :requestee, :class_name => "User"
+
+      lifecycle do
+            state :requested, :active, :ignored
+
+        create :requester, :request, :params => [ :requestee ], :become => :requested do
+          $emails << "Dear #{requestee.name}, #{requester.name} wants to be friends with you"
+        end
+
+
+                transition :requestee, :accept, { :requested => :active } do
+          $emails << "Dear #{requester.name}, #{requestee.name} is now your friend :-)"
+        end
+
+                transition :requestee, :reject, { :requested => :destroy } do
+          $emails << "Dear #{requester.name}, #{requestee.name} blew you out :-("
+        end
+
+                transition :requestee, :ignore, { :requested => :ignored }
+
+                transition :requester, :retract, { :requested => :destroy } do
+          $emails << "Dear #{requestee.name}, #{requester.name} reconsidered"
+        end
+
+                transition [ :requester, :requestee ], :cancel, { :active => :destroy }
+                # TODO: send the email - for this we need the acting user to be passed to the block
+
+      end
+
+    end
+
+Check the simple accept still works, and sends emails
+
+        >> f = Friendship::Lifecycle.request(tom, :requestee => bob)
+        >> $emails.last
+        => "Dear Bob, Tom wants to be friends with you"
+        >> f.lifecycle.accept(bob)
+        >> $emails.last
+        => "Dear Tom, Bob is now your friend :-)"
+        >> f.lifecycle.active?
+        => true
+
+Rejection:
+
+        >> f = Friendship::Lifecycle.request(tom, :requestee => bob)
+        >> f.lifecycle.reject(bob)
+        >> $emails.last
+        => "Dear Tom, Bob blew you out :-("
+        >> f.state
+        => "destroy"
+
+Retraction:
+
+        >> f = Friendship::Lifecycle.request(tom, :requestee => bob)
+        >> f.lifecycle.can_retract?(bob)
+        => false
+        >> f.lifecycle.retract(tom)
+        >> $emails.last
+        => "Dear Bob, Tom reconsidered"
+        >> f.lifecycle.active?
+
+Ignoring
+
+        >> f = Friendship::Lifecycle.request(tom, :requestee => bob)
+        >> $emails = []
+        >> f.lifecycle.ignore(bob)
+        >> $emails # Ignoring shouldn't send any email
+        => []
+        >> f.state
+        => "ignored"
+
+Requester cancels
+
+        >> f = Friendship::Lifecycle.request(tom, :requestee => bob)
+        >> f.lifecycle.can_cancel?(tom)
+        => false
+        >> f.lifecycle.accept(bob)
+        >> f.lifecycle.cancel(tom)
+        >> f.state
+        => "destroy"
+
+
+
+
+
+
+
+
+
+