restful-sharepoint 0.1.7 → 0.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ed833ac3ebadfee98a8b6fa2b9da7cdc28b52123328ebd90ab1ae997850e2461
-  data.tar.gz: 546418c16f83e2072d0cdd36eade766b99cea7450e1b93533768493f8b8b003c
+  metadata.gz: 676e57e07950be0b111e91a9675056ab7f9b3d90c39319dc1e9ac619476e7cec
+  data.tar.gz: 717a90610e1a58b0895eed3fe018f3d99faae5f7947ce1b81797c0e8cf9fe6c1
 SHA512:
-  metadata.gz: 41d9bd7486df21258be7ef1ffa903607128e303d7f2245d3dc5ec9ed94a44fbc52ee8c5e927380d3fc51fcb70b53f05fe9a393ec504d08acb4d5ebc9d024129f
-  data.tar.gz: 93134acddffbafb778f7254c955ccc61c2e38818d66d460e065a92ac215d6f44e4759c84f9cd4d33fc9e5289edb2c7cd8c1553ae4144c8867602637cee112c8f
+  metadata.gz: e448c10bb59bee93d58725f109f2c5ce8f55ed0b2bae7f27944ae865ec9352f1f133947a948f5fadce119b67c614a844f7f6c1435ac31cab6fafff9c7134a472
+  data.tar.gz: dd7afb07ce1d26484e3f48a070c8dfe28c67de1a52c02481b5a13d70f90d15e0e35ae91a4e4d545c98669402a02b20513dc6c43d7a35c59e1a6dd4cf637ea332

data/lib/restful-sharepoint/collection.rb

@@ -2,13 +2,18 @@ module RestfulSharePoint
   class Collection < CommonBase
     DEFAULT_OPTIONS = {}
 
+    include Enumerable
+    extend Forwardable
+
+    def_delegators :@collection, :each, :length, :[]
+
     def self.object_class
       Object
     end
 
     def initialize(parent: nil, connection: nil, collection: nil, options: {})
       @parent = parent
-      @connection = connection || @parent.connection # Iterate collection and coerce each into into a ListItem
+      @connection = @parent ? @parent.connection : connection
       self.collection = collection
       self.options = options
     end
@@ -22,24 +27,42 @@ module RestfulSharePoint
 
     attr_writer :endpoint
     def endpoint
-      @endpoint || (raise NotImplementedError, "Endpoint needs to be set")
+      @endpoint || (raise NotImplementedError, "Endpoint could not be determined")
     end
 
     def collection=(collection)
       @collection = collection
       @collection&.each_with_index do |v,i|
-        @collection[i] = objectify(v)
+        @collection[i] = connection.objectify(v)
       end
-      @properties
+      @collection
+    end
+
+    def ==(other)
+      other.== collection
+    end
+
+    def eql?(other)
+      other.eql? collection
     end
 
     def collection
       @collection || self.collection = connection.get(endpoint, options: @options)
     end
 
-    def values
-      collection.dup.each { |k,v| properties[k] = v.values if v.is_a?(Object) || v.is_a?(Collection) }
+    def to_a
+      collection.map do |v|
+        case v
+        when Object
+          v.to_h
+        when Collection
+          v.to_a
+        else
+          v
+        end
+      end
     end
+    alias to_array to_a
 
     def next
       self.new(@connection, @connection.get(collection['__next']))
@@ -48,13 +71,5 @@ module RestfulSharePoint
     def to_json(*args, &block)
       collection.to_json(*args, &block)
     end
-
-    def method_missing(method, *args, &block)
-      collection.respond_to?(method) ? collection.send(method, *args, &block) : super
-    end
-
-    def respond_to_missing?(method, include_all = false)
-      collection.respond_to?(method, include_all)
-    end
   end
 end

data/lib/restful-sharepoint/common-base.rb

@@ -1,18 +1,5 @@
 module RestfulSharePoint
   class CommonBase
-    # Converts the given enumerable tree to a collection or object.
-    def objectify(tree)
-      if tree['results'] && !tree['results'].empty?
-        type = tree.dig('__metadata', 'type')  || tree.dig('results', 0, '__metadata', 'type')
-        raise "Object type not specified" unless type
-        pattern, klass = COLLECTION_MAP.find { |pattern,| pattern.match(type)  }
-        klass ? RestfulSharePoint.const_get(klass).new(parent: self, collection: tree['results']) : tree['results']
-      elsif tree['__metadata']
-        type = tree['__metadata']['type']
-        raise "Collection type not specified" unless type
-        pattern, klass = OBJECT_MAP.find { |pattern,| pattern.match(type)  }
-        klass ? RestfulSharePoint.const_get(klass).new(parent: self, properties: tree) : tree
-      end
-    end
+
   end
 end

data/lib/restful-sharepoint/connection.rb

@@ -13,6 +13,10 @@ module RestfulSharePoint
 
     attr_reader :site_url
 
+    def get_as_object(path, options: {})
+      objectify(get(path, options: options))
+    end
+
     def get(path, options: {})
       request path, :get, options: options
     end
@@ -27,7 +31,7 @@ module RestfulSharePoint
       req = HTTPI::Request.new(url: url, headers: {'accept' => 'application/json; odata=verbose'})
       req.auth.ntlm(@username, @password) if @username
       if body
-        req.body = body.to_json.gsub('/', '\\/') # SharePoint requires forward slashes be escaped in JSON (WTF!!!)
+        req.body = JSON.dump(body).gsub('/', '\\/') # SharePoint requires forward slashes be escaped in JSON (WTF!!!)
         req.headers['Content-Type'] = 'application/json'
         req.headers['X-HTTP-Method'] = 'MERGE' # TODO: Extend logic to support all operations
         req.headers['If-Match'] = '*'
@@ -35,35 +39,45 @@ module RestfulSharePoint
       yield(req) if block_given?
       LOG.info "Making HTTP request to: #{req.url.to_s}"
       response = HTTPI.request(method, req)
-      # Log each request to file
-      if @debug
-        request_name = req.url.path.gsub(/[^\w.]/, '_')
-        filepath = ::File.join(@debug, "#{DateTime.now.strftime('%FT%R')}_#{request_name}.log")
-        FileUtils.mkdir_p @debug
-        ::File.open(filepath, 'w+') do |file|
-          file.puts response.code
-          response.headers.each { |k,v| file.puts "#{k}: #{v}" }
-          file.puts '----------'
-          file.puts response.body
-        end
-      end
       if response.body.empty?
         if response.code >= 300
           raise RestError, "Server returned HTTP status #{response.code} with no message body."
         end
       else
         if response.headers['Content-Type'].start_with? "application/json"
-          data_tree = parse(response.body)
+          parse response.body
         else
           response.body
         end
       end
     end
 
+    # Converts the given enumerable tree to a collection or object.
+    def objectify(tree, parent: nil)
+      if tree['results']
+        type = tree['__metadata']&.[]('type') || tree['results'][0]&.[]('__metadata')&.[]('type') || ''
+        pattern, klass = COLLECTION_MAP.any? { |pattern,| pattern.match(type) }
+        klass ||= :Collection
+        RestfulSharePoint.const_get(klass).new(connection: self, parent: parent, collection: tree['results'])
+      elsif tree['__metadata']
+        type = tree['__metadata']['type']
+        raise "Object type not specified. #{tree.inspect}" unless type
+        pattern, klass = OBJECT_MAP.find { |pattern,| pattern.match(type) }
+        klass ? RestfulSharePoint.const_get(klass).new(connection: self, parent: parent, properties: tree) : tree
+      else
+        tree
+      end
+    end
+
+    def objectified?(v)
+      CommonBase === v || !v.is_a?(Hash)
+    end
+
   protected
 
     def parse(str)
-      data = JSON.parse(str)
+      data = JSON.load(str)
+      ::File.write('parsed.json', JSON.dump(data))
       raise RestError, "(#{data['error']['code']}): #{data['error']['message']['value']}" if data['error']
       parse_tree(data['d'])
     end

data/lib/restful-sharepoint/object.rb

@@ -2,10 +2,15 @@ module RestfulSharePoint
   class Object < CommonBase
     DEFAULT_OPTIONS = {}
 
+    include Enumerable
+    extend Forwardable
+
+    def_delegators :properties, :length, :keys
+
     def initialize(parent: nil, connection: nil, properties: nil, id: nil, options: {})
       raise Error, "Either a parent or connection must be provided." unless parent || connection
       @parent = parent
-      @connection = connection || @parent.connection
+      @connection = @parent ? @parent.connection : connection
       self.properties = properties
       @id = id
       self.options = options
@@ -19,58 +24,61 @@ module RestfulSharePoint
 
     attr_writer :endpoint
     def endpoint
+      @endpoint || self['__metadata']['uri'] || (raise NotImplementedError, "Endpoint could not be determined")
+    end
 
+    attr_writer :properties
+    def properties
+      @properties || self.properties = connection.get(endpoint, options: @options)
     end
 
-    def properties=(properties)
-      @properties = properties
-      @properties&.each do |k,v|
-        if v.respond_to?(:keys) && v['__deferred']
-          define_singleton_method(k) do |options = {}|
-            if Hash === properties[k] && properties[k]['__deferred']
-              fetch_deferred(k, options)
-            else
-              warn("`options` have been ignored as `#{k}` has already been loaded") unless options.empty?
-              properties[k]
-            end
-          end
-        elsif v.respond_to?(:keys) && (v['__metadata'] || v['results'])
-          @properties[k] = objectify(v)
-        end
+    def [](key, options = {})
+      if connection.objectified?(properties[key])
+        warn "`options` have been ignored as deferred object has already been fetched" unless options.empty?
+        properties[key]
+      elsif properties[key].respond_to?('[]') && properties[key]['__deferred']
+        properties[key] = fetch_deferred(key, options)
+      else
+        properties[key] = connection.objectify(properties[key])
       end
-      @properties
     end
 
-    def properties
-      @properties || self.properties = connection.get(endpoint, options: @options)
+    def ==(other)
+      other.== properties
+    end
+
+    def eql?(other)
+      other.eql? properties
     end
 
-    def values
-      properties.dup.each { |k,v| properties[k] = v.values if v.is_a?(Object) || v.is_a?(Collection) }
+    def to_h
+      hash = {}
+      properties.each do |k,v|
+        hash[k] = case v
+        when Object
+          v.to_h
+        when Collection
+          v.to_a
+        else
+          v
+        end
+      end
     end
+    alias to_hash to_h
 
     def fetch_deferred(property, options = {})
-      data = connection.get(@properties[property]['__deferred']['uri'], options: options)
-      @properties[property] = objectify(data)
+      connection.get_as_object(@properties[property]['__deferred']['uri'], options: options)
     end
 
     def to_json(*args, &block)
       properties.to_json(*args, &block)
     end
 
-    def method_missing(method, *args, &block)
-      if properties.respond_to?(method)
-        properties.send(method, *args, &block)
-      elsif self.methods(false).include?(method) # Works around lazily loaded `properties`
-        self.send(method, *args, &block)
-      else
-        super
+    def each(&block)
+      properties.each do |k,v|
+        yield k, self[k]
       end
     end
 
-    def respond_to_missing?(method, include_all = false)
-      properties.respond_to?(method, include_all)
-    end
-
   end
 end

data/lib/restful-sharepoint/version.rb

@@ -1,3 +1,3 @@
 module RestfulSharePoint
-  VERSION = '0.1.7'
+  VERSION = '0.2.2'
 end

data/spec/restfulsharepoint_spec.rb

@@ -0,0 +1,56 @@
+ENV['RUBY_ENV'] = 'production'
+
+require 'yaml'
+require_relative '../lib/restful-sharepoint.rb'
+
+CONFIG = YAML.load_file(File.join(__dir__, 'config.yml'))
+
+module RestfulSharePoint
+  describe RestfulSharePoint do
+    let :c do
+      Connection.new(CONFIG[:site_url], CONFIG[:username], CONFIG[:password])
+    end
+
+    it "can establish a connection" do
+      lists = c.get('/_api/web/lists/')
+      expect(lists).to be_a(Hash)
+      expect(lists['results']).to be_a(Array)
+    end
+
+    it "can work with a collection" do
+      lists = Collection.new(connection: c, collection: c.get('/_api/web/lists/')['results'])
+      expect(lists.map { |v| v['Title'] }).to include(CONFIG[:test_list_title])
+    end
+
+    it "can work with an object" do
+      list = Object.new(connection: c, properties: c.get("/_api/web/lists/getbytitle('#{URI.encode CONFIG[:test_list_title]}')"))
+      expect(list['Title']).to eq(CONFIG[:test_list_title])
+    end
+
+    it "can automatically get an object or collection" do
+      lists = c.get_as_object('/_api/web/lists/')
+      list = c.get_as_object("/_api/web/lists/getbytitle('#{URI.encode CONFIG[:test_list_title]}')")
+      expect(lists).to be_a(Collection)
+      expect(list).to be_a(Object)
+    end
+
+    it "can get a list by title" do
+      list = List.from_title(CONFIG[:test_list_title], c)
+      expect(list['Title']).to eq(CONFIG[:test_list_title])
+    end
+
+    it "can automatically retrieve deferred objects and c
+    ollections" do
+      list = List.from_title(CONFIG[:test_list_title], c)
+      expect(list['Items'][0]['ContentType']['Name']).to be_a(String)
+    end
+
+    it "can give options when retrieving deferred objects" do
+      list = List.from_title(CONFIG[:test_list_title], c)
+      expect(list['Items'].to_a[0]['ContentType']['Name']).to be_nil
+      expect{list['Items', {expand: 'ContentType'}]}.to output.to_stderr # Should warn about deferred object already been fetched
+      list2 = List.from_title(CONFIG[:test_list_title], c)
+      expect(list2['Items', {expand: 'ContentType'}].to_a[0]['ContentType']['Name']).to be_a(String)
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: restful-sharepoint
 version: !ruby/object:Gem::Version
-  version: 0.1.7
+  version: 0.2.2
 platform: ruby
 authors:
 - Tom Wardrop
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-04-04 00:00:00.000000000 Z
+date: 2018-08-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: httpi
@@ -65,6 +65,7 @@ files:
 - lib/restful-sharepoint/objects/web.rb
 - lib/restful-sharepoint/version.rb
 - restful-sharepoint.gemspec
+- spec/restfulsharepoint_spec.rb
 homepage: https://github.com/Wardrop/restful-sharepoint
 licenses:
 - MIT