google-spreadsheet-ruby 0.2.1 → 0.3.0

data/lib/google_spreadsheet/collection.rb

@@ -1,62 +1,4 @@
 # 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
+require "google_spreadsheet"

data/lib/google_spreadsheet/error.rb

@@ -1,12 +1,4 @@
 # 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
+require "google_spreadsheet"

data/lib/google_spreadsheet/file.rb

@@ -0,0 +1,4 @@
+# Author: Hiroshi Ichikawa <http://gimite.net/>
+# The license of this source is "New BSD Licence"
+
+require "google_spreadsheet"

data/lib/google_spreadsheet/list.rb

@@ -1,115 +1,4 @@
 # 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
+require "google_spreadsheet"

data/lib/google_spreadsheet/list_row.rb

@@ -1,84 +1,4 @@
 # 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
+require "google_spreadsheet"

data/lib/google_spreadsheet/oauth1_fetcher.rb

@@ -1,26 +1,4 @@
 # 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
+require "google_spreadsheet"

data/lib/google_spreadsheet/oauth2_fetcher.rb

@@ -1,29 +1,4 @@
 # 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
+require "google_spreadsheet"

data/lib/google_spreadsheet/record.rb

@@ -1,31 +1,4 @@
 # 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
+require "google_spreadsheet"

data/lib/google_spreadsheet/session.rb

@@ -1,297 +1,4 @@
 # 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
+require "google_spreadsheet"