rhaiker 0.0.1

data/lib/rhaiker/utils.rb

@@ -0,0 +1,113 @@
+#!ruby -Ku
+require 'uri'
+require 'net/http'
+require 'rexml/document'
+require 'time'
+
+class Rhaiker
+
+=begin rdoc
+Utility Module for Rhaiker. 
+This module include URI, Net::HTTP, REXML::Document, and Time.
+=end
+  module Utils
+
+=begin rdoc
+Description::
+  create Net::HTTPRequest instance.
+
+Params::
+  type (:post|:get),
+  uri URI-Instance,
+  use_basic_auth (booleans)
+
+Return::
+  Net::HTTPRequest-Instance
+
+RelatedMethods::
+  create_uri,
+  http_access
+=end
+    def create_request(type, uri, use_basic_auth = false)
+      case type
+        when :get
+          request = Net::HTTP::Get.new(uri.request_uri)
+        when :post
+          request = Net::HTTP::Post.new(uri.request_uri)
+      end
+      request['User-Agent'] = @user_agent
+      request.basic_auth @user_id, @api_key if use_basic_auth
+      return request
+    end
+
+=begin rdoc
+Description::
+  create URI instance.
+
+Params::
+  url_string
+
+Return::
+  URI-Instance
+
+RelatedMethods::
+  parse_options,
+  create_request,
+  http_access
+=end
+    def create_uri(url_string)
+      return URI.parse(URI.escape(url_string))
+    end
+
+=begin rdoc
+Description::
+  access to Hatena::Haiku::API[http://h.hatena.ne.jp/api]
+
+Params::
+  uri (URI-Instance),
+  request (Net::HTTPRequest-Instance)
+
+Return::
+  REXML::Document-Instance or false
+
+RelatedMethods::
+  create_uri,
+  create_request
+=end
+    def http_access(uri, request)
+      Net::HTTP.start(uri.host, uri.port){|http|
+        response = http.request(request)
+        if response.code == '200'
+          return REXML::Document.new(response.body)
+        else
+          return false
+        end
+      }
+    end
+
+=begin rdoc
+Description::
+  parse option parametors
+
+Params::
+  options ({:param_name => value, [...]})
+
+Return::
+  parsed-options ('?param_name=value&...')
+
+RelatedMethods::
+  create_uri
+=end
+    def parse_options(options)
+      result = ''
+      if options[:since]
+        options[:since] = Time.parse(options[:since].to_s).httpdate
+      end
+      options = options.find_all{|option|option.last}
+      result = '?' + options.collect{|option|
+        option.join('=')
+      }.join('&') unless options.empty?
+      return result
+    end
+  end
+end

data/lib/rhaiker/version.rb

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

data/lib/rhaiker/xml_parser.rb

@@ -0,0 +1,211 @@
+#!ruby -Ku
+require 'rexml/document'
+require 'date'
+require 'uri'
+
+class Rhaiker
+
+=begin rdoc
+XML Parser Module for 
+Hatena::Haiku::API[http://h.hatena.ne.jp/api] Response.
+=end
+  module XML_Parser
+
+=begin rdoc
+Description::
+  XML-Document-Parse for timeline
+
+Params::
+  document (REXML::Document-Instance)
+
+Return::
+  [{:id => 12345, ...}, ...]
+
+RelatedMethods::
+  parse_status
+=end
+    def parse_timeline(document)
+      document.elements.collect('//statuses/status'){|status|
+        parse_status(status)
+      }
+    end
+
+=begin rdoc
+Description::
+  XML-Element-Parse for status
+
+Params::
+  status (REXML::Element-Instance)
+
+Return::
+  {:id => 12345, ...}
+
+RelatedMethods::
+  parse_timeline,
+  parse_user,
+  parse_reply
+=end
+    def parse_status(status)
+      result = {
+        :id =>
+          status.elements['id'].text.to_i,
+        :text =>
+          status.elements['text'].text,
+        :link =>
+          URI.parse(status.elements['link'].text),
+        :created_at =>
+          DateTime.parse(status.elements['created_at'].text),
+        :favorited =>
+          status.elements['favorited'].text.to_i,
+        :source =>
+          status.elements['source'].text,
+        :user =>
+          parse_user(status.elements['user'])
+      }
+      in_reply_to = {
+        :in_reply_to => {
+          :status_id =>
+            status.elements['in_reply_to_status_id'].text.to_i,
+          :user_id =>
+            status.elements['in_reply_to_user_id'].text
+        }
+      } if status.elements['in_reply_to_status_id'].has_text?
+      result.merge!(in_reply_to) if in_reply_to
+      replies = status.elements.collect('replies'){|reply|
+        parse_reply(reply)
+      }
+      result.merge!({:replies => replies}) unless replies.empty?
+      return result
+    end
+
+=begin rdoc
+Description::
+  XML-Element-Parse for reply
+
+Params::
+  reply (REXML::Element-Instance)
+
+Return::
+  {:id => 12345, ...}
+
+RelatedMethods::
+  parse_status,
+  parse_user
+=end
+    def parse_reply(reply)
+      {
+        :id =>
+          reply.elements['id'].text.to_i,
+        :created_at =>
+          DateTime.parse(reply.elements['created_at'].text),
+        :favorited =>
+          reply.elements['favorited'].text.to_i,
+        :source =>
+          reply.elements['source'].text,
+        :text =>
+          reply.elements['text'].text,
+        :user =>
+          parse_user(reply.elements['user'])
+      }
+    end
+
+=begin rdoc
+Description::
+  XML-Document-Parse for users
+
+Params::
+  users (REXML::Document-Insetance)
+
+Return::
+  [{:id => 'hoge', ...}, ...]
+
+RelatedMethods::
+  parse_user
+=end
+    def parse_users(document)
+      document.elements.collect('//users/user'){|user|
+        parse_user(user)
+      }
+    end
+
+=begin rdoc
+Description::
+  XML-Element-Parse for user
+
+Params::
+  user (REXML::Element-Instance)
+
+Return::
+  {:id => 'hoge', ...}
+
+RelatedMethods::
+  parse_users,
+  parse_status,
+  parse_reply
+=end
+    def parse_user(user)
+      {
+        :id =>
+          user.elements['id'].text,
+        :name =>
+          user.elements['name'].text,
+        :screen_name =>
+          user.elements['screen_name'].text,
+        :followers_count =>
+          user.elements['followers_count'].text.to_i,
+        :url =>
+          URI.parse(user.elements['url'].text),
+        :profile_image_url =>
+          URI.parse(user.elements['profile_image_url'].text)
+      }
+    end
+
+=begin rdoc
+Description::
+  XML-Document-Parse for keywords
+
+Params::
+  document (REXML::Document-Instance)
+
+Return::
+  [{:title => 'hoge', ...}, ...]
+
+RelatedMethods::
+  parse_keyword
+=end
+    def parse_keywords(document)
+      document.elements.collect('//keywords/keyword'){|keyword|
+        parse_keyword(keyword)
+      }
+    end
+
+=begin rdoc
+Description::
+  XML-Element-Parse for keyword
+
+Params::
+  keyword (REXML::Element-Instance)
+
+Return::
+  timeline ({:title => 'hoge', ...})
+
+RelatedMethods::
+  parse_keywords
+=end
+    def parse_keyword(keyword)
+      {
+        :title =>
+          keyword.elements['title'].text,
+        :entry_count =>
+          keyword.elements['entry_count'].text.to_i,
+        :followers_count =>
+          keyword.elements['followers_count'].text.to_i,
+        :link =>
+          URI.parse(keyword.elements['link'].text),
+        :related_keywords =>
+          keyword.elements.to_a('related_keywords')
+      }
+    end
+  end
+end
+

data/script/console

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+# File: script/console
+irb = RUBY_PLATFORM =~ /(:?mswin|mingw)/ ? 'irb.bat' : 'irb'
+
+libs =  " -r irb/completion"
+# Perhaps use a console_lib to store any extra methods I may want available in the cosole
+# libs << " -r #{File.dirname(__FILE__) + '/../lib/console_lib/console_logger.rb'}"
+libs <<  " -r #{File.dirname(__FILE__) + '/../lib/rhaiker.rb'}"
+puts "Loading rhaiker gem"
+exec "#{irb} #{libs} --simple-prompt"

data/script/destroy

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.expand_path(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.expand_path(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,82 @@
+#!/usr/bin/env ruby
+
+GEM_NAME = 'rhaiker' # what ppl will type to install your gem
+RUBYFORGE_PROJECT = 'rhaiker'
+
+require 'rubygems'
+begin
+  require 'newgem'
+  require 'rubyforge'
+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/#{GEM_NAME}/version.rb"
+
+version  = Rhaiker::VERSION::STRING
+download = "http://rubyforge.org/projects/#{RUBYFORGE_PROJECT}"
+
+def rubyforge_project_id
+  RubyForge.new.autoconfig["group_ids"][RUBYFORGE_PROJECT]
+end
+
+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.html.erb')
+else
+  puts("Usage: #{File.split($0).last} source.txt [template.html.erb] > 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_template = fsrc.read
+  body_text = ERB.new(body_text_template).result(binding)
+  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)