geo_works 0.1.0

data/spec/processors/geo_works/processors/base_geo_processor_spec.rb

@@ -0,0 +1,115 @@
+require 'spec_helper'
+
+describe GeoWorks::Processors::BaseGeoProcessor do
+  before do
+    class TestProcessor
+      include GeoWorks::Processors::BaseGeoProcessor
+      include GeoWorks::Processors::Gdal
+      def directives
+      end
+
+      def source_path
+      end
+    end
+
+    allow(subject).to receive(:directives).and_return(directives)
+    allow(subject).to receive(:source_path).and_return(file_name)
+  end
+
+  after { Object.send(:remove_const, :TestProcessor) }
+
+  subject { TestProcessor.new }
+
+  let(:directives) { { format: 'png', size: '200x400' } }
+  let(:output_file_jpg) { 'output/geo.jpg' }
+  let(:output_file_png) { 'output/geo.png' }
+  let(:output_file) { output_file_png }
+  let(:file_name) { 'files/geo.tif' }
+  let(:options) { { output_size: '150 150' } }
+
+  describe '#run_commands' do
+    let(:method_queue) { [:translate, :warp, :compress] }
+    it 'calls the methods in the queue and cleans up temp files' do
+      expect(subject.class).to receive(:translate)
+      expect(subject.class).to receive(:warp)
+      expect(subject.class).to receive(:compress)
+      expect(FileUtils).to receive(:rm_rf).twice
+      subject.class.run_commands(file_name, output_file, method_queue, options)
+    end
+  end
+
+  describe '#temp_path' do
+    it 'returns a path to a temporary file based on the input file' do
+      expect(subject.class.temp_path(output_file))
+        .to match(%r{output/geo_\d+})
+    end
+  end
+
+  describe '#label' do
+    context 'when directives hash has a label value' do
+      let(:directives) { { label: :thumbnail } }
+      it 'returns the label' do
+        expect(subject.label).to eq(:thumbnail)
+      end
+    end
+
+    context 'when directives hash does not have label value' do
+      it 'returns an empty string' do
+        expect(subject.label).to eq('')
+      end
+    end
+  end
+
+  describe '#output_size' do
+    context 'when given a size string with an x' do
+      it 'returns a size string with a space instead' do
+        expect(subject.output_size).to eq('200 400')
+      end
+    end
+  end
+
+  describe '#output_srid' do
+    context 'when directives hash has an srid value' do
+      let(:directives) { { srid: 'EPSG:26918' } }
+      it 'returns that value' do
+        expect(subject.output_srid).to eq('EPSG:26918')
+      end
+    end
+
+    context 'when directives hash does not have an srid value' do
+      it 'returns that the default srid' do
+        expect(subject.output_srid).to eq('EPSG:4326')
+      end
+    end
+  end
+
+  describe '#id' do
+    context 'when directives hash has an id value' do
+      let(:directives) { { id: '123456' } }
+      it 'returns that value' do
+        expect(subject.id).to eq('123456')
+      end
+    end
+
+    context 'when directives hash does not have an id value' do
+      it 'returns nil' do
+        expect(subject.id).to be_nil
+      end
+    end
+  end
+
+  describe '#basename' do
+    it 'returns the base file name of the source file' do
+      expect(subject.basename).to eq('geo')
+    end
+  end
+
+  describe '#options_for' do
+    it 'returns a hash that includes output size and format' do
+      expect(subject.options_for("a")).to include(:output_size,
+                                                  :label,
+                                                  :output_srid,
+                                                  :basename)
+    end
+  end
+end

data/spec/processors/geo_works/processors/gdal_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+
+describe GeoWorks::Processors::BaseGeoProcessor do
+  before do
+    class TestProcessor
+      include Hydra::Derivatives::Processors::ShellBasedProcessor
+      include GeoWorks::Processors::Gdal
+      def directives
+      end
+
+      def source_path
+      end
+    end
+
+    allow(subject).to receive(:directives).and_return(directives)
+    allow(subject).to receive(:source_path).and_return(file_name)
+  end
+
+  after { Object.send(:remove_const, :TestProcessor) }
+
+  subject { TestProcessor.new }
+
+  let(:directives) { { format: 'png', size: '200x400' } }
+  let(:output_file) { 'output/geo.png' }
+  let(:file_name) { 'files/geo.tif' }
+  let(:options) { { output_size: '150 150', output_srid: 'EPSG:4326' } }
+
+  describe '#translate' do
+    it 'executes a gdal_translate command' do
+      command = "gdal_translate -q -ot Byte -of GTiff \"files/geo.tif\" output/geo.png"
+      expect(subject.class).to receive(:execute).with command
+      subject.class.translate(file_name, output_file, options)
+    end
+  end
+
+  describe '#warp' do
+    it 'executes a reproject command' do
+      command = "gdalwarp -q -r bilinear -t_srs EPSG:4326 files/geo.tif output/geo.png -co 'COMPRESS=NONE'"
+      expect(subject.class).to receive(:execute).with command
+      subject.class.warp(file_name, output_file, options)
+    end
+  end
+
+  describe '#compress' do
+    it 'returns a gdal_translate command with a compress option' do
+      command = "gdal_translate -q -ot Byte -a_srs EPSG:4326 files/geo.tif output/geo.png -co 'COMPRESS=LZW'"
+      expect(subject.class).to receive(:execute).with command
+      subject.class.compress(file_name, output_file, options)
+    end
+  end
+
+  describe '#rasterize' do
+    it 'executes a rasterize command' do
+      command = "gdal_rasterize -q -burn 0 -init 255 -ot Byte -ts 150 150 -of GTiff files/geo.tif output/geo.png"
+      expect(subject.class).to receive(:execute).with command
+      subject.class.rasterize(file_name, output_file, options)
+    end
+  end
+end

data/spec/processors/geo_works/processors/image_spec.rb

@@ -0,0 +1,64 @@
+require 'spec_helper'
+
+describe GeoWorks::Processors::Image do
+  before do
+    class TestProcessor
+      include GeoWorks::Processors::Image
+    end
+  end
+
+  after { Object.send(:remove_const, :TestProcessor) }
+
+  subject { TestProcessor.new }
+
+  let(:shell) { double }
+  let(:output_file_png) { 'output/geo.png' }
+  let(:output_file) { output_file_png }
+  let(:file_name) { 'files/geo.tif' }
+  let(:options) { { output_size: '150 150' } }
+
+  describe '#convert' do
+    let(:args) {
+      [['convert', 'files/geo.tif', '-resize', '150x150', '-extent',
+        '150x150', '-background', 'white', '-gravity', 'center',
+        'output/geo.png'], { whiny: false, stderr: false }]
+    }
+
+    before do
+      allow(MiniMagick::Shell).to receive(:new).and_return(shell)
+    end
+
+    it 'transforms the image and saves it as a PNG' do
+      expect(shell).to receive(:run).with(*args).and_return('output message')
+      subject.class.convert(file_name, output_file_png, options)
+    end
+  end
+
+  describe '#trim' do
+    let(:args) { [['convert', 'files/geo.tif', '-trim', 'output/geo.png'], { whiny: true }] }
+
+    before do
+      allow(MiniMagick::Shell).to receive(:new).and_return(shell)
+    end
+    it 'transforms the image and saves it as a PNG' do
+      expect(shell).to receive(:run).with(*args).and_return('output message')
+      subject.class.trim(file_name, output_file_png, options)
+    end
+  end
+
+  describe '#center' do
+    let(:args) {
+      [['convert', '-size', '150x150', 'xc:white', 'files/geo.tif',
+        '-gravity', 'center', '-composite', 'output/geo.png'],
+       { whiny: true }]
+    }
+
+    before do
+      allow(MiniMagick::Shell).to receive(:new).and_return(shell)
+    end
+    it 'transforms the image and saves it as a PNG' do
+      expect(shell).to receive(:run).with(*args).and_return('output message')
+      subject.class.center(file_name, output_file_png, options)
+    end
+  end
+end

data/spec/processors/geo_works/processors/ogr_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+describe GeoWorks::Processors::BaseGeoProcessor do
+  before do
+    class TestProcessor
+      include Hydra::Derivatives::Processors::ShellBasedProcessor
+      include GeoWorks::Processors::Ogr
+      def directives
+      end
+
+      def source_path
+      end
+    end
+
+    allow(subject).to receive(:directives).and_return(directives)
+    allow(subject).to receive(:source_path).and_return(file_name)
+  end
+
+  after { Object.send(:remove_const, :TestProcessor) }
+
+  subject { TestProcessor.new }
+
+  let(:directives) { { format: 'png', size: '200x400' } }
+  let(:output_file) { 'output/geo.png' }
+  let(:file_name) { 'files/geo.zip' }
+  let(:options) { { output_size: '150 150', output_srid: 'EPSG:4326' } }
+
+  describe '#reproject' do
+    it 'executes a reproject command' do
+      command = "env SHAPE_ENCODING= ogr2ogr -q -nln  -f 'ESRI Shapefile' "\
+                  "-t_srs EPSG:4326 -preserve_fid 'output/geo.png' 'files/geo.zip'"
+      expect(subject.class).to receive(:execute).with command
+      subject.class.reproject(file_name, output_file, options)
+    end
+  end
+end

data/spec/processors/geo_works/processors/raster/aig_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+describe GeoWorks::Processors::Raster::Aig do
+  let(:output_file) { 'output/geo.png' }
+  let(:file_name) { 'files/aig.zip' }
+  let(:options) { { output_size: '150 150',
+                    min_max: '2.054 11.717',
+                    label: :thumbnail }
+  }
+
+  subject { described_class.new(file_name, {}) }
+
+  describe '#translate' do
+    it 'executes a gdal_translate command with scaling' do
+      command = "gdal_translate -scale 2.054 11.717 255 0 -q -ot Byte -of "\
+                  "GTiff \"files/aig.zip\" output/geo.png"
+      expect(subject.class).to receive(:execute).with command
+      subject.class.translate(file_name, output_file, options)
+    end
+  end
+
+  describe '#reproject_queue' do
+    it 'returns an array of command name symbols' do
+      expect(subject.class.reproject_queue).to include :warp
+    end
+  end
+
+  describe '#encode' do
+    it 'wraps encode_raster in an unzip block' do
+      allow(subject.class).to receive(:unzip).and_yield(file_name)
+      expect(subject.class).to receive(:encode_raster)
+      subject.class.encode(file_name, options, output_file)
+    end
+  end
+end

data/spec/processors/geo_works/processors/raster/base_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+
+describe GeoWorks::Processors::Raster::Base do
+  let(:output_file) { 'output/geo.png' }
+  let(:file_name) { 'files/geo.tif' }
+  let(:label) {}
+  let(:options) { { output_size: '150 150', label: label } }
+
+  subject { described_class.new(file_name, {}) }
+
+  describe '#encode' do
+    context 'when output label is thumbnail' do
+      let(:label) { :thumbnail }
+      it 'calls the encode_raster method' do
+        expect(subject.class).to receive(:encode_raster)
+        subject.class.encode(file_name, options, output_file)
+      end
+    end
+
+    context 'when output label is display_raster' do
+      let(:label) { :display_raster }
+      it 'calls the reproject_raster method' do
+        expect(subject.class).to receive(:reproject_raster)
+        subject.class.encode(file_name, options, output_file)
+      end
+    end
+  end
+
+  describe '#encode_queue' do
+    it 'returns an array of command name symbols' do
+      expect(subject.class.encode_queue).to include :translate
+    end
+  end
+
+  describe '#reproject_queue' do
+    it 'returns an array of command name symbols' do
+      expect(subject.class.reproject_queue).to include :warp
+    end
+  end
+
+  describe '#encode_raster' do
+    it 'runs commands to encode the raster thumbnail' do
+      expect(subject.class).to receive(:run_commands)
+      subject.class.encode_raster(file_name, options, output_file)
+    end
+  end
+
+  describe '#reproject_raster' do
+    it 'runs commands to reproject the raster' do
+      expect(subject.class).to receive(:run_commands)
+      subject.class.reproject_raster(file_name, options, output_file)
+    end
+  end
+end

data/spec/processors/geo_works/processors/raster/dem_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+describe GeoWorks::Processors::Raster::Dem do
+  let(:output_file) { 'output/geo.png' }
+  let(:file_name) { 'files/geo.dem' }
+  let(:options) { { output_size: '150 150', label: :thumbnail }
+  }
+
+  subject { described_class.new(file_name, {}) }
+
+  describe '#encode_queue' do
+    it 'returns an array of command name symbols' do
+      expect(subject.class.encode_queue).to include :hillshade
+    end
+  end
+
+  describe '#reproject_queue' do
+    it 'returns an array of command name symbols' do
+      expect(subject.class.reproject_queue).to include :hillshade
+    end
+  end
+
+  describe '#hillshade' do
+    it 'executes a gdal hillshade command' do
+      command = "gdaldem hillshade -q -of GTiff \"files/geo.dem\" output/geo.png"
+      expect(subject.class).to receive(:execute).with command
+      subject.class.hillshade(file_name, output_file, options)
+    end
+  end
+end

data/spec/processors/geo_works/processors/raster/info_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+require 'open3'
+
+describe GeoWorks::Processors::Raster::Info do
+  let(:path) { 'test.tif' }
+  let(:info_doc) { read_test_data_fixture('gdalinfo.txt') }
+
+  subject { described_class.new(path) }
+
+  context 'when initializing a new info class' do
+    it 'shells out to gdalinfo and sets the doc variable to the output string' do
+      expect(Open3).to receive(:capture3).with("gdalinfo -mm #{path}")
+        .and_return([info_doc, '', ''])
+      expect(subject.doc).to eq(info_doc)
+    end
+  end
+
+  context 'after intialization' do
+    before do
+      allow(subject).to receive(:doc).and_return(info_doc)
+    end
+
+    describe '#min_max' do
+      it 'returns with min and max values' do
+        expect(subject.min_max).to eq('354.000 900.000')
+      end
+    end
+
+    describe '#size' do
+      it 'returns raster size' do
+        expect(subject.size).to eq('310 266')
+      end
+    end
+  end
+end

data/spec/processors/geo_works/processors/raster/processor_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+describe GeoWorks::Processors::Raster::Processor do
+  subject { described_class.new(file_name, directives) }
+  let(:processor) { double }
+
+  context 'when a usgs ascii dem format type is passed' do
+    let(:file_name) { 'files/geo.dem' }
+    let(:directives) { { input_format: 'text/plain; gdal-format=USGSDEM' } }
+
+    it 'calls the DEM processor' do
+      expect(GeoWorks::Processors::Raster::Dem).to receive(:new).and_return(processor)
+      expect(processor).to receive(:process)
+      subject.process
+    end
+  end
+
+  context 'when an Arc/Info Binary Grid format type is passed' do
+    let(:file_name) { 'files/aig.zip' }
+    let(:directives) { { input_format: 'application/octet-stream; gdal-format=AIG' } }
+
+    it 'calls the AIG processor' do
+      expect(GeoWorks::Processors::Raster::Aig).to receive(:new).and_return(processor)
+      expect(processor).to receive(:process)
+      subject.process
+    end
+  end
+
+  context 'when a GeoTIFF format type is passed' do
+    let(:file_name) { 'files/geo.tif' }
+    let(:directives) { { input_format: 'image/tiff; gdal-format=GTiff' } }
+
+    it 'calls the base raster processor' do
+      expect(GeoWorks::Processors::Raster::Base).to receive(:new).and_return(processor)
+      expect(processor).to receive(:process)
+      subject.process
+    end
+  end
+end