zimbra 0.0.4

data/README

@@ -0,0 +1,13 @@
+EXAMPLE USAGE
+=============
+
+Zimbra.url = 'http://example.com:7071/soap/service'
+Zimbra.login('admin@example.com','secret')
+
+d = Zimbra::Domain.create('luser.com')
+
+dl = Zimbra::DistributionList.create('info@luser.com')
+dl.admin_group = true
+dl.save
+
+

data/lib/zimbra.rb

@@ -0,0 +1,55 @@
+$:.unshift(File.join(File.dirname(__FILE__)))
+require 'zimbra/handsoap_service'
+require 'zimbra/auth'
+require 'zimbra/cos'
+require 'zimbra/domain'
+require 'zimbra/distribution_list'
+require 'zimbra/account'
+require 'zimbra/acl'
+require 'zimbra/common_elements'
+
+# Manages a Zimbra SOAP session.  Offers ability to set the endpoint URL, log in, and enable debugging.
+module Zimbra
+  class << self
+
+    # The URL that will be used to contact the Zimbra SOAP service
+    def url
+      @@url
+    end
+    # Sets the URL of the Zimbra SOAP service
+    def url=(url)
+      @@url = url
+    end
+
+    # Turn debugging on/off.  Outputs full SOAP conversations to stdout.
+    #   Zimbra.debug = true
+    #   Zimbra.debug = false
+    def debug=(val)
+      Handsoap::Service.logger = (val ? $stdout : nil)
+      @@debug = val
+    end
+
+    # Whether debugging is enabled
+    def debug
+      @@debug ||= false
+    end
+
+    # Authorization token - obtained after successful login
+    def auth_token
+      @@auth_token
+    end
+
+    # Log into the zimbra SOAP service.  This is required before any other action is performed
+    # If a login has already been performed, another login will not be attempted
+    def login(username, password)
+      return @@auth_token if defined?(@@auth_token) && @@auth_token
+      reset_login(username, password)
+    end
+
+    # re-log into the zimbra SOAP service
+    def reset_login(username, password)
+      puts "Logging into zimbra as #{username}"
+      @@auth_token = Auth.login(username, password)
+    end
+  end
+end

data/lib/zimbra/account.rb

@@ -0,0 +1,155 @@
+module Zimbra
+  class Account
+    class << self
+      def all
+        AccountService.all
+      end
+
+      def find_by_id(id)
+        AccountService.get_by_id(id)
+      end
+
+      def find_by_name(name)
+        AccountService.get_by_name(name)
+      end
+
+      def create(options)
+        account = new(options)
+        AccountService.create(account) 
+      end
+
+      def acl_name
+        'account'
+      end
+    end
+
+    attr_accessor :id, :name, :password, :acls, :cos_id, :delegated_admin
+
+    def initialize(options = {})
+      self.id = options[:id]
+      self.name = options[:name]
+      self.password = options[:password]
+      self.acls = options[:acls] || []
+      self.cos_id = (options[:cos] ? options[:cos].id : options[:cos_id])
+      self.delegated_admin = options[:delegated_admin]
+    end
+
+    def delegated_admin=(val)
+      @delegated_admin = Zimbra::Boolean.read(val) 
+    end
+    def delegated_admin?
+      @delegated_admin
+    end
+
+    def save
+      AccountService.modify(self)
+    end
+
+    def delete
+      AccountService.delete(self)
+    end
+  end
+
+  class AccountService < HandsoapService
+    def all
+      xml = invoke("n2:GetAllAccountsRequest")
+      Parser.get_all_response(xml)
+    end
+
+    def create(account)
+      xml = invoke("n2:CreateAccountRequest") do |message|
+        Builder.create(message, account)
+      end
+      Parser.account_response(xml/"//n2:account")
+    end
+
+    def get_by_id(id)
+      xml = invoke("n2:GetAccountRequest") do |message|
+        Builder.get_by_id(message, id)
+      end
+      return nil if soap_fault_not_found?
+      Parser.account_response(xml/"//n2:account")
+    end
+
+    def get_by_name(name)
+      xml = invoke("n2:GetAccountRequest") do |message|
+        Builder.get_by_name(message, name)
+      end
+      return nil if soap_fault_not_found?
+      Parser.account_response(xml/"//n2:account")
+    end
+
+    def modify(account)
+      xml = invoke("n2:ModifyAccountRequest") do |message|
+        Builder.modify(message, account)
+      end
+      Parser.account_response(xml/'//n2:account')
+    end 
+
+    def delete(dist)
+      xml = invoke("n2:DeleteAccountRequest") do |message|
+        Builder.delete(message, dist.id)
+      end
+    end
+
+    class Builder
+      class << self
+        def create(message, account)
+          message.add 'name', account.name
+          message.add 'password', account.password
+          A.inject(message, 'zimbraCOSId', account.cos_id)
+        end
+        
+        def get_by_id(message, id)
+          message.add 'account', id do |c|
+            c.set_attr 'by', 'id'
+          end
+        end
+
+        def get_by_name(message, name)
+          message.add 'account', name do |c|
+            c.set_attr 'by', 'name'
+          end
+        end
+
+        def modify(message, account)
+          message.add 'id', account.id
+          modify_attributes(message, distribution_list)
+        end
+        def modify_attributes(message, account)
+          if account.acls.empty?
+            ACL.delete_all(message)
+          else
+            account.acls.each do |acl|
+              acl.apply(message)
+            end
+          end
+          Zimbra::A.inject(node, 'zimbraCOSId', account.cos_id)
+          Zimbra::A.inject(node, 'zimbraIsDelegatedAdminAccount', (delegated_admin ? 'TRUE' : 'FALSE'))
+        end
+
+        def delete(message, id)
+          message.add 'id', id
+        end
+      end
+    end
+    class Parser
+      class << self
+        def get_all_response(response)
+          (response/"//n2:account").map do |node|
+            account_response(node)
+          end
+        end
+
+        def account_response(node)
+          id = (node/'@id').to_s
+          name = (node/'@name').to_s
+          acls = Zimbra::ACL.read(node)
+          cos_id = Zimbra::A.read(node, 'zimbraCOSId')
+          delegated_admin = Zimbra::A.read(node, 'zimbraIsDelegatedAdminAccount')
+          Zimbra::Account.new(:id => id, :name => name, :acls => acls, :cos_id => cos_id, :delegated_admin => delegated_admin)
+        end
+      end
+    end
+  end
+end

data/lib/zimbra/acl.rb

@@ -0,0 +1,61 @@
+module Zimbra
+  class ACL
+    class TargetObjectNotFound < StandardError; end
+
+    TARGET_CLASSES = [Zimbra::Domain, Zimbra::DistributionList, Zimbra::Cos]
+    TARGET_MAPPINGS = TARGET_CLASSES.inject({}) do |hsh, klass|
+      hsh[klass.acl_name] = klass
+      hsh[klass] = klass.acl_name
+      hsh
+    end
+
+    class << self
+      def delete_all(xmldoc)
+        A.inject(xmldoc, 'zimbraACE', '', 'c' => '1')
+      end
+
+      def read(node)
+        list = A.read(node, 'zimbraACE')
+        return nil if list.nil?
+        list = [list] unless list.respond_to?(:map)
+        acls = list.map do |ace|
+          from_s(ace)
+        end
+      end
+
+      def from_zimbra(node)
+        from_s(node.to_s)
+      end
+
+      def from_s(value)
+        target_id, target_name, name = value.split(' ')
+        target_class = TARGET_MAPPINGS[target_name]
+        raise TargetObjectNotFound, "Target object not found for acl #{acl_string}" if target_class.nil?
+        new(:target_id => target_id, :target_class => target_class, :name => name)
+      end
+    end
+
+    attr_accessor :target_id, :target_class, :name
+
+    def initialize(options = {})
+      if options[:target]
+        self.target_id = options[:target].id
+        self.target_class = options[:target].class
+      else
+        self.target_id = options[:target_id]
+        self.target_class = options[:target_class]
+      end
+      self.name = options[:name]
+    end
+
+    def to_zimbra_acl_value
+      id = target_id
+      type = target_class.acl_name
+      "#{id} #{type} #{name}" 
+    end
+
+    def apply(xmldoc)
+      A.inject(xmldoc, 'zimbraACE', to_zimbra_acl_value, 'c' => '1')
+    end
+  end
+end

data/lib/zimbra/auth.rb

@@ -0,0 +1,43 @@
+module Zimbra
+  class Auth
+    def self.login(username, password)
+      AuthService.login(username, password)
+    end
+  end
+
+  class AuthService < Handsoap::Service
+    include HandsoapErrors
+    include Zimbra::HandsoapNamespaces
+    extend HandsoapUriOverrides
+
+    def on_create_document(doc)
+      request_namespaces(doc)
+    end
+    def on_response_document(doc)
+      response_namespaces(doc)
+    end
+
+    def login(username, password)
+      xml = invoke('n2:AuthRequest') do |message|
+        Builder.auth(message, username, password)
+      end
+      Parser.auth_token(xml)
+    end
+
+    class Builder
+      class << self
+        def auth(message, username, password)
+          message.add 'name', username
+          message.add 'password', password
+        end
+      end
+    end
+    class Parser
+      class << self
+        def auth_token(response)
+          (response/'//n2:authToken').to_s
+        end
+      end
+    end
+  end
+end

data/lib/zimbra/common_elements.rb

@@ -0,0 +1,51 @@
+module Zimbra
+  class A
+    class << self
+      def inject(xmldoc, name, value, extra_attributes = {})
+        new(name, value, extra_attributes).inject(xmldoc)
+      end
+      
+      def read(xmldoc, name)
+        nodes = (xmldoc/"//n2:a[@n='#{name}']")
+        return nil if nodes.nil?
+        if nodes.size > 1
+          nodes.map { |n| from_node(n, name).value }
+        else
+          from_node(nodes, name).value
+        end
+      end
+
+      def from_node(node, name)
+        new(name, node.to_s)
+      end
+    end
+
+    attr_accessor :name, :value, :extra_attributes
+
+    def initialize(name, value, extra_attributes = {})
+      self.name = name
+      self.value = value
+      self.extra_attributes = extra_attributes || {}
+    end
+
+    def inject(xmldoc)
+      xmldoc.add 'a', value do |a|
+        a.set_attr 'n', name
+        extra_attributes.each do |eaname, eavalue|
+          a.set_attr eaname, eavalue
+        end
+      end
+    end
+  end
+
+  class Boolean
+    def self.read(value)
+      case value
+      when 'TRUE' then true
+      when 'FALSE' then false
+      when true then true
+      else false
+      end
+    end
+  end
+end

data/lib/zimbra/cos.rb

@@ -0,0 +1,124 @@
+module Zimbra
+  class Cos
+    class << self
+      def find_by_id(id)
+        CosService.get_by_id(id)
+      end
+
+      def find_by_name(name)
+        CosService.get_by_name(name)
+      end
+
+      def create(name)
+        CosService.create(name)
+      end
+
+      def acl_name
+        'cos'
+      end
+    end
+
+    attr_accessor :id, :name, :acls
+
+    def initialize(id, name, acls = [])
+      self.id = id
+      self.name = name
+      self.acls = acls || []
+    end
+
+    def save
+      CosService.modify(self)
+    end
+    
+    def delete
+      CosService.delete(self)
+    end
+  end
+
+  class CosService < HandsoapService
+    def get_by_id(id)
+      response = invoke("n2:GetCosRequest") do |message|
+        Builder.get_by_id(message, id)
+      end
+      return nil if soap_fault_not_found?
+      Parser.cos_response(response/"//n2:cos")
+    end 
+
+    def get_by_name(name)
+      response = invoke("n2:GetCosRequest") do |message|
+        Builder.get_by_name(message, name)
+      end
+      return nil if soap_fault_not_found?
+      Parser.cos_response(response/"//n2:cos")
+    end 
+
+    def create(name)
+      response = invoke("n2:CreateCosRequest") do |message|
+        Builder.create(message, name)
+      end
+      Parser.cos_response(response/"//n2:cos")
+    end
+
+    def modify(cos)
+      xml = invoke("n2:ModifyCosRequest") do |message|
+        Builder.modify(message, cos)
+      end
+      Parser.cos_response(xml/'//n2:cos')
+    end 
+
+    def delete(cos)
+      xml = invoke("n2:DeleteCosRequest") do |message|
+        Builder.delete(message, cos)
+      end
+    end
+
+    class Builder
+      class << self
+        def get_by_id(message, id)
+          message.add 'cos', id do |c|
+            c.set_attr 'by', 'id'
+          end
+        end
+
+        def get_by_name(message, name)
+          message.add 'cos', name do |c|
+            c.set_attr "by", 'name'
+          end
+        end
+
+        def create(message, name)
+          message.add 'name', name
+        end
+
+        def modify(message, cos)
+          message.add 'id', cos.id
+          modify_attributes(message, cos)
+        end
+        def modify_attributes(message, cos)
+          if cos.acls.empty?
+            ACL.delete_all(message)
+          else
+            cos.acls.each do |acl|
+              acl.apply(message)
+            end
+          end
+        end
+
+        def delete(message, cos)
+          message.add 'id', cos.id
+        end
+      end
+    end
+
+    class Parser
+      class << self
+        def cos_response(node)
+          id = (node/'@id').to_s
+          name = (node/'@name').to_s
+          acls = Zimbra::ACL.read(node)
+          Zimbra::Cos.new(id, name, acls) 
+        end
+      end
+    end
+  end
+end

data/lib/zimbra/distribution_list.rb

@@ -0,0 +1,207 @@
+module Zimbra
+  class DistributionList
+    class << self
+      def all
+        DistributionListService.all
+      end
+
+      def find_by_id(id)
+        DistributionListService.get_by_id(id)
+      end
+
+      def find_by_name(name)
+        DistributionListService.get_by_name(name)
+      end
+
+      def create(name)
+        DistributionListService.create(name)
+      end
+
+      def acl_name
+        'grp'
+      end
+    end
+
+    attr_accessor :id, :name, :admin_console_ui_components, :admin_group, :members
+
+    def initialize(options = {})
+      options.each { |name, value| self.send("#{name}=", value) }
+      @original_members = self.members.dup
+    end
+
+    def admin_console_ui_components
+      @admin_console_ui_components ||= []
+    end
+
+    def members
+      @members ||= []
+    end
+
+    def new_members
+      self.members - @original_members
+    end
+
+    def removed_members
+      @original_members - self.members
+    end
+
+    def admin_group=(val)
+      @admin_group = Zimbra::Boolean.read(val) 
+    end
+    def admin_group?
+      @admin_group
+    end
+
+    def delete
+      DistributionListService.delete(self)
+    end
+
+    def save
+      DistributionListService.modify(self)
+    end
+  end
+
+  class DistributionListService < HandsoapService
+    def all
+      xml = invoke("n2:GetAllDistributionListsRequest")
+      Parser.get_all_response(xml)
+    end
+
+    def get_by_id(id)
+      xml = invoke("n2:GetDistributionListRequest") do |message|
+        Builder.get_by_id(message, id)
+      end
+      return nil if soap_fault_not_found?
+      Parser.distribution_list_response(xml/'//n2:dl')
+    end
+
+    def get_by_name(name)
+      xml = invoke("n2:GetDistributionListRequest") do |message|
+        Builder.get_by_name(message, name)
+      end
+      return nil if soap_fault_not_found?
+      Parser.distribution_list_response(xml/'//n2:dl')
+    end
+
+    def create(name)
+      xml = invoke("n2:CreateDistributionListRequest") do |message|
+        Builder.create(message, name)
+      end
+      Parser.distribution_list_response(xml/'//n2:dl')
+    end
+
+    def modify(dist)
+      xml = invoke("n2:ModifyDistributionListRequest") do |message|
+        Builder.modify(message, dist)
+      end
+      Parser.distribution_list_response(xml/'//n2:dl')
+
+      modify_members(dist)
+    end 
+
+    def modify_members(distribution_list)
+      distribution_list.new_members.each do |member|
+        add_member(distribution_list, member)
+      end
+      distribution_list.removed_members.each do |member|
+        remove_member(distribution_list, member)
+      end
+    end
+
+    def add_member(distribution_list, member)
+      xml = invoke("n2:AddDistributionListMemberRequest") do |message|
+        Builder.add_member(message, distribution_list.id, member)
+      end
+    end
+
+    def remove_member(distribution_list, member)
+      xml = invoke("n2:RemoveDistributionListMemberRequest") do |message|
+        Builder.remove_member(message, distribution_list.id, member)
+      end
+    end
+
+    def delete(dist)
+      xml = invoke("n2:DeleteDistributionListRequest") do |message|
+        Builder.delete(message, dist.id)
+      end
+    end
+
+    module Builder
+      class << self
+        def create(message, name)
+          message.add 'name', name
+        end
+
+        def get_by_id(message, id)
+          message.add 'dl', id do |d|
+            d.set_attr 'by', 'id'
+          end
+        end
+
+        def get_by_name(message, name)
+          message.add 'dl', name do |d|
+            d.set_attr "by", 'name'
+          end
+        end
+
+        def modify(message, distribution_list)
+          message.add 'id', distribution_list.id
+          modify_attributes(message, distribution_list)
+        end
+
+        def modify_attributes(message, distribution_list)
+          modify_admin_console_ui_components(message, distribution_list)
+          modify_is_admin_group(message, distribution_list)
+        end
+
+        def modify_admin_console_ui_components(message, distribution_list)
+          if distribution_list.admin_console_ui_components.empty?
+            A.inject(message, 'zimbraAdminConsoleUIComponents', '')
+          else
+            distribution_list.admin_console_ui_components.each do |component|
+              A.inject(message, 'zimbraAdminConsoleUIComponents', component)
+            end
+          end
+        end
+
+        def modify_is_admin_group(message, distribution_list)
+          A.inject(message, 'zimbraIsAdminGroup', (distribution_list.admin_group? ? 'TRUE' : 'FALSE'))
+        end
+
+        def add_member(message, distribution_list_id, member)
+          message.add 'id', distribution_list_id
+          message.add 'dlm', member
+        end
+
+        def remove_member(message, distribution_list_id, member)
+          message.add 'id', distribution_list_id
+          message.add 'dlm', member
+        end
+
+        def delete(message, id)
+          message.add 'id', id
+        end
+      end
+    end
+    module Parser
+      class << self
+        def get_all_response(response)
+          items = response/"//n2:dl"
+          items.map { |i| distribution_list_response(i) }
+        end
+
+        def distribution_list_response(node)
+          id = (node/'@id').to_s
+          name = (node/'@name').to_s
+          ui_components = A.read(node, 'zimbraAdminConsoleUIComponents')
+          admin_group = A.read(node, 'zimbraIsAdminGroup')
+          members = (node/"//n2:dlm").map { |n| n.to_s }
+
+          Zimbra::DistributionList.new(:id => id, :name => name,
+            :admin_console_ui_components => ui_components, :admin_group => admin_group,
+            :members => members)
+        end
+      end
+    end
+  end
+end

data/lib/zimbra/domain.rb

@@ -0,0 +1,138 @@
+module Zimbra
+  class Domain
+    class << self
+      def all
+        DomainService.all
+      end
+
+      def find_by_id(id)
+        DomainService.get_by_id(id)
+      end
+
+      def find_by_name(name)
+        DomainService.get_by_name(name)
+      end
+
+      def create(name, attributes = {})
+        DomainService.create(name, attributes) 
+      end
+
+      def acl_name
+        'domain'
+      end
+    end
+
+    attr_accessor :id, :name, :acls
+
+    def initialize(id, name, acls = [])
+      self.id = id 
+      self.name = name
+      self.acls = acls || []
+    end
+
+    def save
+      DomainService.modify(self)
+    end
+
+    def delete
+      DomainService.delete(self)
+    end
+  end
+  
+  class DomainService < HandsoapService
+    def all
+      xml = invoke("n2:GetAllDomainsRequest")
+      Parser.get_all_response(xml)
+    end
+
+    def create(name, attributes = {})
+      xml = invoke("n2:CreateDomainRequest") do |message|
+        Builder.create(message, name)
+      end
+      Parser.domain_response(xml/"//n2:domain")
+    end
+
+    def get_by_id(id)
+      xml = invoke("n2:GetDomainRequest") do |message|
+        Builder.get_by_id(message, id)
+      end
+      return nil if soap_fault_not_found?
+      Parser.domain_response(xml/"//n2:domain")
+    end
+
+    def get_by_name(name)
+      xml = invoke("n2:GetDomainRequest") do |message|
+        Builder.get_by_name(message, name)
+      end
+      return nil if soap_fault_not_found?
+      Parser.domain_response(xml/"//n2:domain")
+    end
+
+    def modify(domain)
+      xml = invoke("n2:ModifyDomainRequest") do |message|
+        Builder.modify(message, domain)
+      end
+      Parser.domain_response(xml/'//n2:domain')
+    end 
+
+    def delete(dist)
+      xml = invoke("n2:DeleteDomainRequest") do |message|
+        Builder.delete(message, dist.id)
+      end
+    end
+
+    class Builder
+      class << self
+        def create(message, name)
+          message.add 'name', name
+        end
+        
+        def get_by_id(message, id)
+          message.add 'domain', id do |c|
+            c.set_attr 'by', 'id'
+          end
+        end
+
+        def get_by_name(message, name)
+          message.add 'domain', name do |c|
+            c.set_attr 'by', 'name'
+          end
+        end
+
+        def modify(message, domain)
+          message.add 'id', domain.id
+          modify_attributes(message, domain)
+        end
+        def modify_attributes(message, domain)
+          if domain.acls.empty?
+            ACL.delete_all(message)
+          else
+            domain.acls.each do |acl|
+              acl.apply(message)
+            end
+          end
+        end
+
+        def delete(message, id)
+          message.add 'id', id
+        end
+      end
+    end
+    class Parser
+      class << self
+        def get_all_response(response)
+          (response/"//n2:domain").map do |node|
+            domain_response(node)
+          end
+        end
+
+        def domain_response(node)
+          id = (node/'@id').to_s
+          name = (node/'@name').to_s
+          acls = Zimbra::ACL.read(node)
+          Zimbra::Domain.new(id, name, acls) 
+        end
+      end
+    end
+  end
+end

data/lib/zimbra/handsoap_service.rb

@@ -0,0 +1,73 @@
+require 'handsoap'
+
+module Zimbra
+  module HandsoapErrors
+    class SOAPFault < StandardError; end
+
+    @@response = nil
+
+    def on_http_error(response)
+      @@response = response
+      return nil if soap_fault_not_found?
+      report_error(response) if http_error?
+    end
+    def report_error(response)
+      message = response.body.scan(/<soap:faultstring>(.*)<\/soap:faultstring>/).first
+      raise SOAPFault, message
+    end
+    def on_after_create_http_request(request)
+      @@response = nil
+    end
+
+    def soap_fault_not_found?
+      @@response && @@response.body =~ /no such/
+    end
+    def http_error?
+      @@response && (500..599).include?(@@response.status)
+    end
+    def http_not_found?
+      @@response && (400..499).include?(@@response.status)
+    end
+  end
+
+  module HandsoapNamespaces
+    def request_namespaces(doc)
+      doc.alias 'n1', "urn:zimbra"
+      doc.alias 'n2', "urn:zimbraAdmin"
+      doc.alias 'env', 'http://schemas.xmlsoap.org/soap/envelope/'
+    end
+    def response_namespaces(doc)
+      doc.add_namespace 'n2', "urn:zimbraAdmin"
+    end
+  end
+  
+  module HandsoapUriOverrides
+    def uri
+      Zimbra.url
+    end
+    def envelope_namespace
+      'http://www.w3.org/2003/05/soap-envelope'
+    end
+    def request_content_type
+      "application/soap+xml"
+    end
+  end
+
+  class HandsoapService < Handsoap::Service
+    include HandsoapErrors
+    include HandsoapNamespaces
+    extend HandsoapUriOverrides
+
+    def on_create_document(doc)
+      request_namespaces(doc)
+      header = doc.find("Header")
+      header.add "n1:context" do |s|
+        s.set_attr "env:mustUnderstand", "0"
+        s.add "n1:authToken", Zimbra.auth_token
+      end
+    end
+    def on_response_document(doc)
+      response_namespaces(doc)
+    end
+  end
+end

metadata

@@ -0,0 +1,104 @@
+--- !ruby/object:Gem::Specification 
+name: zimbra
+version: !ruby/object:Gem::Version 
+  hash: 23
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 4
+  version: 0.0.4
+platform: ruby
+authors: 
+- Derek Kastner
+- Matt Wilson
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-11-18 00:00:00 -05:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: handsoap
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id002
+description: Interface to Zimbra management API
+email: derek@vedit.com mwilson@vedit.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- README
+- lib/zimbra/account.rb
+- lib/zimbra/acl.rb
+- lib/zimbra/auth.rb
+- lib/zimbra/common_elements.rb
+- lib/zimbra/cos.rb
+- lib/zimbra/distribution_list.rb
+- lib/zimbra/domain.rb
+- lib/zimbra/handsoap_service.rb
+- lib/zimbra.rb
+has_rdoc: true
+homepage: 
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 2
+summary: SOAP Interface to Zimbra
+test_files: []
+