#!/usr/bin/env ruby

# $:.unshift('lib')

#require 'uri'
require 'yaml'
require 'fileutils'

require './lib/facet/file/self/read_list'

#VERSION = "2005-11-05"
REQPATH = "facet"
DATPATH = "data/facets"
ETCPATH = "conf/facets"
MTHPATH = "lib/facet"
GENPATH = "lib/facets"

#-----------------------------------------------------
# Generate facet/
#-----------------------------------------------------
=begin
desc %{Build facet redirect directory}
task :facet do
  sh %{rm -R './lib/facet'}
  ['ext','set/special','set/general'].each{ |d|
    from = "lib/facets/2005-11-05"
    rbs = Dir.glob( File.join( from, d, '**/*.rb' ) )
    rbs.each { |e|
      nolib = e.gsub( /^lib\//, '' )
      re = Regexp.new( Regexp.escape( File.join( from, d ) + '/' ) )
      link = e.gsub( re, 'lib/facet/')
      FileUtils.mkdir_p( File.dirname( link ) )
      File.open( link, "w+" ) { |w|
         w << "require '#{nolib}'"
      }
    }
  }
end
=end

#-----------------------------------------------------
# Read in the facets directory and sort-out per class
#-----------------------------------------------------
Methods = {}
task :methods do
  Dir.chdir(MTHPATH) do
    dg = Dir.glob('*/**/*.rb')
    dg.each { |f|
      klass, *meth= f.split('/')
      Methods[ klass ] ||= []
      Methods[ klass ] << "#{meth.join('/').chomp('.rb')}"
    }
    Methods.keys.each { |k| Methods[k].sort! }
  end
end

#-----------------------------------------------------
# Save method index to file in yaml format
#-----------------------------------------------------
desc %{Generate method index file}
task :index => [ :methods ] do
  print "Creating method index... "
  loc = File.join( DATPATH, 'index.yml' )
  File.open( loc, 'w' ) { |f|
    f << Methods.to_yaml
  }
  puts "[done]"
end

#-----------------------------------------------------
# Create per class feature files
#-----------------------------------------------------
desc %Q{Generate per-class feature files}
task :class => [:methods ] do
  print "Creating per class files... "

  index  = Methods
  noauto = File.read_list( File.join( ETCPATH, 'noauto' ) )
  allfiles = index.collect{ |k,ms| ms.collect{ |m| "#{k}/#{m}" } }.flatten
  full = calc_full(allfiles, noauto)

  index.each { |classname, method_files|
    File.open( "#{GENPATH}/#{classname.downcase}.rb", 'w' ) { |f|
      method_files.each { |rf|
        mfn = "#{classname.downcase}/#{rf}"
        if full.include?(mfn)
          f << %Q{require '#{REQPATH}/#{mfn}'\n}
        end
      }
    }
  }
  puts "[done]"
end

#-----------------------------------------------------
# Do all prep tasks (do this to generate data index
# file and method group files)
#-----------------------------------------------------
desc %{Do all preperation (index, class)}
task :prep => [ :index, :class ] do
end

#-----------------------------------------------------
# List Methods
#-----------------------------------------------------
desc %{Output a list of all methods}
task 'list' => [ :methods ] do
  puts method_list_outline
end

# #-----------------------------------------------------
# # HTML List MethodsFile.new(
# #-----------------------------------------------------
#
# HEAD = <<-HERE
# <html>
# <head>
#   <style>
#     pre#methods {
#       font-size: .8em;
#       line-height: 1em;
#     }
#   </style>
# </head>
# <body>
# <pre id="methods">
# HERE
# 
# FOOT=<<-HERE
# </pre>
# </body>
# </html>
# HERE
# 
# desc %{generate method list html file}
# task 'listHtml' => [ :scrape_methods ] do
#   s = HEAD + method_list_outline + FOOT
#   File.open('pub/www/methods.html', 'w') { |f| f << s }
# end

#desc "Check for open comment tests"
#task :testchk do
#  system %q{grep -r ^#=begin\ test ./lib}
#end


#-----------------------------------------------------
# Supporting Methods
#-----------------------------------------------------

private

def method_list_outline
  s = ''
  Methods.keys.sort.each { |k|
    ms = Methods[k].collect{|m| m.gsub(%r{^self\/},'::')}.sort
    s << "#{k}:\n"
    ms.each { |m| s << "  #{m}\n" }
  }
  s
end

# Full set of require files (allfiles minus noauto and unsafe)
def calc_full( allfiles, noauto )
  sf = allfiles.dup
  noauto.each do |f|
    if f.include?('*')
      re = %r"#{f.gsub('*','.*')}"
      sf.reject!{ |x| x =~ re }
    elsif sf.include?(f)
      sf.delete f
    end
  end
  sf.sort
end
