dequelabs
diff --git a/‎.gitignore‎
Lines changed: 1 addition & 0 deletions b/‎.gitignore‎
Lines changed: 1 addition & 0 deletions
diff --git a/‎packages/axe-core-api/Gemfile.lock‎
Lines changed: 1 addition & 16 deletions b/‎packages/axe-core-api/Gemfile.lock‎
Lines changed: 1 addition & 16 deletions
diff --git a/‎packages/axe-core-api/axe-core-api.gemspec‎
Lines changed: 0 additions & 4 deletions b/‎packages/axe-core-api/axe-core-api.gemspec‎
Lines changed: 0 additions & 4 deletions
diff --git a/‎packages/axe-core-api/lib/axe/api/results.rb‎
Lines changed: 4 additions & 4 deletions b/‎packages/axe-core-api/lib/axe/api/results.rb‎
Lines changed: 4 additions & 4 deletions
diff --git a/‎packages/axe-core-api/lib/axe/api/results/check.rb‎
Lines changed: 1 addition & 1 deletion b/‎packages/axe-core-api/lib/axe/api/results/check.rb‎
Lines changed: 1 addition & 1 deletion
diff --git a/‎packages/axe-core-api/lib/axe/api/results/checked_node.rb‎
Lines changed: 3 additions & 3 deletions b/‎packages/axe-core-api/lib/axe/api/results/checked_node.rb‎
Lines changed: 3 additions & 3 deletions
diff --git a/‎packages/axe-core-api/lib/axe/api/results/rule.rb‎
Lines changed: 2 additions & 2 deletions b/‎packages/axe-core-api/lib/axe/api/results/rule.rb‎
Lines changed: 2 additions & 2 deletions
diff --git a/‎packages/axe-core-api/lib/axe/api/value_object.rb‎
Lines changed: 123 additions & 3 deletions b/‎packages/axe-core-api/lib/axe/api/value_object.rb‎
Lines changed: 123 additions & 3 deletions
diff --git a/‎packages/axe-core-api/spec/axe/api/value_object_spec.rb‎
Lines changed: 132 additions & 0 deletions b/‎packages/axe-core-api/spec/axe/api/value_object_spec.rb‎
Lines changed: 132 additions & 0 deletions
@@ -17,3 +17,4 @@ rdoc
 .ruby-version
 bin/
 node_modules/
+vendor/
@@ -1,20 +1,15 @@
 PATH
   remote: .
   specs:
-    axe-core-api (4.8.0)
+    axe-core-api (4.11.3)
       dumb_delegator
-      virtus
 
 GEM
   remote: https://rubygems.org/
   specs:
     addressable (2.8.5)
       public_suffix (>= 2.0.2, < 6.0)
     ast (2.4.2)
-    axiom-types (0.1.1)
-      descendants_tracker (~> 0.0.4)
-      ice_nine (~> 0.11.0)
-      thread_safe (~> 0.3, >= 0.3.1)
     capybara (3.39.2)
       addressable
       matrix
@@ -24,13 +19,8 @@ GEM
       rack-test (>= 0.6.3)
       regexp_parser (>= 1.5, < 3.0)
       xpath (~> 3.2)
-    coercible (1.0.0)
-      descendants_tracker (~> 0.0.1)
-    descendants_tracker (0.0.4)
-      thread_safe (~> 0.3, >= 0.3.1)
     diff-lcs (1.5.0)
     dumb_delegator (1.0.0)
-    ice_nine (0.11.2)
     json (2.7.0)
     language_server-protocol (3.17.0.3)
     matrix (0.4.2)
@@ -85,12 +75,7 @@ GEM
       rexml (~> 3.2, >= 3.2.5)
       rubyzip (>= 1.2.2, < 3.0)
       websocket (~> 1.0)
-    thread_safe (0.3.6)
     unicode-display_width (2.5.0)
-    virtus (2.0.0)
-      axiom-types (~> 0.1)
-      coercible (~> 1.0)
-      descendants_tracker (~> 0.0, >= 0.0.3)
     watir (7.3.0)
       regexp_parser (>= 1.2, < 3)
       selenium-webdriver (~> 4.2)
 
@@ -24,10 +24,6 @@ Gem::Specification.new do |spec|
   ]
 
   spec.add_dependency "dumb_delegator"
-  # used by virtus; including it to make sure we install the gem and do not
-  # rely on the standard library version, which will be removed in 3.5.0
-  spec.add_dependency "ostruct"
-  spec.add_dependency "virtus"
 
   spec.add_development_dependency "bundler", "~> 2.1"
   spec.add_development_dependency "capybara"
 
@@ -6,16 +6,16 @@ class Results < ValueObject
       require_relative "./results/rule"
 
       values do
-        attribute :inapplicable, ::Array[Rule]
-        attribute :incomplete, ::Array[Rule]
-        attribute :passes, ::Array[Rule]
+        attribute :inapplicable, [Rule]
+        attribute :incomplete, [Rule]
+        attribute :passes, [Rule]
         attribute :timestamp
         attribute :testEngine
         attribute :testEnvironment
         attribute :testRunner
         attribute :toolOptions
         attribute :url, ::String
-        attribute :violations, ::Array[Rule]
+        attribute :violations, [Rule]
       end
 
       def failure_message
 
@@ -10,7 +10,7 @@ class Check < ValueObject
           attribute :id, ::Symbol
           attribute :impact, ::Symbol
           attribute :message, ::String
-          attribute :relatedNodes, ::Array[Node]
+          attribute :relatedNodes, [Node]
         end
 
         def failure_message
 
@@ -7,9 +7,9 @@ class Results
       class CheckedNode < Node
         values do
           attribute :impact, ::Symbol
-          attribute :any, ::Array[Check]
-          attribute :all, ::Array[Check]
-          attribute :none, ::Array[Check]
+          attribute :any, [Check]
+          attribute :all, [Check]
+          attribute :none, [Check]
           attribute :failureSummary, ::Symbol
           attribute :html, ::String
           attribute :target
 
@@ -11,8 +11,8 @@ class Rule < ValueObject
           attribute :help, ::String
           attribute :helpUrl, ::String
           attribute :impact, ::Symbol
-          attribute :tags, ::Array[::Symbol]
-          attribute :nodes, ::Array[CheckedNode]
+          attribute :tags, [::Symbol]
+          attribute :nodes, [CheckedNode]
         end
 
         def failure_messages(index)
 
@@ -1,9 +1,129 @@
-require 'virtus'
-
 module Axe
   module API
     class ValueObject
-      include ::Virtus.value_object mass_assignment: false, nullify_blank: false
+      class << self
+        def attributes
+          @attributes ||= superclass.respond_to?(:attributes) ? superclass.attributes.dup : {}
+        end
+
+        def values(&block)
+          instance_eval(&block)
+        end
+
+        def attribute(name, type = nil)
+          attributes[name] = type
+          attr_reader(name) unless method_defined?(name)
+        end
+      end
+
+      def initialize(attrs = {})
+        attrs ||= {}
+        self.class.attributes.each do |name, type|
+          raw = if attrs.respond_to?(:key?)
+                  if attrs.key?(name)
+                    attrs[name]
+                  elsif attrs.key?(name.to_s)
+                    attrs[name.to_s]
+                  end
+                elsif attrs.respond_to?(name)
+                  attrs.public_send(name)
+                end
+          instance_variable_set("@#{name}", coerce(raw, type))
+        end
+      end
+
+      def attributes
+        self.class.attributes.each_key.each_with_object({}) do |name, hash|
+          hash[name] = public_send(name)
+        end
+      end
+
+      def to_h
+        attributes
+      end
+
+      def to_hash
+        to_h
+      end
+
+      def ==(other)
+        other.instance_of?(self.class) && attributes == other.attributes
+      end
+      alias_method :eql?, :==
+
+      def hash
+        [self.class, attributes].hash
+      end
+
+      def inspect
+        pairs = attributes.map { |name, value| "#{name}=#{value.inspect}" }
+        pairs.empty? ? "#<#{self.class.name}>" : "#<#{self.class.name} #{pairs.join(" ")}>"
+      end
+
+      def [](name)
+        key = name.to_sym
+        self.class.attributes.key?(key) ? public_send(key) : nil
+      end
+
+      BOOLEAN_TRUE_STRINGS = %w[1 t T true TRUE].freeze
+      BOOLEAN_FALSE_STRINGS = %w[0 f F false FALSE].freeze
+
+      private
+
+      def coerce(value, type)
+        return value if type.nil?
+
+        case type
+        when Array
+          Array(value).map { |element| coerce(element, type.first) }
+        when Class
+          coerce_class(value, type)
+        else
+          value
+        end
+      end
+
+      # Virtus-compatible lenient coercion: returns the input unchanged when
+      # it can't be cleanly converted, rather than raising.
+      def coerce_class(value, type)
+        return nil if value.nil?
+
+        if type == ::Symbol
+          value.to_sym
+        elsif type == ::String
+          value.to_s
+        elsif type == ::Integer
+          coerce_integer(value)
+        elsif type == ::Float
+          coerce_float(value)
+        elsif type == ::TrueClass || type == ::FalseClass
+          coerce_boolean(value)
+        elsif type <= ValueObject
+          value.is_a?(type) ? value : type.new(value)
+        else
+          value
+        end
+      end
+
+      def coerce_integer(value)
+        return value.to_i if value.is_a?(::Numeric)
+        return value.to_i if value.is_a?(::String) && value =~ /\A-?\d+\z/
+        value
+      end
+
+      def coerce_float(value)
+        return value.to_f if value.is_a?(::Numeric)
+        return value.to_f if value.is_a?(::String) && value =~ /\A-?(?:\d+\.?\d*|\.\d+)\z/
+        value
+      end
+
+      def coerce_boolean(value)
+        return value if value == true || value == false
+        str = value.to_s
+        return true if BOOLEAN_TRUE_STRINGS.include?(str)
+        return false if BOOLEAN_FALSE_STRINGS.include?(str)
+        value
+      end
     end
   end
 end
@@ -0,0 +1,132 @@
+require "spec_helper"
+require_relative "../../../lib/axe/api/value_object"
+
+module Axe::API
+  describe ValueObject do
+    describe "Virtus-compatible lenient coercion" do
+      describe "Integer attribute" do
+        let(:klass) do
+          Class.new(ValueObject) do
+            values { attribute :count, Integer }
+          end
+        end
+
+        it "coerces numeric strings to Integer" do
+          expect(klass.new(count: "42").count).to eq(42)
+          expect(klass.new(count: "-7").count).to eq(-7)
+        end
+
+        it "passes through non-numeric strings unchanged (does not raise)" do
+          expect(klass.new(count: "abc").count).to eq("abc")
+          expect(klass.new(count: "42abc").count).to eq("42abc")
+        end
+
+        it "coerces numeric types via to_i" do
+          expect(klass.new(count: 3.7).count).to eq(3)
+          expect(klass.new(count: 5).count).to eq(5)
+        end
+
+        it "preserves nil" do
+          expect(klass.new(count: nil).count).to be_nil
+        end
+      end
+
+      describe "Float attribute" do
+        let(:klass) do
+          Class.new(ValueObject) do
+            values { attribute :ratio, Float }
+          end
+        end
+
+        it "coerces numeric strings to Float" do
+          expect(klass.new(ratio: "3.14").ratio).to eq(3.14)
+          expect(klass.new(ratio: ".5").ratio).to eq(0.5)
+          expect(klass.new(ratio: "-2.5").ratio).to eq(-2.5)
+          expect(klass.new(ratio: "42").ratio).to eq(42.0)
+        end
+
+        it "passes through non-numeric strings unchanged (does not raise)" do
+          expect(klass.new(ratio: "abc").ratio).to eq("abc")
+        end
+
+        it "coerces numeric types via to_f" do
+          expect(klass.new(ratio: 42).ratio).to eq(42.0)
+        end
+
+        it "preserves nil" do
+          expect(klass.new(ratio: nil).ratio).to be_nil
+        end
+      end
+
+      describe "Boolean attribute" do
+        let(:klass) do
+          Class.new(ValueObject) do
+            values { attribute :flag, TrueClass }
+          end
+        end
+
+        it "maps Virtus-style truthy strings to true" do
+          %w[1 t T true TRUE].each do |s|
+            expect(klass.new(flag: s).flag).to be(true), "expected #{s.inspect} -> true"
+          end
+        end
+
+        it "maps Virtus-style falsy strings to false" do
+          %w[0 f F false FALSE].each do |s|
+            expect(klass.new(flag: s).flag).to be(false), "expected #{s.inspect} -> false"
+          end
+        end
+
+        it "passes through booleans unchanged" do
+          expect(klass.new(flag: true).flag).to be(true)
+          expect(klass.new(flag: false).flag).to be(false)
+        end
+
+        it "passes through unrecognized strings unchanged" do
+          expect(klass.new(flag: "maybe").flag).to eq("maybe")
+        end
+
+        it "preserves nil" do
+          expect(klass.new(flag: nil).flag).to be_nil
+        end
+      end
+    end
+
+    describe "#to_hash" do
+      it "dispatches dynamically to subclass #to_h overrides" do
+        klass = Class.new(ValueObject) do
+          values { attribute :x }
+          def to_h
+            { x: x, extra: :from_override }
+          end
+        end
+
+        instance = klass.new(x: 1)
+        expect(instance.to_hash).to eq(instance.to_h)
+        expect(instance.to_hash).to eq(x: 1, extra: :from_override)
+      end
+    end
+
+    describe "#inspect" do
+      it "renders attributes inline" do
+        klass = Class.new(ValueObject) do
+          def self.name; "Sample"; end
+          values do
+            attribute :a
+            attribute :b
+          end
+        end
+
+        expect(klass.new(a: 1, b: "x").inspect).to eq('#<Sample a=1 b="x">')
+      end
+
+      it "has no trailing space when there are no attributes" do
+        klass = Class.new(ValueObject) do
+          def self.name; "Empty"; end
+        end
+
+        expect(klass.new.inspect).to eq("#<Empty>")
+      end
+    end
+  end
+end
Original file line number	Diff line number	Diff line change
`@@ -24,10 +24,6 @@ Gem::Specification.new do \|spec\|`
`24`	`24`	`]`
`25`	`25`
`26`	`26`	`spec.add_dependency "dumb_delegator"`
`27`		`- # used by virtus; including it to make sure we install the gem and do not`
`28`		`- # rely on the standard library version, which will be removed in 3.5.0`
`29`		`- spec.add_dependency "ostruct"`
`30`		`- spec.add_dependency "virtus"`
`31`	`27`
`32`	`28`	`spec.add_development_dependency "bundler", "~> 2.1"`
`33`	`29`	`spec.add_development_dependency "capybara"`