repo_manager 0.7.1

data/lib/repo_manager/actions/task_action.rb

@@ -0,0 +1,71 @@
+module RepoManager
+
+  # @group CLI actions
+  #
+  # Invoke external tasks, normally Thor tasks
+  #
+  # @example Usage: repo task TASK [args]
+  #
+  #      repo task repo_manager:sweep:screenshots /to/some/folder
+  #      repo repo_manager:sweep:screenshots /to/some/folder
+  #
+  # @example General task help:
+  #
+  #      repo help task
+  #
+  # @example Help for specific task
+  #
+  #      repo task help repo_manager:sweep:screenshots
+  #      repo help repo_manager:sweep:screenshots
+  #
+  # @example Display a list of tasks
+  #
+  #      repo task -T
+  #      repo  -T
+  #
+  #      repo task --tasks
+  #      repo --tasks
+  #
+  # @return [Number] exit code from task
+  class TaskAction < AppAction
+
+    # Add action specific options
+    def parse_options
+      super(:raise_on_invalid_option => false, :parse_base_options => false) do |opts|
+
+      opts.on("-T", "--tasks", "List tasks") do |t|
+        options[:tasks] = t
+      end
+
+      end
+    end
+
+    def process
+      # Thor actions can include toxic side effects,
+      # keep the namespace clean until needed
+      require 'repo_manager/tasks/task_manager'
+      task_manager = RepoManager::TaskManager.new(configuration)
+
+      if options[:tasks]
+        task_manager.list_tasks
+        return 0
+      end
+
+      raise "task name required" if args.empty?
+
+      target = args.shift
+
+      if target == "help"
+        target = args.shift
+        task_manager.task_help(target)
+      else
+        task_manager.invoke(target, args)
+      end
+    end
+
+    def help
+      super(:comment_starting_with => "Invoke", :located_in_file => __FILE__)
+    end
+
+  end
+end

data/lib/repo_manager/app.rb

@@ -0,0 +1,116 @@
+require 'term/ansicolor'
+
+class String
+  include Term::ANSIColor
+end
+
+module RepoManager
+
+  AVAILABLE_ACTIONS = %w[help list task path status git]
+
+  # Commands that don't need to have the 'git' arg precede them.  These are not
+  # necessarily the same as the allowed 'commands' specified in the repo.conf
+  # file.
+  # NOTE: `git help --all` for a full list of git supported commands
+  GIT_NATIVE_SUPPORT = %w[add config commit diff fetch log pull push show ls-files grep]
+
+  class App
+
+    # bin wrapper option parser object
+    attr_accessor :option_parser
+
+    def initialize(argv=[], configuration={})
+      @configuration = configuration
+      @options = configuration[:options] || {}
+      @argv = argv
+      $stdout.sync = true
+
+      config_filename = configuration[:configuration_filename]
+      RepoManager::Logger::Manager.new(config_filename, :logging, configuration)
+
+      logger.debug "configuration: #{@configuration.inspect}"
+      logger.debug "argv: #{@argv.inspect}"
+      logger.debug "config file: #{configuration[:configuration_filename]}" if configuration[:configuration_filename]
+    end
+
+    def execute
+      begin
+
+        args = @argv
+        if action_argument_required?
+          action = @argv.shift
+
+          # push action back to args if this is a native pass-through command
+          if GIT_NATIVE_SUPPORT.include?(action)
+            args.unshift(action)
+            action = 'git'
+          end
+
+          # special case: actionless tasks
+          action = 'task' if action.nil? && @options.include?(:tasks)
+
+          # special case: `repo sweep:screenshots` is an acceptable task action
+          if action && action.match(/[a-zA-Z]+:+/)
+            args.unshift(action)
+            action = 'task'
+          end
+
+          # special case: `repo help sweep:screenshots` is an acceptable task help action
+          if action == 'help' && args.any?
+            target = args[0]
+            if target.match(/[a-zA-Z]+:+/)
+              args.unshift(action)
+              action = 'task'
+            end
+          end
+
+          unless AVAILABLE_ACTIONS.include?(action)
+            if action.nil?
+              puts "repo action required"
+            else
+              puts "repo invalid action: #{action}"
+            end
+            puts "repo --help for more information"
+            exit 1
+          end
+          logger.debug "execute action: #{action} #{args.join(' ')}"
+          klass = Object.const_get('RepoManager').const_get("#{action.capitalize}Action")
+          app_action = klass.new(args, @configuration)
+          app_action.option_parser = self.option_parser
+          result = app_action.execute
+        else
+          #
+          # default action if action_argument_required? is false
+          #
+          result = 0
+        end
+
+        if result.is_a?(Numeric)
+          exit(result)
+        else
+          # handle all other return types
+          exit(result ? 0 : 1)
+        end
+
+      rescue SystemExit => e
+        # This is the normal exit point
+        logger.debug "repo run system exit: #{e}, status code: #{e.status}"
+        exit(e.status)
+      rescue Exception => e
+        logger.fatal("repo fatal exception: #{e.message}")
+        STDERR.puts("repo failed: #{e.message}".red)
+        STDERR.puts("Command failed, use '--verbose' for backtrace.") unless @options[:verbose]
+        STDERR.puts(e.backtrace.join("\n")) if @options[:verbose]
+        exit(1)
+      end
+    end
+
+  private
+
+    # true if application requires an action to be specified on the command line
+    def action_argument_required?
+      !AVAILABLE_ACTIONS.empty?
+    end
+
+  end
+end

data/lib/repo_manager/assets.rb

@@ -0,0 +1,3 @@
+require 'repo_manager/assets/base_asset'
+require 'repo_manager/assets/app_asset'
+require 'repo_manager/assets/repo_asset'

data/lib/repo_manager/assets/app_asset.rb

@@ -0,0 +1,15 @@
+####################################################
+# 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 asset functionality specific to an
+  # application implementation.  Put application specific code here.
+  class AppAsset < BaseAsset
+  end
+
+end

data/lib/repo_manager/assets/asset_accessors.rb

@@ -0,0 +1,67 @@
+module RepoManager
+
+  module AssetAccessors
+
+    # Given an array, create accessors
+    # NOTE: This is similar to using method_missing with a whitelist
+    #
+    # @return [void]
+    def create_accessors(*attrs)
+      return unless attrs
+      raise ArgumentError, "Expected 'user_attributes' to be an array" unless attrs.is_a? Array
+
+      # Define each of the attributes
+      attrs.flatten.each do |attr|
+        create_accessor(attr)
+      end
+    end
+
+    def create_accessor(attr)
+      create_reader(attr)
+      create_writer(attr)
+    end
+
+    def create_reader(attr)
+      return unless attr
+
+      method = "#{attr}".to_sym
+
+      if self.kind_of? RepoManager::BaseAsset
+        return if self.respond_to? method
+
+        self.class.send(:define_method, method) do
+          render(attributes[method])
+        end
+      else
+        return if respond_to? method
+
+        define_method(method) do
+          render(attributes[method])
+        end
+      end
+    end
+
+    def create_writer(attr)
+      return unless attr
+
+      method = "#{attr}=".to_sym
+
+      if self.kind_of? RepoManager::BaseAsset
+        return if self.respond_to? method
+
+        self.class.send(:define_method, method) do |value|
+          attributes[attr] = value
+        end
+      else
+        return if respond_to? method
+
+        define_method(method) do |value|
+          attributes[attr] = value
+        end
+      end
+
+    end
+
+  end
+
+end

data/lib/repo_manager/assets/asset_configuration.rb

@@ -0,0 +1,137 @@
+require 'yaml'
+require 'erb'
+require 'pathname'
+require 'fileutils'
+
+module RepoManager
+
+  # asset_configuration saves just the user data by subtracting out the
+  # global hash and writing just the result
+  #
+  # An asset requires a global template but doesn't require a user datafile.
+  #
+  # LOADING:
+  #
+  # Load up the master template YAML file first,  evaluate the ERB, save this
+  # hash for later use.
+  #
+  # Copy the results to the asset attributes and then load the user data.  The
+  # user data doesn't contain ERB.
+  #
+  # SAVING:
+  #
+  # Compare existing asset attributes to the saved and eval'd master hash and write
+  # just the change assets to the user file.
+  #
+  class AssetConfiguration
+
+    # user datastore folder, can override parent datastore
+    attr_accessor :folder
+
+    # parent datastore defaults folder, read asset from here first if exists
+    attr_accessor :parent
+
+    attr_reader :asset
+
+    def initialize(asset)
+      #logger.debug "initializing new AssetConfiguration with asset class: #{asset.class.to_s}"
+      @asset = asset
+    end
+
+    # Save specific attributes to an asset configuration file. Only the param
+    # 'attrs' and the current  contents of the config file are saved. Parent
+    # asset configurations are not saved.
+    #
+    def save(attrs=nil)
+      raise "a Hash of attributes to save must be specified" unless attrs && attrs.is_a?(Hash)
+      raise "folder must be set prior to saving attributes" unless folder
+
+      # merge attributes to asset that contains parent attributes
+      @asset.attributes.merge!(attrs)
+
+      # load contents of the user folder and merge in attributes passed to save
+      # so that we don't save parent attributes
+      contents = {}
+      if File.exists?(folder)
+        contents = load_contents(folder)
+        raise "expected contents to be a hash" unless contents.is_a?(Hash)
+      end
+
+      contents = contents.merge!(attrs)
+      write_contents(folder, contents)
+    end
+
+    # load an asset from a configuration folder
+    def load(ds=nil)
+      @folder ||= ds
+
+      contents = load_contents(folder)
+
+      # if a global parent folder is defined, load it first
+      parent = contents.delete(:parent) || parent
+      if parent
+        parent_folder = File.join(parent)
+        unless Pathname.new(parent_folder).absolute?
+          base_folder = File.dirname(folder)
+          parent_folder = File.join(base_folder, parent_folder)
+        end
+
+        logger.debug "AssetConfiguration loading parent: #{parent_folder}"
+        parent_configuration = RepoManager::AssetConfiguration.new(asset)
+
+        begin
+          parent_configuration.load(parent_folder)
+        rescue Exception => e
+          logger.warn "AssetConfiguration parent configuration load failed on: '#{parent_folder}' with: '#{e.message}'"
+        end
+      end
+
+      # Load all attributes as hash 'attributes' so that merging
+      # and adding new attributes doesn't require code changes. Note
+      # that the 'parent' setting is not merged to attributes
+      @asset.attributes.merge!(contents)
+      @asset.create_accessors(@asset.attributes[:user_attributes])
+      @asset
+    end
+
+    def to_hash
+      result = {}
+      result.merge!(:parent => parent.folder) if parent
+      result.merge!(:attributes => @asset.attributes)
+      result
+    end
+
+    private
+
+    # load the raw contents from an asset_folder, ignore parents
+    #
+    # @return [Hash] of the raw text contents
+    def load_contents(asset_folder)
+      file = File.join(asset_folder, 'asset.conf')
+      if File.exists?(file)
+        contents = YAML.load(ERB.new(File.open(file, "rb").read).result(@asset.get_binding))
+        if contents && contents.is_a?(Hash)
+          contents.recursively_symbolize_keys!
+        else
+          {}
+        end
+      else
+        {}
+      end
+    end
+
+    # write raw contents to an asset_folder
+    def write_contents(asset_folder, contents)
+      contents.recursively_stringify_keys!
+
+      FileUtils.mkdir(asset_folder) unless File.exists?(asset_folder)
+      filename = File.join(asset_folder, 'asset.conf')
+
+      #TODO, use "wb" and write CRLF on Windows
+      File.open(filename, "w") do |f|
+        f.write(contents.to_conf)
+      end
+    end
+
+  end
+end

data/lib/repo_manager/assets/asset_manager.rb

@@ -0,0 +1,72 @@
+####################################################
+# 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 'pathname'
+require 'fileutils'
+
+module RepoManager
+
+  class AssetManager
+
+    # @raise [Exception] unless asset_options contains base_folder or :assets if an absolute path
+    #
+    # @return [Array] of Asset
+    def assets(asset_options={})
+      logger.debug "asset_options: #{asset_options.inspect}"
+      # type of asset to create, used to guess the asset_folder name
+      type = asset_options[:type] || :app_asset
+
+      assets = []
+      filters = asset_options[:filter] || ['.*']
+      match_count = 0
+      logger.debug "generating assets array with filter array: #{filters.join(',')}"
+
+      assets_folder = asset_options[:assets_folder] || "assets"
+      pattern = File.join(assets_folder, '*/')
+      logger.debug "reading from asset type: '#{type}' from assets_folder:'#{assets_folder}' "
+
+      # asset folder can be relative to main config file
+      unless Pathname.new(pattern).absolute?
+        # base_folder is determined from the configuration file
+        # location, if it is not set, then the configuration file wasn't not found
+        raise "configuration file not found" unless asset_options[:base_folder]
+        base_folder = asset_options[:base_folder]
+        pattern = File.expand_path(File.join(base_folder, pattern))
+      end
+      logger.debug "asset glob pattern: #{pattern}"
+      folders = Dir.glob(pattern)
+      logger.debug "user assets folder is empty: #{pattern}" if folders.empty?
+
+      folders.sort.each do |folder|
+        folder_basename = Pathname.new(folder).basename.to_s
+        #logger.debug "matching folder: #{folder} using basename: #{folder_basename}"
+        if filters.find {|filter| matches?(folder_basename, filter, asset_options)}
+          logger.debug "match found for: #{folder_basename}"
+          match_count += 1
+          asset = RepoManager::AppAsset.create(type, folder, {})
+          assets << asset
+          break if ((asset_options[:match] == 'FIRST') || (asset_options[:match] == 'EXACT'))
+          raise "match mode = ONE, multiple matching assets found filter" if (asset_options[:match] == 'ONE' && match_count > 1)
+        end
+      end
+
+      assets
+    end
+
+  private
+
+    def matches?(str, filter, match_options={})
+      if (match_options[:match] == 'EXACT')
+        str == filter
+      else
+        str.match(/#{filter}/)
+      end
+    end
+  end
+
+end