rtrac 1.0.1

data/History.txt

@@ -0,0 +1,5 @@
+== 1.0.0 / 2007-11-25
+
+* 1 major enhancement
+  * Birthday!
+

data/Manifest.txt

@@ -0,0 +1,14 @@
+History.txt
+Manifest.txt
+README.txt
+Rakefile
+bin/rtrac
+lib/rtrac.rb
+lib/rtrac/util.rb
+lib/rtrac/base.rb
+lib/rtrac/ticket.rb
+test/test_helper.rb
+test/test_rtrac.rb
+test/test_base.rb
+test/test_ticket.rb
+test/test_rtrac.rb

data/README.txt

@@ -0,0 +1,54 @@
+rtrac
+    by Josh Stephenson
+    http://rtrac.rubyforge.org
+
+== DESCRIPTION:
+  
+Trac API wrappers
+
+== FEATURES/PROBLEMS:
+  
+Ticket access for Trac
+
+== SYNOPSIS:
+  
+Rtrac::Base.get_by_milestone(milestone).each do |id|
+	# grab the ticket's data
+	tick = Rtrac::Ticket.new(id)
+	iteration_hash[:total] += tick.severity.to_i
+	iteration_hash[:tickets] << {:id => id, :points => tick.severity.to_i, :status => tick.status, :updated_at =>Time.parse(tick.updated_at.to_s)}
+end
+
+== REQUIREMENTS:
+
+active_support
+hoe
+
+== INSTALL:
+
+sudo gem install rtrac
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2007 Josh Stephenson
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,15 @@
+require 'rubygems'
+require 'hoe'
+require './lib/rtrac.rb'
+
+Hoe.new('rtrac', Rtrac::Config.version) do |p|
+  p.rubyforge_name = 'rtrac'
+  p.author = 'Josh Stephenson'
+  p.email = 'josh@elctech.com'
+  p.summary = 'Trac wrapper with command line tool'
+  p.description = p.paragraphs_of('README.txt', 2..5).join("\n\n")
+  p.url = p.paragraphs_of('README.txt', 0).first.split(/\n/)[1..-1]
+  p.changes = p.paragraphs_of('History.txt', 0..1).join("\n\n")
+end
+
+# vim: syntax=Ruby

data/bin/rtrac

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'rtrac'
+require 'rtrac/util'
+
+Rtrac::Util.run!

data/lib/rtrac.rb

@@ -0,0 +1,15 @@
+$:.unshift File.dirname(__FILE__)
+module Rtrac
+  class Config
+    def self.version
+      '1.0.1'
+    end
+  end
+end
+require 'rubygems'
+require 'yaml'
+require 'active_support'
+require 'xmlrpc/client'
+require 'rtrac/base'
+require 'rtrac/ticket'
+require 'rtrac/util'

data/lib/rtrac/base.rb

@@ -0,0 +1,190 @@
+module Rtrac
+  class Base
+
+    cattr_accessor :connection, :config
+
+    class << self
+      # handles the sending of queries to Trac with exception handling
+      def send_query(*args)
+        begin
+          connection.call(*args)
+        rescue
+          # print a standard error
+          logger.error "Error connecting to Trac API"
+          if logger.level > Logger::INFO
+            logger.error $@
+          end
+          exit
+        end
+      end
+
+      def connection
+        @connection ||= self.open_connection
+      end
+
+      # list all methods supported by the trac api
+      def list_methods
+        send_query('system.listMethods')
+      end
+
+      def custom(*args)
+        send_query(*args)
+      end
+
+      def get_by_milestone(milestone)
+        send_query('ticket.query', "milestone=#{milestone.strip}")
+      end
+
+      # returns method help
+      def method_help(method)
+        send_query('system.methodHelp', method)
+      end
+
+      # Returns an array of ticket ids
+      # Valid order types include:
+      def get_tickets(count, order = :priority)
+        extract_account_info
+        order = :priority unless columns.include?(order)
+        send_query('ticket.query', "order=#{order.to_s}")[0,count].collect{ |id| id }
+      end
+
+      #:stopdoc:
+      def open_connection
+        if (options = extract_account_info)
+          @username, @password, @url = options
+          uri = URI.parse @url
+          #puts "Connecting to \"#{@url}\" using username \"#{@username}\" and password \"#{@password}\""
+          @connection = XMLRPC::Client.new3(:host => uri.host, :path => "#{uri.path}/login/xmlrpc", :user => @username, :password => @password, :use_ssl => true)
+        end
+      end
+
+      def extract_account_info
+        username = password = url = columns = nil
+        configuration_options.each do |key, value|
+          if key.to_sym == :username
+            username = value.to_s
+          elsif key.to_sym == :password
+            password = value.to_s
+          elsif key.to_sym == :url
+            url = value.to_s
+          elsif key.to_sym == :columns
+            @columns = value.to_a
+          end
+        end
+        if invalid_config?(username, password, url, @columns)
+          logger.error "Invalid configuration options.  Please edit your #{config_path} file accordingly." 
+          return false 
+        end
+        [username, password, url, @columns]
+      end
+
+      def configuration_options
+        return @configuration_options unless @configuration_options.nil?
+        if self.config.nil?
+          @configuration_options = find_or_create_config
+        else
+          if File.exist?(config)
+            @configuration_options = YAML::load(open(config))
+          end
+        end
+        @configuration_options  
+      end
+
+      def invalid_config?(username, password, url, columns)
+        username.empty? || password.empty? || columns.empty? || ![url =~ /^http(s|):\/\/.+/i].any?
+      end
+
+      def columns
+        extract_account_info
+        @columns ||= required_columns + optional_columns
+      end
+
+      def required_columns
+        extract_account_info
+        @configuration_options["columns"]["required"]
+      end
+
+      def optional_columns
+        extract_account_info
+        @configuration_options["columns"]["optional"]
+      end
+
+      def find_or_create_config
+        begin
+          config = YAML::load(open(config_path))
+        rescue
+          create_new_config
+        end
+        config
+      end
+
+      def home_dir
+        ENV['HOME'] || ENV['USERPROFILE'] || ENV['HOMEPATH']
+      end
+
+      def config_path
+        if RAILS_ROOT
+          File.join(RAILS_ROOT, 'config', Rtrac::Configuration.options[:config_filename])
+        else
+          File.join(home_dir, ".#{Rtrac::Configuration.options[:config_filename]}") # hide it if it goes in home
+        end
+      end
+
+      def create_new_config
+        file = File.open(config_path, "w+")
+        file.write(Rtrac::Configuration.options[:default_config_file])
+        file.flush
+        file.close
+        logger.info "No config file found in #{home_dir}
+A new one has been created.  Please edit it before continuing
+#{config_path}
+"
+        exit
+      end
+      
+      def logger
+        if @logger.nil?
+          @logger = Logger.new(STDERR)
+          @logger.level = Logger::INFO
+        end
+        @logger
+      end
+      #:start_doc:
+    end
+  end
+  class Configuration
+    class << self
+      def options
+        {:default_config_file => default_config_file, :config_filename => 'rtrac.yml'}
+      end
+
+      def default_config_file
+        default_config_file=<<CONFIG
+  username: 
+  password: 
+  url: 
+  columns:
+    required:
+      - :summary
+      - :description
+    optional:
+      - :type 
+      - :time
+      - :changetime
+      - :component
+      - :severity
+      - :priority
+      - :owner
+      - :reporter
+      - :cc
+      - :version
+      - :milestone
+      - :status
+      - :resolution
+      - :keywords
+CONFIG
+        default_config_file
+      end
+    end
+  end
+end

data/lib/rtrac/ticket.rb

@@ -0,0 +1,96 @@
+module Rtrac
+  class TicketError < StandardError; end
+  class Ticket < Rtrac::Base
+
+    attr_accessor :trac_id
+
+    def initialize(trac_id, logger = nil)
+      @logger = logger
+      @trac_id = trac_id
+    end
+
+    def created_at
+      Time.at(ticket_attributes[1].to_i)
+    end
+
+    def updated_at
+      Time.at(+ticket_attributes[2].to_i)
+    end
+
+    def attributes
+      extended_attributes = ticket_attributes[3].symbolize_keys!
+      {:id => ticket_attributes[0], :created_at => ticket_attributes[1], :updated_at => ticket_attributes[2]}.merge(extended_attributes)
+    end
+
+    def attributes=(attributes)
+      @ticket_attributes = attributes
+    end
+
+    # ticket description
+    def description
+      method_missing(:description)
+    end
+    alias_method :body, :description
+
+    # ticket summary
+    def summary
+      method_missing(:summary)
+    end
+    alias_method :title, :summary
+
+    # update a ticket with a comment and attributes
+    def update(comment, attributes = {})
+      sendable_attributes = attributes
+      sendable_attributes.delete(:created_at) && sendable_attributes.delete(:updated_at)
+      self.class.send_query('ticket.update', @trac_id, comment, sendable_attributes)
+    end
+
+    # create a new ticket
+    def self.create(title, description, attributes = {})
+      send_query('ticket.create', title, description, attributes)
+    end
+
+    # delete a ticket forever
+    def self.destroy(trac_id)
+      send_query('ticket.delete', trac_id)
+    end
+
+    def to_s
+      "#{summary}"
+    end
+
+    protected
+
+    def method_missing(method)
+      if attributes.has_key?(method)
+        attributes[method]
+      else
+        logger.debug "No attribute found for #{method}"
+      end
+    end
+
+    # returns a hash of ticket attributes
+    def get
+      self.class.send_query('ticket.get', @trac_id)
+    end
+
+    def ticket_attributes
+      @ticket_attributes ||= get
+    end
+
+    def logger
+      @logger ||= Logger.new(STDERR)
+    end
+  end
+end
+class Hash
+  def symbolize_keys!
+    keys.each do |key| 
+      unless key.is_a?(Symbol) || (new_key = key.to_sym).nil? 
+        self[new_key] = self[key] 
+        delete(key) 
+      end
+    end
+    self
+  end
+end

data/lib/rtrac/util.rb

@@ -0,0 +1,165 @@
+module Rtrac
+  class Util < Rtrac::Base
+    VALID_COMMANDS = [:list, :show, :update, :delete, :create]
+
+    class << self
+      def run!
+        if ARGV.include?('--debug')
+          @logger = Logger.new(STDERR)
+          @logger.level = Logger::DEBUG
+          ARGV.delete('--debug')
+        end
+        command = ARGV.shift
+        if command.nil?
+          usage
+        else
+          case command.to_sym
+          when :list
+            list(ARGV.shift, ARGV.shift)
+          when :show
+            show(ARGV.shift)
+          when :update
+            update(ARGV.shift)
+          when :delete
+            delete(ARGV.shift)
+          when :close
+            close(ARGV.shift)
+          when :create
+            create
+          else
+            usage
+          end
+        end
+      end
+
+      def list(count, order = 'priority')
+        Rtrac::Base.get_tickets(count.to_i, order).each do |id|
+          tick = Rtrac::Ticket.new(id)
+          keys = tick.attributes.keys.reject{|k| k == :id || k == :type }
+           
+          keys.each do |key|
+            puts "#{key.to_s[0,16].rjust(16, ' ')}:  #{tick.send(key).to_s[0,60].rjust(60, ' ')}"
+          end
+          puts ""
+        end
+      end
+
+      def show(id)
+        usage if id.nil?
+        tick = get_ticket(id)
+        display(tick)
+      end
+
+      def delete(id)
+        if(Rtrac::Ticket.destroy(id)).to_i.zero?
+          puts 'Deleted'
+        else
+          puts 'Error deleting ticket.'
+        end
+      end
+
+      def create
+        required_attributes = {}
+        optional_attributes = {}
+        read_required_attributes(required_attributes)
+        read_optional_attributes(optional_attributes)
+        required_attributes = required_attributes.values
+        puts Rtrac::Ticket.create(required_attributes.shift, required_attributes.shift, optional_attributes)
+      end
+
+      def update(id)
+        tick = get_ticket(id)
+        all_attributes = tick.attributes
+        read_optional_attributes(all_attributes, true)
+        comment = read_value(:comment)
+        resp = tick.update(comment, all_attributes)
+#        tick.attributes = all_attributes
+#        display(tick)
+      end
+
+      def read_required_attributes(attribute_hash)
+        self.required_columns.each do |attr|
+          while attribute_hash[attr].nil?
+            puts "#{attr.to_s.capitalize}: "
+            value = STDIN.readline
+            attribute_hash[attr] = value
+          end 
+        end
+      end
+
+      def read_optional_attributes(attribute_hash, conflate = false)
+        cols = conflate ? self.required_columns + self.optional_columns : self.optional_columns
+        display_menu(attribute_hash, cols)
+        until (num = STDIN.readline.strip).empty?
+          num = num.to_i
+          attribute = cols[num-1]
+          attribute_hash[cols[num-1]] = read_value(attribute)
+          display_menu(attribute_hash, cols)
+        end
+      end
+
+      def read_value(attribute)
+        puts "#{attribute.to_s.capitalize}: "
+        STDIN.readline.strip
+      end
+
+      def display_menu(attribute_hash, cols)
+        puts "Enter the number of an attribute to fill in or <Enter> to submit"
+        cols.each_with_index do |attr, idx|
+          puts "#{idx+1}. #{attr.to_s.capitalize} => #{attribute_hash[attr]}"
+        end
+        puts ""
+      end
+
+      def close(id, comment = nil)
+        raise NotImplementedError
+      end
+
+      def get_ticket(id)
+        @tick ||= Rtrac::Ticket.new(id, @logger)
+      end
+
+      def display(tick)
+        if tick.is_a?(Rtrac::Ticket)
+          display_ticket(tick)
+        else
+          display_ticket_from_hash(tick)
+        end
+      end
+
+      def display_ticket(tick)
+        # reject #id and #type or ruby will choke!
+        keys = tick.attributes.keys.reject{|k| k == :id || k == :type }
+
+        keys.each do |key|
+          # we'll send the method to the ticket so dates are parsed
+          puts "#{key.to_s[0,16].rjust(16, ' ')}:  #{tick.send(key).to_s[0,60].rjust(60, ' ')}"
+        end
+      end
+
+      def display_ticket_from_hash(attributes)
+        # reject #id and #type or ruby will choke!
+        keys = attributes.keys.reject{|k| k == :id || k == :type }
+
+        keys.each do |key|
+          # we'll send the method to the ticket so dates are parsed
+          puts "#{key.to_s[0,16].rjust(16, ' ')}:  #{tick.attributes[key].to_s[0,60].rjust(60, ' ')}"
+        end
+      end
+
+      def usage
+        usage=<<USAGE
+rtrac COMMAND [OPTIONS]
+COMMANDS:
+  list [COUNT] [PRIORITY]
+  show ID
+  create
+  update ID
+  delete ID
+USAGE
+        puts usage
+        exit
+      end
+    end
+  end
+end

data/test/test_base.rb

@@ -0,0 +1,49 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class RtracBaseTest < Test::Unit::TestCase
+#  def test_send_query_should_open_connection
+#    XMLRPC::Client.expects(:new3).returns(stub())
+#    Rtrac::Base.expects(:open_connection).returns(stub(:call => ''))
+#    Rtrac::Base.send_query('foo')
+#  end
+#
+#  def test_open_connection_should_hit_xmlrpc
+#    Rtrac::Base.send_query('foo')
+#  end
+
+  def test_connection
+    Rtrac::Base.expects(:open_connection)
+    Rtrac::Base.connection
+  end
+
+  def test_list_methods
+    Rtrac::Base.expects(:send_query)
+    Rtrac::Base.list_methods
+  end
+
+  def test_get_tickets
+    Rtrac::Base.expects(:send_query)
+    Rtrac::Base.list_methods
+  end
+
+  def test_open_connection
+    XMLRPC::Client.expects(:new3)
+    URI.expects(:parse).returns(stub(:host => 'foo.com', :path => 'foo'))
+    Rtrac::Base.send(:open_connection)
+  end
+
+  def test_extract_account_info
+    Rtrac::Base.expects(:configuration_options).returns({:username => 'foo', :password => '123', :url => 'http://wush.net/trac/foo'})
+    Rtrac::Base.expects(:invalid_config?).returns(false)
+    Rtrac::Base.send(:extract_account_info)
+  end
+
+  def test_valid_config
+    assert_equal false, Rtrac::Base.send(:invalid_config?, 'foo', 'bar', 'http://wush.net/trac/foo', ['foo'])
+  end
+
+  def test_invalid_config
+    assert Rtrac::Base.send(:invalid_config?, 'foo', 'bar', 'ttp://wush.net/trac/foo', ['foo'])
+  end
+
+end

data/test/test_helper.rb

@@ -0,0 +1,4 @@
+require 'test/unit'
+require 'rubygems'
+require 'mocha'
+require File.dirname(__FILE__) + '/../lib/rtrac'

data/test/test_ticket.rb

@@ -0,0 +1,37 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class TestTicket < Test::Unit::TestCase
+  def test_attributes
+    tick = Rtrac::Ticket.new(1)
+    tick.stubs(:ticket_attributes).returns(['1', 1195317367, 1195317367, {'summary' => 'test summary', 'description' => 'test description'}])
+    assert_equal tick.attributes, {:id => '1', :created_at => 1195317367, :updated_at => 1195317367, :summary => 'test summary', :description => 'test description'}
+  end
+
+  def test_setting_attributes
+    tick = Rtrac::Ticket.new(1)
+    tick.attributes = {:foo => 'foo'}
+    assert_equal tick.instance_variable_get(:@ticket_attributes), {:foo => 'foo'}
+  end
+
+  def test_update_should_remove_updated_at_and_created_at
+    tick = Rtrac::Ticket.new(1, {:summary => 'foo', :created_at => 'foo', :updated_at => 'foo'})
+    Rtrac::Ticket.expects(:send_query).with('ticket.update', 1, 'Testing Comment', {:summary => 'foo'}).returns(true)
+    tick.update('Testing Comment', {:summary => 'foo', :created_at => 'foo', :updated_at => 'foo'})
+  end
+
+  def test_create
+    Rtrac::Ticket.expects(:send_query).with('ticket.create', 'Test Title', 'Test Description', {:foo => 'foo'})
+    Rtrac::Ticket.create('Test Title', 'Test Description', {:foo => 'foo'})
+  end
+
+  def test_destroy
+    Rtrac::Ticket.expects(:send_query).with('ticket.delete', 1)
+    Rtrac::Ticket.destroy(1)
+  end
+
+  def test_get
+    tick = Rtrac::Ticket.new(1)
+    Rtrac::Ticket.expects(:send_query).with('ticket.get', 1)
+    tick.send(:get)
+  end
+end

metadata

@@ -0,0 +1,79 @@
+--- !ruby/object:Gem::Specification 
+name: rtrac
+version: !ruby/object:Gem::Version 
+  version: 1.0.1
+platform: ruby
+authors: 
+- Josh Stephenson
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-03-08 23:00:00 -08:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.5.0
+    version: 
+description: "== FEATURES/PROBLEMS:  Ticket access for Trac  == SYNOPSIS:  Rtrac::Base.get_by_milestone(milestone).each do |id| # grab the ticket's data tick = Rtrac::Ticket.new(id) iteration_hash[:total] += tick.severity.to_i iteration_hash[:tickets] << {:id => id, :points => tick.severity.to_i, :status => tick.status, :updated_at =>Time.parse(tick.updated_at.to_s)} end  == REQUIREMENTS:  active_support hoe"
+email: josh@elctech.com
+executables: 
+- rtrac
+extensions: []
+
+extra_rdoc_files: 
+- History.txt
+- Manifest.txt
+- README.txt
+files: 
+- History.txt
+- Manifest.txt
+- README.txt
+- Rakefile
+- bin/rtrac
+- lib/rtrac.rb
+- lib/rtrac/util.rb
+- lib/rtrac/base.rb
+- lib/rtrac/ticket.rb
+- test/test_helper.rb
+- test/test_rtrac.rb
+- test/test_base.rb
+- test/test_ticket.rb
+has_rdoc: true
+homepage: "    by Josh Stephenson"
+post_install_message: 
+rdoc_options: 
+- --main
+- README.txt
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: rtrac
+rubygems_version: 1.0.1
+signing_key: 
+specification_version: 2
+summary: Trac wrapper with command line tool
+test_files: 
+- test/test_base.rb
+- test/test_helper.rb
+- test/test_rtrac.rb
+- test/test_ticket.rb