Improvements

activesp.gemspec

@@ -12,8 +12,9 @@ Gem::Specification.new do |s|
   s.files += Dir['lib/**/*.rb']
   # s.bindir = "bin"
   # s.executables.push(*(Dir['bin/*.rb']))
-  s.add_dependency('savon-xaop', '= 0.7.2.7')
-  s.add_dependency('nokogiri')
+  s.add_dependency('savon', '>= 0.9.8')
+  s.add_dependency('curb')
+  s.add_dependency('httpi', '= 0.9.4')
   # s.rdoc_options << '--exclude' << 'ext' << '--main' << 'README'
   # s.extra_rdoc_files = ["README"]
   s.has_rdoc = false

lib/activesp.rb

@@ -50,6 +50,9 @@ module ActiveSP
 require 'activesp/ghost_field'
 require 'activesp/user'
 require 'activesp/group'
+require 'activesp/user_group_proxy'
 require 'activesp/role'
 require 'activesp/permission_set'
 require 'activesp/file'
+require 'activesp/site_template'
+require 'activesp/list_template'

lib/activesp/base.rb

@@ -31,6 +31,16 @@ class Base
     extend Caching
     extend Associations
 
+    # @private
+    def relative_url(site_or_list = @list ? @list.site.connection.root : connection.root)
+      reference_url = site_or_list.url
+      reference_url += "/" unless reference_url[-1, 1] == "/"
+      url = self.url
+      reference_url = reference_url.sub(/\Ahttps?:\/\/[^\/]+/, "")
+      url = url.sub(/\Ahttps?:\/\/[^\/]+/, "")
+      url[reference_url.length..-1]
+    end
+
     # Returns a key that can be used to retrieve this object later on using {Connection#find_by_key}
     # @return [String]
     def key
@@ -85,9 +95,11 @@ def attribute_type(name)
     # @return [Integer, Float, String, Time, Boolean, Base] The assigned value
     # @raise [ArgumentError] Raised when this object does not have an attribute by the given name or if the attribute by the given name is read-only
     def set_attribute(name, value)
-      has_attribute?(name) and field = attribute_type(name) and internal_attribute_types[name] or raise ArgumentError, "#{self} has no field by the name #{name}"
-      !field.ReadOnly or raise ArgumentError, "field #{name} of #{self} is read-only"
-      current_attributes[name] = type_check_attribute(field, value)
+      set_attribute_internal(name, value, false)
+    end
+
+    def set_attribute!(name, value)
+      set_attribute_internal(name, value, true)
     end
 
     # Provides convenient getters and setters for attributes. Note that no name mangling
@@ -134,6 +146,16 @@ def changed_attributes
       changes
     end
 
+    def set_attribute_internal(name, value, override_restrictions)
+      has_attribute?(name) and field = attribute_type_internal(name, override_restrictions) or raise ArgumentError, "#{self} has no field by the name #{name}"
+      override_restrictions or !field.ReadOnly or raise ArgumentError, "field #{name} of #{self} is read-only"
+      current_attributes[name] = type_check_attribute(field, value, override_restrictions)
+    end
+
+    def attribute_type_internal(name, override_restrictions)
+      attribute_type(name)
+    end
+
   end
 
 end

lib/activesp/connection.rb

@@ -24,12 +24,71 @@
 # OTHER DEALINGS IN THE SOFTWARE.
 
 require 'savon'
+require 'activesp/wasabi_authentication'
 require 'net/ntlm_http'
 
-Savon::Request.logger.level = Logger::ERROR
+Savon.configure do |config|
+  config.log = false
+end
+
+HTTPI.log = false
+
+HTTPI.adapter = :curb
+
+class Savon::SOAP::Fault
+
+  def error_code
+    Integer(((to_hash[:fault] || {})[:detail] || {})[:errorcode] || 0)
+  end
+
+  def error_string
+    ((to_hash[:fault] || {})[:detail] || {})[:errorstring]
+  end
+
+end
 
-Savon::Response.error_handler do |soap_fault|
-  soap_fault[:detail][:errorstring]
+class HTTPI::Auth::Config
+
+  # Accessor for the GSSNEGOTIATE auth credentials.
+  def gssnegotiate(*args)
+    return @gssnegotiate if args.empty?
+
+    self.type = :gssnegotiate
+    @gssnegotiate = args.flatten.compact
+  end
+
+  # Returns whether to use GSSNEGOTIATE auth.
+  def gssnegotiate?
+    type == :gssnegotiate
+  end
+
+end
+
+class HTTPI::Adapter::Curb
+
+  def setup_client(request)
+    basic_setup request
+    setup_http_auth request if request.auth.http?
+    setup_ssl_auth request.auth.ssl if request.auth.ssl?
+    setup_ntlm_auth request if request.auth.ntlm?
+    setup_gssnegotiate_auth request if request.auth.gssnegotiate?
+  end
+
+  def setup_gssnegotiate_auth(request)
+    client.username, client.password = *request.auth.credentials
+    client.http_auth_types = request.auth.type
+  end
+
+end
+
+# This is because setting the cookie causes problems on SP 2011
+class Savon::Client
+
+private
+
+  def set_cookie(headers)
+  end
+
 end
 
 module ActiveSP
@@ -43,7 +102,7 @@ class Connection
 
     # @private
     # TODO: create profile
-    attr_reader :login, :password, :auth_type, :root_url, :trace
+    attr_reader :login, :password, :auth_type, :root_url, :trace, :user_group_proxy
 
     # @param [Hash] options The connection options
     # @option options [String] :root The URL of the root site
@@ -57,6 +116,7 @@ def initialize(options = {})
       @password = options.delete(:password)
       @auth_type = options.delete(:auth_type) || :ntlm
       @trace = options.delete(:trace)
+      @user_group_proxy = options.delete(:user_group_proxy)
       options.empty? or raise ArgumentError, "unknown options #{options.keys.map { |k| k.inspect }.join(", ")}"
       cache = nil
       configure_persistent_cache { |c| cache ||= c }
@@ -95,6 +155,15 @@ def find_by_key(key)
         else
           ActiveSP::ContentType.new(parent, nil, trail[1])
         end
+      when ?M
+        case type[1]
+        when ?S
+          site_template(trail[0])
+        when ?L
+          list_template(trail[0].to_i)
+        else
+          raise "not yet #{key.inspect}"
+        end
       else
         raise "not yet #{key.inspect}"
       end
@@ -107,54 +176,56 @@ def find_by_key(key)
     # @param [String] url The URL to fetch
     # @return [String] The content fetched from the URL
     def fetch(url)
-      # TODO: support HTTPS too
-      @open_params ||= begin
-        u = URL(@root_url)
-        [u.host, u.port]
-      end
-      Net::HTTP.start(*@open_params) do |http|
-        request = Net::HTTP::Get.new(URL(url).full_path.gsub(/ /, "%20"))
-        if @login
-          case auth_type
-          when :ntlm
-            request.ntlm_auth(@login, @password)
-          when :basic
-            request.basic_auth(@login, @password)
-          else
-            raise ArgumentError, "Unknown authentication type #{auth_type.inspect}"
-          end
+      url = "#{protocol}://#{open_params.join(':')}#{url.gsub(/ /, "%20")}" unless /\Ahttp:\/\// === url
+      request = HTTPI::Request.new(url)
+      if login
+        case auth_type
+        when :ntlm
+          request.auth.ntlm(login, password)
+        when :basic
+          request.auth.basic(login, password)
+        when :digest
+          request.auth.digest(login, password)
+        when :gss_negotiate
+          request.auth.gssnegotiate(login, password)
+        else
+          raise ArgumentError, "Unknown authentication type #{auth_type.inspect}"
         end
-        response = http.request(request)
-        # if Net::HTTPFound === response
-        #   response = fetch(response["location"])
-        # end
-        # response
       end
+      HTTPI.get(request)
     end
 
     def head(url)
-      # TODO: support HTTPS too
+      url = "#{protocol}://#{open_params.join(':')}#{url.gsub(/ /, "%20")}" unless /\Ahttp:\/\// === url
+      request = HTTPI::Request.new(url)
+      if login
+        case auth_type
+        when :ntlm
+          request.auth.ntlm(login, password)
+        when :basic
+          request.auth.basic(login, password)
+        when :digest
+          request.auth.digest(login, password)
+        when :gss_negotiate
+          request.auth.gssnegotiate(login, password)
+        else
+          raise ArgumentError, "Unknown authentication type #{auth_type.inspect}"
+        end
+      end
+      HTTPI.head(request).headers
+    end
+
+    def open_params
       @open_params ||= begin
         u = URL(@root_url)
         [u.host, u.port]
       end
-      Net::HTTP.start(*@open_params) do |http|
-        request = Net::HTTP::Head.new(URL(url).full_path.gsub(/ /, "%20"))
-        if @login
-          case auth_type
-          when :ntlm
-            request.ntlm_auth(@login, @password)
-          when :basic
-            request.basic_auth(@login, @password)
-          else
-            raise ArgumentError, "Unknown authentication type #{auth_type.inspect}"
-          end
-        end
-        response = http.request(request)
-        # if Net::HTTPFound === response
-        #   response = fetch(response["location"])
-        # end
-        # response
+    end
+
+    def protocol
+      @protocol ||= begin
+        u = URL(@root_url)
+        u.protocol
       end
     end
 

lib/activesp/content_type.rb

@@ -106,7 +106,7 @@ def fields_by_name
     # See {Base#save}
     # @return [void]
     def save
-      p untype_cast_attributes(@site, nil, internal_attribute_types, changed_attributes)
+      p untype_cast_attributes(@site, nil, internal_attribute_types, changed_attributes, false)
     end
 
     # @private
@@ -121,9 +121,9 @@ def to_s
 
     def data
       if @list
-        call("Lists", "get_list_content_type", "listName" => @list.id, "contentTypeId" => @id).xpath("//sp:ContentType", NS).first
+        call("Lists", "GetListContentType", "listName" => @list.id, "contentTypeId" => @id).xpath("//sp:ContentType", NS).first
       else
-        call("Webs", "get_content_type", "contentTypeId" => @id).xpath("//sp:ContentType", NS).first
+        call("Webs", "GetContentType", "contentTypeId" => @id).xpath("//sp:ContentType", NS).first
       end
     end
     cache :data

lib/activesp/errors.rb

@@ -1,8 +1,14 @@
 module ActiveSP
 
+  class NotFound < Exception
+  end
+
   class AccessDenied < Exception
   end
 
+  class PermissionDenied < Exception
+  end
+
   class AlreadyExists < Exception
 
     def initialize(msg, &object_blk)