hydra-tutorial 0.1.3 → 0.2.0

metadata

@@ -1,15 +1,16 @@
 --- !ruby/object:Gem::Specification
 name: hydra-tutorial
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.2.0
   prerelease: 
 platform: ruby
 authors:
 - Chris Beer
+- Monty Hindman
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-08-07 00:00:00.000000000 Z
+date: 2012-10-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: thor
@@ -72,32 +73,33 @@ files:
 - README.md
 - Rakefile
 - bin/hydra-tutorial
+- development_notes.txt
 - hydra-tutorial.gemspec
-- open-repositories-tutorial.thor
-- or_templates/add_file_upload/_form.html.erb
-- or_templates/add_tests/ci.rake
-- or_templates/add_tests/ci_with_coverage.rake
-- or_templates/add_tests/integration_spec.rb
-- or_templates/add_tests/records_controller_spec.rb
-- or_templates/adding_our_models/basic_af_model.rb
-- or_templates/adding_our_models/basic_mods_model.rb
-- or_templates/adding_our_models/basic_om_model.rb
-- or_templates/adding_our_models/mods_desc_metadata.rb
-- or_templates/building_a_basic_rails_app/fedora.yml
-- or_templates/building_a_basic_rails_app/solr.yml
-- or_templates/records_controller.rb
-- or_templates/sprinkle_some_styling/_add_assets_links.html.erb
-- or_templates/wiring_it_into_rails/_form.html.erb
-- or_templates/wiring_it_into_rails/show.html.erb
-- templates/application/dataset_hydra_mods_om.rb
-- templates/application/dataset_hydra_om.rb
-- templates/application/datasets_controller.rb
-- templates/application/mods_desc_metadata.rb
-- templates/building_a_basic_rails_app/dataset_af_om.rb
-- templates/building_a_basic_rails_app/dataset_simple_om.rb
-- templates/building_a_basic_rails_app/fedora.yml
-- templates/building_a_basic_rails_app/om_record.rb
-- templates/building_a_basic_rails_app/solr.yml
+- old_tutorial/templates/application/dataset_hydra_mods_om.rb
+- old_tutorial/templates/application/dataset_hydra_om.rb
+- old_tutorial/templates/application/datasets_controller.rb
+- old_tutorial/templates/application/mods_desc_metadata.rb
+- old_tutorial/templates/building_a_basic_rails_app/dataset_af_om.rb
+- old_tutorial/templates/building_a_basic_rails_app/dataset_simple_om.rb
+- old_tutorial/templates/building_a_basic_rails_app/fedora.yml
+- old_tutorial/templates/building_a_basic_rails_app/om_record.rb
+- old_tutorial/templates/building_a_basic_rails_app/solr.yml
+- old_tutorial/tutorial.thor
+- templates/_add_assets_links.html.erb
+- templates/_form.add_file_upload.html.erb
+- templates/_form.wiring_it_into_rails.html.erb
+- templates/basic_af_model.rb
+- templates/basic_mods_model.rb
+- templates/basic_om_model.rb
+- templates/ci.rake
+- templates/ci_with_coverage.rake
+- templates/fedora.yml
+- templates/integration_spec.rb
+- templates/mods_desc_metadata.rb
+- templates/records_controller.rb
+- templates/records_controller_spec.rb
+- templates/show.html.erb
+- templates/solr.yml
 - tutorial.thor
 homepage: http://projecthydra.org
 licenses: []
@@ -113,7 +115,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -4225154311551487159
+      hash: 1291579110055489875
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -122,10 +124,10 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -4225154311551487159
+      hash: 1291579110055489875
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.23
+rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
 summary: Hydra head tutorial walkthrough

data/open-repositories-tutorial.thor

@@ -1,888 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'rubygems'
-require 'thor'
-require 'thor/group'
-require 'rails/generators/actions'
-require 'active_support/core_ext/array/extract_options'
-require 'active_support/core_ext/string/inflections'
-
-$base_templates_path = File.expand_path(File.join(File.dirname(__FILE__), 'or_templates'))
-$application_name = ''
-$application_root = ''
-
-STATEMENT = Thor::Shell::Color::YELLOW
-QUESTION = Thor::Shell::Color::GREEN
-WAIT = Thor::Shell::Color::CYAN
-
-class HydraOpenRepositoriesTutorialApp < Thor::Group
-  include Thor::Actions
-  include Rails::Generators::Actions
-
-  module TutorialActions
-    def continue_prompt
-      ask %Q{
-    HIT <ENTER> KEY TO CONTINUE
-      }, WAIT
-    end
-
-    def rails_console
-      say %Q{
-    We'll launch the console again. Give some of those commands a try.
-      }, STATEMENT
-
-      say %Q{
-
-    Hit Ctrl-D (^D) to stop the Rails console and continue this tutorial.
-      }, WAIT
-
-      run "rails c"
-    end
-
-    def rails_server url = '/'
-      say %Q{
-    We'll start the Rails server for you. It should be available in 
-    your browser at:
-
-       http://localhost:3000#{url}
-      }, STATEMENT
-
-      say %Q{
-
-    Hit Ctrl-C (^C) to stop the Rails server and continue this tutorial.
-      }, WAIT
-
-      run "rails s"
-    end
-  end
-
-  include TutorialActions
-  class_option :quick, :default => false
-  class_option :git, :default => false
-
-  def setup_parameters
-    $quick = options[:quick]
-    $git = options[:git]
-  end
-
-  def welcome
-    say %Q{
-    Welcome to this Hydra tutorial. We're going to step through building a 
-    working Hydra application. We'll build the application gradually, starting 
-    by building our "business logic", wiring in HTML views, and then 
-    connecting it to our Rails application.
-
-    At several points in this tutorial, as we iteratively develop our files, 
-    you may be prompted to review conflicts between versions of files. It is 
-    safe to blindly accept the changes ('y'), however you may wish to view 
-    the diff ('d') to see the things we're change.
-
-    This tutorial, a README file, and our bug tracker are at:
-        
-        https://github.com/projecthydra/hydra-tutorial
-
-    }, STATEMENT
-
-    name = ask %Q{
-    What do you want to call your application?
-    }, QUESTION unless $quick
-
-    name = name.to_s.strip
-    name = 'hydra_tutorial_app' if name.empty?
-
-
-    $application_name = name
-
-    dir = $application_name.parameterize('_')
-    $application_root = dir
-
-    if File.exists? $application_root
-      say %Q{
-    #{$application_root} already exists. Either remove it or provide 
-    a different application name.
-      }, Thor::Shell::Color::RED
-      exit
-    end
-
-    say %Q{
-    We'll generate a stub application #{$application_name} into the folder 
-    #{$application_root}. But, first, lets check your Ruby environment.
-    }, STATEMENT
-
-  end
-
-  def prerequisites
-    Prerequisites.start
-  end
-
-  def building_a_basic_rails_app
-    inside $application_root do
-      BuildingABasicRailsApp.start
-    end
-  end
-  
-  def adding_our_models
-    inside $application_root do
-      AddingOurModels.start
-    end
-  end
-
-  def wiring_it_into_rails 
-    inside $application_root do
-      WiringItIntoRails.start
-    end
-  end
-
-  def add_blacklight_and_hydra
-    inside $application_root do
-      AddBlacklightAndHydra.start
-    end
-  end
-
-  def fixup_for_hydra
-    inside $application_root do
-      FixupForHydra.start
-    end
-  end
-
-  def add_tests
-    inside $application_root do
-      AddTests.start
-    end
-  end
-
-  def add_file_upload
-    inside $application_root do
-      AddFileUpload.start
-    end
-  end
-
-  def sprinkle_some_styling
-    inside $application_root do
-      SprinkeSomeStyling.start
-    end
-  end
-
-  def cleanup
-    inside $application_root do
-      Cleanup.start
-    end
-  end
-
-  class Cleanup < Thor::Group
-
-    include Thor::Actions
-    include Rails::Generators::Actions
-    include TutorialActions
-
-    def start_everything
-      say %Q{
-    This is the end of the tutorial. We'll give you a final chance to look 
-    at the web application.
-      }, STATEMENT
-      rake 'jetty:stop'
-      rake 'jetty:start'
-      rails_server
-    end
-
-    def stop_jetty
-      rake 'jetty:stop'
-    end
-  end
-
-  class Prerequisites < Thor::Group
-    include Thor::Actions
-    include Rails::Generators::Actions
-    include TutorialActions
-
-    def install_ruby
-      return if $quick
-      say %Q{ 
-    Obviously, if you can run this tutorial, you have already installed ruby.
-      }, STATEMENT
-
-
-      ruby_executable = run 'which ruby', :capture => true
-
-      say %Q{
-    You are running this using:
-    #{ruby_executable}
-      }, STATEMENT
-
-      if ruby_executable =~ /rvm/ or ruby_executable =~ /rbenv/ or ruby_executable =~ /home/ or ruby_executable =~ /Users/
-        say %Q{
-    It looks like you're using rvm/rbenv/etc. (with a gemset?) We'll use 
-    this environment to build the application.
-      }, STATEMENT
-
-      else
-
-      say %Q{
-    We checked, and it looks like you might be using a system-wide ruby. 
-    We suggest you use somethng like rvm [1], rbenv [2], etc to manage 
-    your ruby projects.
-
-    You can continue and hope for the best, or go install one of these 
-    ruby managers, which may make your life easier.
-
-    [1] http://rvm.io/
-    [2] https://github.com/sstephenson/rbenv/
-      }, Thor::Shell::Color::RED
-
-      continue_prompt unless $quick
-
-      end
-
-    end
-
-    def install_bundler_and_rails
-      say %Q{
-    We're going to install some prerequisite gems in order to create our 
-    skeleton Rails application.
-      }, STATEMENT
-      run 'gem install bundler rails'
-    end
-
-    def new_rails_app
-      say %Q{
-    Now we'll create the application.
-      }, Thor::Shell::Color::YELLOW
-      run "rails new #{$application_root}"
-      run "cd #{$application_root}"
-    end
-
-    def out_of_the_box
-      return if $quick
-      say %Q{
-    Here's a chance to look around. You can see the structure of 
-    a Rails application. In particular, look at:
-       ./app
-       ./config
-       ./lib
-       Gemfile
-      }, STATEMENT
-
-
-      say %Q{
-    If we launched the Rails application server, we can see the application 
-    running in the browser and you can see if everything is working.
-      }, STATEMENT
-
-
-      inside $application_root do
-        rails_server unless $quick
-      end
-    end
-  end
-
-  class BuildingABasicRailsApp < Thor::Group
-    include Thor::Actions
-    include Rails::Generators::Actions
-    include TutorialActions
-
-    def self.source_paths
-      [File.join($base_templates_path, "building_a_basic_rails_app")]
-    end
-
-
-    def adding_dependencies
-      gem 'execjs'
-      gem 'therubyracer'
-    end
-
-    def add_fedora_and_solr_with_hydrajetty
-
-      say %Q{
-    Fedora runs as a Java servlet inside a container like Tomcat or Jetty.
-    Hydra provides a bundled version of Fedora and Solr for 
-    testing and development.
-      }, STATEMENT
-
-      say %Q{
-    We'll download a copy now. It may take awhile.
-      }, STATEMENT
-      unless File.exists? '../jetty'
-        git :clone => '-b 4.x git://github.com/projecthydra/hydra-jetty.git ../jetty'
-      end
-      run 'cp -R ../jetty jetty'
-
-    end
-
-    def jetty_configuration 
-      say %Q{
-    We'll add some configuration yml files with information to connect 
-    to Solr and Fedora.
-      }, STATEMENT
-
-      copy_file 'solr.yml', 'config/solr.yml'
-      copy_file 'fedora.yml', 'config/fedora.yml'
-
-      say %Q{
-    Add the 'jettywrapper' gem, which adds Rake tasks for start and stop Jetty.
-      }, STATEMENT
-
-      gem 'jettywrapper'
-      run 'bundle install'
-
-      say %Q{
-    Starting Jetty
-      }, STATEMENT
-      rake 'jetty:start'
-
-      say %Q{ 
-    Take a look around. Jetty should be running on port 8983. You can see 
-    the Fedora server at:
-
-      http://localhost:8983/fedora/
-
-    And a Solr index at:
-
-      http://localhost:8983/solr/development/admin/
-      }, STATEMENT
-
-      continue_prompt unless $quick
-
-    end
-
-    # and then clean up some cruft
-    def remove_public_index
-      remove_file 'public/index.html'
-    end
-
-  end
-
-  class AddingOurModels < Thor::Group
-    include Thor::Actions
-    include Rails::Generators::Actions
-    include TutorialActions
-
-    def self.source_paths
-      [File.join($base_templates_path, "adding_our_models")]
-    end
-
-    def add_activefedora
-      say %Q{
-    The active-fedora gem provides a way to model Fedora objects within Ruby.
-    It will help you create Ruby models for creating, updating and reading 
-    objects from Fedora using a domain-specific language (DSL) similar 
-    to the Rails' ActiveRecord.
-
-    The om gem provides mechanisms for mapping XML documents into Ruby.
-
-    We'll add both of these to the Gemfile.
-      }, STATEMENT
-
-      gem 'active-fedora'
-      gem 'om'
-      run 'bundle install'
-    end
-
-    def add_initial_model
-      say %Q{ 
-    Now we'll add a basic ActiveFedora stub model for a 'Record'. 
-      }, STATEMENT
-
-      copy_file "basic_af_model.rb", "app/models/record.rb"
-
-      say %Q{ 
-    It looks like this:
-      }, STATEMENT
-
-      print_wrapped File.read('app/models/record.rb')
-    end
-
-    def rails_console_tour
-
-      say %Q{
-    Now we'll give you a chance to look at the Record model. If you 
-    launch the Rails interactive console (`rails c`), we can create 
-    and manipulate our object:
-
-        ## CREATE
-        > obj = Record.new
-        # => #<Record:1571331701243443635 @pid="__DO_NOT_USE__" >
-        > obj.descMetadata.content = e.g. '<my_xml_content />'
-        > obj.save
-
-        > obj.pid  
-        # => e.g. 'changeme:1'
-
-        ## RETRIEVE
-        > obj = Record.find('changeme:1')
-        > ds = obj.descMetadata
-        # => #<ActiveFedora::NokogiriDatastream:3283711306477137919 ...>
-        > ds.content
-        # => (should be the XML document you added before)
-
-        ## UPDATE
-        # manipulating XML:
-        > ds.ng_xml.xpath('//my_xml_content') 
-
-        ## DELETE
-        > obj.delete
-
-      }, STATEMENT
-
-
-      rails_console unless $quick
-    end
-
-    def enhance_model_with_contrieved_descmd
-      say %Q{
-    Instead of working with the Nokogiri XML document directly, we 
-    can use OM to make querying an XML document easier. We'll replace the 
-    previous Record with a OM-enabled document.
-      }, STATEMENT
-      copy_file "basic_om_model.rb", "app/models/record.rb"
-    end
-
-    def testing_the_contrieved_descmd
-      say %Q{
-    If you launch the Rails interactive console, we can now create and 
-    manipulate our object using methods provided by OM.
-
-        > obj = Record.new
-        > obj.descMetadata.title = "My object title"
-        > obj.save
-        > obj.descMetadata.content
-        # => An XML document with the title "My object title"
-      }, STATEMENT
-
-      rails_console unless $quick
-    end
-
-    def use_the_delegate_method
-      say %Q{
-    We can use the #delegate method to tell the model-object how 
-    to access these attributes.
-
-        > obj = Record.new
-        > obj.title = "My object title"
-        > obj.save
-        > obj.descMetadata.content
-        # => An XML document with the title "My object title"
-      }, STATEMENT
-
-      insert_into_file "app/models/record.rb", :after => %Q{has_metadata :name => "descMetadata", :type => DatastreamMetadata\n} do
-        "delegate :title, :to => 'descMetadata'\n"
-      end
-    end
-
-    def add_mods_model_with_mods_descmd
-      say %Q{
-    We'll now replace the contrieved XML metadata schema with a simple
-    MODS-based example, using an OM terminology we prepared earlier.
-
-    We'll put the MODS datastream in a separate module and file, so that
-    it can be easily reused in other ActiveFedora-based objects.
-      }, STATEMENT
-
-      copy_file "basic_mods_model.rb", "app/models/record.rb"
-      copy_file "mods_desc_metadata.rb", "app/models/mods_desc_metadata.rb"
-
-      say %Q{
-    If you launch the Rails interactive console, we can now create 
-    and manipulate our object using methods provided by OM.
-
-        > obj = Record.new
-        > obj.title = "My object title"
-        > obj.save
-        > obj.descMetadata.content
-        # => A MODS XML document
-      }, STATEMENT
-
-      rails_console unless $quick
-    end
-  end
-
-  class WiringItIntoRails < Thor::Group
-    include Thor::Actions
-    include Rails::Generators::Actions
-    include TutorialActions
-
-    def self.source_paths
-      [File.join($base_templates_path, "wiring_it_into_rails")]
-    end
-    
-    def record_generator
-      say %Q{ 
-    Now that we've set up our model and successfully added content
-    into Fedora, now we want to connect the model to a Rails web application.
-
-    We'll start by using the standard Rails generators to create 
-    a scaffold controller and views, which will give us a 
-    place to start working.
-      }, STATEMENT
-
-      generate "scaffold_controller Record --no-helper --skip-test-framework"
-      route "resources :records"
-
-      say %Q{
-    If you look in ./app/views/records, you can see a set of 
-    Rails ERB templates.
-
-    ./app/controlers/records_controller.rb contains the controller 
-    that ties the model to the views.
-      }, STATEMENT
-
-      continue_prompt unless $quick
-    end
-
-    def add_new_form
-
-      say %Q{
-   The scaffold just provided the basic outline for an application, so 
-   we need to provide the guts for the web form. Here's a simple one:
-      }, STATEMENT
-
-      copy_file "_form.html.erb", "app/views/records/_form.html.erb"
-      copy_file "show.html.erb", "app/views/records/show.html.erb"
-    end
-
-    def check_it_out
-
-      say %Q{
-   If we start the Rails server, we should now be able to visit the records
-   in the browser, create new records, and edit existing records. 
-
-   Start by creating a new record:
-      }, STATEMENT
-
-      rails_server '/records/new' unless $quick
-    end
-
-  end
-
-  class AddBlacklightAndHydra < Thor::Group
-    include Thor::Actions
-    include Rails::Generators::Actions
-    include TutorialActions
-
-    def add_gems
-      say %Q{
-    Thus far, we've been using component parts of the Hydra framework, but 
-    now we'll add in the whole framework so we can take advantage of common 
-    patterns that have emerged in the Hydra community, including search, 
-    gated discovery, etc.
-
-    We'll add a few new gems:
-
-      - blacklight provides a discovery interface on top of the Solr index
-
-      - hydra-head provides a number of common Hydra patterns
-
-      - devise is a standard Ruby gem for providing user-related 
-            functions, like registration, sign-in, etc.
-
-      }, STATEMENT
-
-      if $git
-        gem 'blacklight', :git => "git://github.com/projectblacklight/blacklight.git"
-        gem 'hydra-head', :git => "git://github.com/projecthydra/hydra-head.git"
-      else
-        gem 'blacklight'
-        gem 'hydra-head', ">= 4.1.1"
-      end
-      gem 'devise'
-
-      run 'bundle install'
-    end
-
-    def run_generators
-
-      say %Q{
-    These gems provide generators for adding basic views, styles, and override 
-    points into your application. We'll run these generators now.
-      }, STATEMENT
-      run 'rm config/solr.yml' # avoid meaningless conflict
-      generate 'blacklight', '--devise'
-      run 'rm config/solr.yml' # avoid meaningless conflict
-      generate 'hydra:head', 'User'
-    end
-
-    def db_migrate
-      say %Q{
-    Blacklight uses a SQL database for keeping track of user bookmarks, 
-    searches, etc. We'll run the migrations next:
-      }, STATEMENT
-      rake 'db:migrate'
-      rake 'db:test:prepare'
-    end
-
-    def hydra_jetty_conf
-      say %Q{
-    Hydra provides some configuration for Solr and Fedora. Use them.
-      }, STATEMENT
-      rake 'jetty:stop'
-      rake 'hydra:jetty:config'
-      rake 'jetty:start'
-    end
-  end
-
-  class FixupForHydra < Thor::Group
-    include Thor::Actions
-    include Rails::Generators::Actions
-    include TutorialActions
-
-    def do_it
-
-      say %Q{
-    We need to make a couple changes to our controller and model to make 
-    them fully-compliant objects by teaching them about access rights.
-      }, STATEMENT
-
-      inject_into_class "app/controllers/records_controller.rb", 'RecordsController' do
-        "  include Hydra::AssetsControllerHelper\n"
-      end
-
-      insert_into_file "app/controllers/records_controller.rb", :after => "@record = Record.new(params[:record])\n" do
-        "    apply_depositor_metadata(@record)\n"
-      end
-
-      inject_into_class "app/models/record.rb", "Record" do
-        "
-  include Hydra::ModelMixins::CommonMetadata
-  include Hydra::ModelMethods
-        "
-      end
-
-      insert_into_file "app/models/solr_document.rb", :after => "include Blacklight::Solr::Document\n" do
-        "
-  include Hydra::Solr::Document
-        "
-      end
-      insert_into_file "app/assets/javascripts/application.js", :after => "//= require_tree .\n" do
-        "Blacklight.do_search_context_behavior = function() { }\n"
-      end
-      say %Q{
-    We'll also update our controller to provide access controls on records.
-      }
-
-      inject_into_class "app/controllers/records_controller.rb", 'RecordsController' do
-        "  include Hydra::AccessControlsEnforcement\n" +
-        "  before_filter :enforce_access_controls\n"
-      end
-
-    end
-
-    def look_at_it
-      say %Q{
-    Blacklight and Hydra-Head have added some new functionality to the 
-    application. We can now look at a search interface (provided 
-    by Blacklight) and use gated discovery over our repository. By default, 
-    objects are only visible to their creator.
-
-    Create some new objects, and then check out the search catalog at:
-
-       http://localhost:3000/catalog
-
-      }, STATEMENT
-
-      rails_server('/records/new') unless $quick
-    end
-
-  end
-
-  class AddTests < Thor::Group
-    include Thor::Actions
-    include Rails::Generators::Actions
-    include TutorialActions
-
-    def self.source_paths
-      [File.join($base_templates_path, "add_tests")]
-    end
-
-
-    def install_rspec
-      say %Q{
-    One of the great things about the Rails framework is the strong
-    testing ethic. We'll use rspec to write a couple tests for 
-    this application.
-      }, STATEMENT
-      gem_group :development, :test do
-        gem 'rspec'
-        gem 'rspec-rails'
-      end
-      run 'bundle install'
-
-      generate 'rspec:install'
-    end
-    
-    def write_our_first_test
-      say %Q{
-    Here's a quick example of a test.
-      }
-      copy_file 'records_controller_spec.rb', 'spec/controllers/records_controller_spec.rb'
-      run 'rspec'
-    end
-
-    def a_model_test
-   #   copy_file 'record_test.rb', 'spec/models/record_test.rb'
-      #run 'rspec'
-    end
-
-    def install_capybara
-      say %Q{ 
-    We also want to write integration tests to test the end-result that
-    a user may see. We'll add the capybara gem to do that.
-      }, STATEMENT
-      gem_group :development, :test do
-        gem 'capybara'
-      end
-      run 'bundle install'
-     # inject_into_file 'spec/spec_helper.rb' do
-     #   "  require 'capybara/rails'\n"
-     # end
-    end
-
-    def an_integration_test
-      say %Q{
-    Here's a quick integration test that proves deposit works.
-      }, STATEMENT
-      copy_file 'integration_spec.rb', 'spec/integration/integration_spec.rb'
-    end
-
-    def run_tests_x3
-      say %Q{
-      Now that the integration spec is in place, when we try to run rspec,
-      we'll get a test failure because it can't connect to Fedora.
-      }, STATEMENT
-      run 'rspec'
-    end
-
-    def add_jettywrapper_ci_task
-      say %Q{
-      Instead, we need to add a new Rake task that knows how to wrap the 
-      test suite --  start jetty before running the tests and stop jetty
-      at the end. We can use a feature provided by jettywrapper to do this.
-      }, STATEMENT
-      copy_file 'ci.rake', 'lib/tasks/ci.rake'
-
-      rake 'jetty:stop'
-      rake 'ci'
-      rake 'jetty:start'
-    end
-
-    def add_coverage_stats
-      say %Q{
-      Now that we have tests, we also want to have some coverage statistics.
-      }, STATEMENT
-
-      gem_group :development, :test do
-        gem 'simplecov'
-      end
-
-      run 'bundle install'
-
-      copy_file 'ci_with_coverage.rake', 'lib/tasks/ci.rake'
-      insert_into_file "spec/spec_helper.rb", :after => "ENV[\"RAILS_ENV\"] ||= 'test'\n"do
-        %Q{
-if ENV['COVERAGE'] == "true"
-  require 'simplecov'
-  SimpleCov.start do
-    add_filter "config/"
-    add_filter "spec/"
-  end
-end
-        }
-      end
-
-      rake 'jetty:stop'
-      rake 'ci'
-      rake 'jetty:start'
-    end
-
-    def coverage_prompt
-      say %Q{
-      Go take a look at the coverage report, open the file ./coverage/index.html
-      in your browser.
-      }, STATEMENT
-      continue_prompt
-    end
-  end
-
-  class SprinkeSomeStyling < Thor::Group
-    include Thor::Actions
-    include Rails::Generators::Actions
-    include TutorialActions
-
-    def self.source_paths
-      [File.join($base_templates_path, "sprinkle_some_styling")]
-    end
-
-
-    def fix_add_assets_links
-      say %Q{ 
-    We'll add a little styling to the Hydra app and add a link to add a new 
-    Record in the header of the layout.
-      }, STATEMENT
-      copy_file "_add_assets_links.html.erb", "app/views/_add_assets_links.html.erb"
-    end
-
-
-  end
-
-  class AddCollections
-    def add_collection_model
-
-    end
-
-    def add_collection_controller
-
-    end
-
-    def add_collection_reference_to_record
-
-    end
-  end
-
-  class AddFileUpload < Thor::Group
-    include Thor::Actions
-    include Rails::Generators::Actions
-    include TutorialActions
-    
-    def self.source_paths
-      [File.join($base_templates_path, "add_file_upload")]
-    end
-
-    def add_file_uploads
-      say %Q{ 
-    Now that we have a basic Hydra application working with metadata-only, we
-    want to enhance that with the ability to upload files. Let's add a new 
-    datastream to our model.
-      }, STATEMENT
-      inject_into_class 'app/models/record.rb', 'Record' do
-        "has_file_datastream :name => 'content', :type => ActiveFedora::Datastream\n"
-      end
-    end
-    
-    def add_file_upload_controller
-      say %Q{
-    And educate our controller for managing file objects.
-      }, STATEMENT
-      inject_into_class "app/controllers/records_controller.rb", "RecordsController" do
-        "    include Hydra::Controller::UploadBehavior\n"
-      end
-      insert_into_file "app/controllers/records_controller.rb", :after => "apply_depositor_metadata(@record)\n" do
-        "    @record.label = params[:record][:title] # this is a bad hack to work around an AF bug\n" +
-        "    add_posted_blob_to_asset(@record, params[:filedata]) if params.has_key?(:filedata)\n" 
-      end
-    end
-
-    def add_file_upload_ui
-      say %Q{
-    And add a file upload field on the form.
-      }, STATEMENT
-      copy_file "_form.html.erb", "app/views/records/_form.html.erb"
-    end
-  end
-
-  class AddTechnicalMetadata
-    def add_datastream_and_terminology
-
-    end
-
-  end
-end
-
-HydraOpenRepositoriesTutorialApp.start