fisheye-crucible 0.0.1

data/features/support/common.rb

@@ -0,0 +1,39 @@
+module CommonHelpers
+  def in_tmp_folder(&block)
+    FileUtils.chdir(@tmp_root, &block)
+  end
+
+  def in_project_folder(&block)
+    project_folder = @active_project_folder || @tmp_root
+    FileUtils.chdir(project_folder, &block)
+  end
+
+  def in_home_folder(&block)
+    FileUtils.chdir(@home_path, &block)
+  end
+
+  def force_local_lib_override(project_name = @project_name)
+    rakefile = File.read(File.join(project_name, 'Rakefile'))
+    File.open(File.join(project_name, 'Rakefile'), "w+") do |f|
+      f << "$:.unshift('#{@lib_path}')\n"
+      f << rakefile
+    end
+  end
+
+  def setup_active_project_folder project_name
+    @active_project_folder = File.join(@tmp_root, project_name)
+    @project_name = project_name
+  end
+end
+
+World(CommonHelpers)
+
+# Common steps
+Given /^I have logged in$/ do
+  @fc.login 'gemtest', 'gemtest'
+  @fc.instance_eval("@token").should_not be_nil
+end
+
+Given /^I have not logged in$/ do
+  @fc.instance_eval("@token").should be_nil
+end

data/features/support/config.yaml

@@ -0,0 +1,3 @@
+---
+username: 
+password:

data/features/support/env.rb

@@ -0,0 +1,16 @@
+require File.dirname(__FILE__) + "/../../lib/fisheye-crucible"
+require File.dirname(__FILE__) + "/../../lib/fisheye-crucible/client/legacy"
+
+gem 'cucumber'
+require 'cucumber'
+gem 'rspec'
+require 'spec'
+
+Before do
+  @tmp_root = File.dirname(__FILE__) + "/../../tmp"
+  @home_path = File.expand_path(File.join(@tmp_root, "home"))
+  @lib_path  = File.expand_path(File.dirname(__FILE__) + "/../../lib")
+  FileUtils.rm_rf   @tmp_root
+  FileUtils.mkdir_p @home_path
+  ENV['HOME'] = @home_path
+end

data/features/support/hooks.rb

@@ -0,0 +1,9 @@
+Before do
+  @fc = FisheyeCrucible::Client::Legacy.new 'http://sandbox.fisheye.atlassian.com'
+end
+
+=begin
+at_exit do
+  @fc.logout if @fc
+end
+=end

data/features/support/matchers.rb

@@ -0,0 +1,11 @@
+module Matchers
+  def contain(expected)
+    simple_matcher("contain #{expected.inspect}") do |given, matcher|
+      matcher.failure_message = "expected #{given.inspect} to contain #{expected.inspect}"
+      matcher.negative_failure_message = "expected #{given.inspect} not to contain #{expected.inspect}"
+      given.index expected
+    end
+  end
+end
+
+World(Matchers)

data/lib/fisheye-crucible.rb

@@ -0,0 +1,10 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) ||
+  $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+require 'fisheye_crucible_exception'
+
+module FisheyeCrucible
+  VERSION = '0.0.1'
+  WWW = 'http://github.com/turboladen/fisheye-crucible'
+end

data/lib/fisheye-crucible/client.rb

@@ -0,0 +1,33 @@
+require 'rubygems'
+require 'fisheye-crucible'
+require 'rest-client'
+
+# This is the parent class for accessing Fisheye/Crucible.  This will change
+#   quite a bit once work on the current Fisheye/Crucible gets started.  For
+#   now, look at the docs for FisheyeCrucible::Client::Legacy to get started.
+class FisheyeCrucible::Client
+
+  # @return [Boolean] Turn debug on or off
+  attr_accessor :do_debug
+
+  ##
+  # Sets up a Rest object to interact with the server(s).
+  #
+  # @param [String] server The base URL of the server to connect to.
+  def initialize(server)
+    @server = server
+    @fisheye_rest = RestClient::Resource.new(@server)
+    @token = nil
+    @do_debug = false
+  end
+
+  ##
+  # Print out string if debug is turned on.
+  #
+  # @param [String] string The debug string to print out.
+  def debug(string)
+    if @do_debug
+      puts string
+    end
+  end
+end

data/lib/fisheye-crucible/client/legacy.rb

@@ -0,0 +1,315 @@
+require 'rubygems'
+require 'fisheye-crucible/client'
+require 'fisheye-crucible/type_converter'
+require 'rexml/document'
+
+##
+# This class provides access to the Fisheye/Crucible REST API that was
+#   used before version 2.0.  More info here:
+#   http://confluence.atlassian.com/display/FECRUDEV/FishEye+Legacy+Remote+API
+#
+# All methods are named in Ruby style, however aliases are provided that are
+#   named after the Fisheye/Crucible function name (if different).
+class FisheyeCrucible::Client::Legacy < FisheyeCrucible::Client
+
+  def initialize(server)
+    super(server)
+  end
+
+  ##
+  # Logs in with provided credentials and returns a token that can be used for
+  #   all other calls.
+  #
+  # @param [String] username The user to login with.
+  # @param [String] password The password of the user to login with.
+  # @return [String] The token to use for other calls.
+  def login(username=nil, password=nil)
+    @token = build_rest_call('api/rest/login',
+      :post,
+      {
+        :username => username,
+        :password => password
+      }
+    )
+  end
+
+  ##
+  # Logs out of Fisheye/Crucible.
+  #
+  # @return [Boolean] Returns true if logout was successful.
+  def logout
+    unless @token
+      error_message = "Can't log out--it seems you're not logged in."
+      raise FisheyeCrucibleError, error_message
+    end
+
+    result = build_rest_call('api/rest/logout', :post, { :auth => @token })
+
+    @token = '' if result == true
+
+    result
+  end
+
+  ##
+  # Gets the version of Fisheye.
+  #
+  # @return [String] The version of Fisheye.
+  # @alias fisheyeVersion
+  def fisheye_version
+    build_rest_call('api/rest/fisheyeVersion', :get)
+  end
+  alias_method :fisheyeVersion, :fisheye_version
+
+  ##
+  # Gets the version of Crucible.
+  #
+  # @return [String] The version of Crucible.
+  def crucible_version
+    build_rest_call('api/rest/fisheyeVersion', :get)
+  end
+  alias_method :crucibleVersion, :crucible_version
+
+  ##
+  # Gets the list of repositories to an array.
+  #
+  # @return [Array] The list of repositories.
+  def repositories
+    build_rest_call('api/rest/repositories',
+      :post,
+      { :auth => @token }
+    )
+  end
+  alias_method :listRepositories, :repositories
+
+  ##
+  # Gets the file/dir listing from a repository.
+  #
+  # @param [String] repository The repository to get the listing for.
+  # @param [String] path The directory in the repository to get the listing
+  #   for.  If no path is given, listing is from /.
+  # @return [Hash<String><Hash>] The listing, where the key is the
+  #   file/directory and the value is another Hash that contains properties of
+  #   the file/directory.
+  def list_paths_from(repository, path='')
+    build_rest_call('api/rest/listPaths',
+      :post,
+      {
+        :auth => @token,
+        :rep => repository,
+        :path => path
+      }
+    )
+  end
+  alias_method :listPaths, :list_paths_from
+
+  ##
+  # Gets details about a specific file/directory revision from the given
+  #   repository.
+  #
+  # @param [String] repository The repository in which the file resides.
+  # @param [String] path The path, relative to the repository, in which the
+  #   file resides.
+  # @param [Fixnum] revision The revision of the file/directory to get the info
+  #   about.
+  # @return [Hash] The list of details about the file revision.
+  def revision(repository, path, revision)
+    build_rest_call('api/rest/revision',
+      :post,
+      {
+        :auth => @token,
+        :rep => repository,
+        :path => path,
+        :rev => revision.to_s
+      }
+    )
+  end
+  alias_method :getRevision, :revision
+
+  ##
+  # Gets tags associated with a file/directory revision.
+  #
+  # @param [String] repository The repository in which the file resides.
+  # @param [String] path The path, relative to the repository, in which the
+  #   file resides.
+  # @param [Fixnum] revision The revision of the file/directory to get the tags
+  #   for.
+  # @return [Hash] The list of tags for the file revision.
+  def tags(repository, path, revision)
+    puts "WARNING: This method is untested!"
+
+    tags = build_rest_call('api/rest/tags',
+      :post,
+      {
+        :auth => @token,
+        :rep => repository,
+        :path => path,
+        :rev => revision.to_s
+      }
+    )
+=begin
+    tags_xml = @fisheye_rest['api/rest/tags'].post :auth => @token,
+      :rep => repository,
+      :path => path,
+      :rev => revision.to_s
+
+    #debug tags_xml
+    return tags_xml.to_ruby
+      doc = REXML::Document.new(tags_xml)
+
+      if doc.root.name.eql? 'error'
+        raise doc.root.text
+      elsif doc.root.name.eql? 'response' and doc.root.has_elements?
+        # TODO: Not sure if this works since I can't find any files
+        #   with tags.
+        return doc.root.elements['//tags'].text
+      elsif doc.root.name.eql? 'response' and !doc.root.has_elements?
+        return ""
+      end
+=end
+  end
+  alias_method :listTagsForRevision, :tags
+
+  ##
+  # Gets the history for a file/directory, which is a list of revisions and
+  #   their associated info.
+  #
+  # @param [String] repository The repository for which to get the history
+  #   info about.
+  # @param [String] path The path, relative to root, for which to get info
+  #   about.
+  # @return [Array<Hash>] The list of revisions.
+  def path_history(repository, path='')
+    build_rest_call('api/rest/pathHistory',
+      :post,
+      {
+        :auth => @token,
+        :rep => repository,
+        :path => path
+      }
+    )
+  end
+  alias :pathHistory :path_history
+
+  ##
+  # Gets information about a changeset.
+  #
+  # @param [String] repository The repository for which to get the changeset
+  #   info about.
+  # @param [Fixnum] csid The changeset ID to get the info about.
+  # @return [Hash] All of the changeset info as defined by the API.
+  def changeset(repository, csid)
+    build_rest_call('api/rest/changeset',
+      :post,
+      {
+        :auth => @token,
+        :rep => repository,
+        :csid => csid.to_s
+      }
+    )
+  end
+  alias_method :getChangeset, :changeset
+
+  ##
+  # Gets all changeset IDs (csids) that match the parameters given.
+  #
+  # @param [String] repository The repository for which to get the changesets
+  #   for.
+  # @param [String] path Path to the item(s) to get changesets for.  Can only
+  #   be a directory.
+  # @param [Fixnum] max_return The maximum number of values to return.  If not
+  #   set, this is limited by the internal Fisheye server.  If set, the most
+  #   recent results are returned.
+  # @param [DateTime] start_date The DateTime object representing the start
+  #   date for which to filter the query.
+  # @param [DateTime] end_date The DateTime object representing the end date
+  #   for which to filter the query.
+  # @return [Hash<Array,String>] :csids => the Array of changeset IDs;
+  #   :max_return => Max values returned.
+  def changesets(repository, path='/', max_return=nil, start_date=nil,
+        end_date=nil)
+    build_rest_call('api/rest/changesets',
+      :post,
+      {
+        :auth => @token,
+        :rep => repository,
+        :path => path,
+        :start => start_date,
+        :end => end_date,
+        :maxReturn => max_return
+      }
+    )
+  end
+  alias_method :listChangesets, :changesets
+
+  ##
+  # Sends an EyeQL query to the server for a given repository.  Return types
+  #   can differ depending on the 'return-clause' used in the query.  For more
+  #   info, see http://confluence.atlassian.com/display/FISHEYE/EyeQL+Reference+Guide.
+  #
+  # @param [String] repository The repository to run the EyeQL query on.
+  # @param [String] query The EyeQL query to run.
+  # @return [Object]
+  def query(repository, query)
+    build_rest_call('api/rest/query',
+      :post,
+      {
+        :auth => @token,
+        :rep => repository,
+        :query => query
+      }
+    )
+  end
+
+  ##
+  # Privates
+  private
+
+  ##
+  # Builds and makes the REST call from the arguments given.
+  #
+  # @param [String] url The API portion of the URL as defined by the API.
+  # @param [String] action 'post' or 'get'.
+  # @param [Hash] options The REST params to pass to the REST call.
+  # @return [Object] The Object that #to_ruby returns.
+  def build_rest_call(url, action, options=nil)
+    rest_call = "@fisheye_rest['#{url}'].#{action}"
+
+    unless options.nil?
+      actual_options = non_nil_options_in options
+
+      option_count = 1
+      actual_options.each_pair do |key,value|
+        unless value.nil?
+          rest_call << " :#{key} => '#{value}'"
+          rest_call << ',' unless option_count == actual_options.length
+          option_count += 1
+        end
+      end
+    end
+
+    response_xml = eval(rest_call)
+    response = response_xml.to_ruby
+
+    if response.class == FisheyeCrucibleError
+      raise response
+    end
+
+    response
+  end
+
+  ##
+  # Removes all key/value pairs from Hash that have a nil value and returns
+  #   a Hash with keys that have values.
+  #
+  # @param [Hash] options The Hash to remove nil key/value pairs from.
+  def non_nil_options_in options
+    non_nil_options = {}
+    options.each_pair do |k,v|
+      non_nil_options[k] = v unless v.nil?
+    end
+
+    non_nil_options
+  end
+rescue FisheyeCrucibleError => e
+  puts e.message
+end

data/lib/fisheye-crucible/type_converter.rb

@@ -0,0 +1,285 @@
+require 'rexml/document'
+require 'fisheye-crucible'
+
+# By adding this method to String, the #to_ruby method can be called directly
+# on the return data from RestClient.  This, effectively, accomplishes turning
+# a String of XML into the Ruby data types that make sense for the return types
+# that Atlassian defined.
+class String
+
+  # Takes a String of XML then converts in to a correlating Ruby data type.
+  #   Aside from the documentation for each private method below, here is the
+  #   conversion table:
+  # | Fisheye/Crucible Type  | Ruby Type               |
+  # | string                 | String                  |
+  # | boolean                | TrueClass, FalseClass   |
+  # | pathinfo               | Hash with child Hashes  |
+  # | revision               | Hash                    |
+  # | history                | Array of revisions      |
+  # | changeset              | Hash                    |
+  # | changesets             | Hash of changesets      |
+  # | revisionkey            | Array with child Hashes |
+  # | row                    | Array                   |
+  def to_ruby
+    doc = REXML::Document.new self
+
+    type = doc.root.name
+    doc_text = doc.root.text
+
+    responses = []
+    response_type = ''
+
+    if type == 'error'
+      return FisheyeCrucibleError.new(doc_text)
+    elsif type == 'response'
+      doc.root.each_element do |element|
+        # The data type
+        response_type = element.name
+
+        # Text for the next element
+        responses << element.text
+      end
+    else
+      message = "Not sure what to do with this response:\n#{doc_text}"
+      return FisheyeCrucibleError.new(message)
+    end
+
+    # If we have 0 or 1 actual strings, return the string or ""
+    if response_type.eql? 'string' and responses.length <= 1
+      return string_to_string(doc)
+    # If we have mulitple strings, return the Array of Strings
+    elsif response_type.eql? 'string'
+      return string_to_array(doc)
+    elsif response_type.eql? 'boolean'
+      return boolean_to_true_false(doc)
+    elsif response_type.eql? 'pathinfo'
+      return pathinfo_to_hash(doc)
+    elsif response_type.eql? 'revision'
+      return revision_to_hash(doc)
+    elsif response_type.eql? 'history'
+      return history_to_array(doc)
+    elsif response_type.eql? 'changeset'
+      return changeset_to_hash(doc)
+    elsif response_type.eql? 'changesets'
+      return changesets_to_hash(doc)
+    elsif response_type.eql? 'revisionkey'
+      return revisionkeys_to_array(doc)
+    elsif response_type.eql? 'row'
+      return custom_to_array(doc)
+    end
+
+    message = "Response type unknown: '#{response_type}'"
+    return FisheyeCrucibleError.new(message)
+  end
+
+  ##
+  # PRIVATES!
+  private
+
+  ##
+  # Converts a REXML::Document with 1 element of type <string> into a String.
+  #
+  # @param [REXML::Document] xml_doc The XML document to convert.
+  # @return [String] The string from the XML document.
+  def string_to_string(xml_doc)
+    xml_doc.root.elements[1].text
+  end
+
+  ##
+  # Converts a String to its related Boolean type.  If the string doesn't
+  #   contain such a type, nil is returned.
+  #
+  # @param [String] string The String to convert.
+  # @return [Boolean,String] true, false, or the original string.
+  def string_to_true_false(string)
+    return true if string.eql? 'true'
+    return false if string.eql? 'false'
+    return string
+  end
+
+  ##
+  # Converts a REXML::Document with element <boolean> into a true or false
+  #   value.
+  #
+  # @param [REXML::Document] xml_doc The XML document to convert.
+  # @return [Boolean] true, false, or nil.
+  def boolean_to_true_false(xml_doc)
+    string_to_true_false(xml_doc.root.elements[1].text)
+  end
+
+  ##
+  # Converts a REXML::Document with multiple elements of type <string> into an
+  #   Array.
+  #
+  # @param [REXML::Document] xml_doc The XML document to convert.
+  # @return [Array] The list of strings.
+  def string_to_array(xml_doc)
+    responses = []
+    xml_doc.root.each_element do |element|
+      response_type = element.name
+      responses << element.text
+    end
+
+    responses
+  end
+
+  ##
+  # Takes Fisheye/Crucible's <pathinfo> return type and turns it in to
+  #   a Hash of Hashes.
+  #
+  # @param [REXML::Document] xml_doc The XML document to convert.
+  # @return [Hash<Hash>] The path info as a Hash.  The Hash contains keys
+  #   which are the file/directory names in the path; values for those keys
+  #   are Hashes which contain the properties of that file/directory.
+  def pathinfo_to_hash(xml_doc)
+    path_name = ''
+    path_names = {}
+
+    xml_doc.root.each_element do |element|
+      path_name = element.attributes["name"]
+      path_names[path_name] = {}
+
+      element.attributes.each_attribute do |attribute|
+        next attribute if attribute.name.eql? 'name'
+        boolean_value = string_to_true_false(attribute.value)
+        path_names[path_name][attribute.name.to_sym] = boolean_value
+      end
+    end
+
+    path_names
+  end
+
+  ##
+  # Takes Fisheye/Crucible's <revision> return type and turns it in to a single
+  #   Hash.
+  #
+  # @param [REXML::Document] xml_doc The XML document to convert.
+  # @return [Hash] The info about the revision.
+  def revision_to_hash(xml_doc)
+    details = {}
+
+    xml_doc.root.elements['//revision'].attributes.each do |attribute|
+      # Convert the value to an Int if the string is just a number
+      if attribute[1] =~ /^\d+$/
+        details[attribute.first.to_sym] = attribute[1].to_i
+      else
+        details[attribute.first.to_sym] = attribute[1]
+      end
+    end
+    details[:log] = xml_doc.root.elements['//log'].text
+
+    details
+  end
+
+  ##
+  # Takes Fisheye/Crucible's <history> return type and turns it in to an
+  #   Array of revisions, which are Hashes.
+  #
+  # @param [REXML::Document] xml_doc The XML document to convert.
+  # @return [Array<Hash>] The Array of revision Hashes.
+  def history_to_array(xml_doc)
+    revisions = []
+
+    revisions_xml = REXML::XPath.match(xml_doc, "//revisions/revision")
+    revisions_xml.each do |revision_xml|
+      revision = REXML::Document.new(revision_xml.to_s)
+      revisions << revision_to_hash(revision)
+    end
+
+    revisions
+  end
+
+  ##
+  # Takes Fisheye/Crucible's <changeset> return type and turns it in to a Hash.
+  #
+  # @param [REXML::Document] xml_doc The XML document to convert.
+  # @return [Hash] Hash containting the changeset history information as
+  #   defined by the API.
+  def changeset_to_hash(xml_doc)
+    details = {}
+
+    xml_doc.root.elements['//changeset'].attributes.each do |attribute|
+      # Convert the value to an Int if the string is just a number
+      int_attribute = attribute[1]
+      if int_attribute =~ /^\d+$/
+        details[attribute.first.to_sym] = int_attribute.to_i
+      else
+        details[attribute.first.to_sym] = int_attribute
+      end
+    end
+    details[:log] = xml_doc.root.elements['//log'].text
+
+    # Revisions is an Array of Hashes, where each Hash is a key/value pair that
+    #   contains the path and revsion of one of the files/directories that's
+    #   part of the changeset.
+    details[:revisions] = []
+    details[:revisions] << revisionkeys_to_array(xml_doc)
+
+    details
+  end
+
+  ##
+  # Takes Fisheye/Crucible's <revisionkey> return type and turns it in to an
+  #   Array of Hashes.
+  #
+  # @param [REXML::Document] xml_doc The XML document to convert.
+  # @return [Array<Hash>] The Array of path & rev data.
+  def revisionkeys_to_array(xml_doc)
+    revisionkeys = []
+
+    xml_doc.root.elements.each('//revisionkey') do |element|
+      revisionkey = { :path => element.attributes['path'],
+        :rev => element.attributes['rev'].to_i
+      }
+
+      revisionkeys << revisionkey
+    end
+
+    revisionkeys
+  end
+
+  ##
+  # Takes Fisheye/Crucible's <changesets> return type and turns it in to a
+  #   Hash.
+  #
+  # @param [REXML::Document] xml_doc The XML document to convert.
+  # @return [Hash] Contains the changeset IDs as defined by the query.
+  def changesets_to_hash(xml_doc)
+    changesets = {}
+    changesets[:csids] = []
+
+    changesets[:max_return] = xml_doc.root.elements['//changesets'].
+      attributes['maxReturn']
+
+    xml_doc.root.elements['//csids'].each_element do |element|
+      changesets[:csids] << element.text.to_i
+    end
+
+    changesets
+  end
+
+  ##
+  # Takes Fisheye/Crucible's custom <row> return type (from a query) and turns
+  #   it in to an Array of Hashes containing the results from the query.
+  #
+  # @param [REXML::Document] xml_doc The XML document to convert.
+  # @return [Array] The result from the query.
+  def custom_to_array(xml_doc)
+    responses = []
+
+    xml_doc.elements.each('//row') do |element|
+      response = {}
+      element.each do |subs|
+        if subs.is_a? REXML::Text
+        else
+          # TODO: If subs.text is a Boolean string, it doesn't get converted
+          # to the actual Boolean.  Same if it's an int or empty string.
+          response[subs.name.to_sym] = subs.text
+        end
+      end
+      responses << response
+    end
+
+    responses
+  end
+end