sake 1.0.0

data/LICENSE

@@ -0,0 +1,18 @@
+Copyright (c) 2007 Chris Wanstrath
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of 
+this software and associated documentation files (the "Software"), to deal in 
+the Software without restriction, including without limitation the rights to 
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of 
+the Software, and to permit persons to whom the Software is furnished to do so, 
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all 
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS 
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR 
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER 
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN 
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Manifest.txt

@@ -0,0 +1,8 @@
+./bin/sake
+./lib/sake.rb
+./lib/server.rb
+./lib/help.rb
+./Manifest.txt
+./Rakefile
+./README
+./LICENSE

data/README

@@ -0,0 +1,76 @@
+= Sake. Best served warm.
+
+Sick of copy & pasting your badass custom Rakefiles into every new Rails app 
+you start?  Fed up with writing one-off admistrative scripts and leaving them
+everything?
+
+No longer.  Sake is a tool which helps you maintain a set of system level Rake tasks.  
+
+Get started:
+
+$ sudo gem install sake
+$ sake -h
+
+Show all Sake tasks (but no local Rake tasks), optionally only those matching a pattern.
+  $ sake -T
+  $ sake -T db
+
+Show tasks in a Rakefile, optionally only those matching a pattern.
+  $ sake -T file.rake
+  $ sake -T file.rake db
+
+Install tasks from a Rakefile, optionally specifying specific tasks.
+  $ sake -i Rakefile
+  $ sake -i Rakefile db:remigrate
+  $ sake -i Rakefile db:remigrate routes
+
+Examine the source of a Rake task.
+  $ sake -e routes
+
+Want to share just a few tasks, bundle them up?
+  $ sake -e routes remigrate > my_tasks.rake
+
+You can also examine the source of a task not yet installed. 
+  $ sake -e Rakefile db:remigrate
+
+Uninstall an installed task.
+  $ sake -u db:remigrate
+
+Can be passed one or more tasks.
+
+Invoke a Sake task.
+  $ sake <taskname>
+
+Some Sake tasks may depend on tasks which exist only locally.
+
+For instance, you may have a db:version sake task which depends
+on the 'environment' Rake task.  The 'environment' Rake task is one
+defined by Rails to load its environment.  This db:version task will
+work when your current directory is within a Rails app because
+Sake knows how to find Rake tasks.  This task will not work,
+however, in any other directory (unless a task named 'environment' 
+indeed exists).
+
+Sake can also serve its tasks over a network by launching a Mongrel handler.
+Pass the -S switch to start Sake in server mode.
+
+  $ sake -S
+
+You can, of course, specify a port.
+  $ sake -S -p 1111
+
+You can also daemonize your server for long term serving fun.
+  $ sake -S -d
+
+== Special Thanks
+
+  * Ryan Davis
+  * Eric Hodel
+  * Josh Susser
+  * Brian Donovan
+  * Zack Chandler
+
+== Author
+
+>> Chris Wanstrath
+=> chris@ozmm.org

data/Rakefile

@@ -0,0 +1,23 @@
+require 'rubygems'
+require 'rake'
+
+require 'lib/sake' unless defined? Sake
+
+begin
+  require 'echoe'
+
+  Echoe.new('sake', Sake::Version::String) do |p|
+    p.rubyforge_name = 'err'
+    p.summary = "Sake tastes great and helps maintain system-level Rake files."
+    p.description = "Sake tastes great and helps maintain system-level Rake files."
+    p.url = "http://errtheblog.com/"
+    p.author = 'Chris Wanstrath'
+    p.email = "chris@ozmm.org"
+    p.extra_deps << ['ruby2ruby', '>=1.1.6']
+    p.test_globs = 'test/*_test.rb' 
+  end
+
+rescue LoadError => boom
+  puts "You are missing a dependency required for meta-operations on this gem."
+  puts "#{boom.to_s.capitalize}."
+end

data/bin/sake

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+require 'rubygems'
+require 'sake'
+
+Sake.new(ARGV).run

data/lib/help.rb

@@ -0,0 +1,32 @@
+class Sake
+  module Help
+    extend self
+
+    def display
+      die <<-end_help
+Usage: sake [options]
+
+    Any <file> can be either a local file or a remote URL (such as a web page).
+
+    -T                 Show installed Sake tasks.
+    -T pattern         Show installed Sake tasks matching <pattern>.
+    -T file            Show tasks in <file>.
+    -T file pattern    Show tasks in <file>.
+
+    -i file            Install all tasks from <file>.
+    -i file tasks      Install tasks from <file>.  Can be one or more tasks.
+
+    -u tasks           Uninstalls one or more tasks.
+
+    -e file            Show the source for all tasks from <file>.
+    -e file tasks      Show the source for <task> as defined in <file>.  
+
+    -S                 Start a Mongrel handler and serve your installed Sake tasks
+                       over port 4567.
+    -p                 Set the port to serve Sake tasks on.  Defaults to 4567. Only
+                       works with -S.
+    -d                 Start and daemonize a Sake server.  Only works with -S.
+      end_help
+    end
+  end
+end

data/lib/sake.rb

@@ -0,0 +1,529 @@
+##
+# Sake.  Best served warm.
+#
+# >> Chris Wanstrath
+# => chris@ozmm.org
+
+require 'rubygems'
+require 'rake'
+require 'fileutils'
+require 'open-uri'
+begin
+  require 'ruby2ruby'
+rescue LoadError
+  die "# Sake requires the ruby2ruby gem and Ruby 1.8.6."
+end
+require File.dirname(__FILE__) + '/help'
+
+##
+# Show all Sake tasks (but no local Rake tasks), optionally only those matching a pattern.
+#   $ sake -T
+#   $ sake -T db
+#
+# Show tasks in a Rakefile, optionally only those matching a pattern.
+#   $ sake -T file.rake
+#   $ sake -T file.rake db
+#
+# Install tasks from a Rakefile, optionally specifying specific tasks.
+#   $ sake -i Rakefile
+#   $ sake -i Rakefile db:remigrate
+#   $ sake -i Rakefile db:remigrate routes
+#
+# Examine the source of a Rake task.
+#   $ sake -e routes
+# 
+# You can also examine the source of a task not yet installed. 
+#   $ sake -e Rakefile db:remigrate
+#
+# Uninstall an installed task.
+#   $ sake -u db:remigrate
+#
+# Can be passed one or more tasks.
+#
+# Invoke a Sake task.
+#   $ sake <taskname>
+#
+# Some Sake tasks may depend on tasks which exist only locally.
+#
+# For instance, you may have a db:version sake task which depends
+# on the 'environment' Rake task.  The 'environment' Rake task is one
+# defined by Rails to load its environment.  This db:version task will
+# work when your current directory is within a Rails app because
+# Sake knows how to find Rake tasks.  This task will not work,
+# however, in any other directory (unless a task named 'environment' 
+# indeed exists).
+#
+# Sake can also serve its tasks over a network by launching a Mongrel handler.
+# Pass the -S switch to start Sake in server mode.
+#
+#   $ sake -S
+#
+# You can, of course, specify a port.
+#   $ sake -S -p 1111
+#
+# You can also daemonize your server for long term serving fun.
+#   $ sake -S -d
+#
+class Sake
+  module Version
+    Major  = '1'
+    Minor  = '0'
+    Tweak  = '0'
+    String = [ Major, Minor, Tweak ].join('.')
+  end
+
+  ##
+  # The `application' class, this is basically the controller
+  # which decides what to do then executes.
+  def initialize(args)
+    @args = args
+    Rake.application
+    Rake.application.options.silent = true
+  end
+
+  ##
+  # This method figures out what to do and does it.
+  # Basically a big switch.  Note the seemingly random
+  # return statements: return if you don't want run_rake invoked.
+  # Some actions do want it invoked, however, so they don't return
+  # (like version, which prints a Sake version then trusts Rake to do
+  # likewise).
+  def run
+    ##
+    # Show Sake tasks in the store or in a file, optionally searching for a pattern.
+    # $ sake -T 
+    # $ sake -T db
+    # $ sake -T file.rake
+    # $ sake -T file.rake db
+    if index = @args.index('-T')
+      begin
+        tasks   = TasksFile.parse(@args[index + 1]).tasks
+        pattern = @args[index + 2]
+      rescue
+        tasks   = Store.tasks.sort
+        pattern = @args[index + 1]
+      end
+
+      return show_tasks(tasks, pattern)
+
+    ##
+    # Install a Rakefile or a single Rake task
+    # $ sake -i Rakefile
+    # $ sake -i Rakefile db:migrate
+    elsif index = @args.index('-i')
+      return install(index)
+
+    ##
+    # Uninstall one or more Rake tasks from the Sake store.
+    elsif index = @args.index('-u')
+      return uninstall(index)
+
+    ##
+    # Examine a Rake task
+    #   $ sake -e routes
+    #   $ sake -e Rakefile db:remigrate
+    elsif index = @args.index('-e')
+      return examine(index)
+
+    ##
+    # Start a Mongrel handler which will serve local Rake tasks
+    # to anyone who wants them.
+    #
+    # $ sake -S
+    #
+    # Set a port
+    # $ sake -S -p 1111
+    #
+    # Daemonize
+    # $ sake -S -d
+    elsif @args.include? '-S'
+      return serve_tasks
+
+    ##
+    # Prints Sake and Rake versions.
+    elsif @args.include? '--version'
+      version
+
+    ##
+    # Prints out the help screen.
+    elsif @args.include? '-h' or @args.include? '--help'
+      return Help.display
+    end
+
+    ##
+    # Runs Rake proper, including our ~/.sake tasks.
+    run_rake
+  end
+
+  private
+
+  def show_tasks(tasks = [], pattern = nil)
+    Rake.application.show(tasks, pattern)
+  end
+
+  def install(index)
+    die "# I need a Rakefile." unless file = @args[index+1]
+
+    tasks = TasksFile.parse(file).tasks
+
+    # We may want to install a specific task
+    unless (target_tasks = @args[index + 2..-1]).empty?
+      tasks = tasks.select { |task| target_tasks.include? task.name }
+    end
+
+    # No duplicates.
+    tasks.each do |task|
+      if Store.has_task? task
+        puts "# Task `#{task}' already exists in #{Store.path}"
+      else
+        puts "# Installing task `#{task}'"
+        Store.add_task task
+      end
+    end
+
+    # Commit.
+    Store.save!
+  end
+
+  def uninstall(index)
+    die "# -u option needs one or more installed tasks" if (tasks = @args[index+1..-1]).empty?
+
+    tasks.each do |name|
+      if task = Store.tasks[name]
+        puts "# Uninstalling `#{task}'.  Here it is, for reference:", task.to_ruby, ''
+        Store.remove_task(task)
+      else
+        puts "# You don't have task `#{name}' installed.", ''
+      end
+    end
+
+    Store.save!
+  end
+
+  ##
+  # There is a lot of guesswork inside this method.  Sorry.
+  def examine(index)
+    # Can be -e file task or -e task, which defaults to Store.path
+    if @args[index + 2]
+      file = @args[index + 1]
+      task = @args[index + 2]
+    else
+      task = @args[index + 1]
+    end
+
+    # They didn't pass any args in, so just show the ~/.sake file
+    unless task
+      die Store.tasks.to_ruby
+    end
+
+    # Try to find the task we think they asked for.
+    tasks = file ? TasksFile.parse(file).tasks : Store.tasks
+
+    if tasks[task]
+      die tasks[task].to_ruby 
+    end
+
+    # Didn't find the task.  See if it's a file and, if so, spit
+    # it out.
+    unless (tasks = TasksFile.parse(task).tasks).empty?
+      die tasks.to_ruby 
+    end
+
+    # Failure.  On all counts.
+    error = "# Can't find task (or file) `#{task}'"
+    error << " in #{file}" if file
+    die error
+  end
+
+  def serve_tasks
+    require File.dirname(__FILE__) + '/server'
+    Server.start(@args)
+  end
+
+  def version
+    puts "sake, version #{Version::String}"
+  end
+
+  def run_rake
+    import Sake::Store.path
+    Rake.application.run
+  end
+
+  ##
+  # Lets us do:
+  #   tasks = TasksFile.parse('Rakefile').tasks
+  #   task  = tasks['db:remigrate']
+  class TasksArray < Array
+    def [](name_or_index)
+      if name_or_index.is_a? String
+        detect { |task| task.name == name_or_index }
+      else
+        super
+      end
+    end
+
+    ##
+    # The source of all these tasks.
+    def to_ruby
+      map { |task| task.to_ruby }.join("\n")
+    end
+  end
+
+  ##
+  # This class represents a Rake task file, in the traditional sense.
+  # It takes on parameter: the path to a Rakefile.  When instantiated,
+  # it will read the file and parse out the rake tasks, storing them in
+  # a 'tasks' array.  This array can be accessed directly:
+  #
+  #   file = Sake::TasksFile.parse('Rakefile')
+  #   puts file.tasks.inspect
+  #
+  # The parse method also works with remote files, as its implementation 
+  # uses open-uri's open().
+  #
+  #   Sake::TasksFile.parse('Rakefile')
+  #   Sake::TasksFile.parse('http://errtheblog.com/code/errake')
+  class TasksFile
+    attr_reader :tasks
+
+    ##
+    # The idea here is that we may be sucking in Rakefiles from an untrusted
+    # source.  While we're happy to let the user audit the code of any Rake
+    # task before running it, we'd rather not be responsible for executing a
+    # `rm -rf` in the Rakefile itself.  To ensure this, we need to set a 
+    # safelevel before parsing the Rakefile in question.
+    def self.parse(file)
+      body = open(file).read
+
+      instance = new
+      Thread.new { instance.instance_eval "$SAFE = 3\n#{body}" }.join
+      instance
+    end
+
+    def initialize
+      @namespace = []
+      @tasks     = TasksArray.new
+      @comment   = nil
+    end
+
+    ##
+    # We fake out an approximation of the Rake DSL in order to build
+    # our tasks array.
+    private
+
+    ##
+    # Set a namespace for the duration of the block.  Namespaces can be 
+    # nested.
+    def namespace(name)
+      @namespace << name
+      yield
+      @namespace.delete name
+    end
+
+    ##
+    # Describe the following task.
+    def desc(comment)
+      @comment = comment
+    end
+
+    ## 
+    # Define a task and any dependencies it may have.
+    def task(name, &block)
+      # If we're passed a hash, we know it has one key (the name of
+      # the task) pointing to a single or multiple dependencies. 
+      if name.is_a? Hash
+        deps = name.values.first 
+        name = name.keys.first
+      end
+
+      # Our namespace is really just a convenience method.  Essentially,
+      # a namespace is just part of the task name.
+      name = [ @namespace, name ].flatten * ':'
+
+      # Sake's version of a rake task
+      task = Task.new(name, deps, @comment, &block)
+
+      @tasks << task
+
+      # We sucked up the last 'desc' declaration if it existed, so now clear
+      # it -- we don't want tasks without a description given one.
+      @comment = nil
+    end
+
+    public
+
+    ##
+    # Call to_ruby on all our tasks and return a concat'd string of them.
+    def to_ruby
+      @tasks.to_ruby
+    end
+
+    ##
+    # Add tasks to this TasksFile.  Can accept another TasksFile object or
+    # an array of Task objects.
+    def add_tasks(tasks)
+      Array(tasks.is_a?(TasksFile) ? tasks.tasks : tasks).each do |task|
+        add_task task
+      end
+    end
+
+    ##
+    # Single task version of add_tasks
+    def add_task(task)
+      @tasks << task
+    end
+
+    ##
+    # Does this task exist?
+    def has_task?(task)
+      @tasks.map { |t| t.to_s }.include? task.to_s
+    end
+
+    ##
+    # Hunt for and remove a particular task.
+    def remove_task(target_task)
+      @tasks.reject! { |task| task.name == target_task.name }
+    end
+  end
+
+  ##
+  # This is Sake's version of a Rake task.  Please handle with care.
+  class Task
+    attr_reader :name, :comment
+
+    def initialize(name, deps = nil, comment = nil, &block)
+      @name    = name
+      @comment = comment
+      @deps    = Array(deps)
+      @body    = block
+    end
+
+    ##
+    # Turn ourselves back into Rake task plaintext.
+    def to_ruby
+      out = ''
+      out << "desc '#{@comment}'\n" if @comment
+      out << "task '#{@name}'"
+
+      if @deps.any?
+        deps = @deps.map { |dep| "'#{dep}'" }.join(', ')
+        out << " => [ #{deps} ]" 
+      end
+
+      out << " do\n"
+      
+      # get rid of the proc { / } lines
+      out << @body.to_ruby.split("\n")[1...-1].join("\n")
+
+      out << "\nend\n"
+    end
+
+    ##
+    # String-ish duck typing
+    def <=>(other)
+      to_s <=> other.to_s
+    end
+
+    def to_s; @name end
+    def inspect; @name.inspect end
+  end
+
+  ##
+  # The store is, as of writing, a single Rakefile: ~/.sake
+  # When we add new tasks, we just re-build this file.  Over
+  # and over.
+  module Store
+    extend self
+
+    ##
+    # Everything we can't catch gets sent to our tasks_file.
+    # Common examples are #tasks or #add_task.
+    def method_missing(*args, &block)
+      tasks_file.send(*args, &block)
+    end
+
+    def tasks_file
+      FileUtils.touch(path) unless path.is_file?
+      @tasks_file ||= TasksFile.parse(path)
+    end
+
+    def path
+      File.join(File.expand_path('~'), '.sake')
+    end
+
+    def save!
+      File.open(path, 'w') do |file|
+        file.puts tasks_file.to_ruby
+      end
+    end
+  end
+end
+
+module Rake # :nodoc: all
+  class Application
+    ##
+    # Show the tasks as 'sake' tasks.
+    def printf(*args)
+      args[0].sub!('rake', 'sake') if args[0].is_a? String
+      super
+    end
+
+    ##
+    # Show tasks that don't have comments'
+    def display_tasks_and_comments(tasks = nil, pattern = nil)
+      tasks ||= self.tasks
+
+      if pattern ||= options.show_task_pattern
+        tasks = tasks.select { |t| t.name[pattern] || t.comment.to_s[pattern] }
+      end
+
+      width = tasks.collect { |t| t.name.length }.max
+
+      tasks.each do |t|
+        comment = "   # #{t.comment}" if t.comment
+        printf "sake %-#{width}s#{comment}\n", t.name
+      end
+    end
+    alias_method :show, :display_tasks_and_comments
+
+    ##
+    # Run Sake even if no Rakefile exists in the current directory.
+    alias_method :sake_original_have_rakefile, :have_rakefile
+    def have_rakefile(*args)
+      @rakefile ||= ''
+      sake_original_have_rakefile(*args) || true
+    end
+  end
+
+  class Task
+    ##
+    # We want only run a Sake task -- not any other matching
+    # or duplicate tasks.
+    def enhance(deps=nil, &block)
+      @prerequisites |= deps if deps
+      @actions = [block] if block_given? 
+      self
+    end
+  end
+end
+
+##
+# Hacks which give us "Rakefile".is_file? 
+class String # :nodoc: 
+  def is_file?
+    File.exists? self
+  end
+end
+
+class Nil # :nodoc: 
+  def is_file?
+    false
+  end
+end
+
+def die(*message) # :nodoc: 
+  puts message 
+  exit
+end
+
+Sake.new(ARGV).run if $0 == __FILE__

data/lib/server.rb

@@ -0,0 +1,42 @@
+require 'sake' unless defined? Sake
+require 'mongrel'
+
+class Sake
+  module Server
+    extend self
+
+    def start(args)
+      if index = args.index('-p')
+        port = args[index+1].to_i
+      else
+        port = 4567
+      end
+  
+      daemoned = args.include? '-d'
+
+      config = Mongrel::Configurator.new :host => "127.0.0.1" do
+        daemonize(:cwd => '.', :log_file => 'sake.log') if daemoned
+        listener(:port => port) { uri "/", :handler => Handler.new }
+        run
+      end
+
+      puts "# Serving warm sake tasks on port #{port}..." unless daemoned
+      config.join
+    end
+
+    class Handler < Mongrel::HttpHandler
+      def process(request, response)
+        uri    = request.params['PATH_INFO'].sub(/^\//, '')
+        status = uri.empty? ? 200 : 404
+        body   = status == 200 ? Store.to_ruby : 'Not Found' 
+
+        response.start(status) do |headers, output|
+          headers['Content-Type'] = 'text/plain'
+          output.write body
+        end
+      end
+    end
+  end
+end
+
+Sake::Server.start(ARGV) if $0 == __FILE__

metadata

@@ -0,0 +1,61 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.0
+specification_version: 1
+name: sake
+version: !ruby/object:Gem::Version 
+  version: 1.0.0
+date: 2007-06-23 00:00:00 -07:00
+summary: Sake tastes great and helps maintain system-level Rake files.
+require_paths: 
+- lib
+email: chris@ozmm.org
+homepage: http://errtheblog.com/
+rubyforge_project: err
+description: Sake tastes great and helps maintain system-level Rake files.
+autorequire: 
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- Chris Wanstrath
+files: 
+- ./bin/sake
+- ./lib/sake.rb
+- ./lib/server.rb
+- ./lib/help.rb
+- ./Manifest.txt
+- ./Rakefile
+- ./README
+- ./LICENSE
+test_files: []
+
+rdoc_options: []
+
+extra_rdoc_files: []
+
+executables: 
+- sake
+extensions: []
+
+requirements: []
+
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: ruby2ruby
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.1.6
+    version: