gnip 0.4.2

data/lib/gnip/api.rb

@@ -0,0 +1,191 @@
+module Gnip
+
+# TODO - doc the api
+
+  module Api
+  #
+  #
+    def username(*arg)
+      default.config.username = arg.first.to_s unless arg.empty?
+      default.config.username
+    end
+    alias_method 'username=', 'username'
+
+    def password(*arg)
+      default.config.password = arg.first.to_s unless arg.empty?
+      default.config.password
+    end
+    alias_method 'password=', 'password'
+
+    def uri(*arg)
+      default.config.uri = arg.first.to_s unless arg.empty?
+      default.config.uri
+    end
+    alias_method 'uri=', 'uri'
+
+  #
+  #
+    def ping(*args)
+      args, options = Gnip.args_for(args)
+      path = args.shift || Gnip.default.ping_path
+      options = Gnip.options_for(options)
+      resource = options.getopt(:resource, Gnip.default.resource)
+      endpoint = resource.endpoint(path)
+      !!endpoint.get
+    rescue
+      raise if options.getopt(:raise)
+      false
+    end
+
+  #
+  #
+    def publisher
+      Publisher
+    end
+
+  #
+  #
+    def resource
+      Resource
+    end
+
+  #
+  #
+    def activity
+      Activity
+    end
+
+  #
+  #
+    def filter
+      Filter
+    end
+
+  #
+  #
+    def util
+      Util
+    end
+
+  #
+  #
+    def config
+      Config
+    end
+
+  #
+  #
+    def orderedhash
+      OrderedHash
+    end
+
+  #
+  #
+    def clock_drift(*args)
+      args, options = Gnip.args_for(args)
+      path = args.shift || Gnip.default.ping_path
+      options = Gnip.options_for(options)
+      resource = options.getopt(:resource, Gnip.default.resource)
+      force = options.getopt(:force, false)
+      endpoint = resource.endpoint(path)
+      @clock_drift = nil if force
+      @clock_drift ||= ( Time.httpdate(endpoint.get.headers[:date]).utc - Time.now.utc )
+    end
+
+  #
+  #
+    def Gnip.time
+      Time.now.utc + clock_drift
+    end
+
+  #
+  #
+    attr_writer 'scope'
+
+    def scope *arg, &block
+      @scope ||= Gnip.default.scope
+      if block
+        scope = @scope
+        begin
+          @scope = arg.first.to_s unless arg.empty?
+          block.call(@scope)
+        ensure
+          @scope = scope
+        end
+      end
+      @scope
+    end
+
+  #
+  #
+    def args_for(args)
+      Arguments.for(args)
+    end
+    def argify!(args)
+      Arguments.for(args)
+    end
+
+    def options_for(args)
+      Options.for(args)
+    end
+    def optify!(args)
+      Options.for(args)
+    end
+
+  #
+  #
+    def compress(data)
+      util.compress(data)
+    end
+
+  #
+  #
+    def decompress(data)
+      util.decompress(data)
+    end
+
+  #
+  #
+    def encode(data)
+      util.encode(data)
+    end
+
+  #
+  #
+    def decode(data)
+      util.decode(data)
+    end
+
+
+  #
+  #
+    module Default
+      @uri = 'https://api-v21.gnip.com/'
+      attr_accessor :uri
+
+      @scope = 'gnip'
+      attr_accessor :scope
+
+      @ping_path = '/my/publishers.xml'
+      attr_accessor :ping_path
+
+      attr_writer :config
+      def config
+        @config ||= Config.default
+      end
+
+      attr_writer :resource
+      def resource
+        @resource ||= Resource.default
+      end
+
+      extend self
+    end
+
+    def default
+      Default
+    end
+  end
+
+  extend Api
+end

data/lib/gnip/arguments.rb

@@ -0,0 +1,21 @@
+module Gnip
+  module Arguments
+    def options
+      @options ||= Options.for(last.is_a?(Hash) ? pop : {})
+    end
+
+    %w[ getopt getopts hasopt hasopts delopt delopts ].each do |method|
+      module_eval <<-code
+        def #{ method }(*args, &block)
+          options.#{ method }(*args, &block)
+        end
+      code
+    end
+
+    def Arguments.for(args)
+      raise ArgumentError unless args.is_a?(Array)
+      args.extend(Arguments)
+      [args, args.options]
+    end
+  end
+end

data/lib/gnip/blankslate.rb

@@ -0,0 +1,5 @@
+module Gnip
+  class BlankSlate
+    instance_methods.each{|m| undef_method m unless m =~ /^__/}
+  end
+end

data/lib/gnip/config.rb

@@ -0,0 +1,144 @@
+module Gnip
+  class Config
+    def Config.for(arg)
+      config = new
+      updates =
+        case arg
+          when Hash
+            arg
+          when NilClass
+            {}
+          else
+            if arg.respond_to?(:read)
+              YAML.load(arg.read)
+            else
+              YAML.load(IO.read(arg.to_s))
+            end
+        end
+      config.update(updates)
+      config
+    end
+
+    def Config.default_path
+      File.join(Gnip.util.homedir, '.gnip.yml')
+    end
+
+    def Config.default
+      @default ||= (
+        update_from_env(
+          begin
+            Config.for(default_path)
+          rescue Errno::ENOENT
+            Config.for(nil)
+          end
+        )
+      )
+    end
+
+    def Config.update_from_env config
+      username = ENV['GNIP_USERNAME']
+      password = ENV['GNIP_PASSWORD']
+      auth = ENV['GNIP_AUTH']
+      if(auth and not (username and password))
+        username, password = auth.split(%r/:/, 2)
+      end
+      uri = ENV['GNIP_URI'] || Gnip.default.uri
+      config.username = username if username
+      config.password = password if password
+      config.uri = uri if uri
+      config
+    end
+
+    def Config.normalized hash
+      stringified_keys(hash)
+    end
+
+    def Config.stringified_keys hash
+      hash.keys.inject(Hash.new){|h,k| h.update(k.to_s => hash.fetch(k))}
+    end
+
+    attr :config
+
+    def initialize options = {}
+      @config = {}
+      options.each do |key, value|
+        msg = "#{ key }="
+        if respond_to?(msg)
+          send msg, value
+        else
+          @config[key.to_s] = value
+        end
+      end
+    end
+
+    alias_method 'to_hash', 'config'
+
+    def to_yaml(*args, &block)
+      to_hash.to_yaml(*args, &block)
+    end
+
+    def username= username
+      config['username'] = username.to_s
+    end
+    def username
+      config['username'].to_s
+    end
+
+    def password= password
+      config['password'] = password.to_s
+    end
+    def password
+      config['password'].to_s
+    end
+
+    def uri= uri
+      config['uri'] = uri.to_s
+    end
+    def uri
+      URI.parse(config['uri'].to_s) if config['uri']
+    end
+
+    def inspect
+      config.inspect
+    end
+
+    def normalize!
+      config.replace normalized
+    end
+
+    def normalized hash = config
+      Config.normalized(hash)
+    end
+
+    def [] key
+      config[key.to_s]
+    end
+    alias_method 'get', '[]'
+
+    def []= key, val
+      config[key.to_s] = val
+    end
+    alias_method 'set', '[]='
+
+    def has_key? key
+      config.has_key? key.to_s
+    end
+
+    def update hash
+      config.update normalized(hash)
+      self
+    end
+
+    def method_missing m, *a, &b
+      key, setter = m.to_s.split(/(=)/)
+      if setter
+        val = a.first
+        return(set(key, val))
+      end
+      if has_key?(key)
+        return(get(key))
+      end
+      super
+    end
+  end
+end

data/lib/gnip/filter.rb

@@ -0,0 +1,304 @@
+module Gnip
+  class Filter
+    def Filter.list_from_xml(xml, options = {}, &block)
+      list = []
+      parse_xml(xml, options) do |filter|
+        block ? block.call(filter) : list.push(filter)
+      end
+      block ? nil : list
+    end
+
+    def Filter.parse_xml(xml, options = {}, &block)
+      doc = Nokogiri::XML.parse(xml)
+      list = []
+      selectors = 'filter'
+      selectors.each do |selector|
+        search = doc.search(selector)
+        next unless search.size > 0
+        search.each do |node|
+          filter = Filter.from_node(node, options)
+          block ? block.call(filter) : list.push(filter)
+        end
+      end
+      block ? nil : list
+    end
+
+    def Filter.from_node(node, options = {})
+      full_data = node['fullData'] =~ /true/ ? true : false
+      name = node['name']
+      post_url = nil
+      rules = []
+      node.search('rule').each do |rule_node|
+        type = rule_node['type']
+        value = rule_node.content
+        rules << {:type => type, :value => value}
+      end
+      if post_url_node = node.at('postURL')
+        post_url = post_url_node.content
+      end
+      new(name, rules, :full_data => full_data, :post_url => post_url)
+    end
+
+    def Filter.from_xml(xml, options = {})
+      parse_xml(xml, options){|filter| return filter}
+    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 << 'post_url'
+      def post_url
+        @post_url ||= nil
+      end
+      def post_url= value
+        @post_url = String(value)
+      end
+
+    Attributes << 'rules'
+      def rules
+        @rules ||= List.of(Rule)
+      end
+      def rules= value
+        rules.replace(value)
+      end
+
+    Attributes << 'full_data'
+      def full_data
+        @full_data ||= nil
+      end
+      def full_data= value
+        @full_data = !!value
+      end
+
+    attr_accessor :publisher
+
+    def initialize(*args)
+      args, options = Gnip.args_for(args)
+      self.name = args.shift unless args.empty?
+      self.rules = args unless args.empty?
+      options.each{|key, value| send("#{ key }=", value)}
+    end
+
+    class Rule
+      def Rule.from_xml(xml, options = {})
+        parse_xml(xml, options){|rule| return rule}
+      end
+
+      def Rule.parse_xml(xml, options = {}, &block)
+        doc = Nokogiri::XML.parse(xml)
+        list = []
+        selectors = 'rule'
+        selectors.each do |selector|
+          search = doc.search(selector)
+          next unless search.size > 0
+          search.each do |node|
+            rule = Rule.from_node(node, options)
+            block ? block.call(rule) : list.push(rule)
+          end
+        end
+        block ? nil : list
+      end
+
+      def Rule.from_node(node, options = {})
+        type = node['type']
+        value = node.content
+        new(:type => type, :value => value)
+      end
+
+      def Rule.for(*args)
+        arg = args.first if args.size == 1
+        if Rule === arg
+          arg
+        elsif Hash === arg
+          new(arg)
+        else
+          new(*args)
+        end
+      end
+
+      attr_accessor :type
+      attr_accessor :value
+
+      def initialize(*args)
+        args, options = Gnip.args_for(args)
+        type = value = nil
+        case args.size
+          when 1
+            type, value = args.first.to_s.split(%r/:/, 2)
+          when 2
+            type, value = args
+        end
+        self.type = Publisher.rule.for options.getopt(:type, type)
+        self.value = options.getopt(:value, value)
+      end
+
+      def inspect
+        "#{ type }:#{ value }"
+      end
+
+      def to_s
+        inspect
+      end
+
+      def to_yaml(*a, &b)
+        to_s.to_yaml(*a, &b)
+      end
+
+=begin
+      def Rule.template
+        @template ||=
+          Template.new do
+            "
+              <rule type=<%= type.inspect %>>
+                <%= value %>
+              </rule>
+            "
+          end
+      end
+
+      def to_xml(options = {})
+        Rule.template.expand(self)
+      end
+=end
+
+      include Tagz
+      def to_xml(*args)
+        args, options = Gnip.args_for(args)
+        doc = args.shift
+
+        tagz(doc) {
+          rule_(:type => type){ value }
+        }
+      end
+
+      attr_accessor :filter
+
+      def resource
+        raise 'filter not set!' unless filter
+        rule = self
+        filter.publisher.filter.resource["filters/#{ filter.name }/rules?type=#{ rule.type }&value=#{ rule.value }"]
+      end
+
+      def delete(options = {})
+        Gnip.optify!(options)
+        filter = options.getopt(:filter, self.filter)
+        resource.delete
+        self
+      end
+    end
+
+    include Tagz
+    def to_xml(*args)
+      tagz {
+        filter_(:name => name, :fullData => !!full_data){
+          rules.each do |rule|
+            rule_(:type => rule.type){ rule.value }
+          end
+        }
+      }
+    end
+
+=begin
+    def Filter.template
+      @template ||=
+        Template.new do
+          "
+            <filter name=<%= name.inspect %> fullData=<%= (!!full_data).to_s.inspect %>>
+            % if post_url
+              <postURL><%= post_url %></postURL>
+            % end
+            % rules.each do |rule|
+              <rule type=<%= rule.type.inspect %>><%= rule.value %></rule>
+            % end
+            </filter>
+          "
+        end
+    end
+
+    def to_xml(options = {})
+      Filter.template.expand(self)
+    end
+=end
+
+    def resource
+      raise 'publisher not set!' unless publisher
+      publisher.filter.resource["filters/#{ name }.xml"]
+    end
+
+    def get(*args, &block)
+      resource.get(*args, &block)
+    end
+
+    def delete(*args, &block)
+      resource.delete(*args, &block)
+    end
+
+    def put(*args, &block)
+      resource.put(*args, &block)
+    end
+
+    def post(*args, &block)
+      resource.post(*args, &block)
+    end
+
+    def replace(other)
+      put(other.to_xml)
+      publisher.filter.for(name)
+    end
+
+    def rule
+      @rule ||= RuleResource.new(self)
+    end
+
+    class RuleResource
+      attr_accessor :filter
+
+      def initialize filter
+        @filter = filter
+      end
+
+      def publisher
+        filter.publisher
+      end
+
+      def resource
+        publisher.resource
+      end
+
+      def list options = {}
+        Gnip.optify!(options)
+        type = options.getopt(:type) or raise 'no type'
+        value = options.getopt(:value) or raise 'no type'
+        xml = resource["filters/#{ filter.name }/rules?type=#{ type }&value=#{ value }"].get
+        rule = Rule.from_xml(xml)
+        rule.filter = filter
+        rule
+      end
+
+      def delete options = {}
+        list(options).delete(:filter => filter)
+      end
+
+      def create(*rules)
+        rules = rules.map{|rule| Rule.for(rule)}
+        slices = [] and rules.each_slice(5000){|slice| slices << slice}
+        msg = slices.size > 1 ? 'threadify' : 'each'
+        slices.send(msg) do |slice|
+          xml = slice.map{|rule| rule.to_xml(:declaration => false)}.join
+          resource["filters/#{ filter.name }/rules"].post("<rules>#{ xml }</rules>")
+        end
+        rules.each{|rule| rule.filter = filter}
+        rules
+      end
+    end
+  end
+end