google-cells 0.3.0

data/lib/google_cells/author.rb

@@ -0,0 +1,7 @@
+module GoogleCells
+  class Author < GoogleCells::GoogleObject
+    @permanent_attributes = [ :name, :email ]
+    define_accessors
+  end
+end
+

data/lib/google_cells/cell.rb

@@ -0,0 +1,32 @@
+module GoogleCells
+  class Cell < GoogleCells::GoogleObject
+    include Util
+
+    @permanent_attributes = [:title, :id, :value, :numeric_value, :row, :col, 
+      :edit_url, :worksheet]
+    define_accessors
+
+    attr_reader :input_value
+
+    def input_value=(v)
+      @input_value = v
+      worksheet.track_changes(self)
+      v
+    end
+
+    def to_xml
+<<-EOS
+    <entry>
+      <batch:id>#{e(row)},#{e(col)}</batch:id>
+      <batch:operation type="update"/>
+      <id>#{e(id)}</id>
+      <link rel="edit" type="application/atom+xml"
+        href="#{e(edit_url)}"/>
+      <gs:cell row="#{e(row)}" col="#{e(col)}" inputValue="#{e(input_value)}"/>
+    </entry>
+EOS
+    end
+  end
+end
+
+

data/lib/google_cells/cell_selector.rb

@@ -0,0 +1,18 @@
+require File.dirname(__FILE__) + '/cell_selector/row_selector'
+
+module GoogleCells
+  class CellSelector
+    include Reader
+
+    attr_accessor :min_row, :max_row, :min_col, :max_col, :worksheet
+
+    def initialize(ws)
+      @worksheet = ws
+      @min_row = 1
+      @max_row = worksheet.row_count
+      @min_col = 1
+      @max_col = worksheet.col_count
+    end
+  end
+end
+

data/lib/google_cells/cell_selector/row_selector.rb

@@ -0,0 +1,70 @@
+module GoogleCells
+  class CellSelector
+
+    class RowSelector < CellSelector
+
+      DEFAULT_BATCH_SIZE = 10
+
+      def find_each(opts={}, &block)
+        size = (opts[:batch_size] || DEFAULT_BATCH_SIZE).to_i
+        rnum = @min_row
+        loop do
+          last = [rnum + size, @max_row].min
+          break if rnum > last
+          get_cells(rnum, last).each do |cells|
+            yield Row.new(cells:cells, number:rnum, worksheet:worksheet)
+            rnum += 1
+          end
+        end
+      end
+
+      def each
+        all.each{|c| yield c}
+      end
+
+      def all
+        @rows = []
+        self.find_each(batch_size:@max_row - @min_row){|r| @rows << r}
+        @rows
+      end
+
+      def first
+        all.first
+      end
+
+      def from(num)
+        @min_row = num.to_i
+        self
+      end
+
+      def to(num)
+        @max_row = num.to_i
+        self
+      end
+
+      private
+
+      def get_cells(start, last)
+        cells = []
+        each_entry(worksheet.cells_uri, 'return-empty' => 'true', 
+          'min-row' => start.to_s, 'max-row' => last.to_s) do |entry|
+          gscell = entry.css("gs|cell")[0]
+          cell = Cell.new(
+            id: entry.css("id").text,
+            title: entry.css("title").text,
+            value: gscell.inner_text,
+            row: gscell["row"].to_i,
+            col: gscell["col"].to_i,
+            edit_url: entry.css("link[rel='edit']")[0]["href"],
+            input_value: gscell["inputValue"],
+            numeric_value: gscell["numericValue"],
+            worksheet: self.worksheet
+          )
+          cells[cell.row - start] ||= []
+          cells[cell.row - start][cell.col - 1] = cell
+        end
+        cells
+      end
+    end
+  end
+end

data/lib/google_cells/fetcher.rb

@@ -0,0 +1,27 @@
+module GoogleCells
+
+  module Fetcher
+
+    BASE_URL = 'https://spreadsheets.google.com/feeds/spreadsheets/private/full'
+
+    def raw(url=nil, params={})
+      url ||= BASE_URL
+      res = request(:get, url, url_params: params)
+      res.body
+    end
+
+    def request(method, url, params={})
+      if params[:url_params] && !params[:url_params].empty?
+        url << '?' unless url[-1] == "?"
+        url << params[:url_params].to_a.map{|k,v| "#{k}=#{v}"}.join('&')
+      end
+      GoogleCells.client.authorization.fetch_access_token!
+      GoogleCells.client.execute!(
+        :http_method => method,
+        :uri => url,
+        :headers => params[:headers],
+        :body => params[:body]
+      ) 
+    end
+  end
+end

data/lib/google_cells/folder.rb

@@ -0,0 +1,7 @@
+module GoogleCells
+  class Folder < GoogleCells::GoogleObject
+    @permanent_attributes = [ :key, :spreadsheet ]
+    define_accessors
+  end
+end
+

data/lib/google_cells/google_object.rb

@@ -0,0 +1,31 @@
+ module GoogleCells
+
+  class GoogleObject
+    class << self
+      attr_reader :permanent_attributes
+
+      def define_accessors
+        self.instance_eval do
+          @permanent_attributes.each do |k|
+            define_method(k){ @values[k] }
+          end
+        end
+      end
+    end
+
+    def initialize(attribs={})
+      @values = {}
+      self.class.permanent_attributes.each{|a| @values[a] = attribs[a]}
+
+      extra = attribs.keys - self.class.permanent_attributes
+      extra.each do |a|
+        if self.respond_to?("#{a}=")
+          instance_variable_set("@#{a}".to_sym, attribs[a])
+          next
+        end
+        raise ArgumentError, "invalid attribute #{a} passed to #{
+          self.class}"
+      end
+    end
+  end
+end

data/lib/google_cells/reader.rb

@@ -0,0 +1,19 @@
+require File.dirname(__FILE__) + '/fetcher'
+
+module GoogleCells
+
+  module Reader
+    include GoogleCells::Fetcher
+
+    def each_entry(url=nil, params={}, &block)
+      doc = raw(url, params)
+      reader = Nokogiri::XML::Reader(doc)
+      reader.each do |node|
+        next unless node.name == 'entry' && node.node_type == 
+          Nokogiri::XML::Reader::TYPE_ELEMENT
+        block.call(Nokogiri.parse(node.outer_xml))
+      end
+    end
+  end
+end
+

data/lib/google_cells/row.rb

@@ -0,0 +1,7 @@
+module GoogleCells
+
+  class Row < GoogleCells::GoogleObject
+    @permanent_attributes = [:number, :cells, :worksheet]
+    define_accessors
+  end
+end

data/lib/google_cells/spreadsheet.rb

@@ -0,0 +1,179 @@
+require 'google_cells/worksheet'
+require 'json'
+
+module GoogleCells
+
+  class Spreadsheet < GoogleCells::GoogleObject
+    extend UrlHelper
+    extend Reader
+
+    @permanent_attributes = [ :title, :updated_at, :author, :key ]
+    define_accessors
+
+    class << self
+
+      def list
+        spreadsheets = []
+        each_entry do |entry|
+          args = parse_from_entry(entry)
+          spreadsheets << Spreadsheet.new(args)
+        end
+        spreadsheets
+      end
+
+      alias_method :all, :list
+
+      def get(key)
+        res = request(:get, worksheets_uri(key))
+        args = parse_from_entry(Nokogiri.parse(res.body), key)
+        Spreadsheet.new(args)
+      end
+
+      def copy(key, opts={})
+        params = {}
+        body = nil
+        { :writers_can_share => 'writersCanShare',
+          :title  => 'title' }.each do |sym,str|
+          next unless opts[sym]
+          body ||= {}
+          body[str] = opts.delete(sym)
+        end
+        if body
+          params[:body] = body.to_json
+          params[:headers] = {'Content-Type' => 'application/json'}
+        end
+        res = request(:post, copy_uri(key), params)
+        s = get(res.data['id'])
+      end
+
+      def share(key, params)
+        body = {}
+        [:role, :type, :value].each do |sym|
+          body[sym.to_s] = params.delete(sym)
+        end
+        params[:body] = body.to_json
+
+        params[:url_params] = {}
+        params[:url_params]['sendNotificationEmails'] = params.delete(
+          :send_notification_emails) if !params[:send_notification_emails].
+          to_s.empty?
+        params[:url_params]['emailMessage'] = params.delete(
+          :email_message) if params[:email_message]
+
+        params[:headers] = {'Content-Type' => 'application/json'}
+        
+        res = request(:post, permissions_uri(key), params)
+        true
+      end
+
+      def delete(key)
+        request(:delete, file_uri(key))
+      end
+
+      def unsubscribe(params)
+        body = {}
+        body['id'] = params.delete(:id) if params[:id]
+        body['resourceId'] = params.delete(:resource_id) if params[:resource_id]
+        drive = GoogleCells.client.discovered_api('drive', 'v2')
+        GoogleCells.client.execute!(
+          :api_method => drive.channels.stop,
+          :body_object => body )
+        true
+      end
+
+      def subscribe(key, params)
+        body = {"type" => "web_hook"}
+        [:id, :address, :token, :expiration, :type].each do |sym|
+          body[sym.to_s] = params.delete(sym) if params[sym]
+        end
+        drive = GoogleCells.client.discovered_api('drive', 'v2')
+        res = GoogleCells.client.execute!(
+          :api_method => drive.files.watch,
+          :body_object => body,
+          :parameters => { 'fileId' => key })
+        res.data['resourceId']
+      end
+    end
+
+    %w( subscribe share ).each do |m|
+      define_method(m){|args| self.class.send(m, self.key, args) }
+    end
+
+    def unsubscribe(params)
+      self.class.unsubscribe(params)
+    end
+
+    def delete
+      self.class.delete(self.key)
+    end
+
+    def copy(opts={})
+      self.class.copy(self.key, opts)
+    end
+    
+    def enfold(folder_key)
+      return true if @folders && @folders.select{|f| f.key == folder_key}.first
+      body = {'id' => self.key}.to_json
+      res = self.class.request(:post, self.class.folder_uri(folder_key), 
+        :body => body, :headers => {'Content-Type' => 'application/json'})
+      @folders << Folder.new(spreadsheet:self, key:folder_key) if @folders
+      true
+    end
+
+    def defold(folder_key)
+      klass = self.class
+      res = klass.request(:delete, klass.child_uri(folder_key, self.key))
+      @folders = nil
+      true
+    end
+
+    def folders
+      return @folders if @folders
+      res = self.class.request(:get, self.class.file_uri(key))
+      data = JSON.parse(res.body)
+      return @folders = [] if data['parents'].nil?
+      @folders = data['parents'].map do |f|
+        Folder.new(spreadsheet: self, key:f['id'])
+      end
+    end
+
+    def worksheets
+      return @worksheets if @worksheets
+      @worksheets = []
+      self.class.each_entry(worksheets_uri) do |entry|
+        args = {
+          title: entry.css("title").text,
+          updated_at: entry.css("updated").text,
+          cells_uri: entry.css(
+            "link[rel='http://schemas.google.com/spreadsheets/2006#cellsfeed']"
+            )[0]["href"],
+          lists_uri: entry.css(
+            "link[rel='http://schemas.google.com/spreadsheets/2006#listfeed']"
+            )[0]["href"],
+          row_count: entry.css("gs|rowCount").text.to_i,
+          col_count: entry.css("gs|colCount").text.to_i,
+          spreadsheet: self
+        }
+        @worksheets << Worksheet.new(args)
+      end
+      return @worksheets
+    end
+
+    private
+
+    def self.parse_from_entry(entry, key=nil)
+      key ||= entry.css("link").select{|el| el['rel'] == 'alternate'}.
+        first['href'][/key=.+/][4..-1]
+      { title: entry.css("title").first.text,
+        key: key,
+        updated_at: entry.css("updated").first.text,
+        author: Author.new(
+          name: entry.css("author/name").first.text,
+          email: entry.css("author/email").first.text
+        )
+      }
+    end
+
+    def worksheets_uri; self.class.worksheets_uri(key); end
+  end
+end

data/lib/google_cells/url_helper.rb

@@ -0,0 +1,37 @@
+module GoogleCells
+
+  module UrlHelper
+
+    def worksheets_uri(key)
+      "https://spreadsheets.google.com/feeds/worksheets/#{key}/private/full"
+    end
+
+    def copy_uri(key)
+      "https://www.googleapis.com/drive/v2/files/#{key}/copy"
+    end
+
+    def permissions_uri(key)
+      "https://www.googleapis.com/drive/v2/files/#{key}/permissions"
+    end
+
+    def folder_uri(key)
+      "https://www.googleapis.com/drive/v2/files/#{key}/children"
+    end
+
+    def child_uri(folder_key, child_key)
+      "https://www.googleapis.com/drive/v2/files/#{folder_key}/children/#{child_key}"
+    end
+
+    def file_uri(key)
+      "https://www.googleapis.com/drive/v2/files/#{key}"
+    end
+
+    def watch_uri(key)
+      "https://www.googleapis.com/drive/v2/files/#{key}/watch"
+    end
+
+    def unwatch_uri
+      "https://www.googleapis.com/drive/v2/channels/stop"
+    end
+  end
+end