[Logilogi-svn] SF.net SVN: logilogi:[1623] tools/t-llre/t-llre

Revision: 1623
          http://logilogi.svn.sourceforge.net/logilogi/?rev=1623&view=rev
Author:   wybow
Date:     2009-10-23 22:41:05 +0000 (Fri, 23 Oct 2009)

Log Message:
-----------
Added support for read-paths

Modified Paths:
--------------
    tools/t-llre/t-llre

Modified: tools/t-llre/t-llre
===================================================================
--- tools/t-llre/t-llre	2009-10-23 22:36:19 UTC (rev 1622)
+++ tools/t-llre/t-llre	2009-10-23 22:41:05 UTC (rev 1623)
@@ -75,6 +75,7 @@
   VERSION = '0.5.0'
 
   SPLITTER = "%ll:/"
+  PATH = "%ll:path"
   CONFIG_FILE = File.expand_path('~/.ll_remote')
 
   attr_accessor :errors, :options
@@ -166,53 +167,112 @@
       contents = f.read
     end
 
-    parsed_logis, part_lines = self.parse_contents(contents)
+    parts_lines = unzip_contents(contents, SPLITTER)
+    parsed_logis = parse_logis(parts_lines)
 
     check_errors("Not saved any logi")
 
     puts "# Parsed all logis successfully" if @options.verbose
     puts "### Processing" if @options.verbose
 
-    part_lines = self.process_logis(parsed_logis, part_lines)
+    parsed_logis, parts_lines = self.process_logis(parsed_logis, parts_lines)
 
+    contents = zip_parts_lines(parts_lines)
     puts "# Processed all logis successfully" if @options.verbose
+    puts "# Processing paths" if @options.verbose
+    parts_lines = unzip_contents(contents, PATH)
 
-    update_file(@options.filename, part_lines)
+    parsed_path = self.parse_path(parsed_logis, parts_lines)
+
+    parts_lines = self.process_paths(parsed_path, parts_lines)
+
+    puts "# Processed paths successfully" if @options.verbose
+
+    update_file(@options.filename, zip_parts_lines(parts_lines))
   end
 
-  def parse_contents(contents)
-    parts = contents.split(/^#{SPLITTER}/)
-
+  def parse_logis(parts_lines)
     parsed_logis = []
-    part_lines = [parts[0].split("\n")]
-    parts[1..-1].each do |part|
-      part_lines << part.split("\n")
-      link, title, body = parse_part(part.dup)
+    parts_lines[1..-1].each do |part_lines|
+      link, title, body, level = parse_part(part_lines.join("\n"))
       parsed_logis << {:link => link,
           :title => replace_latex(title, link),
-          :body => replace_latex(body, link)}
+          :body => replace_latex(body, link),
+          :level => level}
     end
-    return parsed_logis, part_lines
+    return parsed_logis
   end
 
-  def process_logis(parsed_logis, part_lines)
+  def parse_path(parsed_logis, parts_lines)
+    parsed_path = {}
+    if parts_lines.size > 1 # A PATH was in there
+      parsed_path[:id] = parse_path_id(parts_lines[1][0])
+      parsed_path[:enabled] = true
+      parsed_path[:step_hashes] = []
+      i = 0
+      parsed_logis.each do |logi_hash|
+        parsed_path[:step_hashes] << {
+            :logi_link => logi_hash[:logi_link],
+            :title => logi_hash[:title],
+            :level => logi_hash[:level],
+            :position => i}
+        i += 1
+      end
+    end
+    return parsed_path
+  end
+
+  def process_logis(parsed_logis, parts_lines)
     LLRemote.setup(:access_token => @options.api_token, :server_url => @options.server_url)
 
     parsed_logis.each_with_index do |parsed, index|
       l = LLRemote::Logi.new(parsed)
       l.save
-      part_lines[index + 1][0] = SPLITTER + l.link
-      puts '# Processed: ' + l.link if @options.verbose
+      parsed[:logi_link] = l.link
+      parts_lines[index + 1][0] = SPLITTER + parsed[:logi_link]
+      puts '# Processed: ' + parsed[:logi_link] if @options.verbose
     end
-    return part_lines
+    return parsed_logis, parts_lines
   end
 
-  def update_file(filename, part_lines)
-    if part_lines[0].join.empty? 
+  def process_paths(parsed_path, parts_lines)
+    if parsed_path[:enabled]
+      LLRemote.setup(:access_token => @options.api_token, :server_url => @options.server_url)
+      if parsed_path[:id]
+        old_path = LLRemote::Path.find(parsed_path[:id])
+        old_path.destroy
+      end
+      path = LLRemote::Path.new
+      path.save
+      parsed_path[:step_hashes].each do |step_hash|
+        step = LLRemote::Step.new(:path => path, :logi_link => step_hash[:logi_link],
+            :level => step_hash[:level], :position => step_hash[:position])
+        step.save
+      end
+      parts_lines[1][0] = PATH + '_' + path.id.to_s
+    end
+    return parts_lines
+  end
+
+  def unzip_contents(contents, splitter)
+    parts = contents.split(/^#{splitter}/)
+
+    parts_lines = [parts[0].split("\n")]
+    parts[1..-1].each do |part|
+      parts_lines << part.split("\n")
+    end
+    return parts_lines
+  end
+
+  def zip_parts_lines(parts_lines)
+    if parts_lines[0].join.empty? 
       # for cases with nothing before the ll
-      part_lines.shift
+      parts_lines.shift
     end
-    contents = part_lines.collect {|t| t.join("\n")}.join("\n\n").chomp
+    return parts_lines.collect {|t| t.join("\n")}.join("\n\n").chomp
+  end
+
+  def update_file(filename, contents)
     File.open(filename, 'w') do |f| 
       f.write(contents)
     end
@@ -224,7 +284,8 @@
 
     title = replace_latex(parse_title(part),link)
     body = replace_latex(raw_body,link)
-    return link, title, body
+    level = parse_level(part)
+    return link, title, body, level
   end
 
   def parse_title(part)
@@ -233,12 +294,26 @@
     return match[1]
   end
 
+  def parse_level(part)
+    part =~ /^\\(\w*)section.*/
+    match = $~
+    return match[1].scan('sub').size + 1
+  end
+
   def parse_link(raw_link)
     link = raw_link.split("\n")[0]
     link.strip!
     return link
   end
 
+  def parse_path_id(path_line)
+    path_line =~ /^_(.*)/
+    match = $~
+    if match
+      return match[1].to_i
+    end
+  end
+
   def replace_latex(text, link)
     text.gsub!(/^%.*\n/, "")
     text.gsub!("\\_", "_")


This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.