Graphiclious 0.1.0

data/lib/graphiclious/utf8.rb

@@ -0,0 +1,19 @@
+#!/usr/bin/env ruby
+#$Id: utf8.rb,v 1.2 2005/05/05 13:37:59 wsdng Exp $
+
+module Graphiclious
+  def self.utf8_as_string(aString)
+    return aString.unpack("U*").pack("C*")
+  end
+
+  def self.string_as_utf8(aString)
+    aString.unpack("C*").pack("U*")
+  end
+
+  # Convert link as provided by del.icio.us via rubilicious
+  # to link containing utf8 strings for description and extended
+  # information
+  def self.link_with_utf8_strings(link)
+    link
+  end
+end

data/lib/graphiclious/version.rb

@@ -0,0 +1,8 @@
+#!/usr/bin/ruby
+#$Id: version.rb,v 1.1 2005/04/03 14:45:26 wsdng Exp $
+
+module Graphiclious
+  def self.version
+    '0.1.0'
+  end
+end

data/lib/graphiclious/yaml-links2html.rb

@@ -0,0 +1,476 @@
+#!/usr/bin/env ruby
+#$Id: yaml-links2html.rb,v 1.20 2006/03/09 22:57:52 wsdng Exp $
+
+require 'yaml'
+require 'ftools'
+require 'graphiclious/environment'
+require 'graphiclious/url_graph'
+
+class YamlLinksToHtml
+  DEL_ICIO_US_URL = "http://del.icio.us"
+  STYLES_FOLDER = File.join(GRAPHICLIOUS_PATH, "styles")
+  MAX_STYLES_IN_CLOUD = 10
+  CLOUD_STYLES = (1..MAX_STYLES_IN_CLOUD).collect{ |size| 'cloud-' + size.to_s }
+  
+  attr_accessor(:link_to_delicious_if_possible, :use_bundles, :include_graph_views, :build_graph_thumbs, :include_private) 
+  
+  # Lazy require things which some users won't use
+  def check_prerequisites
+    require 'RMagick' if @build_graph_thumbs
+  end
+  
+  def self.guess_styles
+    guess_styles_within(STYLES_FOLDER)
+  end
+  
+  def self.guess_styles_within(folder)
+    Dir[File.join(folder, '*', 'dot-attributes.yaml')].collect {
+      |filename|
+      File.dirname(filename)
+    }
+  end
+  
+  def self.guess_users_within(folder)
+    Dir[File.join(folder, '*', 'delicious.yaml')].collect {
+      |filename|
+      File.dirname(filename)
+    }
+  end
+  
+  def set_working_dir(new_working_dir)
+    @working_dir = new_working_dir
+    set_user(@user)
+  end
+  
+  def set_user(user)
+    @user = user
+    @input_file = File.join(@working_dir, @user, 'delicious.yaml')
+    @html_output_path = File.join(@working_dir, @user, 'html')
+    @bundles_file = File.join(@working_dir, @user, 'bundles.yaml')
+  end
+  
+  def set_style style
+    @style = style
+    @dot_attribut_file = "#{@style}/dot-attributes.yaml"
+  end
+  
+  def initialize
+    @include_private = false
+    @working_dir = Dir.getwd
+    set_style(YamlLinksToHtml.guess_styles[0])
+    set_user(YamlLinksToHtml.guess_users_within(@working_dir)[0])
+    @link_to_delicious_if_possible = false
+    @use_bundles = false
+    @include_graph_views = false
+    @build_graph_thumbs = @include_graph_views
+  end
+  
+  def copy_style_to_user
+    ['dot-attributes.yaml', '*.jpg', '*.png', '*.gif', '*.css'].each do
+      |pattern|
+      Dir[File.join(@style, pattern)].each do
+        |template_file|
+        write_line_on_protokol("Copy #{template_file} to #{@user}")
+        File.copy(template_file, File.join(@working_dir, @user)) 
+      end
+    end
+  end
+  
+  def set_protocol_block(aProc)
+    @protocol_block = aProc
+  end
+  
+  def write_line_on_protokol(lineString)
+    puts lineString
+    unless @protocol_block.nil?
+      @protocol_block.call(lineString)
+    end
+  end
+  
+  # methods for html-generation
+  
+  def os_file_join(dir, file)
+    if RUBY_PLATFORM =~ /win32/
+      File.join(dir, file).gsub(File::SEPARATOR, "\\")
+    else
+      File.join(dir, file)
+    end
+  end
+  
+  def downscale(val)
+   (2 * Math.log(val)).round
+  end
+  
+  def get_cloud_style(val, maxval)
+    quot = downscale(maxval) 
+    quot = 1 if quot == 0
+    index = (MAX_STYLES_IN_CLOUD - 1) * downscale(val) / quot
+    if(index >= MAX_STYLES_IN_CLOUD)
+      puts "Corrected index of cloud style for #{val} from #{index} to #{MAX_STYLES_IN_CLOUD}"
+      index = MAX_STYLES_IN_CLOUD      
+    end
+    CLOUD_STYLES[index]
+  end
+  
+  def delicious_tag_url(tag1, *other_tags)
+    url = "#{DEL_ICIO_US_URL}/tag/#{tag1}"
+    other_tags.each { |tag| url = "#{url}+#{tag}" }
+    url + '?settagview=cloud'
+  end
+  
+  def delicious_user_url(tag1, *other_tags)
+    url = "#{DEL_ICIO_US_URL}/#{@user}/#{tag1}"
+    other_tags.each { |tag| url = "#{url}+#{tag}" }
+    url + '?settagview=cloud'
+  end
+  
+  def write_html_head_on(fp)
+    fp.puts '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">'
+    fp.puts '<html><head>'
+    fp.puts '<meta http-equiv="content-type" content="text/html; charset=UTF-8">'
+    fp.puts '<link rel="stylesheet" type="text/css" href="../style.css">'
+    fp.puts '</head><body>'
+  end
+  
+  def write_html_tail_on(fp)
+    fp.puts '</body></html>'
+  end
+  
+  def menuitem(name, id, url)
+    if(name == id)
+      "<div class=\"menuselected\">#{name}</div>"
+    else
+      "<div class=\"menuitem\"><a href=\"#{url}\">#{name}</a></div>"
+    end
+  end
+  
+  def link_index_on(fp, id='none', bundles={})
+    fp.puts '<div class="mainmenu">'|| @checkBundles.checked?
+    fp.puts menuitem('cloud (all)', id, 'index.htm')
+    unless bundles.empty?
+      bundles.keys.sort.each do
+        |bundle|
+        unless bundle == 'unbundled'
+          fp.puts menuitem(bundle, id, "bundle_#{bundle}.htm")
+        end
+      end
+      unless bundles['unbundled'].empty?
+        fp.puts menuitem('unbundled', id, "bundle_unbundled.htm") 
+      end
+    end
+    fp.puts '</div>'
+  end
+  
+  def write_overview(filename, cloud_name, list, bundles, links_by_tag)
+    valid_list = list.reject { |tag|
+      links_by_tag[tag].nil? # doesn't make sense but seems to be possible
+    }
+    File.open(File.join(@html_output_path, filename), 'w') do
+      | fp |
+      write_html_head_on(fp)
+      fp.puts "<h1>Tag overview: #{cloud_name}</h1>"
+      link_index_on(fp, cloud_name, bundles)
+      fp.puts '<div class="main">'
+      fp.puts "<h3>Tags, size representing number of links</h3>"
+      max_num_links = valid_list.collect{ |tag| links_by_tag[tag].size }.max
+      valid_list.each do
+        |tag|
+        style = get_cloud_style(links_by_tag[tag].size, max_num_links)
+        fp.puts(UrlGraph.node_ankor(tag, style))
+      end
+      if(@include_graph_views)
+        name = cloud_name_to_graph_name(cloud_name)
+        fp.puts "<h3>Graph of tag relations</h3>"
+        
+        link_desc = if(@build_graph_thumbs)
+          "<img src=\"#{convert_to_thumbnail_filename(name + '.gif')}\">"
+        else
+          'view it'
+        end 
+        fp.puts "<a href=\"#{name}.htm\">#{link_desc}</a>"
+        fp.puts '</div>'
+      end 
+    end
+  end
+  
+  def sorted_links(links)
+    links.sort { |l1, l2| l1['description'] <=> l2['description'] }
+  end
+  
+  def write_link_on(link, fp, skip_tags = [])
+    fp.puts(UrlGraph.ankor(link['href'], link['description']))
+    info = link['extended']
+    if info
+      fp.puts('<br>')
+      fp.puts("#{info}")
+    end
+    other_tags = link['tags'].reject { |t| skip_tags.include?(t) }
+    unless other_tags.empty?
+      fp.puts('<br>')
+      fp.puts('More tags: ')
+      other_tags.each { |t|
+        fp.puts(UrlGraph.node_ankor(t))
+      }
+    end
+  end
+  
+  # create an empty graph with dot attributes of chosen style
+  def init_tag_graph
+    @tag_graph = UrlGraph.new
+    if File.exists?(@dot_attribut_file)
+      @tag_graph.fixed_dot_attributes = File.open(@dot_attribut_file, 'r') { |io|
+        YAML.load(io)
+      }
+    else
+      # write out the default-attribute-file to make
+      # things easy to configure
+      File.open(@dot_attribut_file, 'w') { |out|
+        YAML.dump(@tag_graph.fixed_dot_attributes, out)
+      }
+      write_line_on_protokol "Wrote #{@dot_attribut_file}, change to adopt different style."
+    end
+  end
+  
+  def load_links
+    # load yaml-file containing links as a hash
+    cache = File.open(@input_file, 'r') { |io|
+      YAML.load(io)
+    }
+    links = cache.values
+    unless(@include_private)
+      links = links.reject { |l| l['shared'] =~ /no/ }
+    end
+    @links_by_tag = Hash.new
+    @links_by_edge = Hash.new
+    links.each do
+      |link|
+      tagsOfLink = link['tags']
+      n = tagsOfLink.size - 1
+       (0..n).each do
+        |i|
+        tag = tagsOfLink[i]
+        unless @links_by_tag.has_key?(tag)
+          @links_by_tag[tag] = Array.new
+          @tag_graph.add_vertex(tag)
+        end
+        @links_by_tag[tag].push(link)
+         (i+1..n).each do
+          |j|
+          otherTag = tagsOfLink[j]
+          # write_line_on_protokol "\t#{tag}<->#{otherTag}"
+          @tag_graph.add_edge(tag, otherTag)
+          edge_name = UrlGraph.edge_name(tag, otherTag)
+          unless @links_by_edge.has_key?(edge_name)
+            @links_by_edge[edge_name] = Array.new
+          end
+          @links_by_edge[edge_name].push(link)
+        end
+      end
+    end
+    
+    # load bundles file
+    @bundles = {}
+    if @use_bundles
+      @bundles = File.open(@bundles_file, 'r') { |io|
+        YAML.load(io)
+      }
+      set_of_unbundled_tags = {}
+      @tag_graph.each { |tag| set_of_unbundled_tags[tag] = tag }
+      @bundles.keys.each { |bundle|
+        @bundles[bundle].each { |tag|
+          set_of_unbundled_tags.delete(tag)
+        }
+      }
+      @bundles['unbundled'] = set_of_unbundled_tags.values.sort
+    end
+  end
+  
+  def fatal(msg)
+    write_line_on_protokol(msg)
+    exit(1)
+  end
+  
+  def thumbnail(filename)
+    thumb_name = convert_to_thumbnail_filename(filename)
+    write_line_on_protokol("Writing thumbnail #{thumb_name} for #{filename}")
+    img = Magick::Image.read(filename)[0]
+    thumb = img.thumbnail(100, 100)
+    thumb.write(thumb_name)
+  end
+  
+  # name.extension will result in name.thumb.extension
+  def convert_to_thumbnail_filename(filename)
+    parts = filename.split('.')
+    ext = parts.pop
+    parts[0..-1].push('thumb').push(ext).join('.')
+  end
+  
+  def do_graphviz(tag_graph, cloud_name)
+    return unless @include_graph_views
+    name = cloud_name_to_graph_name(cloud_name)
+    # Write Graphviz-File
+    tmpDotFile = 'graph.dot~'
+    tag_graph.print_dotted_on_file(tmpDotFile)
+    write_line_on_protokol "Wrote #{tmpDotFile} for temporary use, feel free to delete later."
+    
+    # Use Graphviz to create HTML with client-side imagemap
+    os_gif_file = os_file_join(@html_output_path, "#{name}.gif")
+    dot_command = "dot -Tgif #{tmpDotFile} -o #{os_gif_file}" 
+    system(dot_command) || fatal("Error can't execute #{dot_command}\nPlease check your graphviz installation")
+    write_line_on_protokol "Wrote #{os_gif_file}."
+    graph_htm = File.join(@html_output_path, "#{name}.htm")
+    os_graph_htm = os_file_join(@html_output_path, "#{name}.htm")
+    File.open(graph_htm, 'w') { |fp|
+      write_html_head_on(fp)
+      fp.puts("<h1>Tag graph: #{cloud_name} </h1>")
+      link_index_on(fp, '', @bundles)
+      fp.puts '<div class="main">'
+      fp.puts '<IMG SRC="' + "#{name}.gif" + '" USEMAP=#UrlGraph>'
+      fp.puts '</div>'
+    }
+    dot_command = "dot -Tcmapx #{tmpDotFile} -o graph.htm~"
+    system(dot_command) || fatal("Failed system call: #{dot_command}")
+    File.open(graph_htm, 'a') { |fp|
+      File.open('graph.htm~'){ |fp2| fp2.each_line { |line| fp.puts(line) }}
+      write_html_tail_on(fp)
+    }
+    write_line_on_protokol "Wrote #{os_graph_htm} (which uses #{os_gif_file})."
+    
+    return unless @build_graph_thumbs
+    gif_file = File.join(@html_output_path, "#{name}.gif")
+    thumbnail(gif_file)
+  end
+  
+  def cloud_name_to_graph_name(cloud)
+    UrlGraph.tag2file(cloud) + '__go'
+  end
+  
+  def write_all_overviews
+    # Create a file containing a cloud of all tags
+    list = @links_by_tag.keys.sort
+    filename = 'index.htm'
+    cloud_name = 'cloud (all)'
+    write_overview(filename, cloud_name, list, @bundles, @links_by_tag)
+    do_graphviz(@tag_graph, cloud_name)
+    
+    # The same for all bundles
+    @bundles.keys.each do 
+      | bundle |
+      list = @bundles[bundle]
+      filename = "bundle_#{bundle}.htm"
+      cloud_name = bundle
+      write_overview(filename, cloud_name, list, @bundles, @links_by_tag)
+      @tag_graph.filter_set = Set.new(list)
+      do_graphviz(@tag_graph, cloud_name)
+      @tag_graph.filter_set = nil
+    end
+  end
+  
+  # Create one Html-File for each tag
+  def write_single_tag_files
+    @links_by_tag.keys.sort.each do
+      |tag|
+      File.open(File.join(@html_output_path, UrlGraph.node_url(tag)), 'w') do
+        |fp|
+        write_html_head_on(fp)
+        fp.puts "<h1>Tag: #{tag}</h1>"
+        link_index_on(fp, 'none', @bundles)
+        fp.puts '<div class="main">'
+        fp.puts "<h3>Subcategories for tag #{tag}</h3>"
+        subcloud = @tag_graph.adjacent_vertices(tag).sort
+        max_num_links = subcloud.collect{ |n| @links_by_edge[UrlGraph.edge_name(tag, n)].size }.max
+        subcloud.each do
+          |neighbor|
+          edge_name = UrlGraph.edge_name(tag, neighbor)
+          edgePage = UrlGraph.edge_url(tag, neighbor)
+          style = get_cloud_style(@links_by_edge[edge_name].size, max_num_links)
+          fp.puts(UrlGraph.intern_ankor(UrlGraph.edge_url(tag, neighbor), neighbor, style))
+        end
+        list = @links_by_tag[tag].select { |l| l['tags'].size == 1 }
+        unless list.empty?
+          fp.puts("<h3>Links with the single tag #{tag}</h3>")
+          fp.puts('<ul>')
+          sorted_links(list).each do
+            |link|
+            fp.puts('<li>')
+            write_link_on(link, fp, [tag])
+            fp.puts('</li>')
+          end
+          fp.puts('</ul>')
+        end
+        if @link_to_delicious_if_possible
+          fp.puts("<h3>#{UrlGraph.ankor(DEL_ICIO_US_URL, 'del.icio.us')} links with tag #{tag}</h3>")
+          fp.puts(UrlGraph.ankor(delicious_user_url(tag), "#{@user}"))
+          fp.puts(UrlGraph.ankor(delicious_tag_url(tag), "all"))
+        end
+        fp.puts '</div>'
+        write_html_tail_on(fp)
+      end
+    end
+    write_line_on_protokol "Wrote one html-file for each tag to directory #{@html_output_path}."
+  end
+  
+  def write_double_tag_files
+    # Create one Html-File for each edge between two tags
+    @tag_graph.each_edge do
+      |tag1,tag2|
+      edge_name = UrlGraph.edge_name(tag1, tag2)
+      edge_url = UrlGraph.edge_url(tag1, tag2)
+      File.open(File.join(@html_output_path, edge_url), 'w') do
+        |fp|
+        write_html_head_on(fp)
+        fp.puts "<h1>Tags: #{tag1} AND #{tag2}</h1>"
+        link_index_on(fp, 'none', @bundles)
+        fp.puts '<div class="main">'
+        ankor1 = UrlGraph.node_ankor(tag1)
+        ankor2 = UrlGraph.node_ankor(tag2)
+        fp.puts "<h3>Links for tag combination #{ankor1}/#{ankor2}</h3>"
+        fp.puts '<ul>'
+        sorted_links(@links_by_edge[edge_name]).each do
+          |link|
+          fp.puts('<li>')
+          write_link_on(link, fp, [tag1, tag2])
+          fp.puts('<br></li>')
+        end
+        fp.puts '</ul>'
+        if @link_to_delicious_if_possible
+          fp.puts("<h3>#{UrlGraph.ankor(DEL_ICIO_US_URL, 'del.icio.us')} links with tag combination #{ankor1}/#{ankor2}</h3>")
+          fp.puts(UrlGraph.ankor(delicious_user_url(tag1, tag2), @user))
+          fp.puts(UrlGraph.ankor(delicious_tag_url(tag1, tag2), 'all'))
+        end
+        fp.puts '</div>'
+        write_html_tail_on(fp)
+      end
+    end
+    write_line_on_protokol "Wrote one html-file for each combination of two tags to directory #{@html_output_path}."
+  end
+  
+  # make all run-variables garbage collectable
+  def reset_build_state
+    @tag_graph = nil
+    @links_by_tag = nil
+    @links_by_edge = nil
+    @bundles = nil
+  end
+  
+  # run the complete batch
+  def run
+    unless File.exists?(@input_file)
+      raise "Missing input file #{@input_file}"
+    end
+    check_prerequisites
+    Dir.mkdir(@html_output_path) unless File.directory?(@html_output_path)
+    copy_style_to_user unless @user == @style
+    init_tag_graph
+    load_links
+    write_all_overviews
+    write_single_tag_files    
+    write_double_tag_files  
+    reset_build_state
+    write_line_on_protokol "Finished."
+  end
+end
+
+if $0 == __FILE__
+  YamlLinksToHtml.new.run
+end