archivesspace-client 0.1.6 → 0.1.10

data/lib/archivesspace/client/configuration.rb

@@ -1,16 +1,17 @@
-module ArchivesSpace
+# frozen_string_literal: true
 
+module ArchivesSpace
   class Configuration
-
     def defaults
       {
-        base_uri: "http://localhost:8089",
-        base_repo: "",
-        username: "admin",
-        password: "admin",
+        base_uri: 'http://localhost:8089',
+        base_repo: '',
+        debug: false,
+        username: 'admin',
+        password: 'admin',
         page_size: 50,
         throttle: 0,
-        verify_ssl: true,
+        verify_ssl: true
       }
     end
 
@@ -18,11 +19,10 @@ module ArchivesSpace
       settings = defaults.merge(settings)
       settings.each do |property, value|
         next unless defaults.keys.include? property
+
         instance_variable_set("@#{property}", value)
         self.class.send(:attr_accessor, property)
       end
     end
-
   end
-
-end
+end

data/lib/archivesspace/client/pagination.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module ArchivesSpace
+  # Handle API Pagination using enumerator
+  module Pagination
+    # TODO: get via lookup of endpoints that support pagination? (nice-to-have)
+    ENDPOINTS = %w[
+      accessions
+      agents/corporate_entities
+      agents/families
+      agents/people
+      agents/software
+      archival_objects
+      digital_objects
+      groups
+      repositiories
+      resources
+      subjects
+      users
+    ]
+
+    ENDPOINTS.each do |endpoint|
+      method_name = endpoint.split('/').last # remove prefix
+      define_method(method_name) do |options = {}|
+        all(endpoint, options)
+      end
+    end
+
+    def all(path, options = {})
+      Enumerator.new do |yielder|
+        page = 1
+        unlimited_listing = false
+        loop do
+          options[:query] ||= {}
+          options[:query][:page] = page
+          result = get(path, options)
+          results = []
+
+          if result.parsed.respond_to?(:key) && result.parsed.key?('results')
+            results = result.parsed['results']
+          else
+            results = result.parsed
+            unlimited_listing = true
+          end
+
+          if results.any?
+            results.each do |i|
+              yielder << i
+            end
+            raise StopIteration if unlimited_listing
+
+            page += 1
+          else
+            raise StopIteration
+          end
+        end
+      end.lazy
+    end
+  end
+end

data/lib/archivesspace/client/request.rb

@@ -1,5 +1,6 @@
-module ArchivesSpace
+# frozen_string_literal: true
 
+module ArchivesSpace
   class Request
     include HTTParty
     attr_reader :config, :headers, :method, :path, :options
@@ -9,37 +10,34 @@ module ArchivesSpace
         delete: {},
         get: {},
         post: {
-          "Content-Type" => "application/json",
-          "Content-Length" => "nnnn",
+          'Content-Type' => 'application/json',
+          'Content-Length' => 'nnnn'
         },
         put: {
-          "Content-Type" => "application/json",
-          "Content-Length" => "nnnn",
+          'Content-Type' => 'application/json',
+          'Content-Length' => 'nnnn'
         }
       }
       headers[method]
     end
 
-    def initialize(config, method = "GET", path = "", options = {})
+    def initialize(config, method = 'GET', path = '', options = {})
       @config            = config
       @method            = method.downcase.to_sym
-      @path              = path.gsub(/^\/+/, '')
+      @path              = path.gsub(%r{^/+}, '')
       @options           = options
       @options[:headers] = options[:headers] ? default_headers(@method).merge(options[:headers]) : default_headers(@method)
       @options[:verify]  = config.verify_ssl
-      @options[:query]   = {} unless options.has_key? :query
+      @options[:query]   = {} unless options.key? :query
 
-      base_uri = (
-        config.base_repo.nil? or config.base_repo.empty?
-      ) ? config.base_uri : "#{config.base_uri}/#{config.base_repo}"
+      self.class.debug_output($stdout) if @config.debug
 
+      base_uri = config.base_repo&.length&.positive? ? File.join(config.base_uri, config.base_repo) : config.base_uri
       self.class.base_uri base_uri
     end
 
     def execute
       self.class.send method, "/#{path}", options
     end
-
   end
-
 end

data/lib/archivesspace/client/response.rb

@@ -1,10 +1,10 @@
-module ArchivesSpace
+# frozen_string_literal: true
 
+module ArchivesSpace
   class Response
-    attr_reader :result, :parsed, :body, :headers, :status, :status_code, :xml
+    attr_reader :result, :parsed, :body, :headers, :status, :status_code
 
     def initialize(result)
-      # throw error
       @result      = result
       @parsed      = result.parsed_response
       @body        = result.body
@@ -12,7 +12,5 @@ module ArchivesSpace
       @status      = result.response
       @status_code = result.code.to_i
     end
-
   end
-
-end
+end

data/lib/archivesspace/client/task.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module ArchivesSpace
+  # Perform specific API tasks
+  module Task
+    # def batch_import(payload, params = {})
+    #   # TODO: create "batch_import", payload, params
+    # end
+
+    def group_user_assignment(users_with_roles)
+      updated = []
+      groups.each do |group|
+        group = get("groups/#{uri_to_id(group['uri'])}").parsed
+        update = false
+
+        users_with_roles.each do |user, roles|
+          # should the user still belong to this group?
+          if group['member_usernames'].include?(user)
+            unless roles.include? group['group_code']
+              group['member_usernames'].delete user
+              update = true
+            end
+          # should the user be added to this group?
+          elsif roles.include? group['group_code']
+            group['member_usernames'] << user
+            update = true
+          end
+        end
+
+        next unless update
+
+        response = post("/groups/#{uri_to_id(group['uri'])}", group.to_json)
+        updated << response
+      end
+      updated
+    end
+
+    def login
+      username  = config.username
+      password  = config.password
+      base_repo = config.base_repo
+      use_global_repository # ensure we're in the global scope to login
+      result = request('POST', "/users/#{username}/login", { query: { password: password } })
+      unless result.parsed['session']
+        raise ConnectionError, "Failed to connect to ArchivesSpace backend as #{username} #{password}"
+      end
+
+      config.base_repo = base_repo # reset repo as set by the cfg
+      @token = result.parsed['session']
+      self
+    end
+
+    def password_reset(username, password)
+      user = all('users').find { |u| u['username'] == username }
+      raise RequestError, user.status unless user
+
+      post(user['uri'], user.to_json, { password: password })
+    end
+
+    # def search(params)
+    #   # TODO: get "search", params
+    # end
+
+    private
+
+    def uri_to_id(uri)
+      uri.split('/').last
+    end
+  end
+end

data/lib/archivesspace/client/template.rb

@@ -1,25 +1,26 @@
-module ArchivesSpace
+# frozen_string_literal: true
 
+module ArchivesSpace
   module Template
-
     def self.list
-      []
+      Dir.glob File.join(templates_path, '*.erb')
     end
 
-    def self.process_template(template, data)
-      t = ERB.new(self.read_template(template))
-      r = t.result(binding).gsub(/\n+/,"\n")
-      JSON.parse(r)
+    def self.process(template, data)
+      t = ERB.new(read(template))
+      r = t.result(binding).gsub(/\n+/, "\n")
+      JSON.parse(r).to_json
     end
 
-    def self.read_template(file)
-      File.read("#{self.templates_path}/#{file.to_s}.json.erb")
+    def self.read(file)
+      File.read("#{templates_path}/#{file}.json.erb")
     end
 
     def self.templates_path
-      File.join(File.dirname(File.expand_path(__FILE__)), 'templates')
+      ENV.fetch(
+        'ARCHIVESSPACE_CLIENT_TEMPLATES_PATH',
+        File.join(File.dirname(File.expand_path(__FILE__)), 'templates')
+      )
     end
-
   end
-
-end
+end

data/lib/archivesspace/client/version.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 module ArchivesSpace
   class Client
-    VERSION = "0.1.6"
+    VERSION = '0.1.10'
   end
 end

data/lib/archivesspace/client.rb

@@ -1,22 +1,34 @@
+# frozen_string_literal: true
+
+require 'dry/cli'
 require 'httparty'
 require 'json'
 require 'nokogiri'
 
 # mixins required first
-require "archivesspace/client/helpers"
+require 'archivesspace/client/pagination'
+require 'archivesspace/client/task'
+
+require 'archivesspace/client/client'
+require 'archivesspace/client/configuration'
+require 'archivesspace/client/request'
+require 'archivesspace/client/response'
+require 'archivesspace/client/template'
+require 'archivesspace/client/version'
 
-require "archivesspace/client/client"
-require "archivesspace/client/configuration"
-require "archivesspace/client/request"
-require "archivesspace/client/response"
-require "archivesspace/client/template"
-require "archivesspace/client/version"
+# cli
+require 'archivesspace/client/cli/exec'
+require 'archivesspace/client/cli/version'
+require 'archivesspace/client/cli' # load the registry last
 
 module ArchivesSpace
+  class ConnectionError < RuntimeError; end
+
+  class ContextError    < RuntimeError; end
+
+  class RepositoryIdError < RuntimeError; end
 
-  class ConnectionError < Exception ; end
-  class ContextError    < Exception ; end
-  class ParamsError     < Exception ; end
-  class RequestError    < Exception ; end
+  class ParamsError     < RuntimeError; end
 
-end
+  class RequestError    < RuntimeError; end
+end

data/spec/archivesspace/client_spec.rb

@@ -1,43 +1,90 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe ArchivesSpace::Client do
-
   let(:client) { ArchivesSpace::Client.new }
   let(:login)  { -> { client.login } }
 
-  describe "Configuration" do
-
+  describe 'Configuration' do
     it 'will use the default configuration if none is provided' do
       client = ArchivesSpace::Client.new
       expect(client.config.base_uri).to eq DEFAULT_BASE_URI
     end
 
     it 'will raise an error if supplied configuration is of invalid type' do
-      expect{ ArchivesSpace::Client.new({ base_uri: CUSTOM_BASE_URI }) }.to raise_error(RuntimeError)
+      expect { ArchivesSpace::Client.new({ base_uri: CUSTOM_BASE_URI }) }.to raise_error(RuntimeError)
     end
 
     it 'will allow a configuration object to be provided' do
       client = ArchivesSpace::Client.new(ArchivesSpace::Configuration.new({ base_uri: CUSTOM_BASE_URI }))
       expect(client.config.base_uri).to eq CUSTOM_BASE_URI
     end
+  end
+
+  describe 'Repository scoping' do
+    it 'will set the repository with an integer id' do
+      client = ArchivesSpace::Client.new
+      client.repository 2
+      expect(client.config.base_repo).to eq 'repositories/2'
+    end
+
+    it 'will set the repository with a string id cast to integer' do
+      client = ArchivesSpace::Client.new
+      client.repository '2'
+      expect(client.config.base_repo).to eq 'repositories/2'
+    end
+
+    it 'will fail if the id cannot be cast to integer' do
+      client = ArchivesSpace::Client.new
+      expect { client.repository('xyz') }.to raise_error(
+        ArchivesSpace::RepositoryIdError
+      )
+    end
+
+    it 'will use the global repo if repository is passed nil' do
+      client = ArchivesSpace::Client.new
+      client.repository 2
+      client.repository nil
+      expect(client.config.base_repo).to eq ''
+    end
 
+    it 'will use the global repo when the method is called' do
+      client = ArchivesSpace::Client.new
+      client.repository 2
+      client.use_global_repository
+      expect(client.config.base_repo).to eq ''
+    end
   end
 
-  describe "Version information" do
+  describe 'Pagination' do
+    it 'will have a method for defined paginated record types' do
+      client = ArchivesSpace::Client.new
+      ArchivesSpace::Pagination::ENDPOINTS.each do |e|
+        next if e.match?('/')
+
+        expect(client.respond_to?(e.to_sym)).to be true
+      end
+    end
+
+    it 'will have a method for defined paginated record types with multipart path' do
+      client = ArchivesSpace::Client.new
+      expect(client.respond_to?(:people)).to be true
+    end
+  end
 
+  describe 'Version information' do
     it 'has a version number' do
       expect(ArchivesSpace::Client::VERSION).not_to be nil
     end
 
-    it "can retrieve the backend version info" do
+    it 'can retrieve the backend version info' do
       VCR.use_cassette('backend_version') do
         login.call
-        response = client.get "version"
+        response = client.get 'version'
         expect(response.status_code).to eq(200)
         expect(response.body).to match(/ArchivesSpace \(.*\)/)
       end
     end
-
   end
-
-end
+end

data/spec/archivesspace/configuration_spec.rb

@@ -1,7 +1,8 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe ArchivesSpace::Configuration do
-
   it 'uses the default profile for configuration settings' do
     config = ArchivesSpace::Configuration.new
     expect(config.base_uri).to eq DEFAULT_BASE_URI
@@ -9,8 +10,8 @@ describe ArchivesSpace::Configuration do
 
   it 'allows configuration settings to be provided' do
     config = ArchivesSpace::Configuration.new({
-      base_uri: CUSTOM_BASE_URI,
-    })
+                                                base_uri: CUSTOM_BASE_URI
+                                              })
     expect(config.base_uri).to eq CUSTOM_BASE_URI
   end
 
@@ -22,7 +23,6 @@ describe ArchivesSpace::Configuration do
 
   it 'ignores unrecognized configuration properties' do
     config = ArchivesSpace::Configuration.new({ xyz: 123 })
-    expect{ config.xyz }.to raise_error(NoMethodError)
+    expect { config.xyz }.to raise_error(NoMethodError)
   end
-
-end
+end

data/spec/archivesspace/templates_spec.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe ArchivesSpace::Template do
+  it 'can list the default templates' do
+    templates = ArchivesSpace::Template.list
+    expect(templates).to_not be_empty
+    expect(templates).to include(/repository_with_agent.*erb/)
+  end
+
+  it 'can change the path when template envvar is set' do
+    expect(ArchivesSpace::Template.templates_path).to match(
+      /#{File.join('lib', 'archivesspace', 'client', 'templates')}/
+    )
+    ENV['ARCHIVESSPACE_CLIENT_TEMPLATES_PATH'] = '/path/to/nowhere'
+    expect(ArchivesSpace::Template.templates_path).to eq '/path/to/nowhere'
+    ENV.delete('ARCHIVESSPACE_CLIENT_TEMPLATES_PATH')
+  end
+
+  it 'can process a template' do
+    data = { repo_code: 'ABC', name: 'ABC Archive', agent_contact_name: 'ABC Admin' }
+    json = JSON.parse(ArchivesSpace::Template.process(:repository_with_agent, data))
+    expect(json['repository']['repo_code']).to eq data[:repo_code]
+  end
+end

data/spec/spec_helper.rb

@@ -1,14 +1,16 @@
-$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift File.expand_path('../lib', __dir__)
 require 'archivesspace/client'
 require 'vcr'
 require 'webmock/rspec'
 
 # GLOBAL VALUES FOR SPECS
-DEFAULT_BASE_URI = "http://localhost:8089"
-CUSTOM_BASE_URI  = "https://archives.university.edu/api"
+DEFAULT_BASE_URI = 'http://localhost:8089'
+CUSTOM_BASE_URI  = 'https://archives.university.edu/api'
 
 VCR.configure do |c|
-  c.cassette_library_dir = "spec/fixtures/cassettes"
+  c.cassette_library_dir = 'spec/fixtures/cassettes'
   c.hook_into :webmock
-  c.default_cassette_options = { :record => :once }
-end
+  c.default_cassette_options = { record: :once }
+end