yapra 0.1.0

data/legacy_plugins/Publish/mixi_diary_writer.rb

@@ -0,0 +1,104 @@
+## author "emergent"
+## descr  "post feed(s) to mixi diary"
+## 
+## example <<EOE
+## when posting one diary per one feed 
+## - module: publish::mixi_diary_writer
+##   config:
+##     username: test@test.com
+##     password: ********
+## 
+## when posting merged feeds to one diary
+## - module: publish::mixi_diary_writer
+##   config:
+##     username: test@test.com
+##     password: ********
+##     title: "フィード一覧"
+##     merge_feeds: 1
+## EOE
+## config({ :username => Field.new("username to login", String, true),
+##          :password => Field.new("password to login", String, true),
+##          :merge_feeds => Field.new("aggregate feeds to one diary", String),
+##          :title => Field.new("title when merge_feeds is on", String) })
+
+require 'rubygems'
+require 'mechanize'
+require 'kconv'
+
+class MixiDiaryWriter
+
+  def initialize username=nil, password=nil
+    @id = nil
+    @username = username
+    @password = password
+    @agent = WWW::Mechanize.new
+  end
+
+  def login username=@username, password=@password
+    if username == nil || password == nil
+      return
+    else
+      @username = username
+      @password = password
+    end
+    @agent.post('http://mixi.jp/login.pl', 
+                { 'email' => @username,
+                  'password' => @password,
+                  'next_url' => '/home.pl' })
+    @home_page = @agent.get('http://mixi.jp/home.pl')
+  end
+
+  def edit title, content
+    if /add_diary\.pl\?id=(\d+)/ =~ @home_page.body
+      @id = $1
+    end
+
+    @edit_page = @agent.get('http://mixi.jp/add_diary.pl?id='+@id)
+
+    begin
+      edit_form = @edit_page.forms.name("diary").first
+      edit_form['diary_title'] = title.toeuc
+      edit_form['diary_body'] = content.toeuc
+      confirm_page = @agent.submit(edit_form)
+    
+      conf_form = confirm_page.forms[0] # select 'hai'
+      @agent.submit(conf_form)
+    rescue => e
+      puts "Exception when posting diary"
+      puts e.message
+      puts e.backtrace.join("\n")
+    end
+  end
+
+  OK_TAGS = 'a|p|strong|em|u|del|blockquote'
+  def striptags str
+    str.gsub!(/<br.*?>/, "\n")
+    str.gsub!(/<[\/]{0,1}(?!(?:(?:#{OK_TAGS})(?:\s|>)))\w+[\s]{0,1}.*?>/, '')
+    str
+  end
+end
+
+def mixi_diary_writer(config, data)
+  title = config['title'] || data[0].title
+  content = []
+
+  if config['merge_feeds'] #.to_i == 1
+    data.each {|item|
+      content << {:title => title, :body => ('- <a href="'+item.link+'">'+item.title+"</a>\n"+item.description+"...\n\n" rescue item.to_s)}
+    }
+  else
+    data.each {|d|
+      # delete line feed and space at the top of content
+      content << {:title => d.title, :body => d.content_encoded.to_s.sub(/^(?:\s+)/, '')}
+    }
+  end
+
+  mdw = MixiDiaryWriter.new(config['username'], config['password'])
+
+  content.each {|entry|
+    mdw.login
+    mdw.edit entry[:title], mdw.striptags(entry[:body])
+  }
+
+  return data
+end

data/legacy_plugins/Publish/scuttle.rb

@@ -0,0 +1,92 @@
+## Publish::scuttle - to post feed items to scuttle -- emergent
+##
+## - module: Publish::scuttle
+##   config:
+##     url: http://your.example.com/scuttle/
+##     username: your_username
+##     password: your_password
+##     opt_tag: pragger
+##     no_comment: 1
+##
+require 'rubygems'
+require 'mechanize'
+require 'uri'
+require 'kconv'
+
+class Scuttle
+
+  def initialize url, username, password, proxy=nil
+    @post_url = url + 'api/posts/add?'
+    @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 = {}
+    
+    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.each 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('&')))
+    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 scuttle 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'] ? entry.description : ''
+
+    begin
+      agent = Scuttle.new(config['url'], 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
+  }
+  return data
+end
+

data/legacy_plugins/Publish/twitter.rb

@@ -0,0 +1,35 @@
+##Publish::twitter  -- itoshi
+##
+## from: http://itoshi.tv/d/?date=20071123#p01
+##
+##- module: Publish::twitter
+##  config:
+##    login: xxxxxx
+##    password: xxx
+##    check: 30##
+##
+
+begin
+  require 'rubygems'
+rescue LoadError
+end
+require 'twitter'
+require 'kconv'
+
+def twitter(config, data)
+  c = Twitter::Client.new(:login=>config["login"], :password=>config["password"])
+
+  posts = c.timeline_for(:me,:count=>config["check"])
+  posted_entries = posts.map do |post| post.text.gsub!(/ http.+$/, '') end
+
+  data.reverse.each {|item|
+    link  = item.link
+    title = item.title.toutf8
+
+    next if posted_entries.include? title
+
+    comment = [title, link].join(' ')
+    s = c.status(:post, comment)
+    p comment
+  }
+end

data/legacy_plugins/RSS/load.rb

@@ -0,0 +1,38 @@
+## Load RSS from given URLs -- IKeJI
+## 
+## Load RSS from given URLs.
+## If URL is an Array, all URLs in the array will be loaded.
+##
+## - module: RSS::load
+##   config:
+##     uri: http://www.example.com/hoge.rdf
+
+require 'open-uri'
+require 'rss/1.0'
+require 'rss/2.0'
+require 'rss/maker'
+
+def load(config, data)
+  begin
+    rss_source = 
+      if config['url'].is_a?(Array)
+        config['url'].map {|url| open(url) {|io| io.read } }
+      else
+        [ open(config['url']) {|r| r.read } ]
+      end
+  rescue
+    puts "LoadError File = #{config["url"]}"
+    return []
+  end
+  
+  feeds = rss_source.collect {|cont|
+    begin
+      RSS::Parser.parse(cont)
+    rescue RSS::InvalidRSSError
+      RSS::Parser.parse(cont, false)
+    end
+  }
+  
+  feeds.select {|f| f}.inject([]) {|acc,f| acc + f.items }
+end
+

data/legacy_plugins/RSS/save.rb

@@ -0,0 +1,41 @@
+## Save RSS as a file -- IKeJI
+## 
+## Save RSS as a file.
+## Title, Link, and Description of the RSS can be set.
+## The input is expected to be an Array of RSS::RDF::Item.
+##
+## - module: RSS::save
+##   config:
+##     title: An Title
+##     link: http://www.example.com/hoge.rdf
+##     description: sample rdf
+
+require "rss/maker"
+
+@count = Time.now.to_i
+
+def save(config,data)
+  rss = RSS::Maker.make("1.0") do |maker|
+    maker.channel.about = config['about'] || config['link'] || "http://example.net/"
+    maker.channel.title = config['title'] || "Pragger output"
+    maker.channel.description = config['description'] || ""
+    maker.channel.link = config['link'] || "http://example.net/"
+    
+    data.each do |i|
+      if(i.instance_of?(RSS::RDF::Item))
+        i.setup_maker(maker)
+      else 
+        item = maker.items.new_item
+        item.title = i.title rescue i.to_s
+        item.link = i.link rescue (config['link'] || "http://example.net/") + "\##{@count}"
+        item.description = i.description rescue i.to_s
+        item.date = i.date rescue Time.now
+        @count += 1
+      end
+    end
+  end
+  open(config["filename"],"w"){|w| w.puts rss }
+  return data
+end
+
+

data/legacy_plugins/Yaml/load.rb

@@ -0,0 +1,5 @@
+def load(config,data)
+  require "yaml"
+  return YAML.load_file(config["filename"]) || []
+end
+

data/legacy_plugins/Yaml/save.rb

@@ -0,0 +1,9 @@
+require "yaml"
+
+def save(config,data)
+  File.open(config["filename"],"w") do |w|
+    YAML.dump(data,w)
+  end
+  return data
+end
+

data/legacy_plugins/argv.rb

@@ -0,0 +1,5 @@
+## read data form argv -- takatoh
+
+def argv(config,data)
+  return ARGV.clone
+end

data/legacy_plugins/concat.rb

@@ -0,0 +1,18 @@
+## concat two data -- IKeJI
+##
+## concat two data plugin.
+## this plugin is concat two data.
+##
+## - module: concat
+##   config:
+##     - module: foo
+##     - module: bar
+##     - module: baz
+##
+
+
+def concat(config,data)
+  data2 = eval_pragger(config,[])
+  return data+data2
+end
+

data/legacy_plugins/const_list.rb

@@ -0,0 +1,15 @@
+## constant list -- IKeJI
+##
+## constant list plugin.
+##
+## - module: const_list
+##   config:
+##     - a
+##     - b
+##     - c
+##
+
+def const_list(config,data)
+  return config
+end
+

data/legacy_plugins/first.rb

@@ -0,0 +1,11 @@
+## first data plugin -- IKeJI
+##
+## this plugin returns only first data
+##
+## -moduel: first
+##
+
+def first(config,data)
+  return [data.first]
+end
+

data/legacy_plugins/head.rb

@@ -0,0 +1,14 @@
+## head plugin -- IKeJI
+##
+## it looks like linux head command.
+## this example is like 'head -n 10'
+##
+## -module: head
+##  config:
+##    n: 10
+##
+
+def head(config,data)
+  return data[0, config['n'].to_i]
+end
+

data/legacy_plugins/load_path.rb

@@ -0,0 +1,21 @@
+## Add path to $LOAD_PATH -- gtaka555
+##
+## Add path to $LOAD_PATH plugin.
+##
+## - module: load_path
+##   config:
+##     path:
+##       - /home/foo/ruby/lib/1
+##       - /home/foo/ruby/lib/2
+##       - /home/foo/ruby/lib/3
+##
+
+def load_path(config, data)
+  return data  unless config.key?('path')
+
+  config['path'].each {|path|
+    $LOAD_PATH << path
+  }
+
+  data
+end

data/legacy_plugins/plagger.rb

@@ -0,0 +1,94 @@
+## Interleave Plagger processing -- Soutaro Matsumoto
+##
+## Invokes Plagger and process the input with your Plagger.
+## The input must be an Array of RSS::RDF::Item.
+## The output is an Array of RSS::RDF::Item.
+## If "debug" is a value evaluated to true, tempolary files for/from Plagger won't be deleted.
+## If "input" is not "feed", the input will be ignored.
+## If you omit "dir", the default is /var.
+## Make sure your system have /var directory and pragger/Plagger can write.
+##
+## - module: plagger
+##   config:
+##     input: feed
+##     debug: false
+##     dir: /var
+##     plugins: 
+##       - module: Publish::CSV
+##         config: 
+##           dir: /var
+##           filename: a.csv
+
+require 'rbconfig'
+require 'open-uri'
+require 'rss/1.0'
+require 'rss/2.0'
+require 'pathname'
+
+raise LoadError unless ENV['PATH'].split(Config::CONFIG['PATH_SEPARATOR']).find {|dir|
+  File.executable?(File.join(dir, 'plagger')) || File.executable?(File.join(dir, 'plagger.bat'))
+}
+
+def plagger(config, data)
+  pla_con = config["plugins"]
+  
+  if input_option(config) == :feed
+    pla_con = [{"module" => "Subscription::Feed", "config"=>{ "url" => "file:#{pla_input(config)}" }}] + pla_con
+    eval_pragger([{"module" => "save_rss", "config" => { "filename" => pla_input(config).to_s }}], data)
+  end
+  
+  pla_con.push({"module" => "Publish::Feed",
+                 "config" =>
+                 {"dir" => "/var",
+                   "format" => "RSS",
+                   "filename" => pla_output(config).basename.to_s}})
+  
+  pla_config(config).open("w") {|io| io.write to_plagger_yaml(YAML.dump({ "plugins" => pla_con })) }
+  
+  system "plagger -c #{pla_config(config)}"
+  
+  begin
+    RSS::Parser.parse(pla_output(config).read).items
+  rescue
+    []
+  ensure
+    unless config.has_key?("debug")
+      pla_config(config).delete
+      pla_input(config).delete
+      pla_output(config).delete
+    end
+  end
+end
+
+def pla_dir(config)
+  Pathname.new(config.has_key?("dir") ? config["dir"] : "/var")
+end
+
+def pla_config(config)
+  pla_dir(config) + "pla.yaml"
+end
+
+def pla_output(config)
+  pla_dir(config) + "pla_output"
+end
+
+def pla_input(config)
+  pla_dir(config) + "pla_input"
+end
+
+def input_option(config)
+  opt = config.has_key?("input") ? config["input"] : "nothing"
+  case opt
+  when "feed": :feed
+  when "nothing": :nothing
+  else
+    :nothing
+  end
+end
+
+def to_plagger_yaml(yaml)
+  a = yaml.split(/\n/)
+  ret = a[1]+"\n"
+  ret + a[2..(a.size-1)].collect {|x| "  "+x }.join("\n")+"\n"
+end
+

data/legacy_plugins/plugin_from_uri.rb

@@ -0,0 +1,31 @@
+## Load plugin from uri and evaluate it -- Soutaro Matsumoto
+##
+## Load plugiin from uri and evaluate it.
+## If you omit "name", the last component of the uri will be used as the name of plugin.
+##
+## - module: plugin_from_uri
+##   config:
+##     uri: http://some_host/some_path
+##     name: super_plugin
+##     config:
+##       ** configuration for the plugin **
+
+require 'open-uri'
+require 'uri'
+
+def plugin_from_uri(config, data)
+  uri = URI(config["uri"])
+  name = config["name"] || uri.path.split("/").last.gsub(/\..*$/,'')
+  
+  body = open(uri.to_s) {|io| io.read}
+  
+  plugin = Class.new(Plugin)
+  plugin.class_eval {
+    def initialize()
+    end
+  }
+  plugin.class_eval(body, uri.to_s, 1)
+  
+  plugin.new().send(name, config["config"], data)
+end
+

data/legacy_plugins/pluginbase.rb

@@ -0,0 +1,4 @@
+def pluginbase(config,data)
+  return []
+end
+

data/legacy_plugins/print.rb

@@ -0,0 +1,15 @@
+## pritty print plugin -- IKeJI
+##
+## it for debug
+## print data using pritty print
+##
+## -module: print
+##
+
+require "pp"
+
+def print(config,data)
+  pp data
+  return data
+end
+

data/legacy_plugins/reverse.rb

@@ -0,0 +1,10 @@
+## reverse plugin -- IKeJI
+##
+## it reverse data array
+##
+## -module: reverse
+##
+
+def reverse(config, data)
+  data.reverse
+end

data/legacy_plugins/send_msg.rb

@@ -0,0 +1,18 @@
+## Send Message Plugin -- Soutaro Matsumoto
+##
+## it invoke ruby method
+##
+## -module: send_msg
+##  config:
+##    method: to_s
+##    params: 16
+##
+
+def send_msg(config, data)
+  method = config['method'] || nil
+  params = config['params'] || []
+  
+  data.collect {|x|
+    method ? x.send(method, *params) : x
+  }
+end

data/legacy_plugins/stdin.rb

@@ -0,0 +1,6 @@
+## Read data from stdin -- Soutaro Matsumoto
+
+def stdin(config, data)
+  stdin_data = readlines
+  (config || { "input" => "concat" })["input"] == "nothing" ? stdin_data : data + stdin_data
+end

data/legacy_plugins/stdout.rb

@@ -0,0 +1,6 @@
+## Write data to stdout -- Soutaro Matsumoto
+
+def stdout(config, data)
+  data.each {|x| puts x }
+  data
+end