whtt-eric-beet 0.6.10

data/features/support/common.rb

@@ -0,0 +1,33 @@
+module CommonHelpers
+  def in_tmp_folder(&block)
+    FileUtils.chdir(@tmp_root, &block)
+  end
+
+  def in_project_folder(&block)
+    project_folder = @active_project_folder || @tmp_root
+    FileUtils.chdir(project_folder, &block)
+  end
+
+  def in_project_subfolder(folder, &block)
+    FileUtils.chdir(File.join(@active_project_folder, folder), &block)
+  end
+
+  def in_home_folder(&block)
+    FileUtils.chdir(@home_path, &block)
+  end
+
+  def force_local_lib_override(project_name = @project_name)
+    rakefile = File.read(File.join(project_name, 'Rakefile'))
+    File.open(File.join(project_name, 'Rakefile'), "w+") do |f|
+      f << "$:.unshift('#{@lib_path}')\n"
+      f << rakefile
+    end
+  end
+
+  def setup_active_project_folder project_name
+    @active_project_folder = File.join(@tmp_root, project_name)
+    @project_name = project_name
+  end
+end
+
+World(CommonHelpers)

data/features/support/env.rb

@@ -0,0 +1,25 @@
+gem 'cucumber'
+require 'cucumber'
+gem 'rspec'
+require 'spec'
+
+Before do
+  @tmp_root = File.dirname(__FILE__) + "/../../tmp"
+  @home_path = File.expand_path(File.join(@tmp_root, "home"))
+  FileUtils.rm_rf   @tmp_root
+  FileUtils.mkdir_p @home_path
+  ENV['HOME'] = @home_path
+end
+
+After do
+  unless ENV['LEAVE_CUCUMBER_GENERATED_OUTPUT']
+    FileUtils.rm_rf @active_project_folder
+  end
+end
+
+gem "fakeweb"
+require "fakeweb"
+
+Before do
+  FakeWeb.allow_net_connect = false
+end

data/lib/beet.rb

@@ -0,0 +1,13 @@
+# TODO similarly, figure out how to require things as needed by the template
+require 'beet/command_execution'
+require 'beet/file_system'
+require 'beet/interaction'
+require 'beet/capistrano'
+require 'beet/rails'
+require 'beet/scm'
+require 'beet/executor'
+require 'beet/gem_location_map'
+require 'beet/template_location_map'
+
+# for camelize and others
+require 'active_support/inflector'

data/lib/beet/capistrano.rb

@@ -0,0 +1,14 @@
+module Beet
+  module Capistrano
+    # Just run the capify command in root
+    #
+    # ==== Example
+    #
+    #   capify!
+    #
+    def capify!
+      log 'capifying'
+      in_root { run('capify .', false) }
+    end
+  end
+end

data/lib/beet/command_execution.rb

@@ -0,0 +1,56 @@
+module Beet
+  module CommandExecution
+    # Executes a command
+    #
+    # ==== Example
+    #
+    #   inside('vendor') do
+    #     run('ln -s ~/edge rails)
+    #   end
+    #
+    def run(command, log_action = true)
+      log 'executing',  "#{command} from #{Dir.pwd}" if log_action
+      system(command)
+    end
+
+    # Executes a command with sudo
+    #
+    # ==== Example
+    #
+    #   inside('vendor') do
+    #     sudo('mkdir /var/log/something')
+    #   end
+    #
+    def sudo(command, log_action = true)
+      command = "#{SUDO}#{command}"
+      run(command,log_action)
+    end
+
+    # Executes a ruby script (taking into account WIN32 platform quirks)
+    def run_ruby_script(command, log_action = true)
+      ruby_command = RUBY_PLATFORM=~ /win32/ ? 'ruby ' : ''
+      rvm("#{ruby_command}#{command}", log_action)
+    end
+
+    # Runs the supplied rake task
+    #
+    # ==== Example
+    #
+    #   rake("db:migrate")
+    #   rake("db:migrate", :env => "production")
+    #   rake("gems:install", :sudo => true)
+    #
+    def rake(command, options = {})
+      log 'rake', command
+      env = options[:env] || 'development'
+      sudo = options[:sudo] ? 'sudo ' : ''
+      in_root { run("#{sudo}rake #{command} RAILS_ENV=#{env}", false) }
+    end
+
+    # Installs the gems using the specified ruby if rvmrc recipe is included
+    def rvm(command, log_action = true)
+      command = "rvm #{@ruby_version} exec #{command}" unless @ruby_version.nil?
+      run(command, log_action)
+    end
+  end
+end

data/lib/beet/executor.rb

@@ -0,0 +1,236 @@
+require 'open-uri'
+require 'beet/logger'
+require 'yaml'
+require 'find'
+begin
+  require 'ruby-debug'
+rescue LoadError
+  # not required to actually run beet
+end
+
+module Beet
+  class Executor
+    BEET_DATA_FILE = "~/.beet.yml"
+    include Beet::CommandExecution
+    include Beet::FileSystem
+    include Beet::Interaction
+
+    include Beet::Rails
+    include Beet::Capistrano
+    include Beet::SCM
+
+    attr_reader :root, :logger, :options, :template
+    attr_accessor :recipes, :project_name, :gems, :todo_items, :ruby_version
+
+    def initialize(project_name, options={}) # :nodoc:
+      @root = calculate_project_root(project_name)
+      @project_name = ((project_name == '.') ? File.basename(Dir.pwd) : project_name)
+      @logger = Beet::Logger.new
+      @gems = []
+      @template = options[:template]
+      @options = options
+      @todo_items = ''
+      @recipes = []
+      @project_type = (options[:project_type] && options[:project_type].to_sym) || :rails3
+      @generate = true unless options[:generate] == false
+      @display = options[:display]
+      extract_commands_from_options
+    end
+
+    def start
+      if options[:use]
+        puts "Loading saved configuration: #{@options[:use]}"
+        data = load_saved_recipe_file
+        if config = data[@options[:use]]
+          @gems.concat(config[:gems]) if config[:gems]
+          @template = config[:template] if config[:template]
+          @recipes.concat(config[:recipes]) if config[:recipes]
+        end
+      end
+
+      if @display && @template
+        puts open(TEMPLATE_LOCATIONS[@template]).read
+      else
+        if @generate
+          # TODO maybe let people specify path to rails 3 script rather than just assume its 'rails'
+          if @project_type == :rails3
+            puts "Generating rails 3 project #{project_name}..."
+            if @template
+              system("rails new #{project_name} -m #{TEMPLATE_LOCATIONS[@template]}")
+            else
+              system("rails new #{project_name}")
+            end
+          else
+            unless rails2_version = search_for_rails_2
+              puts "Please create a rails2 command which points to rails 2.x executable."
+              exit
+            else
+              puts "Generating rails project #{project_name}..."
+              if @template
+                system("rails _#{rails2_version}_ #{project_name} -m #{TEMPLATE_LOCATIONS[@template]}")
+              else
+                system("rails _#{rails2_version}_ #{project_name}")
+              end
+            end
+          end
+        end
+
+        add_gems
+
+        print_todo
+
+        if options[:save]
+          save_run
+        end
+      end
+
+      run_recipes
+
+    end
+
+    def run_recipes
+      @recipes.each do |recipe|
+        begin
+          code = open(recipe).read
+          if @display
+            puts code
+          else
+            in_root { instance_eval(code)}
+          end
+        rescue LoadError, Errno::ENOENT => e
+          raise "The recipe [#{recipe}] could not be loaded. Error: #{e}"
+        end
+      end
+    end
+
+    def log(*args)
+      logger.log(*args)
+    end
+
+    def todo(string=nil, &block)
+      self.todo_items << (string || block.call)
+    end
+
+    private
+
+    def print_todo
+      unless todo_items.empty?
+        puts '#' * 30
+        puts "TODO Items:"
+        puts todo_items
+        puts '#' * 30
+      end
+    end
+
+    def calculate_project_root(project_name)
+      # if the name looks like ~/projects/foobar then thats the root
+      if project_name.include?('/')
+        project_name
+      # if we're running inside the app, then current dir is it
+      elsif File.basename(Dir.pwd) == project_name
+        Dir.pwd
+      # assume the root is ./project_name
+      else
+        File.join(Dir.pwd, project_name)
+      end
+    end
+
+    def add_gems
+      if @gems
+        @gems.each do |gem_data|
+          duped_data = gem_data.clone # to avoid removing :name from @gems
+          name = duped_data.delete(:name)
+          gem(name, duped_data)
+        end
+      end
+    end
+
+    def extract_commands_from_options
+      if options[:gems]
+        options[:gems].split(/[\s,]+/).each do |gem|
+          if gem_info = gem_location(gem)
+            if gem_info.is_a?(Hash)
+              @gems << {:name => gem}.merge(gem_info)
+            else
+              @gems << {:name => gem, :source => gem_info}
+            end
+          else
+            @gems << {:name => gem}
+          end
+        end
+      end
+      if options[:recipes]
+        options[:recipes].split(/[\s,]+/).each do |recipe|
+          if file = recipe_location(recipe)
+            @recipes << file
+          else
+            puts "Can't find recipe #{recipe}"
+          end
+        end
+      end
+    end
+
+    def save_run
+      name = if options[:save] == true
+               ask("Enter a name for this configuration: ")
+             else
+               options[:save]
+             end
+      data = load_saved_recipe_file
+      data[name] = {:gems => @gems, :recipes => @recipes, :template => @template}
+      write_saved_recipe_file(data)
+    end
+
+    def beet_data_file
+      File.expand_path(BEET_DATA_FILE)
+    end
+
+    def load_saved_recipe_file
+      if File.exists?(beet_data_file)
+        ::YAML.load_file(beet_data_file) || {} # if for some reason is nil, give back an empty hash
+      else
+        {}
+      end
+    end
+
+    def write_saved_recipe_file(data)
+      File.open(beet_data_file, "wb") do |f|
+        f.write(YAML::dump(data))
+      end
+    end
+
+    def gem_location(gem_name)
+      GEM_LOCATIONS[gem_name]
+    end
+
+    def recipe_location(recipe)
+      return recipe if File.exists?(recipe) or recipe.include?('http://')
+      locations = []
+      recipe_paths = []
+      locations << File.expand_path(ENV['BEET_RECIPES_DIR']) if ENV['BEET_RECIPES_DIR']
+      locations << File.expand_path(File.join(File.dirname(__FILE__), 'recipes'))
+
+      Find.find(locations * ", ") do |path|
+        recipe_paths << path if path.include?("#{recipe}.rb")
+      end
+
+      filename = if recipe_paths.length > 1
+        @project_type == :rails3 ?
+          recipe_paths.find {|path| path.include?("rails3")} :
+          recipe_paths.find {|path| path.include?("rails")}
+      else
+        recipe_paths.first
+      end
+
+      return filename
+    end
+
+    def search_for_rails_2
+      rails_versions = `gem list rails`.chomp
+      clean_versions = rails_versions.match /\((.*)\)/
+      numbered_versions = clean_versions[1].split(', ')
+      numbered_versions.find {|v| v.split('.').first.to_i == 2}
+    end
+  end
+end
+

data/lib/beet/file_system.rb

@@ -0,0 +1,163 @@
+require 'fileutils'
+module Beet
+  module FileSystem
+    # Create a new file in the project folder.  Specify the
+    # relative path from the project's root.  Data is the return value of a block
+    # or a data string.
+    #
+    # ==== Examples
+    #
+    # file("lib/fun_party.rb") do
+    #   hostname = ask("What is the virtual hostname I should use?")
+    #   "vhost.name = #{hostname}"
+    # end
+    #
+    # file("config/apach.conf", "your apache config")
+    def file(filename, data = nil, log_action = true, &block)
+      log 'file', filename if log_action
+      dir, file = [File.dirname(filename), File.basename(filename)]
+
+      inside(dir) do
+        File.open(file, "w") do |f|
+          data = block.call if block_given?
+          f.write(remove_blank_start(data))
+        end
+      end
+    end
+
+    # Create a new file in the lib/ directory. Code can be specified
+    # in a block or a data string can be given.
+    #
+    # ==== Examples
+    #
+    #   lib("crypto.rb") do
+    #     "crypted_special_value = '#{rand}--#{Time.now}--#{rand(1337)}--'"
+    #   end
+    #
+    #   lib("foreign.rb", "# Foreign code is fun")
+    #
+    def lib(filename, data = nil, &block)
+      log 'lib', filename
+      file("lib/#{filename}", data, false, &block)
+    end
+
+    # Create a new Rakefile with the provided code (either in a block or a string).
+    #
+    # ==== Examples
+    #
+    #   rakefile("bootstrap.rake") do
+    #     project = ask("What is the UNIX name of your project?")
+    #
+    #     <<-TASK
+    #       namespace :#{project} do
+    #         task :bootstrap do
+    #           puts "i like boots!"
+    #         end
+    #       end
+    #     TASK
+    #   end
+    #
+    #   rakefile("seed.rake", "puts 'im plantin ur seedz'")
+    #
+    def rakefile(filename, data = nil, &block)
+      log 'rakefile', filename
+      file("lib/tasks/#{filename}", data, false, &block)
+    end
+
+    # Do something in the root of the project or
+    # a provided subfolder; the full path is yielded to the block you provide.
+    # The path is set back to the previous path when the method exits.
+    def inside(dir = '', &block)
+      folder = File.join(root, dir)
+      FileUtils.mkdir_p(folder) unless File.exist?(folder)
+      FileUtils.cd(folder) { block.arity == 1 ? yield(folder) : yield }
+    end
+
+    def in_root
+      FileUtils.cd(root) { yield }
+    end
+
+    # Run a regular expression replacement on a file
+    #
+    # ==== Example
+    #
+    #   gsub_file 'app/controllers/application_controller.rb', /#\s*(filter_parameter_logging :password)/, '\1'
+    #
+    def gsub_file(path, regexp, *args, &block)
+      #path = destination_path(relative_destination)
+      content = File.read(path)
+      check_for = args.first || yield('')
+      regex = Regexp.new(regexp.source + Regexp.escape(check_for))
+      return if content =~ regex # if we can match the text and its leadin regex, don't add again
+      content = content.gsub(regexp, *args, &block)
+      File.open(path, 'wb') { |file| file.write(content) }
+    end
+
+    # Append text to a file
+    #
+    # ==== Example
+    #
+    #   append_file 'config/environments/test.rb', 'config.gem "rspec"'
+    #
+    def append_file(relative_destination, data)
+      path = destination_path(relative_destination)
+      File.open(path, 'ab') { |file| file.write("\n#{data}") }
+    end
+
+    # Add text after matching line
+    #
+    # ==== Example
+    #
+    #    add_after 'config/environment.rb', '# config.gem "aws-s3", :lib => "aws/s3"'
+    #
+    def add_after(filename, matching_text, data=nil, &block)
+      gsub_file filename, /(\s*#{Regexp.escape(matching_text)})/mi do |match|
+        "#{match}\n#{data || block.call}"
+      end
+    end
+
+    # Add text after matching line, otherwise append to file wrapped in before/after text
+    #
+    # ==== Example
+    #
+    #    add_after_or_append 'Gemfile', 'group :test', "gem 'rspec-rails'", "group :test do", "end"
+    #
+    def add_after_or_append(filename, matching_text, text_to_add, before_text, after_text)
+      content = File.read(filename)
+      if content.include?(matching_text)
+        add_after(filename, matching_text, text_to_add)
+      else
+        append_file(filename, [before_text, text_to_add, after_text].join("\n"))
+      end
+    end
+
+    # Add text before matching line
+    #
+    # ==== Example
+    #
+    #    add_before 'config/environment.rb', '# config.gem "aws-s3", :lib => "aws/s3"'
+    #
+    def add_before(filename, matching_text, data=nil, &block)
+      gsub_file filename, /^(\s*#{Regexp.escape(matching_text)})/mi do |match|
+        "#{data || block.call}#{match}"
+      end
+    end
+
+    protected
+
+    def destination_path(relative_destination)
+      File.join(root, relative_destination)
+    end
+
+    # it's common for multi-line strings to be coded in a way so that their first character is a newline
+    # like this
+    # string = %{
+    # foo
+    # }
+    # string => "\nfoo\n"
+    # This is bad when it needs to be #!/usr/bin/something so we remove that newline in a dumb but effective way for now
+    def remove_blank_start(string)
+      string.reverse.chomp.reverse
+    end
+  end
+end