geohydra 0.3.1 → 0.3.3

data/bin/extract_thumbnail.rb

@@ -3,47 +3,48 @@
 require 'optparse'
 require 'geohydra'
 
-def do_file fn, flags
-  if fn =~ %r{^(.*)\.(shp|tif)\.xml$}i
-    puts "Processing #{fn} for JPEG" if flags[:verbose]
-    GeoHydra::Transform.extract_thumbnail fn, File.join(File.dirname(fn), 'preview.jpg')
-  else
-    raise OptionParser::InvalidOption, "File <#{fn}> is not ESRI metadata format"
+class ExtractThumbnail < GeoHydra::Process
+  def do_file fn, flags
+    if fn =~ %r{^(.*)\.(shp|tif)\.xml$}i
+      puts "Processing #{fn} for JPEG" if flags[:verbose]
+      GeoHydra::Transform.extract_thumbnail fn, File.join(File.dirname(fn), 'preview.jpg')
+    else
+      raise OptionParser::InvalidOption, "File <#{fn}> is not ESRI metadata format"
+    end
   end
-end
 
-flags = {
-  :datadir => '.',
-  :recurse => false,
-  :verbose => false
-}
+  def run(args)
+    flags = {
+      :datadir => '.',
+      :recurse => false,
+      :verbose => false
+    }
 
-optparse = OptionParser.new do |opts|
-  opts.banner = <<EOM
-Usage: #{File.basename(__FILE__)} [options] [fn [fn...]]
+    optparse = OptionParser.new do |opts|
+      opts.banner = <<EOM
+    Usage: #{File.basename(__FILE__)} [options] [fn [fn...]]
 EOM
-  opts.on("-d", "--dir DIR", "Process all files in DIR (default: #{flags[:datadir]})") do |v|
-    flags[:datadir] = v
-  end
-  opts.on("-r", "--recursive", "Process all files recurvisely") do |v|
-    flags[:recurse] = true
-  end
-  
-  opts.on("-v", "--verbose", "Run verbosely") do |v|
-    flags[:verbose] = true
+      opts.on("-d", "--dir DIR", "Process all files in DIR (default: #{flags[:datadir]})") do |v|
+        flags[:datadir] = v
+      end
+      opts.on("-r", "--recursive", "Process all files recurvisely") do |v|
+        flags[:recurse] = true
+      end
+
+      opts.on("-v", "--verbose", "Run verbosely") do |v|
+        flags[:verbose] = true
+      end
+    end
+
+    optparse.parse!(args)  
+    if args.empty?
+      raise OptionParser::InvalidOption, flags[:datadir] + ' not a directory' unless File.directory?(flags[:datadir])
+      Dir.glob(flags[:datadir] + (flags[:recurse] ? '/**/*.shp.xml' : '/*.shp.xml')).each {|fn| do_file fn, flags }
+    else
+      args.each {|fn| do_file fn, flags }
+    end
   end
 end
 
-begin
-  optparse.parse!  
-  if ARGV.empty?
-    raise OptionParser::InvalidOption, flags[:datadir] + ' not a directory' unless File.directory?(flags[:datadir])
-    Dir.glob(flags[:datadir] + (flags[:recurse] ? '/**/*.shp.xml' : '/*.shp.xml')).each {|fn| do_file fn, flags }
-  else
-    ARGV.each {|fn| do_file fn, flags }
-  end
-rescue OptionParser::InvalidOption, OptionParser::MissingArgument => e
-  $stderr.puts e
-  $stderr.puts optparse
-  exit(-1)
-end
+ExtractThumbnail.new.run(ARGV)
+

data/bin/geo2mods.rb

@@ -0,0 +1,78 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+require File.expand_path(File.dirname(__FILE__) + '/../config/boot')
+require 'optparse'
+require 'json'
+
+class Geo2MODS < GeoHydra::Process
+  def main(flags)
+    defaultGeometryType = 'Polygon'
+    defaultZipName = 'data.zip'
+    purl, ifn, optfn, ofn = flags[:purl], flags[:geoMetadata], flags[:geoOptions], flags[:descMetadata]
+  
+    puts "Processing #{purl} #{ifn}" if flags[:verbose]
+
+    puts "Loading extra out-of-band options #{optfn}" if flags[:debug]
+    if not optfn.nil? and File.exist?(optfn)
+      h = JSON.parse(File.read(optfn))
+      flags = flags.merge(h).symbolize_keys
+      ap({:optfn => optfn, :h => h, :flags => flags}) if flags[:debug]
+    else
+      puts "WARNING: missing options .json parameters: #{optfn}"
+      flags[:geometryType] ||= defaultGeometryType # XXX: placeholder
+    end
+
+    # Load datastream
+    geoMetadataDS = Dor::GeoMetadataDS.from_xml File.read(ifn)
+    geoMetadataDS.geometryType = flags[:geometryType] || defaultGeometryType
+    geoMetadataDS.zipName = defaultZipName
+    geoMetadataDS.purl = purl
+    ap({:geoMetadataDS => geoMetadataDS}) if flags[:debug]
+
+    # MODS from GeoMetadataDS
+    puts "Generating #{flags[:descMetadata]}" if flags[:verbose]
+    File.open(flags[:descMetadata], 'wb') do |f| 
+      f << geoMetadataDS.to_mods.to_xml(:index => 2) 
+    end
+  end
+
+  # __MAIN__
+  def run(args)
+    flags = {
+      :debug => false,
+      :verbose => false
+    }
+
+    OptionParser.new do |opts|
+      opts.banner = <<EOM
+  Usage: #{File.basename(__FILE__)} [options]
+EOM
+      opts.on('-v', '--verbose', 'Run verbosely') do |v|
+        flags[:debug] = true if flags[:verbose]
+        flags[:verbose] = true
+      end
+      opts.on('--purl URI', "PURL with druid") do |v|
+        flags[:purl] = v
+      end
+      opts.on('--geoMetadata FILE', "Input file with ISO 19139/19110 XML") do |v|
+        flags[:geoMetadata] = v
+      end
+      opts.on('--geoOptions FILE', "Input file with JSON flags") do |v|
+        flags[:geoOptions] = v
+      end
+      opts.on('--descMetadata FILE', "Output file with MODS XML") do |v|
+        flags[:descMetadata] = v
+      end
+    end.parse!(args)
+
+    %w{purl geoMetadata descMetadata}.each do |k|
+      raise ArgumentError, "Missing required --#{k} flag" if flags[k.to_sym].nil?
+    end
+
+    ap({:flags => flags}) if flags[:debug]
+    main flags
+  end
+end
+
+# __MAIN__
+Geo2MODS.new.run(ARGV)

data/bin/geohydra

@@ -1,11 +1,20 @@
 #!/bin/bash
 
-if [ $# -eq 0 ]; then
-  echo "Usage: geohydra command [flags]"
+usage() {
+  echo "Usage:"
+  echo "          geohydra command [flags]"
+  echo "          geohydra help"
+  echo "Commands:"
+  ls bin/*.rb | sed -e 's/^bin./          /' -e 's/.rb$//'
   exit -1
-fi
+}
 
-fn=$1
+[ $# -eq 0 ] && usage
+
+fn=`basename $1 .rb`
 shift
 
-bundle exec bin/$fn.rb $*
+[ $fn = '--help' -o $fn = 'help' ] && usage
+[ ! -x bin/$fn.rb ] && echo "ERROR: Invalid command: Missing bin/$fn.rb" && usage
+
+bundle exec bin/$fn.rb $@

data/bin/ingest_arcgis.rb

@@ -4,74 +4,94 @@ require File.expand_path(File.dirname(__FILE__) + '/../config/boot')
 require 'optparse'
 require 'fileutils'
 
-def extract_thumbnail fn, flags
-  if fn =~ %r{^(.*)\.(shp|tif)\.xml$}i or File.basename(fn) == 'metadata.xml'
-    puts "Processing #{fn} for JPEG" if flags[:verbose]
-    GeoHydra::Transform.extract_thumbnail fn, File.join(File.dirname(fn), 'preview.jpg')
-  else
-    raise OptionParser::InvalidOption, "File <#{fn}> is not ESRI metadata format"
+class IngestArcGIS < GeoHydra::Process
+  def extract_thumbnail fn, flags
+    if fn =~ %r{^(.*)\.(shp|tif)\.xml$}i or File.basename(fn) == 'metadata.xml'
+      puts "Processing #{fn} for JPEG" if flags[:verbose]
+      thumbnail_fn = File.join(File.dirname(fn), 'preview.jpg')
+      puts "Writing to #{thumbnail_fn}" if flags[:debug]
+      GeoHydra::Transform.extract_thumbnail fn, thumbnail_fn
+    else
+      raise OptionParser::InvalidOption, "File <#{fn}> is not ESRI metadata format"
+    end
   end
-end
 
-def process_file fn, flags
-  puts "Processing #{fn}" if flags[:verbose]
-  if fn =~ %r{^(.*).(shp|tif).xml$}
-    ofn = $1 + '-iso19139.xml'
-    ofn_fc = $1 + '-iso19139-fc.xml'
-  elsif File.basename(fn) == 'metadata.xml'
-    ofn = File.join(File.dirname(fn), 'metadata.iso19139.xml')
-    ofn_fc = File.join(File.dirname(fn), 'metadata.iso19139-fc.xml')
-  else
-    raise OptionParser::InvalidOption, "File <#{fn}> is not named correctly"
-  end
+  def process_file fn, flags
+    puts "Processing #{fn}" if flags[:verbose]
+    if fn =~ %r{^(.*).(shp|tif).xml$}
+      ofn = $1 + '-iso19139.xml'
+      ofn_fc = $1 + '-iso19110.xml'
+      ofn_fgdc = $1 + '-fgdc.xml'
+    elsif File.basename(fn) == 'metadata.xml'
+      ofn = File.join(File.dirname(fn), 'metadata.iso19139.xml')
+      ofn_fc = File.join(File.dirname(fn), 'metadata.iso19110.xml')
+      ofn_fgdc = File.join(File.dirname(fn), 'metadata.fgdc.xml')
+    else
+      raise OptionParser::InvalidOption, "File <#{fn}> is not named correctly"
+    end
   
-  ap({:fn => fn, :ofn => ofn, :ofn_fc => ofn_fc}) if flags[:debug]
-  unless FileUtils.uptodate?(ofn, [fn]) and FileUtils.uptodate?(ofn_fc, [fn])
-    GeoHydra::Transform.from_arcgis fn, ofn, ofn_fc
-    extract_thumbnail(fn, flags)
-    dstdir = "#{File.dirname(fn)}/../content/"
-    FileUtils.mkdir_p(dstdir) unless File.directory?(dstdir)
-    system("mv #{File.dirname(fn)}/*.jpg #{dstdir}/")
+    if flags[:rebuild] or not (FileUtils.uptodate?(ofn, [fn]) and FileUtils.uptodate?(ofn_fc, [fn]))
+      ap({:fn => fn, :ofn => ofn, :ofn_fc => ofn_fc, :ofn_fgdc => ofn_fgdc}) if flags[:debug]
+      begin
+        GeoHydra::Transform.from_arcgis fn, ofn, ofn_fc, ofn_fgdc
+        extract_thumbnail(fn, flags)
+        if flags[:mv_jpg]
+          dstdir = "#{File.dirname(fn)}/../content/"
+          FileUtils.mkdir_p(dstdir) unless File.directory?(dstdir)
+          system("mv #{File.dirname(fn)}/*.jpg #{dstdir}/")
+        
+        end
+      rescue Exception => e
+        puts e
+      end
+    
+    end
   end
-end
 
-flags = {
-  :verbose => false,
-  :debug => false,
-  :directory => '/var/geomdtk/current/stage'
-}
-OptionParser.new do |opts|
-  opts.banner = "
-Usage: #{__FILE__} [-v] file.shp.xml [file.shp.xml ...]
-       #{__FILE__} [-v] metadata.xml [metadata.xml ...]
-       #{__FILE__} [-v] [directory]
-"
-  opts.on("-v", "--verbose", "Run verbosely") do |v|
-    flags[:debug] = true if flags[:verbose]
-    flags[:verbose] = true
-  end
-end.parse!
-ARGV << flags[:directory] if ARGV.empty?
+  def run(args)
+    flags = {
+      :verbose => false,
+      :debug => false,
+      :rebuild => false,
+      :mv_jpg => true,
+      :directory => '/var/geomdtk/current/stage'
+    }
+    OptionParser.new do |opts|
+      opts.banner = "
+    Usage: #{__FILE__} [-v] file.shp.xml [file.shp.xml ...]
+           #{__FILE__} [-v] metadata.xml [metadata.xml ...]
+           #{__FILE__} [-v] [directory]
+    "
+      opts.on("-v", "--verbose", "Run verbosely") do |v|
+        flags[:debug] = true if flags[:verbose]
+        flags[:verbose] = true
+      end
+    end.parse!(args)
+    args << flags[:directory] if args.empty?
 
-ap({:flags => flags, :argv => ARGV}) if flags[:debug]
+    ap({:flags => flags, :args => args}) if flags[:debug]
 
-n = 0
-ARGV.each do |fn|
-  if File.directory? fn
-    Dir.glob(File.join(fn, '**', '*.shp.xml')) do |fn2|
-      process_file fn2, flags if File.exist?(fn2)
-      n = n + 1
+    n = 0
+    args.each do |fn|
+      if File.directory? fn
+        Dir.glob(File.join(fn, '**', '*.shp.xml')) do |fn2|
+          process_file fn2, flags if File.exist?(fn2)
+          n = n + 1
+        end
+        Dir.glob(File.join(fn, '**', 'metadata.xml')) do |fn2|
+          process_file fn2, flags if File.exist?(fn2)
+          n = n + 1
+        end
+      elsif File.exist? fn
+        process_file fn, flags
+        n = n + 1
+      else
+        $stderr.puts "WARNING: Missing file <#{fn}>"
+      end
     end
-    Dir.glob(File.join(fn, '**', 'metadata.xml')) do |fn2|
-      process_file fn2, flags if File.exist?(fn2)
-      n = n + 1
-    end
-  elsif File.exist? fn
-    process_file fn, flags
-    n = n + 1
-  else
-    $stderr.puts "WARNING: Missing file <#{fn}>"
+    puts "Processed #{n} ArcGIS metadata files"
   end
 end
-puts "Processed #{n} ArcGIS metadata files"
+
+IngestArcGIS.new().run(ARGV)
 

data/bin/iso2geo.rb

@@ -0,0 +1,64 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+require File.expand_path(File.dirname(__FILE__) + '/../config/boot')
+require 'nokogiri'
+require 'optparse'
+
+class Iso2Geo < GeoHydra::Process
+  def main(flags)
+    isoXml = Nokogiri::XML(File.read(flags[:iso19139]))
+    if isoXml.nil? or isoXml.root.nil?
+      raise ArgumentError, "Empty ISO 19139" 
+    end
+    if flags[:iso19110].nil?
+      fcXml = nil
+    else
+      fcXml = Nokogiri::XML(File.read(flags[:iso19110]))
+    end
+
+    ap({:isoXml => isoXml, :fcXml => fcXml, :flags => flags}) if flags[:debug]
+
+    # GeoMetadataDS
+    puts "Generating #{flags[:geoMetadata]}" if flags[:verbose]
+    xml = GeoHydra::Transform.to_geoMetadataDS(isoXml, fcXml, { 'purl' => flags[:purl] }) 
+    File.open(flags[:geoMetadata], 'wb') {|f| f << xml.to_xml(:indent => 2) }  
+  end
+
+  def run(args)
+    flags = {
+      :debug => false,
+      :verbose => false
+    }
+  
+    OptionParser.new do |opts|
+      opts.banner = <<EOM
+  Usage: #{File.basename(__FILE__)} [options]
+EOM
+      opts.on('-v', '--verbose', 'Run verbosely') do |v|
+        flags[:debug] = true if flags[:verbose]
+        flags[:verbose] = true
+      end
+      opts.on('--purl URI', "PURL with druid") do |v|
+        flags[:purl] = v
+      end
+      %w{19110 19139}.each do |n|
+        opts.on("--iso#{n} FILE", "Input file with ISO #{n} XML") do |v|
+          flags["iso#{n}".to_sym] = v
+        end
+      end
+      opts.on('--geoMetadata FILE', "Output file with ISO 19139/19110 XML") do |v|
+        flags[:geoMetadata] = v
+      end
+    end.parse!(args)
+  
+    %w{purl iso19139 geoMetadata}.each do |k|
+      raise ArgumentError, "Missing required --#{k} flag" if flags[k.to_sym].nil?
+    end
+  
+    ap({:flags => flags}) if flags[:debug]
+    main flags
+  end
+end
+
+# __MAIN__
+Iso2Geo.new().run(ARGV)

data/bin/loader_postgis.rb

@@ -8,252 +8,146 @@ require 'optparse'
 require 'mods'
 require 'druid-tools'
 require 'dor-services'
-
-require 'active_record'
-require 'active_support'
 require 'tmpdir'
 
-class RegisteredLayer < ActiveRecord::Base
-  attr_accessible :druid, :layername, :title
-  # self.primary_key = 'druid'
-  
-  def find_by_druid(druid)
-    RegisteredLayer.find(:first, :conditions => [ "druid = ?", druid.to_s])
-  end
-end
-
+class LoaderPostGIS < GeoHydra::Process
 
-# ENV['RGEOSERVER_CONFIG'] ||= ENV_FILE + '_rgeoserver.yml'
-# require 'rgeoserver'
+  # USAGE: shp2pgsql [<options>] <shapefile> [[<schema>.]<table>]
+  # OPTIONS:
+  #   -s [<from>:]<srid> Set the SRID field. Defaults to 0.
+  #       Optionally reprojects from given SRID (cannot be used with -D).
+  #  (-d|a|c|p) These are mutually exclusive options:
+  #      -d  Drops the table, then recreates it and populates
+  #          it with current shape file data.
+  #      -a  Appends shape file into current table, must be
+  #          exactly the same table schema.
+  #      -c  Creates a new table and populates it, this is the
+  #          default if you do not specify any options.
+  #      -p  Prepare mode, only creates the table.
+  #   -g <geocolumn> Specify the name of the geometry/geography column
+  #       (mostly useful in append mode).
+  #   -D  Use postgresql dump format (defaults to SQL insert statements).
+  #   -e  Execute each statement individually, do not use a transaction.
+  #       Not compatible with -D.
+  #   -G  Use geography type (requires lon/lat data or -r to reproject).
+  #   -k  Keep postgresql identifiers case.
+  #   -i  Use int4 type for all integer dbf fields.
+  #   -I  Create a spatial index on the geocolumn.
+  #   -S  Generate simple geometries instead of MULTI geometries.
+  #   -t <dimensionality> Force geometry to be one of '2D', '3DZ', '3DM', or '4D'
+  #   -w  Output WKT instead of WKB.  Note that this can result in
+  #       coordinate drift.
+  #   -W <encoding> Specify the character encoding of Shape's
+  #       attribute column. (default: "UTF-8")
+  #   -N <policy> NULL geometries handling policy (insert*,skip,abort).
+  #   -n  Only import DBF file.
+  #   -T <tablespace> Specify the tablespace for the new table.
+  #       Note that indexes will still use the default tablespace unless the
+  #       -X flag is also used.
+  #   -X <tablespace> Specify the tablespace for the table's indexes.
+  #       This applies to the primary key, and the spatial index if
+  #       the -I flag is used.
+  #   -?  Display this help screen.
 
-#=  Input data. *See DATA section at end of file*
-# The input file is in YAML syntax with each record is a Hash with keys:
-# - layername
-# - filename
-# - format
-# - title
-# and optionally
-# - description
-# - keywords
-# - metadata_links
+  def main layer, flags, format = :shapefile
+    druid = layer[:druid]
+    zipfn = layer[:zipfn]
+    projection = layer[:projection] || flags[:projection]
+    schema = layer[:schema] || flags[:schema]
+    encoding = layer[:encoding] || flags[:encoding]
+    ap({:druid => druid, :zipfn => zipfn, :projection => projection, :schema => schema, :encoding => encoding}) if flags[:debug]
 
-# USAGE: shp2pgsql [<options>] <shapefile> [[<schema>.]<table>]
-# OPTIONS:
-#   -s [<from>:]<srid> Set the SRID field. Defaults to 0.
-#       Optionally reprojects from given SRID (cannot be used with -D).
-#  (-d|a|c|p) These are mutually exclusive options:
-#      -d  Drops the table, then recreates it and populates
-#          it with current shape file data.
-#      -a  Appends shape file into current table, must be
-#          exactly the same table schema.
-#      -c  Creates a new table and populates it, this is the
-#          default if you do not specify any options.
-#      -p  Prepare mode, only creates the table.
-#   -g <geocolumn> Specify the name of the geometry/geography column
-#       (mostly useful in append mode).
-#   -D  Use postgresql dump format (defaults to SQL insert statements).
-#   -e  Execute each statement individually, do not use a transaction.
-#       Not compatible with -D.
-#   -G  Use geography type (requires lon/lat data or -r to reproject).
-#   -k  Keep postgresql identifiers case.
-#   -i  Use int4 type for all integer dbf fields.
-#   -I  Create a spatial index on the geocolumn.
-#   -S  Generate simple geometries instead of MULTI geometries.
-#   -t <dimensionality> Force geometry to be one of '2D', '3DZ', '3DM', or '4D'
-#   -w  Output WKT instead of WKB.  Note that this can result in
-#       coordinate drift.
-#   -W <encoding> Specify the character encoding of Shape's
-#       attribute column. (default: "UTF-8")
-#   -N <policy> NULL geometries handling policy (insert*,skip,abort).
-#   -n  Only import DBF file.
-#   -T <tablespace> Specify the tablespace for the new table.
-#       Note that indexes will still use the default tablespace unless the
-#       -X flag is also used.
-#   -X <tablespace> Specify the tablespace for the table's indexes.
-#       This applies to the primary key, and the spatial index if
-#       the -I flag is used.
-#   -?  Display this help screen.
+    raise NotImplementedError, "Unsupported format: #{format}" unless format == :shapefile
 
-def main conn, layers, flags = {}
-  ap({:layers => layers, :flags => flags}) if flags[:debug]
-  layers.each do |k, v|
-    %w{layername format filename title}.each do |i|
-      raise ArgumentError, "Layer is missing required '#{i}'" if v[i.to_sym].nil? or not v.include?(i.to_sym)
-    end
-    puts "Processing layer #{k}" if flags[:verbose]
-  
-    layername = v[:layername].strip
-    format = v[:format].downcase.strip.to_sym
-    druid = v[:druid]
-    title = v[:title].strip
-      
-    case format
-    when :shapefile      
-      ap({:v => v}) if flags[:debug]
-      Dir.mktmpdir('shp', druid.temp_dir) do |d|
-        begin
-          system("unzip -oj '#{v[:filename]}' -d '#{d}'")
-          system("ls -la #{d}")
-          Dir.glob("#{d}/*.shp") do |shp|
-            # XXX: HARD CODED projection here -- extract from MODS or ISO19139
-            # XXX: Perhaps put the .sql data into the content directory as .zip for derivative
-            # XXX: -G for the geography column causes some issues with GeoServer
-            system("shp2pgsql -d -D -I -W #{flags[:encoding]} '#{shp}' #{flags[:schema]}.#{druid.id} > '#{druid.temp_dir}/#{druid.id}.sql'")
-            system('psql --no-psqlrc --no-password --quiet ' +
-                   "--host='#{flags[:host.to_s]}' " +
-                   "--port='#{flags[:port.to_s]}' " +
-                   "--username='#{flags[:username.to_s]}' " + 
-                   "--dbname='#{flags[:database.to_s]}' " +
-                   "--file='#{druid.temp_dir}/#{druid.id}.sql' ")
-          end
-        rescue Exception => e
-          FileUtils.rm_rf(d) if File.exist?(d)
+    Dir.mktmpdir('shp', druid.temp_dir) do |d|
+      begin
+        system("unzip -oj '#{zipfn}' -d '#{d}'")
+        system("ls -la #{d}") if flags[:debug]
+        Dir.glob("#{d}/*.shp") do |shp|
+          # XXX: HARD CODED projection here -- extract from MODS or ISO19139
+          # XXX: Perhaps put the .sql data into the content directory as .zip for derivative
+          # XXX: -G for the geography column causes some issues with GeoServer
+          system("shp2pgsql -s #{projection} -d -D -I -W #{encoding}" +
+                 " '#{shp}' #{schema}.#{druid.id} " +
+                 "> '#{druid.temp_dir}/#{druid.id}.sql'")
+          system('psql --no-psqlrc --no-password --quiet ' +
+                 "--file='#{druid.temp_dir}/#{druid.id}.sql' ")
         end
+      rescue Exception => e
+        FileUtils.rm_rf(d) if File.exist?(d)
       end
-      
-      if flags[:register]
-        puts "Registering layer #{druid.id}, #{layername}, #{title}" if flags[:verbose]
-        layer = RegisteredLayer.find_by_druid druid.id
-        ap({:found_layer => layer}) if flags[:debug]
-        if layer.nil?
-          layer = RegisteredLayer.new( 
-            :druid => druid.id,
-            :layername => layername,
-            :title => title
-          )
-        end
-        layer.layername = layername
-        layer.title = title
-        ap({:updated_layer => layer}) if flags[:debug]
-        layer.save
-      end
-    else
-      raise NotImplementedError, "Unsupported format #{format}"    
     end
   end
-end
 
-def from_druid druid, flags
-  ap({:druid => druid}) if flags[:debug]
-  prj = flags[:projection] || "EPSG:4326"
-  prj = prj.split(':').join('_')
-  druid = DruidTools::Druid.new(druid, flags[:datadir])
-  mods_fn = druid.path('metadata/descMetadata.xml')
-  puts "Loading #{mods_fn}" if flags[:verbose]
-  mods = Mods::Record.new
-  mods.from_url(mods_fn)
-  ap({:mods => mods}) if flags[:debug]
+  # locates the data.zip file, preferring one with explicit projection
+  def druid2layer druid, flags
+    ap({:druid => druid}) if flags[:debug]
 
-  geo_fn = druid.path('metadata/geoMetadata.xml')
-  puts "Loading #{geo_fn}" if flags[:verbose]
-  geo = Dor::GeoMetadataDS.from_xml(File.read(geo_fn))
-  ap({:geo => geo}) if flags[:debug]
-
-  zipfn = nil
-  layername = nil
-  projection = nil
-  Dir.glob(druid.content_dir + "/*_#{prj}.zip") do |fn|
-    puts "Found EPSG 4326 zip: #{fn}" if flags[:verbose]
-    projection = '4326'
-    zipfn = fn
-    layername = File.basename(zipfn, "_#{prj}.zip")
-    puts "Derived layername #{zipfn} -> #{layername}" if flags[:verbose]
-  end
-  if not zipfn
-    Dir.glob(druid.content_dir + "/*.zip") do |fn|
-      zipfn = fn
-      layername = File.basename(zipfn, '.zip')
+    zipfn = nil
+    projection = nil
+    %w{4326}.each do |prj|
+      Dir.glob(File.join(druid.content_dir, "data_EPSG_#{prj}.zip")) do |fn|
+        puts "Found EPSG #{prj} zip: #{fn}" if flags[:verbose]
+        projection = prj
+        zipfn = fn
+      end
     end
-  end
-  raise ArgumentError, zipfn unless File.exist?(zipfn) and layername
-  ap({:zipfn => zipfn, :layername => layername}) if flags[:debug]
-  r = { 
-    :vector => {
+    
+    if zipfn.nil?
+      Dir.glob(File.join(druid.content_dir, 'data.zip')) do |fn|
+        puts "Found native zip: #{fn}" if flags[:verbose]
+        zipfn = fn
+        projection = '4326' # XXX: Hardcoded assumption that native work is in WGS84 if missing derived work
+      end
+    end
+
+    raise ArgumentError, "Missing data ZIP file: #{zipfn}" unless File.exist?(zipfn)
+    raise ArgumentError, "Missing Projection" if projection.nil?
+    ap({:zipfn => zipfn}) if flags[:debug]
+
+    { 
       :druid => druid,
-      :format => 'Shapefile',
-      :layername => layername,
-      :filename => zipfn,
-      :title => mods.full_titles.first,
-      :projection => projection.nil?? '4326' : projection
+      :zipfn => zipfn,
+      :projection => projection
     }
-  }
-  r
-end
+  end
 
-# __MAIN__
-begin
-  flags = {
-    :debug => false,
-    :verbose => false,
-    :register => false,
-    :register_drop => false,
-    :register_table => 'registered_layers',
-    :encoding => 'UTF-8',
-    :datadir => '/var/geomdtk/current/workspace',
-    :schema => GeoHydra::Config.postgis.schema || 'public'
-  }
+  def run(args)
+    flags = {
+      :encoding => 'UTF-8',
+      :workspacedir => GeoHydra::Config.geohydra.workspace || 'workspace',
+      :schema => GeoHydra::Config.postgis.schema || 'druid'
+    }
+    args = %w{--help} if args.nil? or args.empty?
   
-  OptionParser.new do |opts|
-    opts.banner = "
-Usage: #{File.basename(__FILE__)} [-v] [druid ... | < druids]
-"
-    opts.on("-v", "--verbose", "Run verbosely") do |v|
-      flags[:debug] = true if flags[:verbose]
-      flags[:verbose] = true
-    end
-    opts.on("-d DIR", "--datadir DIR", "Data directory on GeoServer (default: #{flags[:datadir]})") do |v|
-      raise ArgumentError, "Invalid directory #{v}" unless File.directory?(v)
-      flags[:datadir] = v
-    end    
-    opts.on("-R", "--register", "Register shapefile") do |v|
-      flags[:register] = true
-    end
-
-    %w{schema encoding}.each do |k|
-      opts.on("--#{k} #{k.upcase}", "PostGIS #{k} (default: #{flags[k.to_sym]})") do |v|
-        flags[k.to_sym] = v
+    OptionParser.new do |opts|
+      opts.banner = "Usage: #{File.basename(__FILE__)} [-v] druid [druid...]"
+      opts.on('-v', '--verbose', 'Run verbosely, use multiple times for debug level output') do
+        flags[:debug] = true if flags[:verbose]  # -vv
+        flags[:verbose] = true
+      end
+      opts.on('--workspace DIR', "Workspace directory for assembly (default: #{flags[:workspacedir]})") do |v|
+        flags[:workspacedir] = v
       end
-    end
-  end.parse!
 
-  ap({:flags => flags}) if flags[:debug]
-  dbfn = File.expand_path(File.dirname(__FILE__) + '/../config/database.yml')
-  puts "Loading #{dbfn}" if flags[:verbose]
-  dbconfig = YAML.load(File.read(dbfn))
-  raise ArgumentError, "Missing configuration for environment" unless dbconfig.include?(ENV['GEOHYDRA_ENVIRONMENT'])
-  flags.merge! dbconfig[ENV['GEOHYDRA_ENVIRONMENT']]
-  ap({:flags => flags}) if flags[:debug]
-  
-  ActiveRecord::Base.logger = ActiveSupport::BufferedLogger.new($stderr) if flags[:debug]
-  
-  conn = ActiveRecord::Base.establish_connection flags
-  conn.with_connection do |db|
-    # ap({:obj => db, :klass => db.class, :methods => db.public_methods, :schema_search_path => db.schema_search_path})
-    puts "Connected to PostgreSQL #{db.select_value("SHOW server_version")} " +
-         "using #{db.current_database} database" if flags[:verbose]
-    if db.select_value('select default_version from pg_catalog.pg_available_extensions where name = \'postgis\'') =~ /^(2\.[\.\d]*)$/
-      puts "Using PostGIS #{$1}" if flags[:verbose]
-    else
-      raise NotImplementedError, "Database does not have PostGIS support"
-    end
-    if flags[:register]
-      n = db.select_value("SELECT COUNT(*) FROM pg_tables WHERE schemaname = 'public' and tablename = '#{flags[:register_table]}'")
-      if n.to_i == 0 or flags[:register_drop]
-        puts "Creating registry table in public.#{flags[:register_table]}" if flags[:verbose]
-        db.execute("DROP TABLE public.#{flags[:register_table]}") if flags[:register_drop]
-        db.execute("
-          CREATE TABLE public.#{flags[:register_table]}
-          (
-            druid character varying NOT NULL PRIMARY KEY,
-            layername character varying NOT NULL,
-            title character varying NOT NULL
-          );      
-          ")
+      %w{schema encoding}.each do |k|
+        opts.on("--#{k} #{k.upcase}", "PostGIS flag #{k} (default: #{flags[k.to_sym]})") do |v|
+          flags[k.to_sym] = v
+        end
       end
-    end
-  end
+    end.parse!(args)
+
+    ap({:args => args, :flags => flags}) if flags[:debug]
     
-  (ARGV.size > 0 ? ARGV : $stdin).each do |s|
-      main(conn, from_druid(s.strip, flags), flags)
+    raise OptionParser::MissingArgument, "At least one druid required" if args.size == 0
+
+    args.each do |s|
+      druid = DruidTools::Druid.new(s.strip, flags[:workspacedir])
+      puts "Processing #{druid.id}" if flags[:verbose]
+      main(druid2layer(druid, flags), flags)
+    end
   end
-end
+end
+
+# __MAIN__
+LoaderPostGIS.new.run(ARGV)