google_apps 0.4.6 → 0.4.8

data/lib/google_apps/atom/atom.rb

@@ -13,18 +13,43 @@ module GoogleApps
     include LibXML
 
     HASH_FUNCTION = "SHA-1"
-    DOCUMENTS = %w(user export group group_member message_attributes public_key)
 
     NAMESPACES = {
       atom: 'http://www.w3.org/2005/Atom',
       apps: 'http://schemas.google.com/apps/2006',
-      gd: 'http://schemas.google.com/g/2005'
+      gd: 'http://schemas.google.com/g/2005',
+      openSearch: 'http://a9.com/-/spec/opensearchrss/1.0/'
     }
 
+    MAPS = {
+      user: {
+        userName: :login,
+        suspended: :suspended,
+        familyName: :last_name,
+        givenName: :first_name,
+        limit: :quota,
+        password: :password
+      },
+      nickname: {
+        name: :nickname,
+        userName: :user
+      }
+    }
+
+    CATEGORY = {
+      user: [['scheme', 'http://schemas.google.com/g/2005#kind'], ['term', 'http://schemas.google.com/apps/2006#user']],
+      nickname: [['scheme', 'http://schemas.google.com/g/2005#kind'], ['term', 'http://schemas.google.com/apps/2006#nickname']],
+      group: [['scheme', 'http://schemas.google.com/g/2005#kind'], ['term', 'http://schemas.google.com/apps/2006#group']]
+    }
+
+    ENTRY_TAG = ["<atom:entry xmlns:atom=\"#{NAMESPACES[:atom]}\" xmlns:apps=\"#{NAMESPACES[:apps]}\" xmlns:gd=\"#{NAMESPACES[:gd]}\">", '</atom:entry>']
+
+    DOCUMENTS = %w(user export group group_member message_attributes public_key feed)
+
     # The idea is to make document distribution more dynamic.
     # Might be pointless but it's here for now.
     DOCUMENTS.each do |doc|
-      eval "def #{doc}\n  #{doc.camel_up}.new\nend"
+      eval "def #{doc}(*args)\n  #{doc.camel_up}.new *args\nend" # Needs __file__ and __line__
       module_function doc.to_sym
     end
   end

data/lib/google_apps/atom/document.rb

@@ -0,0 +1,41 @@
+module GoogleApps
+  module Atom
+    module Document
+      # parse takes xml, either a document or a string
+      # and returns a parsed document.  Since libxml-ruby
+      # doesn't build a parse tree dynamically this
+      # is needed more than you would think.
+      #
+      # parse xml
+      #
+      # parse returns a parsed xml document
+      def parse(xml)
+        document = make_document(xml)
+
+        Atom::XML::Parser.document(document).parse
+      end
+
+
+      # make_document takes either an xml document or a
+      # string and generates an xml document.
+      #
+      # make_document xml
+      #
+      # make_document returns an xml document.
+      def make_document(xml)
+        xml.is_a?(Atom::XML::Document) ? xml : Atom::XML::Document.string(xml)
+      end
+
+
+      # new_empty_doc creates an empty LibXML::XML::Document
+      #
+      # new_empty_doc
+      #
+      # new_empty_doc returns a LibXML::XML::Document without
+      # any nodes.
+      def new_empty_doc
+        Atom::XML::Document.new
+      end
+    end
+  end
+end

data/lib/google_apps/atom/export.rb

@@ -1,6 +1,9 @@
 module GoogleApps
   module Atom
     class Export
+      HEADER = 'HEADER_ONLY'
+      FULL = 'FULL_MESSAGE'
+
       def initialize
         @document = Atom::XML::Document.new
         set_header

data/lib/google_apps/atom/feed.rb

@@ -0,0 +1,108 @@
+module GoogleApps
+  module Atom
+    class Feed
+      # TODO: Google's feed responses are inconsistent.  Will need special fun time, assholes.
+
+      include Atom::Node
+      include Atom::Document
+
+      attr_reader :xml, :items, :next_page
+
+      TYPE_MATCH = /<id.*(user|group|nickname).*?<\/id/
+      #TYPE_MATCH = /term.*?\#(\w*?)/
+
+      def initialize(xml)
+        @xml = parse(xml)
+        @items = entries_from document: @xml, type: @xml.to_s.match(TYPE_MATCH).captures[0], entry_tag: 'entry'
+      end
+
+      # TODO: Need to make sure this works for feeds other than user.
+      def entries_from(properties)
+        type = properties[:type].to_sym
+
+        properties[:document].root.inject([]) do |results, entry|
+          if entry.name == properties[:entry_tag]
+            results << new_doc(type, node_to_ary(entry), ['apps:', 'atom:', 'gd:'])
+          end
+          set_next_page(entry) if entry.name == 'link' and entry.attributes[:rel] == 'next'
+          results
+        end
+      end
+
+
+      def set_next_page(node)
+        @next_page = node.attributes[:href]
+      end
+
+
+      # node_to_ary converts a Atom::XML::Node to an array.
+      #
+      # node_to_ary node
+      #
+      # node_to_ary returns the string representation of the
+      # given node split on \n.
+      def node_to_ary(node)
+        node.to_s.split("\n")
+      end
+
+
+      # new_doc creates a new Atom document from the data
+      # provided in the feed.  new_doc takes a type, an
+      # array of content to be placed into the document
+      # as well as an array of filters.
+      #
+      # new_doc 'user', content_array, ['apps:']
+      #
+      # new_doc returns an GoogleApps::Atom document of the
+      # specified type.
+      def new_doc(type, content_array, filters)
+        content_array = filters.inject([]) do |content, filter|
+          content << grab_elements(content_array, filter)
+          content
+        end
+
+        add_category content_array, type
+
+        Atom.send type, entry_wrap(content_array.flatten).join("\n")
+      end
+
+
+      # add_category adds the proper atom:category node to the
+      # content_array
+      #
+      # add_category content_array, 'user'
+      #
+      # add_category returns the modified content_array
+      def add_category(content_array, type)
+        content_array.unshift(create_node(type: 'atom:category', attrs: Atom::CATEGORY[type.to_sym]).to_s)
+      end
+
+
+      # grab_elements applies the specified filter to the
+      # provided array.  Google's feed provides a lot of data
+      # that we don't need in an entry document.
+      #
+      # grab_elements content_array, 'apps:'
+      #
+      # grab_elements returns an array of items from content_array
+      # that match the given filter.
+      def grab_elements(content_array, filter)
+        content_array.grep(Regexp.new filter)
+      end
+
+
+      # entry_wrap adds atom:entry opening and closing tags
+      # to the provided content_array and the beginning and
+      # end.
+      #
+      # entry_wrap content_array
+      #
+      # entry_wrap returns an array with an opening atom:entry
+      # element prepended to the front and a closing atom:entry
+      # tag appended to the end.
+      def entry_wrap(content_array)
+        content_array.unshift(Atom::ENTRY_TAG[0]).push(Atom::ENTRY_TAG[1])
+      end
+    end
+  end
+end

data/lib/google_apps/atom/group.rb

@@ -1,13 +1,20 @@
 module GoogleApps
   module Atom
     class Group
+      include Atom::Node
+      include Atom::Document
+
       #ATTRIBUTES = %w(id name description perms).map(&:to_sym)
 
-      def initialize
-        @document = Atom::XML::Document.new
-        add_header
+      def initialize(xml = nil)
+        if xml
+          @document = parse(xml)
+        else
+          @document = Atom::XML::Document.new
+          add_header
+        end
       end
-      
+
       # new_group populates the Group XML document with
       # the provided values.  new_group accepts a hash
       # with the following keys:  id, name, description
@@ -36,7 +43,7 @@ module GoogleApps
           prop = Atom::XML::Node.new('apps:property')
           prop_name(prop, key)
           prop.attributes['value'] = group_values[key]
-          @document.root << prop 
+          @document.root << prop
         end
 
         @document.root
@@ -59,6 +66,32 @@ module GoogleApps
         Atom::XML::Namespace.new(@document.root, 'gd', 'http://schemas.google.com/g/2005')
       end
 
+
+      def find_values
+        map = Atom::MAPS[:user]
+
+        @document.root.each do |entry|
+          unless entry.name.match 'gd' or entry.name.match 'atom'
+            entry.attributes.each do |attribute|
+              instance_variable_set "@#{map[attribute.name.to_sym]}", check_value(attribute.value)
+            end
+          end
+        end
+      end
+
+
+      def check_value(value)
+        case value
+          when 'true'
+            true
+          when 'false'
+            false
+          else
+            value
+        end
+      end
+
+
       # prop_name takes a LibXML::XML::Node object and
       # sets the name attribute based on the provided
       # key.

data/lib/google_apps/atom/group_member.rb

@@ -1,7 +1,9 @@
 module GoogleApps
   module Atom
     class GroupMember
-      include GoogleApps::Atom::Node
+      include Atom::Node
+      include Atom::Document
+
       attr_accessor :member
 
       def initialize

data/lib/google_apps/atom/nickname.rb

@@ -1,7 +1,9 @@
 module GoogleApps
   module Atom
     class Nickname
-      include GoogleApps::Atom::Node
+      include Atom::Node
+      include Atom::Document
+
       attr_reader :nickname, :user, :document
 
       ELEMENTS = { nick: ['apps:nickname', 'name'], user: ['apps:login', 'userName'] }
@@ -48,12 +50,7 @@ module GoogleApps
       # header returns an atom:entry node with the appropriate
       # namespaces for a GoogleApps nickname document
       def header
-        node = Atom::XML::Node.new('atom:entry')
-
-        Atom::XML::Namespace.new(node, 'atom', 'http://www.w3.org/2005/Atom')
-        Atom::XML::Namespace.new(node, 'apps', 'http://schemas.google.com/apps/2006')
-
-        node
+        add_namespaces create_node(type: 'atom:entry'), atom: 'http://www.w3.org/2005/Atom', apps: 'http://schemas.google.com/apps/2006'
       end
 
 
@@ -61,11 +58,7 @@ module GoogleApps
       # appropriate attributes for a GoogleApps nickname
       # document.
       def category
-        node = Atom::XML::Node.new('atom:category')
-        node.attributes['scheme'] = 'http://schemas.google.com/g/2005#kind'
-        node.attributes['term'] = 'http://schemas.google.com/apps/2006#nickname'
-
-        node
+        create_node type: 'atom:category', attrs: Atom::CATEGORY[:nickname]
       end
 
 

data/lib/google_apps/atom/node.rb

@@ -20,6 +20,22 @@ module GoogleApps
       end
 
 
+      # add_namespaces adds the specified namespaces to the
+      # specified node.  namespaces should be a hash of name,
+      # value pairs.
+      #
+      # add_namespaces node, atom: 'http://www.w3.org/2005/Atom', apps: 'http://schemas.google.com/apps/2006'
+      #
+      # add_namespaces returns the node with namespaces
+      def add_namespaces(node, namespaces)
+        namespaces.each_pair do |name, value|
+          Atom::XML::Namespace.new node, name.to_s, value
+        end
+
+        node
+      end
+
+
       # add_attributes adds the specified attributes to the
       # given node.  It takes a LibXML::XML::Node and an
       # array of name, value attribute pairs.
@@ -50,10 +66,22 @@ module GoogleApps
       def find_and_update(document, xpath, attributes)
         document.find(xpath).each do |node|
           attributes.each_key do |attrib|
-            node.attributes[attrib.to_s] = attributes[attrib][1] if node.attributes[attrib.to_s] == attributes[attrib][0]
+            node.attributes[attrib.to_s] = attributes[attrib][1] if node.attributes[attrib.to_s].to_s == attributes[attrib][0].to_s
           end
         end
       end
+
+
+      # get_content returns the content of the specified node.
+      # If multiple nodes match the xpath value get_content
+      # will return the content of the first occurance.
+      #
+      # get_content document, '//title'
+      #
+      # get_content returns the content of the node as a string.
+      def get_content(document, xpath)
+        document.find(xpath).first.content
+      end
     end
   end
 end

data/lib/google_apps/atom/user.rb

@@ -1,89 +1,163 @@
 module GoogleApps
 	module Atom
+    # TODO: Move User attribute map to user class
+    # TODO: Update attribute map to include @ for instance variables
   	class User
-      attr_reader :document
-      
-  		def initialize
-        new_doc
-  			add_header
+      include Atom::Node
+      include Atom::Document
+
+      attr_reader :document, :login, :suspended, :first_name, :last_name, :quota, :password
+
+  		def initialize(xml = nil)
+        if xml
+          @document = parse(xml)
+          find_values
+        else
+          @document = new_empty_doc
+  			  add_header
+        end
   		end
 
-      # new_user adds the nodes necessary to create a new
-      # user in Google Apps.  new_user requires a username,
-      # first name, last name and password.  You can also
-      # provide an optional quota argument, this will override
-      # the default quota in Google Apps.
+
+      # set adds the values for the given attributes to the
+      # current document.  populates takes a hash of attribute,
+      # value pairs.
       #
-      # new_user 'username', 'first_name', 'last_name', 'password', 1024
+      # set login: 'Zuddile', password: 'old shoes'
+      def set(attributes)
+        attributes.keys.each do |key|
+          self.send("#{key}=", attributes[key])
+        end
+      end
+
+
+      # add_node creates the specified node in the user document.  It
+      # takes a type/name and an array of attribute, value pairs as
+      # arguments.  It also parses the new document and saves the
+      # copy in @document
       #
-      # new_user returns the full XML document.
-  		def new_user(user_name, first, last, password, quota=nil)
-        set_values suspended: 'false', username: user_name, password: password, first_name: first, last_name: last, quota: quota
-  		end
+      # add_node 'apps:login', [['userName', 'Zanzabar']]
+      #
+      # add_node returns a parsed copy of the new document.
+      def add_node(type, attrs) # TODO: Should take a target argument rather than only appending to @document.root
+        @document.root << create_node(type: type, attrs: attrs)
+
+        @document = parse @document
+      end
+
+
+      # update_node updates an existing node in the document.  It takes
+      # the type/name, attribute name and the new value as arguments
+      #
+      # update_node 'apps:login', :userName, true
+      def update_node(type, attribute, value)
+        find_and_update @document, "//#{type}", { attribute => [instance_variable_get("@#{Atom::MAPS[:user][attribute]}").to_s, value.to_s]}
+      end
+
+
+      # TODO: Move this method.
+      def node(name)
+        @document.find_first("//#{name}")
+      end
+
 
-      # TODO: Document
-      def set_values(values = {})
-        # Don't want to create login_node if nothing has been specified.
-        @document.root << login_node(values[:suspended], values[:username], values[:password])
-        @document.root << quota_node(values[:quota]) if values[:quota]
-        @document.root << name_node(values[:first_name], values[:last_name]) if values[:first_name] or values[:last_name]
+      # NOTE: setters should work even if target node exists but has no suspended property.  Unless libxml-ruby changes it's default for the attributes hash on a node.
 
-        @document
+
+      # suspended= sets the suspended value for the account
+      #
+      # suspended = true
+      #
+      # suspended= returns the value that has been set
+      def suspended=(value)
+        node('apps:login') ? update_node('apps:login', :suspended, value) : add_node('apps:login', [['suspended', value.to_s]])
+
+        @suspended = value
       end
 
-      # login_node adds an apps:login attribute to @document.
-      #  login_node takes a username and password as arguments
-      # it is also possible to specify that the account be 
-      # suspended.
+
+      # login= sets the login/account name for this entry
       #
-      # login_node suspended, 'username', 'password'
+      # login = 'Zanzabar'
       #
-      # login_node returns an 'apps:login' LibXML::XML::Node
-      def login_node(suspended = "false", user_name = nil, password = nil)
-        login = Atom::XML::Node.new('apps:login')
-        login['userName'] = user_name unless user_name.nil?
-        login['password'] = OpenSSL::Digest::SHA1.hexdigest password unless password.nil?
-        login['hashFunctionName'] = Atom::HASH_FUNCTION unless password.nil?
-        suspended.nil? ? login['suspended'] = 'false' : login['suspended'] = suspended
+      # login= returns the value that has been set
+      def login=(login)
+        node('apps:login') ? update_node('apps:login', :userName, login) : add_node('apps:login', [['userName', login]])
 
-        login
+        @login = login
       end
 
 
-      # quota_node adds an apps:quota attribute to @document.  
-      # quota_node takes an integer value as an argument.  This
-      # argument translates to the number of megabytes available
-      # on the Google side.
+      # first_name= sets the first name for this user entry
       #
-      # quota_node 1024
+      # first_name = 'Lou'
       #
-      # quota_node returns an 'apps:quota' LibXML::XML::Node
-  		def quota_node(limit)
-  			quota = Atom::XML::Node.new('apps:quota')
-  			quota['limit'] = limit.to_s
+      # first_name returns the value that has been set
+      def first_name=(name)
+        node('apps:name') ? update_node('apps:name', :givenName, name) : add_node('apps:name', [['givenName', name]])
 
-  			quota
-  		end
+        @first_name = name
+      end
 
-      # name_node adds an apps:name attribute to @document.  
-      # name_node takes the first and last names as arguments.
+
+      # last_name= sets the last name for this user entry
       #
-      # name_node 'first name', 'last name'
+      # last_name = 'Svensen'
       #
-      # name_node returns an apps:name LibXML::XML::Node
-  		def name_node(first = nil, last = nil)
-  			name = Atom::XML::Node.new('apps:name')
-  			name['familyName'] = last if last
-  			name['givenName'] = first if first
+      # last_name= returns the value that has been set
+      def last_name=(name)
+        node('apps:name') ? update_node('apps:name', :familyName, name) : add_node('apps:name', [['familyName', name]])
+
+        @last_name = name
+      end
+
+
+      # quota= sets the quota for this user entry
+      #
+      # quota = 123456
+      #
+      # quota= returns the value that has been set
+      def quota=(limit)
+        node('apps:quota') ? update_node('apps:quota', :limit, limit) : add_node('apps:quota', [['limit', limit.to_s]])
+
+        @quota = limit
+      end
+
+
+      # password= sets the password and hashFunctionName attributes
+      # in the apps:login node.  It takes a plaintext string as it's
+      # only argument.
+      #
+      # password = 'new password'
+      #
+      # password= returns the value that has been set
+      def password=(password)
+        hashed = hash_password(password)
+
+        node('apps:login') ? update_node('apps:login', :password, hashed) : add_node('apps:login', [['password', hashed]])
+
+        add_attributes node('apps:login'), [['hashFunctionName', Atom::HASH_FUNCTION]]
+
+        @password = hashed
+      end
+
+
+      # hash_password hashes the provided password
+      #
+      # hash_password 'new password'
+      #
+      # hash_password returns an SHA1 digest of the password
+      def hash_password(password)
+        OpenSSL::Digest::SHA1.hexdigest password
+      end
 
-  			name
-  		end
 
       # to_s returns @document as a string
       def to_s
         @document.to_s
       end
 
+
       private
 
       # new_doc re-initializes the XML document.
@@ -91,6 +165,35 @@ module GoogleApps
         @document = Atom::XML::Document.new
       end
 
+
+      # TODO: This needs to target the proper nodes.
+      # TODO: This needs to treat 'true' and 'false' properly
+      def find_values
+        map = Atom::MAPS[:user]
+
+        @document.root.each do |entry|
+          # Something in the feedLink entries causes a segfault.
+          unless entry.name.match 'gd' or entry.name.match 'atom'
+            entry.attributes.each do |attribute|
+              instance_variable_set "@#{map[attribute.name.to_sym]}", check_value(attribute.value)
+            end
+          end
+        end
+      end
+
+
+      def check_value(value)
+        case value
+          when 'true'
+            true
+          when 'false'
+            false
+          else
+            value
+        end
+      end
+
+
       def add_header
         @document.root = Atom::XML::Node.new('atom:entry')
 

data/lib/google_apps/transport.rb

@@ -5,10 +5,14 @@ require 'rexml/document'
 
 module GoogleApps
 	class Transport
-		attr_reader :request, :response, :domain
+		attr_reader :request, :response, :domain, :feeds
 		attr_accessor :auth, :user, :group, :nickname, :export
 
     BOUNDARY = "=AaB03xDFHT8xgg"
+    PAGE_SIZE = {
+      user: 100,
+      group: 200
+    }
 
 		def initialize(domain, targets = {})
 			@auth = targets[:auth] || "https://www.google.com/accounts/ClientLogin"
@@ -22,6 +26,7 @@ module GoogleApps
 			@token = nil
 			@response = nil
 			@request = nil
+      @feeds = []
 		end
 
 
@@ -109,15 +114,41 @@ module GoogleApps
     # get returns the HTTP response received from Google.
     def get(endpoint, id = nil)
       # TODO:  Need to handle <link rel='next' for pagination if wanting all users
-      id ? uri = URI(endpoint + "/#{id}") : uri = URI(endpoint)
-      #uri = URI(instance_variable_get("@#{endpoint.to_s}") + "/#{id}")
-      @request = Net::HTTP::Get.new(uri.path)
+      id ? uri = URI(endpoint + build_id(id)) : uri = URI(endpoint)
+      @request = Net::HTTP::Get.new(uri.request_uri)
       set_headers :user
 
       @response = request uri
     end
 
 
+    # get_users retrieves as many users as specified from the
+    # domain.  If no starting point is given it will grab all the
+    # users in the domain.  If a starting point is specified all
+    # users from that point on (alphabetically) will be returned.
+    #
+    # get_users start: 'lholcomb2'
+    #
+    # get_users returns the final response from google.
+    def get_users(options = {})
+      # TODO: Limit isn't working right.  It stops the retrieval but not as soon as it should.
+      @feeds, page = [], 0
+
+      options[:limit] ? limit = options[:limit] : limit = 1000000
+      options[:start] ? get(@user + "?startUsername=#{options[:start]}") : get(@user)
+
+      add_feed
+
+      while (next_page = get_next(@feeds.last.xml)) and (page * PAGE_SIZE[:user] < limit)
+        get @feeds.last.next_page
+        add_feed
+        page += 1
+      end
+
+      @response
+    end
+
+
     # add_member_to adds a member to a group in the domain.
     # It takes a group_id and a GoogleApps::Atom::GroupMember
     # document as arguments.
@@ -246,6 +277,14 @@ module GoogleApps
     end
 
 
+    # build_id checks the id string.  If it is formatted
+    # as a query string it is returned as is.  If not
+    # a / is prepended to the id string.
+    def build_id(id)
+      id =~ /^\?/ ? id : "/#{id}"
+    end
+
+
     # Grab the auth token from the response body
     def set_auth_token
       @response.body.split("\n").grep(/auth=(.*)/i)
@@ -254,6 +293,12 @@ module GoogleApps
     end
 
 
+    # add_feed adds a feed to the @feeds array.
+    def add_feed
+      @feeds << GoogleApps::Atom.feed(@response.body)
+    end
+
+
 		def request(uri)
       # TODO: Clashes with @request reader
 			Net::HTTP.start(uri.host, uri.port, :use_ssl => uri.scheme == 'https') do |http|

data/lib/google_apps.rb

@@ -1,6 +1,8 @@
 require 'google_apps/transport'
 require 'google_apps/atom/atom'
 require 'google_apps/atom/node'
+require 'google_apps/atom/document'
+require 'google_apps/atom/feed'
 require 'google_apps/atom/user'
 require 'google_apps/atom/group'
 require 'google_apps/atom/public_key'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: google_apps
 version: !ruby/object:Gem::Version
-  version: 0.4.6
+  version: 0.4.8
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-06-24 00:00:00.000000000 Z
+date: 2012-07-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: libxml-ruby
@@ -34,7 +34,9 @@ extensions: []
 extra_rdoc_files: []
 files:
 - lib/google_apps/atom/atom.rb
+- lib/google_apps/atom/document.rb
 - lib/google_apps/atom/export.rb
+- lib/google_apps/atom/feed.rb
 - lib/google_apps/atom/group.rb
 - lib/google_apps/atom/group_member.rb
 - lib/google_apps/atom/message.rb