sinclair 1.6.5 → 1.6.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 82dceb39442cd887b9188fd91bc0b225aedae2504e180a61ba3f5ec6d18b6de3
-  data.tar.gz: '09dafbb7642c1021c47c7ab4db0732f5f514c881d61adba3a7d1cc3c6ac620ca'
+  metadata.gz: 3c38de6f509924f2b5b98eff6492718504c2f83111360e4985c67e421a2cebc5
+  data.tar.gz: 9210a66214f8fa11a6c42496b00f1045bf2268adde7c049b1481d47b21aba6cd
 SHA512:
-  metadata.gz: 794343fe9272e52bd35a9b0a23c3b2e5e64d45a291f29b75d94335b6ff0f65e6d117585ca75562e9fad94b186d5cc1d66126caec9df3d06a4497cee5d6fe3fa8
-  data.tar.gz: ac6e7f371357b46111d9eceaf0b5d6a06816d1bd537665d4824d96713762e59ce7eb986048ac18d4219d9fd860e165f200c8d5cbfea34e62f04a0d7e7c641959
+  metadata.gz: 7536c4b9bc1198fd23777b4bd73d20479d0c94d6ef03444e48e4c05687623d0c4f2cdcdb8ad6bfef4a20832307f04021d14bdd628bd3ff2cbf6e1c611c5be7ad
+  data.tar.gz: f0c246aa85bd9989337240ded4aa36634b80dcf1042f8776663b05ebea81220dd13b60f45f8c12ee4aa95064be096094c68d9fe6619d517fa36a879ffe897011

data/README.md

@@ -15,7 +15,7 @@ methods
 
 Yard Documentation
 -------------------
-[https://www.rubydoc.info/gems/sinclair/1.6.5](https://www.rubydoc.info/gems/sinclair/1.6.5)
+[https://www.rubydoc.info/gems/sinclair/1.6.6](https://www.rubydoc.info/gems/sinclair/1.6.6)
 
 Installation
 ---------------
@@ -452,6 +452,8 @@ Options allows projects to have an easy to configure option object
 ```ruby
   class ConnectionOptions < Sinclair::Options
     with_options :timeout, :retries, port: 443, protocol: 'https'
+
+    # skip_validation if you dont want to validate intialization arguments
   end
 
  options = ConnectionOptions.new(

data/lib/sinclair/options.rb

@@ -20,64 +20,10 @@ class Sinclair
   #   options.port     # returns 8080
   #   options.protocol # returns 'https'
   class Options
-    autoload :Builder, 'sinclair/options/builder'
+    autoload :Builder,      'sinclair/options/builder'
+    autoload :ClassMethods, 'sinclair/options/class_methods'
 
-    class << self
-      # @api private
-      #
-      # returns invalid options
-      #
-      # @return [Array<Symbol>]
-      def invalid_options_in(names)
-        names.map(&:to_sym) - allowed_options.to_a
-      end
-
-      # @api private
-      #
-      # Allow new option
-      #
-      # This does not create the method
-      #
-      # @param name [String,Symbol] options to be allowed
-      #
-      # @return [Set<Symbol>]
-      def allow(name)
-        allowed_options << name.to_sym
-      end
-
-      # @api private
-      # @private
-      #
-      # Options allowed when initializing options
-      #
-      # @return [Set<Symbol>]
-      def allowed_options
-        @allowed_options ||= superclass.try(:allowed_options).dup || Set.new
-      end
-
-      private
-
-      # @api public
-      # @!visibility public
-      #
-      # Add available options
-      #
-      # @example (see Options)
-      #
-      # @return (see Sinclair#build)
-      #
-      # @overload with_options(*options)
-      #   @param options [Array<Symbol>] list of accepted
-      #     options
-      # @overload with_options(*options, **defaults)
-      #   @param options [Array<Symbol>] list of accepted
-      #     options
-      #   @param defaults [Hash<Symbol,Object>] default options
-      #     hash
-      def with_options(*options)
-        Builder.new(self, *options).build
-      end
-    end
+    extend ClassMethods
 
     # @param options [Hash] hash with options (see {.options}, {.with_options})
     # @example (see Options)
@@ -108,7 +54,7 @@ class Sinclair
     #                #   protocol: 'https'
     #                # }
     def to_h
-      self.class.allowed_options.inject({}) do |hash, option|
+      allowed_options.inject({}) do |hash, option|
         hash.merge(option => public_send(option))
       end
     end
@@ -121,13 +67,15 @@ class Sinclair
     def ==(other)
       return false unless self.class == other.class
 
-      self.class.allowed_options.all? do |name|
+      allowed_options.all? do |name|
         public_send(name) == other.public_send(name)
       end
     end
 
     private
 
+    delegate :allowed_options, :skip_validation?, :invalid_options_in, to: :class
+
     # @private
     # @api private
     #
@@ -137,7 +85,9 @@ class Sinclair
     #
     # @return [NilClass]
     def check_options(options)
-      invalid_keys = self.class.invalid_options_in(options.keys)
+      return if skip_validation?
+
+      invalid_keys = invalid_options_in(options.keys)
 
       return if invalid_keys.empty?
 

data/lib/sinclair/options/class_methods.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+require 'set'
+
+class Sinclair
+  class Options
+    # Class Methods for {Sinclai::Options}
+    module ClassMethods
+      # @api private
+      #
+      # returns invalid options
+      #
+      # @return [Array<Symbol>]
+      def invalid_options_in(names)
+        names.map(&:to_sym) - allowed_options.to_a
+      end
+
+      # @api private
+      #
+      # Allow new option
+      #
+      # This does not create the method
+      #
+      # @param name [String,Symbol] options to be allowed
+      #
+      # @return [Set<Symbol>]
+      def allow(name)
+        allowed_options << name.to_sym
+      end
+
+      # @api private
+      # @private
+      #
+      # Options allowed when initializing options
+      #
+      # @return [Set<Symbol>]
+      def allowed_options
+        @allowed_options ||= superclass.try(:allowed_options).dup || Set.new
+      end
+
+      # @api private
+      #
+      # checks if class skips initialization validation
+      #
+      # @return [TrueClass,FalseClass]
+      def skip_validation?
+        @skip_validation ||= superclass.try(:skip_validation?) || false
+      end
+
+      private
+
+      # @api public
+      # @!visibility public
+      #
+      # Add available options
+      #
+      # @example (see Options)
+      #
+      # @return (see Sinclair#build)
+      #
+      # @overload with_options(*options)
+      #   @param options [Array<Symbol>] list of accepted
+      #     options
+      # @overload with_options(*options, **defaults)
+      #   @param options [Array<Symbol>] list of accepted
+      #     options
+      #   @param defaults [Hash<Symbol,Object>] default options
+      #     hash
+      def with_options(*options)
+        Builder.new(self, *options).build
+      end
+
+      # @api public
+      # @!visibility public
+      #
+      # Changes class to skip attributes validation
+      #
+      # when initializing options, options
+      # will accept any arguments when validation
+      # is skipped
+      #
+      # @return [TrueClass]
+      #
+      # @example
+      #   class BuilderOptions < Sinclair::Options
+      #     with_options :name
+      #
+      #     skip_validation
+      #   end
+      #   options = BuilderOptions.new(name: 'Joe', age: 10)
+      #
+      #   options.name      # returns 'Joe'
+      #   options.try(:age) # returns nil
+      def skip_validation
+        @skip_validation = true
+      end
+    end
+  end
+end

data/lib/sinclair/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 class Sinclair
-  VERSION = '1.6.5'
+  VERSION = '1.6.6'
 end

data/spec/integration/yard/sinclair/options_parser_spec.rb

@@ -13,5 +13,14 @@ describe Sinclair::OptionsParser do
         expect(model.the_method).to eq('The value is not 10 but 20')
       end
     end
+
+    describe '.skip_validation' do
+      it 'accepts options' do
+        options = BuilderOptions.new(name: 'Joe', age: 10)
+
+        expect(options.name).to eq('Joe')
+        expect(options.try(:age)).to be_nil
+      end
+    end
   end
 end

data/spec/lib/sinclair/options/class_methods_spec.rb

@@ -0,0 +1,255 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Sinclair::Options::ClassMethods do
+  subject(:options) { klass.new }
+
+  describe '.with_options' do
+    let(:klass)     { Class.new(Sinclair::Options) }
+    let(:test_keys) { %i[timeout retries invalid] }
+
+    context 'when calling with keys' do
+      it 'add first method' do
+        expect { klass.send(:with_options, :timeout, 'retries') }
+          .to add_method(:timeout).to(klass)
+      end
+
+      it 'add second method' do
+        expect { klass.send(:with_options, :timeout, 'retries') }
+          .to add_method(:retries).to(klass)
+      end
+
+      it 'adds options to allowed' do
+        expect { klass.send(:with_options, :timeout, 'retries') }
+          .to change { klass.invalid_options_in(test_keys) }
+          .from(%i[timeout retries invalid])
+          .to([:invalid])
+      end
+
+      it do
+        expect { klass.send(:with_options, :timeout, 'retries') }
+          .not_to change {
+                    Sinclair::Options.invalid_options_in(%i[timeout retries invalid])
+                  }
+      end
+
+      context 'when when calling method after building' do
+        before { klass.send(:with_options, :timeout, 'retries') }
+
+        it { expect(options.timeout).to be_nil }
+      end
+
+      context 'when calling method twice' do
+        before { klass.send(:with_options, :timeout, retries: 10) }
+
+        it do
+          expect { klass.send(:with_options, :timeout, :retries) }
+            .not_to change {
+                      klass.invalid_options_in(%i[timeout retries invalid])
+                    }
+        end
+      end
+    end
+
+    context 'when calling with a hash' do
+      it 'adds method' do
+        expect { klass.send(:with_options, timeout_sec: 10, 'retries' => 20) }
+          .to add_method(:timeout_sec).to(klass)
+      end
+
+      context 'when when calling method after building' do
+        before { klass.send(:with_options, timeout_sec: 10, 'retries' => 20) }
+
+        it 'returns default value' do
+          expect(options.retries).to eq(20)
+        end
+      end
+    end
+
+    context 'when calling on subclass' do
+      let(:super_class) { Class.new(Sinclair::Options) }
+      let(:klass)       { Class.new(super_class) }
+
+      let(:test_keys) do
+        %i[timeout retries name protocol port invalid]
+      end
+
+      before { super_class.send(:with_options, :timeout, 'retries', name: 'My Connector') }
+
+      it 'add first method' do
+        expect { klass.send(:with_options, :protocol, 'port' => 443) }
+          .to add_method(:protocol).to(klass)
+      end
+
+      it 'add second method' do
+        expect { klass.send(:with_options, :protocol, 'port' => 443) }
+          .to add_method(:port).to(klass)
+      end
+
+      it do
+        expect { klass.send(:with_options, 'protocol', port: 443) }
+          .to change {
+                klass.invalid_options_in(test_keys)
+              }.from(%i[protocol port invalid])
+          .to([:invalid])
+      end
+
+      it do
+        expect { klass.send(:with_options, 'protocol', port: 443) }
+          .not_to change {
+                    super_class.invalid_options_in(%i[protocol port])
+                  }
+      end
+
+      context 'when overriding a method' do
+        it do
+          expect { klass.send(:with_options, :name, timeout: 10) }
+            .not_to change { klass.invalid_options_in(%i[name timeout]) }
+        end
+
+        it 'change methods to return new default' do
+          expect { klass.send(:with_options, :name, timeout: 10) }
+            .to change { klass.new.timeout }
+            .from(nil).to(10)
+        end
+
+        it 'change methods to return without default' do
+          expect { klass.send(:with_options, :name, timeout: 10) }
+            .to change { klass.new.name }
+            .from('My Connector').to(nil)
+        end
+      end
+    end
+  end
+
+  describe '.invalid_options_in' do
+    let(:klass)     { Class.new(Sinclair::Options) }
+    let(:test_keys) { %i[timeout invalid] }
+
+    it 'returns alls keys as invalid' do
+      expect(klass.invalid_options_in(test_keys))
+        .to eq(test_keys)
+    end
+
+    context 'when allowed options was never set' do
+      before { klass.allow(:timeout) }
+
+      it 'returns keys that are not allowed by the input' do
+        expect(klass.invalid_options_in(test_keys))
+          .to eq([:invalid])
+      end
+    end
+
+    context 'when calling on subclass' do
+      let(:super_class) { Class.new(Sinclair::Options) }
+      let(:klass)       { Class.new(super_class) }
+      let(:test_keys)   { %i[timeout invalid] }
+
+      before { super_class.allow(:timeout) }
+
+      context 'when not adding allowed options' do
+        it 'returns keys that are not allowed by the input' do
+          expect(klass.invalid_options_in(test_keys))
+            .to eq([:invalid])
+        end
+      end
+
+      context 'when adding keys' do
+        before { super_class.allow(:retries) }
+
+        it 'returns keys that are not allowed by the input' do
+          expect(klass.invalid_options_in(test_keys))
+            .to eq([:invalid])
+        end
+
+        it 'adds new key to accepted' do
+          expect(klass.invalid_options_in([:retries]))
+            .to be_empty
+        end
+      end
+    end
+  end
+
+  describe '.allow' do
+    let(:klass)     { Class.new(Sinclair::Options) }
+    let(:test_keys) { %i[timeout retries invalid] }
+
+    it 'adds options to allowed' do
+      expect { klass.allow(:timeout) }
+        .to change { klass.invalid_options_in(test_keys) }
+        .from(%i[timeout retries invalid])
+        .to(%i[retries invalid])
+    end
+
+    context 'when calling on subclass' do
+      let(:super_class) { Class.new(Sinclair::Options) }
+      let(:klass)       { Class.new(super_class) }
+
+      before { super_class.allow(:timeout) }
+
+      it 'adds options to allowed' do
+        expect { klass.allow(:retries) }
+          .to change { klass.invalid_options_in(test_keys) }
+          .from(%i[retries invalid])
+          .to(%i[invalid])
+      end
+    end
+  end
+
+  describe '.allowed_options' do
+    let(:klass) { Class.new(Sinclair::Options) }
+
+    context 'when class has not been changed' do
+      it { expect(klass.allowed_options).to be_a(Set) }
+    end
+
+    context 'when initializing with with options' do
+      let(:expected) do
+        Set.new %i[timeout retries port protocol]
+      end
+
+      before do
+        klass.send(
+          :with_options,
+          :timeout, :retries, port: 443, protocol: 'https'
+        )
+      end
+
+      it do
+        expect(klass.allowed_options)
+          .to eq(expected)
+      end
+
+      context 'when class is descendent' do
+        let(:descendent_class) { Class.new(klass) }
+        let(:expected) do
+          Set.new %i[timeout retries port protocol name]
+        end
+
+        before do
+          descendent_class.send(
+            :with_options,
+            :name
+          )
+        end
+
+        it do
+          expect(descendent_class.allowed_options)
+            .to eq(expected)
+        end
+      end
+    end
+  end
+
+  describe '.skip_validation' do
+    let(:klass) { Class.new(Sinclair::Options) }
+
+    it 'skip initialization validation' do
+      klass.send(:skip_validation)
+
+      expect { klass.new(invalid: 10) }
+        .not_to raise_error
+    end
+  end
+end

data/spec/lib/sinclair/options_spec.rb

@@ -5,243 +5,6 @@ require 'spec_helper'
 describe Sinclair::Options do
   subject(:options) { klass.new }
 
-  describe '.with_options' do
-    let(:klass)     { Class.new(described_class) }
-    let(:test_keys) { %i[timeout retries invalid] }
-
-    context 'when calling with keys' do
-      it 'add first method' do
-        expect { klass.send(:with_options, :timeout, 'retries') }
-          .to add_method(:timeout).to(klass)
-      end
-
-      it 'add second method' do
-        expect { klass.send(:with_options, :timeout, 'retries') }
-          .to add_method(:retries).to(klass)
-      end
-
-      it 'adds options to allowed' do
-        expect { klass.send(:with_options, :timeout, 'retries') }
-          .to change { klass.invalid_options_in(test_keys) }
-          .from(%i[timeout retries invalid])
-          .to([:invalid])
-      end
-
-      it do
-        expect { klass.send(:with_options, :timeout, 'retries') }
-          .not_to change {
-                    described_class.invalid_options_in(%i[timeout retries invalid])
-                  }
-      end
-
-      context 'when when calling method after building' do
-        before { klass.send(:with_options, :timeout, 'retries') }
-
-        it { expect(options.timeout).to be_nil }
-      end
-
-      context 'when calling method twice' do
-        before { klass.send(:with_options, :timeout, retries: 10) }
-
-        it do
-          expect { klass.send(:with_options, :timeout, :retries) }
-            .not_to change {
-                      klass.invalid_options_in(%i[timeout retries invalid])
-                    }
-        end
-      end
-    end
-
-    context 'when calling with a hash' do
-      it 'adds method' do
-        expect { klass.send(:with_options, timeout_sec: 10, 'retries' => 20) }
-          .to add_method(:timeout_sec).to(klass)
-      end
-
-      context 'when when calling method after building' do
-        before { klass.send(:with_options, timeout_sec: 10, 'retries' => 20) }
-
-        it 'returns default value' do
-          expect(options.retries).to eq(20)
-        end
-      end
-    end
-
-    context 'when calling on subclass' do
-      let(:super_class) { Class.new(described_class) }
-      let(:klass)       { Class.new(super_class) }
-
-      let(:test_keys) do
-        %i[timeout retries name protocol port invalid]
-      end
-
-      before { super_class.send(:with_options, :timeout, 'retries', name: 'My Connector') }
-
-      it 'add first method' do
-        expect { klass.send(:with_options, :protocol, 'port' => 443) }
-          .to add_method(:protocol).to(klass)
-      end
-
-      it 'add second method' do
-        expect { klass.send(:with_options, :protocol, 'port' => 443) }
-          .to add_method(:port).to(klass)
-      end
-
-      it do
-        expect { klass.send(:with_options, 'protocol', port: 443) }
-          .to change {
-                klass.invalid_options_in(test_keys)
-              }.from(%i[protocol port invalid])
-          .to([:invalid])
-      end
-
-      it do
-        expect { klass.send(:with_options, 'protocol', port: 443) }
-          .not_to change {
-                    super_class.invalid_options_in(%i[protocol port])
-                  }
-      end
-
-      context 'when overriding a method' do
-        it do
-          expect { klass.send(:with_options, :name, timeout: 10) }
-            .not_to change { klass.invalid_options_in(%i[name timeout]) }
-        end
-
-        it 'change methods to return new default' do
-          expect { klass.send(:with_options, :name, timeout: 10) }
-            .to change { klass.new.timeout }
-            .from(nil).to(10)
-        end
-
-        it 'change methods to return without default' do
-          expect { klass.send(:with_options, :name, timeout: 10) }
-            .to change { klass.new.name }
-            .from('My Connector').to(nil)
-        end
-      end
-    end
-  end
-
-  describe '.invalid_options_in' do
-    let(:klass)     { Class.new(described_class) }
-    let(:test_keys) { %i[timeout invalid] }
-
-    it 'returns alls keys as invalid' do
-      expect(klass.invalid_options_in(test_keys))
-        .to eq(test_keys)
-    end
-
-    context 'when allowed options was never set' do
-      before { klass.allow(:timeout) }
-
-      it 'returns keys that are not allowed by the input' do
-        expect(klass.invalid_options_in(test_keys))
-          .to eq([:invalid])
-      end
-    end
-
-    context 'when calling on subclass' do
-      let(:super_class) { Class.new(described_class) }
-      let(:klass)       { Class.new(super_class) }
-      let(:test_keys)   { %i[timeout invalid] }
-
-      before { super_class.allow(:timeout) }
-
-      context 'when not adding allowed options' do
-        it 'returns keys that are not allowed by the input' do
-          expect(klass.invalid_options_in(test_keys))
-            .to eq([:invalid])
-        end
-      end
-
-      context 'when adding keys' do
-        before { super_class.allow(:retries) }
-
-        it 'returns keys that are not allowed by the input' do
-          expect(klass.invalid_options_in(test_keys))
-            .to eq([:invalid])
-        end
-
-        it 'adds new key to accepted' do
-          expect(klass.invalid_options_in([:retries]))
-            .to be_empty
-        end
-      end
-    end
-  end
-
-  describe '.allow' do
-    let(:klass)     { Class.new(described_class) }
-    let(:test_keys) { %i[timeout retries invalid] }
-
-    it 'adds options to allowed' do
-      expect { klass.allow(:timeout) }
-        .to change { klass.invalid_options_in(test_keys) }
-        .from(%i[timeout retries invalid])
-        .to(%i[retries invalid])
-    end
-
-    context 'when calling on subclass' do
-      let(:super_class) { Class.new(described_class) }
-      let(:klass)       { Class.new(super_class) }
-
-      before { super_class.allow(:timeout) }
-
-      it 'adds options to allowed' do
-        expect { klass.allow(:retries) }
-          .to change { klass.invalid_options_in(test_keys) }
-          .from(%i[retries invalid])
-          .to(%i[invalid])
-      end
-    end
-  end
-
-  describe '.allowed_options' do
-    let(:klass) { Class.new(described_class) }
-
-    context 'when class has not been changed' do
-      it { expect(klass.allowed_options).to be_a(Set) }
-    end
-
-    context 'when initializing with with options' do
-      let(:expected) do
-        Set.new %i[timeout retries port protocol]
-      end
-
-      before do
-        klass.send(
-          :with_options,
-          :timeout, :retries, port: 443, protocol: 'https'
-        )
-      end
-
-      it do
-        expect(klass.allowed_options)
-          .to eq(expected)
-      end
-
-      context 'when class is descendent' do
-        let(:descendent_class) { Class.new(klass) }
-        let(:expected) do
-          Set.new %i[timeout retries port protocol name]
-        end
-
-        before do
-          descendent_class.send(
-            :with_options,
-            :name
-          )
-        end
-
-        it do
-          expect(descendent_class.allowed_options)
-            .to eq(expected)
-        end
-      end
-    end
-  end
-
   describe '#initialize' do
     let(:klass) { ConnectionOptions }
 
@@ -323,6 +86,34 @@ describe Sinclair::Options do
       end
     end
 
+    context 'when initializing with invalid args a class that skips validation' do
+      let(:klass) { OpenOptions }
+
+      it do
+        expect { klass.new(valid_option: 20, invalid: 10) }
+          .not_to raise_error
+      end
+
+      it 'initialize option' do
+        expect(klass.new(valid_option: 20, invalid: 10).valid_option)
+          .to eq(20)
+      end
+
+      context 'when initializing a subclass' do
+        let(:klass) { Class.new(OpenOptions) }
+
+        it do
+          expect { klass.new(valid_option: 20, invalid: 10) }
+            .not_to raise_error
+        end
+
+        it 'initialize option' do
+          expect(klass.new(valid_option: 20, invalid: 10).valid_option)
+            .to eq(20)
+        end
+      end
+    end
+
     context 'when initializing with string or symbol keys' do
       it do
         expect { klass.new('timeout' => 20, retries: 30) }

data/spec/support/models/builder_options.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class BuilderOptions < Sinclair::Options
+  with_options :name
+
+  skip_validation
+end

data/spec/support/models/open_options.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class OpenOptions < Sinclair::Options
+  with_options :valid_option
+
+  skip_validation
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sinclair
 version: !ruby/object:Gem::Version
-  version: 1.6.5
+  version: 1.6.6
 platform: ruby
 authors:
 - DarthJee
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-05-17 00:00:00.000000000 Z
+date: 2020-05-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -300,6 +300,7 @@ files:
 - lib/sinclair/method_definitions.rb
 - lib/sinclair/options.rb
 - lib/sinclair/options/builder.rb
+- lib/sinclair/options/class_methods.rb
 - lib/sinclair/options_parser.rb
 - lib/sinclair/version.rb
 - sinclair.gemspec
@@ -350,6 +351,7 @@ files:
 - spec/lib/sinclair/method_definition_spec.rb
 - spec/lib/sinclair/method_definitions_spec.rb
 - spec/lib/sinclair/options/builder_spec.rb
+- spec/lib/sinclair/options/class_methods_spec.rb
 - spec/lib/sinclair/options_parser_spec.rb
 - spec/lib/sinclair/options_spec.rb
 - spec/lib/sinclair_spec.rb
@@ -357,6 +359,7 @@ files:
 - spec/support/fixture_helpers.rb
 - spec/support/models/app_client.rb
 - spec/support/models/app_config.rb
+- spec/support/models/builder_options.rb
 - spec/support/models/client.rb
 - spec/support/models/connection_options.rb
 - spec/support/models/default_value.rb
@@ -381,6 +384,7 @@ files:
 - spec/support/models/my_configurable.rb
 - spec/support/models/my_model.rb
 - spec/support/models/my_server_config.rb
+- spec/support/models/open_options.rb
 - spec/support/models/person.rb
 - spec/support/models/purchase.rb
 - spec/support/models/random_generator.rb