geoserver-publish 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 408b468e3035e6cc2936098828b02cb17ea2229a
+  data.tar.gz: c59d7fc39f5e862432cb4ccdfd71809015cba20a
+SHA512:
+  metadata.gz: 4cd36658509fda089b6320ae089f3218834149a506142ffe40e14332e3743534bfd63e59bd478d5491ad8b6bb782ebde8e6cca626d4a5a4827f3c2df986730cb
+  data.tar.gz: 7a3e123c4a42b73e7cd3272807996adc60b56df0f2f71f94c783654f012e01d39d35403325ce0fb6ec7ac5198ee333623ba14f55b4d742d470436fc3e2fde6e5

data/.gitignore

@@ -0,0 +1,11 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+.byebug_history
+.rspec_status
+Gemfile.lock

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,17 @@
+inherit_gem:
+  bixby: bixby_default.yml
+AllCops:
+  DisplayCopNames: true
+  TargetRubyVersion: 2.4
+  Exclude:
+    - 'bin/*'
+Metrics/BlockLength:
+  Exclude:
+    - 'spec/**/*'
+    - '*.gemspec'
+Naming/FileName:
+  Exclude: 
+    - "geoserver-publish.gemspec"
+    - "Gemfile"
+Style/StringLiterals:
+  EnforcedStyle: double_quotes

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.4.2
+before_install: gem install bundler -v 1.16.1

data/Gemfile

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+source "https://rubygems.org"
+
+git_source(:github) { |repo_name| "https://github.com/#{repo_name}" }
+
+gemspec
+
+group :development, :test do
+  gem "bixby", require: false
+  gem "coveralls", require: false
+  gem "simplecov", require: false
+end
+
+group :test do
+  gem "webmock"
+end

data/LICENSE.txt

@@ -0,0 +1,15 @@
+##########################################################################
+# Copyright 2018 Princeton University Library
+# Additional copyright may be held by others, as reflected in the commit log
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.

data/README.md

@@ -0,0 +1,81 @@
+# Geoserver::Publish
+
+[![Build Status](https://img.shields.io/travis/pulibrary/geoserver-publish/master.svg)](https://travis-ci.org/pulibrary/geoserver-publish)
+[![Coverage Status](https://img.shields.io/coveralls/pulibrary/geoserver-publish/master.svg)](https://coveralls.io/github/pulibrary/geoserver-publish?branch=master)
+
+Simple client for publishing Shapefiles and GeoTIFFs to Geoserver.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'geoserver-publish'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install geoserver-publish
+
+## Usage
+
+#### GeoTIFF
+
+```ruby
+Geoserver::Publish.geotiff(workspace_name: "public", file_path: "file:///path/on/geoserver/raster.tif", id: "1234", title: "GeoTiff Title")
+```
+
+#### Shapefile
+
+Because of a limitation in GeoServer, the layer id  must be the same name as the shapefile without the extenstion. For example, if the file name is `1234.shp`, the id must be `1234`.
+
+```ruby
+Geoserver::Publish.shapefile(workspace_name: "public", file_path: "file:///path/on/geoserver/1234.shp", id: "1234", title: "Shapefile Title")
+```
+
+#### Deleting
+
+```Ruby
+Geoserver::Publish.delete_geotiff(workspace_name: "public", id: "1234")
+Geoserver::Publish.delete_shapefile(workspace_name: "public", id: "1234")
+```
+
+## Configuration
+
+#### Default
+
+To use the default GeoServer connection parameters, no further configuration is needed. These are useful for testing and development against a local GeoServer instance.
+
+ - url: http://localhost:8080/geoserver/rest
+ - user: admin
+ - password: geoserver
+
+
+#### Environment Variables
+
+GeoServer Connection parameters can be set using environment variables.
+
+  - GEOSERVER_URL
+  - GEOSERVER_USER
+  - GEOSERVER_PASSWORD
+
+#### Connection Object
+
+A connection object can be instantiated with a parameter hash and passed into publishing methods.
+
+```ruby
+new_conn = Geoserver::Publish::Connection.new({"url"=> "http://mygeoserver.com:8181/geoserver/rest", "user" => "admin_user", "password" => "supersecret"})
+Geoserver::Publish.geotiff(connection: new_conn, workspace_name: "public", file_path: "file:///path/on/geoserver/raster.tif", id: "1234", title: "GeoTiff Title")
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/pulibrary/geoserver-publish.

data/Rakefile

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "geoserver/publish"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/config/config.yml

@@ -0,0 +1,4 @@
+geoserver:
+  url: <%= ENV['GEOSERVER_URL'] || "http://localhost:8080/geoserver/rest" %>
+  user: <%= ENV['GEOSERVER_USER'] || "admin" %>
+  password: <%= ENV['GEOSERVER_PASSWORD'] || "geoserver" %>

data/geoserver-publish.gemspec

@@ -0,0 +1,31 @@
+
+# frozen_string_literal: true
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "geoserver/publish/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "geoserver-publish"
+  spec.version       = Geoserver::Publish::VERSION
+  spec.authors       = ["Eliot Jordan"]
+  spec.email         = ["eliotj@princeton.edu"]
+
+  spec.summary       = "Simple client for publishing Shapefiles and GeoTIFFs to Geoserver"
+  spec.description   = "Simple client for publishing Shapefiles and GeoTIFFs to Geoserver"
+  spec.homepage      = "https://github.com/pulibrary/geoserver-publish"
+  spec.license       = "Apache-2.0"
+
+  spec.files = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "faraday"
+
+  spec.add_development_dependency "bundler", "~> 1.16"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+end

data/lib/geoserver/publish.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+require "erb"
+require "faraday"
+require "json"
+require "yaml"
+
+module Geoserver
+  module Publish
+    require "geoserver/publish/config"
+    require "geoserver/publish/connection"
+    require "geoserver/publish/coverage"
+    require "geoserver/publish/coverage_store"
+    require "geoserver/publish/create"
+    require "geoserver/publish/data_store"
+    require "geoserver/publish/feature_type"
+    require "geoserver/publish/version"
+    require "geoserver/publish/workspace"
+
+    def self.delete_geotiff(workspace_name:, id:, connection: nil)
+      CoverageStore.new(connection).delete(workspace_name: workspace_name, coverage_store_name: id)
+    end
+
+    def self.delete_shapefile(workspace_name:, id:, connection: nil)
+      DataStore.new(connection).delete(workspace_name: workspace_name, data_store_name: id)
+    end
+
+    def self.geotiff(workspace_name:, file_path:, id:, title: nil, connection: nil)
+      create_workspace(workspace_name: workspace_name, connection: connection)
+      create_coverage_store(workspace_name: workspace_name, coverage_store_name: id, url: file_path, connection: connection)
+      create_coverage(workspace_name: workspace_name, coverage_store_name: id, coverage_name: id, title: title, connection: connection)
+    end
+
+    def self.shapefile(workspace_name:, file_path:, id:, title: nil, connection: nil)
+      create_workspace(workspace_name: workspace_name, connection: connection)
+      create_data_store(workspace_name: workspace_name, data_store_name: id, url: file_path, connection: connection)
+      create_feature_type(workspace_name: workspace_name, data_store_name: id, feature_type_name: id, title: title, connection: connection)
+    end
+
+    def self.root
+      Pathname.new(File.expand_path("../../../", __FILE__))
+    end
+
+    class Error < StandardError
+    end
+  end
+end

data/lib/geoserver/publish/config.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+module Geoserver
+  module Publish
+    def config
+      @config ||= config_yaml
+    end
+
+    private
+
+      def config_yaml
+        file_path = File.join(Geoserver::Publish.root, "config", "config.yml")
+        YAML.safe_load(ERB.new(File.read(file_path)).result, [], [], true)
+      end
+
+      module_function :config, :config_yaml
+  end
+end

data/lib/geoserver/publish/connection.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+module Geoserver
+  module Publish
+    class Connection
+      attr_reader :config
+
+      def initialize(config = nil)
+        @config = config || Geoserver::Publish.config["geoserver"]
+      end
+
+      def delete(path:)
+        response = faraday_connection.delete do |req|
+          req.url path
+          req.params["recurse"] = "true"
+        end
+        return true if response.status == 200
+        raise Geoserver::Publish::Error, response.reason_phrase
+      end
+
+      def get(path:)
+        response = faraday_connection.get do |req|
+          req.url path
+          req.headers["Accept"] = "application/json"
+        end
+        response.body if response.status == 200
+      end
+
+      def post(path:, payload:)
+        response = faraday_connection.post do |req|
+          req.url path
+          req.headers["Content-Type"] = "application/json"
+          req.body = payload
+        end
+        return true if response.status == 201 || response.status == 401
+        raise Geoserver::Publish::Error, response.reason_phrase
+      end
+
+      private
+
+        def faraday_connection
+          Faraday.new(url: config["url"]) do |conn|
+            conn.adapter Faraday.default_adapter
+            conn.basic_auth(config["user"], config["password"]) if config["user"]
+          end
+        end
+    end
+  end
+end

data/lib/geoserver/publish/coverage.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+module Geoserver
+  module Publish
+    class Coverage
+      attr_reader :connection
+
+      def initialize(conn = nil)
+        @connection = conn || Geoserver::Publish::Connection.new
+      end
+
+      def delete(workspace_name:, coverage_store_name:, coverage_name:)
+        path = coverage_url(workspace_name: workspace_name, coverage_store_name: coverage_store_name, coverage_name: coverage_name)
+        connection.delete(path: path)
+      end
+
+      def find(workspace_name:, coverage_store_name:, coverage_name:)
+        path = coverage_url(workspace_name: workspace_name, coverage_store_name: coverage_store_name, coverage_name: coverage_name)
+        out = connection.get(path: path)
+        JSON.parse(out) if out
+      end
+
+      def create(workspace_name:, coverage_store_name:, coverage_name:, title:)
+        path = coverage_url(workspace_name: workspace_name, coverage_store_name: coverage_store_name, coverage_name: nil)
+        payload = payload_new(coverage_name: coverage_name, title: title)
+        connection.post(path: path, payload: payload)
+      end
+
+      private
+
+        def coverage_url(workspace_name:, coverage_store_name:, coverage_name:)
+          last_path_component = coverage_name ? "/#{coverage_name}" : ""
+          "workspaces/#{workspace_name}/coveragestores/#{coverage_store_name}/coverages#{last_path_component}"
+        end
+
+        def payload_new(coverage_name:, title:)
+          {
+            coverage: {
+              enabled: true,
+              name: coverage_name,
+              title: title
+            }
+          }.to_json
+        end
+    end
+  end
+end

data/lib/geoserver/publish/coverage_store.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+module Geoserver
+  module Publish
+    class CoverageStore
+      attr_reader :connection
+
+      def initialize(conn = nil)
+        @connection = conn || Geoserver::Publish::Connection.new
+      end
+
+      def delete(workspace_name:, coverage_store_name:)
+        path = coverage_store_url(workspace_name: workspace_name, coverage_store_name: coverage_store_name)
+        connection.delete(path: path)
+      end
+
+      def find(workspace_name:, coverage_store_name:)
+        path = coverage_store_url(workspace_name: workspace_name, coverage_store_name: coverage_store_name)
+        out = connection.get(path: path)
+        JSON.parse(out) if out
+      end
+
+      def create(workspace_name:, coverage_store_name:, url:, type: "GeoTIFF")
+        path = coverage_store_url(workspace_name: workspace_name, coverage_store_name: nil)
+        payload = payload_new(workspace_name: workspace_name, coverage_store_name: coverage_store_name, url: url, type: type)
+        connection.post(path: path, payload: payload)
+      end
+
+      private
+
+        def coverage_store_url(workspace_name:, coverage_store_name:)
+          last_path_component = coverage_store_name ? "/#{coverage_store_name}" : ""
+          "workspaces/#{workspace_name}/coveragestores#{last_path_component}"
+        end
+
+        def payload_new(workspace_name:, coverage_store_name:, type:, url:)
+          {
+            coverageStore: {
+              name: coverage_store_name,
+              url: url,
+              enabled: true,
+              workspace: {
+                name: workspace_name
+              },
+              type: type,
+              _default: false
+            }
+          }.to_json
+        end
+    end
+  end
+end

data/lib/geoserver/publish/create.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Geoserver
+  module Publish
+    def create_coverage_store(workspace_name:, coverage_store_name:, url:, connection: nil)
+      return if CoverageStore.new(connection).find(workspace_name: workspace_name, coverage_store_name: coverage_store_name)
+      CoverageStore.new(connection).create(workspace_name: workspace_name, coverage_store_name: coverage_store_name, url: url)
+    end
+
+    def create_coverage(workspace_name:, coverage_store_name:, coverage_name:, title:, connection: nil)
+      return if Coverage.new(connection).find(workspace_name: workspace_name, coverage_store_name: coverage_store_name, coverage_name: coverage_name)
+      Coverage.new(connection).create(workspace_name: workspace_name, coverage_store_name: coverage_store_name, coverage_name: coverage_name, title: title)
+    end
+
+    def create_data_store(workspace_name:, data_store_name:, url:, connection: nil)
+      return if DataStore.new(connection).find(workspace_name: workspace_name, data_store_name: data_store_name)
+      DataStore.new(connection).create(workspace_name: workspace_name, data_store_name: data_store_name, url: url)
+    end
+
+    def create_feature_type(workspace_name:, data_store_name:, feature_type_name:, title:, connection: nil)
+      return if FeatureType.new(connection).find(workspace_name: workspace_name, data_store_name: data_store_name, feature_type_name: feature_type_name)
+      FeatureType.new(connection).create(workspace_name: workspace_name, data_store_name: data_store_name, feature_type_name: feature_type_name, title: title)
+    end
+
+    def create_workspace(workspace_name:, connection: nil)
+      return if Workspace.new(connection).find(workspace_name: workspace_name)
+      Workspace.new(connection).create(workspace_name: workspace_name)
+    end
+
+    module_function :create_coverage_store, :create_coverage, :create_data_store, :create_feature_type, :create_workspace
+  end
+end

data/lib/geoserver/publish/data_store.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+module Geoserver
+  module Publish
+    class DataStore
+      attr_reader :connection
+
+      def initialize(conn = nil)
+        @connection = conn || Geoserver::Publish::Connection.new
+      end
+
+      def delete(workspace_name:, data_store_name:)
+        path = data_store_url(workspace_name: workspace_name, data_store_name: data_store_name)
+        connection.delete(path: path)
+      end
+
+      def find(workspace_name:, data_store_name:)
+        path = data_store_url(workspace_name: workspace_name, data_store_name: data_store_name)
+        out = connection.get(path: path)
+        JSON.parse(out) if out
+      end
+
+      def create(workspace_name:, data_store_name:, url:)
+        path = data_store_url(workspace_name: workspace_name, data_store_name: nil)
+        payload = payload_new(data_store_name: data_store_name, url: url)
+        connection.post(path: path, payload: payload)
+      end
+
+      private
+
+        def data_store_url(workspace_name:, data_store_name:)
+          last_path_component = data_store_name ? "/#{data_store_name}" : ""
+          "workspaces/#{workspace_name}/datastores#{last_path_component}"
+        end
+
+        # rubocop:disable Metrics/MethodLength
+        def payload_new(data_store_name:, url:)
+          {
+            dataStore: {
+              name: data_store_name,
+              connectionParameters: {
+                entry: [
+                  {
+                    "@key": "create spatial index",
+                    "$": "true"
+                  },
+                  {
+                    "@key": "url",
+                    "$": url
+                  },
+                  {
+                    "@key": "cache and reuse memory maps",
+                    "$": "false"
+                  }
+                ]
+              }
+            }
+          }.to_json
+        end
+      # rubocop:enable Metrics/MethodLength
+    end
+  end
+end

data/lib/geoserver/publish/feature_type.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+module Geoserver
+  module Publish
+    class FeatureType
+      attr_reader :connection
+
+      def initialize(conn = nil)
+        @connection = conn || Geoserver::Publish::Connection.new
+      end
+
+      def delete(workspace_name:, data_store_name:, feature_type_name:)
+        path = feature_type_url(workspace_name: workspace_name, data_store_name: data_store_name, feature_type_name: feature_type_name)
+        connection.delete(path: path)
+      end
+
+      def find(workspace_name:, data_store_name:, feature_type_name:)
+        path = feature_type_url(workspace_name: workspace_name, data_store_name: data_store_name, feature_type_name: feature_type_name)
+        out = connection.get(path: path)
+        JSON.parse(out) if out
+      end
+
+      # Feature type name must be the same name as the shapefile without the extenstion.
+      # E.g. If the file is `12345.shp`, then feature_type_name = "12345".
+      def create(workspace_name:, data_store_name:, feature_type_name:, title:)
+        path = feature_type_url(workspace_name: workspace_name, data_store_name: data_store_name, feature_type_name: nil)
+        payload = payload_new(feature_type_name: feature_type_name, title: title)
+        connection.post(path: path, payload: payload)
+      end
+
+      private
+
+        def feature_type_url(workspace_name:, data_store_name:, feature_type_name:)
+          last_path_component = feature_type_name ? "/#{feature_type_name}" : ""
+          "workspaces/#{workspace_name}/datastores/#{data_store_name}/featuretypes#{last_path_component}"
+        end
+
+        def payload_new(feature_type_name:, title:)
+          {
+            featureType: {
+              name: feature_type_name,
+              title: title,
+              enabled: true
+            }
+          }.to_json
+        end
+    end
+  end
+end

data/lib/geoserver/publish/version.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+module Geoserver
+  module Publish
+    VERSION = "0.2.0"
+  end
+end

data/lib/geoserver/publish/workspace.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+module Geoserver
+  module Publish
+    class Workspace
+      attr_reader :connection
+
+      def initialize(conn = nil)
+        @connection = conn || Geoserver::Publish::Connection.new
+      end
+
+      def delete(workspace_name:)
+        path = workspace_url(workspace_name: workspace_name)
+        connection.delete(path: path)
+      end
+
+      def find(workspace_name:)
+        path = workspace_url(workspace_name: workspace_name)
+        out = connection.get(path: path)
+        JSON.parse(out) if out
+      end
+
+      def create(workspace_name:)
+        path = workspace_url(workspace_name: nil)
+        connection.post(path: path, payload: payload_new(workspace_name: workspace_name))
+      end
+
+      private
+
+        def payload_new(workspace_name:)
+          {
+            workspace: {
+              name: workspace_name
+            }
+          }.to_json
+        end
+
+        def workspace_url(workspace_name:)
+          last_path_component = workspace_name ? "/#{workspace_name}" : ""
+          "workspaces#{last_path_component}"
+        end
+    end
+  end
+end

metadata

@@ -0,0 +1,122 @@
+--- !ruby/object:Gem::Specification
+name: geoserver-publish
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- Eliot Jordan
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2018-03-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: Simple client for publishing Shapefiles and GeoTIFFs to Geoserver
+email:
+- eliotj@princeton.edu
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- config/config.yml
+- geoserver-publish.gemspec
+- lib/geoserver/publish.rb
+- lib/geoserver/publish/config.rb
+- lib/geoserver/publish/connection.rb
+- lib/geoserver/publish/coverage.rb
+- lib/geoserver/publish/coverage_store.rb
+- lib/geoserver/publish/create.rb
+- lib/geoserver/publish/data_store.rb
+- lib/geoserver/publish/feature_type.rb
+- lib/geoserver/publish/version.rb
+- lib/geoserver/publish/workspace.rb
+homepage: https://github.com/pulibrary/geoserver-publish
+licenses:
+- Apache-2.0
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.14
+signing_key: 
+specification_version: 4
+summary: Simple client for publishing Shapefiles and GeoTIFFs to Geoserver
+test_files: []