powerhome-scimitar 1.0.0

data/app/models/scimitar/authentication_error.rb

@@ -0,0 +1,9 @@
+module Scimitar
+
+  class AuthenticationError < ErrorResponse
+    def initialize
+      super(status: 401, detail: 'Requires authentication')
+    end
+
+  end
+end

data/app/models/scimitar/authentication_scheme.rb

@@ -0,0 +1,18 @@
+module Scimitar
+  class AuthenticationScheme
+    include ActiveModel::Model
+    attr_accessor :type, :name, :description
+
+    def self.basic
+      new type:        'httpbasic',
+          name:        'HTTP Basic',
+          description: 'Authentication scheme using the HTTP Basic Standard'
+    end
+
+    def self.bearer
+      new type:        'oauthbearertoken',
+          name:        'OAuth Bearer Token',
+          description: 'Authentication scheme using the OAuth Bearer Token Standard'
+    end
+  end
+end

data/app/models/scimitar/bulk.rb

@@ -0,0 +1,8 @@
+module Scimitar
+
+  # This isn't supported yet; the class is a placeholder.
+  #
+  class Bulk < Supportable
+    attr_accessor :maxOperations, :maxPayloadSize
+  end
+end

data/app/models/scimitar/complex_types/address.rb

@@ -0,0 +1,12 @@
+module Scimitar
+  module ComplexTypes
+
+    # Represents the complex Address type.
+    #
+    # See also Scimitar::Schema::Address
+    #
+    class Address < Base
+      set_schema Scimitar::Schema::Address
+    end
+  end
+end

data/app/models/scimitar/complex_types/base.rb

@@ -0,0 +1,83 @@
+require 'set'
+
+module Scimitar
+  module ComplexTypes
+
+    # This class represents complex types that could be used inside SCIM
+    # resources. Each complex type must inherit from this class. They also need
+    # to have their own schema defined. For example:
+    #
+    #     module Scimitar
+    #       module ComplexTypes
+    #         class Email < Base
+    #           set_schema Scimitar::Schema::Email
+    #
+    #           def as_json(options = {})
+    #             {'type' => 'work', 'primary' => true}.merge(super(options))
+    #           end
+    #         end
+    #       end
+    #     end
+    #
+    class Base
+      include ActiveModel::Model
+      include Scimitar::Schema::DerivedAttributes
+      include Scimitar::Errors
+
+      # Instantiates with attribute values - see ActiveModel::Model#initialize.
+      #
+      # Allows case-insensitive attributes given in options, by enumerating all
+      # instance methods that exist in the subclass (at the point where this
+      # method runs, 'self' is a subclass, unless someone instantiated this
+      # base class directly) and subtracting methods in the base class. Usually
+      # this leaves just the attribute accessors, with not much extra.
+      #
+      # Map a normalized case version of those names to the actual method names
+      # then for each key in the inbound options, normalize it and see if one
+      # of the actual case method names is available. If so, use that instead.
+      #
+      # Unmapped option keys will most likely have no corresponding writer
+      # method in the subclass and NoMethodError will therefore arise.
+      #
+      def initialize(options={})
+        normalized_method_map     = HashWithIndifferentAccess.new
+        corrected_options         = {}
+        probable_accessor_methods = self.class.instance_methods - self.class.superclass.instance_methods
+
+        unless options.empty?
+          probable_accessor_methods.each do | method_name |
+            next if method_name.end_with?('=')
+            normalized_method_map[method_name.downcase] = method_name
+          end
+
+          options.each do | ambiguous_case_name, value |
+            normalized_name = ambiguous_case_name.downcase
+            corrected_name  = normalized_method_map[normalized_name]
+
+            if corrected_name.nil?
+              corrected_options[ambiguous_case_name] = value # Probably will lead to NoMethodError
+            else
+              corrected_options[corrected_name] = value
+            end
+          end
+
+          options = corrected_options
+        end
+
+        super # Calls into ActiveModel::Model
+
+        @errors = ActiveModel::Errors.new(self)
+      end
+
+      # Converts the object to its SCIM representation, which is always JSON.
+      #
+      # +options+:: A hash that could provide default values for some of the
+      #             attributes of this complex type object.
+      #
+      def as_json(options={})
+        options[:except] ||= ['errors']
+        super.except(options)
+      end
+    end
+  end
+end

data/app/models/scimitar/complex_types/email.rb

@@ -0,0 +1,12 @@
+module Scimitar
+  module ComplexTypes
+
+    # Represents the complex Email type.
+    #
+    # See also Scimitar::Schema::Email
+    #
+    class Email < Base
+      set_schema Scimitar::Schema::Email
+    end
+  end
+end

data/app/models/scimitar/complex_types/entitlement.rb

@@ -0,0 +1,12 @@
+module Scimitar
+  module ComplexTypes
+
+    # Represents the complex Entitlement type.
+    #
+    # See also Scimitar::Schema::Entitlement
+    #
+    class Entitlement < Base
+      set_schema Scimitar::Schema::Entitlement
+    end
+  end
+end

data/app/models/scimitar/complex_types/ims.rb

@@ -0,0 +1,12 @@
+module Scimitar
+  module ComplexTypes
+
+    # Represents the complex Instant Messaging type.
+    #
+    # See also Scimitar::Schema::Ims
+    #
+    class Ims < Base
+      set_schema Scimitar::Schema::Ims
+    end
+  end
+end

data/app/models/scimitar/complex_types/name.rb

@@ -0,0 +1,12 @@
+module Scimitar
+  module ComplexTypes
+
+    # Represents the complex Name type.
+    #
+    # See also Scimitar::Schema::Name
+    #
+    class Name < Base
+      set_schema Scimitar::Schema::Name
+    end
+  end
+end

data/app/models/scimitar/complex_types/phone_number.rb

@@ -0,0 +1,12 @@
+module Scimitar
+  module ComplexTypes
+
+    # Represents the complex PhoneNumber type.
+    #
+    # See also Scimitar::Schema::PhoneNumber
+    #
+    class PhoneNumber < Base
+      set_schema Scimitar::Schema::PhoneNumber
+    end
+  end
+end

data/app/models/scimitar/complex_types/photo.rb

@@ -0,0 +1,12 @@
+module Scimitar
+  module ComplexTypes
+
+    # Represents the complex Photo type.
+    #
+    # See also Scimitar::Schema::Photo
+    #
+    class Photo < Base
+      set_schema Scimitar::Schema::Photo
+    end
+  end
+end

data/app/models/scimitar/complex_types/reference_group.rb

@@ -0,0 +1,12 @@
+module Scimitar
+  module ComplexTypes
+
+    # Represents the complex reference-a-group type.
+    #
+    # See also Scimitar::Schema::ReferenceGroup
+    #
+    class ReferenceGroup < Base
+      set_schema Scimitar::Schema::ReferenceGroup
+    end
+  end
+end

data/app/models/scimitar/complex_types/reference_member.rb

@@ -0,0 +1,12 @@
+module Scimitar
+  module ComplexTypes
+
+    # Represents the complex reference-a-member type.
+    #
+    # See also Scimitar::Schema::ReferenceMember
+    #
+    class ReferenceMember < Base
+      set_schema Scimitar::Schema::ReferenceMember
+    end
+  end
+end

data/app/models/scimitar/complex_types/role.rb

@@ -0,0 +1,12 @@
+module Scimitar
+  module ComplexTypes
+
+    # Represents the complex Role type.
+    #
+    # See also Scimitar::Schema::Role
+    #
+    class Role < Base
+      set_schema Scimitar::Schema::Role
+    end
+  end
+end

data/app/models/scimitar/complex_types/x509_certificate.rb

@@ -0,0 +1,12 @@
+module Scimitar
+  module ComplexTypes
+
+    # Represents the complex X509Certificate type.
+    #
+    # See also Scimitar::Schema::X509Certificate
+    #
+    class X509Certificate < Base
+      set_schema Scimitar::Schema::X509Certificate
+    end
+  end
+end

data/app/models/scimitar/engine_configuration.rb

@@ -0,0 +1,32 @@
+module Scimitar
+
+  # Scimitar general configuration.
+  #
+  # See config/initializers/scimitar.rb for more information.
+  #
+  class EngineConfiguration
+    include ActiveModel::Model
+
+    attr_accessor(
+      :uses_defaults,
+      :basic_authenticator,
+      :token_authenticator,
+      :application_controller_mixin,
+      :exception_reporter,
+      :optional_value_fields_required,
+    )
+
+    def initialize(attributes = {})
+      @uses_defaults = attributes.empty?
+
+      # Set defaults that may be overridden by the initializer.
+      #
+      defaults = {
+        optional_value_fields_required: true
+      }
+
+      super(defaults.merge(attributes))
+    end
+
+  end
+end

data/app/models/scimitar/error_response.rb

@@ -0,0 +1,32 @@
+module Scimitar
+  class ErrorResponse < StandardError
+    include ActiveModel::Model
+
+    attr_accessor :status,
+                  :detail,
+                  :scimType
+
+    def as_json(options = {})
+      data = {
+        'schemas': ['urn:ietf:params:scim:api:messages:2.0:Error'],
+        'detail': detail,
+        'status': "#{status}"
+      }
+
+      data['scimType'] = scimType if scimType
+      data
+    end
+
+    # Originally Scimitar used attribute "detail" for exception text; it was
+    # only for JSON responses at the time, but in hindsight was a bad choice.
+    # It should have been "message" given inheritance from StandardError, which
+    # then works properly with e.g. error reporting services.
+    #
+    # The "detail" attribute is still present, for backwards compatibility with
+    # any client code that might be using this class.
+    #
+    def message
+      self.detail
+    end
+  end
+end

data/app/models/scimitar/errors.rb

@@ -0,0 +1,14 @@
+module Scimitar
+  module Errors
+    def add_errors_from_hash(errors_hash:, prefix: nil)
+      errors_hash.each_pair do |key, value|
+        new_key = prefix.nil? ? key : "#{prefix}.#{key}".to_sym
+        if value.is_a?(Array)
+          value.each {|error| errors.add(new_key, error)}
+        else
+          errors.add(new_key, value)
+        end
+      end
+    end
+  end
+end

data/app/models/scimitar/filter.rb

@@ -0,0 +1,11 @@
+module Scimitar
+
+  # Used to configure filters via
+  # app/models/scimitar/service_provider_configuration.rb.
+  #
+  class Filter < Supportable
+    MAX_RESULTS_DEFAULT = 100
+
+    attr_accessor :maxResults
+  end
+end

data/app/models/scimitar/filter_error.rb

@@ -0,0 +1,22 @@
+module Scimitar
+
+  # Raised when an invalid query is attempted, either by being malformed or by
+  # being unsupported in some way.
+  #
+  class FilterError < ErrorResponse
+    def initialize(message = nil)
+      detail = 'The specified filter syntax was invalid, or the specified attribute and filter comparison combination is not supported'
+
+      if message.present?
+        detail << ":\n#{message}"
+      end
+
+      super(
+        status:   400,
+        scimType: 'invalidFilter',
+        detail:   detail
+      )
+    end
+  end
+
+end

data/app/models/scimitar/invalid_syntax_error.rb

@@ -0,0 +1,9 @@
+module Scimitar
+  class InvalidSyntaxError < ErrorResponse
+
+    def initialize(error_message)
+      super(status: 400, scimType: 'invalidSyntax', detail: error_message)
+    end
+
+  end
+end

data/app/models/scimitar/lists/count.rb

@@ -0,0 +1,64 @@
+module Scimitar
+  module Lists
+    class Count
+      include ActiveModel::Model
+
+      attr_accessor :limit, :start_index, :total
+      attr_reader   :offset
+
+      def initialize(*args)
+        @limit       = 100
+        @start_index = 1
+
+        super(*args)
+      end
+
+      # Set a limit (page size) value.
+      #
+      # +value+:: Integer value held in a String. Must be >= 1.
+      #
+      # Raises exceptions if given non-numeric, zero or negative input.
+      #
+      def limit=(value)
+        value = value&.to_s
+        return if value.blank? # NOTE EARLY EXIT
+
+        validate_numericality(value)
+        input = value.to_i
+        raise if input < 1
+        @limit = input
+      end
+
+      # Set a start index (offset) value. Values start at 1. See also #offset.
+      #
+      # +value+:: Integer value held in a String. Must be >= 1.
+      #
+      # Raises exceptions if given non-numeric or negative input. Corrects an
+      # input value of zero to 1.
+      #
+      def start_index=(value)
+        value = value&.to_s
+        return if value.blank? # NOTE EARLY EXIT
+
+        validate_numericality(value)
+        input = value.to_i
+        input = 1 if input < 1
+        @start_index = input
+      end
+
+      # Read-only accessor that represents #start_index as a zero-based offset,
+      # rather than 1-based. This is useful for most storage engines.
+      #
+      def offset
+        start_index - 1
+      end
+
+    private
+
+      def validate_numericality(input)
+        raise unless input.match?(/\A\d+\z/)
+      end
+
+    end
+  end
+end