support responseSetFilters, fix specs

Author: patodevilla

Gemfile.lock

@@ -8,7 +8,7 @@ GIT
 PATH
   remote: .
   specs:
-    json_schema_form (0.10.1)
+    json_schema_form (0.12.0)
       activesupport (~> 6)
       dry-schema (~> 1.10)
       json_schemer (= 0.2.17)
@@ -72,10 +72,10 @@ GEM
     rake (13.0.6)
     regexp_parser (2.5.0)
     ruby-progressbar (1.11.0)
-    tzinfo (2.0.5)
+    tzinfo (2.0.6)
       concurrent-ruby (~> 1.0)
     uri_template (0.7.0)
-    zeitwerk (2.6.0)
+    zeitwerk (2.6.7)
 
 PLATFORMS
   ruby

lib/jsf/forms/condition.rb

@@ -84,7 +84,7 @@ def errors(**passthru)
 
       # @return [NilClass, String]
       def condition_property_key
-        self.dig('if', 'properties')&.keys&.first
+        dig('if', 'properties')&.keys&.first
       end
 
       # @return [NilClass, String]
@@ -94,42 +94,38 @@ def condition_property
 
       # @return [Boolean]
       def negated
-        !!self.dig('if', 'properties', condition_property_key)&.key?('not')
+        !!dig('if', 'properties', condition_property_key)&.key?('not')
       end
 
-      # @return [nil, 'enum', 'const']
+      # @return [nil, 'enum', 'const', 'not_enum', 'not_const']
       def condition_type
-        if negated
-          self.dig('if', 'properties', condition_property_key, 'not')&.keys&.first
+        hash = dig('if', 'properties', condition_property_key)
+        return unless hash
+
+        if hash.key?('not')
+          "not_#{hash['not'].keys.first}"
         else
-          self.dig('if', 'properties', condition_property_key)&.keys&.first
+          hash.keys.first
         end
       end
 
       # @return [NilClass, String]
       def value
-        if negated
-          self.dig('if', 'properties', condition_property_key, 'not', condition_type)
-        else
-          self.dig('if', 'properties', condition_property_key, condition_type)
-        end
+        path = JSF::Forms::Form::CONDITION_TYPE_TO_PATH.call(condition_type)
+        dig('if', 'properties', condition_property_key, *path)
       end
 
       # Sets a new value for the condition
       #
       # @param [String, Boolean, Number] value
-      # @param [Boolean] negated
       # @param ['const', 'enum']
       #
       # @return [void]
-      def set_value(value, negated: self.negated, condition_type: self.condition_type)
-        self.dig('if', 'properties')&.clear
-
-        path = ['if', 'properties', condition_property_key]
-        path.push('not') if negated
-        path.push(condition_type)
+      def set_value(value, condition_type: self.condition_type)
+        dig('if', 'properties')&.clear
 
-        SuperHash::Utils.bury(self, *path, value)
+        path = JSF::Forms::Form::CONDITION_TYPE_TO_PATH.call(condition_type)
+        SuperHash::Utils.bury(self, 'if', 'properties', condition_property_key, *path, value)
       end
 
       # Takes a document or a part of a document (for nested hashes like JSF::Forms::Section) and

lib/jsf/forms/field/checkbox.rb

@@ -32,6 +32,7 @@ def validation_schema(passthru)
                 end
               end
               required(:pictures).value(:array?).array(:str?)
+              optional(:responseSetFilters).value(:array?).array(:str?)
               required(:sort).filled(:integer)
               required(:visibility).hash do
                 required(:label).filled(:bool)

lib/jsf/forms/field/concerns/conditionable.rb

@@ -15,8 +15,8 @@ def insert_property_at_index(*args, **kwargs, &block)
             meta.dig(:parent).insert_conditional_property_at_index(*args, dependent_on: key_name, **kwargs, &block)
           end
 
-          def condition(*arguments, &block)
-            meta.dig(:parent).condition(key_name, *arguments, &block)
+          def find_or_add_condition(*arguments, &block)
+            meta.dig(:parent).find_or_add_condition(key_name, *arguments, &block)
           end
 
           # delegate

lib/jsf/forms/field/concerns/response_settable.rb

@@ -11,6 +11,19 @@ module ResponseSettable
           ###VALIDATIONS####
           ##################
 
+          # since we cannot augment the displayProperties schema, remove 'responseSetFilters' when valid
+          # so it passes validations
+          def validation_schema(passthru)            
+            Dry::Schema.define(parent: super) do
+              before(:key_validator) do |result|
+                hash = result.to_h
+                d_p = hash['displayProperties']
+                d_p.delete('responseSetFilters') if d_p && d_p['responseSetFilters'].is_a?(::Array)
+                hash
+              end
+            end
+          end
+
           # # Consider response set
           # #
           # # @param [] locale

lib/jsf/forms/field/select.rb

@@ -34,6 +34,7 @@ def validation_schema(passthru)
                 end
               end
               required(:pictures).value(:array?).array(:str?)
+              optional(:responseSetFilters).value(:array?).array(:str?)
               required(:sort).filled(:integer)
               required(:visibility).hash do
                 required(:label).filled(:bool)

lib/jsf/forms/form.rb

@@ -633,15 +633,21 @@ def resort!
       #
       # @param dependent_on [Symbol] name of property the condition depends on
       # @param type [Symbol] type of condition to filter by
-      # @param value [String,Boolean,Integer] Value that makes the condition TRUE
-      # @return [JSF::Schema]
-      def get_condition(dependent_on, type, value)
+      # @param value [*] Value that makes the condition TRUE
+      # @return [Array<JSF::Schema>, NilClass]
+      def get_conditions(dependent_on, type, value=nil)
         cond_path = CONDITION_TYPE_TO_PATH.call(type)
-        self[:allOf]&.find do |condition|
-          if [:enum, :not_enum].include?(type)
-            condition.dig(:if, :properties, dependent_on, *cond_path)&.include?(value)
+
+        self[:allOf]&.select do |condition|
+          prop_schema = condition.dig(:if, :properties, dependent_on)
+          next unless prop_schema
+
+          condition_value = prop_schema.dig(*cond_path)
+
+          if [:enum, :not_enum].include?(type.to_sym)
+            condition_value&.include?(value)
           else
-            condition.dig(:if, :properties, dependent_on, *cond_path) == value
+            condition_value == value
           end
         end
       end
@@ -668,8 +674,8 @@ def add_condition(dependent_on, type, value)
         self[:allOf].last
       end
 
-      def condition(dependent_on, type, value, &block)
-        condition = get_condition(dependent_on, type, value) || add_condition(dependent_on, type, value)
+      def find_or_add_condition(dependent_on, type, value, &block)
+        condition = get_conditions(dependent_on, type, value)&.first || add_condition(dependent_on, type, value)
         condition[:then].instance_eval(&block) if block_given?
         condition
       end
@@ -688,7 +694,7 @@ def insert_conditional_property_at_index(sort_value, property_id, definition, de
           raise ArgumentError.new("sort must be an Integer, :prepend or :append, got #{sort_value}")
         end
 
-        condition = condition(dependent_on, type, value)
+        condition = find_or_add_condition(dependent_on, type, value)
         subform = condition[:then]
 
         case sort_value

lib/jsf/forms/response.rb

@@ -42,6 +42,7 @@ def validation_schema(passthru)
               end
             end
             optional(:color).maybe(:string)
+            optional(:tags).value(:array?).array(:str?)
           end
           if passthru[:is_inspection]
             required(:enableScore).value(Types::True) #deprecate?

lib/jsf/version.rb

@@ -1,3 +1,3 @@
 module JSF
-  VERSION = "0.11.0"
+  VERSION = "0.12.0"
 end

test/spec/forms/condition_spec.rb

@@ -69,11 +69,11 @@ def test_condition_type
 
     # not const
     instance['if']['properties']['some_prop'] = { not: { const: true } }
-    assert_equal 'const', instance.condition_type
+    assert_equal 'not_const', instance.condition_type
 
     # not enum
     instance['if']['properties']['some_prop'] = { not: { enum: true } }
-    assert_equal 'enum', instance.condition_type
+    assert_equal 'not_enum', instance.condition_type
 
     # const
     instance['if']['properties']['some_prop'] = { const: true }
@@ -123,17 +123,17 @@ def test_set_value
 
     instance.set_value(1)
     assert_equal true, instance.negated
-    assert_equal 'const', instance.condition_type
+    assert_equal 'not_const', instance.condition_type
     assert_equal 1, instance.value
 
     instance.set_value(2, condition_type: 'enum')
-    assert_equal true, instance.negated
+    assert_equal false, instance.negated
     assert_equal 'enum', instance.condition_type
     assert_equal 2, instance.value
 
-    instance.set_value(3, condition_type: 'enum', negated: false)
-    assert_equal false, instance.negated
-    assert_equal 'enum', instance.condition_type
+    instance.set_value(3, condition_type: 'not_enum')
+    assert_equal true, instance.negated
+    assert_equal 'not_enum', instance.condition_type
     assert_equal 3, instance.value
   end
 

test/spec/forms/form_builder_spec.rb

@@ -8,7 +8,7 @@ class FormbuilderTest < Minitest::Test
   def test_fixtures
     klasses = {
       JSF::Forms::SharedRef => [
-        {errors_args: {unless: ->(i, key){key = :ref_presence} }}
+        {errors_args: {unless: ->(i, key){key == :ref_presence} }}
       ],
       JSF::Forms::Form => [],
       JSF::Forms::ResponseSet => [],
@@ -20,18 +20,18 @@ def test_fixtures
 
       # fields
       JSF::Forms::Field::Checkbox => [
-        {errors_args: {unless: ->(i, key){key = :ref_presence} }}
+        {errors_args: {unless: ->(i, key){key == :ref_presence} }}
       ],
       JSF::Forms::Field::Shared => [
-        {errors_args: {unless: ->(i, key){key = :ref_presence} }}
+        {errors_args: {unless: ->(i, key){key == :ref_presence} }}
       ],
       JSF::Forms::Field::DateInput => [],
       JSF::Forms::Field::FileInput => [],
       JSF::Forms::Field::GeoPoints => [],
       JSF::Forms::Field::Markdown => [],
       JSF::Forms::Field::NumberInput => [],
       JSF::Forms::Field::Select => [
-        {errors_args: {unless: ->(i, key){key = :ref_presence} }}
+        {errors_args: {unless: ->(i, key){key == :ref_presence} }}
       ],
       JSF::Forms::Field::Signature => [],
       JSF::Forms::Field::Slider => [],
@@ -88,7 +88,7 @@ def test_builder_example
         append_property :depedendent_select1, example('select'), type: :const, value: 'option1'
         append_property :depedendent_select2, example('select'), type: :enum, value: ['option1']
 
-        condition(:const, 'option2') do
+        find_or_add_condition(:const, 'option2') do
           append_property(:depedendent_select3, example('select')) do |f|
             f.response_set_id = :response_set_1
             f.hidden = true

test/spec/forms/form_spec.rb

@@ -516,7 +516,7 @@ def test_resort!
     assert_equal 2, form.get_property('switch_3').sort
   end
 
-  def test_get_condition
+  def test_get_conditions
     form = JSF::Forms::FormBuilder.build() do
       append_property(:prop1, example('select'))
       add_condition('prop1', :const, 'const')
@@ -526,16 +526,16 @@ def test_get_condition
     end
 
     # found
-    assert_equal 'const', form.get_condition(:prop1, :const, 'const')&.dig(:if, :properties, :prop1, :const)
-    assert_equal 'not_const', form.get_condition(:prop1, :not_const, 'not_const')&.dig(:if, :properties, :prop1, :not, :const)
-    assert_equal 'enum', form.get_condition(:prop1, :enum, 'enum')&.dig(:if, :properties, :prop1, :enum)&.first
-    assert_equal 'not_enum', form.get_condition(:prop1, :not_enum, 'not_enum')&.dig(:if, :properties, :prop1, :not, :enum)&.first
+    assert_equal 'const', form.get_conditions(:prop1, :const, 'const').first.dig(:if, :properties, :prop1, :const)
+    assert_equal 'not_const', form.get_conditions(:prop1, :not_const, 'not_const').first.dig(:if, :properties, :prop1, :not, :const)
+    assert_equal ['enum'], form.get_conditions(:prop1, :enum, 'enum').first.dig(:if, :properties, :prop1, :enum)
+    assert_equal ['not_enum'], form.get_conditions(:prop1, :not_enum, 'not_enum').first.dig(:if, :properties, :prop1, :not, :enum)
 
     # not found
-    assert_nil form.get_condition(:prop1, :const, 'other_value')
+    assert_nil form.get_conditions(:prop1, :const, 'other_value').first
 
     # invalid key
-    assert_raises(ArgumentError){ form.get_condition(:prop1, :wrong_key, 'other_value') }
+    assert_raises(ArgumentError){ form.get_conditions(:prop1, :wrong_key, 'other_value') }
   end
 
   def test_add_condition
@@ -1233,7 +1233,7 @@ def test_scored?
     # non root
     complex_non_scorable_form = JSF::Forms::FormBuilder.build do
       append_property(:number_input_1, example('number_input')) do |f|
-        condition(:const, 1) do
+        find_or_add_condition(:const, 1) do
           append_property(:markdown_1_1, example('markdown'), type: :const, value: 1)
           append_property(:section, example('section')) do |f|
             f.form.instance_eval do