yapra 0.1.0

data/legacy_plugins/Feed/lirs.rb

@@ -0,0 +1,36 @@
+## load lirs file plugin -- takatoh
+##
+## see http://d.hatena.ne.jp/takatoh/20070308/loadlirs
+##
+## example
+## - module: Feed::load_lirs
+##   config: 
+##     url: http://example.com/hoge.lirs.gz
+##
+
+
+require 'open-uri'
+require 'rss/maker'
+require 'zlib'
+require 'kconv'
+
+def parse_lirs(record)
+  fields = record.chomp.split(",")
+  item = RSS::RDF::Item.new
+  item.title = fields[6]                                 # Title
+  item.link  = fields[5]                                 # URL
+item.date  = Time.at(fields[1].to_i + fields[3].to_i)  # Last-Modified (local time)
+  return item
+end
+
+
+def lirs(config, data)
+  f = open(config["url"])
+  lirs = Zlib::GzipReader.wrap(f) {|gz| gz.read }.toutf8
+  items = lirs.map {|record| parse_lirs(record) }
+  return items
+rescue
+  puts "LoadError File = #{config["url"]}"
+  return []
+end
+

data/legacy_plugins/Filter/Translations/yahoo.rb

@@ -0,0 +1,40 @@
+## Translate input strings by Yahoo Honyaku -- Soutaro Matsumoto
+
+def yahoo(config, data)
+  begin
+    require 'rubygems'
+  rescue LoadError
+  end
+  require 'mechanize'
+
+
+  config = (config || { "translation" => "en=>ja" })
+
+  trans = case config["translation"]
+          when "en=>ja": "EJ"
+          when "kr=>ja": "KJ"
+          when "cn=>ja": "CJ"
+          when "ja=>en": "JE"
+          when "ja=>kr": "JK"
+          when "ja=>cn": "JC"
+          else
+            return data
+          end
+  
+  data.collect {|d|
+    if d && d =~ /\S/
+      agent = WWW::Mechanize.new
+      start = agent.get("http://honyaku.yahoo.co.jp/")
+      form = start.forms.last
+      
+      form.radiobuttons.each {|radio| radio.checked = (radio.value =~ /#{trans}/) ? true : false }
+      form.fields.name("text").first.value = d
+      
+      result = agent.submit(form)
+      result.forms.name("textFormEntry").fields.name("trn_text").value
+    else
+      d.to_s
+    end
+  }
+
+end

data/legacy_plugins/Filter/apply_text_html.rb

@@ -0,0 +1,26 @@
+
+def apply_text_html(config, data)
+  begin
+    require 'rubygems'
+  rescue LoadError
+  end
+  require 'hpricot'
+  
+  data.collect {|d|
+    doc = Hpricot(d.to_s.toutf8)
+    texts = []
+    doc.traverse_text {|text|
+      texts << text.to_s
+    }
+    
+    data2 = eval_pragger(config, texts)
+    
+    result_html = d.to_s.toutf8
+    
+    Hash[*texts.zip(data2).flatten].each {|k,v|
+      result_html.sub!(k,v)
+    }
+    
+    result_html
+  }
+end

data/legacy_plugins/Filter/average.rb

@@ -0,0 +1,6 @@
+## average plugin -- takatoh
+
+def average(config, data)
+  sum = data.inject(0.0){|a,b| a + b.to_f }
+  return [ sum / data.size ]
+end

data/legacy_plugins/Filter/deduped.rb

@@ -0,0 +1,51 @@
+## Filter::deduped - Plugin to get Deduped entries -- emergent
+## 
+## Plugin to get Deduped entries
+## Cache path can be set.
+##
+## - module: Filter::deduped
+##   config:
+##    path: /tmp/cache/hoge
+##
+require 'pathname'
+require 'digest/md5'
+
+def mkdir_p path
+  begin
+    Dir.mkdir(path)
+  rescue Errno::ENOENT
+    mkdir_p Pathname.new(path).parent
+    retry
+  rescue Errno::EACCES
+    raise
+  end
+  0
+end
+
+def deduped config, data
+  cacheroot = Pathname(__FILE__).parent.parent.parent.realpath + 'cache'
+  cachepath = Pathname.new(config['path']) || root
+  if cachepath.relative?
+    cachepath = cacheroot + cachepath
+  end
+  puts '  cache path: ' + cachepath
+
+  if !File.exists?(cachepath)
+    begin
+      mkdir_p cachepath
+    rescue
+      puts "could'nt make cache directory"
+      return data
+    end
+  end
+  
+  deduped_data = data.select {|d|
+    hashpath = cachepath.to_s + '/' + Digest::MD5.hexdigest(d.to_s)
+    if File.exists?(hashpath)
+      false
+    else 
+      File.open(hashpath, "wb").write(d.to_s) rescue false
+    end
+  }
+  return deduped_data
+end

data/legacy_plugins/Filter/find_num.rb

@@ -0,0 +1,8 @@
+def find_num(config,data)
+  retval = []
+  data.each do |text|
+    text.gsub(/\d(\d|,)+/) {|i| retval.push(i) }
+  end
+  return retval
+end
+

data/legacy_plugins/Filter/find_regex.rb

@@ -0,0 +1,9 @@
+def find_regex(config,data)
+  retval = []
+  reg = Regexp.new(config["regex"])
+  data.each do |text|
+    text.gsub(reg) {|i| retval.push(i) }
+  end
+  return retval
+end
+

data/legacy_plugins/Filter/fresh.rb

@@ -0,0 +1,9 @@
+def fresh(config,data)
+  t = config['duration']
+  t = t.to_i * (60)       if t=~/m$/
+  t = t.to_i * (60*60)    if t=~/h$/
+  t = t.to_i * (60*60*24) if t=~/d$/
+  data.delete_if do |i|
+    i.date < (Time.now - t)
+  end
+end

data/legacy_plugins/Filter/get_html.rb

@@ -0,0 +1,11 @@
+def get_html(config,data)
+  require 'open-uri'
+  require 'kconv'
+
+  data.map do |line|
+    r = ""
+    open(line) {|f| r = f.read.toutf8 }
+    r
+  end
+end
+

data/legacy_plugins/Filter/grep.rb

@@ -0,0 +1,16 @@
+## Filter input by given regular expression -- IKeJI
+## 
+## Filter input by given regular expression.
+## The test will be done with the result of to_s method of the input.
+## invert option will invert results(-v option of UNIX grep command).
+##
+## - module: grep
+##   config:
+##     regex: "[あ-ん]"
+##     invert: false
+
+def grep(config,data)
+  regex = Regexp.new(config["regex"])
+  invert = config["invert"] || false
+  data.select {|i| invert ^ (regex =~ i.to_s) }
+end

data/legacy_plugins/Filter/invert.rb

@@ -0,0 +1,14 @@
+## filter::invert
+##
+## Apply filter of config: section and invert the result.
+##
+## - module: filter::invert
+##   config:
+##     - module: grep
+##       config: 
+##         regex: "理系の人々"
+##
+
+def invert(config, data)
+  data - eval_pragger(config, data)
+end

data/legacy_plugins/Filter/sort.rb

@@ -0,0 +1,10 @@
+def sort(config,data)
+  return data.sort do|a,b|
+    if(config==nil || config["method"] == nil)
+      a <=> b
+    else
+      eval_pragger(config["method"],[a])[0] <=> eval_pragger(config["method"],[b])[0]
+    end
+  end
+end
+

data/legacy_plugins/Filter/subs.rb

@@ -0,0 +1,6 @@
+def subs(config,data)
+  reg = Regexp.new(config["regex"])
+  to = config["to"]
+  return data.map {|i| i.gsub(reg,to) }
+end
+

data/legacy_plugins/Filter/to_integer.rb

@@ -0,0 +1,4 @@
+def to_integer(config,data)
+  return data.map{|i| i.to_i }
+end
+

data/legacy_plugins/Publish/delicious.rb

@@ -0,0 +1,91 @@
+## Publish::delicious - to post feed items to del.icio.us-- emergent
+##
+## - module: Publish::delicious
+##   config:
+##     username: your_username
+##     password: your_password
+##     opt_tag: pragger
+##     no_comment: 1
+##
+require 'rubygems'
+require 'mechanize'
+require 'uri'
+require 'kconv'
+
+class Delicious
+  def initialize username, password, proxy=nil
+    @username = username
+    @password = password
+    @agent    = WWW::Mechanize.new
+    @agent.basic_auth(@username, @password)
+    if proxy && proxy.is_a?(Hash) && proxy['proxy_addr'] && proxy['proxy_port']
+      @agent.set_proxy(proxy['proxy_addr'], proxy['proxy_port'],
+                       proxy['proxy_user'], proxy['proxy_pass'])
+    end
+  end
+
+  def post url, desc, option=nil
+    params = {}
+    post_url = 'https://api.del.icio.us/v1/posts/add?'
+    
+    params[:url] = url
+    params[:description] = desc
+
+    if option
+      params[:extended] = option["summary"]  if option["summary"]
+      params[:dt]       = option["datetime"] if option["datetime"]
+      params[:tags]     = option["tags"]     if option["tags"]
+      params[:replace]  = 'no'               if option["no_replace"]
+      params[:shared]   = 'no'               if option["private"]
+    end
+
+    req_param = []
+    params.map do |k,v|
+      req_param << k.to_s.toutf8 + '=' + v.toutf8 if (v.length > 0)
+    end
+    result = @agent.get(URI.encode(post_url + req_param.join('&')))
+    puts URI.encode(post_url + req_param.join('&'))
+    if result.body =~ /code="done"/
+      return true
+    end
+    false
+  end
+end
+
+def get_tags entry
+  entry.dc_subjects.map do |s| s.content end.join(' ') rescue ''
+end
+
+def delicious config, data
+  sleeptime = 3
+
+  if config['sleep']
+    sleeptime = config['sleep'].to_i
+  end
+
+  data.each {|entry|
+    print 'posting ' + entry.title + ': '
+    
+    tags = get_tags entry
+    if config['opt_tag']
+      tags = [tags, config['opt_tag']].select{|t| t.length > 0}.join(' ')
+    end
+
+    summary = config['no_comment'].to_i > 0 ? '' : entry.description
+
+    begin
+      agent = Delicious.new(config['username'], config['password'])
+      res = agent.post(entry.link, entry.title,
+                       'tags' => tags, 'summary' => summary)
+                       
+      if res then puts 'done' else puts 'failed' end
+    rescue
+      puts 'exception'
+      #raise
+    end
+
+    sleep sleeptime
+  }
+  data
+end
+

data/legacy_plugins/Publish/google_calendar.rb

@@ -0,0 +1,58 @@
+## Write Google Calendar Events -- Soutaro Matsumoto
+## 
+## Write Events on given Calendar.
+## The input must be an array of GooleCalendar::Event.
+##
+## - module: publish::google_calendar
+##   config:
+##     mail: your gmail address
+##     pass: your password
+##     calendar: the name of calendar
+
+begin
+  require 'rubygems'
+rescue LoadError
+end
+require 'gcalapi'
+require 'date'
+
+def google_calendar(config, data)
+  today = Date.today
+  
+  pass = config['pass']
+  mail = config['mail']
+  calendar_name = /#{config['calendar']}/
+
+  start_day = today - 30
+  end_day = today + 31
+  
+  start_time = Time.mktime(start_day.year, start_day.month, start_day.day)
+  end_time = Time.mktime(end_day.year, end_day.month, end_day.day)
+  
+  srv = GoogleCalendar::Service.new(mail, pass)
+  cal_list = GoogleCalendar::Calendar.calendars(srv)
+  calendar = cal_list.values.find {|cal| calendar_name =~ cal.title }
+  
+  if calendar
+    calendar.events(:'start-min' => start_time, :'start-max' => end_time).each {|event|
+      event.destroy!
+    }
+    
+    data.each {|event|
+      begin
+        new_event = calendar.create_event
+        new_event.title = event.title
+        new_event.desc = event.desc
+        new_event.where = event.where
+        new_event.st = event.st
+        new_event.en = event.en
+        new_event.allday = event.allday
+        new_event.save!
+      rescue
+      end
+    }
+  end
+
+  data
+end
+

data/legacy_plugins/Publish/hatena_bookmark.rb

@@ -0,0 +1,47 @@
+## author "emergent"
+## description  "post feeds to hatena bookmark"
+## this requires hatenabm
+## -----
+## $ gem install hatenabm
+## -----
+## example <<EOE
+## - module: Publish::hatena_bookmark
+##   config:
+##     username: your_username
+##     password: your_password
+##     opt_tag: "imported"
+##     no_comment: 1
+## EOE
+## config({ :username => Field.new("username to login", String, true),
+##          :password => Field.new("password to login", String, true),
+##          :opt_tag => Field.new("optional tag(s)", String) })
+require 'rubygems'
+require 'hatenabm'
+
+def hatena_bookmark(config, data)
+  sleeptime = config["sleep"] ? config["sleep"].to_i : 2
+
+  opt_tag = config[:opt_tag] || ''
+  hbm = HatenaBM.new(:user => config['username'],:pass => config['password'])
+
+  data.each {|entry|
+    puts 'posting ' + entry.title + ': '
+
+    tags = entry.dc_subjects.map do |s| s.content end.join(' ') rescue ''    
+    if config['opt_tag']
+      tags = [tags, config['opt_tag']].select{|t| t.length > 0}.join(' ')
+    end
+
+    summary = config['no_comment'] ?  '' : entry.description
+
+    hbm.post(
+             :title => entry.title,
+             :link  => entry.link, 
+             :tags  => tags,
+             :summary => summary
+             )
+    sleep sleeptime
+  }
+  return data
+end
+

data/legacy_plugins/Publish/hatena_diary_writer.rb

@@ -0,0 +1,53 @@
+## Post data to Hatena Diary -- garyo
+##
+## - module: Publish::hatena_diary_writer
+##   config:
+##     user_id: your-hatena-user-id
+##     password: your-password
+
+require 'rubygems'
+require 'mechanize'
+require 'kconv'
+
+class HatenaDiaryWriter
+  def initialize(id,password)
+    @id = id
+    @password = password
+    @agent = WWW::Mechanize.new
+    if proxy = ENV['HTTP_PROXY']
+      proxy = URI.parse(proxy)
+      @agent.set_proxy(proxy.host, proxy.port)
+    end
+    @diary = @agent.get("http://d.hatena.ne.jp/#{id}/")
+  end
+
+  def login
+    login_link = @diary.links.text("ログイン".toeuc)
+    login_page = @agent.get(login_link.href)
+    login_form = login_page.forms.first
+    login_form['name'] = @id
+    login_form['password'] = @password
+    redirect_page = @agent.submit(login_form)
+    @diary_link = redirect_page.links.text("こちら".toutf8)
+    @diary_page = @agent.get(@diary_link.href)
+  end
+
+  def edit(content)
+    edit_link = @diary_page.links.text("日記を書く".toeuc)
+    edit_page = @agent.get(edit_link.href)
+    edit_form = edit_page.forms.name("edit").first
+    edit_form["body"] += content
+    ok_button = edit_form.buttons.name("edit")
+    @agent.submit(edit_form, ok_button)
+  end
+end
+
+def hatena_diary_writer(config, data)
+  diary = HatenaDiaryWriter.new(config['user_id'], config['password']) 
+  content = ''
+  data.each do |line|
+    content << ("* "+line.title+"\n"+line.link+"\n"+line.description rescue line.to_s)
+  end
+  diary.login
+  diary.edit(content.toeuc)
+end

data/legacy_plugins/Publish/hatena_graph.rb

@@ -0,0 +1,39 @@
+## Post data to Hatena Graph -- takatoh
+## 
+## hatenaapigraph 0.2.1 is required.
+## 
+## - module: Publish::hatena_graph
+##   config:
+##     user_id: your-hatena-user-id
+##     password: your-password
+##     graph_name: the-name-of-graph
+##     proxy_host: proxy-host-name   (optional)
+##     proxy_port: proxy-port        (optional)
+##     proxy_user: proxy-user        (optional)
+##     proxy_pass: proxy-password    (optional)
+
+begin
+  require 'rubygems'
+  gem 'hatenaapigraph', '>=0.2.2'
+rescue Exception
+end
+require 'hatena/api/graph'
+
+
+def hatena_graph(config, data)
+  graph = Hatena::API::Graph.new(config['user_id'], config['password'])
+  if config['proxy_host']
+    proxy_host = config['proxy_host']
+    proxy_port = config['proxy_port']
+    proxy_user = config['proxy_user']
+    proxy_pass = config['proxy_pass']
+    graph.proxy = ::Net::HTTP.Proxy(proxy_host, proxy_port, proxy_user, proxy_pass)
+  end
+  data.each do |d|
+    begin
+      graph.post_data(config['graph_name'], :date => d.date, :value => d.value.to_f)
+    rescue
+      graph.post_data(config['graph_name'], :date => Date.today, :value => d.to_f)
+    end
+  end
+end

data/legacy_plugins/Publish/lingr.rb

@@ -0,0 +1,110 @@
+
+def lingr(config,data)
+  require 'open-uri'
+  require 'kconv'
+  require 'net/http'
+  require 'rexml/document'
+  Net::HTTP.version_1_2
+  lapi = LingrRoom.new(config['key'],config['room']||'pragger',config['nick']||'praggrTan')
+
+  data.each do |i|
+    txt = i.title rescue txt = i.to_s
+    lapi.say txt
+  end
+  return data
+end
+
+# Lingr API is from Sasada
+# http://www.atdot.net/~ko1/diary/200702.html#d5
+
+class LingrRoom
+  class LingrAPIError < RuntimeError; end
+
+  def initialize key, room, nick
+    @key = key
+    create_session
+    enter room, nick
+    @active = true
+  end
+
+  def post uri, params = {}
+    uri = URI.parse("http://www.lingr.com/api/#{uri}")
+    Net::HTTP.start(uri.host, uri.port) {|http|
+      response = http.post(uri.path, uri.query)
+      body = response.body
+
+      if false # ||true
+        puts "---------------------------------------------"
+        puts response.code
+        puts uri
+        puts body
+        body
+      end
+      body
+    }
+  end
+
+  def get uri, params = {}
+    open("http://www.lingr.com/api/#{uri}"){|f|
+      f.read
+    }
+  end
+
+  def get_text doc, path
+    e = doc.elements[path]
+    raise LingrAPIError.new("path not found: #{path} at #{doc}") unless e
+    e.get_text
+  end
+
+  def request method, uri, params
+    doc = REXML::Document.new(__send__(method, uri, params))
+    raise LingrAPIError.new("Error: #{doc.to_s}") if get_text(doc, '/response/status') != 'ok'
+    doc
+  end
+
+  def post_request uri, params = {}
+    request :post, uri, params
+  end
+
+  def get_request uri, params = {}
+    request :get, uri, params
+  end
+
+  def create_session
+    doc = post_request "session/create?api_key=#{@key}"
+    @session = get_text(doc, '/response/session')
+  end
+
+  def enter room, nick
+    doc = post_request "room/enter?session=#{@session}&id=#{room}&nickname=#{nick}"
+    @room_doc = doc
+    @ticket = get_text(doc, '/response/ticket')
+    @counter = get_text(doc, '/response/room/counter')
+  end
+
+  def observe
+    doc = get_request "room/observe?session=#{@session}&ticket=#{@ticket}&counter=#{@counter}"
+    #
+    @counter = get_text(doc, '/response/counter')
+    result = []
+    doc.elements['/response/messages'].each{|e|
+      nick = get_text(e, 'nickname')
+      text = get_text(e, 'text')
+      result << [nick, text]
+    }
+    result
+  end
+
+  def observe_loop
+    while @active
+      observe.each{|nick, text|
+        puts "#{nick}: #{text}".tosjis
+      }
+    end
+  end
+
+  def say text
+    doc = post_request "room/say?session=#{@session}&ticket=#{@ticket}&message=#{URI.encode(text)}"
+  end
+end
+