minglr 1.3.11

data/lib/minglr/action.rb

@@ -0,0 +1,85 @@
+module Minglr
+  
+  class Action
+  
+    def self.execute(action, options = [], flag_options = {}, config = {})
+      if action.to_s == options[0]
+        options.shift
+      else
+        options.shift
+        options.shift
+      end
+      begin
+        Commands.send(action, options, flag_options, config)
+      rescue ActiveResource::ResourceNotFound => error
+        puts error.message + " for URL '#{Resources::Base.site}' ..."
+      end
+    end
+  
+    def self.valid_actions
+      Commands.methods(false)
+    end
+  
+    def self.valid_action?(action)
+      valid_actions.include? action
+    end
+  
+    class Commands
+    
+      def self.attach(options, flag_options, config)
+        raise "Missing card number!" if options.empty?
+        
+        card_number = options.first
+        file_name = flag_options[:file_attachment]
+        Resources::Attachment.attach(card_number, file_name, config[:username], config[:password])
+      end
+
+      def self.card(options, flag_options, config)
+        raise "Missing card number!" if options.empty?
+        
+        card_number = options.first
+        Resources::Card.print_card(card_number, config[:status_property])
+      end
+  
+      def self.cards(options, flag_options, config)
+        Resources::Card.print_all(options, config[:status_property])
+      end
+  
+      def self.create(options, flag_options, config)
+        Resources::Card.create(flag_options, config[:status_property])
+      end
+  
+      def self.fetch(options, flag_options, config)
+        raise "Missing card number!" if options.empty?
+        
+        card_number = options.first
+        Resources::Attachment.fetch(card_number, config[:username], config[:password])
+      end
+  
+      def self.move(options, flag_options, config)
+        raise "Missing card number!" if options.empty?
+        
+        card_number = options.first
+        Resources::Card.move(card_number, flag_options, config)
+      end
+  
+      def self.projects(options, flag_options, config)
+        Resources::Project.print_all(options, config[:status_property])
+      end
+  
+      def self.update(options, flag_options, config)
+        raise "Missing card number!" if options.empty?
+        
+        card_number = options.first
+        Resources::Card.update(card_number, flag_options)
+      end
+  
+      def self.users(options, flag_options, config)
+        Resources::User.print_all(options)
+      end
+    
+    end
+    
+  end
+  
+end

data/lib/minglr/config_parser.rb

@@ -0,0 +1,51 @@
+module Minglr
+  
+  class ConfigParser
+    
+    CONFIG_FILE = ".minglrconfig"
+    attr_reader :config
+  
+    def self.parse
+      config_files = [File.join(ENV["HOME"], CONFIG_FILE), File.join(ENV["PWD"], CONFIG_FILE)]
+      config_files.uniq!
+      config_files.each do |config_file_name|
+        if File.exist?(config_file_name)
+          return self.new(File.read(config_file_name)).config
+        end
+      end
+      puts "Unable to find #{CONFIG_FILE} in #{config_files.join(", ")}"
+      class_eval("send :exit, 1") # Why is it so hard to mock or stub exit?
+    end
+  
+    def initialize(config_contents)
+      @config = {}
+      @current_section = nil
+      config_contents.each_line do |line|
+        line = line.strip!
+        case line
+        when "", /^#.*$/
+          next
+        when /\[(.*)\]/
+          define_section($1.to_s)
+        else
+          define_var(line)
+        end
+      end
+      @config
+    end
+  
+    def define_section(section_name)
+      @config[section_name.to_sym] = {} unless @config.has_key?(section_name.to_sym)
+      @current_section = section_name.to_sym
+    end
+  
+    def define_var(line)
+      key, value = line.split("=")
+      key.strip!
+      value.strip!
+      @config[@current_section][key.to_sym] = value
+    end
+  
+  end
+
+end

data/lib/minglr/extensions/array.rb

@@ -0,0 +1,23 @@
+module Minglr
+  
+  module Extensions
+    
+    module Array
+      
+      def filter(attributes, words)
+        collection = self
+        words.each do |word|
+          collection = self.select do |element|
+            output = ""
+            attributes.each { |attribute| output << element.send(attribute).to_s + " " }
+            output =~ /#{word}/i
+          end
+        end
+        collection
+      end
+    
+    end
+  
+  end
+  
+end

data/lib/minglr/mtx/input_cache.rb

@@ -0,0 +1,24 @@
+module MTX
+  class InputCache
+    class << self
+      def put(key, content)
+        File.open(file_pathname(key), File::CREAT | File::WRONLY | File::TRUNC) { |file| file.write content }
+      end
+    
+      def get(key)
+        if content = File.read(file_pathname(key))
+          return nil if content.blank?
+          content
+        end
+      rescue
+        nil
+      end
+    
+      protected
+    
+      def file_pathname(key)
+        File.join(Dir::tmpdir, "#{key.to_s.gsub(/[^\w]/, '')}.entry")
+      end
+    end
+  end
+end

data/lib/minglr/mtx/options_parser.rb

@@ -0,0 +1,58 @@
+module MTX
+  
+  class OptionsParser
+    
+    def self.parse(args, *required_by_command)
+      uri_options = {}
+      command_options = {}
+
+      parser = OptionParser.new do |opts|
+        opts.banner = "Usage: mtx [options]"
+        opts.on("--transition TRANSITION", "Transition name.") do |transition|
+          command_options[:transition] = transition
+        end
+
+        opts.on("--card CARD", "Card number.") do |card|
+          command_options[:card] = card
+        end
+
+        opts.on("--properties ARGS", Array, "User-entered properties and values for the transition in array format. Must be an even number of comma-delimited values, like \"A,B,'C with spaces','D with spaces'\".") do |args|
+          command_options[:properties] = args.in_groups_of(2).map { |key, value| {'name' => key, 'value' => value} }
+        end
+      
+        opts.on("--comment COMMENT", "Transition comment. This may be required depending on your transition settings.") do |comment|
+          command_options[:comment] = comment
+        end
+
+        opts.on("--username USERNAME", "Mingle username.") do |username|
+          uri_options[:username] = username
+        end
+
+        opts.on("--password PASSWORD", "Mingle password.") do |password|
+          uri_options[:password] = password
+        end
+
+        opts.on("--host_port HOST_PORT", "Host and port.") do |host_and_port|
+          uri_options[:host_and_port] = host_and_port
+        end
+
+        opts.on("--project PROJECT", "Project name.") do |project|
+          uri_options[:project] = project
+        end
+      end
+    
+      parser.parse! args
+
+      ([:project, :host_and_port] | required_by_command).each do |arg|
+        unless command_options[arg] || uri_options[arg]
+          # TODO: let commands handle their own errors
+          $stderr.puts "Missing command-line argument --#{arg.to_s}, use --help for command-line options."
+          exit 1
+        end
+      end
+
+      [uri_options, command_options]
+    end
+  end
+  
+end

data/lib/minglr/options_parser.rb

@@ -0,0 +1,82 @@
+require "yaml"
+
+module Minglr
+  class OptionsParser
+    def self.parse(args, *required_by_command)
+      project_options = []
+    
+      if Resources::Base.site
+        begin
+          project_options = Resources::PropertyDefinition.project_options
+        rescue ActiveResource::UnauthorizedAccess => exception
+          puts "Connection #{exception.message} to #{Resources::Base.site.to_s}"
+          puts "Did you set 'basic_authentication_enabled: true' in your auth_config.yml file?"
+          exit 1 unless MINGLR_ENV == "test"
+        end
+      end
+      
+      command_options = {}
+      
+      parser = OptionParser.new do |opts|
+        opts.banner = "Usage: minglr [action] [options]"
+        opts.separator ""
+        opts.separator "Valid Commands Are: #{Minglr::Action.valid_actions.join(", ")}"
+      
+        opts.on("-n NAME", String, "Short name of card") do |card_name|
+          command_options[:name] = card_name.strip
+        end
+      
+        opts.on("-d DESCRIPTION", String, "Description of card") do |card_description|
+          command_options[:description] = card_description.strip
+        end
+      
+        opts.on("-t TYPE", String, "Type of card") do |card_type|
+          command_options[:card_type_name] = card_type.strip
+        end
+      
+        opts.on("-c COMMENT", String, "Comment") do |comment|
+          command_options[:comment] = comment.strip
+        end
+      
+        opts.on("-f FILE", String, "File to attach") do |file|
+          command_options[:file_attachment] = file.strip
+        end
+      
+        unless project_options.empty?
+          opts.separator ""
+          opts.separator "Project Specific Options"
+        
+          project_options.each do |option_pair|
+            option_switch = option_pair[1].downcase.gsub(/\s|_/, "-").gsub(/--|---/, '-').gsub(/--/, '-')
+            opts.on("--#{option_switch}", String, "Set the #{option_pair[1]} for a card") do |option|
+              command_options[option_pair[0]] = option
+            end
+          end
+        
+          opts.separator ""
+        end
+    
+        opts.on_tail("-h", "--help", "Show this help message.") do |help|
+          puts opts
+          exit 0 unless MINGLR_ENV == "test"
+        end
+      
+        opts.on_tail("--version", "Show version") do
+          version = YAML.load(File.read(File.join(File.dirname(__FILE__), "..", "..", "VERSION.yml")))
+          puts "#{version[:major]}.#{version[:minor]}.#{version[:patch]}"
+          exit 0 unless MINGLR_ENV == "test"
+        end
+      
+        if args.empty?
+          puts opts
+          exit 0 unless MINGLR_ENV == "test"
+        end
+      end
+
+      parser.parse! args
+      command_options
+    end
+    
+  end
+
+end

data/lib/minglr/resources/attachment.rb

@@ -0,0 +1,51 @@
+require 'httpclient'
+
+module Resources
+  
+  class Attachment < Base
+  
+    def self.configure
+      self.prefix += "cards/:card_number/"
+    end
+    
+    def self.curl(command)
+      `#{command}`
+    end
+    
+    def self.fetch(card_number, username, password)
+      if card_to_update = Card.find(card_number)
+        attachments = find(:all, :params => { :card_number => card_number })
+        attachments.each do |attachment|
+          url = self.site + attachment.url
+          url.userinfo = nil, nil
+          puts "Downloading #{url.to_s}:"
+          command = "curl --insecure --progress-bar --output #{attachment.file_name} --user #{username}:#{password} #{url}"
+          curl(command)
+        end
+      end
+    end
+    
+    def self.attach(card_number, file_name, username, password)
+      if card_to_update = Card.find(card_number)
+        url = (site.to_s.gsub(/#{site.path}$/, '')) + collection_path(:card_number => card_number)
+        if File.exist?(file_name)
+          File.open(file_name) do |file|
+            body = { 'file' => file, "filename" => file_name }
+            client = HTTPClient.new
+            client.set_auth(nil, username, password)
+            response = client.post(url, body)
+            if response.status_code == 201
+              puts "File '#{file_name}' attached to card #{card_number}"
+            else
+              puts "Error attaching file '#{file_name}' to card #{card_number} (Got back HTTP code #{response.status_code})"
+            end
+          end
+        else
+          warn "Unable to open file '#{file_name}'"
+        end
+      end
+    end
+  
+  end
+  
+end

data/lib/minglr/resources/base.rb

@@ -0,0 +1,42 @@
+require "uri"
+
+module Resources
+  
+  class Base < ActiveResource::Base
+    
+    def self.configure(uri_options)
+      uri = URI.parse(uri_options[:url])
+      uri.user = uri_options[:username]
+      uri.password = uri_options[:password]
+      self.site = uri
+    end
+
+    def self.print_collection(collection, attributes, align = :left)
+      output = []
+      longest_attributes = Array.new(attributes.length, 0)
+      alignment = (align == :left ? :ljust : :rjust)
+      collection.each do |element|
+        entry = []
+        attributes.each_with_index do |attribute, index|
+          attribute_value = element.send(attribute).to_s
+          longest_attributes[index] = attribute_value.length if attribute_value.length > longest_attributes[index]
+          entry << attribute_value
+        end
+        output << entry
+      end
+      output.each do |entry|
+        row = []
+        entry.each_with_index do |part, index|
+          row << [part.send(alignment, longest_attributes[index])]
+        end
+        puts row.join(" - ")
+      end
+    end
+    
+    def self.warn(message)
+      puts "Warning: #{message}"
+    end
+  
+  end
+  
+end

data/lib/minglr/resources/card.rb

@@ -0,0 +1,117 @@
+module Resources
+  
+  class Card < Base
+    
+    def self.create(options = {}, status_property = nil)
+      options.merge!({status_property.to_sym => "New"}) if status_property
+      card = self.new(options)
+      if card.save
+        card.reload
+        puts "Card ##{card.number} created"
+      else
+        warn "Unable to create card"
+      end
+    end
+    
+    def self.move(card_number, options = {}, config = {})
+      if card_to_move = find(card_number)
+        transition_options = { :card => card_number }
+        transition_options.merge!({ :comment => options[:comment]}) if options[:comment]
+        if config[:status_property]
+          current_status = card_to_move.send(config[:status_property])
+        else
+          warn "No known status of card ##{card_number}, cannot move!"
+          return
+        end
+        next_transition = nil
+        
+        card_type = card_to_move.card_type_name.downcase
+        case card_type
+        when /defect/
+          status_states = config.select do |key, value|
+            key.to_s =~ /^defect/
+          end
+        when /task/
+          status_states = config.select do |key, value|
+            key.to_s =~ /^task_state_/
+          end
+        when /story/
+          status_states = config.select do |key, value|
+            key.to_s =~ /^story_state/
+          end
+        else
+          warn "No transitions defined for card of type #{card_to_move.card_type_name}"
+          return
+        end
+        status_states = status_states.collect {|state| state.last }.collect {|state| state.split(">").collect { |value| value.strip } }
+        next_transition = status_states.select {|state| state.first.downcase == current_status.downcase }.first.last
+        transition_options.merge!({ :transition => next_transition })
+
+        if response = TransitionExecution.create(transition_options)
+          if response.attributes["status"] == "completed"
+            puts "Moved card from #{current_status} to #{next_transition}"
+          end
+        end
+      else
+        warn "No card ##{card_number} found to move"
+      end
+    end
+    
+    def self.print_all(options = [], status_property = nil)
+      attributes = [:number, :card_type_name, status_property, :name].compact
+      cards = find(:all)
+      cards.send(:extend, Minglr::Extensions::Array)
+      cards = cards.filter(attributes, options)
+      if cards.any?
+        print_collection(cards, attributes)
+      else
+        warn "No cards found"
+      end
+    end
+    
+    def self.print_card(card_number, status_property = nil)
+      if card = find(card_number.to_i)
+        puts card.to_s(status_property)
+      else
+        warn "No card ##{card_number} found"
+      end
+    end
+    
+    def self.update(card_number, options = {})
+      if card_to_update = find(card_number)
+        options.each do |attribute, value|
+          card_to_update.send("#{attribute.to_s}=".to_sym, value)
+        end
+        card_to_update.save
+        puts "Card ##{card_to_update.number} updated\n\n"
+        puts card_to_update.to_s
+      else
+        warn "Unable to update card ##{card_number}"
+      end
+    end
+    
+    def to_s(status_property = nil)
+      attachments = []
+      begin
+        attachments = Attachment.find(:all, :params => { :card_number => number })
+        attachments = attachments.collect do |attachment|
+          "* #{attachment.file_name}: #{Resources::Base.site + attachment.url}"
+        end
+      rescue ActiveResource::ResourceNotFound => error
+        attachments = ["N/A"]
+      end
+      output = <<-EOS
+     Number: #{number}
+       Name: #{name}
+       Type: #{card_type_name.nil? ? "N/A" : card_type_name}
+     Status: #{send(status_property) if status_property && self.respond_to?(status_property)}
+Description: #{description.nil? ? "N/A" : description}
+
+Attachments:
+  #{attachments.join("\n")}
+    EOS
+      output
+    end
+    
+  end
+end