googletastic 0.0.1

data/README.textile

@@ -0,0 +1,47 @@
+h1. Googletastic
+
+Making it more than easy to save everything on Google, so all your app has to do is say how to define pretty urls and formatting.
+
+h2. Installing
+
+<code>
+sudo gem install googletastic
+</code>
+
+h3. Installing from Source
+
+<pre><code>
+git clone git@github.com:viatropos/googletastic.git
+cd googletastic
+rake install
+</code></pre>
+
+h2. Authentication
+
+Google's API's have "two types of accounts"http://code.google.com/apis/accounts/docs/AuthForInstalledApps.html#Request:
+
+# Regular (for individuals): "GOOGLE"
+# Hosted (for Google Apps): "HOSTED" (or "HOSTED_OR_GOOGLE")
+
+Google's APIs have "3 types of authentication":http://code.google.com/apis/accounts/index.html:
+
+# "ClientLogin":http://code.google.com/apis/accounts/docs/AuthForInstalledApps.html: For single users
+# "OpenAuth":http://code.google.com/apis/accounts/docs/OAuth.html: For "registering an app":http://code.google.com/apis/accounts/docs/RegistrationForWebAppsAuto.html to automatically login.  You need to "register your domain here":https://www.google.com/accounts/ManageDomains
+# "AuthSub":http://code.google.com/apis/accounts/docs/AuthSub.html
+
+You can permanently unlock the CAPTCHA for a computer by going "here":https://www.google.com/a/accd.org/UnlockCaptcha.
+
+"Working with Authsub":http://code.google.com/apis/accounts/docs/AuthSub.html#WorkingAuthSub
+
+If this is for Google Apps, you must go to Google Docs Settings in the Admin Panel, and make sure this is selected: "Users can share documents outside this domain, but will receive a warning each time".  The most restrictive, "Users cannot share documents outside this domain", won't allow you to view documents at all.  Also, don't select "Require mydomain.com sign-in to view this form." for google forms.
+
+h2. Top 10 Things I Need the Google Data API to Have
+
+"Submit Your Ideas to Google!!!":http://productideas.appspot.com/#15/e=220cb&t=2192a&f=22150
+
+# Partial Responses for everything.
+	So we can get only the data we need.  This way we can poll our google docs for any changes and run processes on them.
+# Publish the docs as plain text.
+# Textile and Markdown support
+# Better font support in PDF documents
+# Everything Should Be TAGGABLE

data/Rakefile

@@ -0,0 +1,103 @@
+require 'rake'
+require "rake/rdoctask"
+require 'rake/gempackagetask'
+require File.join(File.expand_path(File.dirname(__FILE__)),'lib','googletastic')
+
+begin
+  require 'spec/rake/spectask'
+rescue LoadError
+  puts <<-EOS
+To use rspec for testing you must install rspec gem:
+    gem install rspec
+EOS
+  exit(0)
+end
+
+def files(path, from = __FILE__, &block)
+  Dir.glob(File.join(File.dirname(from), path)) {|file| yield file}
+end
+
+APP_ROOT = defined?(RAILS_ROOT) ? RAILS_ROOT : File.dirname(__FILE__)
+RAILS_ROOT = File.dirname(__FILE__)
+
+# http://docs.rubygems.org/read/chapter/20
+spec = Gem::Specification.new do |s|
+  s.name              = "googletastic"
+  s.author            = "Lance Pollard"
+  s.version           = Googletastic::VERSION
+  s.date              = "Mon Mar 22 20:12:47 -0700 2010"
+  s.summary           = "More than Syncing Rails Apps with the Google Data API"
+  s.homepage          = "http://github.com/viatropos/googletastic"
+  s.email             = "lancejpollard@gmail.com"
+  s.description       = "Googletastic: A New Way of Googling"
+  s.has_rdoc          = true
+  s.rubyforge_project = "googletastic"
+  s.platform          = Gem::Platform::RUBY
+  s.files             = %w(README.textile Rakefile) + 
+                          Dir["{googletastic,lib,spec}/**/*"] - 
+                          Dir["spec/tmp"]
+  s.extra_rdoc_files  = %w(README.textile)
+  s.require_path      = "lib"
+  s.add_dependency("nokogiri")
+  s.add_dependency("activesupport", ">= 2.3.5")
+  s.add_dependency("activerecord", ">= 2.3.5")
+  s.add_dependency("gdata")
+end
+
+desc "Create .gemspec file (useful for github)"
+task :gemspec do
+  File.open("#{spec.name}.gemspec", "w") do |f|
+    f.puts spec.to_ruby
+  end
+end
+
+desc "Build the gem into the current directory"
+task :gem => :gemspec do
+  `gem build #{spec.name}.gemspec`
+end
+
+desc "Print a list of the files to be put into the gem"
+task :manifest => :clean do
+  File.open("Manifest", "w") do |f|
+    spec.files.each do |file|
+      f.puts file
+    end
+  end
+end
+
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.gem_spec = spec
+end
+
+desc "Install the gem locally"
+task :install => [:package] do
+  sh %{sudo gem install pkg/googletastic-#{Googletastic::VERSION} --no-ri --no-rdoc}
+end
+
+desc "Run all specs"
+Spec::Rake::SpecTask.new('spec') do |t|
+	t.spec_opts = ["--color"]
+	t.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+desc "Print specdocs"
+Spec::Rake::SpecTask.new(:doc) do |t|
+	t.spec_opts = ["--format", "specdoc"]
+	t.spec_files = FileList['spec/*_spec.rb']
+end
+
+desc "Generate the rdoc"
+Rake::RDocTask.new do |rdoc|
+  files = ["README.textile", "lib/**/*.rb"]
+  rdoc.rdoc_files.add(files)
+  rdoc.main = "README.textile"
+  rdoc.title = "Googletastic: A New Way of Googling"
+end
+
+desc "Run the rspec"
+task :default => :spec
+
+desc "Run Googletastic Benchmarks"
+task :benchmark do
+  files("spec/benchmarks/*") {|file| system("ruby #{file}") }
+end

data/lib/googletastic/access_rule.rb

@@ -0,0 +1,45 @@
+class Googletastic::AccessRule < Googletastic::Base
+  
+  attr_accessor :title, :agent, :role, :email
+  
+  class << self
+    
+    def build_url(options)
+      base = nil
+      if options.has_key?(:document_id)
+        options[:client] = Googletastic::Document.client
+        base = "http://docs.google.com/feeds/acl/private/full/#{options[:document_id]}"
+      end
+      options[:url] = base
+      super(options)
+    end
+    
+    def unmarshall(xml)
+      records = xml.xpath("//atom:entry", ns_tag("atom")).collect do |record|
+        title = id = value = nil # reset
+        id          = record.xpath("atom:id", ns_tag("atom")).text
+        title       = record.xpath("atom:title", ns_tag("atom")).text
+        scope       = record.xpath("gAcl:scope", ns_tag("gAcl")).first
+        role        = record.xpath("gAcl:role", ns_tag("gAcl")).first["value"].to_s
+        Googletastic::AccessRule.new(
+          :id => id,
+          :title => title,
+          :email => scope["value"].to_s,
+          :agent => scope["type"].to_s,
+          :role => role
+        )
+      end
+      records
+    end
+    
+    def marshall(record)
+      
+    end
+    
+  end
+  
+  def has_access?(email)
+    self.email == email
+  end
+  
+end

data/lib/googletastic/album.rb

@@ -0,0 +1,22 @@
+class Googletastic::Album < Googletastic::Base
+  
+  class << self
+    
+    def client_class
+      "Photos"
+    end
+    
+    def index_url
+      "http://picasaweb.google.com/data/feed/api/user/default"
+    end
+    
+    def unmarshall(xml)
+      records = xml.xpath("//atom:entry", ns_tag("atom")).collect do |record|
+        
+      end
+      records
+    end
+    
+  end
+  
+end

data/lib/googletastic/app_engine.rb

@@ -0,0 +1,103 @@
+module GData
+  module Client
+    
+    # Client class to wrap working with the TBD App Engine API.
+    class AppEngine < Base
+      
+      def initialize(options = {})
+        options[:clientlogin_service] = 'ah'
+        super(options)
+      end
+      
+      # override so we can get cookie
+      def get(url)
+        set_cookie(url)
+        response = self.make_request(:get, url)
+        if response.status_code == 302
+          # if it's redirecting us, we need to get the cookie
+          new_cookie(url)
+          # now we can make the request again
+          response = self.make_request(:get, url)
+        end
+        response
+      end
+      
+      def new_cookie(url)
+        cookie = get_cookie(url)
+        headers["Cookie"] = cookie
+        Googletastic.credentials[:cookie] = cookie
+        # save the cookie to a file since we're
+        # not in the browser!
+        storage = Googletastic.keys.has_key?(:storage) ? Googletastic.keys[:storage] : :filesystem
+        
+        # heroku can't store anything on filesystem
+        if storage == :filesystem
+          File.open("config/gdata.yml", 'w') do |file|
+            file.write Googletastic.credentials.to_yaml
+          end
+        elsif storage == :environment
+          ENV["GOOGLETASTIC_GAE_COOKIE"] = cookie
+        end
+        cookie
+      end
+      
+      def get_cookie(url)
+        uri = URI.parse(url)
+        url_for_cookie = "#{uri.scheme}://#{uri.host}/_ah/login?continue=#{url}&auth=#{auth_handler.token}"
+        response = self.make_request(:get, url_for_cookie)
+        cookie = response.headers["set-cookie"].split('; ',2)[0]
+        cookie
+      end
+      
+      def set_cookie(url)
+        if Googletastic.credentials[:cookie]
+          headers["Cookie"] = Googletastic.credentials[:cookie]
+          return headers["Cookie"]
+        else
+          new_cookie(url)
+        end
+      end
+      
+      # globally push to google app engine, using the python library
+      # pushes files to gae
+      # required options:
+      #   folder => where the python command executes
+      #   username, password
+      def push(username, password, options = {})
+        options.symbolize_keys!
+        raise "Please define local GAE Folder" unless options[:folder] and File.exists?(options[:folder])
+        sleep 0.5
+        # update GAE
+        puts "Pushing to GAE..."
+        cmd = "appcfg.py update #{options[:folder]}"
+        original_values = [STDOUT.sync, STDERR.sync, $expect_verbose]
+        STDOUT.sync     = true
+        STDERR.sync     = true
+        $expect_verbose = true
+        PTY.spawn("#{cmd} 2>&1") do | input, output, pid |
+          begin
+            input.expect("Email:") do
+              output.puts("#{username}\n")
+            end
+            input.expect("Password") do
+              output.write("#{password}\n")
+            end
+            while ((str = input.gets) != nil)
+              puts str
+            end
+          rescue Exception => e
+            puts "GAE Error... #{e.inspect}"
+          end
+        end
+        STDOUT.sync     = original_values[0]
+        STDERR.sync     = original_values[1]
+        $expect_verbose = original_values[2]
+        sleep 0.5
+      end
+    end
+  end
+end
+
+module Googletastic::AppEngine
+  
+end

data/lib/googletastic/attendee.rb

@@ -0,0 +1,7 @@
+class Googletastic::Attendee < Hash # simple value object
+  
+  include Googletastic::Mixins::Attributes
+  
+  attr_accessor :email, :role, :name
+  
+end

data/lib/googletastic/base.rb

@@ -0,0 +1,46 @@
+class Googletastic::Base < Hash
+  
+  include Googletastic::Mixins::Namespaces
+  include Googletastic::Mixins::Attributes
+  include Googletastic::Mixins::Requesting
+  include Googletastic::Mixins::Parsing
+  include Googletastic::Mixins::Finders
+  include Googletastic::Mixins::Actions
+  
+  # ID's are specifically the hash key for each entry.
+  # They don't include the url for finding the document,
+  # which can be inferred from the "action" you're taking on it,
+  # and the general api.
+  attr_accessor :id
+  attr_accessor :acl
+  attr_accessor :created_at, :updated_at
+  attr_accessor :attachment_path # for docs, images...
+  # classes/records it is synced with
+  attr_accessor :synced_with
+  attr_accessor :response
+  
+  def synced_with
+    @synced_with ||= []
+    @synced_with
+  end
+  
+  def initialize(attributes = {})
+    self.attributes = attributes unless attributes.nil?
+  end
+  
+  class << self # Class methods
+    
+    # This is referring to the gdata gem's implementation,
+    # which more closely maps to the google api
+    # override if you name classes differently.
+    def client_class
+      self.to_s.split("::").last
+    end
+    
+  end
+  
+  def to_xml
+    self.class.marshall(self)
+  end
+  
+end

data/lib/googletastic/calendar.rb

@@ -0,0 +1,60 @@
+class Googletastic::Calendar < Googletastic::Base
+  
+  attr_accessor :created_at, :updated_at, :title, :role
+  attr_accessor :color, :hidden, :selected, :timezone
+  
+  class << self
+    
+    def index_url
+      "http://www.google.com/calendar/feeds/default/allcalendars/full"
+    end
+    
+    def show_url(id)
+      "http://www.google.com/calendar/embed?src=#{id}"
+    end
+    
+    def unmarshall(xml)
+      records = xml.xpath("//atom:entry", ns_tag("atom")).collect do |record|
+        id          = record.xpath("atom:id", ns_tag("atom")).first.text
+        title       = record.xpath("atom:title", ns_tag("atom")).first.text
+        created_at  = record.xpath("atom:published", ns_tag("atom")).first.text
+        updated_at  = record.xpath("atom:updated", ns_tag("atom")).first.text
+        
+        role        = record.xpath("gCal:accesslevel", ns_tag("gCal")).first["value"]
+        color       = record.xpath("gCal:color", ns_tag("gCal")).first["value"]
+        hidden      = record.xpath("gCal:hidden", ns_tag("gCal")).first["value"]
+        selected    = record.xpath("gCal:selected", ns_tag("gCal")).first["value"]
+        timezone    = record.xpath("gCal:timezone", ns_tag("gCal")).first["value"]
+        
+        Googletastic::Calendar.new(
+          :id => id,
+          :title => title,
+          :created_at => created_at,
+          :updated_at => updated_at,
+          :role => role,
+          :color => color,
+          :selected => selected,
+          :timezone => timezone
+        )
+      end
+      records
+    end
+    
+    def marshall(record)
+      Nokogiri::XML::Builder.new { |xml| 
+        xml.entry(ns_xml("atom", "gCal")) {
+          if record.id
+            xml.id {
+              xml.text "#{ID}#{record.id}"
+            }
+          end
+          xml.title {
+            xml.text record.title
+          }
+        }
+      }.to_xml
+    end
+    
+  end
+
+end

data/lib/googletastic/comment.rb

@@ -0,0 +1,3 @@
+class Googletastic::Comment < Googletastic::Base
+  
+end

data/lib/googletastic/document.rb

@@ -0,0 +1,219 @@
+# "Anonymous modules have no name to be referenced by"
+#   If you have a class constant that's undefined
+class Googletastic::Document < Googletastic::Base
+  
+  ID = "https://docs.google.com/feeds/default/private/full/"
+  FEED_BASE = 'http://docs.google.com/feeds' unless defined?(FEED_BASE)
+  FEED = 'http://docs.google.com/feeds/documents/private/full' unless defined?(FEED)
+  BASE_URL = "http://docs.google.com" unless defined?(BASE_URL)
+  DOCS_DOWNLOAD = 'download/documents/Export'
+  CSV = "text/csv" unless defined?(CSV)
+  TSV = "text/tab-separated-values" unless defined?(TSV)
+  TAB = "text/tab-separated-values" unless defined?(TAB)
+  HTML = "text/html" unless defined?(HTML)
+  HTM = "text/html" unless defined?(HTM)
+  DOC = "application/msword" unless defined?(DOC)
+  DOCX = "application/vnd.openxmlformats-officedocument.wordprocessingml.document" unless defined?(DOCX)
+  ODS = "application/x-vnd.oasis.opendocument.spreadsheet" unless defined?(ODS)
+  ODT = "application/vnd.oasis.opendocument.text" unless defined?(ODT)
+  RTF = "application/rtf" unless defined?(RTF)
+  SXW = "application/vnd.sun.xml.writer" unless defined?(SXW)
+  TXT = "text/plain" unless defined?(TXT)
+  XLS = "application/vnd.ms-excel" unless defined?(XLS)
+  XLSX = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet" unless defined?(XLSX)
+  PDF = "application/pdf" unless defined?(PDF)
+  PPT = "application/vnd.ms-powerpoint" unless defined?(PPT)
+  PPS = "application/vnd.ms-powerpoint" unless defined?(PPS)
+  
+  attr_accessor :title, :kind, :categories, :resource_id, :ext
+  
+  def has_access?(email)
+    self.class.first(:url => update_url)
+  end
+  
+  attr_reader :body
+  def body
+    return @body if @body
+    @body = Nokogiri::XML(view.body)
+  end
+  
+  attr_reader :content
+  # returns the content within the body tags for the document
+  def content
+    return @content if @content
+    body.xpath("//img").each do |img_node|
+      if img_node["src"] =~ /File\?/
+        img_node["src"] = "#{BASE_URL}/#{img_node['src']}"
+      end
+    end
+    body.xpath("//div[@id='google-view-footer']").each { |n| n.unlink }
+    @content = body.xpath("//div[@id='doc-contents']").first
+  end
+  
+  def acl
+    return @acl if @acl
+    @acl = Googletastic::AccessRule.find(:all, :document_id => id)
+  end
+  
+  # returns the styles for the document, in case you need them
+  def styles
+    
+  end
+  
+  def view
+    client.get(self.show_url)
+  end
+  
+  def download(format = "pdf")
+    client.get(self.download_url + "&exportFormat=#{format}")
+  end
+  
+  def new_record?
+    return false if !self.id.nil?
+    return self.class.first(:title => self.title, :exact_title => true).nil?
+  end
+  
+  # Time.now.xmlschema
+  class << self
+    
+    def client_class
+      "DocList"
+    end
+    
+    def valid_queries
+      {
+        :title => "title",
+        :exact_title => "title-exact",
+        :opened_after => "opened-min",
+        :opened_before => "opened-max",
+        :edited_after => "edited-min",
+        :edited_before => "edited-max",
+        :owner => "owner",
+        :writer => "writer",
+        :reader => "reader",
+        :show_folders => "showfolders",
+        :show_deleted => "showdeleted",
+        :optical_character_recognition => "ocr",
+        :translate_to => "targetLanguage",
+        :language => "sourceLanguage",
+        :permanent_delete => "delete",
+        :convert => "convert",
+        :format => "exportFormat"
+      }.merge(super)
+    end
+    
+    def valid_category?(value)
+      %w(document spreadsheet folder presentation pdf form).include?(value)
+    end
+    
+    def index_url(ids = nil)
+      "http://docs.google.com/feeds/documents/private/full"
+    end
+    
+    # docid (all lowercase)
+    def show_url(id)
+      "http://docs.google.com/View?docID=#{id}&revision=_latest"
+    end
+    
+    def get_url(id)
+      "https://docs.google.com/feeds/default/private/full/#{id}"
+    end
+    
+    def edit_url(id)
+      "http://docs.google.com/Doc?docid=#{id}"
+    end
+    
+    def update_url(id)
+      if has_attachment?
+        "http://docs.google.com/feeds/media/private/full/#{self.id}"
+      else
+        "http://docs.google.com/feeds/documents/private/full/#{self.id}"
+      end
+    end
+
+    # docId (camelcase)
+    def download_url(id)
+      "http://docs.google.com/feeds/download/documents/Export?docId=#{id}"
+    end
+    
+    def upload_url(id = nil)
+      index_url(id)
+    end
+    
+    %w(document spreadsheet folder presentation pdf form).each do |category|
+      define_method category do
+        all(:url => "#{index_url}/-/#{category}")
+      end
+    end
+    
+    def download(*args)
+      old_options = args.extract_options!
+      options = {}
+      options[:format] = old_options[:format] || "pdf"
+      options[:url] = download_url(args.first.is_a?(String) ? args.first : old_options[:id])
+      args << options
+      find(*args)
+    end
+    
+    def upload(*args)
+      client.post_file(upload_url, args.first, TXT)
+    end
+    
+    def build_url(options)
+      base = options.has_key?(:url) ? options[:url] : self.index_url
+      base.gsub!(/full$/, "expandAcl") if options.has_key?(:include) and options[:include].index(:acl)
+      base << "/#{options[:id]}" if options.has_key?(:id)
+      options[:url] = base
+      super(options)
+    end
+    
+    def unmarshall(xml)
+      records = xml.xpath("//atom:entry", ns_tag("atom")).collect do |record|
+        kind = title = id = categories = value = nil # reset
+        title       = record.xpath("atom:title", ns_tag("atom")).text
+        categories  = record.xpath("atom:category", ns_tag("atom")).collect do |category|
+          value = category["label"].to_s
+          kind = value if !kind and valid_category?(value)
+          value
+        end
+        resource_id = record.xpath("gd:resourceId", ns_tag("gd")).text
+        id          = resource_id.gsub(/#{kind}:/, "")
+        created_at  = record.xpath("atom:published", ns_tag("atom")).text
+        updated_at  = record.xpath("atom:updated", ns_tag("atom")).text
+        puts "UPDATED AT: #{updated_at.inspect}"
+        Googletastic::Document.new(
+          :id => id,
+          :title => title,
+          :categories => categories,
+          :kind => kind,
+          :resource_id => resource_id,
+          :ext => File.extname(title),
+          :created_at => DateTime.parse(created_at),
+          :updated_at => DateTime.parse(updated_at)
+        )
+      end
+      records
+    end
+    
+    def marshall(record)
+      Nokogiri::XML::Builder.new { |xml| 
+        xml.entry(ns_xml("atom", "exif", "openSearch")) {
+          if record.id
+            xml.id_ {
+              xml.text get_url(record.resource_id)
+            }
+          end
+          record.categories.each do |category|
+            xml.category(
+              :scheme => "http://schemas.google.com/g/2005#kind",
+              :term => "#{category}"
+            )
+          end
+          xml.title {
+            xml.text record.title
+          }
+        }
+      }.to_xml
+    end
+  end
+end