merb-gen 1.0.15 → 1.1.0.pre

data/lib/generators/templates/application/common/doc.thor

@@ -1,149 +0,0 @@
-$: << File.join("doc")
-require 'rubygems'
-require 'rdoc/rdoc'
-require 'fileutils'
-require 'erb'
-
-module Merb
-  
-  class GemNotFoundException < Exception
-  end
-  
-  module DocMethods
-    def setup_gem_path
-      if File.directory?(gems_dir = File.join(File.dirname(__FILE__), 'gems'))
-        $BUNDLE = true; Gem.clear_paths; Gem.path.unshift(gems_dir)
-      end
-    end
-    
-    def get_more
-      libs = []
-      more_library = find_library("merb-more")
-      File.open("#{more_library}/lib/merb-more.rb").read.each_line do |line|
-        if line['require']
-          libs << line.gsub("require '", '').gsub("'\n", '')
-        end
-      end
-      return libs
-    end
-    
-    def generate_documentation(file_list, destination, arguments = [])
-      output_dir = File.join("/../doc", "rdoc", destination)
-      FileUtils.rm_rf(output_dir)
-      
-      arguments += [
-        "--fmt", "merb",
-        "--op", output_dir
-      ]
-      RDoc::RDoc.new.document(arguments + file_list)
-      AdvancedDoc.new.index
-    end
-    
-    def find_library(directory_snippet)
-      gem_dir = nil
-      Gem.path.find do |path|
-        dir = Dir.glob("#{path}/gems/#{directory_snippet}*") 
-        dir.empty? ? false : gem_dir = dir.last
-      end
-      raise GemNotFoundException if gem_dir.nil?
-      return gem_dir
-    end
-    
-    def get_file_list(directory_snippet)
-      gem_dir = find_library(directory_snippet)
-      files = Dir.glob("#{gem_dir}/**/lib/**/*.rb")
-      files += ["#{gem_dir}/README"] if File.exists?("#{gem_dir}/README")
-      return  files
-    end
-  end
-  
-  class AdvancedDoc < Thor
-    
-    group 'core'
-    include DocMethods
-    
-    def initialize
-      super
-      setup_gem_path
-    end
-    
-    desc 'index', "Regenerate the index file for your framework documentation"
-    def index
-      @directories = Dir.entries(File.join(File.dirname(__FILE__) + "/../", "doc", "rdoc"))
-      @directories.delete(".")
-      @directories.delete("..")
-      @directories.delete("generators")
-      @directories.delete("index.html")
-      index_template = File.read(File.join("doc", "rdoc", "generators", "template", "merb", "index.html.erb"))
-      
-      File.open(File.join("doc", "rdoc", "index.html"), "w") do |file|
-        file.write(ERB.new(index_template).result(binding))
-      end
-    end
-    
-    desc 'plugins', 'Generate the rdoc for each merb-plugins seperatly'
-    def plugins
-      libs = ["merb_activerecord", "merb_builder", "merb_jquery", "merb_laszlo", "merb_parts", "merb_screw_unit", "merb_sequel", "merb_stories", "merb_test_unit"]
-      
-      libs.each do |lib|
-        options[:gem] = lib
-        gem
-      end
-    end
-    
-    desc 'more', 'Generate the rdoc for each merb-more gem seperatly'
-    def more
-      libs = get_more
-      libs.each do |lib|
-        options[:gem] = lib
-        gem
-      end
-    end
-    
-    desc 'core', 'Generate the rdoc for merb-core'
-    def core
-      options[:gem] = "merb-core"
-      gem
-    end
-    
-    desc 'gem', 'Generate the rdoc for a specific gem'
-    method_options "--gem" => :required
-    def gem
-      file_list = get_file_list(options[:gem])
-      readme = File.join(find_library("merb-core"), "README")
-      generate_documentation(file_list, options[:gem], ["-m", readme])
-    rescue GemNotFoundException
-      puts "Can not find the gem in the gem path #{options[:gem]}"
-    end
-    
-  end
-  
-  class Doc < Thor
-    
-    include DocMethods
-    
-    def initialize
-      super
-      setup_gem_path
-      
-    end
-    
-    desc 'stack', 'Generate the rdoc for merb-core, merb-more merged together'
-    def stack
-      libs = ["merb"]
-            
-      file_list = []
-      libs.each do |gem_name|
-        begin
-          file_list += get_file_list(gem_name)
-        rescue GemNotFoundException
-          puts "Could not find #{gem_name} in #{Gem.path}.  Continuing with out it."
-        end
-      end
-      readme = File.join(find_library("merb"), "README")
-      generate_documentation(file_list, "stack", ["-m", readme])
-    end
-    
-  end
-  
-end

data/lib/generators/templates/application/common/merb_thor/app_script.rb

@@ -1,31 +0,0 @@
-#!/usr/bin/env ruby
-
-# This was added by Merb's bundler
-
-require "rubygems"
-require File.join(File.dirname(__FILE__), "common")
-
-gems_dir = File.join(File.dirname(__FILE__), '..', 'gems')
-
-if File.directory?(gems_dir)
-  $BUNDLE = true
-  Gem.clear_paths
-  Gem.path.replace([File.expand_path(gems_dir)])
-  ENV["PATH"] = "#{File.dirname(__FILE__)}:#{ENV["PATH"]}"
-  
-  gem_file = File.join(gems_dir, "specifications", "<%= spec.name %>-*.gemspec")
-  
-  if local_gem = Dir[gem_file].last
-    version = File.basename(local_gem)[/-([\.\d]+)\.gemspec$/, 1]
-  end
-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 %>'

data/lib/generators/templates/application/common/merb_thor/common.rb

@@ -1,68 +0,0 @@
-# This was added via Merb's bundler
-
-require "rubygems"
-require "rubygems/source_index"
-
-module Gem
-  BUNDLED_SPECS = File.join(Dir.pwd, "gems", "specifications")
-  MAIN_INDEX = Gem::SourceIndex.from_gems_in(BUNDLED_SPECS)
-  FALLBACK_INDEX = Gem::SourceIndex.from_installed_gems
-  
-  def self.source_index
-    MultiSourceIndex.new
-  end
-  
-  def self.searcher
-    MultiPathSearcher.new
-  end
-  
-  class ArbitrarySearcher < GemPathSearcher
-    def initialize(source_index)
-      @source_index = source_index
-      super()
-    end
-    
-    def init_gemspecs
-      @source_index.map { |_, spec| spec }.sort { |a,b|
-        (a.name <=> b.name).nonzero? || (b.version <=> a.version)
-      }
-    end
-  end
-
-  class MultiPathSearcher
-    def initialize
-      @main_searcher = ArbitrarySearcher.new(MAIN_INDEX)
-      @fallback_searcher = ArbitrarySearcher.new(FALLBACK_INDEX)
-    end
-    
-    def find(path)
-      try = @main_searcher.find(path)
-      return try if try
-      @fallback_searcher.find(path)
-    end
-    
-    def find_all(path)
-      try = @main_searcher.find_all(path)
-      return try unless try.empty?
-      @fallback_searcher.find_all(path)
-    end
-  end
-  
-  class MultiSourceIndex
-    # Used by merb.thor to confirm; not needed when MSI is in use
-    def load_gems_in(*args)
-    end
-    
-    def search(*args)
-      try = MAIN_INDEX.search(*args)
-      return try unless try.empty?
-      FALLBACK_INDEX.search(*args)
-    end
-    
-    def find_name(*args)
-      try = MAIN_INDEX.find_name(*args)
-      return try unless try.empty?
-      FALLBACK_INDEX.find_name(*args)
-    end
-  end
-end

data/lib/generators/templates/application/common/merb_thor/gem_ext.rb

@@ -1,125 +0,0 @@
-require "erb"
-
-Gem.pre_install_hooks.push(proc do |installer|
-  unless File.file?(installer.bin_dir / "common.rb")
-    FileUtils.mkdir_p(installer.bin_dir)
-    FileUtils.cp(File.dirname(__FILE__) / "common.rb", installer.bin_dir / "common.rb")
-  end
-  
-  include ColorfulMessages
-  name = installer.spec.name
-  if $GEMS && versions = ($GEMS.assoc(name) || [])[1]
-    dep = Gem::Dependency.new(name, versions)
-    unless dep.version_requirements.satisfied_by?(installer.spec.version)
-      error "Cannot install #{installer.spec.full_name} " \
-            "for #{$INSTALLING}; " \
-            "you required #{dep}"
-      ::Thor::Tasks::Merb::Gem.rollback_trans
-      exit!
-    end
-  end
-  success "Installing #{installer.spec.full_name}"
-end)
-
-class ::Gem::Uninstaller
-  def self._with_silent_ui
-    
-    ui = Gem::DefaultUserInteraction.ui 
-    def ui.say(str)
-      puts "- #{str}"
-    end
-    
-    yield
-    
-    class << Gem::DefaultUserInteraction.ui
-      remove_method :say
-    end 
-  end
-  
-  def self._uninstall(source_index, name, op, version)
-    unless source_index.find_name(name, "#{op} #{version}").empty?
-      uninstaller = Gem::Uninstaller.new(
-        name,
-        :version => "#{op} #{version}",
-        :install_dir => Dir.pwd / "gems",
-        :all => true,
-        :ignore => true
-      )
-      _with_silent_ui { uninstaller.uninstall }
-    end
-  end
-  
-  def self._uninstall_others(source_index, name, version)
-    _uninstall(source_index, name, "<", version)
-    _uninstall(source_index, name, ">", version)
-  end
-end
-
-Gem.post_install_hooks.push(proc do |installer|
-  source_index = installer.instance_variable_get("@source_index")
-  ::Gem::Uninstaller._uninstall_others(
-    source_index, installer.spec.name, installer.spec.version
-  )
-end)
-
-class ::Gem::DependencyInstaller
-  alias old_fg find_gems_with_sources
-  
-  def find_gems_with_sources(dep)
-    if @source_index.any? { |_, installed_spec|
-      installed_spec.satisfies_requirement?(dep)
-    }
-      return []
-    end
-    
-    old_fg(dep)
-  end
-end
-
-class ::Gem::SpecFetcher
-  alias old_fetch fetch
-  def fetch(dependency, all = false, matching_platform = true, prerelease = false)
-    idx = Gem::SourceIndex.from_installed_gems
-    
-    reqs = dependency.version_requirements.requirements
-    
-    if reqs.size == 1 && reqs[0][0] == "="
-      dep = idx.search(dependency).sort.last
-    end
-    
-    if dep
-      file = dep.loaded_from.dup
-      file.gsub!(/specifications/, "cache")
-      file.gsub!(/gemspec$/, "gem")
-      spec = ::Gem::Format.from_file_by_path(file).spec
-      [[spec, file]]
-    else
-      old_fetch(dependency, all, matching_platform)
-    end
-  end
-end
-
-class ::Gem::Installer
-  def app_script_text(bin_file_name)
-    template = File.read(File.dirname(__FILE__) / "app_script.rb")
-    erb = ERB.new(template)
-    erb.result(binding)
-  end
-end
-
-class ::Gem::Specification
-  def recursive_dependencies(from, index = Gem.source_index)
-    specs = self.runtime_dependencies.map do |dep|
-      spec = index.search(dep).last
-      unless spec
-        from_name = from.is_a?(::Gem::Specification) ? from.full_name : from.to_s
-        wider_net = index.find_name(dep.name).last
-        ThorUI.error "Needed #{dep} for #{from_name}, but could not find it"
-        ThorUI.error "Found #{wider_net.full_name}" if wider_net
-        ::Thor::Tasks::Merb::Gem.rollback_trans
-      end
-      spec
-    end
-    specs + specs.map {|s| s.recursive_dependencies(self, index)}.flatten.uniq
-  end
-end

data/lib/generators/templates/application/common/merb_thor/main.thor

@@ -1,151 +0,0 @@
-require "rubygems"
-require "rubygems/source_index"
-require "rubygems/dependency_installer"
-require "rubygems/uninstaller"
-require "fileutils"
-require File.join(File.dirname(__FILE__), "utils")
-require File.join(File.dirname(__FILE__), "gem_ext")
-require File.join(File.dirname(__FILE__), "ops")
-
-$INSTALLING = []
-
-module Merb
-  
-  class Gem < Thor
-    extend ColorfulMessages
-    
-    def initialize
-      dirs = [Dir.pwd, File.dirname(__FILE__) / ".."]
-      root = dirs.find {|d| File.file?(d / "config" / "dependencies.rb")}
-      
-      if root
-        @depsrb = root / "config" / "dependencies.rb"
-      else
-        self.class.error "dependencies.rb was not found"
-        exit!
-      end
-      
-      FileUtils.mkdir_p(Dir.pwd / "gems")
-      
-      @list = Collector.collect(File.read(@depsrb))
-      @idx = ::Gem::SourceIndex.new.load_gems_in("gems/specifications")
-    end
-    
-    def list
-      require "pp"
-      pp @list
-    end
-    
-    desc "redeploy", "Syncs up gems/cache with gems/gems. All gems in the cache " \
-                     "that are not already installed will be installed from the " \
-                     "cache. All installed gems that are not in the cache will " \
-                     "be uninstalled."
-    def redeploy
-      gem_dir = Dir.pwd / "gems" / "gems"
-      cache_dir = Dir.pwd / "gems" / "cache"
-      
-      gems  = Dir[gem_dir / "*"].map!  {|n| File.basename(n)}
-      cache = Dir[cache_dir / "*.gem"].map! {|n| File.basename(n, ".gem")}
-      new_gems = cache - gems
-      outdated = gems - cache
-      idx = ::Gem::SourceIndex.new
-      idx.load_gems_in(Dir.pwd / "gems" / "specifications")
-
-      new_gems.each do |g|
-        installer = ::Gem::Installer.new(cache_dir / "#{g}.gem",
-          :bin_dir => Dir.pwd / "bin",
-          :install_dir => Dir.pwd / "gems",
-          :ignore_dependencies => true,
-          :user_install => false,
-          :wrappers => true,
-          :source_index => idx)
-            
-        installer.install
-      end
-      
-      outdated.each do |g|
-        /(.*)\-(.*)/ =~ g
-        name, version = $1, $2
-        uninstaller = ::Gem::Uninstaller.new(name,
-          :version => version,
-          :bin_dir => Dir.pwd / "bin",
-          :install_dir => Dir.pwd / "gems",
-          :ignore => true,
-          :executables => true
-        )
-        uninstaller.uninstall
-      end
-    end
-    
-    desc "confirm", "Confirm the current setup. merb:gem:install will " \
-                    "automatically run this task before committing the " \
-                    "changes it makes."
-    def confirm(gems = @list)
-      ::Gem.path.replace([Dir.pwd / "gems"])
-      ::Gem.source_index.load_gems_in(Dir.pwd / "gems" / "specifications")
-      
-      self.class.info "Confirming configuration..."
-      
-      ::Gem.loaded_specs.clear
-      
-      begin
-        gems.each do |name, versions|
-          versions ||= []
-          ::Gem.activate name, *versions
-        end
-      rescue ::Gem::LoadError => e
-        self.class.error "Configuration could not be confirmed: #{e.message}"
-        # Don't rollback since its possibly the confirmation is just broken
-        # self.class.rollback_trans
-      end
-      self.class.info "Confirmed"
-    end
-    
-    desc 'install', 'Sync up your bundled gems with the list in config/dependencies.rb'
-    def install(*gems)
-      if gems.empty?
-        gems = @list
-      else
-        gems = gems.map {|desc| name, *versions = desc.split(" ") }
-      end
-      
-      $GEMS = gems
-      
-      self.class.begin_trans
-      
-      gems.each do |name, versions|
-        dep = ::Gem::Dependency.new(name, versions || [])
-        unless @idx.search(dep).empty?
-          next
-        end
-        
-        rescue_failures do
-          $INSTALLING = dep
-          _install(dep)
-        end
-      end
-
-      gem_dir = Dir.pwd / "gems" / "gems"
-      installed_gems  = Dir[gem_dir / "*"].map!  {|n| File.basename(n)}
-      
-      list = full_list.map {|x| x.full_name}.compact
-      
-      (installed_gems - list).each do |g|
-        /^(.*)\-(.*)$/ =~ g
-        name, version = $1, $2
-        uninstaller = ::Gem::Uninstaller.new(name,
-          :version => version,
-          :bin_dir => (Dir.pwd / "bin").to_s,
-          :install_dir => (Dir.pwd / "gems").to_s,
-          :ignore => true,
-          :executables => true
-        )
-        uninstaller.uninstall
-      end
-      
-      confirm(gems)
-      
-      self.class.commit_trans
-    end
-  end
-end

data/lib/generators/templates/application/common/merb_thor/ops.rb

@@ -1,93 +0,0 @@
-module Thor::Tasks
-  module Merb
-    class Collector
-      attr_reader :dependencies
-
-      def self.collect(str)
-        collector = new
-        collector.instance_eval(str)
-        collector.dependencies
-      end
-
-      def initialize
-        @dependencies = []
-      end
-
-      def dependency(name, *versions)
-        versions.pop if versions.last.is_a?(Hash)
-        @dependencies << [name, versions]
-      end
-    end
-    
-    class Gem < Thor
-      def full_list
-        @idx.load_gems_in("gems/specifications")
-
-        @list.map do |name, versions|
-          dep = ::Gem::Dependency.new(name, versions)
-          spec = @idx.search(dep).last
-          unless spec
-            self.class.error "A required dependency #{dep} was not found"
-            self.class.rollback_trans
-          end
-          deps = spec.recursive_dependencies(dep, @idx)
-          [spec] + deps
-        end.flatten.uniq
-      end
-      
-      def rescue_failures(error = StandardError, prc = nil)
-        begin
-          yield
-        rescue error => e
-          if prc
-            prc.call(e)
-          else
-            puts e.message
-            puts e.backtrace
-          end
-          self.class.rollback_trans
-        end
-      end
-
-      def self.begin_trans
-        note "Beginning transaction"
-        FileUtils.cp_r(Dir.pwd / "gems", Dir.pwd / ".original_gems")
-      end
-
-      def self.commit_trans
-        note "Committing transaction"
-        FileUtils.rm_rf(Dir.pwd / ".original_gems")
-      end
-
-      def self.rollback_trans
-        if File.exist?(Dir.pwd / ".original_gems")
-          note "Rolling back transaction"
-          FileUtils.rm_rf(Dir.pwd / "gems")
-          FileUtils.mv(Dir.pwd / ".original_gems", Dir.pwd / "gems")
-        end
-        exit!
-      end
-      
-      private
-      def _install(dep)
-        @idx.load_gems_in("gems/specifications")
-        return if @idx.search(dep).last
-        
-        installer = ::Gem::DependencyInstaller.new(
-          :bin_dir => Dir.pwd / "bin",
-          :install_dir => Dir.pwd / "gems",
-          :user_install => false)
-
-        begin
-          installer.install dep.name, dep.version_requirements
-        rescue ::Gem::GemNotFoundException => e
-          puts "Cannot find #{dep}"
-        rescue ::Gem::RemoteFetcher::FetchError => e
-          puts e.message
-          puts "Retrying..."
-          retry
-        end
-      end
-    end
-  end
-end

data/lib/generators/templates/application/common/merb_thor/utils.rb

@@ -1,40 +0,0 @@
-class String
-  def /(other)
-    (Pathname.new(self) + other).to_s
-  end
-end
-
-module ColorfulMessages
-  
-  # red
-  def error(*messages)
-    puts messages.map { |msg| "\033[1;31m#{msg}\033[0m" }
-  end
-  
-  # yellow
-  def warning(*messages)
-    puts messages.map { |msg| "\033[1;33m#{msg}\033[0m" }
-  end
-  
-  # green
-  def success(*messages)
-    puts messages.map { |msg| "\033[1;32m#{msg}\033[0m" }
-  end
-  
-  alias_method :message, :success
-  
-  # magenta
-  def note(*messages)
-    puts messages.map { |msg| "\033[1;35m#{msg}\033[0m" }
-  end
-  
-  # blue
-  def info(*messages)
-    puts messages.map { |msg| "\033[1;34m#{msg}\033[0m" }
-  end
-  
-end
-
-module ThorUI
-  extend ColorfulMessages
-end

data/lib/generators/templates/application/merb_core/public/merb.fcgi

@@ -1,22 +0,0 @@
-#!/usr/bin/env ruby
-                                                               
-require 'rubygems'
-require 'merb-core'
-
-# this is Merb.root, change this if you have some funky setup.
-merb_root = File.expand_path(File.dirname(__FILE__) / '../')
-        
-# If the fcgi process runs as apache, make sure
-# we have an inlinedir set for Rubyinline action-args to work
-unless ENV["INLINEDIR"] || ENV["HOME"]
-  tmpdir = merb_root / "tmp"
-  unless File.directory?(tmpdir)
-    Dir.mkdir(tmpdir)
-  end                
-  ENV["INLINEDIR"] = tmpdir
-end
-   
-# start merb with the fcgi adapter, add options or change the log dir here
-Merb.start(:adapter => 'fcgi',
-           :merb_root => merb_root,
-           :log_file => merb_root /'log'/'merb.log')