rews 0.1.0

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Trampoline Systems Ltd
+
+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.rdoc

@@ -0,0 +1,52 @@
+= rews
+
+Rews is a simple Ruby client for Exchange Web Services. 
+
+* Searching, fetching and deletion are supported.
+* Filtering, ordering, and arbitrary property retrieval are supported.
+* Bulk operations are supported
+
+Method names generally follow the Exchange Web Services API
+http://msdn.microsoft.com/en-us/library/bb409286(EXCHG.140).aspx 
+
+to use : 
+
+  # create a client
+  c = Rews::Client.new("https://exchange.bar.com/EWS/Exchange.asmx", :ntlm, 'EXCHDOM\foo', 'password')
+
+  # find a distinguished folder from any one of the mailboxes the user has permissions for
+  inbox=c.distinguished_folder_id('inbox', 'foo@bar.com')
+
+  # find some message_ids, 
+  mids = inbox.find_item_id(:restriction=>[:<=, "item:DateTimeReceived",DateTime.now], 
+                            :sort_order=>[["item:DateTimeReceived", "Ascending"]],
+                            :indexed_page_item_view=>{:max_entries_returned=>10, :offset=>0})
+
+  # get some properties for a bunch of messages in one hit
+  messages = inbox.get_item(mids, :item_shape=>{
+                                    :base_shape=>:IdOnly,
+                                    :additional_properties=>[
+                                      [:field_uri, "item:Subject"],
+                                      [:field_uri, "item:DateTimeReceived"],
+                                      [:field_uri, "message:InternetMessageId"]]})
+
+  # delete the items to the DeletedItems folder
+  inbox.delete_item(mids, :delete_type=>:MoveToDeletedItems)
+
+== Install
+
+  gem install rews
+
+== Note on Patches/Pull Requests
+ 
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Commit, do not mess with rakefile, version, or history.
+  (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+== Copyright
+
+Copyright (c) 2011 Trampoline Systems Ltd. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,50 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "rews"
+    gem.summary = %Q{a Ruby client for Exchange Web Services}
+    gem.description = %Q{an email focussed Ruby client for Exchange Web Services atop Savon}
+    gem.email = "craig@trampolinesystems.com"
+    gem.homepage = "http://github.com/trampoline/rews"
+    gem.authors = ["Trampoline Systems Ltd"]
+    gem.add_dependency "savon", ">= 0.8.6"
+    gem.add_dependency "ntlm-http", ">= 0.1.1"
+    gem.add_dependency "httpclient", ">= 2.1.6.1.1"
+    gem.add_dependency "fetch_in", ">= 0.2.0"
+    gem.add_development_dependency "rspec", ">= 1.2.9"
+    gem.add_development_dependency "rr", ">= 0.10.5"
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+
+require 'spec/rake/spectask'
+Spec::Rake::SpecTask.new(:spec) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+Spec::Rake::SpecTask.new(:rcov) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :spec => :check_dependencies
+
+task :default => :spec
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "rews #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/lib/rews/folder.rb

@@ -0,0 +1,274 @@
+module Rews
+  module Folder
+    class Folder
+      attr_reader :client
+      attr_reader :folder_id
+      attr_reader :attributes
+
+      def initialize(client, folder)
+        @folder_id = VanillaFolderId.new(client, folder[:folder_id])
+        @attributes = folder
+      end
+
+      def [](key)
+        @attributes[key]
+      end
+
+      def keys
+        @attributes.keys
+      end
+    end
+
+    class FindResult
+      VIEW_ATTRS = [:includes_last_item_in_range,
+                    :indexed_paging_offset,
+                    :total_items_in_view]
+
+      VIEW_ATTRS.each do |attr|
+        attr_reader attr
+      end
+      attr_reader :result
+
+      def initialize(view, &proc)
+        VIEW_ATTRS.each do |attr|
+          self.instance_variable_set("@#{attr}", view[attr])
+        end
+        @result = proc.call(view) if proc
+      end
+
+      def length
+        result.length
+      end
+
+      def size
+        result.size
+      end
+
+      def [](key)
+        result[key]
+      end
+    end
+
+    class BaseFolderId
+      include Util
+      
+      attr_reader :client
+
+      def initialize(client)
+        @client=client
+      end
+
+      FIND_FOLDER_OPTS = {
+        :restriction=>nil,
+        :indexed_page_folder_view=>View::INDEXED_PAGE_VIEW_OPTS,
+        :folder_shape=>Shape::FOLDER_SHAPE_OPTS}
+
+      def find_folder(opts={})
+        opts = check_opts(FIND_FOLDER_OPTS, opts)
+
+        r = with_error_check(client, :find_folder_response, :response_messages, :find_folder_response_message) do
+          client.request(:wsdl, "FindFolder", "Traversal"=>"Shallow") do
+            soap.namespaces["xmlns:t"]=SCHEMA_TYPES
+            xml = Builder::XmlMarkup.new
+            
+            xml << Shape::FolderShape.new(opts[:folder_shape]||{}).to_xml
+            xml << View::IndexedPageFolderView.new(opts[:indexed_page_folder_view]).to_xml if opts[:indexed_page_folder_view]
+            xml << Restriction.new(opts[:restriction]).to_xml if opts[:restriction]
+            
+            xml.wsdl :ParentFolderIds do
+              xml << Gyoku.xml(self.to_xml_hash)
+            end
+            soap.body = xml.target!
+          end
+        end
+
+        FindResult.new(r.fetch_in(:root_folder)) do |view|
+          results = view.fetch_in(:folders, :folder)
+          results = [results] if !results.is_a?(Array)
+          results.compact.map do |folder|
+            Folder.new(client, folder)
+          end
+        end
+      end
+
+      def find_folder_id(opts={})
+        opts = check_opts(FIND_FOLDER_OPTS, opts)
+
+        shape = opts[:folder_shape] ||={} 
+        shape[:base_shape]||=:IdOnly
+
+        r = find_folder(opts)
+        r.result.map!(&:folder_id)
+        r
+      end
+
+      FIND_ITEM_OPTS = {
+        :restriction=>nil,
+        :sort_order=>nil,
+        :indexed_page_item_view=>View::INDEXED_PAGE_VIEW_OPTS,
+        :item_shape=>Shape::ITEM_SHAPE_OPTS}
+
+      # find message-ids in a folder
+      def find_item(opts={})
+        opts = check_opts(FIND_ITEM_OPTS, opts)
+
+        r = with_error_check(client, :find_item_response, :response_messages, :find_item_response_message) do
+          client.request(:wsdl, "FindItem", "Traversal"=>"Shallow") do
+            soap.namespaces["xmlns:t"]=SCHEMA_TYPES
+            
+            xml = Builder::XmlMarkup.new
+            
+            xml << Shape::ItemShape.new(opts[:item_shape]||{}).to_xml
+            xml << View::IndexedPageItemView.new(opts[:indexed_page_item_view]).to_xml if opts[:indexed_page_item_view]
+            xml << Restriction.new(opts[:restriction]).to_xml if opts[:restriction]
+            xml << SortOrder.new(opts[:sort_order]).to_xml if opts[:sort_order]
+
+            xml.wsdl :ParentFolderIds do
+              xml << Gyoku.xml(self.to_xml_hash)
+            end
+
+            soap.body = xml.target!
+          end
+        end
+        
+        FindResult.new(r.to_hash.fetch_in(:root_folder)) do |view|
+          results = Item.read_items(client, view[:items])
+        end
+      end
+
+      def find_item_id(opts={})
+        opts = check_opts(FIND_ITEM_OPTS, opts)
+
+        shape = opts[:item_shape] ||= {}
+        shape[:base_shape]||=:IdOnly
+
+        r = find_item(opts)
+        r.result.map!(&:item_id)
+        r
+      end
+
+      GET_ITEM_OPTS = {
+        :item_shape=>Shape::ITEM_SHAPE_OPTS,
+        :ignore_change_keys=>nil
+      }
+
+      # get a bunch of messages in one api hit
+      def get_item(message_ids, opts={})
+        opts = check_opts(GET_ITEM_OPTS, opts)
+        message_ids = message_ids.result if message_ids.is_a?(FindResult)
+
+        r = with_error_check(client, :get_item_response,:response_messages,:get_item_response_message) do
+          client.request(:wsdl, "GetItem") do
+            soap.namespaces["xmlns:t"]=SCHEMA_TYPES
+            
+            xml = Builder::XmlMarkup.new
+
+            xml << Shape::ItemShape.new(opts[:item_shape]||{}).to_xml
+            xml.wsdl :ItemIds do
+              message_ids.each do |mid|
+                xml << Gyoku.xml(mid.to_xml_hash(opts[:ignore_change_keys]))
+              end
+            end
+
+            soap.body = xml.target!
+          end
+        end
+        Item.read_get_item_response_messages(client, r)
+      end
+
+      DELETE_ITEM_OPTS = {
+        :delete_type! =>nil,
+        :ignore_change_keys=>false
+      }
+
+      def delete_item(message_ids, opts={})
+        opts = check_opts(DELETE_ITEM_OPTS, opts)
+        message_ids = message_ids.result if message_ids.is_a?(FindResult)
+
+        r = with_error_check(client, :delete_item_response, :response_messages, :delete_item_response_message) do
+          client.request(:wsdl, "DeleteItem", :DeleteType=>opts[:delete_type]) do
+            soap.namespaces["xmlns:t"]=SCHEMA_TYPES
+            
+            xml = Builder::XmlMarkup.new
+
+            xml.wsdl :ItemIds do
+              message_ids.each do |mid|
+                xml << Gyoku.xml(mid.to_xml_hash(opts[:ignore_change_keys]))
+              end
+            end
+
+            soap.body = xml.target!
+          end
+        end
+        true
+      end
+    end
+
+    class VanillaFolderId < BaseFolderId
+      attr_reader :id
+      attr_reader :change_key
+
+      def initialize(client, folder_id)
+        super(client)
+        @id=folder_id[:id]
+        @change_key=folder_id[:change_key]
+        raise "no id" if !@id
+      end
+
+      def to_xml_hash
+        if change_key
+          {
+            "t:FolderId"=>"",
+            :attributes! => {
+              "t:FolderId" => {
+                "Id" => id.to_s,
+                "ChangeKey" => change_key.to_s}}}
+        else
+          {
+            "t:FolderId"=>"",
+            :attributes! => {
+              "t:FolderId" => {
+                "Id" => id.to_s}}}
+        end
+      end
+
+      def inspect
+        "#{self.class}(id: #{id}, change_key: #{change_key})"
+      end
+    end
+
+    class DistinguishedFolderId < BaseFolderId
+      attr_reader :id
+      attr_reader :mailbox_email
+
+      def initialize(client, id, mailbox_email=nil)
+        super(client)
+        @id = id
+        @mailbox_email = mailbox_email
+        raise "no id" if !@id
+      end
+
+      def to_xml_hash
+        {
+          "t:DistinguishedFolderId"=>mailbox_xml_hash,
+          :attributes! => {"t:DistinguishedFolderId"=>{"Id"=>id}}}
+      end
+
+      def inspect
+        "#{self.class}(id: #{id}, mailbox_email: #{mailbox_email})"
+      end
+
+      private
+
+      def mailbox_xml_hash
+        if mailbox_email
+          {
+            "t:Mailbox"=>{
+              "t:EmailAddress"=>mailbox_email}}
+        else
+          ""
+        end
+      end
+    end
+  end
+end

data/lib/rews/item.rb

@@ -0,0 +1,127 @@
+module Rews
+  module Item
+    module_function
+
+    # return a list of Item objects given a hash formed from an Items element
+    def read_items(client, items)
+      items.map do |item_class,items_of_class|
+        items_of_class = [items_of_class] if !items_of_class.is_a?(Array)
+        items_of_class.map do |item|
+          Item.new(client, item_class, item)
+        end
+      end.flatten
+    end
+
+    # return a list of Item objects from a list of GetItemResponseMessages
+    def read_get_item_response_messages(client, get_item_response_messages)
+      get_item_response_messages = [get_item_response_messages] if !get_item_response_messages.is_a?(Array)
+      items = get_item_response_messages.map do |girm|
+        read_items(client, girm[:items])
+      end.flatten
+    end
+
+    class Item
+      attr_reader :client
+      attr_reader :item_id
+      attr_reader :item_class
+      attr_reader :attributes
+      
+      def initialize(client, item_class, attributes)
+        @item_id = ItemId.new(client, attributes[:item_id])
+        @item_class = item_class
+        @attributes = attributes
+      end
+
+      def [](key)
+        @attributes[key]
+      end
+
+      def keys
+        @attributes.keys
+      end
+    end
+
+    class ItemId
+      include Util
+
+      attr_reader :client
+      attr_reader :id
+      attr_reader :change_key
+      
+      def initialize(client, item_id)
+        @client=client
+        @id = item_id[:id]
+        @change_key=item_id[:change_key]
+        raise "no id" if !@id
+      end
+
+      GET_ITEM_OPTS = {
+        :item_shape=>Shape::ITEM_SHAPE_OPTS,
+        :ignore_change_keys=>nil
+      }
+
+      def get_item(opts={})
+        opts = check_opts(GET_ITEM_OPTS, opts)
+        r = with_error_check(client, :get_item_response,:response_messages,:get_item_response_message) do
+          client.request(:wsdl, "GetItem") do
+            soap.namespaces["xmlns:t"]=SCHEMA_TYPES
+            
+            xml = Builder::XmlMarkup.new
+            
+            xml << Shape::ItemShape.new(opts[:item_shape]||{}).to_xml
+            xml.wsdl :ItemIds do
+              xml << Gyoku.xml(self.to_xml_hash(opts[:ignore_change_keys]))
+            end
+            
+            soap.body = xml.target!
+          end
+        end
+        ::Rews::Item.read_get_item_response_messages(client, r).first
+      end
+
+      DELETE_ITEM_OPTS = {
+        :delete_type! =>nil,
+        :ignore_change_keys=>false
+      }
+
+      def delete_item(opts={})
+        opts = check_opts(DELETE_ITEM_OPTS, opts)
+        r = with_error_check(client, :delete_item_response, :response_messages, :delete_item_response_message) do
+          client.request(:wsdl, "DeleteItem", :DeleteType=>opts[:delete_type]) do
+            soap.namespaces["xmlns:t"]=SCHEMA_TYPES
+            
+            xml = Builder::XmlMarkup.new
+            
+            xml.wsdl :ItemIds do
+              xml << Gyoku.xml(self.to_xml_hash(opts[:ignore_change_keys]))
+            end
+            
+            soap.body = xml.target!
+          end
+        end
+        true
+      end
+
+      def to_xml_hash(ignore_change_key=false)
+        if change_key && !ignore_change_key
+          {
+            "t:ItemId"=>"",
+            :attributes! => {
+              "t:ItemId" => {
+                "Id" => id.to_s,
+                "ChangeKey" => change_key.to_s}}}
+        else
+          {
+            "t:ItemId"=>"",
+            :attributes! => {
+              "t:ItemId" => {
+                "Id" => id.to_s}}}
+        end
+      end
+
+      def inspect
+        "#{self.class}(id: #{id}, change_key: #{change_key})"
+      end
+    end
+  end
+end

data/lib/rews/restriction.rb

@@ -0,0 +1,89 @@
+# takes restrictions written in Ruby s-expressions and 
+# outputs Exchange Web Services Restriction XML
+#
+#
+module Rews
+  class Restriction
+
+    attr_reader :expr
+
+    def initialize(expr)
+      @expr = expr
+    end
+
+    def inspect
+      "#{self.class}: #{@expr.inspect}"
+    end
+
+    def to_xml
+      Xml::write_restriction(expr)
+    end
+
+    module Xml
+      module_function
+
+      def write_restriction(expr)
+        xml = Builder::XmlMarkup.new
+        xml.wsdl :Restriction do
+          write_expr(xml, expr)
+        end
+        xml.target!
+      end
+
+      def write_expr(xml, expr)
+        case expr[0]
+        when :<, :<=, :==, :>=, :>, :"!=" then
+          write_comparison(xml, expr)
+        when :and, :or, :not then
+          write_logical(xml, expr)
+        else
+          raise "unknown operator: #{expr[0]}"
+        end
+      end
+
+      COMPARISON_OPS = {
+        :< => :IsLessThan,
+        :<= => :IsLessThanOrEqualTo,
+        :== => :IsEqualTo,
+        :>= => :IsGreaterThanOrEqualTo,
+        :> => :IsGreaterThan,
+        :"!=" => :IsNotEqualTo}
+      
+      def write_comparison(xml, expr)
+        xml.t COMPARISON_OPS[expr[0]] do
+          write_field_uri(xml, expr[1])
+          write_field_uri_or_constant(xml, expr[2])
+        end
+      end
+
+      def write_field_uri_or_constant(xml, expr)
+        xml.t :FieldURIOrConstant do
+          if expr.is_a?(Array) && expr[0] == :field_uri
+            write_field_uri(xml, expr[1])
+          else
+            write_constant(xml, expr)
+          end
+        end
+      end
+
+      def write_field_uri(xml, expr)
+        xml.t :FieldURI, :FieldURI=>expr
+      end
+
+      def write_constant(xml, expr)
+        xml.t :Constant, :Value=>expr
+      end
+
+      LOGICAL_OPS = {
+        :and => :And,
+        :or => :Or,
+        :not => :Not
+      }
+      def write_logical(xml, expr)
+        xml.t LOGICAL_OPS[expr[0]] do
+          write_xml(xml ,expr[1..-1])
+        end
+      end
+    end
+  end
+end

data/lib/rews/shape.rb

@@ -0,0 +1,70 @@
+module Rews
+  module Shape
+
+    module Xml
+      module_function
+
+      def write_shape(shape_type, &proc)
+        xml = Builder::XmlMarkup.new
+        xml.wsdl shape_type do
+          proc.call(xml)
+        end
+        xml.target!
+      end
+
+      def write_additional_properties(xml, additional_properties)
+        return if !additional_properties
+        xml.t :AdditionalProperties do
+          additional_properties.each do |additional_property|
+            if additional_property[0] == :field_uri
+              xml.t :FieldURI, :FieldURI=>additional_property[1]
+            end
+          end
+        end
+      end
+    end
+
+    class Base
+      include Util
+      attr_reader :shape
+    end
+
+    ITEM_SHAPE_OPTS = {
+      :base_shape=>:Default,
+      :include_mime_content=>nil,
+      :additional_properties=>nil
+    }
+
+    class ItemShape < Base
+      def initialize(shape)
+        @shape = check_opts(ITEM_SHAPE_OPTS, shape)
+      end
+
+      def to_xml
+        Xml::write_shape(:ItemShape) do |xml|
+          xml.t :BaseShape, shape[:base_shape]
+          xml.t :IncludeMimeContent, shape[:include_mime_content] if shape[:include_mime_content]
+          Xml::write_additional_properties(xml, shape[:additional_properties])
+        end
+      end
+    end
+
+    FOLDER_SHAPE_OPTS = {
+      :base_shape=>:Default,
+      :additional_properties=>nil
+    }
+
+    class FolderShape < Base
+      def initialize(shape)
+        @shape = check_opts(FOLDER_SHAPE_OPTS, shape)
+      end
+
+      def to_xml
+        Xml::write_shape(:FolderShape) do |xml|
+          xml.t :BaseShape, shape[:base_shape]
+          Xml::write_additional_properties(xml, shape[:additional_properties])
+        end
+      end
+    end
+  end
+end

data/lib/rews/sort_order.rb

@@ -0,0 +1,53 @@
+# takes sort_orders written in Ruby s-expressions and
+# outputs EWS SortOrder XML
+module Rews
+  class SortOrder
+    attr_reader :expr
+
+    def initialize(expr)
+      @expr=expr
+    end
+
+    def inspect
+      "#{self.class}: #{@expr.inspect}"
+    end
+    
+    def to_xml
+      Xml::write_sort_order(expr)
+    end
+
+    module Xml
+      module_function
+
+      def write_sort_order(expr)
+        xml = Builder::XmlMarkup.new
+        xml.wsdl :SortOrder do
+          write_expr(xml, expr)
+        end
+        xml.target!
+      end
+
+      def write_expr(xml, expr)
+        expr.each do |field_order|
+          write_field_order(xml, field_order)
+        end
+      end
+
+      def write_field_order(xml, field_order)
+        if field_order.is_a?(Array)
+          xml.t :FieldOrder, :Order=>field_order[1] do
+            write_field_uri(xml, field_order[0])
+          end
+        else
+          xml.t :FieldOrder, field_order do
+            write_field_uri(xml, field_order)
+          end
+        end
+      end
+
+      def write_field_uri(xml, field_uri)
+        xml.t :FieldURI, :FieldURI=>field_uri
+      end
+    end
+  end
+end

data/lib/rews/util.rb

@@ -0,0 +1,86 @@
+require 'set'
+
+module Rews
+  module Util
+    module_function
+
+    # validates an options hash against a constraints hash
+    # in the constraints hash :
+    # - keys ending in ! indicate option is required
+    # - keys not ending in ! indicate option is not required
+    # - non-nil values provide defaults
+    # - hash values provide constraints for sub-hashes
+    def check_opts(constraints, opts={}, prefix=nil)
+      required_keys = Hash[constraints.keys.select{|k| k.to_s[-1..-1] == '!'}.map{|k| [strip_bang(k),k]}]
+      optional_keys = constraints.keys.select{|k| k.to_s[-1..-1] != '!'}
+
+      # check each of the provided options
+      opts.keys.each do |key|
+        raise "unknown option: #{[prefix,key].compact.join(".")}" if !required_keys.include?(key) && !optional_keys.include?(key)
+        
+        ckey = required_keys[key] || key
+        if constraints[ckey].is_a? Hash
+          check_opts(constraints[ckey], opts[key] || {}, [prefix,key].compact.join("."))
+        end
+
+        required_keys.delete(key)
+        optional_keys.delete(key)
+      end
+
+      raise "required options not given: #{required_keys.keys.map{|k| [prefix,k].compact.join('.')}.join(", ")}" if required_keys.size>0
+      
+      # defaults
+      optional_keys.each{|k| opts[k] = constraints[k] if !constraints[k].is_a?(Hash)}
+      opts
+    end
+
+    def strip_bang(k)
+      if k.is_a? Symbol
+        k.to_s[0...-1].to_sym
+      else
+        k.to_s[0...-1]
+      end
+    end
+
+    def camelize(s)
+      s.split('_').map(&:capitalize).join
+    end
+
+    def camel_keys(h)
+      Hash[h.map{|k,v| [camelize(k.to_s), v]}]
+    end
+
+    def with_error_check(client, *response_msg_keys)
+      raise "no block" if !block_given?
+
+      response = yield
+      hash_response = response.to_hash
+      statuses = hash_response.fetch_in(*response_msg_keys)
+
+      if statuses.is_a?(Array)
+        all_statuses = statuses
+      else
+        all_statuses = [statuses]
+      end
+
+      errors = all_statuses.map{|s| single_error_check(client, s)}.compact
+      raise errors.join("\n") if !errors.empty?
+
+      statuses
+    end
+
+    def single_error_check(client, status)
+      begin
+        response_class = status[:response_class]
+      rescue
+        raise "no response_class found: #{status.inspect}" if !response_class
+      end
+
+      if status[:response_class] == "Error"
+        return "Rews: #{status[:response_code]} - #{status[:message_text]}"
+      elsif status[:response_class] == "Warning"
+        client.log{|logger| logger.warn("#{status[:message_text]}")}
+      end
+    end
+  end
+end

data/lib/rews/view.rb

@@ -0,0 +1,43 @@
+module Rews
+  module View
+    module Xml
+      module_function
+
+      def write_item_view(view_type, attrs, &proc)
+        xml = Builder::XmlMarkup.new
+        xml.wsdl view_type, Util::camel_keys(attrs) do
+          proc.call(xml) if proc
+        end
+        xml.target!
+      end
+    end
+
+    class Base
+      include Util
+      
+      attr_reader :view
+    end
+
+    INDEXED_PAGE_VIEW_OPTS = {:max_entries_returned=>nil, :offset=>0, :base_point=>:Beginning}
+
+    class IndexedPageItemView < Base
+      def initialize(view)
+        @view = check_opts(INDEXED_PAGE_VIEW_OPTS, view)
+      end
+
+      def to_xml
+        Xml::write_item_view(:IndexedPageItemView, view)
+      end
+    end
+
+    class IndexedPageFolderView < Base
+      def initialize(view)
+        @view = check_opts(INDEXED_PAGE_VIEW_OPTS, view)
+      end
+
+      def to_xml
+        Xml::write_item_view(:IndexedPageFolderView, view)
+      end
+    end
+  end
+end

data/lib/rews.rb

@@ -0,0 +1,55 @@
+$: << File.expand_path("..", __FILE__)
+
+require 'net/ntlm'
+require 'httpclient'
+require 'savon'
+require 'fetch_in'
+
+# Ruby Exchange Web Services
+module Rews
+  WSDL = File.expand_path("../../Services.wsdl", __FILE__)
+  SCHEMA_MESSAGES = "http://schemas.microsoft.com/exchange/services/2006/messages"
+  SCHEMA_TYPES = "http://schemas.microsoft.com/exchange/services/2006/types"
+end
+
+require 'rews/util'
+require 'rews/restriction'
+require 'rews/shape'
+require 'rews/sort_order'
+require 'rews/view'
+require 'rews/folder'
+require 'rews/item'
+
+module Rews
+  class Client
+    attr_reader :client
+    attr_accessor :logdev
+
+    # Rews::Client.new('https://exchange.foo.com/EWS/Exchange.asmx', :ntlm, 'DOMAIN\\user', 'password')
+    # Rews::Client.new('https://exchange.foo.com/EWS/Exchange.asmx', :basic, 'DOMAIN\\user', 'password')
+    def initialize(endpoint, auth_type, user, password)
+      @client = Savon::Client.new do
+        wsdl.endpoint = endpoint
+        wsdl.namespace = SCHEMA_MESSAGES
+        
+        http.auth.ssl.verify_mode = :none
+        http.auth.send(auth_type, user, password)
+      end
+    end
+
+    # client.distinguished_folder_id('inbox')
+    # client.distinguished_folder_id('inbox', 'foo@bar.com') # to get a folder from another mailbox
+    def distinguished_folder_id(id, mailbox_email=nil)
+      Folder::DistinguishedFolderId.new(client, id, mailbox_email)
+    end
+
+    def log
+      yield logger if @logdev
+    end
+
+    def logger
+      return @logger if @logger
+      @logger = Logger.new(@logdev) if @logdev
+    end
+  end
+end

data/spec/rews_spec.rb

@@ -0,0 +1,4 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe Rews do
+end

data/spec/spec.opts

@@ -0,0 +1 @@
+--color

data/spec/spec_helper.rb

@@ -0,0 +1,11 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'rubygems'
+require 'rews'
+require 'spec'
+require 'spec/autorun'
+require 'rr'
+
+Spec::Runner.configure do |config|
+  config.mock_with RR::Adapters::Rspec
+end

metadata

@@ -0,0 +1,181 @@
+--- !ruby/object:Gem::Specification 
+name: rews
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: 
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Trampoline Systems Ltd
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-03-14 00:00:00 +00:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: savon
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 51
+        segments: 
+        - 0
+        - 8
+        - 6
+        version: 0.8.6
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: ntlm-http
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 25
+        segments: 
+        - 0
+        - 1
+        - 1
+        version: 0.1.1
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: httpclient
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 217
+        segments: 
+        - 2
+        - 1
+        - 6
+        - 1
+        - 1
+        version: 2.1.6.1.1
+  type: :runtime
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: fetch_in
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 23
+        segments: 
+        - 0
+        - 2
+        - 0
+        version: 0.2.0
+  type: :runtime
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 13
+        segments: 
+        - 1
+        - 2
+        - 9
+        version: 1.2.9
+  type: :development
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: rr
+  prerelease: false
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 61
+        segments: 
+        - 0
+        - 10
+        - 5
+        version: 0.10.5
+  type: :development
+  version_requirements: *id006
+description: an email focussed Ruby client for Exchange Web Services atop Savon
+email: craig@trampolinesystems.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- .document
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION
+- lib/rews.rb
+- lib/rews/folder.rb
+- lib/rews/item.rb
+- lib/rews/restriction.rb
+- lib/rews/shape.rb
+- lib/rews/sort_order.rb
+- lib/rews/util.rb
+- lib/rews/view.rb
+- spec/rews_spec.rb
+- spec/spec.opts
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/trampoline/rews
+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.5.2
+signing_key: 
+specification_version: 3
+summary: a Ruby client for Exchange Web Services
+test_files: 
+- spec/rews_spec.rb
+- spec/spec_helper.rb