gnip 0.4.2

data/gemspec.rb

@@ -0,0 +1,47 @@
+#! /usr/bin/env gem build
+
+require 'rubygems'
+
+Gem::Specification::new do |spec|
+  $VERBOSE = nil
+
+  shiteless = lambda do |list|
+    list.delete_if do |file|
+      file =~ %r/\.git/ or
+      file =~ %r/\.svn/ or
+      file =~ %r/\.tmp/
+    end
+  end
+
+  spec.name = $lib
+  spec.version = $version
+  spec.platform = Gem::Platform::RUBY
+  spec.summary = $lib
+
+  spec.files = shiteless[Dir::glob("**/**")]
+  spec.executables = shiteless[Dir::glob("bin/*")].map{|exe| File::basename(exe)}
+  
+  spec.require_path = "lib" 
+
+  spec.has_rdoc = true #File::exist? "doc" 
+  # spec.test_suite_file = "test/#{ $lib }.rb" if File::file?("test/#{ $lib }.rb")
+  spec.add_dependency 'rest-client'
+  spec.add_dependency 'nokogiri'
+  spec.add_dependency 'threadify'
+  spec.add_dependency 'tagz', '>= 5.0.1'
+
+  spec.extensions << "extconf.rb" if File::exists? "extconf.rb"
+
+  spec.rubyforge_project = 'gnip'
+  spec.author = "Ara T. Howard"
+  spec.email = "ara.t.howard@gmail.com"
+  spec.homepage = "http://gnip.com"
+end
+
+
+BEGIN{ 
+  Dir.chdir(File.dirname(__FILE__))
+  $lib = 'gnip'
+  Kernel.load "./lib/#{ $lib }.rb"
+  $version = Gnip.version
+}

data/lib/gnip.rb

@@ -0,0 +1,71 @@
+# built-in libs
+#
+  require 'yaml'
+  require 'time'
+  require 'zlib'
+  require 'enumerator'
+  require 'base64'
+  # require 'erb'
+
+# gems and third party libs
+#
+  begin
+    require 'rubygems'
+    gem 'tagz', '>= 5.0.1'
+  rescue LoadError
+    'oh noes!'
+  end
+
+  begin
+    require 'restclient'
+  rescue
+    abort 'sudo gem install rest-client'
+  end
+
+  begin
+    require 'nokogiri'
+  rescue
+    abort 'sudo gem install nokogiri #=> depends on libxml + libxslt'
+  end
+
+  begin
+    require 'tagz'
+  rescue
+    abort 'sudo gem install tagz'
+  end
+
+  begin
+    require 'threadify'
+  rescue
+    abort 'sudo gem install threadify'
+  end
+
+# gnip libs
+#
+  module Gnip
+    Version = '0.4.2'
+
+    def version
+      Gnip::Version
+    end
+
+    def libdir(*args)
+      @libdir ||= File.expand_path(__FILE__).sub(/\.rb$/,'')
+      args.empty? ? @libdir : File.join(@libdir, *args)
+    end
+    extend self
+  end
+
+  require Gnip.libdir('util')
+  require Gnip.libdir('orderedhash')
+  # require Gnip.libdir('blankslate')
+  require Gnip.libdir('arguments')
+  require Gnip.libdir('options')
+  require Gnip.libdir('list')
+  require Gnip.libdir('config')
+  require Gnip.libdir('resource')
+  # require Gnip.libdir('template')
+  require Gnip.libdir('publisher')
+  require Gnip.libdir('filter')
+  require Gnip.libdir('activity')
+  require Gnip.libdir('api')

data/lib/gnip/activity.rb

@@ -0,0 +1,663 @@
+module Gnip
+  class Activity
+
+    def Activity.list_from_xml(xml, &block)
+      list = []
+      parse_xml(xml) do |activity|
+        block ? block.call(activity) : list.push(activity)
+      end
+      block ? nil : list
+    end
+
+    def Activity.from_xml(xml)
+      parse_xml(xml){|activity| return activity}
+      nil
+    end
+
+    def Activity.parse_xml(xml, &block)
+      doc = Nokogiri::XML.parse(xml)
+      list = []
+      selectors = '*/activities', 'activity'
+      selectors.each do |selector|
+        search = doc.search(selector)
+        next unless search.size > 0
+        search.each do |node|
+          activity = Activity.from_node(node)
+          block ? block.call(activity) : list.push(activity)
+        end
+      end
+      block ? nil : list
+    end
+
+    def Activity.from_node(node)
+      activity = new
+
+      if value = node.at('at')
+        activity.at = value.content
+      end
+      if value = node.at('action')
+        activity.action = value.content
+      end
+      if value = node.at('activityID')
+        activity.activity_id = value.content
+      end
+      if value = node.at('URL')
+        activity.url = value.content
+      end
+      if values = node.search('source')
+        values.each{|value| activity.sources << value.content}
+      end
+      if values = node.search('keyword')
+        values.each{|value| activity.keywords << value.content}
+      end
+      if places = node.search('place')
+        places.each do |value|
+          place = activity.places.build
+          %w( point elev floor featuretypetag featurename relationshiptag ).each do |tag|
+            tag_value = value.at(tag)
+            place.send("#{ tag }=", tag_value.content) if tag_value
+          end
+        end
+      end
+      if values = node.search('actor')
+        values.each do |value|
+          actor = activity.actors.build
+          actor.content = value.content
+          actor.meta_url = value['metaURL']
+          actor.uid = value['uid']
+        end
+      end
+      if values = node.search('destinationURL')
+        values.each do |value|
+          destination_url = activity.destination_urls.build
+          destination_url.content = value.content
+          destination_url.meta_url = value['metaURL']
+        end
+      end
+      if values = node.search('tag')
+        values.each do |value|
+          tag = activity.tags.build
+          tag.content = value.content
+          tag.meta_url = value['metaURL']
+        end
+      end
+      if values = node.search('to')
+        values.each do |value|
+          to = activity.tos.build
+          to.content = value.content
+          to.meta_url = value['metaURL']
+        end
+      end
+      if values = node.search('regardingURL')
+        values.each do |value|
+          regarding_url = activity.regarding_urls.build
+          regarding_url.content = value.content
+          regarding_url.meta_url = value['metaURL']
+        end
+      end
+      if payload_node = node.at('payload')
+        activity.payload! do |payload|
+          if title_node = payload_node.at('title')
+            payload.title = title_node.content
+          end
+          if body_node = payload_node.at('body')
+            payload.body = body_node.content
+          end
+          if raw_node = payload_node.at('raw')
+            payload.raw = payload.decode(raw_node.content)
+          end
+          if media_url_nodes = payload_node.search('mediaURL')
+            media_url_nodes.each do |media_url_node|
+              media_url = payload.media_urls.build
+              media_url.content = media_url_node.content
+              media_url.height = media_url_node['height']
+              media_url.width = media_url_node['width']
+              media_url.duration = media_url_node['duration']
+              media_url.mime_type = media_url_node['mimeType']
+              media_url.type = media_url_node['type']
+            end
+          end
+        end
+      end
+
+      activity
+    end
+
+    def Activity.from_hash(*args)
+      args, options = Gnip.args_for(args)
+
+      activity = new
+
+      %w(
+        at
+        action
+        activity_id
+        url
+        sources
+        keywords
+        places
+        actors
+        destination_urls
+        tags
+        tos
+        regarding_urls
+        payload
+      ).each do |opt|
+        if options.hasopt?(opt)
+          activity.send("#{ opt }=", options.getopt(opt))
+        end
+      end
+
+      activity
+    end
+
+    def Activity.from_yaml(string)
+      string = string.read if string.respond_to?(:read)
+      to_hash(YAML.load(string))
+    end
+
+    Attributes = []
+
+    Attributes << 'activity_id'
+      def activity_id
+        @activity_id ||= nil
+      end
+      def activity_id= value
+        @activity_id = value.to_s
+      end
+
+    Attributes << 'at'
+      def at
+        @at ||= nil
+      end
+      def at= value
+        @at = Time === value ? value : Time.parse(value.to_s).utc #.iso8601(3)
+      end
+
+    Attributes << 'action'
+      def action
+        @action ||= nil
+      end
+      def action= value
+        @action = value.to_s
+      end
+
+    Attributes << 'url'
+      def url
+        @url ||= nil
+      end
+      def url= value
+        @url = value.to_s
+      end
+
+    Attributes << 'sources'
+      def sources
+        @sources ||= List.of(String)
+      end
+      def sources= value
+        sources.replace(value)
+      end
+
+    Attributes << 'keywords'
+      def keywords
+        @keywords ||= List.of(String)
+      end
+      def keywords= value
+        keywords.replace(value)
+      end
+
+    Attributes << 'places'
+      def places
+        @places ||= List.of(Place)
+      end
+      def places= value
+        places.replace(value)
+      end
+
+    Attributes << 'actors'
+      def actors
+        @actors ||= List.of(Actor)
+      end
+      def actors= value
+        actors.replace(value)
+      end
+
+    Attributes << 'destination_urls'
+      def destination_urls
+        @destination_urls ||= List.of(DestinationURL)
+      end
+      def destination_urls= value
+        destination_urls.replace(value)
+      end
+
+    Attributes << 'tags'
+      def tags
+        @tags ||= List.of(Tag)
+      end
+      def tags= value
+        tags.replace(value)
+      end
+
+    Attributes << 'tos'
+      def tos
+        @tos ||= List.of(To)
+      end
+      def tos= value
+        tos.replace(value)
+      end
+
+    Attributes << 'regarding_urls'
+      def regarding_urls
+        @regarding_urls ||= List.of(RegardingURL)
+      end
+      def regarding_urls= value
+        regarding_urls.replace(value)
+      end
+
+# TODO - extend this pattern to other elements
+#
+    Attributes << 'payload'
+      def payload(*args, &block)
+        return payload!(*args, &block) if block
+        @payload ||= nil
+      end
+      def payload!(*args, &block)
+        @payload = Payload.for(*args)
+        block ? block.call(@payload) : @payload
+      end
+      def payload= value
+        @payload = Payload.for(value)
+      end
+
+    def initialize(options = {})
+      options = Gnip.options_for(options)
+      options.each{|key, value| send("#{ key }=", value)}
+    end
+
+    include Tagz
+    def to_xml(*args)
+      args, options = Gnip.args_for(args)
+      doc = args.shift
+
+      tagz(doc) {
+        activity_{
+          at_{ at.utc.iso8601(3) }
+          action_{ action.to_s }
+    
+          if activity_id
+            activityID_{ activity_id }
+          end
+          if url
+            URL_{ url }
+          end
+          if sources
+            sources.each{|source| source_{ source } }
+          end
+          if keywords
+            keywords.each{|keyword| keyword_{ keyword } }
+          end
+          if places
+            places.each{|place| place.to_xml(tagz)}
+          end
+          if actors
+            actors.each{|actor| actor.to_xml(tagz)}
+          end
+          if destination_urls
+            destination_urls.each{|destination_url| destination_url.to_xml(tagz)}
+          end
+          if tags
+            tags.each{|tag| tag.to_xml(tagz)}
+          end
+          if tos
+            tos.each{|to| to.to_xml(tagz)}
+          end
+          if regarding_urls
+            regarding_urls.each{|regarding_url| regarding_url.to_xml(tagz)}
+          end
+          if payload
+            payload.to_xml(tagz)
+          end
+        }
+      }
+    end
+
+    class Place
+      def Place.for(*args, &block)
+        arg = args.first if(args.size == 1 and args.first.is_a?(Place))
+        new(*args, &block)
+      end
+
+      def initialize(options = {}, &block)
+        options.each{|key, value| send "#{ key }=", value}
+      end
+
+      class Point
+        def Point.for(*args, &block)
+          new(*args, &block)
+        end
+
+        attr_accessor :lat
+        attr_accessor :lon
+
+        def initialize(*args)
+          @lat, @lon = Point.parse(*args)
+        end
+
+        def Point.parse(*args)
+          string = args.join(' ')
+          coords = string.strip.split(%r/\s+/, 2).map{|coord| Util.number_for(coord)}
+          raise ArgumentError, args.inspect unless coords.size == 2
+          coords
+        end
+
+        def to_s
+          [@lat, @lon].join(' ')
+        end
+
+        def format n
+          '%03.3f' % n
+        end
+      end
+
+      attr :point
+      def point= value
+        @point = Point.for(value)
+      end
+
+      attr :elev
+      def elev= value
+        @elev = Util.number_for(value)
+      end
+
+      attr :floor
+      def floor= value
+        @floor = Util.number_for(value).to_i
+      end
+
+      attr :featuretypetag
+      def featuretypetag= value
+        @featuretypetag = String(value)
+      end
+
+      attr :featurename
+      def featurename= value
+        @featurename = String(value)
+      end
+
+      attr :relationshiptag
+      def relationshiptag= value
+        @relationshiptag = String(value)
+      end
+
+      def to_yaml(*a, &b)
+        oh = OrderedHash.new
+        oh['point'] = [point.lat, point.lon] if point
+        oh['elev'] = elev
+        oh['floor'] = floor
+        oh['featuretypetag'] = featuretypetag
+        oh['featurename'] = featurename
+        oh['relationshiptag'] = relationshiptag
+        oh.to_yaml(*a, &b)
+      end
+
+      include Tagz
+      def to_xml(*args)
+        args, options = Gnip.args_for(args)
+        doc = args.shift
+
+        tagz(doc) {
+          place_{
+            point_{ point } if point
+            elev_{ elev } if elev
+            floor_{ floor } if floor
+            featuretypetag_{ featuretypetag } if featuretypetag
+            featurename_{ featurename } if featurename
+            relationshiptag_{ relationshiptag } if relationshiptag
+          }
+        }
+      end
+    end
+
+    class MetaURL
+      attr_accessor :content
+      attr_accessor :meta_url
+
+      def MetaURL.for(*args)
+        arg = args.flatten.compact.first
+        self.class === arg ? arg : new(*args)
+      end
+
+      def initialize(*args)
+        args, options = Gnip.args_for(args)
+        self.content = args.join unless args.empty?
+        options.each{|k,v| send "#{ k }=", v}
+      end
+
+      def to_yaml(*a, &b)
+        oh = OrderedHash.new
+        oh['content'] = content
+        oh['meta_url'] = meta_url
+        oh.to_yaml(*a, &b)
+      end
+
+      include Tagz
+      def to_xml(*args)
+        args, options = Gnip.args_for(args)
+        doc = args.shift
+        tagz(doc){ send("#{ xml_tag }_", xml_attributes){ content } }
+      end
+
+      def xml_attributes
+        attributes = {}
+        attributes.update(:metaURL => meta_url) if meta_url
+        attributes
+      end
+
+      def xml_tag
+        self.class.const_get(:XML_TAG)
+      end
+    end
+
+    class Actor < MetaURL
+      XML_TAG = 'actor'
+
+      attr_accessor :uid
+
+      def to_yaml(*a, &b)
+        oh = OrderedHash.new
+        oh['content'] = content
+        oh['meta_url'] = meta_url
+        oh['uid'] = uid
+        oh.to_yaml(*a, &b)
+      end
+
+      def xml_attributes
+        attributes = super
+        attributes.update(:uid => uid) if uid
+        attributes
+      end
+    end
+
+    class Tag < MetaURL
+      XML_TAG = 'tag'
+    end
+
+    class To < MetaURL
+      XML_TAG = 'to'
+    end
+
+    class DestinationURL < MetaURL
+      XML_TAG = 'destinationURL'
+    end
+
+    class RegardingURL < MetaURL
+      XML_TAG = 'regardingURL'
+    end
+
+    class Payload
+      def Payload.for(*args)
+        return args.first if(args.size == 1 and args.first.is_a?(Place))
+        new(*args)
+      end
+
+      def initialize(options = {}, &block)
+        options.each{|key, value| send "#{ key }=", value}
+      end
+
+      def title
+        @title ||= nil
+      end
+      def title= title
+        @title = String(title)
+      end
+
+      def body
+        @body ||= nil
+      end
+      def body= body
+        @body = String(body)
+      end
+
+      def media_urls
+        @media_urls ||= List.of(MediaURL)
+      end
+      def media_urls= value
+        media_urls.replace value
+      end
+
+      def raw
+        @raw ||= nil
+      end
+      def __raw__
+        @raw ||= nil
+      end
+      def raw= raw
+        @raw = raw
+      end
+      def __raw__= raw
+        @raw = raw
+      end
+
+      include Tagz
+      def to_xml(*args)
+        args, options = Gnip.args_for(args)
+        doc = args.shift
+        tagz(doc){
+          payload_{
+            title_{ title } if title
+            body_{ normalize(body) } if body
+            media_urls.each{|media_url| media_url.to_xml(tagz)} if media_urls
+            raw_{ encode(raw) } if raw
+          }
+        }
+      end
+
+      def encode(data)
+        Util.encode(raw)
+      end
+
+      def decode(raw)
+        Util.decode(raw)
+      end
+
+      def normalize(string)
+        Util.normalize!(string)
+      end
+
+      class MediaURL
+        attr_accessor :content
+        attr_accessor :height
+        attr_accessor :width
+        attr_accessor :duration
+        attr_accessor :mime_type
+        attr_accessor :type
+
+        def initialize(*args)
+          args, options = Gnip.args_for(args)
+          self.content = args.join
+          options.each{|k,v| send "#{ k }=", v}
+        end
+
+        def to_yaml(*a, &b)
+          oh = OrderedHash.new
+          oh['content'] = content
+          oh['height'] = height
+          oh['width'] = width
+          oh['duration'] = duration
+          oh['mime_type'] = mime_type
+          oh['type'] = type
+          oh.to_yaml(*a, &b)
+        end
+
+        include Tagz
+        def to_xml(*args)
+          args, options = Gnip.args_for(args)
+          doc = args.shift
+          tagz(doc){
+            options = {}
+            options['height'] = height if height
+            options['width'] = width if width
+            options['duration'] = duration if duration
+            options['mimeType'] = mime_type if mime_type
+            options['type'] = type if type
+            mediaURL_(options){ content }
+          }
+        end
+      end
+    end
+
+    class Stream
+      def Stream.from_xml(xml, options = {}, &block)
+        doc = Nokogiri::XML.parse(xml)
+        selector = 'activityStream'
+        node = doc.at(selector)
+        Stream.from_node(node)
+      end
+
+      def Stream.from_node(node)
+        updated_at = node.at('activitiesAddedAt').content
+        buckets = []
+        node.search('bucket').each do |bucket|
+          buckets << bucket['href']
+        end
+        Stream.new(:updated_at => updated_at, :buckets => buckets)
+      end
+
+      Attributes = []
+
+      Attributes << 'updated_at'
+        def updated_at
+          @updated_at ||= nil
+        end
+        def updated_at= value
+          @updated_at = Time.parse(value.to_s)
+        end
+
+      Attributes << 'buckets'
+        def buckets
+          @buckets ||= List.of(String)
+        end
+        def buckets= value
+          buckets.replace(value)
+        end
+
+        def initialize(options = {})
+          options = Gnip.options_for(options)
+          options.each{|key, value| send("#{ key }=", value)}
+        end
+    end
+
+    def Activity.stream(options = {})
+      options = Gnip.options_for(options)
+      scope = options.getopt(:scope, Gnip.scope)
+      resource = options.getopt(:resource, Gnip.default.resource)
+      style = options.getopt(:style, 'activity')
+      publisher = options.getopt(:publisher)
+      endpoint = resource.endpoint "#{ scope }/publishers/#{ publisher.name }/#{ style }.xml"
+      response = endpoint.get
+      xml = response.to_s
+      Activity::Stream.from_xml(xml)
+    end
+
+  end
+end