repo_manager 0.7.1

data/lib/repo_manager/tasks/generate/init.rb

@@ -0,0 +1,42 @@
+require 'fileutils'
+require 'repo_manager/views/view_helper'
+
+module RepoManager
+  class Generate < Thor
+    namespace :generate
+    include Thor::Actions
+    include RepoManager::ThorHelper
+    include ::RepoManager::ViewHelper
+
+    desc "init PATH", "create the initial configuration file and folder structure"
+    def init(path)
+      logger.debug "init task initial configuration: #{configuration.inspect}"
+
+      # create instance var so that it can be referenced in templates
+      @path = path ? File.expand_path(path) : FileUtils.pwd
+
+      source = path_to(:repo_manager, File.join('lib', 'repo_manager', 'tasks', 'generate', 'templates', 'config', 'repo.conf.tt'))
+      destination = File.join(@path, 'repo.conf')
+
+      say_status :init, "creating initial config file at '#{destination}'"
+      template(source, destination)
+
+      source = path_to(:repo_manager, File.join('lib', 'repo_manager', 'tasks', 'generate', 'templates', 'init', '.'))
+      destination = @path
+
+      say_status :init, "creating initial file structure in '#{destination}'"
+      directory(source, destination)
+
+      return 0
+    end
+
+    private
+
+    # where to start looking, required by the template method
+    def self.source_root
+      File.dirname(__FILE__)
+    end
+
+
+  end
+end

data/lib/repo_manager/tasks/generate/templates/config/repo.conf.tt

@@ -0,0 +1,61 @@
+---
+# default CLI options
+options:
+  color      : AUTO
+  verbose    : false
+  short      : false
+  unmodified : HIDE
+  match      : ALL
+  list       : ALL
+
+folders:
+
+  # main repo configuration files
+  assets  : <%= "#{@path}/assets" %>
+
+  #
+  # repo user tasks, file extentions can be '.rb' or '.thor'
+  #
+  # @examples:
+  #
+  #     linux:
+  #
+  #         ~/.repo_manager/tasks
+  #
+  #     win32
+  #
+  #         c:/dat/condenser/tasks
+  #
+  tasks        : <%= "#{@path}/tasks" %>
+
+# git commands must be whitelisted
+commands:
+- diff
+- grep
+- log
+- ls-files
+- show
+- status
+
+logging:
+  loggers:
+    - name          : root
+      appenders:
+        - logfile
+        - stdout
+  appenders:
+    - type          : Stdout
+      name          : stdout
+      level         : info
+      layout:
+        type        : Pattern
+        pattern     : '%l %c : %m\n'
+        color_scheme: default
+    - type          : File
+      name          : logfile
+      level         : info
+      truncate      : true
+      filename      : '<%= "#{@path}/repo.log" %>'
+      layout:
+        type        : Pattern
+        pattern     : '[%d] %l %c : %m\n'

data/lib/repo_manager/tasks/generate/templates/init/global/default/asset.conf

@@ -0,0 +1,2 @@
+# defaults
+---

data/lib/repo_manager/tasks/task_manager.rb

@@ -0,0 +1,166 @@
+require 'thor'
+require 'thor/core_ext/file_binary_read'
+require 'thor/util'
+
+# embed Thor engine to allow extendable tasks
+module RepoManager
+  class TaskManager
+
+    attr_accessor :configuration
+
+    def initialize(configuration=nil)
+      @configuration = configuration.dup
+      options = @configuration[:options]
+      self.color = options ? options[:color] : true
+    end
+
+    # @examples:
+    #
+    #     find_by_namespace(sweep:screenshots)
+    #     find_by_namespace(repo_manager:sweep:screenshots)
+    #
+    #     returns:
+    #
+    #         RepoManager::Sweep, screenshots
+    #
+    # @return [Class, String] the Thor class and the task
+    def find_by_namespace(name)
+      names = name.to_s.split(':')
+      raise "invalid task namespace" unless names.any?
+
+      namespace = names.join(":")
+
+      #puts "searching for task #{namespace}"
+      klass, task = ::Thor::Util.find_class_and_task_by_namespace(namespace, fallback = false)
+    end
+
+    #
+    # @examples:
+    #
+    #     invoke(sweep:screenshots)
+    #     invoke(update:models)
+    #     invoke(generate:init, ["."], nil)
+    #
+    def invoke(name, args=ARGV)
+      logger.debug "invoke name: #{name}, args #{args.inspect}, configuration defined: #{configuration ? 'yes' : 'no'}"
+      args = args.dup
+      load_tasks
+
+      logger.debug "find_by_namespace: #{name}"
+      klass, task  = find_by_namespace(name)
+
+      if klass
+        config = {}
+        config[:shell] ||= shell
+        klass.send(:dispatch, task, args, nil, config) do |instance|
+          if defined?(instance.configuration)
+            instance.configuration = configuration.dup
+          end
+        end
+        logger.debug "after invoke"
+        result = 0
+      else
+        puts "Could not find task #{name}"
+        result = 1
+      end
+      result
+    end
+
+    # load all the tasks in this gem plus the user's own repo_manager task folder
+    #
+    # NOTE: doesn't load any default tasks or non-RepoManager tasks
+    def load_tasks
+      return if @loaded
+
+      # By convention, the '*_helper.rb' files are helpers and need to be loaded first. Load
+      # them into the Thor::Sandbox namespace
+      Dir.glob( File.join(File.dirname(__FILE__), '**', '*.rb')  ).each do |task|
+        if task.match(/_helper\.rb$/)
+          #logger.debug "load_thorfile helper: #{task}"
+          ::Thor::Util.load_thorfile task
+        end
+      end
+
+      # Now load the thor files
+      Dir.glob( File.join(File.dirname(__FILE__), '**', '*.rb')  ).each do |task|
+        unless task.match(/_helper\.rb$/)
+          #logger.debug "load_thorfile: #{task}"
+          ::Thor::Util.load_thorfile task
+        end
+      end
+
+      # load user tasks
+      if user_tasks_folder
+        Dir.glob( File.join([user_tasks_folder, '**', '*.{rb,thor}'])  ).each { |task| ::Thor::Util.load_thorfile task if task.match(/_helper\.rb$/) }
+        Dir.glob( File.join([user_tasks_folder, '**', '*.{rb,thor}'])  ).each { |task| ::Thor::Util.load_thorfile task unless task.match(/_helper\.rb$/) }
+      end
+
+      @loaded = true
+    end
+
+    def user_tasks_folder
+      return unless configuration
+
+      folder = configuration[:folders] ?  configuration[:folders][:tasks] : nil
+      return unless folder
+      return folder if Pathname.new(folder).absolute?
+
+      if configuration[:configuration_filename]
+        base_folder = File.dirname(configuration[:configuration_filename])
+        folder = File.join(base_folder, folder)
+      end
+    end
+
+    def color
+      @color
+    end
+
+    def color=(value)
+      @color = value
+      if value
+        ::Thor::Base.shell = Thor::Shell::Color
+      else
+        ::Thor::Base.shell = Thor::Shell::Basic
+      end
+    end
+
+    def shell
+      return @shell if @shell
+
+      @shell = @color ? ::Thor::Shell::Color.new : ::Thor::Shell::Basic.new
+    end
+
+    # display help for the given task
+    #
+    def task_help(name)
+      load_tasks
+
+      klass, task  = find_by_namespace(name)
+
+      # set '$thor_runner' to true to display full namespace
+      $thor_runner = true
+
+      klass.task_help(shell , task)
+    end
+
+    # display a list of tasks
+    def list_tasks
+      load_tasks
+
+      # set '$thor_runner' to true to display full namespace
+      $thor_runner = true
+
+      list = [] #Thor.printable_tasks(all = true, subcommand = true)
+      Thor::Base.subclasses.each do |klass|
+        list += klass.printable_tasks(false) unless klass == Thor
+      end
+      list.sort!{ |a,b| a[0] <=> b[0] }
+
+      title = "repo_manager tasks"
+      shell.say shell.set_color(title, :blue, bold=true)
+      shell.say "-" * title.size
+      shell.print_table(list, :ident => 2, :truncate => true)
+    end
+
+  end
+end

data/lib/repo_manager/tasks/thor_helper.rb

@@ -0,0 +1,29 @@
+require 'pathname'
+require 'rbconfig'
+require 'repo_manager'
+require 'repo_manager/actions/action_helper'
+
+module RepoManager
+  module ThorHelper
+    include ::RepoManager::ActionHelper
+
+    # main repo_manager configuration setttings file
+    def configuration(configuration_file=nil)
+      return @configuration if @configuration
+      logger.debug "getting repo_manager configuration"
+      app_options = {}
+      app_options[:config] = configuration_file || options[:config]
+      @configuration = ::RepoManager::Settings.new(nil, app_options)
+    end
+
+    def configuration=(value={})
+      logger.debug "setting repo_manager configuration"
+      @configuration = value.dup
+    end
+
+    def ruby_binary
+      File.join(RbConfig::CONFIG['bindir'], RbConfig::CONFIG['ruby_install_name'])
+    end
+
+  end
+end

data/lib/repo_manager/test/asset_steps.rb

@@ -0,0 +1,19 @@
+Given /^the folder "([^"]*)" with the following asset configurations:$/ do |folder, table|
+  create_dir(folder) unless File.exists?(File.join(current_dir, folder))
+
+  table.hashes.each do |hash|
+    config = {}
+    config.merge!('path' => hash[:path]) if hash[:path]
+    config.merge!('parent' => hash[:parent]) if hash[:parent]
+    config.merge!('binary' => hash[:binary]) if hash[:binary]
+    config.merge!('icon' => hash[:icon]) if hash[:icon]
+
+    asset_name = hash[:name]
+    create_dir(File.join(folder, asset_name))
+
+    filename = File.join(folder, asset_name, 'asset.conf')
+    write_file(filename, config.to_conf)
+  end
+
+end
+

data/lib/repo_manager/test/base_steps.rb

@@ -0,0 +1,152 @@
+require 'fileutils'
+require 'chronic'
+require 'repo_manager/test/test_api'
+
+World(RepoManager::TestApi)
+
+# Given PENDING: some reason
+Given /^PENDING/ do
+  pending
+end
+
+Then /^its output should contain "([^"]*)"$/ do |expected|
+  assert_partial_output(expected, output_from(@commands.last))
+end
+
+Then /^its output should not contain "([^"]*)"$/ do |expected|
+  assert_no_partial_output(expected, output_from(@commands.last))
+end
+
+Then /^its output should contain:$/ do |expected|
+  assert_partial_output(expected, output_from(@commands.last))
+end
+
+Then /^its output should not contain:$/ do |expected|
+  assert_no_partial_output(expected, output_from(@commands.last))
+end
+
+# "the output should match" allows regex in the partial_output, if
+# you don't need regex, use "the output should contain" instead since
+# that way, you don't have to escape regex characters that
+# appear naturally in the output
+Then /^its output should match \/([^\/]*)\/$/ do |expected|
+  assert_matching_output(expected, output_from(@commands.last))
+end
+
+Then /^its output should not match \/([^\/]*)\/$/ do |expected|
+  output_from(@commands.last).should_not =~ /#{expected}/
+end
+
+Then /^its output should match:$/ do |expected|
+  assert_matching_output(expected, output_from(@commands.last))
+end
+
+Then /^its output should not match:$/ do |expected|
+  output_from(@commands.last).should_not =~ /#{expected}/
+end
+
+Then /^the normalized output should contain:$/ do |partial_output|
+  str = process_regex_tokens(Regexp.escape(normalize(partial_output)))
+  normalize(all_output).should =~ Regexp.compile(str)
+end
+
+Then /^the normalized output should not contain:$/ do |partial_output|
+  str = process_regex_tokens(Regexp.escape(normalize(partial_output)))
+  normalize(all_output).should_not =~ Regexp.compile(str)
+end
+
+Then /^the normalized output should contain exactly:$/ do |partial_output|
+  normalize(all_output).should == normalize(partial_output)
+end
+
+Then /^the normalized output should match \/([^\/]*)\/$/ do |partial_output|
+  normalize(all_output).should =~ /#{normalize(partial_output)}/
+end
+
+Then /^the normalized output should not match \/([^\/]*)\/$/ do |partial_output|
+  normalize(all_output).should_not =~ /#{normalize(partial_output)}/
+end
+
+Then /^the normalized output should match:$/ do |partial_output|
+  normalize(all_output).should =~ /#{normalize(partial_output)}/m
+end
+
+Then /^the normalized output should not match:$/ do |partial_output|
+  normalize(all_output).should_not =~ /#{normalize(partial_output)}/m
+end
+
+Then /^the file "([^"]*)" should contain:$/ do |file, partial_content|
+  process_and_check_file_content(fullpath(file), partial_content, true)
+end
+
+Then /^the file "([^"]*)" should not contain:$/ do |file, partial_content|
+  process_and_check_file_content(fullpath(file), partial_content, false)
+end
+
+Then /^the file "([^"]*)" should match:$/ do |file, partial_content|
+  check_file_content(fullpath(file),/#{partial_content}/, true)
+end
+
+Then /^the file "([^"]*)" should not match:$/ do |file, partial_content|
+  check_file_content(fullpath(file),/#{partial_content}/, false)
+end
+
+Then /^the file "([^"]*)", within (\d+) seconds, should contain:$/ do |file, seconds, partial_content|
+  seconds = seconds.to_i
+
+  lambda {
+
+    timeout(seconds) do
+      begin
+        sleep 0.2 unless (seconds == 0)
+      end until (seconds == 0 || File.exists?(fullpath(file)))
+    end
+
+  }.should_not raise_exception
+
+  process_and_check_file_content(fullpath(file), partial_content, true)
+end
+
+Given /^the fixture "([^"]*)" is copied to "([^"]*)"$/ do |source, destination|
+  in_current_dir do
+    source = File.join("../../spec/fixtures/", source)
+    _mkdir(File.dirname(destination))
+    FileUtils.cp(source, destination)
+  end
+end
+
+# | filename   | mtime | content |
+Given /^the folder "([^"]*)" with the following files:$/ do |folder, table|
+  create_dir(folder) unless File.exists?(File.join(current_dir, folder))
+  table.hashes.each do |hash|
+    filename = hash[:filename]
+    content = hash[:content]
+    filename = File.join(folder,filename)
+    mtime = hash[:mtime] ? Chronic.parse(hash[:mtime]) : Time.now
+    write_file(filename, content)
+    File.utime(mtime, mtime, fullpath(filename))
+  end
+end
+
+# | filename   | mtime | content |
+Given /^the folder "([^"]*)" with the following binary files:$/ do |folder, table|
+  create_dir(folder) unless File.exists?(File.join(current_dir, folder))
+  table.hashes.each do |hash|
+    filename = hash[:filename]
+    filename = File.join(folder,filename)
+    mtime = hash[:mtime] ? Chronic.parse(hash[:mtime]) : Time.now
+    filesize = hash[:size] || 10
+    write_fixed_size_file(filename, filesize.to_i)
+    File.utime(mtime, mtime, fullpath(filename))
+  end
+end
+
+Given /^the following empty files:$/ do |files|
+  files.raw.map do |file_row|
+    write_file(file_row[0], '')
+  end
+end
+
+Given /^a (\d+) byte file named "([^"]*)"$/ do |file_size, file_name|
+  write_fixed_size_file(file_name, file_size.to_i)
+end