symgate 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 4b8844223c94a355ea8ad0d294d75bfa31127a27
+  data.tar.gz: 822d5a227b81ac8e4e22c6a62b07d5c813b40640
+SHA512:
+  metadata.gz: d1e6978cf81fb2f10922d9fdb3eb13c86163cc5e95a5b75e428363ecd4fe6435bbd02809c66074a8fa8df5849b82f627af7f03a87caa54286105dff6ad8a1a9b
+  data.tar.gz: a4f344a61d6cd9d6c08a7e7f3d2bc0b82a4641dc26a1cc7a2da28504e5e45b5075093e1b11ce1d632ae4c08da238e61276ab9632e586a8461b5db835e6e7af61

data/.gitignore

@@ -0,0 +1,19 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+/.junit/*.xml
+/.idea/
+/.chef/
+/local-mode-cache/
+/nodes/
+/.vagrant/
+/Berksfile.lock
+/vendor/
+/coverage/
+/coverage.zip

data/.gitmodules

@@ -0,0 +1,3 @@
+[submodule "symboliser-vagrant"]
+	path = symboliser-vagrant
+	url = https://git.widgit.com/scm/online/symboliser-vagrant.git

data/.rubocop.yml

@@ -0,0 +1,19 @@
+AllCops:
+  TargetRubyVersion: 2.2
+  Exclude:
+    - 'vendor/**/*'
+    - '.chef/**/*'
+    - 'local-mode-cache/**/*'
+    - 'symboliser-vagrant/**/*'
+
+Metrics/LineLength:
+  Max: 100
+
+Metrics/MethodLength:
+  Max: 12
+
+Style/NumericLiterals:
+  MinDigits: 6
+
+Metrics/ClassLength:
+  Max: 120

data/.ruby-version

@@ -0,0 +1 @@
+2.2.1

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in symgate-gem.gemspec
+gemspec

data/README.md

@@ -0,0 +1,39 @@
+# Symgate::Gem
+
+Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/symgate/gem`. To experiment with that code, run `bin/console` for an interactive prompt.
+
+TODO: Delete this and the text above, and describe your gem
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'symgate-gem'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install symgate-gem
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release` to create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/symgate-gem/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,100 @@
+require 'bundler/gem_tasks'
+
+# rubocop:disable Lint/RescueException
+
+begin
+  require 'rspec/core/rake_task'
+  RSpec::Core::RakeTask.new(:spec) do |spec|
+    spec.pattern = 'test/spec/**/*_spec.rb'
+  end
+  desc 'Run RSpec integration tests against vagrant symboliser'
+  RSpec::Core::RakeTask.new('spec:integration') do |spec|
+    spec.pattern = 'test/integration/**/*_spec.rb'
+  end
+
+  desc 'Run RSpec code examples with junit output'
+  RSpec::Core::RakeTask.new('teamcity:spec') do |spec|
+    spec.rspec_opts = '-f RspecJunitFormatter -o .junit/rspec.xml'
+    spec.pattern = 'test/spec/**/*_spec.rb'
+  end
+
+  desc 'Run RSpec integration tests against vagrant symboliser with junit output'
+  RSpec::Core::RakeTask.new('teamcity:spec:integration') do |spec|
+    spec.rspec_opts = '-f RspecJunitFormatter -o .junit/integration.xml'
+    spec.pattern = 'test/integration/**/*_spec.rb'
+  end
+rescue LoadError
+  $stderr.puts 'Unable to find rspec gem'
+end
+
+desc 'Runs the rubocop linting tool'
+task :rubocop do
+  raise 'rubocop failed' unless system 'bundle exec rubocop -D -E -S'
+end
+
+desc 'Run all tests'
+task test: [:rubocop, :spec]
+
+namespace :teamcity do
+  desc 'Runs rubocop with junit output'
+  task :rubocop do
+    raise 'rubocop failed' unless system 'bundle exec rubocop ' \
+      '--no-color --require rubocop/formatter/junit_formatter ' \
+      '--format RuboCop::Formatter::JUnitFormatter --out .junit/rubocop.xml ' \
+      '-D -E -S'
+  end
+
+  desc 'Archives coverage html report into a zip'
+  task :zip_coverage do
+    Dir.chdir('coverage') do
+      system 'zip ../coverage.zip -r *'
+    end
+  end
+
+  desc 'Run all tests with junit output'
+  task :test do
+    first_exception = nil
+
+    %w(teamcity:rubocop
+       teamcity:spec
+       teamcity:zip_coverage
+       teamcity:spec:integration).each do |task_name|
+      begin
+        Rake::Task[task_name].invoke
+      rescue Exception => e
+        first_exception = e if first_exception.nil?
+      end
+    end
+
+    raise first_exception if first_exception
+  end
+end
+
+namespace :test do
+  task teamcity: 'teamcity:test'
+end
+
+namespace :vagrant do
+  desc 'Boot the symboliser virtual machine'
+  task :up do
+    Bundler.with_clean_env do
+      system 'bundle install --path vendor/bundle', chdir: 'symboliser-vagrant'
+      system 'RUBYLIB= NOEXEC_DISABLE=1 vagrant up',
+             chdir: 'symboliser-vagrant'
+    end
+  end
+
+  desc 'Destroy the symboliser virtual machine'
+  task :destroy do
+    Bundler.with_clean_env do
+      system 'RUBYLIB= NOEXEC_DISABLE=1 vagrant destroy --force',
+             chdir: 'symboliser-vagrant'
+    end
+  end
+
+  desc 'Halt the symboliser virtual machine for later use'
+  task :halt do
+    system 'RUBYLIB= NOEXEC_DISABLE=1 vagrant halt --force',
+           chdir: 'symboliser-vagrant'
+  end
+end

data/lib/symgate/auth/client.rb

@@ -0,0 +1,151 @@
+require 'symgate/client'
+require 'symgate/auth/user'
+
+module Symgate
+  module Auth
+    # client for the Symgate authentication system
+    class Client < Symgate::Client
+      # returns a list of groups for the current symgate account
+      def enumerate_groups
+        Symgate::Client.savon_array(
+          savon_request(:enumerate_groups).body[:enumerate_groups_response],
+          :groupid
+        )
+      end
+
+      # creates a new group
+      def create_group(group_id)
+        savon_request(:create_group, returns_error_string: true) do |soap|
+          soap.message(groupid: group_id)
+        end
+      end
+
+      # destroys an existing group
+      def destroy_group(group_id)
+        savon_request(:destroy_group, returns_error_string: true) do |soap|
+          soap.message(groupid: group_id)
+        end
+      end
+
+      # renames a group
+      def rename_group(old_group_id, new_group_id)
+        savon_request(:rename_group, returns_error_string: true) do |soap|
+          soap.message(old_groupid: old_group_id, new_groupid: new_group_id)
+        end
+      end
+
+      # returns a list of users for the specified group
+      def enumerate_users(group_id)
+        resp = savon_request(:enumerate_users) { |soap| soap.message(groupid: group_id) }
+
+        Symgate::Client.savon_array(
+          resp.body[:enumerate_users_response],
+          :user,
+          Symgate::Auth::User
+        )
+      end
+
+      # creates a new user from a Symgate::Auth::User, with the specified password
+      def create_user(user, password)
+        savon_request(:create_user, returns_error_string: true) do |soap|
+          soap.message(password: password)
+          user.to_soap(soap[:message])
+        end
+      end
+
+      # updates a user (sets the is_group_admin member)
+      def update_user(user)
+        savon_request(:update_user, returns_error_string: true) do |soap|
+          soap.message({})
+          user.to_soap(soap[:message])
+        end
+      end
+
+      # renames a user (must be within the same group)
+      def rename_user(old_user_id, new_user_id)
+        savon_request(:rename_user, returns_error_string: true) do |soap|
+          soap.message(old_user_id: old_user_id, new_user_id: new_user_id)
+        end
+      end
+
+      # moves a user between groups
+      def move_user(old_user_id, new_user_id)
+        savon_request(:move_user, returns_error_string: true) do |soap|
+          soap.message(old_user_id: old_user_id, new_user_id: new_user_id)
+        end
+      end
+
+      # sets the password for a user
+      def set_user_password(user_id, password)
+        savon_request(:set_user_password, returns_error_string: true) do |soap|
+          soap.message(userid: user_id, password: password)
+        end
+      end
+
+      # destroys a user
+      def destroy_user(user_id)
+        savon_request(:destroy_user, returns_error_string: true) do |soap|
+          soap.message(userid: user_id)
+        end
+      end
+
+      # authenticates a user and returns a token, optionally with a user to impersonate
+      def authenticate(user_to_impersonate = nil)
+        r = savon_request(:authenticate) do |soap|
+          soap.message(userid: user_to_impersonate) if user_to_impersonate
+        end.body[:authenticate_response]
+
+        r ? r[:authtoken] : nil
+      end
+
+      # adds a language to the specified group and returns 'OK' if successful or
+      # 'Exists' if the language is already assigned to the account
+      def add_group_language(group, language)
+        savon_request(:add_group_language) do |soap|
+          soap.message(groupid: group, language: language)
+        end.body[:add_group_language_response]
+      end
+
+      # removes a language from the specified group and returns 'OK' if successful or
+      # 'NotExist' if the language is not assigned to the account
+      def remove_group_language(group, language)
+        savon_request(:remove_group_language) do |soap|
+          soap.message(groupid: group, language: language)
+        end.body[:remove_group_language_response]
+      end
+
+      # lists the languages assigned to a group
+      def enumerate_group_languages(group_id)
+        resp = savon_request(:enumerate_group_languages) { |soap| soap.message(groupid: group_id) }
+
+        Symgate::Client.savon_array(
+          resp.body[:enumerate_group_languages_response],
+          :language
+        )
+      end
+
+      # queries whether a language is available for a group
+      def query_group_language(group_id, language)
+        savon_request(:query_group_language) do |soap|
+          soap.message(groupid: group_id, language: language)
+        end.body[:query_group_language_response]
+      end
+
+      # lists the language for the currently authenticated user
+      def enumerate_languages
+        resp = savon_request(:enumerate_languages)
+
+        Symgate::Client.savon_array(
+          resp.body[:enumerate_languages_response],
+          :language
+        )
+      end
+
+      # queries whether a language is available for the currently authenticated user
+      def query_language(language)
+        savon_request(:query_language) { |soap| soap.message(language: language) }
+          .body[:query_language_response]
+      end
+    end
+  end
+end

data/lib/symgate/auth/user.rb

@@ -0,0 +1,37 @@
+require 'symgate/type'
+
+module Symgate
+  module Auth
+    # defines a symgate user
+    class User < Symgate::Type
+      def initialize(opts = {})
+        super(opts)
+        @is_group_admin = opts[:is_group_admin] || false
+      end
+
+      def self.from_soap(hash)
+        Symgate::Auth::User.new(
+          user_id: hash[:@id],
+          is_group_admin: hash[:@is_group_admin] == 'true'
+        )
+      end
+
+      def to_soap(hash)
+        hash[:'auth:user'] = ''
+        hash[:attributes!] = {} unless hash.include? :attributes!
+        hash[:attributes!][:'auth:user'] = { id: @user_id }
+        hash[:attributes!][:'auth:user'][:isGroupAdmin] = @is_group_admin if @is_group_admin
+      end
+
+      def to_s
+        @user_id + (@is_group_admin ? '(admin)' : '')
+      end
+
+      protected
+
+      def attributes
+        %i(user_id is_group_admin)
+      end
+    end
+  end
+end

data/lib/symgate/auth.rb

@@ -0,0 +1,2 @@
+require 'symgate/auth/user'
+require 'symgate/auth/client'

data/lib/symgate/client.rb

@@ -0,0 +1,142 @@
+require 'savon'
+require 'symgate/error'
+require 'symgate/namespaces'
+
+module Symgate
+  # A generic client for the Symgate API.
+  # See the WSDL for full documentation
+  class Client
+    attr_accessor :wsdl, :endpoint, :user, :password, :token, :account, :key, :savon_opts
+    attr_reader :savon_client
+
+    # Constructs a new client with the provided options
+    def initialize(opts = {})
+      @wsdl = 'https://ws.widgitonline.com/schema/symboliser.wsdl'
+      @endpoint = 'https://ws.widgitonline.com/'
+      @savon_opts = {}
+      opts.each { |k, v| instance_variable_set("@#{k}", v) }
+
+      validate_client_options
+      create_savon_client
+    end
+
+    # returns an array from 0 or more items when an array is expected.
+    # (savon returns a single value for things that can be a sequence of multiple objects)
+    # expects a hash, and a key for the array within that hash.
+    # if classname is specified, the method will return an array of objects initialised
+    # by the hash contents
+    def self.savon_array(hash, key, classname = nil)
+      if hash && hash.include?(key)
+        [hash[key]].flatten
+      else
+        []
+      end.map { |v| classname ? classname.from_soap(v) : v }
+    end
+
+    protected
+
+    # ensures enough information has been passed to the client
+    def validate_client_options
+      validate_has_account
+      validate_has_key_or_user
+      validate_is_passwordy
+    end
+
+    def validate_has_account
+      raise Symgate::Error, 'No account specified' if @account.nil?
+    end
+
+    def validate_has_key_or_user
+      raise Symgate::Error, 'No key or user specified' if @key.nil? && @user.nil?
+      raise Symgate::Error, 'Both key and user were specified' if @key && @user
+    end
+
+    def validate_is_passwordy
+      unless [@key, @password, @token].one?
+        raise Symgate::Error, 'You must supply one of key, password or token'
+      end
+    end
+
+    def create_savon_client
+      @savon_client = Savon.client(savon_opts.merge(wsdl: @wsdl, endpoint: @endpoint)) do
+        endpoint(@endpoint) if @endpoint
+        namespaces(Symgate::NAMESPACES)
+      end
+    end
+
+    # builds a credentials object - required for all requests
+    def savon_creds
+      creds = { 'auth:account': @account }
+      creds[:'auth:key'] = @key if @key
+      creds[:'auth:user'] = savon_user if @user
+
+      { 'auth:creds': creds }
+    end
+
+    def savon_user
+      user = { 'auth:id': @user }
+      user[:'auth:password'] = @password if @password
+      user[:'auth:authtoken'] = @token if @token
+
+      user
+    end
+
+    # sends a request to the server and yields a soap block for defining the
+    # message body
+    def savon_request(method, opts = {})
+      r = @savon_client.call(method) do |soap|
+        yield soap if block_given?
+        soap.message({}) if soap[:message].nil?
+        soap[:message].merge!(savon_creds)
+      end
+
+      raise_error_on_string_response(r, "#{method}_response".to_sym) if opts[:returns_error_string]
+      r
+    rescue Savon::SOAPFault => e
+      raise Symgate::Error.from_savon(e)
+    end
+
+    def raise_error_on_string_response(response, response_type)
+      e = response.body[response_type]
+      raise Symgate::Error, e unless e.to_s == ''
+    end
+
+    def arrayize_option(singular, plural, opts)
+      if opts.include? singular # else nothing to do
+        if opts.include? plural
+          raise Symgate::Error, "Options can't include both #{singular} and #{plural}"
+        end
+
+        opts[plural] = [opts[singular]]
+        opts.delete(singular)
+      end
+    end
+
+    def check_option_is_array_of(classname, key, opts)
+      if opts.include? key
+        raise Symgate::Error, "#{key} must be an array" unless opts[key].is_a? Array
+        check_array_for_type(opts[key], classname)
+      end
+    end
+
+    def check_for_unknown_opts(keys, opts)
+      opts.keys.each do |k|
+        raise Symgate::Error, "Unknown option: #{k}" unless keys.include? k
+      end
+    end
+
+    def check_array_for_type(ary, type_name)
+      raise Symgate::Error, "#{ary.class.name} is not an array" unless ary.is_a? Array
+
+      ary.each do |item|
+        unless item.is_a? type_name
+          raise Symgate::Error, "'#{item.class.name}' is not a #{type_name.name}"
+        end
+      end
+    end
+
+    def check_for_multiple_opts(keys, opts)
+      raise Symgate::Error, "Supply only one of 'match' or 'entry'" if keys.all? { |k| opts.key? k }
+    end
+  end
+end

data/lib/symgate/cml/symbol.rb

@@ -0,0 +1,48 @@
+require 'symgate/type'
+
+module Symgate
+  module Cml
+    # defines the cml symbol information for a concept
+    class Symbol < Symgate::Type
+      def self.from_soap(hash)
+        Symgate::Cml::Symbol.new(
+          symset: hash_value_with_optional_namespace(:cml, :symset, hash),
+          main: hash_value_with_optional_namespace(:cml, :main, hash),
+          top_left: hash_value_with_optional_namespace(:cml, :top_left, hash),
+          top_right: hash_value_with_optional_namespace(:cml, :top_right, hash),
+          bottom_left: hash_value_with_optional_namespace(:cml, :bottom_left, hash),
+          bottom_right: hash_value_with_optional_namespace(:cml, :bottom_right, hash),
+          full_left: hash_value_with_optional_namespace(:cml, :full_left, hash),
+          full_right: hash_value_with_optional_namespace(:cml, :full_right, hash),
+          top: hash_value_with_optional_namespace(:cml, :top, hash),
+          extra: hash_value_with_optional_namespace(:cml, :extra, hash)
+        )
+      end
+
+      def to_soap
+        {
+          'cml:symset': symset,
+          'cml:main': main,
+          'cml:top_left': top_left,
+          'cml:top_right': top_right,
+          'cml:bottom_left': bottom_left,
+          'cml:bottom_right': bottom_right,
+          'cml:full_left': full_left,
+          'cml:full_right': full_right,
+          'cml:top': top,
+          'cml:extra': extra
+        }.delete_if { |_, v| v.nil? }
+      end
+
+      def to_s
+        "Symbol: #{@main}"
+      end
+
+      protected
+
+      def attributes
+        %i(symset main top_left top_right bottom_left bottom_right full_left full_right top extra)
+      end
+    end
+  end
+end

data/lib/symgate/cml.rb

@@ -0,0 +1 @@
+require 'symgate/cml/symbol'

data/lib/symgate/error.rb

@@ -0,0 +1,33 @@
+require 'savon'
+
+module Symgate
+  # Defines a symgate-specific error so this can be caught by the caller
+  class Error < StandardError
+    attr_reader :original_error, :detail
+
+    # Initialises a symgate error from either a string or a savon error
+    def initialize(message)
+      super(message)
+    end
+
+    def self.from_savon(error)
+      e = Symgate::Error.new(message_from_savon_error(error))
+
+      e.original_error = error
+      e
+    end
+
+    def original_error=(error)
+      @original_error = error
+      @detail = error.to_hash[:fault][:detail]
+    end
+
+    def self.message_from_savon_error(error)
+      "#{error.message}. #{error.to_hash[:fault][:detail]}"
+    rescue
+      # :nocov:
+      error.message
+      # :nocov:
+    end
+  end
+end