atig 0.0.1

data/lib/atig/stream.rb

@@ -0,0 +1,66 @@
+# -*- mode:ruby; coding:utf-8 -*-
+
+require 'json'
+require 'uri'
+require 'logger'
+require 'atig/twitter_struct'
+require 'atig/util'
+require 'atig/url_escape'
+
+module Atig
+  class Stream
+    include Util
+
+    class APIFailed < StandardError; end
+    def initialize(context, user, password)
+      @log      = context.log
+      @opts     = context.opts
+      @user     = user
+      @password = password
+    end
+
+    def watch(path, query={}, &f)
+      path.sub!(%r{\A/+}, "")
+
+      uri = api_base
+      uri.path += path
+      uri.path += ".json"
+      uri.query = query.to_query_str unless query.empty?
+
+      @log.debug [uri.to_s]
+
+      Net::HTTP.start(uri.host, uri.port) do |http|
+        request = Net::HTTP::Post.new uri.request_uri
+        request.basic_auth @user, @password
+
+        http.request(request) do |response|
+          unless response.code == '200' then
+            raise APIFailed,"#{response.code} #{response.message}"
+          end
+
+          begin
+            buffer = ''
+            response.read_body do |chunk|
+              next if chunk.chomp.empty?
+              buffer << chunk.to_s
+
+              if buffer =~ /\A(.*)\n/ then
+                text = $1
+                unless text.strip.empty?
+                  f.call TwitterStruct.make(JSON.parse(text))
+                end
+                buffer = ''
+              end
+            end
+          rescue => e
+            raise APIFailed,e.to_s
+          end
+        end
+      end
+    end
+
+    def api_base
+      URI(@opts.stream_api_base)
+    end
+  end
+end

data/lib/atig/twitter.rb

@@ -0,0 +1,79 @@
+#!/usr/bin/env ruby
+# -*- coding: utf-8 -*-
+require 'atig/basic_twitter'
+require 'atig/http'
+
+module Atig
+  # from tig.rb
+  class Twitter < BasicTwitter
+    def initialize(context, oauth)
+      super context, :api_base
+      @oauth = oauth
+      @http  = Atig::Http.new @log
+    end
+
+    # authenticate = trueでないとSSL verified errorがでることがある
+    def page(path, name, authenticate = true, &block)
+      limit = 0.98 * @remain # 98% of IP based rate limit
+      r     = []
+      cursor = -1
+      1.upto(limit) do |num|
+        # next_cursor にアクセスするとNot found が返ってくることがあるので，その時はbreak
+        ret = api(path, { :cursor => cursor }, { :authenticate => authenticate }) rescue break
+        arr = ret[name.to_s]
+        r.concat arr
+        cursor = ret[:next_cursor]
+        break if cursor.zero?
+      end
+      r
+    end
+
+    def self.http_methods(*methods)
+      methods.each do |m|
+        self.module_eval <<END
+          def #{m}(path, query = {}, opts = {})
+            opts.update( :method => :#{m})
+            api path, query, opts
+          end
+END
+      end
+    end
+    http_methods :get, :post, :put, :delete
+
+    protected
+    def request(uri, opts)
+      authenticate = opts.fetch(:authenticate, true)
+      method       = opts.fetch(:method, :get)
+
+      header      = {}
+      req         = @http.req method, uri, header
+      @log.debug [req.method, uri.to_s]
+
+      if authenticate
+        oauth 30, req
+      else
+        @http.http(uri, 30, 30).request req
+      end
+    end
+
+    def oauth(time, req)
+      timeout(time) do
+        headers = {}
+        req.each{|k,v| headers[k] = v }
+
+        case req
+        when Net::HTTP::Get
+          @oauth.get req.path,headers
+        when Net::HTTP::Head
+          @oauth.head req.path,headers
+        when Net::HTTP::Post
+          @oauth.post req.path,req.body,headers
+        when Net::HTTP::Put
+          @oauth.put req.path,req.body,headers
+        when Net::HTTP::Delete
+          @oauth.delete req.path,headers
+        end
+      end
+    end
+  end
+end

data/lib/atig/twitter_struct.rb

@@ -0,0 +1,63 @@
+# -*- mode:ruby; coding:utf-8 -*-
+#
+
+module Atig
+  # from tig.rb
+  class TwitterStruct
+    def self.make(obj)
+      case obj
+      when Hash
+        obj = obj.dup
+        obj.each do |k, v|
+          obj[k] = TwitterStruct.make(v)
+        end
+        TwitterStruct.new(obj)
+      when Array
+        obj.map {|i| TwitterStruct.make(i) }
+      else
+        obj
+      end
+    end
+
+    def initialize(obj)
+      @obj = obj
+    end
+
+    def id
+      @obj["id"]
+    end
+
+    def [](name)
+      @obj[name.to_s]
+    end
+
+    def []=(name,val)
+      @obj[name.to_s] = val
+    end
+
+    def merge(hash)
+      obj = @obj.dup
+      hash.each do|key,value|
+        obj[key.to_s] = value
+      end
+      TwitterStruct.make obj
+    end
+
+    def hash
+      self.id ? self.id.hash : super
+    end
+
+    def eql?(other)
+      self.hash == other.hash
+    end
+
+    def ==(other)
+      self.hash == other.hash
+    end
+
+    def method_missing(sym, *args)
+      # XXX
+      @obj[sym.to_s]
+    end
+  end
+end

data/lib/atig/unu.rb

@@ -0,0 +1,27 @@
+# -*- mode:ruby; coding:utf-8 -*-
+module Atig
+  class Unu
+    def initialize(logger)
+      @log = logger
+      @http = Atig::Http.new logger
+    end
+
+    def shorten(url)
+      unu_url = "http://u.nu/"
+      unu     = URI("#{unu_url}unu-api-simple")
+      url = URI.rstrip url
+      unu.query = { :url => url }.to_query_str
+      res = @http.http(unu, 5, 5).request(@http.req(:get, unu)).body
+
+      if res[0, 12] == unu_url
+        res
+      else
+        @log.error res
+        url
+      end
+    rescue Errno::ETIMEDOUT, JSON::ParserError, IOError, Timeout::Error, Errno::ECONNRESET => e
+      @log.error e
+      url
+    end
+  end
+end

data/lib/atig/update_checker.rb

@@ -0,0 +1,53 @@
+# -*- mode:ruby; coding:utf-8 -*-
+
+module Atig
+  module UpdateChecker
+    def commits
+      uri = URI("http://github.com/api/v1/json/mzp/atig/commits/master")
+      http = Atig::Http.new
+      res = http.http(uri).request http.req(:get, uri)
+      JSON.parse(res.body)['commits']
+    end
+
+    def server_version
+      @server_version ||= instance_eval {
+        head = `git rev-parse HEAD 2>/dev/null`.chomp
+        head.empty?? "unknown" : head
+      }
+    end
+
+    def local_repos?(rev)
+      system("git show #{rev} > /dev/null 2>&1")
+    end
+
+    def git?
+      system('which git > /dev/null 2>&1')
+    end
+
+    def latest
+      unless git? then
+        []
+      else
+        cs      = commits
+        latest  = cs.first['id'][/^[0-9a-z]{40}$/]
+        raise "github API changed?" unless latest
+
+        if local_repos?(latest) then
+          []
+        else
+          current  = cs.map {|i| i['id'] }.index(server_version)
+          if current then
+            cs[0...current]
+          else
+            cs
+          end.map {|i| i['message'] }
+        end
+      end
+    rescue Errno::ECONNREFUSED, Timeout::Error => e
+      []
+    end
+
+    module_function :latest, :commits, :server_version, :local_repos?, :git?
+  end
+end
+

data/lib/atig/url_escape.rb

@@ -0,0 +1,62 @@
+# -*- mode:ruby; coding:utf-8 -*-
+
+class Hash
+  # { :f  => "v" }    #=> "f=v"
+  # { "f" => [1, 2] } #=> "f=1&f=2"
+  # { "f" => "" }     #=> "f="
+  # { "f" => nil }    #=> "f"
+  def to_query_str separator = "&"
+    inject([]) do |r, (k, v)|
+      k = URI.encode_component k.to_s
+      (v.is_a?(Array) ? v : [v]).each do |i|
+        if i.nil?
+          r << k
+        else
+          r << "#{k}=#{URI.encode_component i.to_s}"
+        end
+      end
+      r
+    end.join separator
+  end
+end
+
+class String
+  def ch?
+    /\A[&#+!][^ \007,]{1,50}\z/ === self
+  end
+
+  def screen_name?
+    /\A[A-Za-z0-9_]{1,15}\z/ === self
+  end
+
+  def encoding! enc
+    return self unless respond_to? :force_encoding
+    force_encoding enc
+  end
+end
+
+module URI::Escape
+  alias :_orig_escape :escape
+
+  if defined? ::RUBY_REVISION and RUBY_REVISION < 24544
+		# URI.escape("あ１") #=> "%E3%81%82\xEF\xBC\x91"
+    # URI("file:///４")  #=> #<URI::Generic:0x9d09db0 URL:file:/４>
+    #   "\\d" -> "[0-9]" for Ruby 1.9
+    def escape str, unsafe = %r{[^-_.!~*'()a-zA-Z0-9;/?:@&=+$,\[\]]} #'
+      _orig_escape(str, unsafe)
+    end
+    alias :encode :escape
+  end
+
+  def encode_component str, unsafe = /[^-_.!~*'()a-zA-Z0-9 ]/
+    _orig_escape(str, unsafe).tr(" ", "+")
+  end
+
+  def rstrip str
+		str.sub(%r{
+			(?: ( / [^/?#()]* (?: \( [^/?#()]* \) [^/?#()]* )* ) \) [^/?#()]*
+			  | \.
+			) \z
+		}x, "\\1")
+  end
+end

data/lib/atig/util.rb

@@ -0,0 +1,16 @@
+# -*- mode:ruby; coding:utf-8 -*-
+
+require 'atig/exception_util'
+module Atig
+  module Util
+    private
+    include ExceptionUtil
+    def log(type, s)
+      if @log then
+        @log.send type, "[#{self.class}] #{s}"
+      else
+        STDERR.puts s
+      end
+    end
+  end
+end

data/lib/atig/version.rb

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

data/lib/memory_profiler.rb

@@ -0,0 +1,77 @@
+# This is a memory profiler for Ruby. Once started, it runs in a thread in the
+# background, periodically inspecting Ruby's ObjectSpace to look for new
+# objects and printing a count of objects added and removed since the previous
+# cycle.
+#
+# To use the profiler, do something like this:
+#
+#   require 'memory_profiler'
+#
+#   MemoryProfiler.start
+#
+# The profiler will write logs to ./log/memory_profiler.log.
+#
+# If you start MemoryProfiler with the ':string_debug => true' option, then it
+# will dump a list of all strings in the app into the log/ directory after
+# each cycle.  You can then use 'diff' to spot which strings were added
+# between runs.
+class MemoryProfiler
+  DEFAULTS = {:delay => 10, :string_debug => false}
+
+  def self.start(opt={})
+    opt = DEFAULTS.dup.merge(opt)
+
+    Thread.new do
+      prev = Hash.new(0)
+      curr = Hash.new(0)
+      curr_strings = []
+      delta = Hash.new(0)
+
+      file = File.open("log/memory_profiler.#{Time.now.to_i}.log",'w')
+
+      loop do
+        begin
+          GC.start
+          curr.clear
+
+          curr_strings = [] if opt[:string_debug]
+
+          ObjectSpace.each_object do |o|
+            curr[o.class] += 1 #Marshal.dump(o).size rescue 1
+            if opt[:string_debug] and o.class == String
+              curr_strings.push o
+            end
+          end
+
+          if opt[:string_debug]
+            File.open("log/memory_profiler_strings.log.#{Time.now.to_i}",'w') do |f|
+              curr_strings.sort.each do |s|
+                f.puts s
+              end
+            end
+            curr_strings.clear
+          end
+
+          delta.clear
+          (curr.keys + delta.keys).uniq.each do |k,v|
+            delta[k] = curr[k]-prev[k]
+          end
+
+          file.puts "Top 20: #{Time.now}"
+          delta.sort_by { |k,v| -v.abs }[0..19].sort_by { |k,v| -v}.each do |k,v|
+            file.printf "%+5d: %s (%d)\n", v, k.name, curr[k] unless v == 0
+          end
+          file.flush
+
+          delta.clear
+          prev.clear
+          prev.update curr
+          GC.start
+        rescue Exception => err
+          STDERR.puts "** memory_profiler error: #{err}"
+        end
+        sleep opt[:delay]
+      end
+    end
+  end
+end