googletastic 0.0.1

data/lib/googletastic/helpers/event.rb

@@ -0,0 +1,26 @@
+module Googletastic::Helpers::EventModelHelper
+  
+  def self.included(base, &block)
+    base.extend ClassMethods
+    base.class_eval do
+      include InstanceMethods
+    end
+  end
+  
+  module InstanceMethods
+    attr_accessor :google_doc
+    
+    def hello
+#      puts _googletastic_options.inspect + " OPTIONS!"
+    end
+    
+    def google_doc
+      @google_doc ||= Googletastic::DocList.find(self.remote_id)
+      @google_doc
+    end
+  end
+  
+  module ClassMethods
+    
+  end
+end

data/lib/googletastic/helpers/form.rb

@@ -0,0 +1,102 @@
+# was Googletastic::Helpers::Form, but rails through fits with namespacing problems
+module Googletastic::Helpers::FormModelHelper
+  
+  # REQUIREMENTS:
+  # DEFINE 'formkey' property on model
+  
+  # class options for Form:
+  #   as: property name for the googletastic form
+  #   foreign_key: foreign key to reference it, defaults to "as"_id
+  #   sync: the properties you want to sync with the form
+  #   redirect_to: where to redirect the forms submission
+  #   form_only: don't include title and header that google gives you (defaults to false)
+  def self.included(base)
+    # defaults
+    options = Googletastic[base]
+    options[:as] ||= "google_form"
+    options[:foreign_key] ||= "#{options[:as]}_id"
+    options[:form_key] ||= "form_key"
+    options[:form_only] = false unless options.has_key?(:form_only)
+    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]
+    form_key    = options[:form_key]
+    
+    # eval
+    base.class_eval <<-end_eval, __FILE__, __LINE__
+      attr_accessor :#{as}
+      attr_accessor :content
+      
+      def self.find_with_#{as}(*args)
+        google_records = Googletastic::Form.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,
+              :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
+      
+      # get form content
+      def get
+        self.#{as}.form_key ||= self.#{form_key}
+        self.#{as}.get
+      end
+      
+      if base.is_a?(ActiveRecord::Base)
+        
+        before_validation       :clean_form_key
+        validates_presence_of   :#{as}
+        validates_uniqueness_of :#{as}
+        validate                :validate_formkey_is_valid
+        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
+
+        def validate_form_key_is_valid
+          case self.#{as}.get
+          when Net::HTTPSuccess
+            true
+          else
+            errors.add(:form_key, "is not a valid Google Forms key or URL or error connecting to Google")
+            false
+          end
+        end
+
+      end
+    end_eval
+  end
+  
+end

data/lib/googletastic/helpers.rb

@@ -0,0 +1,18 @@
+module Googletastic::Helpers
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
+  
+  
+  module ClassMethods
+    
+    def googletastic(model, options = {})
+      Googletastic.options_for(self, options)
+      
+      include ("Googletastic::Helpers::#{model.to_s.camelize}ModelHelper").constantize
+    end
+    
+  end
+end
+
+require_local "helpers/*", __FILE__

data/lib/googletastic/image.rb

@@ -0,0 +1,121 @@
+class Googletastic::Image < Googletastic::Base
+  
+  attr_accessor :url, :width, :height, :size, :thumbnails, :title, :summary, :content_type
+  attr_accessor :album_id, :access, :commentable, :id, :created_at, :updated_at, :kind
+  
+  class << self
+    
+    # http://code.google.com/apis/picasaweb/docs/2.0/reference.html#Parameters
+    def valid_queries
+      {
+        :access => "access",
+        :geo_coordinates => "bbox",
+        :geo_location => "l",
+        :image_max_size => "imgmax",
+        :thumb_size => "thumbsize",
+        :kind => "kind",
+        :tag => "tag",
+      }.merge(super)
+    end
+    
+    def valid_access?(value)
+      %w(all private public visible).include?(value)
+    end
+    
+    def valid_image_max_size?(value)
+      [94, 110, 128, 200, 220, 288, 320, 400, 512, 576, 640, 720, 800, 912, 1024, 1152, 1280, 1440, 1600].include?(value)
+    end
+    
+    def valid_kind?(value)
+      %w(album photo comment tag user).include?(value)
+    end
+    
+    def client_class
+      "Photos"
+    end
+    
+    def index_url
+      "http://picasaweb.google.com/data/feed/api/user/#{Googletastic.credentials[:username]}"
+    end
+    
+    def build_url(options)
+      base = options.has_key?(:url) ? options[:url] : self.index_url
+      options[:url] = base
+      options[:kind] = "photo" unless options.has_key?(:kind)
+      options[:access] ||= "all"
+      #options[:image_max_size] = 720 unless options.has_key?(:image_max_size)
+      super(options)
+    end
+    
+    def unmarshall(xml)
+      records = xml.xpath("//atom:entry", ns_tag("atom")).collect do |record|
+        # thumbnails
+        thumbnails = record.xpath("media:group/media:thumbnail").collect do |thumbnail|
+          url     = thumbnail["url"]
+          width   = thumbnail["width"].to_i
+          height  = thumbnail["height"].to_i
+          Googletastic::Thumbnail.new(
+            :url => url,
+            :width => width,
+            :height => height
+          )
+        end
+
+        id            = record.xpath("atom:id", 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
+        kind          = "photo"
+        title         = record.xpath("atom:title", ns_tag("atom")).first.text
+        summary       = record.xpath("atom:summary", ns_tag("atom")).first.text
+                    
+        album_id      = record.xpath("gphoto:albumid", ns_tag("gphoto")).first.text
+        access        = record.xpath("gphoto:access", ns_tag("gphoto")).first.text
+        width         = record.xpath("gphoto:width", ns_tag("gphoto")).first.text.to_i
+        height        = record.xpath("gphoto:height", ns_tag("gphoto")).first.text.to_i
+        size          = record.xpath("gphoto:size", ns_tag("gphoto")).first.text.to_i
+        
+        commentable   = record.xpath("gphoto:commentingEnabled", ns_tag("gphoto")).first.text == "true" ? true : false
+                    
+        content       = record.xpath("media:group/media:content").first
+        url           = content["url"].to_s
+        content_type  = content["type"].to_s
+
+        Googletastic::Image.new(
+          :id => id,
+          :created_at => created_at,
+          :kind => kind,
+          :title => title,
+          :summary => summary,
+          :album_id => album_id,
+          :access => access,
+          :width => width,
+          :height => height,
+          :size => size,
+          :commentable => commentable,
+          :url => url,
+          :content_type => content_type,
+          :thumbnails => thumbnails
+        )
+      end
+      records
+    end
+    
+    # not implemented
+    def marshall(record)
+      Nokogiri::XML::Builder.new { |xml| 
+        xml.entry('xmlns' => Googletastic::ATOM_NS, 'xmlns:docs' => ns("docs")) {
+          if record.id
+            xml.id {
+              xml.text show_url(record.id)
+            }
+          end
+          xml.title {
+            xml.text record.title
+          }
+        }
+      }.to_xml
+    end
+    
+  end
+  
+end

data/lib/googletastic/mixins/actions.rb

@@ -0,0 +1,113 @@
+module Googletastic::Mixins::Actions
+  include_class_and_instance_modules
+  
+  module ClassMethods
+    
+    # see the data live on google docs
+    def show_url(id)
+      raise "Implement in Sublass"
+    end
+    
+    # edit the data on google docs
+    def edit_url(id)
+      raise "Implement in Subclass"
+    end
+    
+    # update the data via xml
+    def update_url(id)
+      raise "Implement in Subclass"
+    end
+    
+    # xml feed
+    def index_url(ids = nil)
+      raise "Implement in Subclass"
+    end
+    
+    # xml entry feed
+    def get_url(id)
+      raise "Implement 'get' in subclass"
+    end
+    
+    def upload_url(id = nil)
+      raise "Implement in Subclass"
+    end
+    
+    def download_url(id)
+      raise "Implement in Subclass"
+    end
+  end
+  
+  module InstanceMethods
+    def show_url
+      self.class.show_url(self.id)
+    end
+
+    def edit_url
+      self.class.edit_url(self.id)
+    end
+
+    def index_url(ids = nil)
+      self.class.index_url(ids)
+    end
+    
+    def get_url
+      self.class.get_url(self.id)
+    end
+
+    def update_url
+      self.class.update_url(self.id)
+    end
+
+    def download_url
+      self.class.download_url(self.id)
+    end
+
+    def upload_url
+      puts "UPLOADURL"
+      self.class.upload_url(self.id)
+      puts "POST"
+    end
+      
+    def save
+      create_or_update
+    end
+
+    def destroy
+
+    end
+
+    def clone
+
+    end
+
+    def reload(options = nil)
+    end
+
+    def new_record?
+      self.id.nil?
+    end
+    
+    private
+      def create_or_update
+        result = new_record? ? create : update
+        result != false
+      end
+
+      def create
+        if has_attachment?
+          self.class.client.post_file(self.class.index_url, self.attachment_path, mime_type, self.to_xml)
+        else
+          self.class.client.post(self.class.index_url, self.to_xml)
+        end
+      end
+
+      def update(attribute_names = @attributes.keys)
+        if has_attachment?
+          self.class.client.put_file(self.class.index_url, self.attachment_path, mime_type, self.to_xml)
+        else
+          self.class.client.put(self.edit_url || self.class.index_url, self.to_xml)
+        end
+      end
+  end
+  
+end

data/lib/googletastic/mixins/attributes.rb

@@ -0,0 +1,27 @@
+module Googletastic::Mixins::Attributes
+  attr_accessor :attributes
+  
+  def attributes=(value)
+    return if value.nil?
+    attributes = value.dup
+    attributes.stringify_keys!
+    @attributes = attributes
+    attributes.each do |k, v|
+      respond_to?(:"#{k}=") ? send(:"#{k}=", v) : raise("unknown attribute: #{k}")
+    end
+  end
+  
+  def attribute_names
+    @attributes.keys.sort
+  end
+  
+  def has_attribute?(attr_name)
+    @attributes.has_key?(attr_name.to_s)
+  end
+  
+  def inspect
+    hash = ""
+    attributes.each { |k,v| hash << " @#{k.to_s}=#{v.inspect}" }
+    "#<#{self.class.to_s}#{hash}/>"
+  end
+end

data/lib/googletastic/mixins/finders.rb

@@ -0,0 +1,78 @@
+module Googletastic::Mixins::Finders
+  
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
+  
+  module ClassMethods
+    def first(*args)
+      find(:first, *args)
+    end
+    
+    def last(*args)
+      find(:last, *args)
+    end
+    
+    def all(*args)
+      find(:all, *args)
+    end
+    
+    def find(*args)
+      options = args.extract_options!
+
+      case args.first
+        when :first then find_initial(options)
+        when :last  then find_last(options)
+        when :all   then find_every(options)
+        else             find_from_ids(args, options)
+      end
+    end
+
+    def find_initial(options)
+      find_by_api(options.merge({:limit => 1})).first
+    end
+    
+    def find_last(options)
+      
+    end
+    
+    def find_every(options)
+      find_by_api(options)
+    end
+    
+    def find_from_ids(ids, options)
+      expects_array = ids.first.kind_of?(Array)
+      return ids.first if expects_array && ids.first.empty?
+      
+      ids = ids.flatten.compact.uniq
+      
+      case ids.size
+        when 0
+          raise "Couldn't find #{self.to_s} without an ID"
+        when 1
+          result = find_one(ids.first, options)
+          expects_array ? [ result ] : result
+        else
+          find_some(ids, options)
+      end
+    end
+    
+    def find_one(id, options)
+      options[:id] = id
+      find_by_api(options).first
+    end
+
+    def find_some(ids, options)
+      
+    end
+    
+    def find_by_api(options)
+      url = build_url(options)
+      agent = options.has_key?(:client) ? options[:client] : client
+      data = agent.get(url)
+      return data if options.has_key?(:raw) and options[:raw] == true
+      records = unmarshall(Nokogiri::XML(data.body)).collect {|r| r.response = data; r}
+    end
+  end
+  
+end

data/lib/googletastic/mixins/namespaces.rb

@@ -0,0 +1,42 @@
+module Googletastic::Mixins::Namespaces
+  
+  NAMESPACES = {
+    "gphoto" => "http://schemas.google.com/photos/2007",
+    "media" => "http://search.yahoo.com/mrss",
+    "openSearch" => "http://a9.com/-/spec/opensearchrss/1.0/",
+    "docs" => "http://schemas.google.com/docs/2007",
+    "atom" => "http://www.w3.org/2005/Atom",
+    "gd" => "http://schemas.google.com/g/2005",
+    "gAcl" => "http://schemas.google.com/acl/2007",
+    "exif" => "http://schemas.google.com/photos/exif/2007",
+    "app" => "http://www.w3.org/2007/app",
+    "gCal" => "http://schemas.google.com/gCal/2005",
+    "gContact" => "http://schemas.google.com/contact/2008",
+    "batch" => "http://schemas.google.com/gdata/batch"
+  } unless defined?(NAMESPACES)
+    
+  def self.included(base)
+    base.extend ClassMethods
+  end
+  
+  module ClassMethods
+    def ns(name)
+      NAMESPACES[name]
+    end
+  
+    def ns_tag(name)
+      {name => ns(name)}
+    end
+    
+    def ns_xml(*names)
+      first = names[0]
+      names.inject({}) do |hash, name|
+        xmlns = "xmlns"
+        xmlns << ":#{name}" unless name == first
+        hash[xmlns] = ns(name)
+        hash
+      end
+    end
+  end
+  
+end

data/lib/googletastic/mixins/parsing.rb

@@ -0,0 +1,68 @@
+module Googletastic::Mixins::Parsing
+  
+  def self.included(base)
+    base.extend(ClassMethods)
+    base.class_eval do
+      include InstanceMethods
+      
+      # if you want to hook into these processes easily,
+      # without having to override/copy-paste/alias-method
+      # they're placed at convenient locations
+      # define them as a block
+      # base.define_callbacks :before_unmarshall, :during_unmarshall, :after_unmarshall
+    end
+  end
+  
+  module ClassMethods
+    
+    # cached nokogiri xml, false by default
+    attr_accessor :cache_parsed
+
+    def cache_parsed?
+      @cache_parsed == true
+    end
+    
+    # cache xml as string?
+    attr_accessor :cache_result
+    
+    def cache_result?
+      @cache_result == true
+    end
+    
+    # implement in subclasses
+    def unmarshall(xml_records)
+      raise "Implemnent in subclasses"
+    end
+    
+    # implement in subclasses
+    def marshall(records)
+      raise "Implemnent in subclasses"
+    end
+  end
+  
+  module InstanceMethods
+    # cached nokogiri xml, false by default
+    attr_accessor :cache_parsed
+    
+    def cache_parsed?
+      @cache_parsed != false || self.class.cache_result?
+    end
+    
+    # cache xml as string?
+    attr_accessor :cache_result
+    
+    def cache_result?
+      @cache_result != false || self.class.cache_result?
+    end
+    
+    def from_xml(xml)
+      self.class.unmarshall(xml)
+    end
+
+    def after_parse(parsed)
+
+    end
+    
+  end
+  
+end

data/lib/googletastic/mixins/requesting.rb

@@ -0,0 +1,84 @@
+module Googletastic::Mixins::Requesting
+  
+  def self.included(base)
+    base.extend(ClassMethods)
+    base.class_eval do
+      include InstanceMethods
+    end
+  end
+  
+  module ClassMethods
+    
+    def valid_queries
+      {
+        :limit => "max-result",
+        :offset => "start-index",
+        :start => "start-index",
+        :end => "end-index",
+        :categories => "category",
+        :with => "q"
+#        :only => "fields", # only the fields we want!
+#        :fields => "fields"
+      }
+    end
+    
+    def urlify(url, params = {})
+      if params && !params.empty?
+        query = params.collect do |k,v|
+          v = v.to_json if %w{key startkey endkey}.include?(k.to_s)
+          "#{k}=#{CGI.escape(v.to_s)}"
+        end.join("&")
+        url = "#{url}?#{query}"
+      end
+      url
+    end
+
+    # helper method for google client
+    def client(name = self.client_class)
+      Googletastic.client_for(name.to_s.underscore)
+    end
+    
+    def build_url(options)
+      base = options.has_key?(:url) ? options[:url] : self.index_url
+      options[:url] = base
+      urlify(base, extract_params(options))
+    end
+    
+    # http://code.google.com/apis/gdata/docs/2.0/reference.html#Queries
+    def extract_params(options)
+      queries = self.valid_queries
+      options.inject({}) do |converted, (key, value)|
+        real_key = queries[key]
+        if queries.has_key?(key)
+          next if self.respond_to?("valid_#{real_key}?") and !self["valid_#{real_key}?"]
+          value = self.send("convert_#{real_key}", value) if self.respond_to?("convert_#{real_key}")
+          converted[real_key] = value
+        end
+        converted
+      end
+    end
+    
+    # http://code.google.com/apis/gdata/docs/2.0/reference.html#PartialResponse
+    # link,entry(@gd:etag,id,updated,link[@rel='edit']))
+    # fields=entry[author/name='Lance']
+    def convert_fields(value)
+      value
+    end
+  end
+  
+  module InstanceMethods
+
+    def has_attachment?
+      !self.attachment_path.nil?
+    end
+    
+    def client
+      self.class.client
+    end
+    
+    def mime_type
+      return "" if has_attachment?
+      return "" #TODO
+    end
+  end
+end

data/lib/googletastic/mixins.rb

@@ -0,0 +1,5 @@
+module Googletastic::Mixins
+  
+end
+
+require_local "mixins/*", __FILE__