repo_manager 0.7.1

data/lib/repo_manager/git/status.rb

@@ -0,0 +1,196 @@
+module RepoManager
+
+  # Simplified version of ruby-git's class that uses Git's 'status --porcelain' command
+  #
+  # The --porcelain switch is useful since it handles ignored files and ignores
+  # non-commitable changes.  Speed is not a big concern.  There is only one
+  # call needed to the Git binary. No plumbing commands are used.
+  class Status
+    include Enumerable
+
+    # repo status unchanged/clean
+    CLEAN = 0
+
+    # bitfields for status
+    NOPATH = 1
+    INVALID = 2
+    CHANGED = 4
+    ADDED =  8
+    DELETED =  16
+    UNTRACKED =  32
+    UNMERGED = 64
+
+    attr_reader :files
+
+    def initialize(scm)
+      @files = {}
+      @scm = scm
+      construct_status
+    end
+
+    # @return [Numeric] 0 if CLEAN or bitfield with status: CHANGED | UNTRACKED | ADDED | DELETED | UNMERGED
+    def bitfield
+      # M ? A D U
+      (changed? ? CHANGED : 0) |
+      (untracked? ? UNTRACKED : 0) |
+      (added? ? ADDED : 0) |
+      (deleted? ? DELETED : 0) |
+      (unmerged? ? UNMERGED : 0)
+    end
+
+    def changed
+      @files.select { |k, f| f.type == 'M' }
+    end
+
+    def added
+      @files.select { |k, f| f.type == 'A' }
+    end
+
+    def deleted
+      @files.select { |k, f| f.type == 'D' }
+    end
+
+    def untracked
+      @files.select { |k, f| f.type == '?' }
+    end
+
+    def unmerged
+      @files.select { |k, f| f.type == 'U' }
+    end
+
+    # @return [Boolean] false unless a file has been modified/changed
+    def changed?
+      !changed.empty?
+    end
+
+    # @return [Boolean] false unless a file has been added
+    def added?
+      !added.empty?
+    end
+
+    # @return [Boolean] false unless a file has been deleted
+    def deleted?
+      !deleted.empty?
+    end
+
+    # @return [Boolean] false unless there is a new/untracked file
+    def untracked?
+      !untracked.empty?
+    end
+
+    # @return [Boolean] false unless there is an unmerged file
+    def unmerged?
+      !unmerged.empty?
+    end
+
+    def [](file)
+      @files[file]
+    end
+
+    def each
+      @files.each do |k, file|
+        yield file
+      end
+    end
+
+    class StatusFile
+      attr_accessor :path, :type
+
+      def initialize(hash)
+        @path = hash[:path]
+        @type = hash[:type]
+      end
+    end
+
+    private
+
+      def construct_status
+        # XY filename
+        # Y = working tree
+        #
+        # From git 1.7+ documentation
+        #
+        #   X          Y     Meaning
+        #   -------------------------------------------------
+        #             [MD]   not updated
+        #   M        [ MD]   updated in index
+        #   A        [ MD]   added to index
+        #   D        [ MD]   deleted from index
+        #   R        [ MD]   renamed in index
+        #   C        [ MD]   copied in index
+        #   [MARC]           index and work tree matches
+        #   [ MARC]     M    work tree changed since index
+        #   [ MARC]     D    deleted in work tree
+        #   -------------------------------------------------
+        #   D           D    unmerged, both deleted
+        #   A           U    unmerged, added by us
+        #   U           D    unmerged, deleted by them
+        #   U           A    unmerged, added by them
+        #   D           U    unmerged, deleted by us
+        #   A           A    unmerged, both added
+        #   U           U    unmerged, both modified
+        #   -------------------------------------------------
+        #   ?           ?    untracked
+        #   -------------------------------------------------
+        #
+        #
+        # simplify porcelain output:
+        #
+        #   combine X and Y and boil down status returns to just five types,
+        #   M ? A D U
+        #
+        # example output:
+        #
+        #  output = [" M .gitignore", "R  testing s.txt", "test space.txt", "?? new_file1.txt"]
+        #
+        # show working folder status with just five status condtions
+        #
+        #   exact matches for untracked and unmerged
+        #
+        #     '??' => 'untracked' [untracked.blue]
+        #     'DD', 'AU', 'UD', 'UA', 'DU', 'AA', 'UU' => 'unmerged' [unmerged.red.bold]
+        #
+        #   added with working folder clear
+        #
+        #     /R./ => 'renamed' [added.green], special handling required
+        #     /A /, /M /, /D /, /R /, /C / => 'added' [added.green]
+        #
+        #   everything else can be described by working folder status character
+        #
+        #     /.D/ => 'deleted', [deleted.yellow]
+        #     /.M/ => 'modified', [changed.red]
+
+        output = @scm.lib.native('status', ['--porcelain', '-z']).split("\000")
+        while line = output.shift
+          next unless line && line.length > 3
+          file_hash = nil
+          # first two chars, XY format
+          st = line[0..1]
+          # skip the space
+          filename = line[3..-1]
+
+          # renamed/copied files 'to -> from', 'from' will be on the next line,
+          # shift it off as we don't track this
+          output.shift if st.match(/[R|C]/)
+
+          case st
+            when '??'
+              file_hash = {:type => '?', :path => filename}
+            when 'DD', 'AU', 'UD', 'UA', 'DU', 'AA', 'UU'
+              file_hash = {:type => 'U', :path => filename}
+            when 'A ', 'M ', 'D ', 'R ', 'C '
+              file_hash = {:type => 'A', :path => filename}
+            when /.D/
+              file_hash = {:type => 'D', :path => filename}
+            when /.M/
+              file_hash = {:type => 'M', :path => filename}
+            else
+              raise "fatal error: unknown git status condition: '#{st}'"
+          end
+
+          @files[filename] = StatusFile.new(file_hash) if (file_hash && filename)
+        end
+      end
+
+  end
+end

data/lib/repo_manager/logger.rb

@@ -0,0 +1,39 @@
+require 'logging'
+include Logging.globally
+
+module RepoManager
+  module Logger
+
+    class Manager
+
+      def initialize(config_filename=nil, yaml_key=nil, configuration={})
+
+        options = configuration[:options] || {}
+
+        if config_filename && yaml_key && configuration.has_key?(yaml_key)
+          Logging::Config::YamlConfigurator.load(config_filename, yaml_key.to_s)
+        else
+          # setup a default root level STDOUT logger
+          format = {:pattern => '%-5l %c: %m\n'}
+          format = format.merge(:color_scheme => 'default') if options[:color]
+          Logging.appenders.stdout('stdout', :layout => Logging.layouts.pattern(format), :level => :info)
+          Logging.logger.root.add_appenders('stdout')
+        end
+
+        # if verbose, all defined loggers are set to debug level
+        if options[:verbose]
+          Logging.appenders.each do |appender|
+            appender.level = :debug
+          end
+        end
+
+        # debug
+        #Logging.show_configuration
+        #logger.error "error"
+        #logger.warn "warn"
+        #logger.info "info"
+      end
+    end
+
+  end
+end

data/lib/repo_manager/settings.rb

@@ -0,0 +1,98 @@
+require 'yaml'
+require 'erb'
+require 'fileutils'
+require 'repo_manager/extensions/hash'
+
+module RepoManager
+
+  # Access setting via symbolized keys or using accessor methods
+  #
+  # @example
+  #
+  #   settings = Settings.new(FileUtils.pwd, {:config => 'some/file.yml'})
+  #
+  #       verbose = settings.to_hash[:options] ? settings.to_hash[:options][:verbose] : false
+  #
+  #    equivalent to:
+  #
+  #       verbose = settings.options ? settings.options.verbose : false
+  #
+  # @return [Hash], for pure hash use 'to_hash' instead
+  class Settings < Hash
+    include RepoManager::Extensions::MethodReader
+    include RepoManager::Extensions::MethodWriter
+
+    def initialize(working_dir=nil, options={})
+      @working_dir = working_dir || FileUtils.pwd
+      @configuration = configure(options)
+
+      # call super without args
+      super *[]
+
+      self.merge!(@configuration)
+    end
+
+  private
+
+    # read options from YAML config
+    def configure(options)
+
+      # config file default options
+      configuration = {
+                        :options => {
+                          :verbose => false,
+                          :color => 'AUTO',
+                          :short => false,
+                          :unmodified => 'HIDE',
+                          :match => 'ALL',
+                          :list => 'ALL'
+                        },
+                        :commands => [
+                          'diff',
+                          'grep',
+                          'log',
+                          'ls-files',
+                          'show',
+                          'status'
+                        ]
+                      }
+
+      # set default config if not given on command line
+      config = options[:config]
+      if config.nil?
+        config = [
+                   File.join(@working_dir, "repo.conf"),
+                   File.join(@working_dir, ".repo.conf"),
+                   File.join(@working_dir, "repo_manager", "repo.conf"),
+                   File.join(@working_dir, ".repo_manager", "repo.conf"),
+                   File.join(@working_dir, "config", "repo.conf"),
+                   File.expand_path(File.join("~", ".repo.conf")),
+                   File.expand_path(File.join("~", "repo.conf")),
+                   File.expand_path(File.join("~", "repo_manager", "repo.conf")),
+                   File.expand_path(File.join("~", ".repo_manager", "repo.conf"))
+                 ].detect { |filename| File.exists?(filename) }
+      end
+
+      if config && File.exists?(config)
+        # load options from the config file, overwriting hard-coded defaults
+        logger.debug "reading configuration file: #{config}"
+        config_contents = YAML.load(ERB.new(File.open(config, "rb").read).result)
+        configuration.merge!(config_contents.symbolize_keys!) if config_contents && config_contents.is_a?(Hash)
+      else
+        # user specified a config file?, no error if user did not specify config file
+        raise "config file not found" if options[:config]
+      end
+
+      # store the original full config filename for later use
+      configuration[:configuration_filename] = config
+
+      configuration.recursively_symbolize_keys!
+
+      # the command line options override options read from the config file
+      configuration[:options].merge!(options)
+      configuration
+    end
+
+  end
+
+end

data/lib/repo_manager/tasks.rb

@@ -0,0 +1,3 @@
+require 'repo_manager/tasks/task_manager'
+
+RepoManager::TaskManager.new.load_tasks

data/lib/repo_manager/tasks/add/asset.rb

@@ -0,0 +1,213 @@
+require 'repo_manager'
+require 'repo_manager/tasks/task_manager'
+require 'repo_manager/actions/action_helper'
+require 'pathname'
+
+module RepoManager
+
+  module GenerateHelper
+
+    def asset_name_to_config_file(name=nil)
+      raise ArgumentError, "missing name" unless name
+      raise "unable to find configuration key ':folders'" unless configuration[:folders]
+      raise "unable to find configuration key ':folders => :assets'" unless configuration[:folders][:assets]
+
+      folder = configuration.folders[:assets]
+      unless folder
+        say "unable to find folder conf key ':folders => :assets', please set key"
+        exit 1
+      end
+
+      unless Pathname.new(folder).absolute?
+        base_folder = File.dirname(configuration[:configuration_filename])
+      end
+
+      file = File.join(base_folder, folder, name, "asset.conf")
+    end
+
+  end
+
+  module AddHelper
+
+    def process_discovered_assets(discovered_assets=[])
+
+      say_status "configuring",  "setting discovered asset attributes"
+      discovered_assets.each do |discovered_asset|
+        folder = File.dirname(asset_name_to_config_file(discovered_asset.name))
+        discovered_asset.configuration.folder = folder
+      end
+
+      if options[:refresh]
+        if existing_assets.any? && discovered_assets.any?
+          say_status "merging",  "merging existing asset attributes"
+          discovered_assets.each do |discovered_asset|
+            existing_asset = existing_assets.detect do |existing_asset|
+              existing_asset.name == discovered_asset.name
+            end
+            discovered_asset.attributes.merge!(existing_asset.attributes) if existing_asset
+          end
+        end
+      else
+        say_status "comparing",  "looking at existing asset names"
+        discovered_assets.delete_if do |asset|
+          result = false
+          if File.exists?(asset.configuration.folder)
+            logger.debug "#{asset.name} asset name already exists, skipping"
+            result = true
+          end
+          result
+        end
+
+        say_status "comparing",  "looking at existing asset paths"
+        discovered_assets.delete_if do |asset|
+          result = false
+          existing_asset = existing_assets.detect do |existing_asset|
+            existing_asset.path && asset.path && (File.expand_path(existing_asset.path) == File.expand_path(asset.path))
+          end
+          if (existing_asset)
+            logger.debug "#{asset.name} path matches existing asset #{existing_asset.name}, skipping"
+            result = true
+          end
+          result
+        end
+      end
+
+      unless discovered_assets.any?
+        say "no assets found for updating"
+        exit 0
+      end
+
+      # list the new assets found
+      say "Discovered assets"
+      discovered_assets.each do |asset|
+        say_status :found, "%-40s path => '%s'" % [asset.name, relative_path(asset.path)] , :green
+      end
+
+      # prompt the user
+      say
+      unless options[:force]
+        exit 0 unless (ask("Found #{discovered_assets.size} asset(s), write the configuration file(s) (y/n)?") == 'y')
+      end
+
+      # write the assets
+      say
+      discovered_assets.each do |asset|
+
+        say_status :creating, "repo_manager configuration file for #{asset.name}", :green
+        logger.debug "writing asset #{asset.name} to #{asset.configuration.folder}"
+        asset.attributes.merge!(:parent => "../global/default")
+        save_writable_attributes(asset, asset.attributes)
+
+      end
+
+    end
+
+  end
+
+  class Add < Thor
+    namespace :add
+    include Thor::Actions
+    include RepoManager::ThorHelper
+    include RepoManager::GenerateHelper
+    include RepoManager::AddHelper
+    include ::RepoManager::ActionHelper
+
+    # adds :quiet, :skip, :pretent, :force
+    add_runtime_options!
+
+    method_option :filter, :type => :array, :aliases => "-f", :desc => "List of regex folder name filters"
+    method_option :refresh, :type => :boolean, :aliases => "-r", :desc => "Refresh existing blank attributes"
+
+    desc "assets FOLDER", "generate multiple config files by searching a folder, one level deep, for git repositories"
+    def assets(folder)
+      say_status "collecting",  "collecting top level folder names"
+      discovered_assets = []
+      filters = options[:filter] || ['.*']
+      # Thor does not allow comma separated array options, fix that here
+      filters = filters.first.to_s.split(',') if filters.length == 1
+      Dir.glob( File.join(folder, '*/')  ).each do |repo_folder|
+        logger.debug "filters: #{filters.inspect}"
+        next unless filters.find {|filter| repo_folder.match(/#{filter}/)}
+        next unless File.exists?(File.join(repo_folder, '.git/'))
+
+        # check existing assets for path match, if found, use existing name instead of the generated name
+        existing = existing_assets.detect do |existing_asset|
+          existing_asset.path && repo_folder && (File.expand_path(existing_asset.path) == File.expand_path(repo_folder))
+        end
+
+        if (existing)
+          name = existing.name
+        else
+          name = File.basename(repo_folder)
+        end
+
+        asset = ::RepoManager::RepoAsset.new(name)
+        asset.path = File.expand_path(repo_folder)
+
+        discovered_assets << asset
+      end
+
+      process_discovered_assets(discovered_assets)
+    end
+
+    method_option :name, :type => :string, :aliases => "-n", :desc => "given the asset a specific name"
+
+    desc "asset FOLDER", "generate a single repo asset file given a working folder"
+    def asset(folder)
+      discovered_assets = []
+      unless File.exists?(File.join(folder, '.git/'))
+        say_status :error, "unable to find '.git' folder in working folder '#{folder}'", :red
+        exit 1
+      end
+
+      # check existing assets for path match, if found, use existing name instead of the generated name
+      existing = existing_assets.detect do |existing_asset|
+        existing_asset.path && folder && (File.expand_path(existing_asset.path) == File.expand_path(folder))
+      end
+
+      if (existing)
+        name = existing.name
+        if options[:name]
+          say_status :error, "asset already exists under a different name '#{name}'", :red
+          exit 1
+        end
+      else
+        name = options[:name]
+        name ||= File.basename(folder)
+      end
+
+      asset = ::RepoManager::RepoAsset.new(name)
+      asset.path = File.expand_path(folder)
+
+      discovered_assets << asset
+      process_discovered_assets(discovered_assets)
+    end
+
+    private
+
+    # where to start looking, required by the template method
+    def self.source_root
+      File.dirname(__FILE__)
+    end
+
+    # write only the attributes that we have set
+    def save_writable_attributes(asset, attributes)
+      valid_keys = [:parent, :path]
+      accessable_attributes = {}
+      attributes.each do |key, value|
+         accessable_attributes[key] = value.dup if valid_keys.include?(key)
+      end
+      asset.configuration.save(accessable_attributes)
+    end
+
+    def existing_assets
+      return @existing_assets if @existing_assets
+      asset_options = {}
+      asset_options.merge!(:assets_folder => configuration[:folders][:assets]) if configuration[:folders]
+      asset_options.merge!(:base_folder => File.dirname(configuration[:configuration_filename])) if configuration[:configuration_filename]
+
+      @existing_assets = ::RepoManager::AssetManager.new.assets(asset_options)
+    end
+
+  end
+end