wuclan 0.2.0

data/lib/wuclan/metrics/user_metrics_basic.rb

@@ -0,0 +1,277 @@
+#!/usr/bin/env ruby
+require 'date'
+# Executes only if run from command line
+if __FILE__ == $0 then $: << File.dirname(__FILE__)+'/../..'; require 'wukong'; end
+
+#
+#
+#
+module Wuclan
+  module Models
+    class UserTweetMetrics < TypedStruct.new(
+        [:id,                 Integer],
+        [:tw_seen,            Integer],
+        [:last_tw_at,         Bignum],
+        [:tw_recent,          Integer]
+        )
+    end
+
+
+    # 1 rsrc 2 id 3 screen_name 4protect 5 age 6duratio 7age_use 8age_las 9 fo
+    # 10fr 11 tw 12 fv 13 fr_fo 14 fo_day 15 fr_day 16 tw_day 17 fv_day 18fo_seen
+    # 19fr_seen 20tw_seen 21tw_rece 22tw_day_ 23at_in_s 24at_out_ 25rt_in_s
+    # 26rt_out_ 27fv_in_s 28fv_out_ 29any_wit 30any_out 31any_in_ 32at_in_w
+    # 33at_out_ 34rt_in_w 35rt_out_ 36fv_in_w 37fv_out_ 38at_tw_o 39rt_tw_o
+    # 40rt_at_o 41at_in_t 42rt_in_t 43rt_at_i 44 reach 45fo_cove 46fr_cove
+    # 47tw_cove 48fv_cove 49scrape_ 50scrape_ 51scrape_ 52 scraped_at
+    # 53part_scraped_at 54 created_at 55 last_tw_at
+
+
+
+    # [
+    #     #
+    #     [:fo_day,            Float],      #   x       Followers accumulated / day
+    #     [:fr_day,            Float],      #   x       Friends   accumulated / day
+    #     [:tw_day,            Float],      #   x       Tweets    sent / day
+    #     [:fv_day,            Float],      #   x       Favorites accumulated / day
+    #     #
+    #     [:at_in_with,        Integer],    #       g   Users Atsigning you
+    #     [:at_out_with,       Integer],    #       g
+    #     [:rt_in_with,        Integer],    #       g   Users Retweeting you
+    #     [:rt_out_with,       Integer],    #       g
+    #     [:fv_in_with,        Integer],    #       g   Favorites by others of your tweets, with
+    #     [:fv_out_with,       Integer],    #     c     Number of users who Favorited you
+    #     #
+    #     [:at_tw_out,         Float],      #       g   Atsigns  out per tweet out
+    #     [:rt_tw_out,         Float],      #       g   Retweets out per tweet out
+    #     [:rt_at_out,         Float],      #       g   Retweets out per  atsign out seen
+    #     [:at_in_tw_out,      Float],      #       g   Atsigns  in  per tweet out
+    #     [:rt_in_tw_out,      Float],      #       g   Retweets in  per tweet out
+    #     [:rt_at_in,          Float],      #       g   Retweets in  seen per atsign in  seen
+    #     #
+    #     [:reach,             Integer],    #   x       Reach:   (your msgs/day) * |n1|
+    # ]
+    # [
+    #     [:scraped_at,        Bignum],
+    #     [:part_scraped_at,   Bignum],     #           Date of last user partial update
+    #     #
+    #     [:fo_coverage,       Float],      #     c     Friends seen   / known to exist
+    #     [:fr_coverage,       Float],      #     c     Followers seen / known to exist
+    #     [:tw_coverage,       Float],      #     c     Tweets seen    / known to exist
+    #     [:fv_coverage,       Float],      #     c     Favorites seen / known to exist
+    #     #
+    #     [:fo_scraped_at,     Integer],      #     c     How long since your followers graph record was scraped
+    #     [:fr_scraped_at,     Integer],      #     c     How long since your friends   graph record was scraped
+    #     [:fv_scraped_at,     Integer],      #     c     How long since your favorites graph record was scraped
+    #     #
+    #   ]
+    #
+
+    class UserMetrics < TypedStruct.new(
+        [:id,                Integer],
+        #
+        [:created_at,        Bignum],
+        [:last_tw_at,        Bignum],      #         t Date of the last seen tweet
+        #
+        [:fo,                Integer],
+        [:fr,                Integer],
+        [:tw,                Integer],
+        [:fv,                Integer],
+        #
+        :n_followers_cat,
+        :n_friends_cat,
+        :n_tweets_cat,
+        :active,
+
+        [:any_with,          Integer],    #          Any graph link to
+        :neighborhood_size,
+        :friend_follower_balance
+        )
+
+      SCRAPING_DAY_ZERO_STR = 20081201000000
+      SCRAPING_DAY_ZERO     = DateTime.parse_safely(SCRAPING_DAY_ZERO_STR.to_s)
+      SINCE_DAY_ZERO        = DateTime.now - SCRAPING_DAY_ZERO
+
+      def to_a
+        members.zip(mtypes).map do |member, type|
+          val = self[member]
+          next if val.nil?
+          case
+          when member.to_sym == :id     then "%010d"  % val.to_i
+          when type == Float            then "%f"  % val.to_f
+          when type == Integer          then "%7d"    % val.to_i
+          when type == Bignum           then "%15s"   % val
+          else val
+          end
+        end
+      end
+      def protected?
+        protected.to_i == 1
+      end
+
+      #
+      #
+      #
+      def user_adopted?
+        @user_adopted
+      end
+
+      #
+      #
+      #
+      def adopt_user user
+        @user_adopted = true
+        self.merge! user
+      end
+
+      #
+      #
+      #
+      def adopt_user_partial user_partial
+        user_scraped_at    = self.scraped_at
+        self.merge! user_partial
+        # restore scraped dates
+        self.part_scraped_at = user_partial.scraped_at
+        self.scraped_at      = user_scraped_at
+      end
+
+      #
+      #
+      #
+      def adopt_scraping_metrics usm
+        [
+          [:friends_ids,   :scrape_age_fr, ],
+          [:followers_ids, :scrape_age_fo, ],
+          [:favorites,     :scrape_age_fv, ],
+        ].each do |context, attr|
+          dt = usm.get context, :scraped_at
+          next if (usm.get(context, :successes).to_i < 1) || (dt.blank?)
+          # fudge bogus date records
+          dt = (dt.to_i < SCRAPING_DAY_ZERO_STR) ? SCRAPING_DAY_ZERO : DateTime.parse_safely(dt)
+          next if dt.blank?
+          self[attr] = now - dt
+        end
+      end
+
+      #
+      # From simple graph metrics
+      #
+      def adopt_graph_metrics user_graph_metrics
+        self.merge! user_graph_metrics
+      end
+
+      #
+      # User's Tweets -- from UserTweetMetrics
+      #
+      def adopt_tweet_metrics user_tweet_metrics
+        self.tw_seen      = user_tweet_metrics.tw_seen
+        self.last_tw_at   = user_tweet_metrics.last_tw_at
+        self.tw_recent    = user_tweet_metrics.tw_recent
+      end
+
+      def followers_count=( fo) self.fo = fo.to_i end
+      def friends_count=(   fr) self.fr = fr.to_i end
+      def statuses_count=(  tw) self.tw = tw.to_i end
+      def favourites_count=(fv) self.fv = fv.to_i end
+      def followers_count()     self.fo end
+      def friends_count()       self.fr end
+      def statuses_count()      self.tw end
+      def favourites_count()    self.fv end
+
+      def crat
+        @crat      ||= DateTime.parse_safely created_at
+      end
+      def scat
+        @scat      ||= DateTime.parse_safely scraped_at
+      end
+      def part_scat
+        @part_scat ||= DateTime.parse_safely part_scraped_at
+      end
+      def twat
+        @twat      ||= DateTime.parse_safely last_tw_at
+      end
+      def now
+        @now       ||= DateTime.now
+      end
+
+      #
+      # duration --
+      #
+      def get_age()
+        return unless crat
+        self.age             = ( now - crat ).to_i
+      end
+      def get_duration()
+        return unless crat && scat
+        self.duration        = ( scat - crat ).to_i
+      end
+      def get_age_last_tw()
+        return unless twat
+        self.age_last_tw     = ( now - twat ).to_i
+      end
+      def get_age_user_scrape()
+        return unless scat
+        self.age_user_scrape = ( now - scat ).to_i
+      end
+
+      #
+      # Per-day metrics
+      #
+      # Should possibly use duration but need to worry about which one.
+      #
+      def get_fo_day()    self.fo_day = (fo.to_f / age)  unless (age.to_i == 0) end
+      def get_fr_day()    self.fr_day = (fr.to_f / age)  unless (age.to_i == 0) end
+      def get_tw_day()    self.tw_day = (tw.to_f / age)  unless (age.to_i == 0) end
+      def get_fv_day()    self.fv_day = (fv.to_f / age)  unless (age.to_i == 0) end
+      def get_fr_fo()     self.fr_fo  = (fr.to_f / fo)        unless (fo.to_i       == 0) end
+      def get_tw_day_recent()
+        self.tw_day_recent = (tw.to_f / SINCE_DAY_ZERO)
+      end
+
+      #
+      # Coverage: how many seen vs. how many known to exist.
+      #
+      def get_fo_coverage()  self.fo_coverage = (fo_seen.to_f     / fo) unless (fo.to_i == 0)  end
+      def get_fr_coverage()  self.fr_coverage = (fr_seen.to_f     / fr) unless (fr.to_i == 0)  end
+      def get_tw_coverage()  self.tw_coverage = (tw_seen.to_f     / tw) unless (tw.to_i == 0)  end
+      def get_fv_coverage()  self.fv_coverage = (fv_out_seen.to_f / fv) unless (fv.to_i == 0)  end
+
+      #
+      # Conversational metrics:
+      #   favorites, @atsigns and RT's per tweet, in and out
+      #    RT per @atsign, in and out
+      #
+      def get_at_tw_out()    self.at_tw_out    = (at_out_seen.to_f / tw_seen.to_f)     unless (tw_seen.to_i == 0)  end
+      def get_rt_tw_out()    self.rt_tw_out    = (rt_out_seen.to_f / tw_seen.to_f)     unless (tw_seen.to_i == 0)  end
+      #
+      def get_at_in_tw_out() self.at_in_tw_out = (at_in_seen.to_f  / tw_seen.to_f)     unless (tw_seen.to_i == 0)  end
+      def get_rt_in_tw_out() self.rt_in_tw_out = (rt_in_seen.to_f  / tw_seen.to_f)     unless (tw_seen.to_i == 0)  end
+      #
+      def get_rt_at_out()    self.rt_at_out    = (rt_out_seen.to_f / at_out_seen.to_f) unless (at_out_seen.to_i == 0) end
+      def get_rt_at_in()     self.rt_at_in     = (rt_in_seen.to_f  / at_in_seen.to_f)  unless (at_in_seen.to_i == 0)  end
+
+      #
+      # Reach:
+      #
+      #   (your msgs/day) * |n1|
+      #
+      # How many of your messages/day might get read. Audience Share (tw_out_share)
+      # is a better measure of your impact.
+      #
+      def get_reach()
+        self.get_tw_day or return
+        self.reach = (tw_day.to_f * fo)
+      end
+
+    end
+  end
+end
+
+
+
+#
+# Executes only if run from command line
+#
+if __FILE__ == $0
+  puts "rsrc\t"+Wuclan::Models::UserMetrics.members.join("\t")
+end

data/lib/wuclan/metrics/user_scraping_metrics.rb

@@ -0,0 +1,64 @@
+require 'date'
+module Wuclan
+  module Models
+    USER_SCRAPING_CONTEXTS = [:user, :friends_ids, :followers_ids, :favorites, ] # :friends, :followers, :user_timeline]
+    # USER_SCRAPING_METRICS_MEMBERS = []
+    # USER_SCRAPING_CONTEXTS.map do |context|
+    #   USER_SCRAPING_METRICS_MEMBERS += [
+    #     ["#{context}_scraped_at",    Bignum],
+    #     ["#{context}_attempts",         Integer],
+    #     ["#{context}_successes",     Integer],
+    #     ["#{context}_failures",      String],
+    #   ]
+    # end
+    # p USER_SCRAPING_METRICS_MEMBERS
+
+    #
+    # Workable kludge to denormalize records
+    #
+    #
+    class UserScrapingMetrics < TypedStruct.new(
+        [:id,                 Integer],
+        # *USER_SCRAPING_METRICS_MEMBERS
+        ["user_scraped_at",          Bignum], ["user_attempts",          Integer], ["user_successes", Integer], ["user_failures", String],
+        ["friends_ids_scraped_at",   Bignum], ["friends_ids_attempts",   Integer], ["friends_ids_successes", Integer], ["friends_ids_failures", String],
+        ["followers_ids_scraped_at", Bignum], ["followers_ids_attempts", Integer], ["followers_ids_successes", Integer], ["followers_ids_failures", String],
+        ["favorites_scraped_at",     Bignum], ["favorites_attempts",     Integer], ["favorites_successes", Integer], ["favorites_failures", String]
+        )
+
+      def set context, attr, val
+        self.send("#{context}_#{attr}=", val)
+      end
+      def get context, attr
+        self.send("#{context}_#{attr}")
+      end
+
+      #
+      # Instantiate from pig grouped output
+      #
+      #   user_scraping_metrics              3021 {(followers,20081228023148,2,2,0,0,0,0,0),(friends_ids,20090205064439,1,1,0,0,0,0,0),(followers_ids,20090205064439,1,1,0,0,0,0,0),(favorites,3021,1,1,0,0,0,0,0),(user,200902
+      #
+      def fill_from_bag scrapings_bag
+        scrapings_bag.split(/\),\(/).each do |scraping|
+          scraping = scraping.gsub(/^[\{\(]+/,'').gsub(/[)}]+$/,'')
+          context, *vals = scraping.split(",", 5)
+          next unless USER_SCRAPING_CONTEXTS.include?(context.to_sym)
+          [:scraped_at, :attempts, :successes, :failures].zip(vals).each do |attr, val|
+            set context, attr, val
+          end
+        end
+        self
+      end
+
+      def self.new id, *args
+        if args.length == 1
+          usm = super(id)
+          usm.fill_from_bag *args
+          usm
+        else
+          super id, *args
+        end
+      end
+    end
+  end
+end

data/lib/wuclan/myspace.rb

@@ -0,0 +1,21 @@
+require 'monkeyshines/scrape_request/raw_json_contents'
+module Wuclan
+  #
+  # == REST ==
+  #
+  # http://wiki.developer.myspace.com/index.php?title=MySpace_REST_Resources
+  #
+  # == OAuth ==
+  #
+  # http://wiki.developer.myspace.com/index.php?title=OAuth_REST_API_Usage_-_Authentication_Process
+  #
+  # To get a developer API key:
+  # * If you do not already have one, set up a MySpace Developer account.
+  # * Go to the [App] page under the MySpace Open Platform's Build tab,
+  # * select the button labeled "Create MySpaceID App"
+  #
+  module Myspace
+
+  end
+end
+

data/lib/wuclan/open_social/scrape/base.rb

@@ -0,0 +1,111 @@
+require 'monkeyshines/scrape_request/raw_json_contents'
+module Wuclan
+  module Lastfm
+    module Scrape
+
+      #
+      # Base class for Lastfm API requests
+      #
+      class Base < TypedStruct.new(
+          [:identifier,       Integer],
+          [:page,             Integer],
+          [:moreinfo,         String],
+          [:url,              String],
+          [:scraped_at,       Bignum],
+          [:response_code,    Integer],
+          [:response_message, String],
+          [:contents,         String]
+          )
+        # Basic ScrapeRequest functionality
+        include Monkeyshines::ScrapeRequestCore
+        # Contents are JSON
+        include Monkeyshines::RawJsonContents
+        # Paginated
+        class_inheritable_accessor :resource_path, :page_limit, :max_items
+        # API
+        cattr_accessor :api_key
+        #
+        def initialize *args
+          super *args
+          self.page = (page.to_i < 1 ? 1 : page.to_i)
+          make_url! if (! url)
+        end
+        #
+        # Generate request URL from other attributes
+        def make_url
+          # This works for most of the twitter calls
+          "http://ws.audioscrobbler.com/2.0/?method=#{resource_path}&artist=#{identifier}&limit=100&page=#{page}&api_key=#{api_key}&format=json"
+        end
+
+
+        #
+        # For parsing, note the different form for empty responses.
+        #
+      end
+
+      class AlbumInfoRequest              < Base ; self.resource_path = 'Album.getInfo'              ; end
+      class AlbumTagsRequest              < Base ; self.resource_path = 'Album.getTags'              ; end
+      class ArtistEventsRequest           < Base ; self.resource_path = 'Artist.getEvents'           ; end
+      class ArtistImagesRequest           < Base ; self.resource_path = 'Artist.getImages'           ; end
+      class ArtistInfoRequest             < Base ; self.resource_path = 'Artist.getInfo'             ; end
+      class ArtistPodcastRequest          < Base ; self.resource_path = 'Artist.getPodcast'          ; end
+      class ArtistShoutsRequest           < Base ; self.resource_path = 'Artist.getShouts'           ; end
+      class ArtistShoutsRequest           < Base ; self.resource_path = 'artist.getShouts'           ; end
+      class ArtistSimilarRequest          < Base ; self.resource_path = 'Artist.getSimilar'          ; end
+      class ArtistTagsRequest             < Base ; self.resource_path = 'Artist.getTags'             ; end
+      class ArtistTopAlbumsRequest        < Base ; self.resource_path = 'Artist.getTopAlbums'        ; end
+      class ArtistTopFansRequest          < Base ; self.resource_path = 'Artist.getTopFans'          ; end
+      class ArtistTopTagsRequest          < Base ; self.resource_path = 'Artist.getTopTags'          ; end
+      class ArtistTopTracksRequest        < Base ; self.resource_path = 'Artist.getTopTracks'        ; end
+      class EventAttendeesRequest         < Base ; self.resource_path = 'Event.getAttendees'         ; end
+      class EventInfoRequest              < Base ; self.resource_path = 'Event.getInfo'              ; end
+      class EventShoutsRequest            < Base ; self.resource_path = 'Event.getShouts'            ; end
+      class GeoEventsRequest              < Base ; self.resource_path = 'Geo.getEvents'              ; end
+      class GeoTopArtistsRequest          < Base ; self.resource_path = 'Geo.getTopArtists'          ; end
+      class GeoTopTracksRequest           < Base ; self.resource_path = 'Geo.getTopTracks'           ; end
+      class GroupMembersRequest           < Base ; self.resource_path = 'Group.getMembers'           ; end
+      class GroupWeeklyAlbumChartRequest  < Base ; self.resource_path = 'Group.getWeeklyAlbumChart'  ; end
+      class GroupWeeklyArtistChartRequest < Base ; self.resource_path = 'Group.getWeeklyArtistChart' ; end
+      class GroupWeeklyChartListRequest   < Base ; self.resource_path = 'Group.getWeeklyChartList'   ; end
+      class GroupWeeklyTrackChartRequest  < Base ; self.resource_path = 'Group.getWeeklyTrackChart'  ; end
+      class PlaylistfetchRequest          < Base ; self.resource_path = 'Playlist.fetch'             ; end
+      class TagSimilarRequest             < Base ; self.resource_path = 'Tag.getSimilar'             ; end
+      class TagTopAlbumsRequest           < Base ; self.resource_path = 'Tag.getTopAlbums'           ; end
+      class TagTopArtistsRequest          < Base ; self.resource_path = 'Tag.getTopArtists'          ; end
+      class TagTopTagsRequest             < Base ; self.resource_path = 'Tag.getTopTags'             ; end
+      class TagTopTracksRequest           < Base ; self.resource_path = 'Tag.getTopTracks'           ; end
+      class TagWeeklyArtistChartRequest   < Base ; self.resource_path = 'Tag.getWeeklyArtistChart'   ; end
+      class TagWeeklyChartListRequest     < Base ; self.resource_path = 'Tag.getWeeklyChartList'     ; end
+      class TasteometercompareRequest     < Base ; self.resource_path = 'Tasteometer.compare'        ; end
+      class TrackInfoRequest              < Base ; self.resource_path = 'Track.getInfo'              ; end
+      class TrackSimilarRequest           < Base ; self.resource_path = 'Track.getSimilar'           ; end
+      class TrackTagsRequest              < Base ; self.resource_path = 'Track.getTags'              ; end
+      class TrackTopFansRequest           < Base ; self.resource_path = 'Track.getTopFans'           ; end
+      class TrackTopTagsRequest           < Base ; self.resource_path = 'Track.getTopTags'           ; end
+      class UserEventsRequest             < Base ; self.resource_path = 'User.getEvents'             ; end
+      class UserFriendsRequest            < Base ; self.resource_path = 'User.getFriends'            ; end
+      class UserInfoRequest               < Base ; self.resource_path = 'User.getInfo'               ; end
+      class UserLovedTracksRequest        < Base ; self.resource_path = 'User.getLovedTracks'        ; end
+      class UserNeighboursRequest         < Base ; self.resource_path = 'User.getNeighbours'         ; end
+      class UserPastEventsRequest         < Base ; self.resource_path = 'User.getPastEvents'         ; end
+      class UserPlaylistsRequest          < Base ; self.resource_path = 'User.getPlaylists'          ; end
+      class UserRecentStationsRequest     < Base ; self.resource_path = 'User.getRecentStations'     ; end
+      class UserRecentTracksRequest       < Base ; self.resource_path = 'User.getRecentTracks'       ; end
+      class UserRecommendedArtistsRequest < Base ; self.resource_path = 'User.getRecommendedArtists' ; end
+      class UserRecommendedEventsRequest  < Base ; self.resource_path = 'User.getRecommendedEvents'  ; end
+      class UserShoutsRequest             < Base ; self.resource_path = 'User.getShouts'             ; end
+      class UserTopAlbumsRequest          < Base ; self.resource_path = 'User.getTopAlbums'          ; end
+      class UserTopArtistsRequest         < Base ; self.resource_path = 'User.getTopArtists'         ; end
+      class UserTopTagsRequest            < Base ; self.resource_path = 'User.getTopTags'            ; end
+      class UserTopTracksRequest          < Base ; self.resource_path = 'User.getTopTracks'          ; end
+      class UserWeeklyAlbumChartRequest   < Base ; self.resource_path = 'User.getWeeklyAlbumChart'   ; end
+      class UserWeeklyArtistChartRequest  < Base ; self.resource_path = 'User.getWeeklyArtistChart'  ; end
+      class UserWeeklyChartListRequest    < Base ; self.resource_path = 'User.getWeeklyChartList'    ; end
+      class UserWeeklyTrackChartRequest   < Base ; self.resource_path = 'User.getWeeklyTrackChart'   ; end
+      class VenueEventsRequest            < Base ; self.resource_path = 'Venue.getEvents'            ; end
+      class VenuePastEventsRequest        < Base ; self.resource_path = 'Venue.getPastEvents'        ; end
+
+    end
+  end
+end
+

data/lib/wuclan/open_social/scrape_request.rb

@@ -0,0 +1,6 @@
+module Wuclan
+  module OpenSocial
+    class OpsoUserRequest
+    end
+  end
+end

data/lib/wuclan/rdf_output/relationship_rdf.rb

@@ -0,0 +1,47 @@
+module TwitterFriends::StructModel
+
+  module RelationshipCommon
+    def rdf_resource
+      @rdf_resource ||= rdf_component(user_a_id, :user)
+    end
+  end
+
+  AFollowsB.class_eval do
+    include TwitterFriends::TwitterRdf
+    def to_rdf3_tuples
+      [
+        [rdf_component(user_a_id, :user), rdf_pred(:follows), rdf_component(user_b_id, :user)]
+      ]
+    end
+  end
+
+  AFavoritesB.class_eval do
+    include TwitterFriends::TwitterRdf
+    def to_rdf3_tuples
+      [
+        [rdf_component(user_a_id, :user), rdf_pred(:favorited_tweet_by), rdf_component(user_b_id, :user), rdf_component(status_id, :tweet) ],
+        [rdf_component(user_a_id, :user), rdf_pred(:favorited_tweet),    rdf_component(status_id, :tweet) ],
+      ]
+    end
+  end
+
+  ARepliesB.class_eval do
+    include TwitterFriends::TwitterRdf
+    def to_rdf3_tuples
+      [
+        [rdf_component(user_a_id, :user),  rdf_pred(:replied_to),       rdf_component(user_b_id, :user), rdf_component(status_id, :tweet) ],
+        [rdf_component(status_id, :tweet), rdf_pred(:continues_thread), rdf_component(in_reply_to_status_id, :tweet) ],
+      ]
+    end
+  end
+
+  AAtsignsB.class_eval do
+    include TwitterFriends::TwitterRdf
+    def to_rdf3_tuples
+      [
+        [rdf_component(user_a_id, :user), rdf_pred(:atsigns), rdf_component(user_b_name, :user)]
+      ]
+    end
+  end
+
+end

data/lib/wuclan/rdf_output/text_element_rdf.rb

@@ -0,0 +1,64 @@
+module TwitterFriends::StructModel
+
+  
+  #
+  # I don't know what graph arcs are interesting
+  # for RDF we're dumping
+  #  user_a ==tweeted_hashtag=> hashtag
+  # and
+  #  tweet  ==has_hashtag=> hashtag
+  #  
+  Hashtag.class_eval do
+    include TwitterFriends::TwitterRdf
+    #
+    # Ugh. We *really* wish we could reify in nt
+    #
+    def to_rdf3_tuples
+      [
+        [rdf_component(twitter_user_id, :user), rdf_pred(:tweeted_hashtag), rdf_component(text, :str), rdf_component(status_id, :tweet)],
+        [rdf_component(status_id, :tweet),      rdf_pred(:has_hashtag),     rdf_component(text, :str), rdf_component(twitter_user_id, :user)],
+      ]
+    end
+  end
+
+  #
+  # I don't know what graph arcs are interesting
+  # for RDF we're dumping
+  #  user_a ==tweeted_tweet_url=> tweet_url
+  # and
+  #  tweet  ==has_tweet_url=> tweet_url
+  #  
+  TweetUrl.class_eval do
+    include TwitterFriends::TwitterRdf
+    def to_rdf3_tuples
+      [
+        [rdf_component(twitter_user_id, :user), rdf_pred(:tweeted_url),     rdf_component(text, :str), rdf_component(status_id, :tweet)],
+        [rdf_component(status_id, :tweet),      rdf_pred(:has_tweet_url),   rdf_component(text, :str), rdf_component(twitter_user_id, :user)],
+      ]
+    end
+  end
+
+  #
+  # I don't know what graph arcs are interesting
+  # for RDF we're dumping
+  #  user ==retweets=> user
+  # and
+  #  user ==rtwhored_in=> status
+  #  
+  #
+  ARetweetsB.class_eval do
+    include TwitterFriends::TwitterRdf
+    def to_rdf3_tuples
+      if is_retweet?
+        [
+          [rdf_component(user_a_id, :user), rdf_pred(:retweets), rdf_component(user_b_name, :user), rdf_component(status_id, :tweet)],
+        ]
+      else
+        [
+          [rdf_component(user_a_id, :user), rdf_pred(:rtwhored_in), rdf_component(status_id, :tweet)],
+        ]
+      end
+    end
+  end
+
+end

data/lib/wuclan/rdf_output/tweet_rdf.rb

@@ -0,0 +1,10 @@
+module TwitterFriends::StructModel
+  Tweet.class_eval do
+    include ModelCommon
+    include TwitterFriends::TwitterRdf
+    def rdf_resource
+      @rdf_resource ||= rdf_component(id, :tweet)
+    end
+
+  end
+end