gnip-gnip 1.1.1

data/lib/gnip/list.rb

@@ -0,0 +1,126 @@
+module Gnip
+# a typed list of objects
+#
+  class List
+    include Enumerable
+    include Comparable
+
+    def List.for(klass, *args, &block)
+      new(klass, *args, &block)
+    end
+
+    def List.of(klass, *args, &block)
+      new(klass, *args, &block)
+    end
+
+    attr :list
+    attr :klass
+
+    def initialize(klass, *args, &block)
+      @list = []
+      @klass = klass
+    end
+
+    def new(*args, &block)
+      if klass.respond_to?(:for)
+        klass.for(*args, &block)
+      else
+        klass.new(*args, &block)
+      end
+    end
+
+    def cast(value)
+      return value if value.is_a?(klass)
+      msg =
+        if klass.respond_to?(:cast)
+          :cast
+        elsif klass.respond_to?(:for)
+          :for
+        else
+          :new
+        end
+      klass.send(msg, value)
+    end
+
+    def build(*args, &block)
+      element = new(*args, &block)
+      list << element
+      element
+    end
+    alias_method 'create', 'build'
+
+    def push(value)
+      list << cast(value)
+      self
+    end
+    alias_method '<<', 'push'
+
+    def each(&block)
+      list.each(&block)
+    end
+
+    def map(&block)
+      list.map(&block)
+    end
+
+    def [](idx)
+      list[idx]
+    end
+
+    def inspect
+      "#{ self.class.name }.of(#{ klass.name })#{ list.inspect }"
+    end
+
+    def clear
+      list.clear
+      self
+    end
+
+    def size
+      list.size
+    end
+
+    def replace other
+      clear
+      case other
+        when List, Array
+          other.flatten.each{|value| push(value)}
+        else
+          push(other)
+      end
+      self
+    end
+
+    def first
+      list.first
+    end
+
+    def last
+      list.last
+    end
+
+    def to_a
+      list
+    end
+
+    def to_xs
+      to_a.map{|element| element.respond_to?(:to_xs) ? element.to_xs : element}
+    end
+
+    def method_missing(m, *a, &b)
+      if list.respond_to?(m)
+        list.send(m, *a, &b)
+      else
+        super
+      end
+    end
+
+    def to_yaml(*a, &b)
+      list.to_yaml(*a, &b)
+    end
+
+    def <=> other
+      list <=> other
+    end
+  end
+end

data/lib/gnip/options.rb

@@ -0,0 +1,96 @@
+module Gnip
+  module Options
+    def to_options!
+      replace to_options
+    end
+
+    def to_options
+      keys.inject(Hash.new){|h,k| h.update k.to_s.to_sym => fetch(k)}
+    end
+          
+    def getopt key, default = nil
+      [ key ].flatten.each do |key|
+        return fetch(key) if has_key?(key)
+        key = key.to_s
+        return fetch(key) if has_key?(key)
+        key = key.to_sym
+        return fetch(key) if has_key?(key)
+      end
+      default
+    end
+
+    def getopts *args
+      args.flatten.map{|arg| getopt arg}
+    end
+
+    def hasopt key, default = nil
+      [ key ].flatten.each do |key|
+        return true if has_key?(key)
+        key = key.to_s
+        return true if has_key?(key)
+        key = key.to_sym
+        return true if has_key?(key)
+      end
+      default
+    end
+    alias_method 'hasopt?', 'hasopt'
+
+    def hasopts *args
+      args.flatten.map{|arg| hasopt arg}
+    end
+    alias_method 'hasopts?', 'hasopts'
+
+    def delopt key, default = nil
+      [ key ].flatten.each do |key|
+        return delete(key) if has_key?(key)
+        key = key.to_s
+        return delete(key) if has_key?(key)
+        key = key.to_sym
+        return delete(key) if has_key?(key)
+      end
+      default
+    end
+
+    def delopts *args
+      args.flatten.map{|arg| delopt arg}
+    end
+
+    def setopt key, value = nil
+      [ key ].flatten.each do |key|
+        return self[key]=value if has_key?(key)
+        key = key.to_s
+        return self[key]=value if has_key?(key)
+        key = key.to_sym
+        return self[key]=value if has_key?(key)
+      end
+      return self[key]=value
+    end
+    alias_method 'setopt!', 'setopt'
+
+    def setopts opts 
+      opts.each{|key, value| setopt key, value}
+      opts
+    end
+    alias_method 'setopts!', 'setopts'
+
+    def select! *a, &b
+      replace select(*a, &b).to_hash
+    end
+  end
+
+  def Options.for(hash)
+    hash =
+      case hash
+        when Hash
+          hash
+        when Array
+          Hash[*hash.flatten]
+        when String, Symbol
+          {hash => true}
+        else
+          hash.to_hash
+      end
+  ensure
+    hash.extend(Options) unless hash.is_a?(Options)
+  end
+end

data/lib/gnip/orderedhash.rb

@@ -0,0 +1,199 @@
+
+# AUTHOR
+#    jan molic /mig/at/1984/dot/cz/
+#
+# DESCRIPTION
+#    Hash with preserved order and some array-like extensions
+#    Public domain. 
+#
+# THANKS
+#    Andrew Johnson for his suggestions and fixes of Hash[],
+#    merge, to_a, inspect and shift
+
+module Gnip
+  class OrderedHash < ::Hash
+      attr_accessor :order
+
+      class << self
+          def [] *args
+            hsh = OrderedHash.new
+            if Hash === args[0]
+              hsh.replace args[0]
+            elsif (args.size % 2) != 0
+              raise ArgumentError, "odd number of elements for Hash"
+            else
+              0.step(args.size - 1, 2) do |a|
+                b = a + 1
+                hsh[args[a]] = args[b]
+              end
+            end
+            hsh
+          end
+      end
+      def initialize(*a, &b)
+        super
+        @order = []
+      end
+      def store_only a,b
+          store a,b
+      end
+      alias orig_store store    
+      def store a,b
+          @order.push a unless has_key? a
+          super a,b
+      end
+      alias []= store
+      def == hsh2
+          return false if @order != hsh2.order
+          super hsh2
+      end
+      def clear
+          @order = []
+          super
+      end
+      def delete key
+          @order.delete key
+          super
+      end
+      def each_key
+          @order.each { |k| yield k }
+          self
+      end
+      def each_value
+          @order.each { |k| yield self[k] }
+          self
+      end
+      def each
+          @order.each { |k| yield k,self[k] }
+          self
+      end
+      alias each_pair each    
+      def delete_if
+          @order.clone.each { |k| 
+              delete k if yield(k)
+          }
+          self
+      end
+      def values
+          ary = []
+          @order.each { |k| ary.push self[k] }
+          ary
+      end
+      def keys
+          @order
+      end
+      def first
+        {@order.first => self[@order.first]}
+      end
+      def last
+        {@order.last => self[@order.last]}
+      end
+      def invert
+          hsh2 = Hash.new    
+          @order.each { |k| hsh2[self[k]] = k }
+          hsh2
+      end
+      def reject(&block)
+          self.dup.delete_if(&block)
+      end
+      def reject!(&block)
+          hsh2 = reject(&block)
+          self == hsh2 ? nil : hsh2
+      end
+      def replace hsh2
+          @order = hsh2.keys 
+          super hsh2
+      end
+      def shift
+          key = @order.first
+          key ? [key,delete(key)] : super
+      end
+      def unshift k,v
+          unless self.include? k
+              @order.unshift k
+              orig_store(k,v)
+              true
+          else
+              false
+          end
+      end
+      def push k,v
+          unless self.include? k
+              @order.push k
+              orig_store(k,v)
+              true
+          else
+              false
+          end
+      end
+      def pop
+          key = @order.last
+          key ? [key,delete(key)] : nil
+      end
+      def to_a
+          ary = []
+          each { |k,v| ary << [k,v] }
+          ary
+      end
+      def to_s
+          self.to_a.to_s
+      end
+      def inspect
+          ary = []
+          each {|k,v| ary << k.inspect + "=>" + v.inspect}
+          '{' + ary.join(", ") + '}'
+      end
+      def update hsh2
+          hsh2.each { |k,v| self[k] = v }
+          self
+      end
+      alias :merge! update
+      def merge hsh2
+          self.dup update(hsh2)
+      end
+      def select
+          ary = []
+          each { |k,v| ary << [k,v] if yield k,v }
+          ary
+      end
+      def class
+        Hash
+      end
+      def __class__
+        OrderedHash
+      end
+
+      attr_accessor "to_yaml_style"
+      def yaml_inline= bool
+        if respond_to?("to_yaml_style")
+          self.to_yaml_style = :inline
+        else
+          unless defined? @__yaml_inline_meth
+            @__yaml_inline_meth =
+              lambda {|opts|
+                YAML::quick_emit(object_id, opts) {|emitter|
+                  emitter << '{ ' << map{|kv| kv.join ': '}.join(', ') << ' }'
+                }
+              }
+            class << self
+              def to_yaml opts = {}
+                begin
+                  @__yaml_inline ? @__yaml_inline_meth[ opts ] : super
+                rescue
+                  @to_yaml_style = :inline
+                  super
+                end
+              end
+            end
+          end
+        end
+        @__yaml_inline = bool
+      end
+      def yaml_inline!() self.yaml_inline = true end
+
+      def each_with_index
+        @order.each_with_index { |k, index| yield k, self[k], index }
+        self
+      end
+  end # class OrderedHash
+end

data/lib/gnip/publisher.rb

@@ -0,0 +1,316 @@
+module Gnip
+  class Publisher
+    def Publisher.list(options = {})
+      options = Gnip.optify!(options)
+      scope = options.getopt(:scope, Gnip.scope)
+      resource = options.getopt(:resource, Gnip.default.resource)
+      endpoint = resource.endpoint "#{ scope }/publishers.xml"
+      response = endpoint.get
+      xml = response.to_s
+      Publisher.list_from_xml(xml, :scope => scope)
+    end
+
+    def Publisher.list_from_xml(xml, options = {}, &block)
+      list = []
+      parse_xml(xml, options) do |publisher|
+        block ? block.call(publisher) : list.push(publisher)
+      end
+      block ? nil : list
+    end
+
+    def Publisher.from_xml(xml, options = {}, &block)
+      parse_xml(xml, options){|publisher| return publisher}
+    end
+
+    def Publisher.parse_xml(xml, options = {}, &block)
+      doc = Nokogiri::XML.parse(xml)
+      list = []
+      selectors = '*/publishers', 'publisher'
+      selectors.each do |selector|
+        search = doc.search(selector)
+        next unless search.size > 0
+        search.each do |node|
+          publisher = Publisher.from_node(node, options)
+          block ? block.call(publisher) : list.push(publisher)
+        end
+      end
+      block ? nil : list
+    end
+
+    def Publisher.from_node(node, options = {})
+      name = node['name']
+      rules = node.search('supportedRuleTypes/type').map{|type| type.content}
+      Publisher.new(name, options.update(:rules => rules))
+    end
+
+    def Publisher.for name, options = {}
+      options = Gnip.optify!(options)
+      scope = options.getopt(:scope, Gnip.scope)
+      resource = options.getopt(:resource, Gnip.default.resource)
+      endpoint = resource["#{ scope }/publishers/#{ name }.xml"]
+      response = endpoint.get
+      xml = response.to_s
+      publisher = Publisher.from_xml(xml)
+      publisher.scope = scope
+      publisher
+    end
+
+    def Publisher.exists?(*args, &block)
+      Publisher.for(*args, &block) rescue false
+    end
+
+    def Publisher.resource
+      @resource ||= Gnip.default.resource
+    end
+
+    def Publisher.create(*args, &block)
+      publisher = new(*args, &block)
+      resource = Publisher.resource["#{ publisher.scope }/publishers.xml"]
+      resource.post(publisher.to_xml(:declaration => true))
+      Publisher.for(publisher.name, :scope => publisher.scope)
+    end
+
+    def Publisher.delete(name, options = {})
+      if publisher = Publisher.exists?(name, options)
+        publisher.delete
+      end
+    end
+
+    Attributes = []
+
+    Attributes << 'name'
+      def name
+        @name ||= nil
+      end
+      def name= value
+        @name = String(value)
+      ensure
+        raise ArgumentError, @name unless @name =~ %r/^[a-zA-Z0-9.+-]+$/
+      end
+
+    Attributes << 'rules'
+      def rules
+        @rules ||= List.of(String)
+      end
+      def rules= value
+        rules.replace(value)
+      end
+
+    attr_accessor :scope
+
+    def initialize(*args)
+      args, options = Gnip.args_for(args)
+      self.name = args.shift if args.first
+      @scope = options.getopt(:scope, Gnip.scope).to_s
+      @resource = options.getopt(:resource, Gnip.default.resource)
+      rules = options.getopt(:rules, []).flatten.compact
+      @rules = rules.map{|rule| Rule.for(rule)}
+    end
+
+    def resource
+      @resource["#{ scope }/publishers/#{ name }"]
+    end
+
+
+
+    class Rule < ::String
+      List = []
+
+      %w[ actor tag to regarding source keyword ].each do |name|
+        module_eval <<-code
+          def Rule.#{ name }
+            @#{ name } ||= Rule.new('#{ name }').freeze
+          end
+        code
+        List << Rule.send(name)
+      end
+
+      List.freeze
+
+      def Rule.list
+        List
+      end
+
+      def Rule.for(name)
+        send(name.to_s.downcase.strip)
+      rescue
+        raise ArgumentError, "bad rule type #{ name.inspect }" 
+      end
+
+      def Rule.[] name
+        Rule.for(name)
+      end
+    end
+
+    def Publisher.rule
+      Rule
+    end
+
+    include Tagz
+    def to_xml(*args)
+      args, options = Gnip.args_for(args)
+      doc = args.first
+
+      tagz(doc) {
+        publisher_(:name => name){
+          supportedRuleTypes_{
+            rules.each{|rule| type_{ rule }}
+          }
+        }
+      }
+    end
+
+=begin
+    def Publisher.template
+      @template ||=
+        Template.new do
+          "
+            <publisher name=<%= name.inspect %>>
+              <supportedRuleTypes>
+            % rules.each do |rule|
+              <type><%= rule %></type>
+            % end
+              </supportedRuleTypes>
+            </publisher>
+          "
+        end
+    end
+
+    def to_xml(options = {})
+      Publisher.template.expand(self)
+    end
+=end
+
+
+    def delete
+      Publisher.resource["#{ scope }/publishers/#{ name }"].delete
+      self
+    end
+
+    def activity_stream options = {}
+      Activity.stream(options.update(:publisher => self, :scope => scope))
+    end
+
+    def activity options = {}, &block
+      Gnip.optify!(options)
+
+      style = options.getopt(:style, 'activity').to_s
+      raise ArgumentError unless %w( activity notification ).include?(style)
+
+
+      bucket = options.getopt(:bucket)
+      ago = options.getopt(:ago)
+      thru = options.getopt(:thru, options.getopt(:through))
+
+      if Range === ago
+        ago, thru = [ago.begin, ago.end].sort.reverse
+      end
+
+      unless bucket
+        bucket = ago ? bucket_for_minutes_ago(ago) : 'current'
+      end
+
+      filter = options.getopt(:filter)
+      filter = filter.value if(filter and filter.respond_to?(:value))
+      filter = filter.name if(filter and filter.respond_to?(:name))
+
+      buckets =
+        if thru
+          thru = 0 if thru =~ /current|now/i
+          a, b = [ago, Integer(thru)].sort
+          (a..b).to_a.reverse.map{|i| bucket_for_minutes_ago(i)}
+        else
+          if bucket =~ /all/i
+            stream = send("#{ style }_stream")
+            stream.buckets.map{|bucket| File.basename(bucket, '.xml')}
+          else
+            [bucket]
+          end
+        end
+
+      buckets.map! do |bucket|
+        bucket.is_a?(Time) ? bucket.strftime('%Y%m%d%H%M') : bucket
+      end
+
+      activities = []
+
+      msg = buckets.size > 1 ? 'threadify' : 'each'
+
+      buckets.send(msg) do |bucket|
+        path = "#{ style }/#{ bucket }.xml"
+        path = "filters/#{ filter }/#{ path }" if filter
+        xml = resource[path].get
+        Activity.list_from_xml(xml) do |activity|
+          activity.gnip_resource_uri = resource[path].uri
+          block ? block.call(activity) : activities.push(activity)
+        end
+      end
+
+      activities unless block
+    end
+
+    def bucket_for_minutes_ago ago
+      bucket = Gnip.time - (Integer(ago) * 60)
+      bucket.strftime('%Y%m%d%H%M')
+    end
+
+    def notification_stream options = {}
+      Activity.stream(options.update(:publisher => self, :scope => scope, :style => 'notification'))
+    end
+
+    def notifications options = {}
+      Gnip.optify!(options)
+      options.setopt!(:style, 'notification') unless options.hasopt?(:style)
+      activity(options)
+    end
+
+    def publish *activities
+      activities.flatten!
+      activities.compact!
+      #xml = "<activiies>#{ activities.map{|activity| activity.to_xml} }</activities>"
+      xml = tagz { activities_{ activities.map{|activity| activity.to_xml(tagz.doc)} } }
+      resource['activity.xml'].post(xml)
+      activities
+    end
+
+
+    def filter
+      @filter ||= FilterResource.new(self)
+    end
+
+    class FilterResource
+      attr_accessor :publisher
+
+      def initialize publisher
+        @publisher = publisher
+      end
+
+      def resource
+        publisher.resource
+      end
+
+      def list
+        xml = resource['filters.xml'].get
+        Filter.list_from_xml(xml).each{|filter| filter.publisher = publisher}
+      end
+
+      def for name
+        xml = resource["filters/#{ name }.xml"].get
+        filter = Filter.from_xml(xml)
+      ensure
+        filter.publisher = publisher if filter
+      end
+
+      alias_method '[]', 'for'
+
+      def create(name, rules, options)
+        Gnip.optify!(options)
+        filter = Filter.new(name, rules, options)
+        resource['filters.xml'].post(filter.to_xml(:declaration => true))
+        filter = self.for(name)
+      ensure
+        filter.publisher = publisher if filter
+      end
+    end
+  end
+end