active_bugzilla 1.0.0

data/LICENSE.txt

@@ -0,0 +1,23 @@
+Copyright (c) 2013-2014 Red Hat, Inc.
+
+
+MIT License
+
+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/README.md

@@ -0,0 +1,57 @@
+# ActiveBugzilla
+
+[![Gem Version](https://badge.fury.io/rb/active_bugzilla.png)](http://badge.fury.io/rb/active_bugzilla)
+[![Build Status](https://travis-ci.org/ManageIQ/active_bugzilla.png)](https://travis-ci.org/ManageIQ/active_bugzilla)
+[![Code Climate](https://codeclimate.com/github/ManageIQ/active_bugzilla.png)](https://codeclimate.com/github/ManageIQ/active_bugzilla)
+[![Coverage Status](https://coveralls.io/repos/ManageIQ/active_bugzilla/badge.png?branch=master)](https://coveralls.io/r/ManageIQ/active_bugzilla)
+[![Dependency Status](https://gemnasium.com/ManageIQ/active_bugzilla.png)](https://gemnasium.com/ManageIQ/active_bugzilla)
+
+ActiveBugzilla is an ActiveRecord like interface to the Bugzilla API.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'active_bugzilla'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install active_bugzilla
+
+## Example Usage
+
+```ruby
+service = ActiveBugzilla::Service.new("http://uri.to/bugzilla", username, password)
+ActiveBugzilla::Base.service = service
+bugs = ActiveBugzilla::Bug.find(:product => product_name, :status => "NEW")
+bugs.each do |bug|
+  puts "Bug ##{bug.id} - created_on=#{bug.created_on}, updated_on=#{bug.updated_on}, priority=#{bug.priority}"
+  puts "Bug Attributes: #{bug.attribute_names.inspect}"
+end
+
+bug = ActiveBugzilla::Bug.find(:id => 12345)
+puts "PRIORITY: #{bug.priority}"   # => "low"
+puts "FLAGS: #{bug.flags.inspect}" # => {"devel_ack"=>"?", "qa_ack"=>"+"}
+bug.priority = "high"
+bug.flags.delete("qa_ack")
+bug.flags["devel_ack"] = "+"
+bug.save
+puts "PRIORITY: #{bug.priority}"   # => "high"
+puts "FLAGS: #{bug.flags.inspect}" # => {"devel_ack"=>"+"}
+puts "FLAG OBJECTS: #{bug.flag_objects.inspect}" # => Array of ActiveBugzilla:Flag objects
+
+bug.add_comment("Testing")
+puts "COMMENTS: #{bug.comments.inspect}" # => Array of ActiveBugzilla:Comment objects
+```
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/lib/active_bugzilla.rb

@@ -0,0 +1,12 @@
+require 'active_bugzilla/version'
+
+require 'active_bugzilla/service'
+
+require 'active_bugzilla/base'
+require 'active_bugzilla/bug'
+require 'active_bugzilla/comment'
+require 'active_bugzilla/field'
+require 'active_bugzilla/flag'
+
+module ActiveBugzilla
+end

data/lib/active_bugzilla/base.rb

@@ -0,0 +1,21 @@
+module ActiveBugzilla
+  class Base
+    def self.service=(service)
+      @@service = service
+    end
+
+    def self.service
+      @@service
+    end
+
+    private
+
+    def self.normalize_timestamp(timestamp)
+      timestamp.respond_to?(:to_time) ? timestamp.to_time : nil
+    end
+
+    def normalize_timestamp(timestamp)
+      self.class.normalize_timestamp(timestamp)
+    end
+  end
+end

data/lib/active_bugzilla/bug.rb

@@ -0,0 +1,107 @@
+require 'active_model'
+
+module ActiveBugzilla
+  class Bug < Base
+    include ActiveModel::Validations
+    include ActiveModel::Dirty
+
+    require_relative 'bug/service_management'
+    include ServiceManagement
+
+    require_relative 'bug/flags_management'
+    include FlagsManagement
+
+    validates_numericality_of :id
+
+    def initialize(attributes = {})
+      attributes.each do |key, value|
+        next unless attribute_names.include?(key)
+        ivar_key = "@#{key}"
+        instance_variable_set(ivar_key, value)
+      end if attributes
+    end
+
+    def save
+      return if changes.empty?
+      update_attributes(changed_attribute_hash)
+      @changed_attributes.clear
+      reload
+    end
+
+    def reload
+      raw_reset
+      reset_instance_variables
+      reset_flags
+      @comments = Comment.instantiate_from_raw_data(raw_comments)
+      self
+    end
+
+    def update_attributes(attributes)
+      attributes.delete(:id)
+
+      attributes.each do |name, value|
+        symbolized_name = name.to_sym
+        raise "Unknown Attribute #{name}" unless attribute_names.include?(symbolized_name)
+        public_send("#{name}=", value)
+        if symbolized_name == :flags
+          attributes[name] = flags_raw_updates
+        else
+          @changed_attributes.delete(symbolized_name)
+        end
+      end
+
+      raw_update(attributes) unless attributes.empty?
+    end
+
+    def update_attribute(key, value)
+      update_attributes(key => value)
+    end
+
+    def comments
+      @comments ||= Comment.instantiate_from_raw_data(raw_comments)
+    end
+
+    def add_comment(comment, is_private = false)
+      _comment_id = service.add_comment(@id, comment, :is_private => is_private)
+      reload
+    end
+
+    def self.fields
+      @fields ||= Field.instantiate_from_raw_data(fetch_fields)
+    end
+
+    def self.find(options = {})
+      options[:include_fields] ||= []
+      options[:include_fields] << :id unless options[:include_fields].include?(:id)
+
+      fields_to_include = options[:include_fields].dup
+
+      search(options).collect do |bug_hash|
+        fields_to_include.each do |field|
+          bug_hash[field] = nil unless bug_hash.key?(field)
+          bug_hash[field] = flags_from_raw_flags_data(bug_hash[field]) if field == :flags
+        end
+        Bug.new(bug_hash)
+      end
+    end
+
+    private
+
+    def reset_instance_variables
+      attribute_names do |name|
+        next if name == :id
+        ivar_name = "@#{name}"
+        instance_variable_set(ivar_name, raw_attribute(name))
+      end
+    end
+
+    def changed_attribute_hash
+      hash = {}
+      changes.each do |key, values|
+        _value_from, value_to = values
+        hash[key.to_sym] = value_to
+      end
+      hash
+    end
+  end
+end

data/lib/active_bugzilla/bug/flags_management.rb

@@ -0,0 +1,88 @@
+require 'active_support/concern'
+require 'dirty_hashy'
+
+module ActiveBugzilla::Bug::FlagsManagement
+  extend ActiveSupport::Concern
+
+  module ClassMethods
+    def flags_from_raw_flags_data(raw_flags_data)
+      return {} if raw_flags_data.nil?
+      flag_objects = ActiveBugzilla::Flag.instantiate_from_raw_data(raw_flags_data)
+      flag_objects.each_with_object({}) do |flag, hash|
+        hash[flag.name] = flag.status
+      end
+    end
+  end
+
+  def flag_objects
+    @flag_objects ||= ActiveBugzilla::Flag.instantiate_from_raw_data(raw_flags, @id)
+  end
+
+  def flags=(value)
+    flags_will_change! unless value == @flags
+    @flags = value
+  end
+
+  def flags
+    @flags ||= begin
+      flags_hash = flag_objects.each_with_object(DirtyIndifferentHashy.new) do |flag, hash|
+        hash[flag.name] = flag.status
+      end
+      flags_hash.clean_up!
+      flags_hash
+    end
+  end
+
+  def flags_raw_updates
+    raw_updates = []
+    flags.changes.each do |key, value|
+      _old_status, new_status = value
+      new_status ||= 'X'
+      raw_updates << {'name' => key.to_s, "status" => new_status}
+    end
+    raw_updates
+  end
+
+  def reset_flags
+    @flag_objects = nil
+    @flags        = nil
+    flags
+  end
+
+  def changed_with_flags?
+    changed_without_flags? || flags.changed?
+  end
+
+  def changes_with_flags
+    changes = changes_without_flags
+    changes['flags'] = [flags_previous_value, flags] if flags.changed?
+    changes
+  end
+
+  def flags_previous_value
+    previous_flags = flags.dup
+    flags.changes.each do |key, value|
+      previous_flags[key] = value.first
+    end
+    previous_flags
+  end
+
+  def changed_attributes_with_flags
+    changed_attributes = changed_attributes_without_flags
+    changed_attributes['flags'] = flags_previous_value if flags.changed?
+    changed_attributes
+  end
+
+  included do
+    define_attribute_methods [:flags]
+
+    alias_method :changed_without_flags?, :changed?
+    alias_method :changed?, :changed_with_flags?
+
+    alias_method :changes_without_flags, :changes
+    alias_method :changes, :changes_with_flags
+
+    alias_method :changed_attributes_without_flags, :changed_attributes
+    alias_method :changed_attributes, :changed_attributes_with_flags
+  end
+end

data/lib/active_bugzilla/bug/service_management.rb

@@ -0,0 +1,174 @@
+require 'active_support/concern'
+module ActiveBugzilla::Bug::ServiceManagement
+  extend ActiveSupport::Concern
+
+  ATTRIBUTES_XMLRPC_RENAMES_MAP = {
+    #   Bug       =>  XMLRPC
+    :created_by   => :creator,
+    :created_on   => :creation_time,
+    :duplicate_id => :dupe_of,
+    :updated_on   => :last_change_time,
+
+    # Some are absent from what Bugzilla.fields() returns
+    :actual_time  => :actual_time,
+    :flags        => :flags,
+  }
+
+  module ClassMethods
+    def attributes_xmlrpc_map
+      @attributes_xmlrpc_map ||= begin
+        hash = generate_xmlrpc_map
+        define_attributes(hash.keys)
+        hash
+      end
+    end
+
+    def xmlrpc_timestamps
+      @xmlrpc_timestamps ||= fields.select(&:timestamp?).collect { |field| field.name.to_sym }
+    end
+
+    def default_service_attributes
+      attributes_xmlrpc_map.values - [:comments]
+    end
+
+    def normalize_attributes_to_service(hash)
+      attributes_xmlrpc_map.each do |bug_key, xmlrpc_key|
+        bug_key    = bug_key.to_sym
+        xmlrpc_key = xmlrpc_key.to_sym
+        next if bug_key == xmlrpc_key
+        hash[xmlrpc_key] = hash.delete(bug_key)
+      end
+
+      hash[:include_fields] = normalize_include_fields_to_service(hash[:include_fields]) if hash.key?(:include_fields)
+
+      hash.delete_if { |k, v| v.nil? }
+      hash
+    end
+
+    def normalize_attributes_from_service(hash)
+      attributes_xmlrpc_map.each do |bug_key, xmlrpc_key|
+        next unless hash.key?(xmlrpc_key.to_s)
+        value = hash.delete(xmlrpc_key.to_s)
+        value = normalize_timestamp(value) if xmlrpc_timestamps.include?(xmlrpc_key)
+        hash[bug_key] = value
+      end
+
+      hash
+    end
+
+    def attribute_names
+      @attribute_names ||= attributes_xmlrpc_map.keys.sort_by { |sym| sym.to_s }
+    end
+
+    def search(options = {})
+      options = normalize_attributes_to_service(options)
+      service.search(options).collect do |bug_hash|
+        normalize_attributes_from_service(bug_hash)
+      end
+    end
+
+    private
+
+    def fetch_fields
+      service.fields
+    end
+
+    def generate_xmlrpc_map
+      hash = ATTRIBUTES_XMLRPC_RENAMES_MAP
+      fields.each do |field|
+        next if hash.values.include?(field.name)
+        next if field.name.include?(".")
+        attribute_name = field.name
+        attribute_name = attribute_name[3..-1] if attribute_name[0..2] == "cf_"
+        hash[attribute_name.to_sym] = field.name.to_sym
+      end
+      hash
+    end
+
+    def normalize_include_fields_to_service(include_fields)
+      include_fields.collect do |bug_key|
+        attributes_xmlrpc_map[bug_key]
+      end.uniq.compact
+    end
+
+    def define_attributes(names)
+      define_attribute_methods names
+
+      names.each do |name|
+        next if name.to_s == 'flags'  # Flags is a special attribute
+
+        ivar_name = "@#{name}"
+        define_method(name) do
+          return instance_variable_get(ivar_name) if instance_variable_defined?(ivar_name)
+          instance_variable_set(ivar_name, raw_attribute(name))
+        end
+
+        define_method("#{name}=") do |val|
+          public_send("#{name}_will_change!") unless val == instance_variable_get(ivar_name)
+          instance_variable_set(ivar_name, val)
+        end
+      end
+    end
+  end
+
+  def attribute_names
+    self.class.attribute_names
+  end
+
+  private
+
+  def service
+    self.class.service
+  end
+
+  def raw_reset
+    @raw_data       = nil
+    @raw_comments   = nil
+    @raw_flags      = nil
+    @raw_attributes = nil
+  end
+
+  def raw_update(attributes)
+    attributes = self.class.normalize_attributes_to_service(attributes)
+    result = service.update(@id, attributes).first
+
+    id = result['id']
+    raise "Error - Expected to update id <#{@id}>, but updated <#{id}>" unless id == @id
+
+    result
+  end
+
+  def raw_data
+    @raw_data ||= service.get(@id, :include_fields => self.class.default_service_attributes).first
+  end
+
+  def raw_flags
+    @raw_flags ||= raw_attribute('flags')
+  end
+
+  def raw_comments
+    @raw_comments ||= (raw_attributes['comments'] || fetch_comments)
+  end
+
+  def raw_attributes
+    @raw_attributes ||= self.class.normalize_attributes_from_service(raw_data)
+  end
+
+  def raw_attribute_set(key, value)
+    raw_attributes
+    @raw_attributes[key] = value
+  end
+
+  def raw_attribute(key)
+    raw_attribute_set(key, fetch_attribute(key)) unless raw_attributes.key?(key)
+    raw_attributes[key]
+  end
+
+  def fetch_comments
+    service.comments(:ids => @id)['bugs'][@id.to_s]['comments']
+  end
+
+  def fetch_attribute(key)
+    service.get(@id, :include_fields => [key]).first[key]
+  end
+end

data/lib/active_bugzilla/comment.rb

@@ -0,0 +1,23 @@
+module ActiveBugzilla
+  class Comment < Base
+    attr_reader :bug_id, :count, :created_by, :created_on, :creator_id, :id, :private, :text, :updated_on
+    alias_method :private?, :private
+
+    def initialize(attributes)
+      @created_by = attributes['author']
+      @bug_id     = attributes['bug_id']
+      @count      = attributes['count']
+      @creator_id = attributes['creator_id']
+      @id         = attributes['id']
+      @text       = attributes['text']
+
+      @created_on = normalize_timestamp attributes['creation_time']
+      @updated_on = normalize_timestamp attributes['time']
+      @private    = attributes['is_private']
+    end
+
+    def self.instantiate_from_raw_data(data)
+      data.sort_by(&:count).collect { |hash| new(hash) }
+    end
+  end
+end

data/lib/active_bugzilla/field.rb

@@ -0,0 +1,68 @@
+module ActiveBugzilla
+  class Field < Base
+    attr_reader  :display_name, :id, :name, :original_name, :type, :values, :visibility_field, :visibility_values
+    attr_reader  :is_custom, :is_mandatory, :is_on_bug_entry
+    alias_method :mandatory?,    :is_mandatory
+    alias_method :custom?,       :is_custom
+    alias_method :on_bug_entry?, :is_on_bug_entry
+
+    KNOWN_TIMESTAMPS = %w(creation_time last_change_time)
+
+    # List of field aliases. Maps old style RHBZ parameter names to actual
+    # upstream values. Used for createbug() and query include_fields at
+    # least.
+    FIELD_ALIASES = {
+      # old               => current
+      'short_desc'        => 'summary',
+      'comment'           => 'description',
+      'rep_platform'      => 'platform',
+      'bug_severity'      => 'severity',
+      'bug_status'        => 'status',
+      'bug_id'            => 'id',
+      'blockedby'         => 'blocks',
+      'blocked'           => 'blocks',
+      'dependson'         => 'depends_on',
+      'reporter'          => 'creator',
+      'bug_file_loc'      => 'url',
+      'dupe_id'           => 'dupe_of',
+      'dup_id'            => 'dupe_of',
+      'longdescs'         => 'comments',
+      'opendate'          => 'creation_time',
+      'creation_ts'       => 'creation_time',
+      'status_whiteboard' => 'whiteboard',
+      'delta_ts'          => 'last_change_time',
+    }
+
+    def initialize(attributes = {})
+      @display_name      = attributes["display_name"]
+      @id                = attributes["id"]
+      @name              = self.class.field_alias(attributes["name"])
+      @original_name     = attributes["name"]
+      @type              = attributes["type"]
+      @values            = attributes["values"]
+      @visibility_field  = attributes["visibility_field"]
+      @visibility_values = attributes["visibility_values"]
+      @is_custom         = attributes["is_custom"]
+      @is_mandatory      = attributes["is_mandatory"]
+      @is_on_bug_entry   = attributes["is_on_bug_entry"]
+    end
+
+    def timestamp?
+      (type == 5) || KNOWN_TIMESTAMPS.include?(name)
+    end
+
+    def self.instantiate_from_raw_data(data)
+      data.delete_if { |hash| hash["name"] == "longdesc" } # Another way to specify comment[0]
+      data.delete_if { |hash| hash["name"].include?(".") } # Remove things like longdescs.count
+      data.collect do |field_hash|
+        new(field_hash)
+      end
+    end
+
+    private
+
+    def self.field_alias(value)
+      FIELD_ALIASES[value] || value
+    end
+  end
+end

data/lib/active_bugzilla/flag.rb

@@ -0,0 +1,22 @@
+module ActiveBugzilla
+  class Flag < Base
+    attr_reader :active, :bug_id, :created_on, :id, :name, :setter, :status, :type_id, :updated_on
+    alias_method :active?, :active
+
+    def initialize(attributes)
+      @id         = attributes['id']
+      @bug_id     = attributes['bug_id']
+      @type_id    = attributes['type_id']
+      @created_on = normalize_timestamp(attributes['creation_date'])
+      @updated_on = normalize_timestamp(attributes['modification_date'])
+      @status     = attributes['status']
+      @name       = attributes['name']
+      @setter     = attributes['setter']
+      @active     = attributes['is_active']
+    end
+
+    def self.instantiate_from_raw_data(data, bug_id = nil)
+      data.collect { |hash| new(hash.merge('bug_id' => bug_id)) }
+    end
+  end
+end

data/lib/active_bugzilla/service.rb

@@ -0,0 +1,234 @@
+require 'xmlrpc/client'
+
+module ActiveBugzilla
+  class Service
+    CLONE_FIELDS = [
+      :assigned_to,
+      :cc,
+      :cf_devel_whiteboard,
+      :cf_internal_whiteboard,
+      :comments,
+      :component,
+      :description,
+      :groups,
+      :keywords,
+      :op_sys,
+      :platform,
+      :priority,
+      :product,
+      :qa_contact,
+      :severity,
+      :summary,
+      :target_release,
+      :url,
+      :version,
+      :whiteboard
+    ]
+
+    attr_accessor :bugzilla_uri, :username, :password, :last_command
+    attr_reader   :bugzilla_request_uri, :bugzilla_request_hostname
+
+    def self.timeout=(value)
+      @@timeout = value
+    end
+
+    def self.timeout
+      defined?(@@timeout) && @@timeout
+    end
+
+    def timeout
+      self.class.timeout
+    end
+
+    def self.product=(value)
+      @@product = value
+    end
+
+    def self.product
+      defined?(@@product) && @@product
+    end
+
+    def product
+      self.class.product
+    end
+
+    def bugzilla_uri=(value)
+      @bugzilla_request_uri      = URI.join(value, "xmlrpc.cgi").to_s
+      @bugzilla_request_hostname = URI(value).hostname
+      @bugzilla_uri              = value
+    end
+
+    def initialize(bugzilla_uri, username, password)
+      raise ArgumentError, "username and password must be set" if username.nil? || password.nil?
+
+      self.bugzilla_uri = bugzilla_uri
+      self.username     = username
+      self.password     = password
+    end
+
+    def inspect
+      super.gsub(/@password=\".+?\", /, "")
+    end
+
+    # http://www.bugzilla.org/docs/4.4/en/html/api/Bugzilla/WebService/Bug.html#comments
+    def comments(params = {})
+      execute('comments', params)
+    end
+
+    # http://www.bugzilla.org/docs/4.4/en/html/api/Bugzilla/WebService/Bug.html#add_comment
+    def add_comment(bug_id, comment, params = {})
+      params[:id]      = bug_id
+      params[:comment] = comment
+      execute('add_comment', params)["id"]
+    end
+
+    # http://www.bugzilla.org/docs/4.4/en/html/api/Bugzilla/WebService/Bug.html#fields
+    def fields(params = {})
+      execute('fields', params)['fields']
+    end
+
+    # http://www.bugzilla.org/docs/4.4/en/html/api/Bugzilla/WebService/Bug.html#get
+    # XMLRPC Bug Query of an existing bug
+    #
+    # Example:
+    #   # Perform an xmlrpc query for a single bug.
+    #   bz.get(948970)
+    #
+    # @param bug_id [Array, String, Fixnum] One or more bug ids to process.
+    # @return [Array] Array of matching bug hashes.
+    def get(bug_ids, params = {})
+      bug_ids = Array(bug_ids)
+      raise ArgumentError, "bug_ids must be all Numeric" unless bug_ids.all? { |id| id.to_s =~ /^\d+$/ }
+
+      params[:ids] = bug_ids
+
+      results = execute('get', params)['bugs']
+      return [] if results.nil?
+      results
+    end
+
+    # http://www.bugzilla.org/docs/4.4/en/html/api/Bugzilla/WebService/Bug.html#search
+    def search(params = {})
+      params[:creation_time]    &&= to_xmlrpc_timestamp(params[:creation_time])
+      params[:last_change_time] &&= to_xmlrpc_timestamp(params[:last_change_time])
+      params[:product]          ||= product if product
+
+      results = execute('search', params)['bugs']
+      return [] if results.nil?
+      results
+    end
+
+    # http://www.bugzilla.org/docs/4.4/en/html/api/Bugzilla/WebService/Bug.html#update
+    def update(ids, params = {})
+      params[:ids] = Array(ids)
+      execute('update', params)['bugs']
+    end
+
+    # http://www.bugzilla.org/docs/4.4/en/html/api/Bugzilla/WebService/Bug.html#create
+    def create(params)
+      execute('create', params)
+    end
+
+    # Clone of an existing bug
+    #
+    # Example:
+    #   # Perform a clone of an existing bug, and return the new bug ID.
+    #   bz.clone(948970)
+    #
+    # @param bug_id [String, Fixnum] A single bug id to process.
+    # @param overrides [Hash] The properties to change from the source bug. Some properties include
+    #   * <tt>:target_release</tt> - The target release for the new cloned bug.
+    #   * <tt>:assigned_to</tt> - The person to assign the new cloned bug to.
+    # @return [Fixnum] The bug id to the new, cloned, bug.
+    def clone(bug_id, overrides = {})
+      raise ArgumentError, "bug_id must be numeric" unless bug_id.to_s =~ /^\d+$/
+
+      existing_bz = get(bug_id, :include_fields => CLONE_FIELDS).first
+
+      clone_description, clone_comment_is_private = assemble_clone_description(existing_bz)
+
+      params = {}
+      CLONE_FIELDS.each do |field|
+        next if field == :comments
+        params[field] = existing_bz[field.to_s]
+      end
+
+      # Apply overrides
+      overrides.each do |param, value|
+        params[param] = value
+      end
+
+      # Apply base clone fields
+      params[:cf_clone_of]        = bug_id
+      params[:description]        = clone_description
+      params[:comment_is_private] = clone_comment_is_private
+
+      create(params)[:id.to_s]
+    end
+
+    # Bypass python-bugzilla and use the xmlrpc API directly.
+    def execute(action, params)
+      cmd = "Bug.#{action}"
+
+      params[:Bugzilla_login]    ||= username
+      params[:Bugzilla_password] ||= password
+
+      self.last_command = command_string(cmd, params)
+      xmlrpc_client.call(cmd, params)
+    end
+
+    private
+
+    DEFAULT_CGI_PATH   = '/xmlrpc.cgi'
+    DEFAULT_PORT       = 443
+    DEFAULT_PROXY_HOST = nil
+    DEFAULT_PROXY_PORT = nil
+    DEFAULT_USE_SSL    = true
+    DEFAULT_TIMEOUT    = 120
+
+    def xmlrpc_client
+      @xmlrpc_client ||= ::XMLRPC::Client.new(
+                            bugzilla_request_hostname,
+                            DEFAULT_CGI_PATH,
+                            DEFAULT_PORT,
+                            DEFAULT_PROXY_HOST,
+                            DEFAULT_PROXY_PORT,
+                            username,
+                            password,
+                            DEFAULT_USE_SSL,
+                            timeout || DEFAULT_TIMEOUT)
+    end
+
+    def to_xmlrpc_timestamp(ts)
+      return ts if ts.kind_of?(XMLRPC::DateTime)
+      return ts unless ts.respond_to?(:to_time)
+      ts = ts.to_time
+      XMLRPC::DateTime.new(ts.year, ts.month, ts.day, ts.hour, ts.min, ts.sec)
+    end
+
+    # Build a printable representation of the xmlrcp command executed.
+    def command_string(cmd, params)
+      clean_params = Hash[params]
+      clean_params[:Bugzilla_password] = "********"
+      "xmlrpc_client.call(#{cmd}, #{clean_params})"
+    end
+
+    def assemble_clone_description(existing_bz)
+      clone_description = " +++ This bug was initially created as a clone of Bug ##{existing_bz[:id]} +++ \n"
+      clone_description << existing_bz[:description.to_s]
+
+      clone_comment_is_private = false
+      existing_bz[:comments.to_s].each do |comment|
+        clone_description << "\n\n"
+        clone_description << "*" * 70
+        clone_description << "\nFollowing comment by %s on %s\n\n" %
+          [comment['author'], comment['creation_time'].to_time]
+        clone_description << "\n\n"
+        clone_description << comment['text']
+        clone_comment_is_private = true if comment['is_private']
+      end
+
+      [clone_description, clone_comment_is_private]
+    end
+  end
+end

data/lib/active_bugzilla/version.rb

@@ -0,0 +1,3 @@
+module ActiveBugzilla
+  VERSION = "1.0.0"
+end

data/spec/active_bugzilla/bug_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+describe ActiveBugzilla::Bug do
+  context "#new" do
+    before(:each) do
+      @service_mapping = {
+        # Bug     => XMLRPC
+        :severity => :severity_xmlrpc,
+        :priority => :priority_xmlrpc,
+      }
+      @service = double('service')
+      ActiveBugzilla::Base.service = @service
+      described_class.stub(:generate_xmlrpc_map).and_return(@service_mapping)
+      described_class.stub(:xmlrpc_timestamps).and_return([])
+      @id  = 123
+      @bug = described_class.new(:id => @id)
+    end
+
+    it "attribute_names" do
+      raw_keys = @service_mapping.values
+      raw_data = {}
+      raw_keys.each { |k| raw_data[k.to_s] = 'foo' }
+      @bug.stub(:raw_data).and_return(raw_data)
+      expect(@bug.attribute_names).to eq(@service_mapping.keys.sort_by { |key| key.to_s })
+    end
+
+    it "severity" do
+      severity = 'foo'
+      raw_data = {'severity_xmlrpc' => severity}
+      @bug.stub(:raw_data).and_return(raw_data)
+      expect(@bug.severity).to eq(severity)
+    end
+
+    it "comments" do
+      comments_hash = [{'id' => 1}]
+      raw_data = {'comments' => comments_hash}
+      @bug.stub(:raw_data).and_return(raw_data)
+      comments = @bug.comments
+      expect(comments).to be_kind_of(Array)
+      expect(comments.count).to eq(1)
+      expect(comments.first).to be_kind_of(ActiveBugzilla::Comment)
+    end
+
+  end
+end

data/spec/active_bugzilla/comment_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe ActiveBugzilla::Comment do
+  before(:each) do
+    @author        = 'author@example.com'
+    @bug_id        = 123
+    @count         = 0
+    @id            = 42
+    @text          = "This is a comment"
+    @is_private    = true
+
+    @bug_comment = described_class.new(
+                     'author'     => @author,
+                     'bug_id'     => @bug_id,
+                     'count'      => @count,
+                     'id'         => @id,
+                     'text'       => @text,
+                     'is_private' => @is_private)
+  end
+
+  it "#private?" do
+    expect(@bug_comment.private?).to eq(@is_private)
+  end
+
+  it "#created_by" do
+    expect(@bug_comment.created_by).to eq(@author)
+  end
+
+  it "#bug_id" do
+    expect(@bug_comment.bug_id).to eq(@bug_id)
+  end
+
+  it "#id" do
+    expect(@bug_comment.id).to eq(@id)
+  end
+
+  it "#text" do
+    expect(@bug_comment.text).to eq(@text)
+  end
+
+end

data/spec/active_bugzilla/service_spec.rb

@@ -0,0 +1,165 @@
+require 'spec_helper'
+
+describe ActiveBugzilla::Service do
+  let(:bz) { described_class.new("http://uri.to/bugzilla", "calvin", "hobbes") }
+
+  context "#new" do
+    it 'normal case' do
+      expect { bz }.to_not raise_error
+    end
+
+    it "when bugzilla_uri is invalid" do
+      expect { described_class.new("lalala", "", "") }.to raise_error(URI::BadURIError)
+    end
+
+    it "when username and password are not set" do
+      expect { described_class.new("http://uri.to/bugzilla", nil, nil) }.to raise_error(ArgumentError)
+    end
+  end
+
+  context "#get" do
+    it "when no argument is specified" do
+      expect { bz.get }.to raise_error(ArgumentError)
+    end
+
+    it "when an invalid argument is specified" do
+      expect { bz.get("not a Fixnum") }.to raise_error(ArgumentError)
+    end
+
+    it "when the specified bug does not exist" do
+      output = {}
+
+      allow(::XMLRPC::Client).to receive(:new).and_return(double('xmlrpc_client', :call => output))
+      matches = bz.get(94897099)
+      expect(matches).to be_kind_of(Array)
+      expect(matches).to be_empty
+    end
+
+    it "when producing valid output" do
+      output = {
+        'bugs' => [
+          {
+            "priority" => "unspecified",
+            "keywords" => ["ZStream"],
+            "cc"       => ["calvin@redhat.com", "hobbes@RedHat.com"],
+          },
+        ]
+      }
+
+      allow(::XMLRPC::Client).to receive(:new).and_return(double('xmlrpc_client', :call => output))
+      existing_bz = bz.get("948972").first
+
+      expect(bz.last_command).to include("Bug.get")
+
+      expect(existing_bz["priority"]).to eq("unspecified")
+      expect(existing_bz["keywords"]).to eq(["ZStream"])
+      expect(existing_bz["cc"]).to eq(["calvin@redhat.com", "hobbes@RedHat.com"])
+    end
+  end
+
+  context "#clone" do
+    it "when no argument is specified" do
+      expect { bz.clone }.to raise_error(ArgumentError)
+    end
+
+    it "when an invalid argument is specified" do
+      expect { bz.clone("not a Fixnum") }.to raise_error(ArgumentError)
+    end
+
+    it "when the specified bug to clone does not exist" do
+      output = {}
+
+      allow(::XMLRPC::Client).to receive(:new).and_return(double('xmlrpc_client', :call => output))
+      expect { bz.clone(94897099) }.to raise_error
+    end
+
+    it "when producing valid output" do
+      output = {"id" => 948992}
+      existing_bz = {
+        "description"    => "Description of problem:\n\nIt's Broken",
+        "priority"       => "unspecified",
+        "assigned_to"    => "calvin@redhat.com",
+        "target_release" => ["---"],
+        "keywords"       => ["ZStream"],
+        "cc"             => ["calvin@redhat.com", "hobbes@RedHat.com"],
+        "comments"       => [
+          {
+            "is_private"    => false,
+            "count"         => 0,
+            "time"          => XMLRPC::DateTime.new(1969, 7, 20, 16, 18, 30),
+            "bug_id"        => 948970,
+            "author"        => "Calvin@redhat.com",
+            "text"          => "It's Broken and impossible to reproduce",
+            "creation_time" => XMLRPC::DateTime.new(1969, 7, 20, 16, 18, 30),
+            "id"            => 5777871,
+            "creator_id"    => 349490
+          },
+          {
+            "is_private"    => false,
+            "count"         => 1,
+            "time"          => XMLRPC::DateTime.new(1970, 11, 10, 16, 18, 30),
+            "bug_id"        => 948970,
+            "author"        => "Hobbes@redhat.com",
+            "text"          => "Fix Me Now!",
+            "creation_time" => XMLRPC::DateTime.new(1972, 2, 14, 0, 0, 0),
+            "id"            => 5782170,
+            "creator_id"    => 349490
+          },
+        ]
+      }
+
+      described_class.any_instance.stub(:get).and_return([existing_bz])
+      allow(::XMLRPC::Client).to receive(:new).and_return(double('xmlrpc_create', :call => output))
+      new_bz_id = bz.clone("948972")
+
+      expect(bz.last_command).to include("Bug.create")
+
+      expect(new_bz_id).to eq(output["id"])
+    end
+
+    it "when providing override values" do
+      output = {"id" => 948992}
+      existing_bz = {
+        "description"    => "Description of problem:\n\nIt's Broken",
+        "priority"       => "unspecified",
+        "assigned_to"    => "calvin@redhat.com",
+        "target_release" => ["---"],
+        "keywords"       => ["ZStream"],
+        "cc"             => ["calvin@redhat.com", "hobbes@RedHat.com"],
+        "comments"       => [
+          {
+            "is_private"    => false,
+            "count"         => 0,
+            "time"          => XMLRPC::DateTime.new(1969, 7, 20, 16, 18, 30),
+            "bug_id"        => 948970,
+            "author"        => "Buzz.Aldrin@redhat.com",
+            "text"          => "It's Broken and impossible to reproduce",
+            "creation_time" => XMLRPC::DateTime.new(1969, 7, 20, 16, 18, 30),
+            "id"            => 5777871,
+            "creator_id"    => 349490
+          },
+          {
+            "is_private"    => false,
+            "count"         => 1,
+            "time"          => XMLRPC::DateTime.new(1970, 11, 10, 16, 18, 30),
+            "bug_id"        => 948970,
+            "author"        => "Neil.Armstrong@redhat.com",
+            "text"          => "Fix Me Now!",
+            "creation_time" => XMLRPC::DateTime.new(1972, 2, 14, 0, 0, 0),
+            "id"            => 5782170,
+            "creator_id"    => 349490
+          },
+        ]
+      }
+
+      described_class.any_instance.stub(:get).and_return([existing_bz])
+      allow(::XMLRPC::Client).to receive(:new).and_return(double('xmlrpc_create', :call => output))
+      new_bz_id = bz.clone("948972", "assigned_to" => "Ham@NASA.gov", "target_release" => ["2.2.0"])
+
+      expect(bz.last_command).to include("Bug.create")
+
+      expect(new_bz_id).to eq(output["id"])
+    end
+  end
+
+end

data/spec/active_bugzilla_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+describe ActiveBugzilla do
+  it "::VERSION" do
+    described_class::VERSION.should be_kind_of(String)
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,24 @@
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# Require this file using `require "spec_helper"` to ensure that it is only
+# loaded once.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = 'random'
+end
+
+begin
+  require 'coveralls'
+  Coveralls.wear!
+rescue LoadError
+end
+
+require 'active_bugzilla'

metadata

@@ -0,0 +1,187 @@
+--- !ruby/object:Gem::Specification
+name: active_bugzilla
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Joe VLcek
+- Jason Frey
+- Oleg Barenboim
+- Alberto Bellotti
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-03-31 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: coveralls
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activemodel
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: dirty_hashy
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: ActiveBugzilla is an ActiveRecord like interface to the Bugzilla API.
+email:
+- jvlcek@redhat.com
+- jfrey@redhat.com
+- chessbyte@gmail.com
+- abellott@redhat.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/active_bugzilla.rb
+- lib/active_bugzilla/base.rb
+- lib/active_bugzilla/bug.rb
+- lib/active_bugzilla/bug/flags_management.rb
+- lib/active_bugzilla/bug/service_management.rb
+- lib/active_bugzilla/comment.rb
+- lib/active_bugzilla/field.rb
+- lib/active_bugzilla/flag.rb
+- lib/active_bugzilla/service.rb
+- lib/active_bugzilla/version.rb
+- README.md
+- LICENSE.txt
+- spec/active_bugzilla/bug_spec.rb
+- spec/active_bugzilla/comment_spec.rb
+- spec/active_bugzilla/service_spec.rb
+- spec/active_bugzilla_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/ManageIQ/active_bugzilla
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: ActiveBugzilla is an ActiveRecord like interface to the Bugzilla API.
+test_files:
+- spec/active_bugzilla/bug_spec.rb
+- spec/active_bugzilla/comment_spec.rb
+- spec/active_bugzilla/service_spec.rb
+- spec/active_bugzilla_spec.rb
+- spec/spec_helper.rb
+has_rdoc: