Commit 9b79e10

@@ -6,45 +6,48 @@ module Scim
       # Represents a scim Attribute type
       class AttributeType
         attr_reader :name, :type
-
-        def initialize(name:, type: :string, overrides: {})
+        attr_accessor :multi_valued
+        attr_accessor :required
+        attr_accessor :case_exact
+        attr_accessor :description
+        attr_reader :mutability
+        attr_reader :returned
+        attr_reader :uniqueness
+
+        def initialize(name:, type: :string)
           @name = name
           @type = type
-          @overrides = defaults.merge(overrides)
-          ensure_valid!(@overrides)
-        end
-
-        def to_h
-          @overrides
+          @description = ''
+          @multi_valued = false
+          @required = false
+          @case_exact = false
+          @mutability = Mutability::READ_WRITE
+          @returned = Returned::DEFAULT
+          @uniqueness = Uniqueness::NONE
         end
 
-        private
-
-        def ensure_valid!(overrides)
-          valid_mutability!(overrides[:mutability])
-          valid_returned!(overrides[:returned])
-          valid_uniqueness!(overrides[:uniqueness])
-        end
-
-        def valid_mutability!(mutability)
-          raise ArgumentError, :mutability unless Mutability.valid?(mutability)
+        def mutability=(value)
+          @mutability = Mutability.find(value)
         end
 
-        def valid_returned!(returned)
-          raise ArgumentError, :returned unless Returned.valid?(returned)
+        def returned=(value)
+          @returned = Returned.find(value)
         end
 
-        def valid_uniqueness!(uniqueness)
-          raise ArgumentError, :uniqueness unless Uniqueness.valid?(uniqueness)
+        def uniqueness=(value)
+          @uniqueness = Uniqueness.find(value)
         end
 
-        def defaults
+        def to_h
           {
-            name: name, type: type.to_s, description: '',
-            multiValued: false, required: false, caseExact: false,
-            mutability: Mutability::READ_WRITE,
-            returned: Returned::DEFAULT,
-            uniqueness: Uniqueness::NONE
+            name: name, type: type.to_s,
+            description: description,
+            multiValued: multi_valued,
+            required: required,
+            caseExact: case_exact,
+            mutability: mutability,
+            returned: returned,
+            uniqueness: uniqueness
           }
         end
       end

@@ -16,8 +16,8 @@ module Scim
           write_only: WRITE_ONLY
         }.freeze
 
-        def self.valid?(value)
-          VALID.key?(value.to_sym) || VALID.value?(value)
+        def self.find(value)
+          VALID[value.to_sym] || (raise ArgumentError, :mutability)
         end
       end
     end

@@ -16,8 +16,8 @@ module Scim
           request: REQUEST
         }.freeze
 
-        def self.valid?(value)
-          VALID[value.to_sym]
+        def self.find(value)
+          VALID[value.to_sym] || (raise ArgumentError, :returned)
         end
       end
     end

@@ -21,7 +21,9 @@ module Scim
         end
 
         def add_attribute(name:)
-          @attributes << AttributeType.new(name: name)
+          attribute = AttributeType.new(name: name)
+          yield attribute if block_given?
+          @attributes << attribute
         end
 
         def to_json

@@ -14,8 +14,8 @@ module Scim
           global: GLOBAL
         }.freeze
 
-        def self.valid?(value)
-          VALID[value.to_sym]
+        def self.find(value)
+          VALID[value.to_sym] || (raise ArgumentError, :uniqueness)
         end
       end
     end

@@ -20,30 +20,34 @@ RSpec.describe Scim::Kit::V2::AttributeType do
 
     describe 'overrides' do
       def build(overrides)
-        described_class.new(name: 'displayName', overrides: overrides)
+        x = described_class.new(name: 'displayName')
+        overrides.each do |(key, value)|
+          x.public_send("#{key}=".to_sym, value)
+        end
+        x
       end
 
-      specify { expect(build(multiValued: true).to_h[:multiValued]).to be(true) }
+      specify { expect(build(multi_valued: true).to_h[:multiValued]).to be(true) }
       specify { expect(build(description: 'hello').to_h[:description]).to eq('hello') }
       specify { expect(build(required: true).to_h[:required]).to be(true) }
-      specify { expect(build(caseExact: true).to_h[:caseExact]).to be(true) }
+      specify { expect(build(case_exact: true).to_h[:caseExact]).to be(true) }
 
-      specify { expect(build(mutability: 'readOnly').to_h[:mutability]).to eql('readOnly') }
-      specify { expect(build(mutability: 'readWrite').to_h[:mutability]).to eql('readWrite') }
-      specify { expect(build(mutability: 'immutable').to_h[:mutability]).to eql('immutable') }
-      specify { expect(build(mutability: 'writeOnly').to_h[:mutability]).to eql('writeOnly') }
-      specify { expect { build(mutability: 'invalid') }.to raise_error(ArgumentError) }
+      specify { expect(build(mutability: :read_only).to_h[:mutability]).to eql('readOnly') }
+      specify { expect(build(mutability: :read_write).to_h[:mutability]).to eql('readWrite') }
+      specify { expect(build(mutability: :immutable).to_h[:mutability]).to eql('immutable') }
+      specify { expect(build(mutability: :write_only).to_h[:mutability]).to eql('writeOnly') }
+      specify { expect { build(mutability: :invalid) }.to raise_error(ArgumentError) }
 
-      specify { expect(build(returned: 'always').to_h[:returned]).to eql('always') }
-      specify { expect(build(returned: 'never').to_h[:returned]).to eql('never') }
-      specify { expect(build(returned: 'default').to_h[:returned]).to eql('default') }
-      specify { expect(build(returned: 'request').to_h[:returned]).to eql('request') }
-      specify { expect { build(returned: 'invalid') }.to raise_error(ArgumentError) }
+      specify { expect(build(returned: :always).to_h[:returned]).to eql('always') }
+      specify { expect(build(returned: :never).to_h[:returned]).to eql('never') }
+      specify { expect(build(returned: :default).to_h[:returned]).to eql('default') }
+      specify { expect(build(returned: :request).to_h[:returned]).to eql('request') }
+      specify { expect { build(returned: :invalid) }.to raise_error(ArgumentError) }
 
-      specify { expect(build(uniqueness: 'none').to_h[:uniqueness]).to eql('none') }
-      specify { expect(build(uniqueness: 'server').to_h[:uniqueness]).to eql('server') }
-      specify { expect(build(uniqueness: 'global').to_h[:uniqueness]).to eql('global') }
-      specify { expect { build(uniqueness: 'invalid') }.to raise_error(ArgumentError) }
+      specify { expect(build(uniqueness: :none).to_h[:uniqueness]).to eql('none') }
+      specify { expect(build(uniqueness: :server).to_h[:uniqueness]).to eql('server') }
+      specify { expect(build(uniqueness: :global).to_h[:uniqueness]).to eql('global') }
+      specify { expect { build(uniqueness: :invalid) }.to raise_error(ArgumentError) }
     end
   end
 end

@@ -19,7 +19,7 @@ RSpec.describe Scim::Kit::V2::Schema do
   specify { expect(result[:meta][:resourceType]).to eql('Schema') }
   specify { expect(result[:meta][:location]).to eql(location) }
 
-  context "with a single simple attribute" do
+  context 'with a single simple attribute' do
     before do
       subject.add_attribute(name: 'displayName')
     end
@@ -33,5 +33,15 @@ RSpec.describe Scim::Kit::V2::Schema do
     specify { expect(result[:attributes][0][:mutability]).to eql('readWrite') }
     specify { expect(result[:attributes][0][:returned]).to eql('default') }
     specify { expect(result[:attributes][0][:uniqueness]).to eql('none') }
+
+    context 'with a description' do
+      before do
+        subject.add_attribute(name: 'userName') do |x|
+          x.description = 'my description'
+        end
+      end
+
+      specify { expect(result[:attributes][1][:description]).to eql('my description') }
+    end
   end
 end