repo_manager 0.7.1

data/lib/repo_manager/assets/base_asset.rb

@@ -0,0 +1,199 @@
+####################################################
+# 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 'mustache'
+require 'pathname'
+
+require 'repo_manager/assets/asset_configuration'
+require 'repo_manager/assets/asset_accessors'
+
+module RepoManager
+
+  class BaseAsset
+    include RepoManager::AssetAccessors
+    extend RepoManager::AssetAccessors
+
+    #
+    # --- Asset attributes START here ---
+    #
+
+    # Asset defined path
+    #
+    # Defaults to asset name when the path attribute is blank
+    #
+    # NOTE: This is not the path to the asset configuration file. If not an
+    # absolute path, then it is relative to the current working directory
+    #
+    # @example Full paths
+    #
+    #     path: /home/robert/photos/photo1.jpg
+    #
+    #     path: /home/robert/app/appfolder
+    #
+    # @example Home folder '~' paths are expanded automatically
+    #
+    #     path: ~/photos/photo1.jpg  -> /home/robert/photos/photo1.jpg
+    #
+    # @example Relative paths are expanded automatically relative to the CWD
+    #
+    #     path: photos/photo1.jpg  -> /home/robert/photos/photo1.jpg
+    #
+    # @example Mustache templates are supported
+    #
+    #     path: /home/robert/{{name}}/appfolder -> /home/robert/app1/appfolder
+    #
+    # @example Mustache braces that come at the start must be quoted
+    #
+    #     path: "{{name}}/appfolder" -> /home/robert/app1/appfolder
+    #
+    # @return [String] an absolute path
+    def path
+      return @path if @path
+
+      path = attributes[:path] || name
+      path = render(path)
+      if (path && !Pathname.new(path).absolute?)
+        # expand path if starts with '~'
+        path = File.expand_path(path) if path.match(/^~/)
+        # paths can be relative to cwd
+        path = File.join(File.expand_path(FileUtils.pwd), path) if (!Pathname.new(path).absolute?)
+      end
+      @path = path
+    end
+    def path=(value)
+      @path = nil
+      attributes[:path] = value
+    end
+
+    # Description (short)
+    #
+    # @return [String]
+    create_accessors :description
+
+    # Notes (user)
+    #
+    # @return [String]
+    create_accessors :notes
+
+    # Classification tags, an array of strings
+    #
+    # @return [Array] of tag strings
+    def tags
+      attributes[:tags] || []
+    end
+    def tags=(value)
+      attributes[:tags] = value
+    end
+
+    #
+    # --- Asset attributes END here ---
+    #
+
+    # The asset name is loosely tied to the name of the configuration folder (datastore).
+    # The name may also be a hash key from a YAML config file.
+    #
+    # The name should be a valid ruby variable name, in turn, a valid folder name, but this
+    # is not enforced.
+    #
+    # @see self.path_to_name
+    attr_accessor :name
+
+    # subclass factory to create Assets
+    #
+    # Call with classname to create.  Pass in optional configuration folder
+    # name and/or a hash of attributes
+    #
+    # @param [String] asset_type (AppAsset) classname to initialize
+    # @param [String] asset_name (nil) asset name or folder name, if folder, will load YAML config
+    # @param [Hash] attributes ({}) initial attributes
+    #
+    # @return [BaseAsset] the created BaseAsset or decendent asset
+    def self.create(asset_type=:app_asset, asset_name=nil, attributes={})
+      classified_name = asset_type.to_s.split('_').collect!{ |w| w.capitalize }.join
+      Object.const_get('RepoManager').const_get(classified_name).new(asset_name, attributes)
+    end
+
+    # takes any path and returns a string suitable for asset name (Ruby identifier)
+    #
+    # @return [String] valid asset name
+    def self.path_to_name(path)
+      basename = File.basename(path)
+      basename = basename.gsub(/\&/,' and ')
+      basename = basename.downcase.strip.gsub(/ /,'_')
+      basename = basename.gsub(/[^a-zA-Z_0-9]/,'')
+      basename = basename.downcase.strip.gsub(/ /,'_')
+      basename.gsub(/[_]+/,'_')
+    end
+
+    # @param [String/Symbol] asset_name_or_folder (nil) if folder exists, will load YAML config
+    # @param [Hash] attributes ({}) initial attributes
+    def initialize(asset_name_or_folder=nil, attributes={})
+      # allow for lazy loading (TODO), don't assign empty attributes
+      @attributes = attributes.dup unless attributes.empty?
+
+      # create user_attribute methods
+      create_accessors(@attributes[:user_attributes]) if @attributes && @attributes[:user_attributes]
+
+      return unless asset_name_or_folder
+
+      folder = asset_name_or_folder.to_s
+      @name = File.basename(folder)
+
+      logger.debug "Asset name: #{name}"
+      logger.debug "Asset configuration folder: #{folder}"
+
+      if File.exists?(folder)
+        logger.debug "initializing new asset with folder: #{folder}"
+        configuration.load(folder)
+      end
+    end
+
+    def configuration
+      @configuration ||= RepoManager::AssetConfiguration.new(self)
+    end
+
+    # attributes is the hash loaded from the asset config file
+    def attributes
+      @attributes ||= {}
+    end
+
+    def to_hash
+      result = {}
+      result.merge!(:name => name) if name
+      result.merge!(:attributes => attributes)
+      result
+    end
+
+    # ERB binding
+    def get_binding
+      binding
+    end
+
+    # render a string with mustache tags replaced in the context of this class
+    #
+    # @return [String/nil] with mustache tags replaced or nil if template is nil
+    def render(template)
+      return nil unless template
+
+      Mustache.render(template, self)
+    end
+
+    # support for Mustache rendering of ad hoc user defined variables
+    # if the key exists in the hash, use if for a lookup
+    def method_missing(name, *args, &block)
+      return attributes[name.to_sym] if attributes.include?(name.to_sym)
+      return super
+    end
+
+    # method_missing support
+    def respond_to?(name)
+      return true if attributes.include?(name.to_sym)
+      super
+    end
+
+  end
+end

data/lib/repo_manager/assets/repo_asset.rb

@@ -0,0 +1,30 @@
+module RepoManager
+
+  # wrapper class for a source code repository configuration
+  class RepoAsset < AppAsset
+
+    # The asset_key, if defined, will be used as key to asset attributes when
+    # loading from YAML, if not defined, the entire YAML file will load.
+    #
+    # Override in decendants.
+    #
+    # @ return [Symbol] or nil
+    def asset_key
+      :repo
+    end
+
+    def status
+      @status ||= RepoManager::Status.new(scm)
+    end
+
+    # version control system wrapper
+    def scm
+      return @scm if @scm
+      raise NoSuchPathError unless File.exists?(path)
+      raise InvalidRepositoryError unless File.exists?(File.join(path, '.git'))
+      @scm = Git.open(path)
+    end
+
+  end
+
+end

data/lib/repo_manager/core.rb

@@ -0,0 +1,2 @@
+require 'repo_manager/core/hash'
+require 'repo_manager/core/array'

data/lib/repo_manager/core/array.rb

@@ -0,0 +1,21 @@
+class Array
+  def recursively_symbolize_keys!
+    self.each do |item|
+      if item.is_a? Hash
+        item.recursively_symbolize_keys!
+      elsif item.is_a? Array
+        item.recursively_symbolize_keys!
+      end
+    end
+  end
+
+  def recursively_stringify_keys!
+    self.each do |item|
+      if item.is_a? Hash
+        item.recursively_stringify_keys!
+      elsif item.is_a? Array
+        item.recursively_stringify_keys!
+      end
+    end
+  end
+end

data/lib/repo_manager/core/hash.rb

@@ -0,0 +1,83 @@
+# encoding: UTF-8
+
+class Hash
+
+  # YAML suitable for configuration files
+  #
+  # returns sorted YAML if Ruby 1.8
+  # returns insertion ordered YAML on Ruby 1.9+
+  def to_conf
+    unless RUBY_VERSION =~ /^1.8/
+      # fix issue with strings that can end up in non UTF-8 encodings, like
+      # ASCII-8BIT, force encoding so that they are not written to YAML as binary
+      self.each_pair { |k,v| self[k] = ((v.is_a? String) ? v.force_encoding("UTF-8") : v)}
+
+      # allow 1.9+ to_yaml to do insertion ordered conf files
+      return to_yaml
+    end
+
+    opts = {}
+    YAML::quick_emit( object_id, opts ) do |out|
+      out.map( taguri, to_yaml_style ) do |map|
+        sorted_keys = keys
+        sorted_keys = begin
+          sorted_keys.sort
+        rescue
+          sorted_keys.sort_by {|k| k.to_s} rescue sorted_keys
+        end
+
+        sorted_keys.each do |k|
+          map.add( k, fetch(k) )
+        end
+      end
+    end
+  end
+
+  # active_support hash key functions
+  def symbolize_keys!
+    self.replace(self.symbolize_keys)
+  end
+
+  def symbolize_keys
+    inject({}) do |options, (key, value)|
+      options[(key.to_sym rescue key) || key] = value
+      options
+    end
+  end
+
+  def recursively_symbolize_keys!
+    self.symbolize_keys!
+    self.values.each do |v|
+      if v.is_a? Hash
+        v.recursively_symbolize_keys!
+      elsif v.is_a? Array
+        v.recursively_symbolize_keys!
+      end
+    end
+    self
+  end
+
+  def stringify_keys!
+    self.replace(self.stringify_keys)
+  end
+
+  def stringify_keys
+    inject({}) do |options, (key, value)|
+      options[(key.to_s rescue key) || key] = value
+      options
+    end
+  end
+
+  def recursively_stringify_keys!
+    self.stringify_keys!
+    self.values.each do |v|
+      if v.is_a? Hash
+        v.recursively_stringify_keys!
+      elsif v.is_a? Array
+        v.recursively_stringify_keys!
+      end
+    end
+    self
+  end
+
+end

data/lib/repo_manager/errors.rb

@@ -0,0 +1,10 @@
+module RepoManager
+
+  class InvalidRepositoryError < StandardError
+  end
+
+  class NoSuchPathError < StandardError
+  end
+
+
+end

data/lib/repo_manager/extensions/hash.rb

@@ -0,0 +1,86 @@
+# This is a modified version of the unreleased (as of 3/9/2012) Hashie Version 2
+#
+# It is modified to always convert new attributes to symbols and
+# return nil if missing attribute so it works more like OpenStruct but
+# still retains Hash as super
+module RepoManager
+  module Extensions
+
+    # MethodReader allows you to access keys of the hash
+    # via method calls. This gives you an OStruct like way
+    # to access your hash's keys. It will recognize keys
+    # either as strings or symbols.
+    #
+    # @example Extending the Hash class
+    #
+    #     class User < Hash
+    #       include RepoManager::Extensions::MethodReader
+    #     end
+    #
+    #     user = User.new
+    #     user['first_name'] = 'Michael'
+    #     user.first_name # => 'Michael'
+    #
+    #     user[:last_name] = 'Bleigh'
+    #     user.last_name # => 'Bleigh'
+    #
+    #     user[:birthday] = nil
+    #     user.birthday # => nil
+    #
+    #     user.not_declared # => nil
+    #
+    module MethodReader
+      def respond_to?(name)
+        return true if key?(name.to_s) || key?(name.to_sym)
+        super
+      end
+
+      def method_missing(name, *args)
+        return self[name.to_s] if key?(name.to_s)
+        return self[name.to_sym] if key?(name.to_sym)
+
+        # mod to return nil instead of 'undefined method'
+        return nil if args.length == 0
+
+        super
+      end
+    end
+
+    # MethodWriter gives you #key_name= shortcuts for
+    # writing to your hash. Keys are written as symbols
+    #
+    # Note that MethodWriter also overrides #respond_to such
+    # that any #method_name= will respond appropriately as true.
+    #
+    # @example
+    #
+    #     class MyHash < Hash
+    #       include RepoManager::Extensions::MethodWriter
+    #     end
+    #
+    #     h = MyHash.new
+    #     h.awesome = 'sauce'
+    #     h['awesome'] # => 'sauce'
+    #
+    module MethodWriter
+      def respond_to?(name)
+        return true if name.to_s =~ /=$/
+        super
+      end
+
+      def method_missing(name, *args)
+        if args.size == 1 && name.to_s =~ /(.*)=$/
+          return self[convert_key($1)] = args.first
+        end
+
+        super
+      end
+
+      def convert_key(key)
+        # mod to return symbol keys instead of string keys
+        key.to_sym
+      end
+    end
+
+  end
+end

data/lib/repo_manager/git.rb

@@ -0,0 +1,2 @@
+require 'repo_manager/git/lib'
+require 'repo_manager/git/status'

data/lib/repo_manager/git/lib.rb

@@ -0,0 +1,69 @@
+require 'git'
+
+module Git
+
+  class CommandFailed < StandardError
+    attr_reader :command
+    attr_reader :exitstatus
+    attr_reader :error
+
+    def initialize(command, exitstatus, error='')
+      @command = command
+      @exitstatus = exitstatus
+      @error = error
+      super "Command exited with #{exitstatus}: #{command}"
+    end
+  end
+
+  class Lib
+
+    # need 'git status --porcelain'
+    def required_command_version
+      [1, 7, 0, 0]
+    end
+
+    # validatation once and only once with warning to STDERR
+    def validate
+      return if defined? @@validated
+      unless meets_required_version?
+        $stderr.puts "[WARNING] The repo_manager gem requires git #{required_command_version.join('.')} or later for the status command functionality, but only found #{current_command_version.join('.')}. You should probably upgrade."
+      end
+      @@validated = true
+    end
+
+    # liberate the ruby-git's private command method with a few tweaks
+    def native(cmd, opts = [], chdir = true, redirect = '', &block)
+      validate
+
+      ENV['GIT_DIR'] = @git_dir
+      ENV['GIT_INDEX_FILE'] = @git_index_file
+      ENV['GIT_WORK_TREE'] = @git_work_dir
+      path = @git_work_dir || @git_dir || @path
+
+      opts = [opts].flatten.map {|s| escape(s) }.join(' ')
+      git_cmd = "git #{cmd} #{opts} #{redirect} 2>&1"
+
+      out = nil
+      if chdir && (Dir.getwd != path)
+        Dir.chdir(path) { out = run_command(git_cmd, &block) }
+      else
+        out = run_command(git_cmd, &block)
+      end
+
+      if @logger
+        @logger.info(git_cmd)
+        @logger.debug(out)
+      end
+
+      if $?.exitstatus > 0
+        if $?.exitstatus == 1 && out == ''
+          return ''
+        end
+        raise Git::CommandFailed.new(git_cmd, $?.exitstatus, out.to_s)
+      end
+      out
+    end
+
+  end
+
+end