google-spreadsheet-ruby 0.1.8 → 0.2.1

data/lib/google_spreadsheet/list_row.rb

@@ -0,0 +1,84 @@
+# Author: Hiroshi Ichikawa <http://gimite.net/>
+# The license of this source is "New BSD Licence"
+
+require "forwardable"
+
+require "google_spreadsheet/util"
+require "google_spreadsheet/error"
+
+
+module GoogleSpreadsheet
+
+    # Hash-like object returned by GoogleSpreadsheet::List#[].
+    class ListRow
+        
+        include(Enumerable)
+        extend(Forwardable)
+        
+        def_delegators(:to_hash,
+            :keys, :values, :each_key, :each_value, :each, :each_pair, :hash,
+            :assoc, :fetch, :flatten, :key, :invert, :size, :length, :rassoc,
+            :merge, :reject, :select, :sort, :to_a, :values_at)
+        
+        def initialize(list, index) #:nodoc:
+          @list = list
+          @index = index
+        end
+        
+        def [](key)
+          return @list.get(@index, key)
+        end
+        
+        def []=(key, value)
+          @list.set(@index, key, value)
+        end
+        
+        def has_key?(key)
+          return @list.keys.include?(key)
+        end
+        
+        alias include? has_key?
+        alias key? has_key?
+        alias member? has_key?
+        
+        def update(hash)
+          for k, v in hash
+            self[k] = v
+          end
+        end
+        
+        alias merge! update
+        
+        def replace(hash)
+          clear()
+          update(hash)
+        end
+        
+        def clear()
+          for key in @list.keys
+            self[key] = ""
+          end
+        end
+        
+        def to_hash()
+          result = {}
+          for key in @list.keys
+            result[key] = self[key]
+          end
+          return result
+        end
+        
+        def ==(other)
+          return self.class == other.class && self.to_hash() == other.to_hash()
+        end
+        
+        alias === ==
+        alias eql? ==
+        
+        def inspect
+          return "\#<%p %p>" % [self.class, to_hash()]
+        end
+        
+    end
+    
+end

data/lib/google_spreadsheet/oauth1_fetcher.rb

@@ -0,0 +1,26 @@
+# Author: Hiroshi Ichikawa <http://gimite.net/>
+# The license of this source is "New BSD Licence"
+
+require "rubygems"
+require "oauth"
+
+
+module GoogleSpreadsheet
+
+    class OAuth1Fetcher #:nodoc:
+        
+        def initialize(oauth1_token)
+          @oauth1_token = oauth1_token
+        end
+        
+        def request_raw(method, url, data, extra_header, auth)
+          if method == :delete || method == :get
+            return @oauth1_token.__send__(method, url, extra_header)
+          else
+            return @oauth1_token.__send__(method, url, data, extra_header)
+          end
+        end
+        
+    end
+    
+end

data/lib/google_spreadsheet/oauth2_fetcher.rb

@@ -0,0 +1,29 @@
+# Author: Hiroshi Ichikawa <http://gimite.net/>
+# The license of this source is "New BSD Licence"
+
+require "rubygems"
+require "oauth2"
+
+
+module GoogleSpreadsheet
+
+    class OAuth2Fetcher #:nodoc:
+        
+        Response = Struct.new(:code, :body)
+        
+        def initialize(oauth2_token)
+          @oauth2_token = oauth2_token
+        end
+        
+        def request_raw(method, url, data, extra_header, auth)
+          if method == :delete || method == :get
+            raw_res = @oauth2_token.request(method, url, {:header => extra_header})
+          else
+            raw_res = @oauth2_token.request(method, url, {:header => extra_header, :body => data})
+          end
+          return Response.new(raw_res.status.to_s(), raw_res.body)
+        end
+        
+    end
+    
+end

data/lib/google_spreadsheet/record.rb

@@ -0,0 +1,31 @@
+# Author: Hiroshi Ichikawa <http://gimite.net/>
+# The license of this source is "New BSD Licence"
+
+require "google_spreadsheet/util"
+require "google_spreadsheet/error"
+
+
+module GoogleSpreadsheet
+
+    # DEPRECATED: Table and Record feeds are deprecated and they will not be available after
+    # March 2012.
+    #
+    # Use GoogleSpreadsheet::Table#records to get GoogleSpreadsheet::Record objects.
+    class Record < Hash
+        include(Util)
+
+        def initialize(session, entry) #:nodoc:
+          @session = session
+          entry.css("gs|field").each() do |field|
+            self[field["name"]] = field.inner_text
+          end
+        end
+
+        def inspect #:nodoc:
+          content = self.map(){ |k, v| "%p => %p" % [k, v] }.join(", ")
+          return "\#<%p:{%s}>" % [self.class, content]
+        end
+
+    end
+
+end

data/lib/google_spreadsheet/session.rb

@@ -0,0 +1,297 @@
+# Author: Hiroshi Ichikawa <http://gimite.net/>
+# The license of this source is "New BSD Licence"
+
+require "cgi"
+
+require "rubygems"
+require "nokogiri"
+
+require "google_spreadsheet/util"
+require "google_spreadsheet/client_login_fetcher"
+require "google_spreadsheet/oauth1_fetcher"
+require "google_spreadsheet/oauth2_fetcher"
+require "google_spreadsheet/error"
+require "google_spreadsheet/authentication_error"
+require "google_spreadsheet/spreadsheet"
+require "google_spreadsheet/worksheet"
+require "google_spreadsheet/collection"
+
+
+module GoogleSpreadsheet
+
+    # Use GoogleSpreadsheet.login or GoogleSpreadsheet.saved_session to get
+    # GoogleSpreadsheet::Session object.
+    class Session
+
+        include(Util)
+        extend(Util)
+
+        # The same as GoogleSpreadsheet.login.
+        def self.login(mail, password, proxy = nil)
+          session = Session.new(nil, ClientLoginFetcher.new({}, proxy))
+          session.login(mail, password)
+          return session
+        end
+
+        # The same as GoogleSpreadsheet.login_with_oauth.
+        def self.login_with_oauth(oauth_token)
+          case oauth_token
+            when OAuth::AccessToken
+              fetcher = OAuth1Fetcher.new(oauth_token)
+            when OAuth2::AccessToken
+              fetcher = OAuth2Fetcher.new(oauth_token)
+            else
+              raise(GoogleSpreadsheet::Error,
+                  "oauth_token is neither OAuth::Token nor OAuth2::Token: %p" % oauth_token)
+          end
+          return Session.new(nil, fetcher)
+        end
+
+        # The same as GoogleSpreadsheet.restore_session.
+        def self.restore_session(auth_tokens, proxy = nil)
+          return Session.new(auth_tokens, nil, proxy)
+        end
+        
+        # Creates a dummy GoogleSpreadsheet::Session object for testing.
+        def self.new_dummy()
+          return Session.new(nil, Object.new())
+        end
+
+        # DEPRECATED: Use GoogleSpreadsheet.restore_session instead.
+        def initialize(auth_tokens = nil, fetcher = nil, proxy = nil)
+          if fetcher
+            @fetcher = fetcher
+          else
+            @fetcher = ClientLoginFetcher.new(auth_tokens || {}, proxy)
+          end
+        end
+
+        # Authenticates with given +mail+ and +password+, and updates current session object
+        # if succeeds. Raises GoogleSpreadsheet::AuthenticationError if fails.
+        # Google Apps account is supported.
+        def login(mail, password)
+          if !@fetcher.is_a?(ClientLoginFetcher)
+            raise(GoogleSpreadsheet::Error,
+                "Cannot call login for session created by login_with_oauth.")
+          end
+          begin
+            @fetcher.auth_tokens = {
+              :wise => authenticate(mail, password, :wise),
+              :writely => authenticate(mail, password, :writely),
+            }
+          rescue GoogleSpreadsheet::Error => ex
+            return true if @on_auth_fail && @on_auth_fail.call()
+            raise(AuthenticationError, "Authentication failed for #{mail}: #{ex.message}")
+          end
+        end
+
+        # Authentication tokens.
+        def auth_tokens
+          if !@fetcher.is_a?(ClientLoginFetcher)
+            raise(GoogleSpreadsheet::Error,
+                "Cannot call auth_tokens for session created by " +
+                "login_with_oauth.")
+          end
+          return @fetcher.auth_tokens
+        end
+
+        # Authentication token.
+        def auth_token(auth = :wise)
+          return self.auth_tokens[auth]
+        end
+
+        # Proc or Method called when authentication has failed.
+        # When this function returns +true+, it tries again.
+        attr_accessor :on_auth_fail
+
+        # Returns list of spreadsheets for the user as array of GoogleSpreadsheet::Spreadsheet.
+        # You can specify query parameters described at
+        # http://code.google.com/apis/spreadsheets/docs/2.0/reference.html#Parameters
+        #
+        # e.g.
+        #   session.spreadsheets
+        #   session.spreadsheets("title" => "hoge")
+        def spreadsheets(params = {})
+          query = encode_query(params)
+          doc = request(
+              :get, "https://spreadsheets.google.com/feeds/spreadsheets/private/full?#{query}")
+          result = []
+          doc.css("feed > entry").each() do |entry|
+            title = entry.css("title").text
+            url = entry.css(
+              "link[rel='http://schemas.google.com/spreadsheets/2006#worksheetsfeed']")[0]["href"]
+            result.push(Spreadsheet.new(self, url, title))
+          end
+          return result
+        end
+
+        # Returns GoogleSpreadsheet::Spreadsheet with given +key+.
+        #
+        # e.g.
+        #   # http://spreadsheets.google.com/ccc?key=pz7XtlQC-PYx-jrVMJErTcg&hl=ja
+        #   session.spreadsheet_by_key("pz7XtlQC-PYx-jrVMJErTcg")
+        def spreadsheet_by_key(key)
+          url = "https://spreadsheets.google.com/feeds/worksheets/#{key}/private/full"
+          return Spreadsheet.new(self, url)
+        end
+
+        # Returns GoogleSpreadsheet::Spreadsheet with given +url+. You must specify either of:
+        # - URL of the page you open to access the spreadsheet in your browser
+        # - URL of worksheet-based feed of the spreadseet
+        #
+        # e.g.
+        #   session.spreadsheet_by_url(
+        #     "https://docs.google.com/spreadsheet/ccc?key=pz7XtlQC-PYx-jrVMJErTcg")
+        #   session.spreadsheet_by_url(
+        #     "https://spreadsheets.google.com/feeds/" +
+        #     "worksheets/pz7XtlQC-PYx-jrVMJErTcg/private/full")
+        def spreadsheet_by_url(url)
+          # Tries to parse it as URL of human-readable spreadsheet.
+          uri = URI.parse(url)
+          if ["spreadsheets.google.com", "docs.google.com"].include?(uri.host) &&
+              uri.path =~ /\/ccc$/
+            if (uri.query || "").split(/&/).find(){ |s| s=~ /^key=(.*)$/ }
+              return spreadsheet_by_key($1)
+            end
+          end
+          # Assumes the URL is worksheets feed URL.
+          return Spreadsheet.new(self, url)
+        end
+
+        # Returns GoogleSpreadsheet::Spreadsheet with given +title+.
+        # Returns nil if not found. If multiple spreadsheets with the +title+ are found, returns
+        # one of them.
+        def spreadsheet_by_title(title)
+          return spreadsheets({"title" => title})[0]
+        end
+        
+        # Returns GoogleSpreadsheet::Worksheet with given +url+.
+        # You must specify URL of cell-based feed of the worksheet.
+        #
+        # e.g.
+        #   session.worksheet_by_url(
+        #     "http://spreadsheets.google.com/feeds/" +
+        #     "cells/pz7XtlQC-PYxNmbBVgyiNWg/od6/private/full")
+        def worksheet_by_url(url)
+          return Worksheet.new(self, nil, url)
+        end
+
+        # Returns GoogleSpreadsheet::Collection with given +url+.
+        # You must specify either of:
+        # - URL of the page you get when you go to https://docs.google.com/ with your browser and
+        #   open a collection
+        # - URL of collection (folder) feed
+        #
+        # e.g.
+        #   session.collection_by_url(
+        #     "https://docs.google.com/?pli=1&authuser=0#folders/" +
+        #     "0B9GfDpQ2pBVUODNmOGE0NjIzMWU3ZC00NmUyLTk5NzEtYaFkZjY1MjAyxjMc")
+        #   session.collection_by_url(
+        #     "http://docs.google.com/feeds/default/private/full/folder%3A" +
+        #     "0B9GfDpQ2pBVUODNmOGE0NjIzMWU3ZC00NmUyLTk5NzEtYaFkZjY1MjAyxjMc")
+        def collection_by_url(url)
+          uri = URI.parse(url)
+          if uri.host == "docs.google.com" && uri.fragment =~ /^folders\/(.+)$/
+            # Looks like a URL of human-readable collection page. Converts to collection feed URL.
+            url = "https://docs.google.com/feeds/default/private/full/folder%3A#{$1}"
+          end
+          return Collection.new(self, url)
+        end
+
+        # Creates new spreadsheet and returns the new GoogleSpreadsheet::Spreadsheet.
+        #
+        # e.g.
+        #   session.create_spreadsheet("My new sheet")
+        def create_spreadsheet(
+            title = "Untitled",
+            feed_url = "https://docs.google.com/feeds/documents/private/full")
+          
+          xml = <<-"EOS"
+            <atom:entry
+                xmlns:atom="http://www.w3.org/2005/Atom"
+                xmlns:docs="http://schemas.google.com/docs/2007">
+              <atom:category
+                  scheme="http://schemas.google.com/g/2005#kind"
+                  term="http://schemas.google.com/docs/2007#spreadsheet"
+                  label="spreadsheet"/>
+              <atom:title>#{h(title)}</atom:title>
+            </atom:entry>
+          EOS
+
+          doc = request(:post, feed_url, :data => xml, :auth => :writely)
+          ss_url = doc.css(
+            "link[rel='http://schemas.google.com/spreadsheets/2006#worksheetsfeed']")[0]["href"]
+          return Spreadsheet.new(self, ss_url, title)
+          
+        end
+
+        def request(method, url, params = {}) #:nodoc:
+          
+          # Always uses HTTPS.
+          url = url.gsub(%r{^http://}, "https://")
+          data = params[:data]
+          auth = params[:auth] || :wise
+          if params[:header]
+            extra_header = params[:header]
+          elsif data
+            extra_header = {"Content-Type" => "application/atom+xml"}
+          else
+            extra_header = {}
+          end
+          response_type = params[:response_type] || :xml
+
+          while true
+            response = @fetcher.request_raw(method, url, data, extra_header, auth)
+            if response.code == "401" && @on_auth_fail && @on_auth_fail.call()
+              next
+            end
+            if !(response.code =~ /^2/)
+              raise(
+                response.code == "401" ? AuthenticationError : GoogleSpreadsheet::Error,
+                "Response code #{response.code} for #{method} #{url}: " +
+                CGI.unescapeHTML(response.body))
+            end
+            return convert_response(response, response_type)
+          end
+          
+        end
+        
+        def inspect
+          return "#<%p:0x%x>" % [self.class, self.object_id]
+        end
+
+      private
+
+        def convert_response(response, response_type)
+          case response_type
+            when :xml
+              return Nokogiri.XML(response.body)
+            when :raw
+              return response.body
+            else
+              raise(GoogleSpreadsheet::Error,
+                  "Unknown params[:response_type]: %s" % response_type)
+          end
+        end
+
+        def authenticate(mail, password, auth)
+          params = {
+            "accountType" => "HOSTED_OR_GOOGLE",
+            "Email" => mail,
+            "Passwd" => password,
+            "service" => auth.to_s(),
+            "source" => "Gimite-RubyGoogleSpreadsheet-1.00",
+          }
+          header = {"Content-Type" => "application/x-www-form-urlencoded"}
+          response = request(:post,
+            "https://www.google.com/accounts/ClientLogin",
+            :data => encode_query(params),
+            :auth => :none,
+            :header => header,
+            :response_type => :raw)
+          return response.slice(/^Auth=(.*)$/, 1)
+        end
+
+    end
+
+end