neufelry-twitter 0.4.2

data/lib/twitter/cli/migrations/20080722194500_create_accounts.rb

@@ -0,0 +1,13 @@
+class CreateAccounts < ActiveRecord::Migration
+  def self.up
+    create_table :accounts do |t|
+      t.string :username, :password
+      t.boolean :current
+      t.timestamps
+    end
+  end
+
+  def self.down
+    drop_table :accounts
+  end
+end

data/lib/twitter/cli/migrations/20080722194508_create_tweets.rb

@@ -0,0 +1,16 @@
+class CreateTweets < ActiveRecord::Migration
+  def self.up
+    create_table :tweets do |t|
+      t.datetime :occurred_at
+      t.boolean :truncated, :favorited, :user_protected, :default => false
+      t.integer :twitter_id, :user_id, :in_reply_to_status_id, :in_reply_to_user_id, :user_followers_count
+      t.text :body
+      t.string :source, :user_name, :user_screen_name, :user_location, :user_description, :user_profile_image_url, :user_url
+      t.timestamps
+    end
+  end
+
+  def self.down
+    drop_table :tweets
+  end
+end

data/lib/twitter/cli/migrations/20080722214605_add_account_id_to_tweets.rb

@@ -0,0 +1,9 @@
+class AddAccountIdToTweets < ActiveRecord::Migration
+  def self.up
+    add_column :tweets, :account_id, :integer
+  end
+
+  def self.down
+    remove_column :tweets, :account_id
+  end
+end

data/lib/twitter/cli/migrations/20080722214606_create_configurations.rb

@@ -0,0 +1,13 @@
+class CreateConfigurations < ActiveRecord::Migration
+  def self.up
+    create_table :configurations do |t|
+      t.string :key
+      t.text :data
+      t.timestamps
+    end
+  end
+
+  def self.down
+    drop_table :accounts
+  end
+end

data/lib/twitter/cli/models/account.rb

@@ -0,0 +1,33 @@
+class Account < ActiveRecord::Base
+  named_scope :current, :conditions => {:current => true}
+  
+  has_many :tweets, :dependent => :destroy
+  
+  def self.add(hash)
+    username = hash.delete(:username)
+    account = find_or_initialize_by_username(username)
+    account.attributes = hash
+    account.save
+    set_current(account) if new_active_needed?
+  end
+  
+  def self.active
+    current.first
+  end
+  
+  def self.set_current(account_or_id)
+    account = account_or_id.is_a?(Account) ? account_or_id : find(account_or_id)
+    account.update_attribute :current, true
+    Account.update_all "current = 0", "id != #{account.id}"
+    account
+  end
+  
+  def self.new_active_needed?
+    self.current.count == 0 && self.count > 0
+  end
+  
+  def to_s
+    "#{current? ? '*' : ' '} #{username}"
+  end
+  alias to_str to_s
+end

data/lib/twitter/cli/models/configuration.rb

@@ -0,0 +1,13 @@
+class Configuration < ActiveRecord::Base
+  serialize :data
+  
+  def self.[](key)
+    key = find_by_key(key.to_s)
+    key.nil? ? nil : key.data
+  end
+  
+  def self.[]=(key, data)
+    c = find_or_create_by_key(key.to_s)
+    c.update_attribute :data, data
+  end
+end

data/lib/twitter/cli/models/tweet.rb

@@ -0,0 +1,20 @@
+class Tweet < ActiveRecord::Base
+  belongs_to :account
+  
+  def self.create_from_tweet(account, s)
+    tweet             = account.tweets.find_or_initialize_by_twitter_id(s.id)
+    tweet.body        = s.text
+    tweet.occurred_at = s.created_at
+    
+    %w[truncated favorited in_reply_to_status_id in_reply_to_user_id source].each do |m|
+      tweet.send("#{m}=", s.send(m))
+    end
+    
+    %w[id followers_count name screen_name location description 
+      profile_image_url url protected].each do |m|
+      tweet.send("user_#{m}=", s.user.send(m))
+    end
+    tweet.save!
+    tweet
+  end
+end

data/lib/twitter/direct_message.rb

@@ -0,0 +1,22 @@
+module Twitter
+  class DirectMessage
+    include EasyClassMaker
+    
+    attributes :id, :text, :sender_id, :recipient_id, :created_at, :sender_screen_name, :recipient_screen_name
+    
+    class << self
+      # Creates a new status from a piece of xml
+      def new_from_xml(xml)
+        DirectMessage.new do |d|
+          d.id                    = (xml).at('id').innerHTML
+          d.text                  = (xml).get_elements_by_tag_name('text').innerHTML
+          d.sender_id             = (xml).at('sender_id').innerHTML
+          d.recipient_id          = (xml).at('recipient_id').innerHTML
+          d.created_at            = (xml).at('created_at').innerHTML
+          d.sender_screen_name    = (xml).at('sender_screen_name').innerHTML
+          d.recipient_screen_name = (xml).at('recipient_screen_name').innerHTML
+        end
+      end
+    end
+  end
+end

data/lib/twitter/easy_class_maker.rb

@@ -0,0 +1,43 @@
+# This is pretty much just a macro for creating a class that allows
+# using a block to initialize stuff and to define getters and setters
+# really quickly.
+module Twitter
+  module EasyClassMaker
+    
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+    
+    module ClassMethods
+      # creates the attributes class variable and creates each attribute's accessor methods
+      def attributes(*attrs)
+        @@attributes = attrs
+        @@attributes.each { |a| attr_accessor a }
+      end
+      
+      # read method for attributes class variable
+      def self.attributes; @@attributes end
+    end
+    
+    # allows for any class that includes this to use a block to initialize
+    # variables instead of assigning each one seperately
+    # 
+    # Example: 
+    # 
+    # instead of...
+    # 
+    # s = Status.new
+    # s.foo = 'thing'
+    # s.bar = 'another thing'
+    #
+    # you can ...
+    # 
+    # Status.new do |s|
+    #   s.foo = 'thing'
+    #   s.bar = 'another thing'
+    # end
+    def initialize
+      yield self if block_given?
+    end
+  end
+end

data/lib/twitter/rate_limit_status.rb

@@ -0,0 +1,19 @@
+module Twitter
+  class RateLimitStatus
+    include EasyClassMaker
+    
+    attributes :reset_time_in_seconds, :reset_time, :remaining_hits, :hourly_limit
+    
+    class << self
+      # Creates a new rate limi status from a piece of xml
+      def new_from_xml(xml)
+        RateLimitStatus.new do |s|
+          s.reset_time_in_seconds = xml.at('reset-time-in-seconds').inner_html.to_i
+          s.reset_time            = Time.parse xml.at('reset-time').inner_html
+          s.remaining_hits        = xml.at('remaining-hits').inner_html.to_i
+          s.hourly_limit          = xml.at('hourly-limit').inner_html.to_i
+        end
+      end
+    end
+  end
+end

data/lib/twitter/search.rb

@@ -0,0 +1,101 @@
+gem 'httparty'
+require 'httparty'
+
+module Twitter
+  class Search
+    include HTTParty
+    include Enumerable
+    base_uri 'search.twitter.com'
+    
+    attr_reader :result, :query
+    
+    def initialize(q=nil)
+      clear
+      containing(q) if q && q.strip != ''
+    end
+    
+    def from(user)
+      @query[:q] << "from:#{user}"
+      self
+    end
+    
+    def to(user)
+      @query[:q] << "to:#{user}"
+      self
+    end
+    
+    def referencing(user)
+      @query[:q] << "@#{user}"
+      self
+    end
+    alias :references :referencing
+    alias :ref :referencing
+    
+    def containing(word)
+      @query[:q] << "#{word}"
+      self
+    end
+    alias :contains :containing
+    
+    # adds filtering based on hash tag ie: #twitter
+    def hashed(tag)
+      @query[:q] << "##{tag}"
+      self
+    end
+    
+    # lang must be ISO 639-1 code ie: en, fr, de, ja, etc.
+    #
+    # when I tried en it limited my results a lot and took 
+    # out several tweets that were english so i'd avoid 
+    # this unless you really want it
+    def lang(lang)
+      @query[:lang] = lang
+      self
+    end
+    
+    # Limits the number of results per page
+    def per_page(num)
+      @query[:rpp] = num
+      self
+    end
+    
+    # Which page of results to fetch
+    def page(num)
+      @query[:page] = num
+      self
+    end
+    
+    # Only searches tweets since a given id. 
+    # Recommended to use this when possible.
+    def since(since_id)
+      @query[:since_id] = since_id
+      self
+    end
+    
+    # Search tweets by longitude, latitude and a given range.
+    # Ranges like 25km and 50mi work.
+    def geocode(long, lat, range)
+      @query[:geocode] = [long, lat, range].join(',')
+      self
+    end
+    
+    # Clears all the query filters to make a new search
+    def clear
+      @query = {}
+      @query[:q] = []
+      self
+    end
+    
+    # If you want to get results do something other than iterate over them.
+    def fetch
+      @query[:q] = @query[:q].join(' ')
+      SearchResultInfo.new_from_hash(self.class.get('/search.json', {:query => @query}))
+    end
+    
+    def each
+      @result = fetch()
+      @result['results'].each { |r| yield r }
+    end
+  end
+end
+

data/lib/twitter/search_result.rb

@@ -0,0 +1,83 @@
+module Twitter
+  class SearchResult < Hash
+    
+    # Creates an easier to work with hash from
+    # one with string-based keys
+    def self.new_from_hash(hash)
+      new.merge!(hash)
+    end
+    
+    def created_at
+      self['created_at']
+    end
+    
+    def created_at=(val)
+      self['created_at'] = val
+    end
+    
+    def from_user
+      self['from_user']
+    end
+    
+    def from_user=(val)
+      self['from_user'] = val
+    end
+    
+    def from_user_id
+      self['from_user_id']
+    end
+    
+    def from_user_id=(val)
+      self['from_user_id'] = val
+    end
+    
+    def id
+      self['id']
+    end
+    
+    def id=(val)
+      self['id'] = val
+    end
+    
+    def iso_language_code
+      self['iso_language_code']
+    end
+    
+    def iso_language_code=(val)
+      self['iso_language_code'] = val
+    end
+    
+    def profile_image_url
+      self['profile_image_url']
+    end
+    
+    def profile_image_url=(val)
+      self['profile_image_url'] = val
+    end
+    
+    def text
+      self['text']
+    end
+    
+    def text=(val)
+      self['text'] = val
+    end
+    
+    def to_user
+      self['to_user']
+    end
+    
+    def to_user=(val)
+      self['to_user'] = val
+    end
+    
+    def to_user_id
+      self['to_user_id']
+    end
+    
+    def to_user_id=(val)
+      self['to_user_id'] = val
+    end
+    
+  end
+end

data/lib/twitter/search_result_info.rb

@@ -0,0 +1,82 @@
+module Twitter
+  class SearchResultInfo < Hash
+    
+    # Creates an easier to work with hash from
+    # one with string-based keys
+    def self.new_from_hash(hash)
+      i = new
+      i.merge!(hash)
+      search_results = []
+      i.results.each do |r|
+        search_results << SearchResult.new_from_hash(r)
+      end
+      i.results = search_results
+      i
+    end
+    
+    def completed_in
+      self['completed_in']
+    end
+    
+    def completed_in=(val)
+      self['completed_in'] = val
+    end
+    
+    def max_id
+      self['max_id']
+    end
+    
+    def max_id=(val)
+      self['max_id'] = val
+    end
+    
+    def next_page
+      self['next_page']
+    end
+    
+    def next_page=(val)
+      self['next_page'] = val
+    end
+    
+    def page
+      self['page']
+    end
+    
+    def page=(val)
+      self['page'] = val
+    end
+    
+    def refresh_url
+      self['refresh_url']
+    end
+    
+    def refresh_url=(val)
+      self['refresh_url'] = val
+    end
+    
+    def results_per_page
+      self['results_per_page']
+    end
+    
+    def results_per_page=(val)
+      self['results_per_page'] = val
+    end
+    
+    def since_id
+      self['since_id']
+    end
+    
+    def since_id=(val)
+      self['since_id'] = val
+    end
+    
+    def results
+      self['results']
+    end
+    
+    def results=(val)
+      self['results'] = val
+    end
+    
+  end
+end