anthonycrumley-twitter 0.3.8

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,94 @@
+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) unless q.blank?
+    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
+    
+    # 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(' ')
+      self.class.get('/search.json', {:query => @query})
+    end
+    
+    def each
+      @result = fetch()
+      @result['results'].each { |r| yield r }
+    end
+  end
+end

data/lib/twitter/status.rb

@@ -0,0 +1,22 @@
+module Twitter
+  class Status
+    include EasyClassMaker
+    
+    attributes :created_at, :id, :text, :user, :source, :truncated, :in_reply_to_status_id, :in_reply_to_user_id, :favorited
+    
+    # Creates a new status from a piece of xml
+    def self.new_from_xml(xml)
+      s = new
+      s.id                    = (xml).at('id').innerHTML
+      s.created_at            = (xml).at('created_at').innerHTML
+      s.text                  = (xml).get_elements_by_tag_name('text').innerHTML
+      s.source                = (xml).at('source').innerHTML
+      s.truncated             = (xml).at('truncated').innerHTML == 'false' ? false : true
+      s.favorited             = (xml).at('favorited').innerHTML == 'false' ? false : true
+      s.in_reply_to_status_id = (xml).at('in_reply_to_status_id').innerHTML
+      s.in_reply_to_user_id   = (xml).at('in_reply_to_user_id').innerHTML
+      s.user                  = User.new_from_xml(xml.at('user')) if (xml).at('user')
+      s
+    end
+  end
+end

data/lib/twitter/user.rb

@@ -0,0 +1,37 @@
+module Twitter
+  class User    
+    include EasyClassMaker
+    
+    attributes  :id, :name, :screen_name, :status, :location, :description, :url,
+                :profile_image_url, :profile_background_color, :profile_text_color, :profile_link_color, 
+                :profile_sidebar_fill_color, :profile_sidebar_border_color, :friends_count, :followers_count,
+                :favourites_count, :statuses_count, :utc_offset , :protected
+    
+    # Creates a new user from a piece of xml
+    def self.new_from_xml(xml)
+      u = new
+      u.id                           = (xml).at('id').innerHTML
+      u.name                         = (xml).at('name').innerHTML
+      u.screen_name                  = (xml).at('screen_name').innerHTML
+      u.location                     = (xml).at('location').innerHTML
+      u.description                  = (xml).at('description').innerHTML
+      u.url                          = (xml).at('url').innerHTML
+      u.profile_image_url            = (xml).at('profile_image_url').innerHTML          
+      
+      # optional, not always present
+      u.profile_background_color     = (xml).at('profile_background_color').innerHTML if (xml).at('profile_background_color')
+      u.profile_text_color           = (xml).at('profile_text_color').innerHTML if (xml).at('profile_text_color')
+      u.profile_link_color           = (xml).at('profile_link_color').innerHTML if (xml).at('profile_link_color')
+      u.profile_sidebar_fill_color   = (xml).at('profile_sidebar_fill_color').innerHTML if (xml).at('profile_sidebar_fill_color')
+      u.profile_sidebar_border_color = (xml).at('profile_sidebar_border_color').innerHTML if (xml).at('profile_sidebar_border_color')
+      u.friends_count                = (xml).at('friends_count').innerHTML if (xml).at('friends_count')
+      u.followers_count              = (xml).at('followers_count').innerHTML if (xml).at('followers_count')
+      u.favourites_count             = (xml).at('favourites_count').innerHTML if (xml).at('favourites_count')
+      u.statuses_count               = (xml).at('statuses_count').innerHTML if (xml).at('statuses_count')
+      u.utc_offset                   = (xml).at('utc_offset').innerHTML if (xml).at('utc_offset')
+      u.protected                    = (xml).at('protected').innerHTML == 'false' ? false : true if (xml).at('protected')
+      u.status                       = Status.new_from_xml(xml.at('status')) if (xml).at('status')
+      u
+    end
+  end
+end

data/lib/twitter/version.rb

@@ -0,0 +1,9 @@
+module Twitter #:nodoc:
+  module VERSION #:nodoc:
+    MAJOR = 0
+    MINOR = 3
+    TINY  = 7
+
+    STRING = [MAJOR, MINOR, TINY].join('.')
+  end
+end

data/script/destroy

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.join(File.dirname(__FILE__), '..')
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/destroy'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:rubygems, :newgem, :newgem_theme, :test_unit]
+RubiGen::Scripts::Destroy.new.run(ARGV)

data/script/generate

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.join(File.dirname(__FILE__), '..')
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/generate'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:rubygems, :newgem, :newgem_theme, :test_unit]
+RubiGen::Scripts::Generate.new.run(ARGV)

data/script/txt2html

@@ -0,0 +1,74 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+begin
+  require 'newgem'
+rescue LoadError
+  puts "\n\nGenerating the website requires the newgem RubyGem"
+  puts "Install: gem install newgem\n\n"
+  exit(1)
+end
+require 'redcloth'
+require 'syntax/convertors/html'
+require 'erb'
+require File.dirname(__FILE__) + '/../lib/twitter/version.rb'
+
+version  = Twitter.git::VERSION::STRING
+download = 'http://rubyforge.org/projects/twitter'
+
+class Fixnum
+  def ordinal
+    # teens
+    return 'th' if (10..19).include?(self % 100)
+    # others
+    case self % 10
+    when 1: return 'st'
+    when 2: return 'nd'
+    when 3: return 'rd'
+    else    return 'th'
+    end
+  end
+end
+
+class Time
+  def pretty
+    return "#{mday}#{mday.ordinal} #{strftime('%B')} #{year}"
+  end
+end
+
+def convert_syntax(syntax, source)
+  return Syntax::Convertors::HTML.for_syntax(syntax).convert(source).gsub(%r!^<pre>|</pre>$!,'')
+end
+
+if ARGV.length >= 1
+  src, template = ARGV
+  template ||= File.join(File.dirname(__FILE__), '/../website/template.rhtml')
+  
+else
+  puts("Usage: #{File.split($0).last} source.txt [template.rhtml] > output.html")
+  exit!
+end
+
+template = ERB.new(File.open(template).read)
+
+title = nil
+body = nil
+File.open(src) do |fsrc|
+  title_text = fsrc.readline
+  body_text = fsrc.read
+  syntax_items = []
+  body_text.gsub!(%r!<(pre|code)[^>]*?syntax=['"]([^'"]+)[^>]*>(.*?)</\1>!m){
+    ident = syntax_items.length
+    element, syntax, source = $1, $2, $3
+    syntax_items << "<#{element} class='syntax'>#{convert_syntax(syntax, source)}</#{element}>"
+    "syntax-temp-#{ident}"
+  }
+  title = RedCloth.new(title_text).to_html.gsub(%r!<.*?>!,'').strip
+  body = RedCloth.new(body_text).to_html
+  body.gsub!(%r!(?:<pre><code>)?syntax-temp-(\d+)(?:</code></pre>)?!){ syntax_items[$1.to_i] }
+end
+stat = File.stat(src)
+created = stat.ctime
+modified = stat.mtime
+
+$stdout << template.result(binding)