picolena 0.0.99

data/app_generators/picolena/templates/lib/ff.rb

@@ -0,0 +1,117 @@
+#!/usr/bin/env ruby
+#
+# ff - Search and index document files using Ferret
+#
+# Author:  Stuart Rackham <srackham@methods.co.nz>
+# License: This source code is released under the MIT license.
+# Home page: http://www.methods.co.nz/ff/
+#
+# Requisites:
+# - Ferret 0.10.4 or better installed as a Ruby Gem.
+#   See http://ferret.davebalmain.com/trac for Ferret installation.
+# - External text file filters documented in lib/filters/*.rb.
+
+#TODO: Not Rubyish at all. Refactor all this!
+
+Analyzer=Ferret::Analysis::StandardAnalyzer.new
+
+# Add file +filename+ to the +index+.
+def index_file(index, filename, mime_type=nil)
+  complete_path=File.expand_path(filename)
+  fields = {
+    :complete_path=> complete_path,
+    :md5 => Digest::MD5.hexdigest(complete_path),
+    :file => File.basename(filename),
+    :basename => File.basename(filename, File.extname(filename)).gsub(/_/,' '),
+    :filetype => File.extname(filename),
+    :date => File.mtime(filename).strftime("%Y%m%d")
+  }
+  
+  if mime_type then
+    text = PlainText.extract_content_from(filename)
+    raise "empty document #{filename}" if text.strip.empty?
+    fields[:content] = text
+  end
+  
+  index << fields
+end
+
+def index_file_and_increment_counter(index,filename,mime_type,counters)
+  counters[mime_type] ||= Struct::Counter.new(0,0,0,0)
+  counters[mime_type].count += 1
+  counters[mime_type].size += File.size(filename)
+  start=Time.now
+  index_file(index, filename,mime_type)
+  counters[mime_type].time_needed += Time.now-start
+end
+
+# Recursively add all qualifying files in directory +dir+ to +index+.
+def index_directory(index, dir, counters)
+  #Index just everything!
+  Dir.glob(File.join(dir,"**/*")) do |filename|
+    # Skip Thumbs.db files
+    if File.file?(filename) and not filename =~ /(Thumbs\.db)/
+      begin
+        IndexLogger.debug "indexing: #{filename}"
+        
+        # Trying to guess MIME type from file contents is not reliable for text
+        # files.  The strategy used here is to infer from file name extension
+        # and rely on the convertor routine to fail if type is incorrect.
+        mime_type = File.mime(filename)
+        index_file_and_increment_counter(index,filename,mime_type,counters)
+      rescue => e
+        # if mime is unknown, just index filename, basename and extension
+        IndexLogger.debug "indexing without content: #{e.message}"
+        index_file(index, filename)
+        counters[mime_type||'Unknown mime type'].without_content += 1
+      end
+    end
+  end
+end
+
+def create_index(dirs)
+  FileUtils.mkpath File.dirname(IndexSavePath)
+  index = Ferret::Index::IndexWriter.new(:create => true, :path => IndexSavePath, :analyzer => Analyzer)
+  
+  add_fields(index)
+  
+  Struct.new('Counter', :size, :count, :without_content, :time_needed) unless Struct.constants.include?("Counter")
+  counters = {}
+  begin
+    dirs.each { |dir| index_directory(index, dir, counters) }
+    index.optimize
+  ensure
+    index.close
+  end
+  counters.each_pair do |key,value|
+    IndexLogger.info "\n#{key}:"
+    IndexLogger.info "files indexed: #{value.count} (#{value.size} bytes)"
+    IndexLogger.info("files without_content: #{value.without_content}") unless value.without_content.zero?
+    unless value.count.zero? or value.without_content==value.count then
+      IndexLogger.info "time needed: #{(value.time_needed*1000).to_i} ms"
+      IndexLogger.info "avg. time needed: #{(value.time_needed*1000/(value.count-value.without_content)).to_i} ms/file"
+    end
+  end
+  total_count = counters.values.inject(0) {|sum,count| sum + count.count}
+  total_size = counters.values.inject(0) {|sum,count| sum + count.size}
+  total_without_content = counters.values.inject(0) {|sum,count| sum + count.without_content}
+  total_time_needed = counters.values.inject(0) {|sum,count| sum + count.time_needed}
+  IndexLogger.info "\ntotal files indexed: #{total_count} (#{total_size} bytes)"
+  IndexLogger.info("total files without_content: #{total_without_content}") unless total_without_content.zero?
+  unless total_count.zero? or total_count==total_without_content then
+    IndexLogger.info "total time needed: #{(total_time_needed*1000).to_i} ms"
+    IndexLogger.info "avg. time needed: #{(total_time_needed*1000/(total_count-total_without_content)).to_i} ms/file"
+  end
+end
+
+def add_fields(index)
+  # Although not intuitively obvious, until I (Stuart Rackham) tokenized the file name, wildcard
+  # file name searches did not return all matching documents.
+  index.field_infos.add_field(:complete_path, :store => :yes, :index => :yes)
+  index.field_infos.add_field(:content, :store => :yes, :index => :yes)
+  index.field_infos.add_field(:basename, :store => :no, :index => :yes, :boost => 1.5)
+  index.field_infos.add_field(:file, :store => :no, :index => :yes, :boost => 1.5)
+  index.field_infos.add_field(:filetype, :store => :no, :index => :yes, :boost => 1.5)
+  index.field_infos.add_field(:date, :store=>:no, :index=>:yes)
+  index.field_infos.add_field(:md5, :store=>:no, :index=>:yes)
+end

data/app_generators/picolena/templates/lib/filter.rb

@@ -0,0 +1,75 @@
+require 'filter_DSL'
+
+module PlainText
+  @@filters=[]
+  
+  #returns every defined filter
+  def self.filters
+    @@filters
+  end
+  
+  #returns every required dependency for every defined filter
+  def self.filter_dependencies
+    @@dependencies||=filters.collect{|filter| filter.dependencies}.flatten.compact.uniq.sort
+  end
+  
+  #returns every supported file extensions
+  def self.supported_extensions
+    @@supported_exts||=filters.collect{|filter| filter.exts}.flatten.compact.uniq
+  end
+
+  #finds which filter should be used for a given file, according to its extension
+  def self.find_filter_for(filename)
+    ext=File.ext_as_sym(filename)
+    filter=filters.find{|filter| filter.exts.include?(ext)} || raise(ArgumentError, "no convertor for #{filename}")
+    filter.source=filename
+    filter
+  end
+  
+  #launches filter on given file and outputs plain text result
+  def self.extract_content_from(source)
+    find_filter_for(source).extract_content
+  end
+  
+  
+  class Filter
+    attr_accessor :source
+    
+    #parses command in order to know which programs are needed.
+    #rspec will then check that every dependecy is installed on the system
+    def dependencies
+      if command.is_a?(String) then
+        command.split(/\|\s*/).collect{|command_part| command_part.split(/ /).first}
+      else
+        @dependencies
+      end
+    end
+    
+    #Conversion part
+    
+    #destination method can be used by some conversion command that cannot output to stdout (example?)
+    #a file containing plain text result will first be written by command, and then be read by extract_content.
+    def destination
+      require 'tmpdir'
+      @@temp_file_as_destination ||= File.join(Dir::tmpdir,"ferret_#{Time.now.to_i}")
+    end
+    
+    #Replaces generic command with specific source and destination (if specified) files
+    def specific_command
+      command.sub('SOURCE','"'<<source<<'"').sub('DESTINATION','"'<<destination<<'"')
+    end
+    
+    def extract_content
+      if command.is_a?(String) then
+        if command.include?('DESTINATION') then
+          system(specific_command)
+          File.read_and_remove(destination)
+        else
+          IO.popen(specific_command){|io| io.read}
+        end
+      else
+        command.call(source)
+      end
+    end    
+  end
+end

data/app_generators/picolena/templates/lib/filter_DSL.rb

@@ -0,0 +1,77 @@
+#Module used to define Filters with DSL
+#For example, to convert "Microsoft Office Word document" to plain text
+#   PlainText.extract {
+#      from :doc, :dot
+#      as "application/msword"
+#      aka "Microsoft Office Word document"
+#      with "antiword SOURCE > DESTINATION 2>/dev/null" => :on_linux, "some other command" => :on_windows
+#      which_should_for_example_extract 'district heating', :from => 'Types of malfunction in DH substations.doc'
+#   }
+module PlainText  
+  #defines a new Filter with DSL
+  def self.extract(&block)
+    filter = Filter.new
+    filter.instance_eval(&block)
+    @@filters<<filter
+    MimeType.add(filter.exts,filter.mime_name)
+  end
+  
+  #defined by DSL described in PlainText
+  class Filter
+    attr_reader :exts, :mime_name, :description, :command, :content_and_file_examples
+    
+    def initialize
+      @content_and_file_examples=[]   
+    end
+    
+    def from(*exts)
+      @exts=exts
+    end
+    
+    def as(mime_name)
+      @mime_name=mime_name
+    end
+    
+    def aka(description)
+      @description=description
+    end
+    
+    def which_requires(*dependencies)
+      @dependencies=dependencies
+    end
+        
+    #used by rspec to test filters:
+    #  which_should_for_example_extract 'in a pdf file', :from => 'basic.pdf'
+    #  or_extract 'some other stuff inside another pdf file', :from => 'yet_another.pdf'
+    #
+    #this spec will pass if 'basic.pdf' and 'yet_another.pdf' are included in an indexed directory, if every dependency is installed,
+    #and if plain text output from the filter applied to 'basic.pdf' and 'yet_another.pdf' respectively include 'in a pdf file' and 'some other stuff inside another pdf file' 
+    def which_should_for_example_extract(content, file)
+      @content_and_file_examples << [content,file[:from]]
+    end
+    
+    #it allows to define specs in this way:
+    #  which_should_for_example_extract 'Hello world!', :from => 'hello.rb'
+    #  or_extract 'text inside!', :from => 'crossed.txt'
+    alias_method :or_extract, :which_should_for_example_extract
+    
+    def with(command_as_hash_or_string=nil,&block)
+      platform=case RUBY_PLATFORM
+        when /linux/
+          :on_linux
+        when /win/
+          :on_windows
+      end
+      @command=case command_as_hash_or_string
+        when String
+          command_as_hash_or_string
+        when Hash
+          #dup must be used, otherwise @command gets frozen. No idea why though....
+          command_as_hash_or_string.invert[platform].dup
+        else
+          block || raise("No command defined for this filter: #{description}")
+        end
+      @command<<' 2>/dev/null' if (@command.is_a?(String) && platform==:on_linux && !@command.include?('|'))
+    end
+  end
+end

data/app_generators/picolena/templates/lib/filters/adobe.pdf.rb

@@ -0,0 +1,13 @@
+# PDF to text conversion:
+#   Program: pdftotext
+#   Version tested: 3.02
+#   Installation: Ubuntu  xpdf-utils package
+#   Home page: http://www.foolabs.com/xpdf/
+
+PlainText.extract {
+  from :pdf
+  as "application/pdf"
+  aka "Adobe Portable Document Format"
+  with "pdftotext -enc UTF-8 SOURCE -" => :on_linux, "some other command" => :on_windows
+  which_should_for_example_extract 'in a pdf file', :from => 'basic.pdf'
+}

data/app_generators/picolena/templates/lib/filters/html.rb

@@ -0,0 +1,17 @@
+PlainText.extract {
+  from :html, :htm
+  as "text/html"
+  aka "HyperText Markup Language document"
+  with {|source|
+    encoding=File.encoding(source)
+    if encoding.empty? or encoding.gsub(/[^\w]/,'').downcase=="utf8" then
+      %x{html2text -nobs "#{source}"}
+    else
+      %x{html2text -nobs "#{source}" | iconv -f #{encoding} -t utf8}
+    end
+  }
+  which_requires 'html2text', 'iconv'
+  which_should_for_example_extract 'zentrum für angewandte forschung an fachhochschulen nachhaltige energietechnik Baden-Württemberg', :from => 'zafh.net.html'
+  or_extract 'Málaga', :from => '7.html'
+  or_extract 'le monde', :from => 'lemonde.htm'
+}

data/app_generators/picolena/templates/lib/filters/ms.excel.rb

@@ -0,0 +1,41 @@
+#Excel 97-2003
+
+PlainText.extract {
+  from :xls
+  as "application/excel"
+  aka "Microsoft Office Excel document"
+  with "xls2csv SOURCE 2>/dev/null | grep -i [a-z] | sed -e 's/\"//g' -e 's/,*$//' -e 's/,/ /g'" => :on_linux, "some other command" => :on_windows
+  which_should_for_example_extract 'Some text (should be indexed!)', :from => 'table.xls'
+}
+
+#Excel 2007
+
+require 'zip/zip'
+PlainText.extract {
+  from :xlsx
+  as 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet'
+  aka "Microsoft Office 2007 Excel spreadsheet"
+  with {|source|
+    Zip::ZipFile.open(source){|zipfile|
+      text_cells=zipfile.read("xl/sharedStrings.xml").split(/</).grep(/^t/).collect{|l|
+        l.sub(/^[^>]+>/,'')
+      }
+      
+      sheet_names=zipfile.read("xl/workbook.xml").split(/</).grep(/^sheet /).collect{|l|
+        l.scan(/name="([^"]*)"/)
+      }
+      (sheet_names+text_cells).join("\n")
+    }
+  }
+  which_should_for_example_extract '<- this result should not be 100000!', :from => 'office2007-excel.xlsx'
+  or_extract 'Sheet name should be indexed!!!', :from => 'office2007-excel.xlsx'
+}
+
+## Microsoft Excel to text conversion:
+##   Program: xls2csv
+##   Version tested: 0.37
+##   Installation: Ubuntu catdoc package
+##   Home page: http://www.winfield.demon.nl/
+
+## MS OOXML excel to text conversion:
+## Ruby code written by Eric DUMINIL

data/app_generators/picolena/templates/lib/filters/ms.powerpoint.rb

@@ -0,0 +1,40 @@
+#Powerpoint 97-2003
+
+PlainText.extract {
+  from :ppt, :pps
+  as "application/powerpoint"
+  aka "Microsoft Office Powerpoint document"
+  with "catppt SOURCE" => :on_linux, "some other command" => :on_windows
+  which_should_for_example_extract 'unofficial written by OOo Impress', :from => 'one_page.ppt'
+  #FIXME: it seems that catppt cannot open .pps files.
+  #or_extract 'a lightweight ferret-powered search engine written in Ruby on rails.', :from => 'picolena.pps'
+}
+
+#Powerpoint 2007
+
+require 'zip/zip'
+PlainText.extract {
+  from :pptx
+  as 'application/vnd.openxmlformats-officedocument.presentationml.presentation' #could that mime BE any longer?
+  aka "Microsoft Office 2007 Powerpoint document"
+  with {|source|
+    Zip::ZipFile.open(source){|zipfile|
+      slides=zipfile.entries.select{|l| l.name=~/^ppt\/slides\/slide\d+.xml/}
+      slides.collect{|entry|
+        zipfile.read(entry).split(/</).grep(/^a:t/).collect{|l|
+            l.sub(/^[^>]+>/,'')
+          }
+      }.join("\n")
+    }
+  }
+  which_should_for_example_extract 'Welcome to Picolena (one more time!)', :from => 'office2007-powerpoint.pptx'
+}
+
+## Microsoft Powerpoint to text conversion:
+##   Program: catppt
+##   Version tested: Catdoc Version 0.94.2
+##   Installation: Ubuntu catdoc package
+##   Home page: http://www.wagner.pp.ru/~vitus/software/catdoc/
+
+## MS OOXML powerpoint to text conversion:
+## Ruby code written by Eric DUMINIL

data/app_generators/picolena/templates/lib/filters/ms.rtf.rb

@@ -0,0 +1,13 @@
+# Microsoft Rich Text Format to text conversion:
+#   Program: unrtf
+#   Version tested: 0.19.2
+#   Installation: Ubuntu unrtf package
+#   http://www.gnu.org/software/unrtf/unrtf.html
+
+PlainText.extract {
+  from :rtf
+  as "application/rtf"
+  aka "Microsoft Rich Text Format"
+  with "unrtf  SOURCE -t text" => :on_linux, "some other command" => :on_windows
+  which_should_for_example_extract 'Resampling when limiting', :from => 'ReadMe.rtf'
+}

data/app_generators/picolena/templates/lib/filters/ms.word.rb

@@ -0,0 +1,37 @@
+#Word 97-2003
+
+PlainText.extract {
+  from :doc, :dot
+  as "application/msword"
+  aka "Microsoft Office Word document"
+  with "antiword SOURCE" => :on_linux, "some other command" => :on_windows
+  which_should_for_example_extract 'district heating', :from => 'Types of malfunction in DH substations.doc'
+  or_extract 'Basic Word template for Picolena specs', :from => 'office2003-word-template.dot'
+}
+
+#Word 2007
+
+require 'zip/zip'
+PlainText.extract {
+  from :docx, :dotx
+  as 'application/vnd.openxmlformats-officedocument.wordprocessingml.document'
+  aka "Microsoft Office 2007 Word document"
+  with {|source|
+    Zip::ZipFile.open(source){|zipfile|
+      zipfile.read("word/document.xml").split(/</).grep(/^w:t/).collect{|l|
+        l.sub(/^[^>]+>/,'')
+      }.join("\n")
+    }
+  }
+  which_should_for_example_extract 'Can this office 2007 document be indexed\?', :from => 'office2007-word.docx'
+  or_extract 'Basic Word 2007 template for Picolena specs', :from => 'office2007-word-template.dotx'
+}
+
+## Microsoft Word to text conversion:
+##   Program: antiword
+##   Version tested: 0.37
+##   Installation: Ubuntu antiword package
+##   Home page: http://www.winfield.demon.nl/
+
+## MS OOXML word to text conversion:
+## Ruby code written by Eric DUMINIL

data/app_generators/picolena/templates/lib/filters/opendocument.presentation.rb

@@ -0,0 +1,16 @@
+# Open Document Presentation to text conversion
+
+require 'zip/zip'
+PlainText.extract {
+  from :odp
+  as 'application/vnd.oasis.opendocument.presentation'
+  aka "Open Document Format for presentation"
+  with {|source|
+    Zip::ZipFile.open(source){|zipfile|
+      zipfile.read("content.xml").split(/</).grep(/^text:(p|span)/).collect{|l|
+        l.sub(/^[^>]+>/,'')
+      }.join("\n")
+    }
+  }
+  which_should_for_example_extract 'Picolena can it find me maybe!', :from => 'ubuntu_theme.odp'
+}

data/app_generators/picolena/templates/lib/filters/opendocument.spreadsheet.rb

@@ -0,0 +1,16 @@
+# Open Document Spreadsheet to text conversion
+
+require 'zip/zip'
+PlainText.extract {
+  from :ods
+  as 'application/vnd.oasis.opendocument.spreadsheet'
+  aka "Open Document Format for spreadsheet"
+  with {|source|
+    Zip::ZipFile.open(source){|zipfile|
+      zipfile.read("content.xml").split(/</).grep(/^text:(p|span)/).collect{|l|
+        l.sub(/^[^>]+>/,'')
+      }.join("\n")
+    }
+  }
+  which_should_for_example_extract 'Cessna F-172P G-BIDF, serial number 2045', :from => 'weight_and_balance.ods'
+}

data/app_generators/picolena/templates/lib/filters/opendocument.text.rb

@@ -0,0 +1,16 @@
+# Open Document to text conversion
+
+require 'zip/zip'
+PlainText.extract {
+  from :odt
+  as 'application/vnd.oasis.opendocument.text'
+  aka "Open Document Format for text"
+  with {|source|
+    Zip::ZipFile.open(source){|zipfile|
+      zipfile.read("content.xml").split(/</).grep(/^text:(p|span)/).collect{|l|
+        l.sub(/^[^>]+>/,'')
+      }.join("\n")
+    }
+  }
+  which_should_for_example_extract 'written with OpenOffice.org', :from => 'basic.odt'
+}

data/app_generators/picolena/templates/lib/filters/plain_text.rb

@@ -0,0 +1,36 @@
+PlainText.extract {
+  from :txt, :text, :tex, :for, :cpp, :c, :rb, :ins, :vee, :java, :no_extension
+  as "application/plain"
+  aka "plain text file"
+  with {|source|
+    encoding=File.encoding(source)
+    #TODO: Return "binary file" if binary
+    if encoding.empty? then
+       File.read(source)
+    else
+       %x{iconv -f #{encoding} -t utf8  "#{source}" 2>/dev/null}
+    end
+  }
+  # for dependencies spec
+  which_requires 'iconv'
+  
+  # to check if filter is working with basic plain text files
+  which_should_for_example_extract 'Hello world!', :from => 'hello.rb'
+  or_extract 'text inside!', :from => 'crossed.txt'
+  or_extract 'txt inside!', :from => 'crossed.text'
+  or_extract 'should index LaTeX too', :from => 'basic.tex'
+  or_extract 'public static void main', :from => 'myfirstjavaprog.java'
+  or_extract '"void CMatrix::inv()"', :from => 'ccmatrix1.cpp'
+  or_extract 'CALL TEST(BOARD,X,Y,POSSIBLE)', :from=>'queens.for'
+  or_extract 'This program calculates greatest common divisors', :from=>'gcd.c'
+  or_extract 'p 3 square.dat', :from => 'square.ins'
+  or_extract 'Do loop (global)', :from => 'xor.vee'
+  
+  # to check if other charsets are supported
+  or_extract 'püöüökäößß AND ßklüöü', :from => 'utf-8.txt'
+  or_extract 'Themenliste für Adsorptionskälte', :from => 'iso-8859-1.txt'
+  or_extract 'F€rnwärme', :from => 'iso-8859-15.txt'
+  or_extract 'The previous line includes some weird chars. Will this file be indexed\?', :from => 'weird_chars.txt'
+  or_extract 'Incidentally this file should get indexed as well', :from => 'README'
+  or_extract 'OMG_thIs_Is_A_w3ird_fileN4mE!', :from => "'weird'filename.txt"
+}

data/app_generators/picolena/templates/lib/tasks/annotations.rake

@@ -0,0 +1,5 @@
+class SourceAnnotationExtractor
+  def find(dirs=%w(app lib spec lang config))
+    dirs.inject({}) { |h, dir| h.update(find_in(dir)) }
+  end
+end

data/app_generators/picolena/templates/lib/tasks/index.rake

@@ -0,0 +1,26 @@
+desc 'Ferret index maintenance tasks'
+namespace :index do  
+  desc 'Clear indexes'
+  task :clear => :environment do
+    require 'fileutils'
+    Dir.glob(File.join(IndexSavePath,'/**/*')).each{|f| FileUtils.rm(f) if File.file?(f)}
+  end
+  
+  desc 'Create index'
+  task :create => :environment do
+    require 'ff'
+    create_index(IndexedDirectories.keys)
+  end
+
+  desc 'Update index'
+  task :update do
+    puts "Implement me!"
+  end
+  
+  # Search index with query "some query" :
+  # rake index:search query="some query"
+  desc 'Search index'
+  task :search => :environment do
+    Finder.new(ENV["query"]).matching_documents.entries.each{|doc| puts doc.to_s}
+  end
+end

data/app_generators/picolena/templates/lib/tasks/install_dependencies.rake

@@ -0,0 +1,37 @@
+desc 'Install dependencies'
+
+def root_privileges_required!
+  raise "Root privileges are required.\nPlease launch this task again as root." if ENV["USER"]!="root"
+end
+
+namespace :install_dependencies do
+  # Not tested yet
+  desc 'Install required packages on Debian'
+  task :on_debian => :deb_packages
+
+
+  # Tested successfully on 7.10 (gutsy)
+  # odt2txt package not available on previous versions
+  desc 'Install required packages on Ubuntu'
+  task :on_ubuntu => :on_debian
+  
+  desc 'Install required gems and programs on Windows'
+  task :on_windows_xp do
+    #NOTE: Long way to go before it runs on XP.
+    $stderr.puts "Implement me!"
+  end
+
+  desc 'Install required gems and packages on Mac Os'  
+  task :on_mac_os do
+    $stderr.puts "Implement me!"
+  end
+
+  desc 'Install required .deb packages'
+  task :deb_packages do
+    root_privileges_required!
+    #TODO: Should load this list from defined PlainText.filters
+    packages=%w{antiword poppler-utils odt2txt html2text catdoc unrtf}.join(" ")
+    puts "Installing "<<packages
+    system("apt-get install "<<packages)
+  end
+end

data/app_generators/picolena/templates/lib/tasks/log.rake

@@ -0,0 +1,21 @@
+desc 'Ferret index maintenance tasks'
+
+namespace :log do  
+  desc 'Parse log files for queries'
+  task :queries do
+    show_action_regexp=/Processing DocumentsController#show \(for ([\d\.]+) at ([\d\- :]+)\) \[GET\]/
+    paramaters_regexp=/"id"=>"(.*?)"/
+    one_line_or_the_other=Regexp.union(show_action_regexp,paramaters_regexp)
+    log_file='log/'<<(ENV["RAILS_ENV"]||"production")<<'.log'
+    File.readlines(log_file).grep(one_line_or_the_other).each{|line|
+      case line
+        when show_action_regexp
+        print "#{$2} (#{$1})"
+        when /\{"format"=>"(.*?)", "action"=>"show", "id"=>"(.*?)"/
+        puts " : #{$2}.#{$1}"
+        when /\{"action"=>"show", "id"=>"(.*?)"/
+        puts " : #{$1}"
+      end
+    }
+  end
+end

data/app_generators/picolena/templates/public/.htaccess

@@ -0,0 +1,40 @@
+# General Apache options
+AddHandler fastcgi-script .fcgi
+AddHandler cgi-script .cgi
+Options +FollowSymLinks +ExecCGI
+
+# If you don't want Rails to look in certain directories,
+# use the following rewrite rules so that Apache won't rewrite certain requests
+# 
+# Example:
+#   RewriteCond %{REQUEST_URI} ^/notrails.*
+#   RewriteRule .* - [L]
+
+# Redirect all requests not available on the filesystem to Rails
+# By default the cgi dispatcher is used which is very slow
+# 
+# For better performance replace the dispatcher with the fastcgi one
+#
+# Example:
+#   RewriteRule ^(.*)$ dispatch.fcgi [QSA,L]
+RewriteEngine On
+
+# If your Rails application is accessed via an Alias directive,
+# then you MUST also set the RewriteBase in this htaccess file.
+#
+# Example:
+#   Alias /myrailsapp /path/to/myrailsapp/public
+#   RewriteBase /myrailsapp
+
+RewriteRule ^$ index.html [QSA]
+RewriteRule ^([^.]+)$ $1.html [QSA]
+RewriteCond %{REQUEST_FILENAME} !-f
+RewriteRule ^(.*)$ dispatch.cgi [QSA,L]
+
+# In case Rails experiences terminal errors
+# Instead of displaying this message you can supply a file here which will be rendered instead
+# 
+# Example:
+#   ErrorDocument 500 /500.html
+
+ErrorDocument 500 "<h2>Application error</h2>Rails application failed to start properly"