expected 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: '0954ddfccf5072455413c702650c98e39ccdbd72a1db7806463598e5c6c0e52b'
+  data.tar.gz: c41841fcb0cfcfde9dfff9c1c27445f88c10a168254c965ea681a0e62676ee0c
+SHA512:
+  metadata.gz: a6cf5251016d8d3f9b36af9ac429a0e9c8f433ee4c03b687a438e339d84361c913df7b63f6779597b49f0fb675ca4998c9da8a066e1371458ad04c1dff3675b5
+  data.tar.gz: bb7461e7f4e02295962c7b52288e86a710bf72f93f7a6ab4129eb29a8f9b7d27a66c50c95eea4b0d8681d0ed620b95f0237cf02818b5c5fda5de1e30f81f82c7

data/MIT-LICENSE

@@ -0,0 +1,22 @@
+Copyright 2019 Taylor Yelverton
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,94 @@
+# Expected: RSpec Matchers - Extended [![Gem Version][version-badge]][rubygems] [![Total Downloads][downloads-total]][rubygems] [![Downloads][downloads-badge]][rubygems]
+
+[version-badge]: https://img.shields.io/gem/v/expected.svg
+[rubygems]: https://rubygems.org/gems/expected
+[downloads-total]: https://img.shields.io/gem/dt/expected.svg
+[downloads-badge]: https://img.shields.io/gem/dtv/expected.svg
+
+Adds several simple matchers to RSpec
+
+
+
+## Installation
+
+### Add to Gemfile
+```ruby
+group :test do
+  gem 'expected'
+end
+```
+
+### Add to RSpec
+Add the following to your projects `spec/rails_helper.rb` for Rails apps, or `spec/spec_helper.rb for non-Rails apps.
+```ruby
+Expected.configure do |config|
+end
+```
+
+
+
+
+
+## Usage
+
+
+
+### `inherit_from`
+Used to test inheritance
+
+```ruby
+# Test if the subject inherits from the supplied Class
+it { is_expected.to inherit_from(SomeClass) }
+```
+
+
+
+### `have_constant`
+Used to test constants
+
+```ruby
+# Test if a constant exists
+it { is_expected.to have_constant(:FOO) }
+
+# Test if a constant has a specific value
+it { is_expected.to have_constant(:FOO).with_value("bar") }
+
+# Test if a constant's value is a specific type
+it { is_expected.to have_constant(:FOO).of_type(String) }
+```
+
+
+
+### `have_attr_reader`
+Used to test inclusion of `attr_reader :attribute`
+
+```ruby
+# Test if the subject has `attr_reader :attribute`
+it { is_expected.to have_attr_reader(:attribute) }
+```
+
+
+
+### `have_attr_writer`
+Used to test inclusion of `attr_writer :attribute`
+
+```ruby
+# Test if the subject has `attr_writer :attribute`
+it { is_expected.to have_attr_writer(:attribute) }
+```
+
+
+
+### `have_attr_accessor`
+Used to test inclusion of `attr_accessor :attribute`
+
+```ruby
+# Test if the subject has `attr_accessor :attribute`
+it { is_expected.to have_attr_accessor(:attribute) }
+```
+
+
+
+## License
+Expected is copyright © 2019-2020 Taylor Yelverton.
+It is free software, and may be redistributed under the terms specified in the MIT-LICENSE file.

data/lib/expected.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+# Container Module
+module Expected
+
+end
+
+require 'active_support/hash_with_indifferent_access'
+require 'active_support/core_ext/hash/indifferent_access'
+
+require 'expected/version'
+require 'expected/configuration'
+require 'expected/matchers'

data/lib/expected/configuration.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+# :nodoc:
+module Expected
+  class << self
+
+    # Configure the library
+    # @yield [Configuration]
+    def configure
+      yield configuration
+    end
+
+    # Memoized {Configuration}
+    # @return [Configuration]
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+  end
+
+  # Configuration class
+  class Configuration
+  end
+
+end

data/lib/expected/matchers.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Expected
+  # Matchers container
+  module Matchers
+  end
+end
+
+require 'expected/matchers/have_constant'
+require 'expected/matchers/inherit_from'
+require 'expected/matchers/have_attr_reader'
+require 'expected/matchers/have_attr_writer'
+require 'expected/matchers/have_attr_accessor'

data/lib/expected/matchers/have_attr_accessor.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module Expected
+  # :nodoc:
+  module Matchers
+
+    # Used to test inclusion of `attr_accessor :attribute` on the subject
+    # @param attribute [String, Symbol]
+    # @return [HaveAttrAccessorMatcher]
+    #
+    # @example Test if the subject has `attr_accessor :attribute`
+    #   it { is_expected.to have_attr_accessor(:some_attribute) }
+    #
+    def have_attr_accessor(attribute) # rubocop:disable Naming/PredicateName
+      HaveAttrAccessorMatcher.new(attribute)
+    end
+
+    # Class used by {#have_constant}
+    class HaveAttrAccessorMatcher
+      attr_reader :attribute, :subject, :has_attr_reader, :has_attr_writer
+
+      # @param attribute [String, Symbol] The attribute the {#subject} is expected to have an attr_accessor for
+      def initialize(attribute)
+        unless attribute.is_a?(String) || attribute.is_a?(Symbol)
+          raise 'HaveAttrAccessorMatcher attribute must be a String or Symbol'
+        end
+        @attribute = attribute.to_sym
+        @has_attr_reader = HaveAttrReaderMatcher.new(attribute)
+        @has_attr_writer = HaveAttrWriterMatcher.new(attribute)
+      end
+
+      # Run the test
+      # @param subject The thing to test against
+      # @return [True] If the test passes
+      # @return [False] if the test fails
+      def matches?(subject)
+        self.subject = subject
+        matches_attr_reader? && matches_attr_writer?
+      end
+
+      # @return [String]
+      def failure_message
+        "Expected #{expectation} (#{@failure})"
+      end
+
+      # @return [String]
+      def failure_message_when_negated
+        "Did not expect #{expectation}"
+      end
+
+      # @return [String]
+      def description
+        "have_attr_accessor: `#{attribute}`"
+      end
+
+      private
+
+        # The thing to test against
+        # @return [Class, Module]
+        def subject=(subject) # rubocop:disable Style/TrivialAccessors
+          @subject = subject
+        end
+
+        def matches_attr_reader?
+          ret = has_attr_reader.matches?(subject)
+          msg = has_attr_reader.instance_variable_get(:@failure)
+          @failure = msg if msg
+          ret
+        end
+
+        def matches_attr_writer?
+          ret = has_attr_writer.matches?(subject)
+          msg = has_attr_writer.instance_variable_get(:@failure)
+          @failure = msg if msg
+          ret
+        end
+
+        # @return String
+        def expectation
+          "<#{subject}> to have attr_accessor `#{attribute}`"
+        end
+
+    end
+
+  end
+end

data/lib/expected/matchers/have_attr_reader.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module Expected
+  # :nodoc:
+  module Matchers
+
+    # Used to test inclusion of `attr_reader :attribute` on the subject
+    # @param attribute [String, Symbol]
+    # @return [HaveAttrReaderMatcher]
+    #
+    # @example Test if the subject has `attr_reader :attribute`
+    #   it { is_expected.to have_attr_reader(:some_attribute) }
+    #
+    def have_attr_reader(attribute) # rubocop:disable Naming/PredicateName
+      HaveAttrReaderMatcher.new(attribute)
+    end
+
+    # Class used by {#have_constant}
+    class HaveAttrReaderMatcher
+      attr_reader :attribute, :subject
+
+      # @param attribute [String, Symbol] The attribute the {#subject} is expected to have an attr_reader for
+      def initialize(attribute)
+        unless attribute.is_a?(String) || attribute.is_a?(Symbol)
+          raise 'HaveAttrReaderMatcher attribute must be a String or Symbol'
+        end
+        @attribute = attribute.to_sym
+      end
+
+      # Run the test
+      # @param subject The thing to test against
+      # @return [True] If the test passes
+      # @return [False] if the test fails
+      def matches?(subject)
+        self.subject = subject
+        method? &&
+          returns_correct_value?
+      end
+
+      # @return [String]
+      def failure_message
+        "Expected #{expectation} (#{@failure})"
+      end
+
+      # @return [String]
+      def failure_message_when_negated
+        "Did not expect #{expectation}"
+      end
+
+      # @return [String]
+      def description
+        "have_attr_reader: `#{attribute}`"
+      end
+
+      private
+
+        # The thing to test against
+        # @return [Class, Module]
+        def subject=(subject)
+          @original_subject = subject
+          @subject = subject.instance_of?(Class) ? subject.allocate : subject
+        end
+
+        # @return [Symbol]
+        def attribute_ivar
+          @attribute_ivar ||= :"@#{attribute}"
+        end
+
+        def method?
+          if subject.respond_to? attribute
+            true
+          else
+            @failure = "no method `#{attribute}`"
+            false
+          end
+        end
+
+        def returns_correct_value? # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+          has_original_val = subject.instance_variable_defined?(attribute_ivar)
+          original_val = subject.instance_variable_get(attribute_ivar)
+          test_val = SecureRandom.hex
+          subject.instance_variable_set(attribute_ivar, test_val)
+          ret = if subject.send(attribute) == test_val
+                  true
+                else
+                  @failure = "method `#{attribute}` did not return the value of #{attribute_ivar}"
+                  false
+                end
+          subject.instance_variable_set(attribute_ivar, original_val) if has_original_val
+          ret
+        end
+
+        # @return String
+        def expectation
+          "<#{@original_subject}> to have attr_reader `#{attribute}`"
+        end
+
+    end
+
+  end
+end

data/lib/expected/matchers/have_attr_writer.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module Expected
+  # :nodoc:
+  module Matchers
+
+    # Used to test inclusion of `attr_writer :attribute` on the subject
+    # @param attribute [String, Symbol]
+    # @return [HaveAttrWriterMatcher]
+    #
+    # @example Test if the subject has `attr_writer :attribute`
+    #   it { is_expected.to have_attr_writer(:some_attribute) }
+    #
+    def have_attr_writer(attribute) # rubocop:disable Naming/PredicateName
+      HaveAttrWriterMatcher.new(attribute)
+    end
+
+    # Class used by {#have_constant}
+    class HaveAttrWriterMatcher
+      attr_reader :attribute, :subject
+
+      # @param attribute [String, Symbol] The attribute the {#subject} is expected to have an attr_writer for
+      def initialize(attribute)
+        unless attribute.is_a?(String) || attribute.is_a?(Symbol)
+          raise 'HaveAttrWriterMatcher attribute must be a String or Symbol'
+        end
+        @attribute = attribute.to_sym
+      end
+
+      # Run the test
+      # @param subject The thing to test against
+      # @return [True] If the test passes
+      # @return [False] if the test fails
+      def matches?(subject)
+        self.subject = subject
+        method? &&
+          sets_correct_value?
+      end
+
+      # @return [String]
+      def failure_message
+        "Expected #{expectation} (#{@failure})"
+      end
+
+      # @return [String]
+      def failure_message_when_negated
+        "Did not expect #{expectation}"
+      end
+
+      # @return [String]
+      def description
+        "have_attr_writer: `#{attribute}`"
+      end
+
+      private
+
+        # The thing to test against
+        # @return [Class, Module]
+        def subject=(subject)
+          @original_subject = subject
+          @subject = subject.instance_of?(Class) ? subject.allocate : subject
+        end
+
+        # @return [Symbol]
+        def attribute_ivar
+          @attribute_ivar ||= :"@#{attribute}"
+        end
+
+        # @return [Symbol]
+        def method_name
+          @method_name ||= :"#{attribute}="
+        end
+
+        def method?
+          if subject.respond_to? method_name
+            true
+          else
+            @failure = "no method `#{method_name}`"
+            false
+          end
+        end
+
+        def sets_correct_value? # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+          has_original_val = subject.instance_variable_defined?(attribute_ivar)
+          original_val = subject.instance_variable_get(attribute_ivar)
+          test_val = SecureRandom.hex
+          subject.send(method_name, test_val)
+          ret = if subject.instance_variable_get(attribute_ivar) == test_val
+                  true
+                else
+                  @failure = "method `#{method_name}` did not set the value of #{attribute_ivar}"
+                  false
+                end
+          subject.instance_variable_set(attribute_ivar, original_val) if has_original_val
+          ret
+        end
+
+        # @return String
+        def expectation
+          "<#{@original_subject}> to have attr_writer `#{attribute}`"
+        end
+
+    end
+
+  end
+end

data/lib/expected/matchers/have_constant.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+module Expected
+  # :nodoc:
+  module Matchers
+
+    # Used to test constants
+    # @param name [String, Symbol]
+    # @return [HaveConstantMatcher]
+    #
+    # @example Test if a constant exists
+    #   it { is_expected.to have_constant(:FOO) }
+    #
+    # @example Test if a constant has a specific value
+    #   it { is_expected.to have_constant(:FOO).with_value("bar") }
+    #
+    # @example Test if a constant's value is a specific type
+    #   it { is_expected.to have_constant(:FOO).of_type(String) }
+    #
+    def have_constant(name) # rubocop:disable Naming/PredicateName
+      HaveConstantMatcher.new(name)
+    end
+
+    # Class used by {#have_constant}
+    class HaveConstantMatcher
+      attr_reader :name, :subject
+
+      # @raise If the provided name is not a {String} or {Symbol}
+      # @param name [String, Symbol] The name of the constant
+      def initialize(name)
+        unless name.is_a?(String) || name.is_a?(Symbol)
+          raise 'HaveConstantMatcher constant name must be a String or Symbol'
+        end
+        @name = name
+      end
+
+      # Sets the expected value of the constant
+      # @param value The expected value of the constant
+      # @return [self]
+      def with_value(value)
+        options[:value] = value
+        self
+      end
+
+      # Sets the expected type of the constant's value
+      # @param type [Module, Class] The expected type of the constant's value
+      # @return [self]
+      def of_type(type)
+        options[:type] = type
+        self
+      end
+
+      # Run the test
+      # @param subject The thing to test against
+      # @return [True] If the test passes
+      # @return [False] if the test fails
+      def matches?(subject)
+        self.subject = subject
+        constant_exists? &&
+          correct_type? &&
+          correct_value?
+      end
+
+      # @return [String]
+      def failure_message
+        "Expected #{expectation} (#{@failure})"
+      end
+
+      # @return [String]
+      def failure_message_when_negated
+        "Did not expect #{expectation}"
+      end
+
+      # @return [String]
+      def description
+        description = "have_constant: #{name}"
+        description += " of_type => #{options[:type].inspect}" if options.key? :type
+        description += " with_value => #{options[:value].inspect}" if options.key? :value
+        description
+      end
+
+      private
+
+        # @return [Hash]
+        def options
+          @options ||= {}.with_indifferent_access
+        end
+
+        # The thing to test against
+        # @return [Class, Module]
+        def subject=(subject)
+          @subject = subject.instance_of?(Class) || subject.is_a?(Module) ? subject : subject.class
+        end
+
+        # Check if the {#subject} has the constant
+        # @return Boolean
+        def constant_exists?
+          if subject.const_defined? name
+            true
+          else
+            @failure = 'missing constant'
+            false
+          end
+        end
+
+        # Check if the constants value is the correct type, specified from {#of_type}
+        # @return Boolean
+        def correct_type?
+          return true unless options.key? :type
+          value = subject.const_get(name)
+          if value.is_a? options[:type]
+            true
+          else
+            @failure = "type was <#{value.class}>"
+            false
+          end
+        end
+
+        # Check if the constants value is correct, specified from {#with_value}
+        # @return Boolean
+        def correct_value?
+          return true unless options.key? :value
+          value = subject.const_get(name)
+          if value == options[:value]
+            true
+          else
+            @failure = "value was #{value.inspect}"
+            false
+          end
+        end
+
+        # @return String
+        def expectation
+          expectation = "<#{subject}> to have a constant named #{name}"
+          expectation += " with a type of <#{options[:type]}>" if options[:type]
+          expectation += " with a value of #{options[:value].inspect}" if options[:value]
+          expectation
+        end
+
+    end
+
+  end
+end

data/lib/expected/matchers/inherit_from.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Expected
+  # :nodoc:
+  module Matchers
+
+    # Used to test inheritance
+    # @param expected_ancestor [Class]
+    # @return [InheritFromMatcher]
+    #
+    # @example Test if the subject inherits from the supplied Class
+    #   it { is_expected.to inherit_from(SomeClass) }
+    #
+    def inherit_from(expected_ancestor)
+      InheritFromMatcher.new(expected_ancestor)
+    end
+
+    # Class used by {#have_constant}
+    class InheritFromMatcher
+      attr_reader :expected_ancestor, :subject
+
+      # @param expected_ancestor [Class] The ancestor the {#subject} is expected to inherit from
+      def initialize(expected_ancestor)
+        @expected_ancestor = expected_ancestor
+      end
+
+      # Run the test
+      # @param subject The thing to test against
+      # @return [True] If the test passes
+      # @return [False] if the test fails
+      def matches?(subject)
+        self.subject = subject
+        self.subject.ancestors.include? expected_ancestor
+      end
+
+      # @return [String]
+      def failure_message
+        "Expected #{expectation}"
+      end
+
+      # @return [String]
+      def failure_message_when_negated
+        "Did not expect #{expectation}"
+      end
+
+      # @return [String]
+      def description
+        "inherit_from: <#{expected_ancestor.inspect}>"
+      end
+
+      private
+
+        # The thing to test against
+        # @return [Class, Module]
+        def subject=(subject)
+          @subject = subject.instance_of?(Class) || subject.is_a?(Module) ? subject : subject.class
+        end
+
+        # @return String
+        def expectation
+          "<#{subject.inspect}> to inherit from <#{expected_ancestor.inspect}>"
+        end
+
+    end
+
+  end
+end

data/lib/expected/version.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Expected
+
+  # Contains version information
+  module Version
+    MAJOR = 1
+    MINOR = 0
+    PATCH = 0
+
+  end
+
+  VERSION = [
+    Version::MAJOR,
+    Version::MINOR,
+    Version::PATCH,
+  ].join('.').freeze
+
+end

metadata

@@ -0,0 +1,78 @@
+--- !ruby/object:Gem::Specification
+name: expected
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Taylor Yelverton
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2020-03-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.0.0
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.0.0
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+description: RSpec's missing matchers
+email: rubygems@yelvert.io
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- lib/expected.rb
+- lib/expected/configuration.rb
+- lib/expected/matchers.rb
+- lib/expected/matchers/have_attr_accessor.rb
+- lib/expected/matchers/have_attr_reader.rb
+- lib/expected/matchers/have_attr_writer.rb
+- lib/expected/matchers/have_constant.rb
+- lib/expected/matchers/inherit_from.rb
+- lib/expected/version.rb
+homepage: https://github.com/yelvert/expected
+licenses:
+- MIT
+metadata:
+  bug_tracker_uri: https://github.com/yelvert/expected/issues
+  changelog_uri: https://github.com/yelvert/expected/commits/master
+  documentation_uri: https://github.com/yelvert/expected/wiki
+  homepage_uri: https://github.com/yelvert/expected
+  source_code_uri: https://github.com/yelvert/expected
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.4.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.4
+signing_key: 
+specification_version: 4
+summary: RSpec's missing matchers
+test_files: []