hobo 1.1.0 → 1.3.0.RC

data/Rakefile

@@ -1,20 +1,25 @@
 require 'rake'
 require 'rake/rdoctask'
 require 'rake/testtask'
+require 'tmpdir'
 
 require 'active_record'
 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')
+$:.unshift File.expand_path('../lib', __FILE__)
+$:.unshift File.expand_path('../../hobo_support/lib', __FILE__)
+$:.unshift File.expand_path('../../hobo_fields/lib', __FILE__)
+$:.unshift File.expand_path('../../dryml/lib', __FILE__)
 require 'hobo'
 
 RUBY = File.join(Config::CONFIG['bindir'], Config::CONFIG['ruby_install_name']).sub(/.*\s.*/m, '"\&"')
-if defined?(Bundler)
-  RUBYDOCTEST = 'bundle exec rubydoctest'
-else
-  RUBYDOCTEST = ENV['RUBYDOCTEST'] || "#{RUBY} -S rubydoctest"
-end
+RUBYDOCTEST = ENV['RUBYDOCTEST'] || "#{RUBY} -S rubydoctest"
+
+GEM_ROOT = File.expand_path('../', __FILE__)
+TESTAPP_PATH = File.join Dir.tmpdir, 'hobo_testapp'
+BIN = File.expand_path('../bin/hobo', __FILE__)
+require 'hobo_support/common_tasks'
+include HoboSupport::CommonTasks
+
 
 desc "Default Task"
 task :default => [ :test ]
@@ -32,8 +37,7 @@ Rake::TestTask.new(:test) { |t|
 namespace "test" do
   desc "Run the doctests"
   task :doctest do |t|
-    files=Dir['doctest/*.rdoctest'].map {|f| File.expand_path(f)}.join(' ')
-    # note, tests in doctest/hobo/ are out of date
+    files=Dir['doctests/**/*.rdoctest'].map {|f| File.expand_path(f)}.join(' ')
     exit(1) if !system("#{RUBYDOCTEST} #{files}")
   end
 end
@@ -50,24 +54,3 @@ Rake::RDocTask.new(:rdoc) do |rdoc|
 end
 
 
-# --- Packaging and Rubyforge & gemcutter & github--- #
-
-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.executables  = ['hobo']
-  gemspec.default_executable = 'hobo'
-  gemspec.rubyforge_project = "hobo"
-  gemspec.add_dependency("rails", [">= 2.2.2", "< 3.0.0"])
-  gemspec.add_dependency("will_paginate", [">= 2.3.11", "~> 2"])
-  gemspec.add_dependency("hobosupport", ["= #{Hobo::VERSION}"])
-  gemspec.add_dependency("hobofields", ["= #{Hobo::VERSION}"])
-  gemspec.add_dependency("dryml", ["= #{Hobo::VERSION}"])
-  gemspec.files.include %w(tasks/environments.rake tasks/hobo_tasks.rake)
-end
-Jeweler::GemcutterTasks.new

data/VERSION

@@ -0,0 +1 @@
+1.3.0.RC

data/{lib/hobo → app/controllers}/dev_controller.rb

@@ -1,13 +1,13 @@
-class Hobo::DevController < ActionController::Base
+class DevController < ActionController::Base
 
   hobo_controller
 
   before_filter :developer_modes_only
-  
+
   def set_current_user
-    model = params[:model] || Hobo::User.default_user_model
+    model = params[:model] || Hobo::Model::UserBase.default_user_model
     self.current_user = if params[:login]
-                          model.find(:first, :conditions => {model.login_attribute => params[:login]})
+                          model.where(model.login_attribute => params[:login]).first
                         else
                           model.find(params[:id])
                         end
@@ -18,8 +18,8 @@ class Hobo::DevController < ActionController::Base
 
   def developer_modes_only
     # Belt and braces. In addition to this check, the routes only get
-    # defined when developer_features? is true
-    render :text => "Permission Denied", :status => 403 unless Hobo.developer_features?
+    # defined when developer_features is true
+    render :text => "Permission Denied", :status => 403 unless Rails.application.config.hobo.developer_features
   end
 
 end

data/app/controllers/dryml_support_controller.rb

@@ -0,0 +1,13 @@
+class DrymlSupportController < ActionController::Base
+
+  def edit_source
+    dryml_editor = ENV['DRYML_EDITOR']
+    if dryml_editor
+      file = File.join(Rails.root, params[:file])
+      command = dryml_editor.sub(":file", file).sub(":line", params[:line])
+      system(command)
+    end
+    render :nothing => true
+  end
+
+end

data/{rails_generators/hobo_front_controller/templates → app/views/dev}/summary.dryml

@@ -8,12 +8,11 @@
       <tr> <td>Application Name</td>           <td><app-name/></td>         </tr>
       <tr> <td>Application Location</td>       <td><rails-root/></td>     </tr>
       <tr> <td>Rails Version</td>              <td><rails-version/></td>    </tr>
-      <tr> <td>Rails Location</td>             <td><rails-location/></td>     </tr>
       <tr> <td>Mode</td>                       <td><rails-env/></td> </tr>
     </table>
 
     <h3>Change Control</h3>
-    <table class="app-summary">      
+    <table class="app-summary">
       <tr> <th></th><th></th></tr>
       <tr> <td>Method</td>                 <td><cms-method/></td> </tr>
       <if test="&cms_method.strip=='git'">
@@ -25,15 +24,13 @@
     </table>
 
 
-    <h3>Gems</h3>
+    <h3>Bundled Gems</h3>
     <table class="app-summary">
       <with-gems>
-        <tr if="&first_item?"><th></th><th>Required</th><th>Installed</th><th>Status</th><th>Dependencies</th></tr>
+        <tr if="&first_item?"><th></th><th>Version</th><th>Dependencies</th></tr>
         <tr>
           <td><gem-name/></td>
-          <td><gem-version-required/></td>
-          <td><gem-version/></td>          
-          <td><gem-frozen/></td>
+          <td><gem-version/></td>
           <td><gem-dependencies/></td>
         </tr>
       </with-gems>
@@ -75,8 +72,8 @@
           <td><model-table-comment/></td>
         </tr>
       </with-models>
-    </table>        
-    
+    </table>
+
     <with-models>
       <h3 if="&this.try.table_name"><model-name /></h3>
       <table class="app-summary">
@@ -102,4 +99,4 @@
     </with-models>
     </div>
   </content:>
-</page>
+</page>

data/bin/hobo

@@ -1,151 +1,19 @@
 #!/usr/bin/env ruby
-
 require 'fileutils'
-require 'pathname'
-
-require 'rbconfig'
 
-RUBY = File.join(Config::CONFIG['bindir'], Config::CONFIG['ruby_install_name']).sub(/.*\s.*/m, '"\&"')
-
-if RUBY.empty?
-  puts "ruby not found"
-  exit 2
+if ENV["HOBODEV"]
+  dev_root = File.expand_path ENV["HOBODEV"], FileUtils.pwd
+  $:.unshift "#{dev_root}/hobo_support/lib"
+else
+  require 'rubygems'
 end
 
-Signal.trap("INT") { puts; exit }
-
-hobo_src = File.join(File.dirname(__FILE__), "../hobo_files/plugin")
-
-USAGE = "USAGE: hobo <options> <app-path>
-
-Options:
-  --user-model <model-name-or-false>
-  --db-create                        # Run rake db:create:all
-  --hobo-src <path to hobo src>
-  -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-only website (admin site, no signup)
-"
-
-
-### Nasty stuff needed for Windows :-( ###
-if Config::CONFIG["arch"] =~ /win32/
-  require "win32/registry"
-  def system(command)
-    win = Win32API.new("crtdll", "system", ['P'], 'L').Call(command)
-  end
+begin
+  require 'hobo_support/command'
+rescue LoadError
+  puts "The 'hobo_support' gem is not installed.
+You probably need to set the HOBODEV environment variable to your local hobo git-repository path."
+  exit
 end
-### end nasty stuff ###
 
-
-def command(*s)
-  com = s.join(' ')
-  puts "--> #{com}"
-  ok = system(com)
-  exit(1) unless ok
-end
-
-user_model = "user"
-create_db  = false
-run_rails  = true
-invite_only = ""
-
-while true
-  case arg_name = ARGV.shift
-  when "--user-model"
-    arg = ARGV.shift
-    user_model = arg == "false" ? nil : arg
-  when "--db-create"
-    create_db = true
-  when "--hobo-src"
-    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_only = "--invite-only"
-  when "--help"
-    puts USAGE
-    exit
-  else
-    app_path = arg_name
-    break
-  end
-end
-
-if run_rails==false && app_path.nil?
-  app_path = '.'
-end
-
-if !ARGV.empty? || app_path.nil?
-  puts USAGE
-  exit 1
-end
-
-if run_rails
-  puts "\nGenerating Rails app...\n"
-  opts = []
-  if rails_version
-    opts << "_#{rails_version}_"
-  else
-    v=`#{RUBY} -S rails -v`.split[1].split(".")
-    unless v.length>=3
-      puts "rails not found!"
-      exit 2
-    end
-    unless v[0]=='2' && ['2', '3'].include?(v[1])
-      puts "Rails 2.2 or 2.3 required!"
-      puts "Rails 3 requires Hobo 1.1 or later."
-      exit 2
-    end
-  end
-  opts << "-d #{database_type}" if database_type
-  system("#{RUBY} -S rails #{opts * ' '} #{app_path}")
-end
-
-Dir.chdir(app_path) do
-  gen = "#{RUBY} #{File.join('script', 'generate')}"
-  plugin = "#{RUBY} #{File.join('script', 'plugin')}"
-
-  FileUtils.touch("public/stylesheets/application.css")
-
-  puts "\nInitialising Hobo...\n"
-  command(gen, "hobo --add-gem --add-routes")
-
-  puts "\nInstalling Hobo Rapid and default theme...\n"
-  command("#{gen} hobo_rapid --import-tags #{invite_only}")
-
-  if user_model
-    puts "\nCreating #{user_model} model and controller...\n"
-    command("#{gen} hobo_user_model #{user_model} #{invite_only}")
-    command("#{gen} hobo_user_controller #{user_model} #{invite_only}")
-  end
-
-  puts "\nCreating standard pages...\n"
-  command("#{gen} hobo_front_controller front --delete-index --add-routes #{invite_only}")
-
-  if create_db
-    puts "\nCreating databases"
-    command("#{RUBY} -S rake db:create:all")
-  end
-end
-
-if !invite_only.empty?
-  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
+HoboSupport::Command.run(:hobo)

data/config/initializers/inflections.rb

@@ -0,0 +1,3 @@
+ActiveSupport::Inflector.inflections do |inflect|
+  inflect.singular(/ess$/i, 'ess')
+end

data/config/routes.rb

@@ -0,0 +1,6 @@
+Rails.application.routes.draw do
+
+  match 'dryml/:action', :controller => 'dryml_support', :as => 'dryml_support'
+  match 'dev/:action', :controller => 'dev', :as => 'dev_support' if Rails.application.config.hobo.developer_features
+
+end

data/{doctest → doctests}/hobo/lifecycles.rdoctest

@@ -15,17 +15,8 @@ Hobo lifecycles is a mechanism for declaring the life-cycle of a model in a natu
 
 First the junk to get us started:
 
-    doctest_require: 'rubygems'
-    doctest_require: 'active_record'
-    >> $:.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")
-
+doctest: prepare testapp environment
+doctest_require: '../prepare_testapp'
 
 A user model for our example:
 
@@ -42,6 +33,7 @@ Now the friendship. For now we'll just declare the *invite* part of the lifecycl
     >>
      class Friendship < ActiveRecord::Base
        hobo_model
+       fields {} # just to trigger hobo:migration
        belongs_to :requester, :class_name => "User"
        belongs_to :requestee, :class_name => "User"
 
@@ -53,9 +45,7 @@ Now the friendship. For now we'll just declare the *invite* part of the lifecycl
 
 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
+        >> Rails::Generators.invoke 'hobo:migration', %w(-n -m)
         >> User.delete_all
         >> Friendship.delete_all
 
@@ -85,8 +75,8 @@ 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 
+              transition :accept, { :requested => :active}, :available_to => :requestee
+              transition :reject, { :requested => :destroy}, :available_to => :requestee
             end
          end
 
@@ -101,7 +91,7 @@ We can test which transitions are available:
         >> f.lifecycle.available_transitions_for(tom).*.name
         => []
         >> f.lifecycle.available_transitions_for(bob).*.name
-        => ["accept", "reject"]
+        => [:accept, :reject]
         >> f.lifecycle.can_accept?(tom)
         => false
         >> f.lifecycle.can_reject?(tom)
@@ -113,7 +103,7 @@ We can test which transitions are available:
 
 Accept the friendship
 
-        >> f.lifecycle.accept(bob)
+        >> f.lifecycle.accept!(bob)
         >> f.state
         => "active"
 
@@ -137,7 +127,7 @@ Let's try a rejected friendship:
         => true
         >> Friendship.count
         => 1
-        >> f.lifecycle.reject(bob)
+        >> f.lifecycle.reject!(bob)
         >> Friendship.count
         => 0
 
@@ -166,55 +156,53 @@ We'll extend the lifecycle to allow:
 Here is the entire lifecycle
 
         >>
-    class Friendship < ActiveRecord::Base
-      hobo_model
-      belongs_to :requester, :class_name => "User"
-      belongs_to :requestee, :class_name => "User"
+         class Friendship < ActiveRecord::Base
+           fields {}
 
-      lifecycle do
-            state :requested, :active, :ignored
+           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
+             create :request, :params => [ :requestee ], :become => :requested, :available_to => "User", :user_becomes => :requester 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 :accept, { :requested => :active }, :available_to => :requestee 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 :reject, { :requested => :destroy }, :available_to => :requestee do
+               $emails << "Dear #{requester.name}, #{requestee.name} blew you out :-("
+             end
 
-                transition :requestee, :ignore, { :requested => :ignored }
+             transition :ignore, { :requested => :ignored }, :available_to => :requestee
 
-                transition :requester, :retract, { :requested => :destroy } do
-          $emails << "Dear #{requestee.name}, #{requester.name} reconsidered"
-        end
+             transition :retract, { :requested => :destroy }, :available_to => :requester 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
+             transition :cancel, { :active => :destroy }, :available_to => [ :requester, :requestee ]
+             # TODO: send the email - for this we need the acting user to be passed to the block
 
-      end
+           end
 
-    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)
+        >> f.lifecycle.accept!(bob)
         >> $emails.last
         => "Dear Tom, Bob is now your friend :-)"
-        >> f.lifecycle.active?
-        => true
+        >> f.state
+        => "active"
 
 Rejection:
 
         >> f = Friendship::Lifecycle.request(tom, :requestee => bob)
-        >> f.lifecycle.reject(bob)
+        >> f.lifecycle.reject!(bob)
         >> $emails.last
         => "Dear Tom, Bob blew you out :-("
         >> f.state
@@ -225,16 +213,17 @@ Retraction:
         >> f = Friendship::Lifecycle.request(tom, :requestee => bob)
         >> f.lifecycle.can_retract?(bob)
         => false
-        >> f.lifecycle.retract(tom)
+        >> f.lifecycle.retract!(tom)
         >> $emails.last
         => "Dear Bob, Tom reconsidered"
-        >> f.lifecycle.active?
+        >> f.state
+        => "destroy"
 
 Ignoring
 
         >> f = Friendship::Lifecycle.request(tom, :requestee => bob)
         >> $emails = []
-        >> f.lifecycle.ignore(bob)
+        >> f.lifecycle.ignore!(bob)
         >> $emails # Ignoring shouldn't send any email
         => []
         >> f.state
@@ -245,17 +234,9 @@ Requester cancels
         >> f = Friendship::Lifecycle.request(tom, :requestee => bob)
         >> f.lifecycle.can_cancel?(tom)
         => false
-        >> f.lifecycle.accept(bob)
-        >> f.lifecycle.cancel(tom)
+        >> f.lifecycle.accept!(bob)
+        >> f.lifecycle.cancel!(tom)
         >> f.state
         => "destroy"
 
 
-
-
-
-
-
-
-
-