googletastic 0.0.1

data/lib/googletastic/event.rb

@@ -0,0 +1,149 @@
+class Googletastic::Event < Googletastic::Base
+  
+  attr_accessor :created_at, :updated_at, :title, :description
+  attr_accessor :who, :start_time, :end_time, :where, :status, :comments
+  attr_accessor :guests_can_join, :guests_can_invite, :guests_can_modify, :guests_can_see_guests, :sequence
+  # not yet implemented
+  attr_accessor :repeats, :calendar_id
+  
+  def new_record?
+    return false if !self.id.nil?
+    return true
+    # not yet using this
+    return self.class.first(:start_time => self.start_time, :end_time => self.end_time).nil?
+  end  
+    
+  def edit_url
+    self.class.edit_url(self.id)
+  end
+  
+  class << self
+    
+    def client_class
+      "Calendar"
+    end
+    
+    def index_url
+      "http://www.google.com/calendar/feeds/default/private/full"
+    end
+    
+    def edit_url(id)
+      "http://www.google.com/calendar/feeds/default/private/full/#{id}"
+    end
+    
+    # http://code.google.com/apis/calendar/data/2.0/reference.html#Parameters
+    # RFC 3339 timestamp format
+    def valid_queries
+      {
+        :timezone => "ctz",
+        :future_only => "futureevents",
+        :order => "orderby",
+        :collapse_recurring => "singleevents",
+        :show_hidden => "showhidden",
+        :before => "start-max",
+        :after => "start-min",
+        :sort => "sortorder" # should be merged with "order"
+      }.merge(super)
+    end
+    
+    def valid_order?(value)
+      %w(lastmodified starttime).include?(value)
+    end
+    
+    def valid_sort?(value)
+      %w(ascending descending).include?(value)
+    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.split("/").last
+        title       = record.xpath("atom:title", ns_tag("atom")).first.text
+        description = record.xpath("atom:content", 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
+        
+        status      = record.xpath("gd:eventStatus", ns_tag("gd")).first["value"].gsub("http://schemas.google.com/g/2005#event.", "")
+        where       = record.xpath("gd:where", ns_tag("gd")).first["valueString"].to_s
+        
+        who         = record.xpath("gd:who", ns_tag("gd")).collect do |who|
+          Googletastic::Attendee.new(
+            :name => who["valueString"].to_s,
+            :email => who["email"],
+            :role => who["rel"].gsub("http://schemas.google.com/g/2005#event.", "")
+          )
+        end
+
+        time        = record.xpath("gd:when", ns_tag("gd")).first
+        start_time  = time["startTime"].to_s
+        end_time    = time["endTime"].to_s
+        
+        guests_can_join     = record.xpath("gCal:anyoneCanAddSelf", ns_tag("gCal")).first["value"] == "true" ? true : false
+        guests_can_invite   = record.xpath("gCal:guestsCanInviteOthers", ns_tag("gCal")).first["value"] == "true" ? true : false
+        guests_can_modify   = record.xpath("gCal:guestsCanModify", ns_tag("gCal")).first["value"] == "true" ? true : false
+        guests_can_see_guests = record.xpath("gCal:guestsCanSeeGuests", ns_tag("gCal")).first["value"] == "true" ? true : false
+        sequence            = record.xpath("gCal:sequence", ns_tag("gCal")).first["value"].to_i
+        
+        Googletastic::Event.new(
+          :id => id,
+          :title => title,
+          :description => description,
+          :created_at => created_at,
+          :updated_at => updated_at,
+          :status => status,
+          :where => where,
+          :who => who,
+          :start_time => start_time,
+          :end_time => end_time,
+          :guests_can_join => guests_can_join,
+          :guests_can_invite => guests_can_invite,
+          :guests_can_modify => guests_can_modify,
+          :guests_can_see_guests => guests_can_see_guests,
+          :sequence => sequence
+        )
+      end
+      records
+    end
+    
+    def marshall(record)
+      Nokogiri::XML::Builder.new { |xml| 
+        xml.entry(ns_xml("atom", "gCal", "gd")) {
+          if record.id
+            xml.id_ {
+              xml.text record.id
+            }
+          end
+          if record.created_at
+            xml.published {
+              xml.text record.created_at
+            }
+          end
+          if record.updated_at
+            xml.updated {
+              xml.text record.updated_at
+            }
+          end
+          xml.title {
+            xml.text record.title
+          }
+          xml.content {
+            xml.text record.description
+          }
+          record.who.each do |who|
+            xml["gd"].who(
+              :email => who.email, 
+              :rel => "http://schemas.google.com/g/2005#event.#{who.role}",
+              :valueString => who.name
+            ) {
+              xml["gd"].attendeeStatus(:value => "http://schemas.google.com/g/2005#event.#{record.status}")
+            }
+          end unless record.who.nil?
+          xml["gd"].where("valueString" => record.where)
+          
+          xml["gd"].when("startTime" => record.start_time, "endTime" => record.end_time)
+        }
+      }.to_xml
+    end
+    
+  end
+  
+end

data/lib/googletastic/ext/file.rb

@@ -0,0 +1,219 @@
+require 'find'
+require 'jcode' # For string.each_char
+
+class File
+  
+  NON_TEXT_FILE_EXTENSIONS = [
+    "jpg", "gif", "jpeg", "pdf", "swf", "swc", "psd", "ai", "ae", "png", "tiff", "mp3",
+    "ttf", "otf", "bmp"
+  ].collect! { |item| ".#{item}" }#.to_hash unless defined?(NON_TEXT_FILE_EXTENSIONS)
+  
+  # removes file content
+  def self.clean(file)
+    File.truncate(file, 0)
+  end
+  
+  def self.touch(file)
+    FileUtils.touch(file) unless File.exists?(file)
+  end
+  
+  # sorts the names of files
+  def self.sort(files)
+    files.sort do |x,y|
+      xs = x.before_last("/")
+      ys = y.before_last("/")
+      xs <=> ys
+    end
+  end
+  
+  # easier to read method to see if file's empty
+  def self.empty?(file)
+    File.zero?(file)
+  end
+  
+  def self.uniq_dirs(paths)
+    dirs = []
+    paths.each do |file|
+      dirs << file.before_last("/") if file =~ /\//
+    end
+    dirs.uniq!
+    dirs
+  end
+  
+  def self.template(target_path, template_path, bind)
+    FileUtils.touch(target_path) unless File.exists?(target_path)
+    File.clean(target_path)
+    File.open(target_path, 'r+') do |f|
+      # parse the template file into this
+      f.print ERB.new(IO.read(template_path), nil, '-').result(bind) 
+    end
+  end
+  
+  def self.write(file, content)
+    File.touch(file)
+    File.clean(file)
+    File.open(file, 'r+') do |f|
+      f.print content
+    end
+  end
+  
+  def self.has_ext?(name)
+    File::NON_TEXT_FILE_EXTENSIONS[name.downcase]
+  end
+  
+  # Matches the file name
+  def self.matches(target, files_only = true, includes = [".*"], excludes = nil)
+    includes ||= [".*"]
+    # need to test this to make sure it always works
+    includes = includes.collect { |e| e.is_a?(Regexp) ? e : Regexp.new(e) }
+    excludes = excludes.collect { |e| e.is_a?(Regexp) ? e : Regexp.new(Regexp.escape(e)) } unless excludes.nil?
+    Find.find(target) do |path|
+      if excludes and excludes.any? {|e| path.match e }
+        next
+      elsif FileTest.directory?(path)
+       yield path if !files_only
+       next
+      else #we have a file
+        #name = "." + File.basename(path.downcase).split(".").last
+        yield path if includes.any? {|e| path.match e }
+      end  
+    end
+  end
+  
+  def self.num_lines(target, files_only = true, includes = [".*"], excludes = nil)
+    n = 0
+    self.matches(target, files_only, includes, excludes) do |path|
+      n += File.readlines(path).size
+    end
+    n
+  end
+  
+  def self.num_words(target, files_only = true, includes = [".*"], excludes = nil)
+    n = 0
+    self.matches(target, files_only, includes, excludes) do |path|
+      IO.read(path).scan(/\b\w+\b/) { n += 1 }
+    end
+    n
+  end
+  
+  def self.num_files(target, files_only = true, includes = [".*"], excludes = nil)
+    n = 0
+    self.matches(target, files_only, includes, excludes) do |path|
+      n += 1
+    end
+    n
+  end
+  
+  # moves all files from random places to a single directory
+  def self.move_all(target, includes = [".*"], excludes = nil)
+    
+  end
+  
+  def self.list_files(target, files_only = true, includes = [".*"], excludes = nil)
+    files = []
+    self.matches(target, files_only, includes, excludes) do |path|
+      yield path if block_given?
+      if !path.nil? and !path.eql?("") then files << path end
+    end
+    files
+  end
+  
+  def self.list_directories(target, includes = [".*"], excludes = nil)
+    dirs = []
+    self.matches(target, false, includes, excludes) do |path|
+      if FileTest.directory?(path)
+        yield path if block_given?
+        if !path.nil? and !path.eql?("") then dirs << path end
+      end
+    end
+    dirs
+  end
+  
+  def self.replace(a, b, target, includes = [".*"], excludes = [], &block)
+    a = Regexp.new(Regexp.escape(a))
+    self.replace_all(target, includes, excludes) do |line|
+      if block_given?
+        yield line, a, b
+      else            # modify lines
+        line.gsub!(a, b) unless line.match(a).nil?
+      end           # truncate to new length
+    end
+  end
+  
+  def self.replace_all(target, includes = [".*"], excludes = [], &block)
+  #  files = self.list_files(target, true, includes, excludes).sort do |a,b|
+   #   Regexp.num_matches(a, "/") <=> Regexp.num_matches(b, "/")
+  #  end
+    self.list_files(target, true, includes, excludes) do |path|
+      File.open(path, 'r+') do |f|    # open file for update
+        lines = f.readlines.collect! { |line| yield path, line if block_given? }
+        f.pos = 0                     # back to start
+        f.print lines                 # write out modified lines
+        f.truncate(f.pos)             # truncate to new length
+      end
+    end
+  end
+  
+  def self.rename_all(target, files_only = false, includes = [".*"], excludes = [], &block)
+    self.list_files(target, files_only, includes, excludes) do |path|
+      dirname = File.dirname(path)
+      filetype = File.basename(path).split(".").last
+      filename = yield path, File.basename(path).split("/").last if block_given?
+      new_path = dirname + "/" + filename
+      File.rename(path, new_path)
+    end
+  end
+  
+  # Inserts lines into a file after a specified pattern's last occurrence.
+  # This method first reads the file into memory as a string and checks to see if
+  # any of the lines you're trying to add are already there.
+  # If they are, it removes them from the inserts.
+  # Then it goes through each line, finds the index of the last occurrence of that pattern,
+  # and splices your inserts into the lines array, and writes them back to the file.
+  def self.insert_lines(target, inserts, pattern, offset = 0, duplicates = false, &block)
+    index = -1
+    content = IO.read(target)
+    accepted_inserts = []
+    inserts.each_with_index do |insert, i|
+      accepted_inserts << insert unless !duplicates and content.match(insert.strip)
+    end
+#    accepted_inserts[0] = "\n#{accepted_inserts[0]}" # next line
+    File.open(target, 'r+') do |f|
+      lines = f.readlines.each_with_index do |line, i|
+        yield line if block_given?
+        if pattern and line.match(pattern) then index = i end
+      end
+      index = index == -1 ? lines.length - 1 : index + offset
+      lines = lines.splice(accepted_inserts, index)
+      f.pos = 0
+      f.print lines
+      f.truncate(f.pos)
+    end
+  end
+  
+  def self.remove_lines(target, patterns)
+    new_lines = []
+    if !patterns.nil? and patterns.length > 0
+      patterns.map! {|p| Regexp.escape(p) }
+      pattern = Regexp.new(patterns.join("|"))
+      File.open(target, 'r+') do |f|
+        f.readlines.each { |line| new_lines << line unless line.match(pattern) }
+        f.pos = 0
+        f.print new_lines
+        f.truncate(f.pos)
+      end
+    end
+    new_lines
+  end
+  
+  def self.scan(target, pattern, position = 0)
+    new_lines = []
+    File.open(target, 'r+') do |f|
+      lines = f.readlines.each do |line|
+        match = line.match(pattern)
+        new_lines << match.captures[position] unless match.nil?
+      end
+    end
+    new_lines
+  end
+end

data/lib/googletastic/ext/pretty_print.xsl

@@ -0,0 +1,47 @@
+<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
+	<xsl:output method="html" indent="yes" encoding="ISO-8859-1"/>
+
+	<xsl:param name="indent-increment" select="'	 '"/>
+
+	<xsl:template name="newline">
+		<xsl:text disable-output-escaping="yes">
+		</xsl:text>
+	</xsl:template>
+
+	<xsl:template match="comment() | processing-instruction()">
+		<xsl:param name="indent" select="''"/>
+		<xsl:call-template name="newline"/>
+		<xsl:value-of select="$indent"/>
+		<xsl:copy />
+	</xsl:template>
+
+	<xsl:template match="text()">
+		<xsl:param name="indent" select="''"/>
+		<xsl:call-template name="newline"/>
+		<xsl:value-of select="$indent"/>
+		<xsl:value-of select="normalize-space(.)"/>
+	</xsl:template>
+	
+	<xsl:template match="text()[normalize-space(.)='']"/>
+
+	<xsl:template match="*">
+		<xsl:param name="indent" select="''"/>
+		<xsl:call-template name="newline"/>
+		<xsl:value-of select="$indent"/>
+			<xsl:choose>
+			 <xsl:when test="count(child::*) > 0">
+				<xsl:copy>
+				 <xsl:copy-of select="@*"/>
+				 <xsl:apply-templates select="*|text()">
+					 <xsl:with-param name="indent" select="concat ($indent, $indent-increment)"/>
+				 </xsl:apply-templates>
+				 <xsl:call-template name="newline"/>
+				 <xsl:value-of select="$indent"/>
+				</xsl:copy>
+			 </xsl:when>
+			 <xsl:otherwise>
+				<xsl:copy-of select="."/>
+			 </xsl:otherwise>
+		 </xsl:choose>
+	</xsl:template>
+</xsl:stylesheet>

data/lib/googletastic/ext/xml.rb

@@ -0,0 +1,10 @@
+# not sure where to fit this in yet
+module Googletastic::PrettyPrint
+  class << self
+    def xml(xml)
+      pretty_printer = File.join(File.dirname(__FILE__), "pretty_print.xsl")
+      xsl = Nokogiri::XSLT(IO.read(pretty_printer))
+      xsl.transform(xml).children.to_xml.gsub(/\t/, "")
+    end
+  end
+end

data/lib/googletastic/ext.rb

@@ -0,0 +1 @@
+require_local "ext/*", __FILE__

data/lib/googletastic/form.rb

@@ -0,0 +1,131 @@
+# from http://github.com/mocra/custom_google_forms
+class Googletastic::Form < Googletastic::Base
+  
+  attr_accessor :title, :body, :redirect_to, :form_key, :form_only
+  
+  def body(options = {}, &block)
+    @body ||= get(options, &block)
+    @body
+  end
+  
+  def submit_url
+    self.class.submit_url(self.form_key)
+  end
+  
+  def show_url
+    self.class.show_url(self.form_key)
+  end
+  
+  class << self
+    
+    def client_class
+      "Spreadsheets"
+    end
+    
+    def index_url
+      "http://spreadsheets.google.com/feeds/spreadsheets/private/full"
+    end
+    
+    def submit_url(id = "")
+      "http://spreadsheets.google.com/formResponse?formkey=#{id}"
+    end
+    
+    def show_url(id)
+      "http://spreadsheets.google.com/viewform?formkey=#{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.gsub("http://spreadsheets.google.com/feeds/spreadsheets/", "")
+        title       = record.xpath("atom:title", ns_tag("atom")).first.text
+        created_at  = record.xpath("atom:published", ns_tag("atom")).text
+        updated_at  = record.xpath("atom:updated", ns_tag("atom")).text
+        
+        # same as spreadsheet
+        Googletastic::Form.new(
+          :id => id,
+          :title => title,
+          :updated_at => DateTime.parse(updated_at)
+        )
+      end
+      records
+    end
+    
+  end
+  
+  def submit(form_key, params)
+    action = submit_url(form_key)
+    uri = URI.parse(action)
+    req = Net::HTTP::Post.new("#{uri.path}?#{uri.query}")
+    req.form_data = params
+    response = Net::HTTP.new(uri.host).start {|h| h.request(req)}
+    response
+  end
+  
+  # get(:redirect => {:url => "/our-forms", :params => {:one => "hello"}})
+  def get(options = {}, &block)
+    raise "I NEED A FORM KEY!" unless self.form_key
+    response = client.get(show_url)
+    if response.is_a?(Net::HTTPSuccess) || response.is_a?(GData::HTTP::Response)
+      unmarshall(Nokogiri::HTML(response.body), options, &block)
+    else
+      response
+    end
+  end
+  
+  # not class unmarshall, instance unmarshall
+  def unmarshall(html, options, &block)
+#    title = html.xpath("//h1[@class='ss-form-title']").first.text
+    add_redirect(html, options, &block)
+    
+    html.xpath("//textarea").each do |node|
+      node.add_child Nokogiri::XML::Text.new("\n", html)
+    end
+    
+    if self.form_only
+      html.xpath("//form").first.unlink
+    else
+      html.xpath("//div[@class='ss-footer']").first.unlink
+      html.xpath("//script").each {|x| x.unlink }
+      html.xpath("//div[@class='ss-form-container']").first.unlink
+    end
+  end
+  
+  def add_redirect(doc, options, &block)
+    action = doc.xpath("//form").first["action"].to_s
+    submit_key = action.gsub(self.submit_url, "")
+    
+    form = doc.xpath("//form").first
+    
+    form["enctype"] = "multipart/form-data"      
+    
+    # don't have time to build this correctly
+    redirect = options[:redirect] || self.redirect_to
+    if redirect
+      form["action"] = redirect[:url]
+      if redirect.has_key?(:params)
+        redirect[:params].each do |k,v|
+          hidden_node = doc.create_element('input')
+          hidden_node["name"] = k.to_s
+          hidden_node["type"] = "hidden"
+          hidden_node["value"] = v.to_s
+          form.children.first.add_previous_sibling(hidden_node)
+        end
+      end
+    end
+    
+    hidden_node = doc.create_element('input')
+    hidden_node["name"] = "submit_key"
+    hidden_node["type"] = "hidden"
+    hidden_node["value"] = submit_key
+    form.children.first.add_previous_sibling(hidden_node)
+    
+    put_node = doc.create_element('input')
+    put_node["name"] = "_method"
+    put_node["type"] = "hidden"
+    put_node["value"] = "put"
+    form.children.first.add_previous_sibling(put_node)
+
+    form
+  end
+end

data/lib/googletastic/group.rb

@@ -0,0 +1,44 @@
+class Googletastic::Group < Googletastic::Base
+  
+  attr_accessor :title, :description, :system_group
+  
+  class << self
+    
+    def index_url
+      "http://www.google.com/m8/feeds/groups/default/full"
+    end
+    
+    def client_class
+      "Contacts"
+    end
+    
+    # http://code.google.com/apis/contacts/docs/2.0/reference.html#Parameters
+    def valid_queries
+      {
+        :order => "orderby",
+        :sort => "sortorder",
+        :group => "group"
+      }.merge(super)
+    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
+        description   = record.xpath("atom:content", ns_tag("atom")).first.text
+        system_group  = record.xpath("gContact:systemGroup").first
+        system_group  = system_group["id"] unless system_group.nil?
+        
+        Googletastic::Group.new(
+          :id => id,
+          :title => title,
+          :description => description,
+          :system_group => system_group
+        )
+      end
+      records
+    end
+    
+  end
+  
+end

data/lib/googletastic/helpers/document.rb

@@ -0,0 +1,70 @@
+module Googletastic::Helpers::DocumentModelHelper
+  
+  def self.included(base)
+    # defaults
+    options = Googletastic[base]
+    options[:as] ||= "google_doc"
+    options[:foreign_key] ||= "#{options[:as]}_id"
+    if options.has_key?(:sync)
+      options[:sync] = case options[:sync].class.to_s
+        when "Symbol"
+          {options[:sync] => options[:sync]}
+        when "String"
+          {options[:sync].to_sym => options[:sync].to_sym}
+        when "Array"
+          options[:sync].collect { |v| {v.to_sym => v.to_sym} }
+        else
+          options[:sync].symbolize_keys
+        end
+    end
+    
+    # fast access
+    as          = options[:as]
+    foreign_key = options[:foreign_key]
+    sync        = options[:sync]
+    
+    # eval
+    base.class_eval <<-end_eval, __FILE__, __LINE__
+      attr_accessor :#{as} # google_doc
+      attr_accessor :content
+      
+      def self.find_with_#{as}(*args)
+        google_records = Googletastic::Document.all
+        foreign_keys = google_records.collect { |record| record.id }
+        records = find_all_by_#{foreign_key}(foreign_keys) || []
+        record_keys = records.collect { |record| record.#{foreign_key} }
+        google_records.each do |google_record|
+          if !record_keys.include?(google_record.id)
+            record = self.new(
+              :#{foreign_key} => google_record.id,
+              :created_at => google_record.created_at,
+              :updated_at => google_record.updated_at,
+              :#{as} => google_record,
+              :title => google_record.title
+            )
+            record.save
+            records << record
+          end
+        end
+        records.each do |record|
+          record.#{as} = google_records.select { |r| r.id == record.#{foreign_key} }.first
+        end
+        records
+      end
+      
+      if base.is_a?(ActiveRecord::Base)
+
+        validates_presence_of   :#{foreign_key}
+        validates_uniqueness_of :#{foreign_key}
+        before_save             :sync_with_google
+        
+        def sync_with_google
+          Hash(#{sync}).each do |mine, theirs|
+            self[mine] = self.#{as}[theirs]
+          end if Googletastic[self].has_key?(:sync)
+        end
+
+      end
+    end_eval
+  end
+end