merb-gen 0.9.6 → 0.9.7

data/Rakefile

@@ -17,7 +17,7 @@ GEM_EMAIL  = "jonas.nicklas@gmail.com"
 
 GEM_NAME    = "merb-gen"
 PKG_BUILD   = ENV['PKG_BUILD'] ? '.' + ENV['PKG_BUILD'] : ''
-GEM_VERSION = (Merb::MORE_VERSION rescue "0.9.6") + PKG_BUILD
+GEM_VERSION = (Merb::MORE_VERSION rescue "0.9.7") + PKG_BUILD
 
 RELEASE_NAME    = "REL #{GEM_VERSION}"
 
@@ -38,11 +38,10 @@ spec = Gem::Specification.new do |s|
   s.bindir = "bin"
   s.executables = %w( merb-gen )
 
-  s.add_dependency "merb-core", ">= 0.9.6"
+  s.add_dependency "merb-core", ">= 0.9.7"
   s.add_dependency "templater", ">= 0.2.0"
 
   s.require_path = 'lib'
-  s.autorequire = GEM_NAME
   s.files = %w(LICENSE README Rakefile TODO) + Dir.glob("{lib,bin,spec}/**/*")
 end
 

data/bin/merb-gen

@@ -1,36 +1,6 @@
 #!/usr/bin/env ruby
 
-# See also: merb-gen scripts and script/merb-gen
-
-# Try to use minigems instead of the fully rubygems library
-begin
-  require 'minigems'
-rescue LoadError
-  require 'rubygems'
-end
-
-# Load script helpers if available - either local or system-wide.
-begin
-  # Figure out the merb root - defaults to the current directory.
-  root_key = %w[-m --merb-root].detect { |o| ARGV.index(o) }
-  root = ARGV[ARGV.index(root_key) + 1] if root_key
-  __DIR__ = root.to_a.empty? ? Dir.getwd : root
-  
-  # Piggyback on the merb-core rubygem for initial setup scripts.
-  # Requiring it doesn't affect the local gem version of merb-core
-  # we might effectively want to load here after.
-  if merb_core_dir = Dir[File.join(__DIR__, 'gems', 'gems', 'merb-core-*')].last
-    require File.join(merb_core_dir, 'lib', 'merb-core', 'script')
-  else
-    require 'merb-core/script'
-  end
-  # Now setup local gems to be incorporated into the normal loaded gems.
-  # Unless the option --no-frozen is given, local gems are enabled.
-  include Merb::ScriptHelpers
-  setup_local_gems!(__DIR__)
-rescue LoadError
-end
-
+require 'rubygems'
 require 'merb-gen'
 
 Merb::BootLoader.after_app_loads do

data/lib/generators/merb/merb_flat.rb

@@ -16,6 +16,8 @@ module Merb::Generators
     
     glob!
     
+    empty_directory :gems, 'gems'
+    
     def destination_root
       File.join(@destination_root, base_name)
     end

data/lib/generators/merb/merb_full.rb

@@ -20,6 +20,8 @@ module Merb::Generators
     
     glob!
     
+    empty_directory :gems, 'gems'
+        
     first_argument :name, :required => true, :desc => "Application name"
     
     invoke :layout do |generator|

data/lib/generators/templates/application/merb/Rakefile

@@ -1,35 +1,11 @@
 require 'rubygems'
-
-# Figure out the merb root - defaults to the current directory.
-__DIR__ = ENV['MERB_ROOT'] || Dir.getwd
-
-# Piggyback on the merb-core rubygem for initial setup scripts.
-# Requiring it doesn't affect the local gem version of merb-core
-# we might effectively want to load here after. 
-if merb_core_dir = Dir[File.join(__DIR__, 'gems', 'gems', 'merb-core-*')].last
-  require File.join(merb_core_dir, 'lib', 'merb-core', 'script')
-else
-  require 'merb-core/script'
-end
-
-# Include some script helper methods.
-include Merb::ScriptHelpers
-
-# Now setup local gems to be incorporated into the normal loaded gems.
-setup_local_gems!(__DIR__)
-
-# When running rake tasks, you can disable local gems using NO_FROZEN:
-# rake NO_FROZEN=true -T # see all rake tasks, loaded from system gems.
-
 require 'rake'
 require 'rake/rdoctask'
 require 'rake/testtask'
 require 'spec/rake/spectask'
 require 'fileutils'
 
-# Require the *real* merb-core, which is the local version for a frozen setup.
 require "merb-core"
-
 require 'merb-core/tasks/merb'
 include FileUtils
 
@@ -54,4 +30,4 @@ end
 ##############################################################################
 # ADD YOUR CUSTOM TASKS IN /lib/tasks
 # NAME YOUR RAKE FILES file_name.rake
-##############################################################################
+##############################################################################

data/lib/generators/templates/application/merb/app/views/exceptions/not_acceptable.html.erb

@@ -57,7 +57,7 @@
   <div id="footer-container">
     <hr />
     <div class="left"></div>
-    <div class="right">&copy; 2007 the merb dev team</div>
+    <div class="right">&copy; 2008 the merb dev team</div>
     <p>&nbsp;</p>
   </div>
 </div>

data/lib/generators/templates/application/merb/app/views/exceptions/not_found.html.erb

@@ -41,7 +41,7 @@
   <div id="footer-container">
     <hr />
     <div class="left"></div>
-    <div class="right">&copy; 2007 the merb dev team</div>
+    <div class="right">&copy; 2008 the merb dev team</div>
     <p>&nbsp;</p>
   </div>
 </div>

data/lib/generators/templates/application/merb/config/init.rb

@@ -43,21 +43,37 @@ $KCODE = 'UTF8'
 
 # ==== Dependencies
 
-# These are some examples of how you might specify dependencies.
-# Dependency loading is delayed to a later Merb app
-# boot stage, but it may be important when
-# another part of your configuration relies on libraries specified
-# here.
-#
-# dependencies "RedCloth", "merb_helpers"
-# OR
+# These are a few, but not all, of the standard merb-more dependencies:
+#
+# dependency "merb-action-args"   # Provides support for querystring arguments to be passed in to controller actions
+# dependency "merb-assets"        # Provides link_to, asset_path, auto_link, image_tag methods (and lots more)
+# dependency "merb-cache"         # Provides your application with caching functions 
+# dependency "merb-haml"          # Adds rake tasks and the haml generators to your merb app
+# dependency "merb-jquery"        # Provides a #jquery method to insert jQuery code in to a content block
+# dependency "merb-mailer"        # Integrates mail support via Merb Mailer
+
+# These are a few, but not all, of the merb-plugin dependencies:
+#
+# dependency "merb_helpers"           # Provides the form, date/time, and other helpers
+# dependency "merb_param_protection"  # Lets you have better control over your query string params and param logging
+# dependency "merb_stories"           # Provides rspec helper methods for your application
+
+# Miscellaneous dependencies:
+#
+# Specify more than one dependency at a time with the #dependencies method:
+# dependencies "RedCloth", "BlueCloth"
+
+# Specify a specific version of a dependency
 # dependency "RedCloth", "> 3.0"
-# OR
-# dependencies "RedCloth" => "> 3.0", "ruby-aes-cext" => "= 1.0"
-Merb::BootLoader.after_app_loads do
-  # Add dependencies here that must load after the application loads:
 
-  # dependency "magic_admin" # this gem uses the app's model classes
+# Specify more than one dependency at a time as well as the version:
+# dependencies "RedCloth" => "> 3.0", "BlueCloth" => "= 1.0.0"
+
+# You can also add in dependencies after your application loads.
+Merb::BootLoader.after_app_loads do
+  # For example, the magic_admin gem uses the app's model classes. This requires that the models be 
+  # loaded already. So, we can put the magic_admin dependency here:
+  # dependency "magic_admin"
 end
 
 #

data/lib/generators/templates/application/merb/merb.thor

@@ -0,0 +1,822 @@
+#!/usr/bin/env ruby
+require 'rubygems'
+require 'rubygems/dependency_installer'
+require 'rubygems/uninstaller'
+require 'thor'
+require 'fileutils'
+require 'yaml'
+
+module MerbThorHelper
+  
+  private
+    
+  # The current working directory, or Merb app root (--merb-root option).
+  def working_dir
+    @_working_dir ||= File.expand_path(options['merb-root'] || Dir.pwd)
+  end
+  
+  # We should have a ./src dir for local and system-wide management.
+  def source_dir
+    @_source_dir  ||= File.join(working_dir, 'src')
+    create_if_missing(@_source_dir)
+    @_source_dir
+  end
+  
+  # If a local ./gems dir is found, it means we are in a Merb app.
+  def application?
+    gem_dir
+  end
+  
+  # If a local ./gems dir is found, return it.
+  def gem_dir
+    if File.directory?(dir = File.join(working_dir, 'gems'))
+      dir
+    end
+  end
+  
+  # If we're in a Merb app, we can have a ./bin directory;
+  # create it if it's not there.
+  def bin_dir
+    @_bin_dir ||= begin
+      if gem_dir
+        dir = File.join(working_dir, 'bin') 
+        create_if_missing(dir)
+        dir
+      end
+    end
+  end
+  
+  # Helper to create dir unless it exists.
+  def create_if_missing(path)
+    FileUtils.mkdir(path) unless File.exists?(path)
+  end
+  
+  # Create a modified executable wrapper in the app's ./bin directory.
+  def ensure_local_bin_for(*gems)
+    if bin_dir && File.directory?(bin_dir)
+      gems.each do |gem|
+        if gemspec_path = Dir[File.join(gem_dir, 'specifications', "#{gem}-*.gemspec")].last
+          spec = Gem::Specification.load(gemspec_path)
+          spec.executables.each do |exec|             
+            if File.exists?(executable = File.join(gem_dir, 'bin', exec))
+              local_executable = File.join(bin_dir, exec)
+              puts "Adding local executable #{local_executable}"
+              File.open(local_executable, 'w', 0755) do |f| 
+                f.write(executable_wrapper(spec, exec))
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+  
+  def executable_wrapper(spec, bin_file_name)
+    <<-TEXT
+#!/usr/bin/env #{RbConfig::CONFIG["ruby_install_name"]}
+#
+# This file was generated by merb.thor.
+#
+# The application '#{spec.name}' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+require 'rubygems'
+
+if File.directory?(gems_dir = File.join(File.dirname(__FILE__), '..', 'gems'))
+  $BUNDLE = true; Gem.clear_paths; Gem.path.unshift(gems_dir)
+end
+
+version = "#{Gem::Requirement.default}"
+
+if ARGV.first =~ /^_(.*)_$/ and Gem::Version.correct? $1 then
+  version = $1
+  ARGV.shift
+end
+
+gem '#{spec.name}', version
+load '#{bin_file_name}'
+TEXT
+  end
+  
+end
+
+# TODO
+# - a task to figure out an app's dependencies
+# - pulling a specific UUID/Tag (gitspec hash) with clone/update
+# - a 'deploy' task (in addition to 'redeploy' ?)
+# - eventually take a --orm option for the 'merb-stack' type of tasks
+
+class Merb < Thor
+  
+  class SourcePathMissing < Exception
+  end
+  
+  class GemPathMissing < Exception
+  end
+  
+  class GemInstallError < Exception
+  end
+  
+  class GemUninstallError < Exception
+  end
+  
+  # Install a Merb stack from stable RubyForge gems. Optionally install a 
+  # suitable Rack adapter/server when setting --adapter to one of the 
+  # following: mongrel, emongrel, thin or ebb.
+  
+  desc 'stable', 'Install extlib, merb-core and merb-more from rubygems'
+  method_options "--merb-root" => :optional,
+                 "--adapter"   => :optional
+  def stable
+    adapters = %w[mongrel emongrel thin ebb]
+    stable = Stable.new
+    stable.options = options
+    if stable.core && stable.more
+      puts "Installed extlib, merb-core and merb-more"
+      if options[:adapter] && adapters.include?(options[:adapter]) &&
+        stable.refresh_from_gems(options[:adapter])
+        puts "Installed #{options[:adapter]}"
+      elsif options[:adapter]
+        puts "Please specify one of the following adapters: #{adapters.join(' ')}"
+      end
+    end  
+  end  
+
+  class Stable < Thor
+
+    # The Stable tasks deal with known -stable- gems; available
+    # as shortcuts to Merb and DataMapper gems.
+    #
+    # These are pulled from rubyforge and installed into into the 
+    # desired gems dir (either system-wide or into the application's 
+    # gems directory).
+    
+    include MerbThorHelper
+    
+    # Gets latest gem versions from RubyForge and installs them.
+    #
+    # Examples:
+    #
+    # thor merb:edge:core
+    # thor merb:edge:core --merb-root ./path/to/your/app
+    # thor merb:edge:core --sources ./path/to/sources.yml
+    
+    desc 'core', 'Install extlib and merb-core from git HEAD'
+    method_options "--merb-root" => :optional
+    def core
+      refresh_from_gems 'extlib', 'merb-core'
+      ensure_local_bin_for('merb-core', 'rake', 'rspec', 'thor')
+    end
+    
+    desc 'more', 'Install merb-more from rubygems'
+    method_options "--merb-root" => :optional
+    def more
+      refresh_from_gems 'merb-more'
+      ensure_local_bin_for('merb-gen')
+    end
+    
+    desc 'plugins', 'Install merb-plugins from rubygems'
+    method_options "--merb-root" => :optional
+    def plugins
+      refresh_from_gems 'merb-plugins'
+    end
+    
+    desc 'dm_core', 'Install dm-core from rubygems'
+    method_options "--merb-root" => :optional
+    def dm_core
+      refresh_from_gems 'extlib', 'dm-core'
+    end
+    
+    desc 'dm_more', 'Install dm-more from rubygems'
+    method_options "--merb-root" => :optional
+    def dm_more
+      refresh_from_gems 'extlib', 'dm-core', 'dm-more'
+    end
+    
+    # Pull from RubyForge and install.
+    def refresh_from_gems(*components)
+      gems = Gems.new
+      gems.options = options
+      components.all? { |name| gems.install(name) }
+    end
+    
+  end
+
+  # Retrieve latest Merb versions from git and optionally install them.
+  #
+  # Note: the --sources option takes a path to a YAML file
+  # with a regular Hash mapping gem names to git urls.
+  #
+  # Examples:
+  #
+  # thor merb:edge
+  # thor merb:edge --install
+  # thor merb:edge --merb-root ./path/to/your/app
+  # thor merb:edge --sources ./path/to/sources.yml
+
+  desc 'edge', 'Install extlib, merb-core and merb-more from git HEAD'
+  method_options "--merb-root" => :optional, 
+                 "--sources"   => :optional,
+                 "--install"   => :boolean
+  def edge
+    edge = Edge.new
+    edge.options = options
+    edge.core
+    edge.more
+  end
+
+  class Edge < Thor
+    
+    # The Edge tasks deal with known gems from the bleeding edge; available
+    # as shortcuts to Merb and DataMapper gems.
+    #
+    # These are pulled from git and optionally installed into into the 
+    # desired gems dir (either system-wide or into the application's 
+    # gems directory).
+    
+    include MerbThorHelper
+    
+    # Gets latest gem versions from git - optionally installs them.
+    #
+    # Note: the --sources option takes a path to a YAML file
+    # with a regular Hash mapping gem names to git urls,
+    # allowing pulling forks of the official repositories.
+    #
+    # Examples:
+    #
+    # thor merb:edge:core
+    # thor merb:edge:core --install
+    # thor merb:edge:core --merb-root ./path/to/your/app
+    # thor merb:edge:core --sources ./path/to/sources.yml
+    
+    desc 'core', 'Update extlib and merb-core from git HEAD'
+    method_options "--merb-root" => :optional, 
+                   "--sources"   => :optional,
+                   "--install"   => :boolean
+    def core
+      refresh_from_source 'thor', 'extlib', 'merb-core'
+      ensure_local_bin_for('merb-core', 'rake', 'rspec', 'thor')
+    end
+    
+    desc 'more', 'Update merb-more from git HEAD'
+    method_options "--merb-root" => :optional, 
+                   "--sources"   => :optional,
+                   "--install"   => :boolean
+    def more
+      refresh_from_source 'merb-more'
+      ensure_local_bin_for('merb-gen')
+    end
+    
+    desc 'plugins', 'Update merb-plugins from git HEAD'
+    method_options "--merb-root" => :optional, 
+                   "--sources"   => :optional,
+                   "--install"   => :boolean
+    def plugins
+      refresh_from_source 'merb-plugins'
+    end
+    
+    desc 'dm_core', 'Update dm-core from git HEAD'
+    method_options "--merb-root" => :optional, 
+                   "--sources"   => :optional,
+                   "--install"   => :boolean
+    def dm_core
+      refresh_from_source 'extlib', 'dm-core'
+    end
+    
+    desc 'dm_more', 'Update dm-more from git HEAD'
+    method_options "--merb-root" => :optional, 
+                   "--sources"   => :optional,
+                   "--install"   => :boolean
+    def dm_more
+      refresh_from_source 'extlib', 'dm-core', 'dm-more'
+    end
+    
+    private
+    
+    # Pull from git and optionally install the resulting gems.
+    def refresh_from_source(*components)
+      source = Source.new
+      source.options = options
+      components.each do |name|
+        source.clone(name)
+        source.install(name) if options[:install]
+      end
+    end
+    
+  end
+    
+  class Source < Thor
+    
+    # The Source tasks deal with gem source packages - mainly from github.
+    # Any directory inside ./src is regarded as a gem that can be packaged
+    # and installed from there into the desired gems dir (either system-wide
+    # or into the application's gems directory).
+    
+    include MerbThorHelper
+    
+    # Install a particular gem from source. 
+    #
+    # If a local ./gems dir is found, or --merb-root is given
+    # the gems will be installed locally into that directory.
+    #
+    # Note that this task doesn't retrieve any (new) source from git;
+    # To update and install you'd execute the following two tasks:
+    #
+    # thor merb:source:update merb-core
+    # thor merb:source:install merb-core
+    #
+    # Alternatively, look at merb:edge and merb:edge:* with --install.
+    #
+    # Examples:
+    # 
+    # thor merb:source:install merb-core
+    # thor merb:source:install merb-more
+    # thor merb:source:install merb-more/merb-slices
+    # thor merb:source:install merb-plugins/merb_helpers
+    # thor merb:source:install merb-core --merb-root ./path/to/your/app
+    
+    desc 'install GEM_NAME', 'Install a rubygem from (git) source'
+    method_options "--merb-root" => :optional
+    def install(name)
+      puts "Installing #{name}..."
+      gem_src_dir = File.join(source_dir, name)
+      opts = {}
+      opts[:install_dir] = gem_dir   if gem_dir
+      Merb.install_gem_from_src(gem_src_dir, opts)
+    rescue Merb::SourcePathMissing
+      puts "Missing rubygem source path: #{gem_src_dir}"
+    rescue Merb::GemPathMissing
+      puts "Missing rubygems path: #{gem_dir}"
+    rescue => e
+      puts "Failed to install #{name} (#{e.message})"
+    end
+    
+    # Clone a git repository into ./src. The repository can be
+    # a direct git url or a known -named- repository.
+    # 
+    # Examples:
+    #
+    # thor merb:source:clone dm-core
+    # thor merb:source:clone dm-core --sources ./path/to/sources.yml
+    # thor merb:source:clone git://github.com/sam/dm-core.git
+    
+    desc 'clone REPOSITORY', 'Clone a git repository into ./src'
+    method_options "--sources" => :optional
+    def clone(repository)
+      if repository =~ /^git:\/\//
+        repository_url = repository
+      elsif url = Merb.repos(options[:sources])[repository]
+        repository_url = url
+      end
+      
+      if repository_url
+        repository_name = repository_url[/([\w+|-]+)\.git/u, 1]
+        fork_name = repository_url[/.com\/+?(.+)\/.+\.git/u, 1]
+        local_repo_path =  "#{source_dir}/#{repository_name}"
+      
+        if File.directory?(local_repo_path)
+          puts "\n#{repository_name} repository exists, updating or branching instead of cloning..."
+          FileUtils.cd(local_repo_path) do
+
+            # to avoid conflicts we need to set a remote branch for non official repos
+            existing_repos  = `git remote -v`.split("\n").map{|branch| branch.split(/\s+/)}
+            origin_repo_url = existing_repos.detect{ |r| r.first == "origin" }.last
+        
+            # pull from the original repository - no branching needed
+            if repository_url == origin_repo_url
+              puts "Pulling from #{repository_url}"            
+              system %{
+                git fetch
+                git checkout master
+                git rebase origin/master
+              }
+            # update and switch to a branch for a particular github fork
+            elsif existing_repos.map{ |r| r.last }.include?(repository_url)
+              puts "Switching to remote branch: #{fork_name}"
+              `git checkout -b #{fork_name} #{fork_name}/master`
+              `git rebase #{fork_name}/master`            
+            # create a new remote branch for a particular github fork 
+            else
+              puts "Add a new remote branch: #{fork_name}"
+              `git remote add -f #{fork_name} #{repository_url}`
+              `git checkout -b#{fork_name} #{fork_name}/master`
+            end
+          end
+        else
+          FileUtils.cd(source_dir) do
+            puts "\nCloning #{repository_name} repository from #{repository_url}..."
+            system("git clone --depth=1 #{repository_url} ")
+          end
+        end
+      else
+        puts "No valid repository url given"
+      end
+    end
+    
+    # Update a specific gem source directory from git. See #clone.
+    
+    desc 'update REPOSITORY_URL', 'Update a git repository in ./src'
+    alias :update :clone
+    
+    # Update all gem sources from git - based on the current branch.
+    
+    desc 'refresh', 'Pull fresh copies of all source gems'
+    def refresh
+      repos = Dir["#{source_dir}/*"]
+      repos.each do |repo|
+        next unless File.directory?(repo) && File.exists?(File.join(repo, '.git'))
+        FileUtils.cd(repo) do
+          puts "Refreshing #{File.basename(repo)}"
+          branch = `git branch --no-color 2> /dev/null | sed -e '/^[^*]/d' -e 's/* \(.*\)/(\1) /'`[/\* (.+)/, 1]
+          system %{git rebase #{branch}}
+        end
+      end
+    end
+
+  end
+  
+  class Gems < Thor
+    
+    # The Gems tasks deal directly with rubygems, either through remotely
+    # available sources (rubyforge for example) or by searching the
+    # system-wide gem cache for matching gems. The gems are installed from 
+    # there into the desired gems dir (either system-wide or into the 
+    # application's gems directory).
+    
+    include MerbThorHelper
+    
+    # Install a gem and its dependencies.
+    #
+    # If a local ./gems dir is found, or --merb-root is given
+    # the gems will be installed locally into that directory.
+    #
+    # The option --cache will look in the system's gem cache
+    # for the latest version and install it in the apps' gems.
+    # This is particularly handy for gems that aren't available
+    # through rubyforge.org - like in-house merb slices etc.
+    #
+    # Examples:
+    #
+    # thor merb:gems:install merb-core
+    # thor merb:gems:install merb-core --cache
+    # thor merb:gems:install merb-core --version 0.9.7
+    # thor merb:gems:install merb-core --merb-root ./path/to/your/app
+    
+    desc 'install GEM_NAME', 'Install a gem from rubygems'
+    method_options "--version"   => :optional, 
+                   "--merb-root" => :optional,
+                   "--cache"     => :boolean
+    def install(name)
+      puts "Installing #{name}..."
+      opts = {}
+      opts[:version] = options[:version]
+      opts[:cache] = options[:cache] if gem_dir
+      opts[:install_dir] = gem_dir   if gem_dir
+      Merb.install_gem(name, opts)
+    rescue => e
+      puts "Failed to install #{name} (#{e.message})"
+    end
+    
+    # Update a gem and its dependencies.
+    #
+    # If a local ./gems dir is found, or --merb-root is given
+    # the gems will be installed locally into that directory.
+    #
+    # The option --cache will look in the system's gem cache
+    # for the latest version and install it in the apps' gems.
+    # This is particularly handy for gems that aren't available
+    # through rubyforge.org - like in-house merb slices etc.
+    #
+    # Examples:
+    #
+    # thor merb:gems:update merb-core
+    # thor merb:gems:update merb-core --cache
+    # thor merb:gems:update merb-core --merb-root ./path/to/your/app
+    
+    desc 'update GEM_NAME', 'Update a gem from rubygems'
+    method_options "--merb-root" => :optional,
+                   "--cache"     => :boolean
+    def update(name)
+      puts "Updating #{name}..."
+      opts = {}
+      if gem_dir
+        if gemspec_path = Dir[File.join(gem_dir, 'specifications', "#{name}-*.gemspec")].last
+          gemspec = Gem::Specification.load(gemspec_path)
+          opts[:version] = Gem::Requirement.new [">#{gemspec.version}"]
+        end
+        opts[:install_dir] = gem_dir
+        opts[:cache] = options[:cache]
+      end
+      Merb.install_gem(name, opts)
+    rescue => e
+      puts "Failed to update #{name} (#{e.message})"
+    end
+    
+    # Uninstall a gem - ignores dependencies.
+    #
+    # If a local ./gems dir is found, or --merb-root is given
+    # the gems will be uninstalled locally from that directory.
+    #
+    # Examples:
+    #
+    # thor merb:gems:uninstall merb-core
+    # thor merb:gems:uninstall merb-core --all
+    # thor merb:gems:uninstall merb-core --version 0.9.7
+    # thor merb:gems:uninstall merb-core --merb-root ./path/to/your/app
+    
+    desc 'install GEM_NAME', 'Install a gem from rubygems'
+    desc 'uninstall GEM_NAME', 'Uninstall a gem'
+    method_options "--version"   => :optional, 
+                   "--merb-root" => :optional,
+                   "--all" => :boolean
+    def uninstall(name)
+      puts "Uninstalling #{name}..."
+      opts = {}
+      opts[:ignore] = true
+      opts[:all] = options[:all]
+      opts[:executables] = true
+      opts[:version] = options[:version]
+      opts[:install_dir] = gem_dir if gem_dir
+      Merb.uninstall_gem(name, opts)
+    rescue => e
+      puts "Failed to uninstall #{name} (#{e.message})"  
+    end
+    
+    # Completely remove a gem and all its versions - ignores dependencies.
+    #
+    # If a local ./gems dir is found, or --merb-root is given
+    # the gems will be uninstalled locally from that directory.
+    #
+    # Examples:
+    #
+    # thor merb:gems:wipe merb-core
+    # thor merb:gems:wipe merb-core --merb-root ./path/to/your/app
+    
+    desc 'wipe GEM_NAME', 'Remove a gem completely'
+    method_options "--merb-root" => :optional
+    def wipe(name)
+      puts "Wiping #{name}..."
+      opts = {}
+      opts[:ignore] = true
+      opts[:all] = true
+      opts[:executables] = true
+      opts[:install_dir] = gem_dir if gem_dir
+      Merb.uninstall_gem(name, opts)
+    rescue => e
+      puts "Failed to wipe #{name} (#{e.message})"  
+    end
+    
+    # This task should be executed as part of a deployment setup, where
+    # the deployment system runs this after the app has been installed.
+    # Usually triggered by Capistrano, God...
+    #
+    # It will regenerate gems from the bundled gems cache for any gem
+    # that has C extensions - which need to be recompiled for the target
+    # deployment platform.
+    
+    desc 'redeploy', 'Recreate any binary gems on the target deployment platform'
+    def redeploy
+      require 'tempfile' # for 
+      if File.directory?(specs_dir = File.join(gem_dir, 'specifications')) &&
+        File.directory?(cache_dir = File.join(gem_dir, 'cache'))
+        Dir[File.join(specs_dir, '*.gemspec')].each do |gemspec_path|
+          unless (gemspec = Gem::Specification.load(gemspec_path)).extensions.empty?
+            if File.exists?(gem_file = File.join(cache_dir, "#{gemspec.full_name}.gem"))
+              gem_file_copy = File.join(Dir::tmpdir, File.basename(gem_file))
+              # Copy the gem to a temporary file, because otherwise RubyGems/FileUtils
+              # will complain about copying identical files (same source/destination).
+              FileUtils.cp(gem_file, gem_file_copy) 
+              Merb.install_gem(gem_file_copy, :install_dir => gem_dir)
+              File.delete(gem_file_copy)
+            end
+          end
+        end
+      else
+        puts "No application local gems directory found"
+      end
+    end
+    
+  end
+  
+  class << self
+        
+    # Default Git repositories - pass source_config option
+    # to load a yaml configuration file.
+    def repos(source_config = nil)
+      @_repos ||= begin
+        repositories = {
+          'merb-core'     => "git://github.com/wycats/merb-core.git",
+          'merb-more'     => "git://github.com/wycats/merb-more.git",
+          'merb-plugins'  => "git://github.com/wycats/merb-plugins.git",
+          'extlib'        => "git://github.com/sam/extlib.git",
+          'dm-core'       => "git://github.com/sam/dm-core.git",
+          'dm-more'       => "git://github.com/sam/dm-more.git",
+          'thor'          => "git://github.com/wycats/thor.git"
+          }
+      end
+      if source_config && File.exists?(source_config)
+        @_repos.merge(YAML.load(File.read(source_config)))
+      else
+        @_repos
+      end
+    end
+    
+    # Install a gem - looks remotely and local gem cache;
+    # won't process rdoc or ri options.
+    def install_gem(gem, options = {})
+      from_cache = (options.key?(:cache) && options.delete(:cache))
+      if from_cache
+        install_gem_from_cache(gem, options)
+      else
+        version = options.delete(:version)
+        Gem.configuration.update_sources = false
+        installer = Gem::DependencyInstaller.new(options.merge(:user_install => false))
+        exception = nil
+        begin
+          installer.install gem, version
+        rescue Gem::InstallError => e
+          exception = e
+        rescue Gem::GemNotFoundException => e
+          if from_cache && gem_file = find_gem_in_cache(gem, version)
+            puts "Located #{gem} in gem cache..."
+            installer.install gem_file
+          else
+            exception = e
+          end
+        rescue => e
+          exception = e
+        end
+        if installer.installed_gems.empty? && exception
+          puts "Failed to install gem '#{gem}' (#{exception.message})"
+        end
+        installer.installed_gems.each do |spec|
+          puts "Successfully installed #{spec.full_name}"
+        end
+      end
+    end
+    
+    # Install a gem - looks in the system's gem cache instead of remotely;
+    # won't process rdoc or ri options.
+    def install_gem_from_cache(gem, options = {})
+      version = options.delete(:version)
+      Gem.configuration.update_sources = false
+      installer = Gem::DependencyInstaller.new(options.merge(:user_install => false))
+      exception = nil
+      begin
+        if gem_file = find_gem_in_cache(gem, version)
+          puts "Located #{gem} in gem cache..."
+          installer.install gem_file
+        else
+          raise Gem::InstallError, "Unknown gem #{gem}" 
+        end
+      rescue Gem::InstallError => e
+        exception = e
+      end
+      if installer.installed_gems.empty? && exception
+        puts "Failed to install gem '#{gem}' (#{e.message})"
+      end
+      installer.installed_gems.each do |spec|
+        puts "Successfully installed #{spec.full_name}"
+      end
+    end
+  
+    # Install a gem from source - builds and packages it first then installs it.
+    def install_gem_from_src(gem_src_dir, options = {})
+      raise SourcePathMissing unless File.directory?(gem_src_dir)
+      raise GemPathMissing if options[:install_dir] && !File.directory?(options[:install_dir])
+  
+      gem_name = File.basename(gem_src_dir)
+      gem_pkg_dir = File.expand_path(File.join(gem_src_dir, 'pkg'))
+
+      # We need to use local bin executables if available.
+      thor = which('thor')
+      rake = which('rake')
+
+      # Handle pure Thor installation instead of Rake
+      if File.exists?(File.join(gem_src_dir, 'Thorfile'))
+        # Remove any existing packages.
+        FileUtils.rm_rf(gem_pkg_dir) if File.directory?(gem_pkg_dir)
+        # Create the package.
+        FileUtils.cd(gem_src_dir) { system("#{thor} :package") }
+        # Install the package using rubygems.
+        if package = Dir[File.join(gem_pkg_dir, "#{gem_name}-*.gem")].last
+          FileUtils.cd(File.dirname(package)) do
+            install_gem(File.basename(package), options.dup)
+            return 
+          end
+        else
+          raise Merb::GemInstallError, "No package found for #{gem_name}"
+        end
+      # Handle standard installation through Rake
+      else
+        # Clean and regenerate any subgems for meta gems.
+        Dir[File.join(gem_src_dir, '*', 'Rakefile')].each do |rakefile|
+          FileUtils.cd(File.dirname(rakefile)) { system("#{rake} clobber_package; #{rake} package") }             
+        end
+  
+        # Handle the main gem install.
+        if File.exists?(File.join(gem_src_dir, 'Rakefile'))
+          # Remove any existing packages.
+          FileUtils.cd(gem_src_dir) { system("#{rake} clobber_package") }
+          # Create the main gem pkg dir if it doesn't exist.
+          FileUtils.mkdir_p(gem_pkg_dir) unless File.directory?(gem_pkg_dir)
+          # Copy any subgems to the main gem pkg dir.
+          Dir[File.join(gem_src_dir, '**', 'pkg', '*.gem')].each do |subgem_pkg|
+            FileUtils.cp(subgem_pkg, gem_pkg_dir)
+          end
+    
+          # Finally generate the main package and install it; subgems 
+          # (dependencies) are local to the main package.
+          FileUtils.cd(gem_src_dir) do 
+            system("#{rake} package")
+            if package = Dir[File.join(gem_pkg_dir, "#{gem_name}-*.gem")].last
+              FileUtils.cd(File.dirname(package)) do
+                install_gem(File.basename(package), options.dup)
+                return 
+              end
+            else
+              raise Merb::GemInstallError, "No package found for #{gem_name}"
+            end
+          end
+        end
+      end
+      raise Merb::GemInstallError, "No Rakefile found for #{gem_name}"
+    end
+    
+    # Uninstall a gem.
+    def uninstall_gem(gem, options = {})
+      if options[:version] && !options[:version].is_a?(Gem::Requirement)
+        options[:version] = Gem::Requirement.new ["= #{version}"]
+      end
+      begin
+        Gem::Uninstaller.new(gem, options).uninstall
+      rescue => e
+        raise GemUninstallError, "Failed to uninstall #{gem}"
+      end
+    end
+    
+    # Will prepend sudo on a suitable platform.
+    def sudo
+      @_sudo ||= begin 
+        windows = PLATFORM =~ /win32|cygwin/ rescue nil
+        windows ? "" : "sudo "
+      end
+    end
+    
+    # Use the local bin/* executables if available.
+    def which(executable)
+      if File.executable?(exec = File.join(Dir.pwd, 'bin', executable))
+        exec
+      else
+        executable
+      end
+    end
+    
+    private
+    
+    def find_gem_in_cache(gem, version)
+      spec = if version
+        version = Gem::Requirement.new ["= #{version}"] unless version.is_a?(Gem::Requirement)
+        Gem.source_index.find_name(gem, version).first
+      else
+        Gem.source_index.find_name(gem).sort_by { |g| g.version }.last
+      end
+      if spec && File.exists?(gem_file = "#{spec.installation_path}/cache/#{spec.full_name}.gem")
+        gem_file
+      end
+    end
+    
+  end
+  
+  class Tasks < Thor
+    
+    include MerbThorHelper
+    
+    # Install Thor, Rake and RSpec into the local gems dir, by copying it from 
+    # the system-wide rubygems cache - which is OK since we needed it to run 
+    # this task already.
+    #
+    # After this we don't need the system-wide rubygems anymore, as all required
+    # executables are available in the local ./bin directory.
+    #
+    # RSpec is needed here because source installs might fail when running
+    # rake tasks where spec/rake/spectask has been required.
+    
+    desc 'setup', 'Install Thor, Rake and RSpec in the local gems dir'
+    method_options "--merb-root" => :optional
+    def setup
+      if $0 =~ /^(\.\/)?bin\/thor$/
+        puts "You cannot run the setup from #{$0} - try #{File.basename($0)} merb:tasks:setup instead"
+        return
+      end
+      create_if_missing(File.join(working_dir, 'gems'))
+      Merb.install_gem('thor',  :cache => true, :install_dir => gem_dir)
+      Merb.install_gem('rake',  :cache => true, :install_dir => gem_dir)
+      Merb.install_gem('rspec', :cache => true, :install_dir => gem_dir)
+      ensure_local_bin_for('thor', 'rake', 'rspec')
+    end
+
+  end
+  
+end

data/lib/generators/templates/application/merb/spec/spec_helper.rb

@@ -1,6 +1,13 @@
-require 'rubygems'
-require 'merb-core'
-require 'spec' # Satisfies Autotest and anyone else not using the Rake tasks
+require "rubygems"
+
+# Add the local gems dir if found within the app root; any dependencies loaded
+# hereafter will try to load from the local gems before loading system gems.
+if (local_gem_dir = File.join(File.dirname(__FILE__), '..', 'gems')) && $BUNDLE.nil?
+  $BUNDLE = true; Gem.clear_paths; Gem.path.unshift(local_gem_dir)
+end
+
+require "merb-core"
+require "spec" # Satisfies Autotest and anyone else not using the Rake tasks
 
 # this loads all plugins required in your init file so don't add them
 # here again, Merb will do it for you

data/lib/generators/templates/application/merb/test/test_helper.rb

@@ -1,7 +1,12 @@
-$TESTING=true
-require 'rubygems'
-require 'merb-core'
+require "rubygems"
 
+# Add the local gems dir if found within the app root; any dependencies loaded
+# hereafter will try to load from the local gems before loading system gems.
+if (local_gem_dir = File.join(File.dirname(__FILE__), '..', 'gems')) && $BUNDLE.nil?
+  $BUNDLE = true; Gem.clear_paths; Gem.path.unshift(local_gem_dir)
+end
+
+require "merb-core"
 
 # TODO: Boot Merb, via the Test Rack adapter
 Merb.start :environment => (ENV['MERB_ENV'] || 'test'),

data/lib/generators/templates/application/merb_flat/spec/spec_helper.rb

@@ -1,4 +1,11 @@
 require "rubygems"
+
+# Add the local gems dir if found within the app root; any dependencies loaded
+# hereafter will try to load from the local gems before loading system gems.
+if (local_gem_dir = File.join(File.dirname(__FILE__), '..', 'gems')) && $BUNDLE.nil?
+  $BUNDLE = true; Gem.clear_paths; Gem.path.unshift(local_gem_dir)
+end
+
 require "spec"
 require "merb-core"
 

data/lib/generators/templates/application/merb_very_flat/spec/spec_helper.rb

@@ -1,4 +1,11 @@
 require "rubygems"
+
+# Add the local gems dir if found within the app root; any dependencies loaded
+# hereafter will try to load from the local gems before loading system gems.
+if (local_gem_dir = File.join(File.dirname(__FILE__), '..', 'gems')) && $BUNDLE.nil?
+  $BUNDLE = true; Gem.clear_paths; Gem.path.unshift(local_gem_dir)
+end
+
 require "spec"
 require "merb-core"
 

data/lib/merb-gen.rb

@@ -23,7 +23,6 @@ require path / "generators" / "model"
 require path / "generators" / "resource_controller"
 require path / "generators" / "resource"
 require path / "generators" / "layout"
-require path / "generators" / "scripts"
 
 Templater::Discovery.discover!("merb-gen")
 

metadata

@@ -1,15 +1,15 @@
 --- !ruby/object:Gem::Specification 
 name: merb-gen
 version: !ruby/object:Gem::Version 
-  version: 0.9.6
+  version: 0.9.7
 platform: ruby
 authors: 
 - Jonas Nicklas
-autorequire: merb-gen
+autorequire: 
 bindir: bin
 cert_chain: []
 
-date: 2008-09-09 00:00:00 +03:00
+date: 2008-09-14 00:00:00 +03:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -20,7 +20,7 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 0.9.6
+        version: 0.9.7
     version: 
 - !ruby/object:Gem::Dependency 
   name: templater
@@ -62,7 +62,6 @@ files:
 - lib/generators/part_controller.rb
 - lib/generators/resource.rb
 - lib/generators/resource_controller.rb
-- lib/generators/scripts.rb
 - lib/generators/session_migration.rb
 - lib/generators/templates
 - lib/generators/templates/application
@@ -94,6 +93,7 @@ files:
 - lib/generators/templates/application/merb/config/init.rb
 - lib/generators/templates/application/merb/config/rack.rb
 - lib/generators/templates/application/merb/config/router.rb
+- lib/generators/templates/application/merb/merb.thor
 - lib/generators/templates/application/merb/public
 - lib/generators/templates/application/merb/public/images
 - lib/generators/templates/application/merb/public/images/merb.jpg
@@ -246,10 +246,6 @@ files:
 - lib/generators/templates/component/resource_controller/test
 - lib/generators/templates/component/resource_controller/test/controllers
 - lib/generators/templates/component/resource_controller/test/controllers/%file_name%_test.rb
-- lib/generators/templates/component/scripts
-- lib/generators/templates/component/scripts/script
-- lib/generators/templates/component/scripts/script/merb
-- lib/generators/templates/component/scripts/script/merb-gen
 - lib/generators/templates/component/session_migration
 - lib/generators/templates/component/session_migration/activerecord
 - lib/generators/templates/component/session_migration/activerecord/schema

data/lib/generators/scripts.rb

@@ -1,51 +0,0 @@
-module Merb::Generators
-  
-  class ScriptsGenerator < Generator
-
-    def self.source_root
-      File.join(super, 'component', 'scripts')
-    end
-    
-    desc <<-DESC
-      Generates local Merb scripts (script/merb and script/merb-gen for example).
-    DESC
-    
-    # Install a script/merb script for local execution (for frozen apps).
-    file :script_merb do |f|
-      f.source = bin_merb_location
-      f.destination = 'script/merb'
-    end
-    
-    # Install a script/merb-gen script for local execution (for frozen apps).
-    file :script_merb_gen do |f|
-      f.source = bin_merb_gen_location
-      f.destination = 'script/merb-gen'
-    end
-     
-    protected
-    
-    def bin_merb_location
-      if (gem_spec = Gem.source_index.search('merb-core').last) && 
-        File.exists?(location = File.join(gem_spec.full_gem_path, gem_spec.bindir, 'merb'))
-        location
-      else
-        'script/merb'
-      end
-    end
-    
-    def bin_merb_gen_location
-      if (gem_spec = Gem.source_index.search('merb-gen').last) && 
-        File.exists?(location = File.join(gem_spec.full_gem_path, gem_spec.bindir, 'merb-gen'))
-        location
-      else
-        'script/merb-gen'
-      end
-    end
-    
-  end
-  
-  add :scripts, ScriptsGenerator
-  
-  puts ScriptsGenerator
-  
-end

data/lib/generators/templates/component/scripts/script/merb

@@ -1,42 +0,0 @@
-#!/usr/bin/env ruby
-
-# This file was generated by 'merb-gen scripts' and 
-# is identical to the executables merb-core/bin/merb
-
-# Try to use minigems instead of the fully rubygems library
-begin
-  require 'minigems'
-rescue LoadError
-  require 'rubygems'
-end
-
-# Load script helpers if available - either local or system-wide.
-begin
-  # Figure out the merb root - defaults to the current directory.
-  root_key = %w[-m --merb-root].detect { |o| ARGV.index(o) }
-  root = ARGV[ARGV.index(root_key) + 1] if root_key
-  __DIR__ = root.to_a.empty? ? Dir.getwd : root
-  
-  # Piggyback on the merb-core rubygem for initial setup scripts.
-  # Requiring it doesn't affect the local gem version of merb-core
-  # we might effectively want to load here after.
-  if merb_core_dir = Dir[File.join(__DIR__, 'gems', 'gems', 'merb-core-*')].last
-    require File.join(merb_core_dir, 'lib', 'merb-core', 'script')
-  else
-    require 'merb-core/script'
-  end
-  # Now setup local gems to be incorporated into the normal loaded gems.
-  # Unless the option --no-frozen is given, local gems are enabled.
-  include Merb::ScriptHelpers
-  setup_local_gems!(__DIR__)
-rescue LoadError
-end
-
-require 'merb-core'
-
-ARGV.push '-H' if ARGV[0] && ARGV[0] =~ /^[^-]/
-unless %w[-a --adapter -i --irb-console -r --script-runner].any? { |o| ARGV.index(o) }
-  ARGV.push *%w[-a mongrel]
-end
-
-Merb.start

data/lib/generators/templates/component/scripts/script/merb-gen

@@ -1,41 +0,0 @@
-#!/usr/bin/env ruby
-
-# This file was generated by 'merb-gen scripts' and 
-# is identical to the executable merb-gen/bin/merb-gen
-
-# Try to use minigems instead of the fully rubygems library
-begin
-  require 'minigems'
-rescue LoadError
-  require 'rubygems'
-end
-
-# Load script helpers if available - either local or system-wide.
-begin
-  # Figure out the merb root - defaults to the current directory.
-  root_key = %w[-m --merb-root].detect { |o| ARGV.index(o) }
-  root = ARGV[ARGV.index(root_key) + 1] if root_key
-  __DIR__ = root.to_a.empty? ? Dir.getwd : root
-  
-  # Piggyback on the merb-core rubygem for initial setup scripts.
-  # Requiring it doesn't affect the local gem version of merb-core
-  # we might effectively want to load here after.
-  if merb_core_dir = Dir[File.join(__DIR__, 'gems', 'gems', 'merb-core-*')].last
-    require File.join(merb_core_dir, 'lib', 'merb-core', 'script')
-  else
-    require 'merb-core/script'
-  end
-  # Now setup local gems to be incorporated into the normal loaded gems.
-  # Unless the option --no-frozen is given, local gems are enabled.
-  include Merb::ScriptHelpers
-  setup_local_gems!(__DIR__)
-rescue LoadError
-end
-
-require 'merb-gen'
-
-Merb::BootLoader.after_app_loads do
-  Merb::Generators.run_cli(Dir.pwd, 'merb-gen', Merb::VERSION, ARGV)
-end
-
-Merb.start :environment => 'development', :log_level => 'error'