google_drive 0.3.11 → 1.0.0.pre1

data/lib/google_drive/spreadsheet.rb

@@ -20,50 +20,29 @@ module GoogleDrive
 
         include(Util)
         
-        SUPPORTED_EXPORT_FORMAT = Set.new(["xls", "csv", "pdf", "ods", "tsv", "html"])
+        SUPPORTED_EXPORT_FORMAT = Set.new(["xlsx", "csv", "pdf"])
 
-        def initialize(session, worksheets_feed_url, title = nil) #:nodoc:
-          super(session, nil)
-          @worksheets_feed_url = worksheets_feed_url
-          @title = title
+        # Key of the spreadsheet.
+        def key
+          return self.id
         end
-
+        
         # URL of worksheet-based feed of the spreadsheet.
-        attr_reader(:worksheets_feed_url)
-
-        # Title of the spreadsheet.
-        #
-        # Set <tt>params[:reload]</tt> to true to force reloading the title.
-        def title(params = {})
-          if !@title || params[:reload]
-            @title = spreadsheet_feed_entry_internal(params).css("title").text
-          end
-          return @title
+        def worksheets_feed_url
+          return "https://spreadsheets.google.com/feeds/worksheets/%s/private/full" %
+              self.id
         end
 
-        # Key of the spreadsheet.
-        def key
-          if !(@worksheets_feed_url =~
-              %r{^https?://spreadsheets.google.com/feeds/worksheets/(.*)/private/.*$})
-            raise(GoogleDrive::Error,
-              "Worksheets feed URL is in unknown format: #{@worksheets_feed_url}")
-          end
-          return $1
+        # URL of feed used in the deprecated document list feed API.
+        def document_feed_url
+          return "https://docs.google.com/feeds/documents/private/full/" + CGI.escape(self.resource_id)
         end
-        
+
         # Spreadsheet feed URL of the spreadsheet.
         def spreadsheet_feed_url
-          return "https://spreadsheets.google.com/feeds/spreadsheets/private/full/#{self.key}"
+          return "https://spreadsheets.google.com/feeds/spreadsheets/private/full/" + self.id
         end
         
-        # URL which you can open the spreadsheet in a Web browser with.
-        #
-        # e.g. "http://spreadsheets.google.com/ccc?key=pz7XtlQC-PYx-jrVMJErTcg"
-        def human_url
-          # Uses Document feed because Spreadsheet feed returns wrong URL for Apps account.
-          return self.document_feed_entry_internal.css("link[rel='alternate']")[0]["href"]
-        end
-
         # DEPRECATED: Table and Record feeds are deprecated and they will not be available after
         # March 2012.
         #
@@ -72,133 +51,18 @@ module GoogleDrive
           warn(
               "DEPRECATED: Google Spreadsheet Table and Record feeds are deprecated and they " +
               "will not be available after March 2012.")
-          return "https://spreadsheets.google.com/feeds/#{self.key}/tables"
+          return "https://spreadsheets.google.com/feeds/%s/tables" % self.id
         end
 
-        # URL of feed used in document list feed API.
-        def document_feed_url
-          return "https://docs.google.com/feeds/documents/private/full/spreadsheet%3A#{self.key}"
-        end
-
-        # <entry> element of spreadsheet feed as Nokogiri::XML::Element.
-        #
-        # Set <tt>params[:reload]</tt> to true to force reloading the feed.
-        def spreadsheet_feed_entry(params = {})
-          warn(
-              "WARNING: GoogleDrive::Spreadsheet\#spreadsheet_feed_entry is deprecated and will be removed " +
-              "in the next version.")
-          return spreadsheet_feed_entry_internal(params)
-        end
-        
-        def spreadsheet_feed_entry_internal(params = {}) #:nodoc
-          if !@spreadsheet_feed_entry || params[:reload]
-            @spreadsheet_feed_entry =
-                @session.request(:get, self.spreadsheet_feed_url).css("entry")[0]
-          end
-          return @spreadsheet_feed_entry
-        end
-        
-        # <entry> element of document list feed as Nokogiri::XML::Element.
-        #
-        # Set <tt>params[:reload]</tt> to true to force reloading the feed.
-        def document_feed_entry(params = {})
-          warn(
-              "WARNING: GoogleDrive::Spreadsheet\#document_feed_entry is deprecated and will be removed " +
-              "in the next version.")
-          if !@document_feed_entry || params[:reload]
-            @document_feed_entry =
-                @session.request(:get, self.document_feed_url, :auth => :writely).css("entry")[0]
-          end
-          return @document_feed_entry
-        end
-        
-        # Creates copy of this spreadsheet with the given title.
-        def duplicate(new_title = nil)
-          new_title ||= (self.title ? "Copy of " + self.title : "Untitled")
-          header = {"GData-Version" => "3.0", "Content-Type" => "application/atom+xml;charset=utf-8"}
-          xml = <<-"EOS"
-            <entry xmlns='http://www.w3.org/2005/Atom'>
-              <id>#{h(self.document_feed_url)}</id>
-              <title>#{h(new_title)}</title>
-            </entry>
-          EOS
-          doc = @session.request(
-              :post, DOCS_BASE_URL, :data => xml, :header => header, :auth => :writely)
-          ss_url = doc.css(
-              "link[rel='http://schemas.google.com/spreadsheets/2006#worksheetsfeed']")[0]["href"]
-          return Spreadsheet.new(@session, ss_url, new_title)
-        end
-
-        # Exports the spreadsheet in +format+ and returns it as String.
-        #
-        # +format+ can be either "csv" or "pdf".
-        # In format such as "csv", only the worksheet specified with +worksheet_index+ is
-        # exported.
-        def export_as_string(format, worksheet_index = nil)
-          if ["xls", "ods", "tsv", "html"].include?(format)
-            warn("WARNING: Export with format '%s' is deprecated, and will not work in the next version." % format)
-          end
-          gid_param = worksheet_index ? "&gid=#{worksheet_index}" : ""
-          format_string = "&format=#{format}"
-          if self.human_url.match("edit")
-            url = self.human_url.gsub(/edit/, "export") + gid_param + format_string
-          else
-            url =
-              "https://spreadsheets.google.com/feeds/download/spreadsheets/Export" +
-              "?key=#{key}&exportFormat=#{format}#{gid_param}"
-          end
-          return @session.request(:get, url, :response_type => :raw)
-        end
-        
-        # Exports the spreadsheet in +format+ as a local file.
-        #
-        # +format+ can be either "xls", "csv", "pdf", "ods", "tsv" or "html".
-        # If +format+ is nil, it is guessed from the file name.
-        # In format such as "csv", only the worksheet specified with +worksheet_index+ is exported.
-        #
-        # e.g.
-        #   spreadsheet.export_as_file("hoge.ods")
-        #   spreadsheet.export_as_file("hoge.csv", nil, 0)
-        def export_as_file(local_path, format = nil, worksheet_index = nil)
-          if !format
-            format = ::File.extname(local_path).gsub(/^\./, "")
-            if !SUPPORTED_EXPORT_FORMAT.include?(format)
-              raise(ArgumentError,
-                  ("Cannot guess format from the file name: %s\n" +
-                   "Specify format argument explicitly.") %
-                  local_path)
-            end
-          end
-          open(local_path, "wb") do |f|
-            f.write(export_as_string(format, worksheet_index))
-          end
-        end
-        
-        def download_to_io(io, params = {})
-          # General downloading API doesn't work for spreadsheets because it requires a different
-          # authorization token, and it has a bug that it downloads PDF when text/html is
-          # requested.
-          raise(NotImplementedError,
-              "Use export_as_file or export_as_string instead for GoogleDrive::Spreadsheet.")
-        end
-        
         # Returns worksheets of the spreadsheet as array of GoogleDrive::Worksheet.
         def worksheets
-          doc = @session.request(:get, @worksheets_feed_url)
+          doc = @session.request(:get, self.worksheets_feed_url)
           if doc.root.name != "feed"
             raise(GoogleDrive::Error,
                 "%s doesn't look like a worksheets feed URL because its root is not <feed>." %
-                @worksheets_feed_url)
+                self.worksheets_feed_url)
           end
-          result = []
-          doc.css("entry").each() do |entry|
-            title = entry.css("title").text
-            updated = Time.parse(entry.css("updated").text)
-            url = entry.css(
-              "link[rel='http://schemas.google.com/spreadsheets/2006#cellsfeed']")[0]["href"]
-            result.push(Worksheet.new(@session, self, url, title, updated))
-          end
-          return result.freeze()
+          return doc.css("entry").map(){ |e| Worksheet.new(@session, self, e) }.freeze
         end
         
         # Returns a GoogleDrive::Worksheet with the given title in the spreadsheet.
@@ -219,10 +83,8 @@ module GoogleDrive
               <gs:colCount>#{h(max_cols)}</gs:colCount>
             </entry>
           EOS
-          doc = @session.request(:post, @worksheets_feed_url, :data => xml)
-          url = doc.css(
-            "link[rel='http://schemas.google.com/spreadsheets/2006#cellsfeed']")[0]["href"]
-          return Worksheet.new(@session, self, url, title)
+          doc = @session.request(:post, self.worksheets_feed_url, :data => xml)
+          return Worksheet.new(@session, self, doc.root)
         end
 
         # DEPRECATED: Table and Record feeds are deprecated and they will not be available after
@@ -237,12 +99,6 @@ module GoogleDrive
           return doc.css("entry").map(){ |e| Table.new(@session, e) }.freeze()
         end
         
-        def inspect
-          fields = {:worksheets_feed_url => self.worksheets_feed_url}
-          fields[:title] = @title if @title
-          return "\#<%p %s>" % [self.class, fields.map(){ |k, v| "%s=%p" % [k, v] }.join(", ")]
-        end
-        
     end
     
 end

data/lib/google_drive/util.rb

@@ -3,14 +3,13 @@
 
 require "cgi"
 
+require "google/api_client"
+
 
 module GoogleDrive
     
     module Util #:nodoc:
 
-        # The beginning of Doc List API URL that is used in all requests (version 3).
-        DOCS_BASE_URL = "https://docs.google.com/feeds/default/private/full"
-        
         EXT_TO_CONTENT_TYPE = {
             ".csv" =>"text/csv",
             ".tsv" =>"text/tab-separated-values",
@@ -37,11 +36,6 @@ module GoogleDrive
       module_function
         
         def encode_query(params)
-          for k, v in params
-            if ["ocr", "targetLanguage", "sourceLanguage"].include?(k.to_s())
-              warn("WARNING: Parameter '%s' is deprecated, and will not work in the next version." % k)
-            end
-          end
           return params.map(){ |k, v| CGI.escape(k.to_s()) + "=" + CGI.escape(v.to_s()) }.join("&")
         end
         
@@ -54,20 +48,135 @@ module GoogleDrive
               (result_query.empty? ? "" : "?#{result_query}")
         end
 
-        # Returns a URL with added version parameter ("?v=3") if needed.
-        def to_v3_url(url)
-          if url =~ %r{docs.google.com/feeds/default/private/} && !(url =~ /[?&]v=3/)
-            return concat_url(url, "?v=3")
-          else
-            return url
-          end
-        end
-
         def h(str)
           # Should also escape "\n" to keep it in cell contents.
           return CGI.escapeHTML(str.to_s()).gsub(/\n/, '
')
         end
         
+        def construct_query(arg)
+
+          case arg
+
+            when String
+              return arg
+
+            when Array
+              if arg[0].scan(/\?/).size != arg.size - 1
+                raise(
+                    ArgumentError,
+                    "The number of placeholders doesn't match the number of arguments: %p" % [arg])
+              end
+              i = 1
+              return arg[0].gsub(/\?/) do
+                v = arg[i]
+                i += 1
+                case v
+                  when String
+                    "'%s'" % v.gsub(/['\\]/){ "\\" + $& }
+                  when Time
+                    "'%s'" % v.iso8601
+                  when TrueClass
+                    "true"
+                  when FalseClass
+                    "false"
+                  else
+                    raise(ArgumentError, "Expected String, Time, true or false, but got %p" % [v])
+                end
+              end
+
+            else
+              raise(ArgumentError, "Expected String or Array, but got %p" % [arg])
+
+          end
+
+        end
+
+        def construct_and_query(args)
+          return args.select(){ |a| a }.map(){ |a| "(%s)" % construct_query(a) }.join(" and ")
+        end
+
+        def convert_params(params)
+          str_params = {}
+          for k, v in params
+            str_params[k.to_s()] = v
+          end
+          old_terms = []
+          new_params = {}
+          for k, v in str_params
+            case k
+              when "q"
+                new_params["q"] = construct_query(v)
+              # Parameters in the old API.
+              when "title"
+                if str_params["title-exact"].to_s() == "true"
+                  old_terms.push(["title = ?", v])
+                else
+                  old_terms.push(["title contains ?", v])
+                end
+              when "title-exact"
+                # Skips it. It is handled above.
+              when "opened-min"
+                old_terms.push(["lastViewedByMeDate >= ?", v])
+              when "opened-max"
+                old_terms.push(["lastViewedByMeDate <= ?", v])
+              when "edited-min"
+                old_terms.push(["modifiedDate >= ?", v])
+              when "edited-max"
+                old_terms.push(["modifiedDate <= ?", v])
+              when "owner"
+                old_terms.push(["? in owners", v])
+              when "writer"
+                old_terms.push(["? in writers", v])
+              when "reader"
+                old_terms.push(["? in readers", v])
+              when "showfolders"
+                if v.to_s() == "false"
+                  old_terms.push("mimeType != 'application/vnd.google-apps.folder'")
+                end
+              when "showdeleted"
+                if v.to_s() == "false"
+                  old_terms.push("trashed = false")
+                end
+              when "ocr", "targetLanguage", "sourceLanguage"
+                raise(ArgumentError, "'%s' parameter is no longer supported." % k)
+              else
+                new_params[k] = v
+            end
+          end
+          if !old_terms.empty?
+            if new_params.has_key?("q")
+              raise(ArgumentError, "Cannot specify both 'q' parameter and old query parameters.")
+            else
+              new_params["q"] = construct_and_query(old_terms)
+            end
+          end
+          return new_params
+        end
+
+        def singleton_class(obj)
+          class << obj
+            return self
+          end
+        end
+
+        def delegate_api_methods(obj, api_obj, exceptions = [])
+          sc = singleton_class(obj)
+          names = api_obj.class.keys.keys - exceptions
+          names.each() do |name|
+            sc.__send__(:define_method, name) do
+              api_obj.__send__(name)
+            end
+          end
+        end
+
+        def new_upload_io(path_or_io, params)
+          content_type =
+              params[:content_type] ||
+              (params[:file_name] ? EXT_TO_CONTENT_TYPE[::File.extname(params[:file_name]).downcase] : nil) ||
+              "application/octet-stream"
+          return Google::APIClient::UploadIO.new(path_or_io, content_type)
+        end
+        
     end
     
 end