google-spreadsheet-ruby 0.1.8 → 0.2.1

data/lib/google_spreadsheet/acl.rb

@@ -0,0 +1,124 @@
+# Author: Guy Boertje <https://github.com/guyboertje>
+# Author: David R. Albrecht <https://github.com/eldavido>
+# Author: Hiroshi Ichikawa <http://gimite.net/>
+# The license of this source is "New BSD Licence"
+
+require "google_spreadsheet/acl_entry"
+
+
+module GoogleSpreadsheet
+    
+    # ACL (access control list) of a spreadsheet.
+    #
+    # Use GoogleSpreadsheet::Spreadsheet#acl to get GoogleSpreadsheet::Acl object.
+    # See GoogleSpreadsheet::Spreadsheet#acl for usage example.
+    #
+    # This code is based on https://github.com/guyboertje/gdata-spreadsheet-ruby .
+    class Acl
+        
+        include(Util)
+        extend(Forwardable)
+        
+        def initialize(session, acls_feed_url) #:nodoc:
+          @session = session
+          @acls_feed_url = acls_feed_url
+          header = {"GData-Version" => "3.0"}
+          doc = @session.request(:get, @acls_feed_url, :header => header, :auth => :writely)
+          @acls = doc.css("entry").map(){ |e| AclEntry.new(entry_to_params(e)) }
+        end
+        
+        def_delegators(:@acls, :size, :[], :each)
+        
+        # Adds a new entry. +entry+ is either a GoogleSpreadsheet::AclEntry or a Hash with keys
+        # :scope_type, :scope and :role. See GoogleSpreadsheet::AclEntry#scope_type and
+        # GoogleSpreadsheet::AclEntry#role for the document of the fields.
+        #
+        # NOTE: This sends email to the new people.
+        #
+        # e.g.
+        #   spreadsheet.acl.push(
+        #       {:scope_type => "user", :scope => "example2@gmail.com", :role => "reader"})
+        #   spreadsheet.acl.push(
+        #       {:scope_type => "user", :scope => "example3@gmail.com", :role => "writer"})
+        def push(entry)
+          
+          entry = AclEntry.new(entry) if entry.is_a?(Hash)
+          
+          header = {"GData-Version" => "3.0", "Content-Type" => "application/atom+xml"}
+          value_attr = entry.scope ? "value='#{h(entry.scope)}'" : ""
+          xml = <<-EOS
+            <entry
+                xmlns='http://www.w3.org/2005/Atom'
+                xmlns:gAcl='http://schemas.google.com/acl/2007'>
+              <category scheme='http://schemas.google.com/g/2005#kind'
+                  term='http://schemas.google.com/acl/2007#accessRule'/>
+              <gAcl:role value='#{h(entry.role)}'/>
+              <gAcl:scope type='#{h(entry.scope_type)}' #{value_attr}/>
+            </entry>
+          EOS
+          doc = @session.request(
+              :post, @acls_feed_url, :data => xml, :header => header, :auth => :writely)
+          
+          entry.params = entry_to_params(doc.root)
+          @acls.push(entry)
+          return entry
+          
+        end
+        
+        # Deletes an ACL entry.
+        #
+        # e.g.
+        #   spreadsheet.acl.delete(spreadsheet.acl[1])
+        def delete(entry)
+          header = {"GData-Version" => "3.0"}
+          @session.request(:delete, entry.edit_url, :header => header, :auth => :writely)
+          @acls.delete(entry)
+        end
+        
+        def update_role(entry, role) #:nodoc:
+          
+          header = {"GData-Version" => "3.0", "Content-Type" => "application/atom+xml"}
+          value_attr = entry.scope ? "value='#{h(entry.scope)}'" : ""
+          xml = <<-EOS
+            <entry
+                xmlns='http://www.w3.org/2005/Atom'
+                xmlns:gAcl='http://schemas.google.com/acl/2007'
+                xmlns:gd='http://schemas.google.com/g/2005'
+                gd:etag='#{h(entry.etag)}'>
+              <category
+                  scheme='http://schemas.google.com/g/2005#kind'
+                  term='http://schemas.google.com/acl/2007#accessRule'/>
+              <gAcl:role value='#{h(role)}'/>
+              <gAcl:scope type='#{h(entry.scope_type)}' #{value_attr}/>
+            </entry>
+          EOS
+          doc = @session.request(
+              :put, entry.edit_url, :data => xml, :header => header, :auth => :writely)
+          
+          entry.params = entry_to_params(doc.root)
+          return entry
+          
+        end
+        
+        def inspect
+          return "\#<%p %p>" % [self.class, @acls]
+        end
+        
+      private
+        
+        def entry_to_params(entry)
+          # TODO Support with-link roles.
+          return {
+            :acl => self,
+            :scope_type => entry.css("gAcl|scope")[0]["type"],
+            :scope => entry.css("gAcl|scope")[0]["value"],
+            :role => entry.css("gAcl|role")[0]["value"],
+            :title => entry.css("title").text,
+            :edit_url => entry.css("link[rel='edit']")[0]["href"],
+            :etag => entry["etag"],
+          }
+        end
+        
+    end
+    
+end

data/lib/google_spreadsheet/acl_entry.rb

@@ -0,0 +1,58 @@
+# Author: Guy Boertje <https://github.com/guyboertje>
+# Author: David R. Albrecht <https://github.com/eldavido>
+# Author: Hiroshi Ichikawa <http://gimite.net/>
+# The license of this source is "New BSD Licence"
+
+# acl.rb, derived from https://github.com/guyboertje/gdata-spreadsheet-ruby/blob/master/lib/document.rb
+# more frankensteining of the original library
+
+module GoogleSpreadsheet
+    
+    # An entry of an ACL (access control list) of a spreadsheet.
+    #
+    # Use GoogleSpreadsheet::Acl#[] to get GoogleSpreadsheet::AclEntry object.
+    #
+    # This code is based on https://github.com/guyboertje/gdata-spreadsheet-ruby .
+    class AclEntry
+        
+        include(Util)
+        
+        PARAM_NAMES = [:acl, :scope_type, :scope, :role, :title, :edit_url, :etag]  #:nodoc:
+        
+        # +params+ is a Hash object with keys +:scope_type+, +:scope+ and +:role+.
+        # See scope_type and role for the document of the fields.
+        def initialize(params)
+          @params = {:role => "reader"}
+          for name, value in params
+            if !PARAM_NAMES.include?(name)
+              raise(ArgumentError, "Invalid key: %p" % name)
+            end
+            @params[name] = value
+          end
+        end
+        
+        attr_accessor(:params)  #:nodoc:
+        
+        PARAM_NAMES.each() do |name|
+          define_method(name) do
+            return @params[name]
+          end
+        end
+        
+        # Changes the role of the scope.
+        #
+        # e.g.
+        #   spreadsheet.acl[1].role = "writer"
+        def role=(role)
+          @params[:acl].update_role(self, role)
+        end
+        
+        def inspect
+          return "\#<%p scope_type=%p, scope=%p, role=%p>" %
+              [self.class, @params[:scope_type], @params[:scope], @params[:role]]
+        end
+        
+    end
+    
+end
+

data/lib/google_spreadsheet/authentication_error.rb

@@ -0,0 +1,14 @@
+# Author: Hiroshi Ichikawa <http://gimite.net/>
+# The license of this source is "New BSD Licence"
+
+require "google_spreadsheet/error"
+
+
+module GoogleSpreadsheet
+
+    # Raised when GoogleSpreadsheet.login has failed.
+    class AuthenticationError < GoogleSpreadsheet::Error
+
+    end
+    
+end

data/lib/google_spreadsheet/client_login_fetcher.rb

@@ -0,0 +1,56 @@
+# Author: Hiroshi Ichikawa <http://gimite.net/>
+# The license of this source is "New BSD Licence"
+
+require "net/https"
+require "uri"
+Net::HTTP.version_1_2
+
+
+module GoogleSpreadsheet
+
+    class ClientLoginFetcher #:nodoc:
+        
+        def initialize(auth_tokens, proxy)
+          @auth_tokens = auth_tokens
+          if proxy
+            @proxy = proxy
+          elsif ENV["http_proxy"] && !ENV["http_proxy"].empty?
+            proxy_url = URI.parse(ENV["http_proxy"])
+            @proxy = Net::HTTP.Proxy(proxy_url.host, proxy_url.port)
+          else
+            @proxy = Net::HTTP
+          end
+        end
+        
+        attr_accessor(:auth_tokens)
+        
+        def request_raw(method, url, data, extra_header, auth)
+          uri = URI.parse(url)
+          http = @proxy.new(uri.host, uri.port)
+          http.use_ssl = true
+          http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+          http.start() do
+            path = uri.path + (uri.query ? "?#{uri.query}" : "")
+            header = auth_header(auth).merge(extra_header)
+            if method == :delete || method == :get
+              return http.__send__(method, path, header)
+            else
+              return http.__send__(method, path, data, header)
+            end
+          end
+        end
+        
+      private
+        
+        def auth_header(auth)
+          token = auth == :none ? nil : @auth_tokens[auth]
+          if token
+            return {"Authorization" => "GoogleLogin auth=#{token}"}
+          else
+            return {}
+          end
+        end
+
+    end
+    
+end

data/lib/google_spreadsheet/collection.rb

@@ -0,0 +1,62 @@
+# Author: Hiroshi Ichikawa <http://gimite.net/>
+# The license of this source is "New BSD Licence"
+
+require "google_spreadsheet/util"
+require "google_spreadsheet/error"
+require "google_spreadsheet/spreadsheet"
+
+
+module GoogleSpreadsheet
+
+    # Use GoogleSpreadsheet::Session#collection_by_url to get GoogleSpreadsheet::Collection object.
+    class Collection
+
+        include(Util)
+        
+        def initialize(session, collection_feed_url) #:nodoc:
+          @session = session
+          @collection_feed_url = collection_feed_url
+        end
+        
+        attr_reader(:collection_feed_url)
+        
+        # Adds the given GoogleSpreadsheet::Spreadsheet to the collection.
+        def add(spreadsheet)
+          contents_url = concat_url(@collection_feed_url, "/contents")
+          header = {"GData-Version" => "3.0", "Content-Type" => "application/atom+xml"}
+          xml = <<-"EOS"
+            <entry xmlns="http://www.w3.org/2005/Atom">
+              <id>#{h(spreadsheet.document_feed_url)}</id>
+            </entry>
+          EOS
+          @session.request(
+              :post, contents_url, :data => xml, :header => header, :auth => :writely)
+          return nil
+        end
+
+        # Returns all the spreadsheets in the collection.
+        def spreadsheets
+          
+          contents_url = concat_url(@collection_feed_url, "/contents")
+          header = {"GData-Version" => "3.0", "Content-Type" => "application/atom+xml"}
+          doc = @session.request(:get, contents_url, :header => header, :auth => :writely)
+          
+          result = []
+          for entry in doc.css("feed > entry")
+            title = entry.css("title").text
+            worksheets_feed_link = entry.css(
+              "link[rel='http://schemas.google.com/spreadsheets/2006#worksheetsfeed']")[0]
+            if worksheets_feed_link
+              result.push(GoogleSpreadsheet::Spreadsheet.new(
+                  @session, worksheets_feed_link["href"], title))
+            end
+          end
+          return result
+          
+        end
+        
+        # TODO Add other operations.
+
+    end
+    
+end

data/lib/google_spreadsheet/error.rb

@@ -0,0 +1,12 @@
+# Author: Hiroshi Ichikawa <http://gimite.net/>
+# The license of this source is "New BSD Licence"
+
+
+module GoogleSpreadsheet
+
+    # Raised when spreadsheets.google.com has returned error.
+    class Error < RuntimeError
+
+    end
+    
+end

data/lib/google_spreadsheet/list.rb

@@ -0,0 +1,115 @@
+# Author: Hiroshi Ichikawa <http://gimite.net/>
+# The license of this source is "New BSD Licence"
+
+require "google_spreadsheet/util"
+require "google_spreadsheet/error"
+require "google_spreadsheet/list_row"
+
+
+module GoogleSpreadsheet
+
+    # Provides access to cells using column names.
+    # Use GoogleSpreadsheet::Worksheet#list to get GoogleSpreadsheet::List object.
+    #--
+    # This is implemented as wrapper of GoogleSpreadsheet::Worksheet i.e. using cells
+    # feed, not list feed. In this way, we can easily provide consistent API as
+    # GoogleSpreadsheet::Worksheet using save()/reload().
+    class List
+        
+        include(Enumerable)
+        
+        def initialize(worksheet) #:nodoc:
+          @worksheet = worksheet
+        end
+        
+        # Number of non-empty rows in the worksheet excluding the first row.
+        def size
+          return @worksheet.num_rows - 1
+        end
+        
+        # Returns Hash-like object (GoogleSpreadsheet::ListRow) for the row with the
+        # index. Keys of the object are colum names (the first row).
+        # The second row has index 0.
+        #
+        # Note that updates to the returned object are not sent to the server until
+        # you call GoogleSpreadsheet::Worksheet#save().
+        def [](index)
+          return ListRow.new(self, index)
+        end
+        
+        # Updates the row with the index with the given Hash object.
+        # Keys of +hash+ are colum names (the first row).
+        # The second row has index 0.
+        #
+        # Note that update is not sent to the server until
+        # you call GoogleSpreadsheet::Worksheet#save().
+        def []=(index, hash)
+          self[index].replace(hash)
+        end
+        
+        # Iterates over Hash-like object (GoogleSpreadsheet::ListRow) for each row
+        # (except for the first row).
+        # Keys of the object are colum names (the first row).
+        def each(&block)
+          for i in 0...self.size
+            yield(self[i])
+          end
+        end
+        
+        # Column names i.e. the contents of the first row.
+        # Duplicates are removed.
+        def keys
+          return (1..@worksheet.num_cols).map(){ |i| @worksheet[1, i] }.uniq()
+        end
+        
+        # Updates column names i.e. the contents of the first row.
+        #
+        # Note that update is not sent to the server until
+        # you call GoogleSpreadsheet::Worksheet#save().
+        def keys=(ary)
+          for i in 1..ary.size
+            @worksheet[1, i] = ary[i - 1]
+          end
+          for i in (ary.size + 1)..@worksheet.num_cols
+            @worksheet[1, i] = ""
+          end
+        end
+        
+        # Adds a new row to the bottom.
+        # Keys of +hash+ are colum names (the first row).
+        # Returns GoogleSpreadsheet::ListRow for the new row.
+        #
+        # Note that update is not sent to the server until
+        # you call GoogleSpreadsheet::Worksheet#save().
+        def push(hash)
+          row = self[self.size]
+          row.update(hash)
+          return row
+        end
+        
+        # Returns all rows (except for the first row) as Array of Hash.
+        # Keys of Hash objects are colum names (the first row).
+        def to_hash_array()
+          return self.map(){ |r| r.to_hash() }
+        end
+        
+        def get(index, key) #:nodoc:
+          return @worksheet[index + 2, key_to_col(key)]
+        end
+        
+        def set(index, key, value) #:nodoc:
+          @worksheet[index + 2, key_to_col(key)] = value
+        end
+        
+      private
+        
+        def key_to_col(key)
+          key = key.to_s()
+          col = (1..@worksheet.num_cols).find(){ |c| @worksheet[1, c] == key }
+          raise(GoogleSpreadsheet::Error, "Colunm doesn't exist: %p" % key) if !col
+          return col
+        end
+        
+    end
+    
+end