runfile 0.12.0 → 1.0.0.rc1

data/lib/runfile/dsl.rb

@@ -1,90 +0,0 @@
-# This file defines all the commands supported in a Runfile.
-# All commands are immediately handed over to the Runner instance
-# for handling.
-
-module Runfile
-  module DSL
-    private
-
-    # Set the name of your Runfile program
-    #   title 'My Runfile'
-    def title(name)
-      Runner.instance.name = name
-    end
-
-    # Set the version of your Runfile program
-    #   version '0.1.0'
-    def version(ver)
-      Runner.instance.version = ver
-    end
-
-    # Set the one line summary of your Runfile program
-    #   summary 'Utilities for my server'
-    def summary(text)
-      Runner.instance.summary = text
-    end
-
-    # Set the usage pattern for the next action
-    #   usage 'server [--background]'
-    def usage(text)
-      Runner.instance.last_usage = text
-    end
-
-    # Set the help message for the next action
-    #   help 'Starts the server in the foreground or background'
-    def help(text)
-      Runner.instance.last_help = text
-    end
-
-    # Add an option/flag to the next action (can be called multiple
-    # times)
-    #   option '-b --background', 'Start in the background'
-    def option(flag, text, scope=nil)
-      Runner.instance.add_option flag, text, scope
-    end
-
-    # Add a parameter (can be called multiple times)
-    #   param 'FOLDER', 'Folder to copy'
-    def param(name, text, scope=nil)
-      Runner.instance.add_param name, text, scope
-    end
-
-    # Set an environment variable (can be called multiple times)
-    #   env_var 'USER', 'Set the user (same as --user)'
-    def env_var(name, text, scope = nil)
-      Runner.instance.add_env_var name, text, scope
-    end
-
-    # Set an example command (can be called multiple times)
-    #   example 'server --background'
-    def example(text)
-      Runner.instance.add_example text
-    end
-
-    # Define the action
-    #   action :server do |args|
-    #     run 'rails server'
-    #   end
-    def action(name, altname=nil, &block) 
-      Runner.instance.add_action name, altname, &block
-    end
-
-    # Define a new command namespace
-    #   command 'server'
-    #   # ... define actions here
-    #   endcommand
-    def command(name=nil)
-      Runner.instance.namespace = name
-    end
-
-    # Cross-call another action
-    #   execute 'other_action'
-    def execute(command_string)
-      Runner.instance.cross_call command_string
-    end
-
-    # Also allow to use 'endcommand' instead of 'command' to end
-    # a command namespace definition
-    alias_method :endcommand, :command
-  end
-end

data/lib/runfile/refinements.rb

@@ -1,22 +0,0 @@
-module Runfile
-  module Refinements
-    refine String do
-      def word_wrap(length = nil)
-        text = self
-
-        length ||= Terminal.width
-        lead = text[/^\s*/]
-        text.strip!
-        length -= lead.length
-        text.split("\n").collect! do |line|
-          if line.length > length
-            line.gsub!(/([^\s]{#{length}})([^\s$])/, "\\1 \\2")
-            line.gsub(/(.{1,#{length}})(\s+|$)/, "#{lead}\\1\n").rstrip
-          else
-            "#{lead}#{line}"
-          end
-        end * "\n"
-      end
-    end
-  end
-end

data/lib/runfile/runfile_helper.rb

@@ -1,165 +0,0 @@
-require 'docopt'
-require 'pp'
-
-module Runfile
-
-  # The RunfileHelper class assists in:
-  # 1. Finding named.runfiles
-  # 2. Creating new runfiles (`run new`)
-  # 3. Showing a list of found system runfiles in a colorful help
-  class RunfileHelper
-    using Refinements
-    include SettingsMixin
-    
-    # Handle the case when `run` is called without a Runfile 
-    # present. We will let the user know they can type `run new`
-    # to create a new sample Runfile.
-    # If the first argument matches the name of a *.runfile name,
-    # we will return it to the caller. Otherwise, we return false
-    # to indicate "no further handling is needed".
-    def handle(argv)
-      # make a new runfile
-      if argv[0] == "new" && !settings_present?
-        make_runfile argv[1]
-        return false
-      end
-
-      # get a list of *.runfile path-wide
-      runfiles = find_runfiles || []
-
-      # if first arg is a valid *.runfile, run it
-      if argv[0] 
-        runfile = runfiles.select { |f| f[/\/#{argv[0]}.runfile/] }.first
-        runfile and return runfile
-      end
-
-      # if we are here, offer some help and advice and show a list
-      # of possible runfiles to run.
-      show_make_help runfiles, settings.folder
-      return false
-    end
-
-    def purge_settings
-      @settings = OpenStruct.new
-    end
-
-    private
-
-    # Create a new runfile in the current directory. We can either
-    # create a standard 'Runfile' or a 'named.runfile'.
-    def make_runfile(name=nil)
-      name = 'Runfile' if name.nil?
-      template = File.expand_path("../templates/Runfile", __FILE__)
-      name += ".runfile" unless name == 'Runfile'
-      dest = "#{Dir.pwd}/#{name}"
-      begin
-        File.write(dest, File.read(template))
-        puts "#{name} created."
-      rescue => e
-        abort "Failed creating #{name}\n#{e.message}"
-      end
-    end
-
-    # Find all *.runfile files in our search difrectories
-    def find_runfiles
-      result = []
-      dirs = runfile_folders
-      dirs.each do |d|
-        found = Dir[File.join(d, '*.runfile')]
-        result << found unless found.empty?
-      end
-      return result.empty? ? false : result.flatten.uniq
-    end
-
-    # Show some helpful tips, and a list of available runfiles
-    def show_make_help(runfiles, compact=false)
-      puts "Runfile engine v#{Runfile::VERSION}" unless compact
-      if runfiles.size < 3 and !compact
-        puts "\nTip: Type 'run new' or 'run new name' to create a runfile.\nFor global access, place named.runfiles in ~/runfile/ or in /etc/runfile/."
-      end
-      if runfiles.empty? 
-        puts "\nRunfile not found."
-      else
-        puts ""
-        compact ? say_runfile_usage(runfiles) : say_runfile_list(runfiles)
-      end
-    end
-
-    # Return array of folders we should search in for runfiles.
-    def runfile_folders
-      # This trick allows searching in subfolders recursively, including
-      # one level of symlinked folder
-      subdirs = '**{,/*/**}'
-      
-      # If there is a '.runfile' settings file with a folder definition
-      # in it, use it. Otherwise, search globally.
-      if settings.folder
-        ["#{settings.folder}/#{subdirs}"]
-      else
-        [Dir.pwd, "#{Dir.home}/runfile/#{subdirs}", "/etc/runfile/#{subdirs}"]
-      end
-    end
-    
-    # [UNUSED] Same as runfile_folders, but including PATH
-    def runfile_folders_with_path
-      dirs = path_dirs
-      dirs.insert 0, Dir.pwd, "#{Dir.home}/runfile", "/etc/runfile"
-      dirs
-    end
-
-    # Output the list of available runfiles
-    def say_runfile_list(runfiles)
-      runfile_paths = runfiles.map { |f| File.dirname f }
-      max = runfile_paths.max_by(&:length).size
-      width = Terminal.width
-      runfiles.each do |f|
-        f[/([^\/]+).runfile$/]
-        command  = "run #{$1}"
-        spacer_size = width - max - command.size - 6
-        spacer_size = [1, spacer_size].max
-        spacer = '.' * spacer_size
-        puts "  #{command} #{spacer} #{File.dirname f}"
-      end
-    end
-
-    # Output the list of available runfiles without filename
-    def say_runfile_usage(runfiles)
-      runfiles_as_columns = get_runfiles_as_columns runfiles
-      
-      puts "#{settings.intro}\n" if settings.intro
-      puts "Usage: run <file>"
-      puts runfiles_as_columns
-
-      show_shortcuts if settings.shortcuts
-    end
-
-    # Prints a friendly output of the shortcut list
-    def show_shortcuts
-      puts "\nShortcuts:"
-      max = settings.shortcuts.keys.max_by(&:length).length
-      settings.shortcuts.each_pair do |shortcut, command|
-        puts "  #{shortcut.rjust max} : #{command}"
-      end
-    end
-
-    # Returns the list of runfiles, organized as columns based on the
-    # current terminal width
-    def get_runfiles_as_columns(runfiles)
-      namelist = runfile_names runfiles
-      width = Terminal.width
-      max = namelist.max_by(&:length).length
-      message = "  " + namelist.map {|f| f.ljust max+1 }.join(' ')
-      message.word_wrap width
-    end
-
-    def runfile_names(runfiles)
-      runfiles.map {|f| /([^\/]+).runfile$/.match(f)[1] }.sort
-    end
-
-    # Returns an array of path directories
-    def path_dirs
-      ENV['PATH'].split(File::PATH_SEPARATOR)
-    end
-
-  end
-end

data/lib/runfile/settings.rb

@@ -1,34 +0,0 @@
-require 'ostruct'
-require 'yaml'
-
-module Runfile
-
-  # The Settings class handles '.runfile' YAML config files.
-  # If found in the current directory, we will use their content.
-  class Settings
-    def as_struct
-      OpenStruct.new settings
-    end
-
-    private
-
-    def settings
-      @settings ||= settings!
-    end
-
-    def settings!
-      File.file?('.runfile') ? YAML.load_file('.runfile') : {}
-    end
-  end
-
-  module SettingsMixin
-    def settings
-      @settings ||= Settings.new.as_struct
-    end
-
-    def settings_present?
-      File.file?('.runfile')
-    end
-  end
-
-end

data/lib/runfile/setup.rb

@@ -1,19 +0,0 @@
-module Runfile
-  class << self
-    # Set the directory where PID files are stored when using `run_bg`
-    #   Runfile.pid_dir = 'tmp'
-    attr_accessor :pid_dir
-
-    # Disable echoing of the command when using `run` or `run!`
-    #   Runfile.quiet = true
-    attr_accessor :quiet
-
-    # You can also configure Runfile by providing a block:
-    #  Runfile.setup do |config|
-    #    config.quiet = true
-    #  end
-    def setup
-      yield self
-    end
-  end
-end

data/lib/runfile/templates/Runfile

@@ -1,16 +0,0 @@
-title   "Greeter"
-summary "A sample Runfile"
-version "0.1.0"
-
-usage  "hello [<name> --shout]"
-help   "Say hello"
-option "-s --shout", "Greet louder"
-action :hello do |args|
-  message = "Hello #{args['<name>']}"
-  
-  if args['--shout']
-    puts message.upcase
-  else
-    puts message
-  end
-end

data/lib/runfile/terminal.rb

@@ -1,32 +0,0 @@
-# This file provides some terminal related utilities (extracted from Colsole)
-
-module Runfile
-  class Terminal
-    class << self
-      def size(default = [80,30])
-        if (ENV['COLUMNS'] =~ /^\d+$/) && (ENV['LINES'] =~ /^\d+$/)
-          result = [ENV['COLUMNS'].to_i, ENV['LINES'].to_i]
-        elsif (RUBY_PLATFORM =~ /java/ || (!STDIN.tty? && ENV['TERM'])) && command_exist?('tput')
-          result = [`tput cols 2>&1`.to_i, `tput lines 2>&1`.to_i]
-        elsif STDIN.tty? && command_exist?('stty')
-          result = `stty size 2>&1`.scan(/\d+/).map { |s| s.to_i }.reverse
-        else
-          result = default
-        end
-        result = default unless result[0].is_a? Integer and result[1].is_a? Integer and result[0] > 0 and result[1] > 0
-        result
-      end
-
-      def width
-        size[0]
-      end
-
-      def command_exist?(command)
-        ENV['PATH'].split(File::PATH_SEPARATOR).any? do |dir|
-          File.exist?(File.join dir, command) or File.exist?(File.join dir, "#{command}.exe")
-        end
-      end
-
-    end
-  end
-end