repo_manager 0.7.1

data/features/support/aruba.rb

@@ -0,0 +1,15 @@
+require 'aruba/api'
+require 'fileutils'
+
+APP_BIN_PATH = File.join(FileUtils.pwd, 'bin', 'repo')
+
+module Aruba
+  module Api
+
+    # override aruba avoid 'current_ruby' call and make sure
+    # that binary run on Win32 without the binstubs
+    def detect_ruby(cmd)
+      cmd = cmd.gsub(/^repo/, "ruby -S #{APP_BIN_PATH}")
+    end
+  end
+end

data/features/support/env.rb

@@ -0,0 +1,11 @@
+require 'repo_manager'
+require 'aruba/cucumber'
+require 'rspec/expectations'
+
+Before do
+  @aruba_timeout_seconds = 10
+end
+
+Before('@slow_process') do
+  @aruba_io_wait_seconds = 2
+end

data/features/support/steps.rb

@@ -0,0 +1,3 @@
+require 'repo_manager/test/base_steps'
+require 'repo_manager/test/asset_steps'
+require 'repo_manager/test/repo_steps'

data/features/tasks/add/asset.feature

@@ -0,0 +1,178 @@
+@announce
+Feature: Task to generate asset configurations
+
+  Generate config files automatically by searching each top level folder
+  contained in the given command line FOLDER.  If a '.git' folder exists,
+  then that top level folder will be used to generate a new config file.
+
+  Help:
+
+      repo help add:asset
+
+      repo help add:assets
+
+  USAGE :
+
+    repo add:asset WORKING_FOLDER
+
+    repo add:assets TOP_LEVEL_FOLDER
+
+  Options:
+    -r, [--refresh]               # Refresh existing blank attributes
+    -f, [--filter=one two three]  # List of regex folder name filters
+
+  Runtime options:
+    -s, [--skip]     # Skip files that already exist
+    -q, [--quiet]    # Suppress status output
+    -p, [--pretend]  # Run but do not make any changes
+    -f, [--force]    # Overwrite files that already exist
+
+  Examples
+
+    cond add:assets c:/users/robert/documents/
+    cond add:assets ~/workspace/delphi
+    cond add:assets ~/workspace --filter guard-*,repo_manager-*
+
+  General Notes:
+
+    * task is not recursive and only looks for .git folder in direct children of the top level folder
+    * task will skip existing asset names and existing asset paths unless using the '--refresh' switch
+    * add '.condenser' file to application path to have Condenser always skip this application
+
+  Example output (~/repo_manager/assets/asset.conf):
+
+      ---
+      path: some/path/my_repo_name
+
+
+  Background: Test repositories and a valid config file
+    Given a repo in folder "workspace/repo1_path" with the following:
+      | filename         | status | content  |
+      | .gitignore       | C      |          |
+    And a repo in folder "workspace/repo2_path" with the following:
+      | filename         | status | content  |
+      | .gitignore       | C      |          |
+    And a directory named "workspace/not_a_repo"
+
+
+  Scenario: Point at a top level folder that contains two repos and on non repo folder
+    Given a file named "repo.conf" with:
+      """
+      ---
+      folders:
+        assets : assets
+      """
+    And a directory named "assets"
+    When I run `repo add:assets workspace` interactively
+    When I type "y"
+    Then the exit status should be 0
+    And the output should contain:
+      """
+      Found 2 asset(s)
+      """
+    And the file "assets/repo1_path/asset.conf" should match:
+      """
+      path: .*/workspace/repo1_path
+      """
+    And the file "assets/repo2_path/asset.conf" should match:
+      """
+      path: .*/workspace/repo2_path
+      """
+
+  Scenario: Point at a single working folder
+    Given a file named "repo.conf" with:
+      """
+      ---
+      folders:
+        assets : assets
+      """
+    And a directory named "assets"
+    When I run `repo add:asset workspace/repo1_path` interactively
+    When I type "y"
+    Then the exit status should be 0
+    And the output should contain:
+      """
+      Found 1 asset(s)
+      """
+    And the file "assets/repo1_path/asset.conf" should match:
+      """
+      path: .*/workspace/repo1_path
+      """
+
+  Scenario: Point at a single working folder relative to repo.conf
+    Given a file named "repo_manager/repo.conf" with:
+      """
+      ---
+      folders:
+        assets : assets
+      """
+    And a directory named "repo_manager/assets"
+    When I run `repo add:asset workspace/repo1_path` interactively
+    When I type "y"
+    Then the exit status should be 0
+    And the output should contain:
+      """
+      Found 1 asset(s)
+      """
+    And the file "repo_manager/assets/repo1_path/asset.conf" should match:
+      """
+      path: .*/workspace/repo1_path
+      """
+
+  Scenario: Point at an invalid working folder
+    Given a file named "repo.conf" with:
+      """
+      ---
+      folders:
+        assets : assets
+      """
+    And a directory named "assets"
+    When I run `repo add:asset workspace/not_a_repo` interactively
+    Then the exit status should be 1
+    And the output should not contain:
+      """
+      Found 1 asset(s)
+      """
+    And the output should contain:
+      """
+      unable to find '.git' folder
+      """
+
+  Scenario: Point at a single working folder and give it a non-default name
+    Given a file named "repo.conf" with:
+      """
+      ---
+      folders:
+        assets : assets
+      """
+    And a directory named "assets"
+    When I run `repo add:asset workspace/repo1_path --name=repo1` interactively
+    When I type "y"
+    Then the exit status should be 0
+    And the output should contain:
+      """
+      Found 1 asset(s)
+      """
+    And the file "assets/repo1/asset.conf" should match:
+      """
+      path: .*/workspace/repo1_path
+      """
+
+  Scenario: Attempting to add an asset that exists under a different name
+    Given a file named "repo.conf" with:
+      """
+      ---
+      folders:
+        assets : assets
+      """
+    And a directory named "assets"
+    And the folder "assets" with the following asset configurations:
+      | name       | path                  |
+      | repo1_path | workspace/repo1_path  |
+    When I run `repo add:asset workspace/repo1_path --name repo1` interactively
+    When I type "y"
+    Then the exit status should be 1
+    And its output should contain:
+      """
+      asset already exists under a different name
+      """

data/features/tasks/generate/init.feature

@@ -0,0 +1,56 @@
+@announce
+Feature: Generate init task
+
+  End-user generation of a repo_manager configuration
+
+  Example commands:
+
+      repo task generate:init .repo_manager
+      repo task generate:init .
+      repo task generate:init repo_manager --force --verbose
+
+  Scenario: Specify path on the command line
+    When I run `repo task generate:init nodefault --no-config --verbose`
+    Then the exit status should be 0
+    Then the output should contain:
+      """
+      creating initial file structure
+      """
+    And the following files should exist:
+      | nodefault/assets/.gitignore                |
+      | nodefault/global/default/asset.conf        |
+      | nodefault/tasks/.gitignore                 |
+
+  Scenario: Path not specified
+    When I run `repo task generate:init --no-config`
+    Then the exit status should be 1
+    Then the output should contain:
+      """
+      repo init requires at least 1 argument
+      """
+
+  Scenario: Config file not found
+    When I run `repo task generate:init . --config=BadConfig.conf`
+    Then the exit status should be 1
+    Then the output should contain:
+      """
+      config file not found
+      """
+
+  Scenario: A file exists at destination and is not overwritten when answering 'No'
+    Given a file named ".gitignore" with:
+      """
+      .my.file.3234134
+      """
+    When I run `repo task generate:init . --no-config` interactively
+    When I type "n"
+    Then the exit status should be 0
+    And the following files should exist:
+      | .gitignore             |
+    And the file ".gitignore" should contain:
+      """
+      .my.file.3234134
+      """
+    And the following files should exist:
+      | assets/.gitignore      |
+

data/lib/repo_manager.rb

@@ -0,0 +1,36 @@
+# require all files here
+require 'rbconfig'
+require 'repo_manager/core'
+require 'repo_manager/errors'
+require 'repo_manager/assets'
+require 'repo_manager/views'
+require 'repo_manager/actions'
+require 'repo_manager/git'
+require 'repo_manager/app'
+require 'repo_manager/settings'
+require 'repo_manager/logger'
+
+
+# Master namespace
+module RepoManager
+
+  # Contents of the VERSION file
+  #
+  # Example format: 0.0.1
+  #
+  # @return [String] the contents of the version file in #.#.# format
+  def self.version
+    version_info_file = File.join(File.dirname(__FILE__), *%w[.. VERSION])
+    File.open(version_info_file, "r") do |f|
+      f.read.strip
+    end
+  end
+
+  # Platform constants
+  unless defined?(RepoManager::WINDOWS)
+    WINDOWS = RbConfig::CONFIG['host_os'] =~ /mswin|mingw/i
+    CYGWIN = RbConfig::CONFIG['host_os'] =~ /cygwin/i
+  end
+
+end
+

data/lib/repo_manager/actions.rb

@@ -0,0 +1,8 @@
+require 'repo_manager/actions/base_action'
+require 'repo_manager/actions/app_action'
+require 'repo_manager/actions/help_action'
+require 'repo_manager/actions/list_action'
+require 'repo_manager/actions/task_action'
+require 'repo_manager/actions/path_action'
+require 'repo_manager/actions/git_action'
+require 'repo_manager/actions/status_action'

data/lib/repo_manager/actions/action_helper.rb

@@ -0,0 +1,39 @@
+require 'pathname'
+require 'rbconfig'
+require 'fileutils'
+
+module RepoManager
+  module ActionHelper
+
+    def shell_quote(string)
+      return "" if string.nil? or string.empty?
+      if windows?
+        %{"#{string}"}
+      else
+        string.split("'").map{|m| "'#{m}'" }.join("\\'")
+      end
+    end
+
+    def windows?
+      RbConfig::CONFIG['host_os'] =~ /mswin|mingw/i
+    end
+
+    # @return[String] the relative path from the CWD
+    def relative_path(path)
+      return unless path
+
+      path = Pathname.new(File.expand_path(path, FileUtils.pwd))
+      cwd = Pathname.new(FileUtils.pwd)
+
+      if windows?
+        # c:/home D:/path/here will faile with ArgumentError: different prefix
+        return path.to_s if path.to_s.capitalize[0] != cwd.to_s.capitalize[0]
+      end
+
+      path = path.relative_path_from(cwd)
+      path = "./#{path}" unless path.absolute? || path.to_s.match(/^\./)
+      path.to_s
+    end
+
+  end
+end

data/lib/repo_manager/actions/app_action.rb

@@ -0,0 +1,30 @@
+####################################################
+# The file is was originally cloned from "Basic App"
+# More information on "Basic App" can be found in the
+# "Basic App" repository.
+#
+# See http://github.com/robertwahler
+####################################################
+module RepoManager
+
+  # An abstract superclass for basic action functionality specific to an
+  # application implementation.  Put application specific code here.
+  class AppAction < BaseAction
+
+    # Used by asset factory to create assets.  Override in app_action.rb or a
+    # descendant to set the class to be instantiated by by the AssetManager.
+    #
+    # @return [Symbol] asset type
+    def asset_type
+      :repo_asset
+    end
+
+    # alias for items/assets
+    #
+    # @return [Array] of repos
+    def repos
+      items
+    end
+  end
+
+end

data/lib/repo_manager/actions/base_action.rb

@@ -0,0 +1,296 @@
+####################################################
+# The file is was originally cloned from "Basic App"
+# More information on "Basic App" can be found in the
+# "Basic App" repository.
+#
+# See http://github.com/robertwahler
+####################################################
+
+require 'repo_manager/assets/asset_manager'
+
+module RepoManager
+
+  # An abstract superclass for basic action functionality
+  class BaseAction
+    # main configuration hash
+    attr_reader :configuration
+
+    # options hash, read from configuration hash
+    attr_reader :options
+
+    # args as passed on command line
+    attr_reader :args
+
+    # filename to template for rendering
+    attr_accessor :template
+
+    # filename to write output
+    attr_accessor :output
+
+    # numeric exit code set from return of process method
+    attr_reader :exit_code
+
+    # bin wrapper option parser object
+    attr_accessor :option_parser
+
+    def initialize(args=[], configuration={})
+      @configuration = configuration
+      @options = configuration[:options] || {}
+      @args = args
+      logger.debug "initialize with args: #{args.inspect}"
+    end
+
+    # Parse generic action options for all decendant actions
+    #
+    # @return [OptionParser] for use by decendant actions
+    def parse_options(parser_configuration = {})
+      raise_on_invalid_option = parser_configuration.has_key?(:raise_on_invalid_option) ? parser_configuration[:raise_on_invalid_option] : true
+      parse_base_options = parser_configuration.has_key?(:parse_base_options) ? parser_configuration[:parse_base_options] : true
+      logger.debug "base_action parsing args: #{args.inspect}, raise_on_invalid_option: #{raise_on_invalid_option}, parse_base_options: #{parse_base_options}"
+
+      @option_parser ||= OptionParser.new
+
+      option_parser.banner = help + "\n\nOptions:"
+
+      if parse_base_options
+        option_parser.on("--template [NAME]", "Use a template to render output. (default=default.slim)") do |t|
+          options[:template] = t.nil? ? "default.slim" : t
+          @template = options[:template]
+        end
+
+        option_parser.on("--output FILENAME", "Render output directly to a file") do |f|
+          options[:output] = f
+          @output = options[:output]
+        end
+
+        option_parser.on("--force", "Overwrite file output without prompting") do |f|
+          options[:force] = f
+        end
+
+        option_parser.on("-r", "--repos a1,a2,a3", "--asset a1,a2,a3", "--filter a1,a2,a3", Array, "List of regex asset name filters") do |list|
+          options[:filter] = list
+        end
+
+        # NOTE: OptionParser will add short options, there is no way to stop '-m' from being the same as '--match'
+        option_parser.on("--match [MODE]", "Asset filter match mode.  MODE=ALL (default), FIRST, EXACT, or ONE (fails if more than 1 match)") do |m|
+          options[:match] = m || "ALL"
+          options[:match].upcase!
+          unless ["ALL", "FIRST", "EXACT", "ONE"].include?(options[:match])
+            puts "invalid match mode option: #{options[:match]}"
+            exit 1
+          end
+        end
+      end
+
+      # allow decendants to add options
+      yield option_parser if block_given?
+
+      # reprocess args for known options, see binary wrapper for first pass
+      # (first pass doesn't know about action specific options), find all
+      # action options that may come after the action/subcommand (options
+      # before subcommand have already been processed) and its args
+      logger.debug "(BaseAction) args before reprocessing: #{args.inspect}"
+      begin
+        option_parser.order!(args)
+      rescue OptionParser::InvalidOption => e
+        if raise_on_invalid_option
+          puts "option error: #{e}"
+          puts option_parser
+          exit 1
+        else
+          # parse and consume until we hit an unknown option (not arg), put it back so it
+          # can be shifted into the new array
+          e.recover(args)
+        end
+      end
+      logger.debug "(BaseAction) args before unknown collection: #{args.inspect}"
+
+      unknown_args = []
+      while unknown_arg = args.shift
+        logger.debug "(BaseAction) unknown_arg: #{unknown_arg.inspect}"
+        unknown_args << unknown_arg
+        begin
+          # consume options and stop at an arg
+          option_parser.order!(args)
+        rescue OptionParser::InvalidOption => e
+          if raise_on_invalid_option
+            puts "option error: #{e}"
+            puts option_parser
+            exit 1
+          else
+            # parse and consume until we hit an unknown option (not arg), put it back so it
+            # can be shifted into the new array
+            e.recover(args)
+          end
+        end
+      end
+      logger.debug "(BaseAction) args after unknown collection: #{args.inspect}"
+
+      @args = unknown_args.dup
+      logger.debug "(BaseAction) args after reprocessing: #{args.inspect}"
+
+      option_parser
+    end
+
+    def execute
+      before_execute
+      parse_options
+      @exit_code = process
+      after_execute
+      @exit_code
+    end
+
+    # handle "assets to items" transformations, if any, and write to output
+    def process
+      write_to_output(render)
+    end
+
+    # TODO: add exception handler and pass return values
+    def write_to_output(content)
+      if output
+        logger.debug "write_to_output called with output : #{output}"
+        if overwrite_output?
+          logger.debug "writing output to : #{output}"
+          File.open(output, 'wb') {|f| f.write(content) }
+        else
+          logger.info "existing file not overwritten.  To overwrite automatically, use the '--force' option."
+        end
+      else
+        logger.debug "base_action writing to STDOUT"
+        print content
+      end
+      return 0
+    end
+
+    # TODO: create items/app_item class with at least the 'name' accessor
+    #
+    # assets: raw configuration handling system for items
+    def assets
+      return @assets if @assets
+      @assets = AssetManager.new.assets(asset_options)
+    end
+
+    # Used by asset factory to create assets.  Override in app_action.rb or a
+    # descendant to set the class to be instantiated by by the AssetManager.
+    #
+    # @return [Symbol] asset type
+    def asset_type
+      :app_asset
+    end
+
+    # asset options separated from assets to make it easier to override assets
+    def asset_options
+      # include all base action options
+      result = options.dup
+
+      # anything left on the command line should be filters as all options have
+      # been consumed, for pass through options, filters must be ignored by overwritting them
+      filters = args.dup
+      filters += result[:filter] if result[:filter]
+      result = result.merge(:filter => filters) unless filters.empty?
+
+      # asset type to create
+      type = result[:type] || asset_type
+      result = result.merge(:type => type)
+
+      # optional key: :assets_folder, absolute path or relative to config file if :base_folder is specified
+      result = result.merge(:assets_folder => configuration[:folders][:assets]) if configuration[:folders]
+
+      # optional key: :base_folder is the folder that contains the main config file
+      result = result.merge(:base_folder => File.dirname(configuration[:configuration_filename])) if configuration[:configuration_filename]
+
+      result
+    end
+
+    # items to be rendered, defaults to assets, override to suit
+    #
+    # @return [Array] of items to be rendered
+    def items
+      assets
+    end
+
+    # Render items result to a string
+    #
+    # @return [String] suitable for displaying on STDOUT or writing to a file
+    def render(view_options=configuration)
+      logger.debug "base_action rendering"
+      result = ""
+      if template
+        logger.debug "base_action rendering with template : #{template}"
+        view = AppView.new(items, view_options)
+        view.template = template
+        result = view.render
+      else
+        items.each_with_index do |item, index|
+          result += "\n" unless index == 0
+          result += item.name.green + ":\n"
+          if item.respond_to?(:attributes)
+            attributes = item.attributes.dup
+            result += attributes.recursively_stringify_keys!.to_conf.gsub(/\s+$/, '') # strip trailing whitespace from YAML
+            result += "\n"
+          end
+        end
+      end
+      result
+    end
+
+    # Convert method comments block to help text
+    #
+    # @return [String] suitable for displaying on STDOUT
+    def help(help_options={})
+      comment_starting_with = help_options[:comment_starting_with] || ""
+      located_in_file = help_options[:located_in_file] || __FILE__
+      text = File.read(located_in_file)
+
+      result = text.match(/(^\s*#\s*#{comment_starting_with}.*)^\s*class .* AppAction/m)
+      result = $1
+      result = result.gsub(/ @example/, '')
+      result = result.gsub(/ @return \[Number\]/, ' Exit code:')
+      result = result.gsub(/ @return .*/, '')
+      result = result.gsub(/ @see .*$/, '')
+
+      # strip the leading whitespace, the '#' and space
+      result = result.gsub(/^\s*# ?/, '')
+
+      # strip surrounding whitespace
+      result.strip
+    end
+
+    # @return [Boolean] true if output doesn't exist or it is OK to overwrite
+    def overwrite_output?
+      return true unless File.exists?(output)
+
+      if options[:force]
+        logger.debug "overwriting output with --force option"
+        return true
+      end
+
+      unless STDOUT.isatty
+        logger.debug "TTY not detected, skipping overwrite prompt"
+        return false
+      end
+
+      result = false
+      print "File '#{output}' exists. Would you like overwrite? [y/n]: "
+      case gets.strip
+        when 'Y', 'y', 'yes'
+          logger.debug "user answered yes to overwrite prompt"
+          result = true
+        else
+          logger.debug "user answered no to overwrite prompt"
+      end
+
+      result
+    end
+
+    # callbacks
+    def before_execute
+      logger.debug "callback: before_execute"
+    end
+
+    def after_execute
+      logger.debug "callback: after_execute"
+    end
+
+  end
+end