da_face 0.0.1

data/lib/da_face/datasift/da_object.rb

@@ -0,0 +1,35 @@
+module DaFace
+  module Datasift
+    class DaObject
+      TWITTER_INTERACTION = :twitter_interaction
+      TWITTER_DELETE_NOTIFICATION = :delete_notification
+      TWITTER_USER_NOTIFICATION = :user_notification
+      
+      attr_reader :interaction, :demographic, :links, :twitter, :salience, :language, :kind
+
+      def initialize data={}
+        if data[:deleted]
+          @twitter = DaFace::Datasift::TwitterDeleteNotification.new(data)
+        else
+          @twitter = DaFace::Datasift::Twitter.new(data[:twitter]) if data[:twitter]
+        end
+
+        @interaction = DaFace::Datasift::Interaction.new(data[:interaction]) if data[:interaction]
+        @demographic = DaFace::Datasift::Demographic.new(data[:demographic]) if data[:demographic]
+        @links = DaFace::Datasift::Links.new(data[:links]) if data[:links]
+        @salience = DaFace::Datasift::Salience.new(data[:salience]) if data[:salience]
+        @language = DaFace::Datasift::Language.new(data[:language]) if data[:language]
+        
+        set_kind! if data.any?
+
+        return self
+      end
+
+      def set_kind!
+        @kind = TWITTER_INTERACTION if @interaction.type == 'twitter'
+        @kind = TWITTER_DELETE_NOTIFICATION if @twitter.class == DaFace::Datasift::TwitterDeleteNotification
+        @kind = TWITTER_USER_NOTIFICATION if @twitter.class == DaFace::Datasift::TwitterUserStatus
+      end
+    end
+  end
+end

data/lib/da_face/datasift/demographic.rb

@@ -0,0 +1,12 @@
+module DaFace
+  module Datasift
+    class Demographic
+      attr_reader :gender
+
+      def initialize data={}
+        @gender = data[:gender]
+      end
+
+    end
+  end
+end

data/lib/da_face/datasift/errors.rb

@@ -0,0 +1,9 @@
+module DaFace
+  module Datasift
+    class MissingJson < Exception
+    end
+
+    class BadTwitterDeleteNotification < Exception
+    end
+  end
+end

data/lib/da_face/datasift/interaction.rb

@@ -0,0 +1,33 @@
+module DaFace
+  module Datasift
+    class Interaction
+      include DaFace::Utilities
+
+      attr_reader :author, :content, :created_at, :id, :link, 
+                  :received_at, :schema, :source, :type, :tags,
+                  :tag_tree
+
+      def initialize data={}
+        allowed_attributes.each do |attr|
+          unless data[attr].nil?
+            self.instance_variable_set("@#{attr}".to_sym, data[attr])
+          end
+        end
+        normalize_attributes!
+        return self
+      end
+
+      def allowed_attributes
+        [:author, :content, :created_at, :id, :link, 
+         :received_at, :schema, :source, :type, :tags,
+         :tag_tree]
+      end
+
+      def normalize_attributes!
+        @created_at = parse_timestamp(@created_at) if @created_at
+        @received_at = parse_timestamp(@received_at) if @received_at
+      end
+
+    end
+  end
+end

data/lib/da_face/datasift/language.rb

@@ -0,0 +1,14 @@
+module DaFace
+  module Datasift
+    class Language
+      attr_reader :confidence, :tag, :tag_extended
+
+      def initialize data={}
+        @confidence = data[:confidence]
+        @tag = data[:tag]
+        @tag_extended = data[:tag_extended]
+      end
+      
+    end
+  end
+end

data/lib/da_face/datasift/link.rb

@@ -0,0 +1,34 @@
+module DaFace
+  module Datasift
+    class Link
+      include DaFace::Utilities
+      
+      attr_reader :code, :created_at, :hops, :meta, :normalized_url,
+                  :retweet_count, :title, :url
+
+      def initialize data={}
+        allowed_attributes.each do |attr|
+          if data[attr]
+            self.instance_variable_set("@#{attr}".to_sym, data[attr])
+          end
+        end
+        normalize_attributes!
+
+        return self
+      end
+
+      def allowed_attributes
+        [:code, :created_at, :hops, :meta, :normalized_url,
+         :retweet_count, :title, :url]
+      end
+
+      private
+      def normalize_attributes!
+        @created_at = parse_timestamp(@created_at) if @created_at
+        @hops = @hops.collect{|d| parse_uri(d)} if @hops
+        @normalized_url = parse_uri(@normalized_url) if @normalized_url
+        @url = parse_uri(@url) if @url
+      end
+    end
+  end
+end

data/lib/da_face/datasift/links.rb

@@ -0,0 +1,38 @@
+module DaFace
+  module Datasift
+    class Links < Array
+      def initialize data={}
+        self.class.get_elements(data).each do |e|
+          self << DaFace::Datasift::Link.new(e)
+        end
+      end
+
+      def self.get_elements data={}
+        hashed_links = []
+        unless data.empty?
+          data.values.first.size.times do |index|
+            hashed_links << get_values(index - 1, data.keys, data)
+          end
+        end
+        return hashed_links
+      end
+
+      # Recursively search the hash for elements of index 'index'
+      # from the arrays inside the hashes.
+      def self.get_values index, keys, hash
+        new_hash = {}
+        keys.each do |key|
+          if hash[key].kind_of? Hash
+            new_hash[key] = get_values(index, hash[key].keys, hash[key])
+          else
+            new_hash[key] = hash[key][index]
+          end
+        end
+        
+        return new_hash
+      end
+
+
+    end
+  end
+end

data/lib/da_face/datasift/parser.rb

@@ -0,0 +1,35 @@
+module DaFace
+  module Datasift
+    class Parser
+      include DaFace::Utilities
+
+      def build_object data
+        DaFace::Datasift::DaObject.new data
+      end
+
+      def build_objects data
+        objects = []
+        data[:interactions].each do |object_data|
+          objects << build_object(object_data)
+        end
+
+        return objects
+      end
+
+      def parse_collection json=nil
+        raise DaFace::Datasift::MissingJson unless json
+
+        data = JSON.parse(json)
+        symbolized_data = symbolize_keys(data.keys, data)
+        return build_objects(symbolized_data)
+      end
+      
+      def parse_from_json json=nil
+        raise DaFace::Datasift::MissingJson unless json
+        data = JSON.parse(json)
+        symbolized_data = symbolize_keys(data.keys, data)
+        return build_object(symbolized_data)
+      end
+    end
+  end
+end

data/lib/da_face/datasift/salience.rb

@@ -0,0 +1,16 @@
+module DaFace
+  module Datasift
+    class Salience
+      attr_reader :content
+
+      def initialize data
+        @content = data[:content]
+      end
+
+      def sentiment
+        self.content[:sentiment]
+      end
+
+    end
+  end
+end

data/lib/da_face/datasift/twitter.rb

@@ -0,0 +1,46 @@
+module DaFace
+  module Datasift
+    class Twitter
+      include DaFace::Utilities
+      
+      attr_accessor :retweet, :retweeted, :tweet, :status
+
+      def self.new data
+        if data[:status]
+          return DaFace::Datasift::TwitterUserStatus.new(data)        
+        else
+          super
+        end
+      end
+
+      def initialize data
+        if data.keys.include? :retweet
+          @tweet = DaFace::Twitter::Parser.parse extract_retweet_info(data), true
+          @retweeted = DaFace::Twitter::Parser.parse extract_tweet_info(data), false
+          @retweet = true
+        else
+          @tweet = DaFace::Twitter::Parser.parse extract_tweet_info(data), false
+          @retweet = false
+        end
+      end
+
+      def retweet?
+        @retweet
+      end
+
+      private
+      def extract_retweet_info data
+        data[:retweet].merge({:text => data[:retweeted][:text]})
+      end
+
+      def extract_tweet_info data
+        if data[:retweet]
+          data[:retweeted]
+        else
+          data
+        end
+      end
+
+    end
+  end
+end

data/lib/da_face/datasift/twitter_delete_notification.rb

@@ -0,0 +1,16 @@
+module DaFace
+  module Datasift
+    class TwitterDeleteNotification
+      attr_reader :interaction_id, :interaction_type, :tweet_id
+
+      def initialize data={}
+        raise DaFace::Datasift::BadTwitterDeleteNotification.new('Missing interaction information') unless data[:interaction]
+        raise DaFace::Datasift::BadTwitterDeleteNotification.new('Missing twitter information') unless data[:interaction]
+
+        @interaction_id = data[:interaction][:id]
+        @interaction_type = data[:interaction][:type]
+        @tweet_id = data[:twitter][:id]
+      end
+    end
+  end
+end

data/lib/da_face/datasift/twitter_user_status.rb

@@ -0,0 +1,37 @@
+module DaFace
+  module Datasift
+    class TwitterUserStatus
+      STATUS_PROTECT   = :user_protect
+      STATUS_UNPROTECT = :user_unprotect
+      STATUS_SUSPEND   = :user_suspend
+      STATUS_UNSUSPEND = :user_unsuspend
+      STATUS_DELETE    = :user_delete
+      STATUS_UNDELETE  = :user_undelete
+
+      attr_reader :user_id, :status
+
+      def initialize data={}
+        @user_id = data[:user][:id]
+        set_status! data[:status]
+      end
+
+      private
+      def set_status! status
+        case status
+        when 'user_protect'
+          @status = STATUS_PROTECT
+        when 'user_unprotect'
+          @status = STATUS_UNPROTECT
+        when 'user_suspend'
+          @status = STATUS_SUSPEND
+        when 'user_unsuspend'
+          @status = STATUS_UNSUSPEND
+        when 'user_delete'
+          @status = STATUS_DELETE
+        when 'user_undelete'
+          @status = STATUS_UNDELETE
+        end
+      end
+    end
+  end
+end

data/lib/da_face/errors.rb

@@ -0,0 +1,7 @@
+module DaFace
+  class AdapterError < Exception
+  end
+
+  class PushError < Exception
+  end
+end

data/lib/da_face/twitter/parser.rb

@@ -0,0 +1,16 @@
+module DaFace
+  module Twitter
+    class Parser
+      extend DaFace::Utilities
+      
+      def self.parse data, retweet=false
+        parsed_data = symbolize_keys(data.keys, data)
+
+        user = DaFace::Twitter::User.new parsed_data[:user]
+        tweet = DaFace::Twitter::Tweet.new parsed_data.merge({:user => user, :retweet => retweet})
+        return tweet
+      end
+
+    end
+  end
+end

data/lib/da_face/twitter/tweet.rb

@@ -0,0 +1,49 @@
+module DaFace
+  module Twitter
+    class Tweet
+      include DaFace::Utilities
+
+      attr_reader :id, :user, :created_at, :lang, :text, :source, :links, 
+                  :retweet, :retweet_count
+      
+      def initialize data={}
+        allowed_attributes.each do |attr|
+          unless data[attr].nil?
+            self.instance_variable_set("@#{attr}".to_sym, data[attr])
+          end
+        end
+        normalize_attributes!
+        return self
+      end
+
+      def retweet?
+        @retweet || false
+      end
+
+      def retweet_count
+        @retweet_count || 0
+      end
+
+      def id_str
+        @id.to_s
+      end
+
+      def normalize_attributes!
+        @created_at = parse_timestamp(@created_at) if @created_at
+        @links = parse_links(@links) if @links
+        @id = @id.to_i if @id
+      end
+
+      def allowed_attributes
+        [:id, :user, :created_at, :lang, :text, :source, :links, 
+         :retweet, :retweet_count]
+      end
+
+      private
+      def parse_links links
+        return [] unless links
+        links.collect{|l| parse_uri(l)}
+      end
+    end
+  end
+end

data/lib/da_face/twitter/user.rb

@@ -0,0 +1,55 @@
+module DaFace
+  module Twitter
+    class User
+      include DaFace::Utilities
+
+      attr_reader :id, :created_at, :favourites_count, :friends_count, :geo_enabled,
+                  :lang, :listed_count, :name, :profile_image_url, :profile_image_url_https,
+                  :screen_name, :statuses_count, :verified
+
+
+      def initialize data={}
+        self.allowed_attributes.each do |attr|
+          unless data[attr].nil?
+            self.instance_variable_set("@#{attr}", data[attr])
+          end
+        end
+        self.normalize_attributes!
+        return self
+      end
+
+      def allowed_attributes
+        [:id, :created_at, :favourites_count, :friends_count, :geo_enabled,
+         :lang, :listed_count, :name, :profile_image_url, :profile_image_url_https,
+         :screen_name, :statuses_count, :verified]
+      end
+
+      def normalize_attributes!
+        @created_at = parse_timestamp(@created_at) if @created_at
+        @profile_image_url = parse_uri(@profile_image_url) if @profile_image_url
+        @profile_image_url_https = parse_uri(@profile_image_url_https) if @profile_image_url_https
+      end
+      
+      def favourites_count
+        @favourites_count || 0
+      end
+
+      def favorites_count
+        favourites_count
+      end
+
+      def friends_count
+        @friends_count || 0
+      end
+
+      def listed_count
+        @listed_count
+      end
+
+      def id_str
+        @id.to_s
+      end
+
+    end
+  end
+end

data/lib/da_face/utilities.rb

@@ -0,0 +1,41 @@
+module DaFace
+  module Utilities
+
+    # Creates a new hash with all keys as symbols, can be
+    # any level of depth
+    def symbolize_keys keys, hash
+      new_hash = {}
+      keys.each do |key|
+        if hash[key].kind_of? Hash
+          new_hash[key.to_sym] = symbolize_keys(hash[key].keys, hash[key])
+        elsif hash[key].kind_of? Array
+          new_hash[key.to_sym] = []
+          hash[key].each do |item|
+            if item.kind_of? Hash
+              new_hash[key.to_sym] << symbolize_keys(item.keys, item)
+            else
+              new_hash[key.to_sym] << item
+            end
+          end
+        else
+          new_hash[key.to_sym] = hash[key]
+        end
+      end
+
+      return new_hash
+    end
+
+    def parse_uri url
+      URI(url) if url
+    end
+    
+    def parse_timestamp timestamp=nil
+      return nil unless timestamp
+      return Time.at(timestamp) if timestamp.kind_of? Fixnum
+      return Time.at(timestamp) if timestamp.kind_of? Float
+      return Time.parse(timestamp) if timestamp.kind_of? String
+      return timestamp
+    end
+
+  end
+end

data/lib/da_face/version.rb

@@ -0,0 +1,3 @@
+module DaFace
+  VERSION = "0.0.1"
+end

data/lib/da_face.rb

@@ -0,0 +1,69 @@
+# Internals dependencies
+require "da_face/version"
+require "da_face/configuration"
+require "da_face/utilities"
+require "da_face/errors"
+require "da_face/api/adapter"
+require "da_face/api/adapters/base"
+require "da_face/api/adapters/excon_adapter"
+require "da_face/api/adapters/em_http_request_adapter"
+require "da_face/api/push"
+require "da_face/api/push_log"
+require "da_face/api/push_log_entry"
+require "da_face/api/push_subscription"
+require "da_face/datasift/parser"
+require "da_face/datasift/errors"
+require "da_face/datasift/da_object"
+require "da_face/datasift/interaction"
+require "da_face/datasift/links"
+require "da_face/datasift/link"
+require "da_face/datasift/demographic"
+require "da_face/datasift/language"
+require "da_face/datasift/salience"
+require "da_face/datasift/twitter"
+require "da_face/datasift/twitter_delete_notification"
+require "da_face/datasift/twitter_user_status"
+require "da_face/twitter/parser"
+require "da_face/twitter/tweet"
+require "da_face/twitter/user"
+
+# External dependencies
+require "json"
+require "excon"
+
+module DaFace
+  class << self
+    attr_accessor :configuration
+
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def configure
+      yield(configuration)
+      self.configuration
+    end
+
+    def reset_config
+      @configuration = Configuration.new
+    end
+
+    def create_subscription data={}
+      DaFace::Api::PushSubscription.new data
+    end
+
+    def parse_datasift_collection data
+      DaFace::Datasift::Parser.new.parse_collection(data)
+    end
+
+    def parse_datasift_object data
+      DaFace::Datasift::Parser.new.parse_from_json(data)
+    end
+    
+    def get_subscriptions
+      DaFace::Api::PushSubscription.get_all
+    end
+
+  end
+
+end

data/spec/da_face/api/adapter_spec.rb

@@ -0,0 +1,58 @@
+require 'spec_helper'
+
+describe DaFace::Api::Adapter do
+  before do
+    DaFace.configure do |config|
+      config.api_path_prefix = '/lolcat'
+      config.api_host = 'http://host.com'
+      config.user = 'lol'
+      config.api_key = 'cat'
+    end
+  end
+
+  describe '#get' do
+    before do
+      @adapter = DaFace::Api::Adapter.new
+      @excon_adapter = DaFace::Api::Adapters::ExconAdapter.new
+      @conn = Excon.new 'http://something.com', :mock => true
+      Excon.stub({}, {:body => {'ok' => true}.to_json, :status => 200})
+      allow(@excon_adapter).to receive(:connection).and_return(@conn)
+      allow(@adapter).to receive(:connection).and_return(@excon_adapter)
+    end
+
+    it 'performs a get' do
+      expect(@adapter.get('thing')).to eq({:ok => true})
+    end
+  end
+
+  describe '#put' do
+    before do
+      @adapter = DaFace::Api::Adapter.new
+      @excon_adapter = DaFace::Api::Adapters::ExconAdapter.new
+      @conn = Excon.new 'http://something.com/post', :mock => true
+      Excon.stub({}, {:status => 200})
+      allow(@excon_adapter).to receive(:connection).and_return(@conn)
+      allow(@adapter).to receive(:connection).and_return(@excon_adapter)
+    end
+
+    it 'performs a post' do
+      expect(@adapter.put('thing', {:something => 1})).to eq(true)
+    end
+  end
+
+  describe '#post' do
+    before do
+      @adapter = DaFace::Api::Adapter.new
+      @excon_adapter = DaFace::Api::Adapters::ExconAdapter.new
+      @conn = Excon.new 'http://something.com', :mock => true
+      Excon.stub({}, {:status => 200})
+      allow(@excon_adapter).to receive(:connection).and_return(@conn)
+      allow(@adapter).to receive(:connection).and_return(@excon_adapter)
+    end
+
+    it 'performs a put' do
+      expect(@adapter.post('thing', {:something => 1})).to eq(true)
+    end
+  end
+
+end