forest_liana 7.0.0.beta.1 → 7.0.0.beta.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 69b23785cf391fb245efbf6488e58fb19bbbc010e9dac0a91574412684e89129
-  data.tar.gz: 26d9dd7b466009b8a09182dec02778b729e58b83c7b717811c45dca5ce6cc032
+  metadata.gz: 6be4888e921b11142c5bc7774e6a0c9ce9a91b7e0b8ceb8a812cff8e297b540a
+  data.tar.gz: '043584e75c96d49b34a4ab6ec0e0f0315700eb86a7d061fb03de66c095840b1c'
 SHA512:
-  metadata.gz: e216bb8280e6adc87f2ab5f4c0d1a2937306ba1237aedcc9b80375a742227bcdf2187e74b573691324f55d9ef13843b397c25348d442a3e211eda2d8c20cb06c
-  data.tar.gz: a3e736ae280744d93d65f9592ff9b9475f1f2b22b24790ee37b202ad361f0f192ff0a2bf87dd2669327492b24d2afee3000130af925d38788879512e086da24e
+  metadata.gz: bfc23dfba08023225f17e44860caf95dc2fe041bcf81a1d61651ee96cea59563aa2c97ee6a1bcdc2e38e2e56a0f9c7c5e144b64583286af70864ec4d636a5795
+  data.tar.gz: 2cc2bf17cc1a235264db9981e33e99b22c23468514bf136e3379523020ca1efd906b792b46c45b6893f0edb279d8845c79e2e14ee8821ee47db6fc87d4992692

data/app/controllers/forest_liana/actions_controller.rb

@@ -27,34 +27,45 @@ module ForestLiana
     end
 
     def get_smart_action_load_ctx(fields)
-      fields = fields.reduce({}) do |p, c|
-        ForestLiana::WidgetsHelper.set_field_widget(c)
-        p.update(c[:field] => c.merge!(value: nil))
+      fields = fields.map do |field|
+        ForestLiana::WidgetsHelper.set_field_widget(field)
+        field[:value] = nil unless field[:value]
+        field
       end
       {:record => get_record, :fields => fields}
     end
 
-    def get_smart_action_change_ctx(fields)
-      fields = fields.reduce({}) do |p, c|
-        field = c.permit!.to_h.symbolize_keys
+    def get_smart_action_change_ctx(fields, field_changed)
+      found_field_changed = fields.find{|field| field[:field] == field_changed}
+      fields = fields.map do |field|
+        field = field.permit!.to_h.symbolize_keys
         ForestLiana::WidgetsHelper.set_field_widget(field)
-        p.update(c[:field] => field)
+        field
       end
-      {:record => get_record, :fields => fields}
+      {:record => get_record,  :field_changed => found_field_changed, :fields => fields}
     end
 
-    def handle_result(result, formatted_fields, action)
-      if result.nil? || !result.is_a?(Hash)
-        return render status: 500, json: { error: 'Error in smart action load hook: hook must return an object' }
+    def handle_result(result, action)
+      if result.nil? || !result.is_a?(Array)
+        return render status: 500, json: { error: 'Error in smart action load hook: hook must return an array of fields' }
       end
-      is_same_data_structure = ForestLiana::IsSameDataStructureHelper::Analyser.new(formatted_fields, result, 1)
-      unless is_same_data_structure.perform
-        return render status: 500, json: { error: 'Error in smart action hook: fields must be unchanged (no addition nor deletion allowed)' }
+
+      # Validate that the fields are well formed.
+      begin
+        # action.hooks[:change] is a hashmap here
+        # to do the validation, only the hook names are require
+        change_hooks_name = action.hooks[:change].nil? ? nil : action.hooks[:change].keys
+        ForestLiana::SmartActionFieldValidator.validate_smart_action_fields(result, action.name, change_hooks_name)
+      rescue ForestLiana::Errors::SmartActionInvalidFieldError => invalid_field_error
+        FOREST_LOGGER.warn invalid_field_error.message
+      rescue ForestLiana::Errors::SmartActionInvalidFieldHookError => invalid_hook_error
+        FOREST_LOGGER.error invalid_hook_error.message
+        return render status: 500, json: { error: invalid_hook_error.message }
       end
 
       # Apply result on fields (transform the object back to an array), preserve order.
-      fields = action.fields.map do |field|
-        updated_field = result[field[:field]]
+      fields = result.map do |field|
+        updated_field = result.find{|f| f[:field] == field[:field]}
 
         # Reset `value` when not present in `enums` (which means `enums` has changed).
         if updated_field[:enums].is_a?(Array)
@@ -72,7 +83,7 @@ module ForestLiana
         updated_field
       end
 
-      render serializer: nil, json: { fields: fields}, status: :ok
+      render serializer: nil, json: { fields: fields }, status: :ok
     end
 
     def load
@@ -81,14 +92,13 @@ module ForestLiana
       if !action
         render status: 500, json: {error: 'Error in smart action load hook: cannot retrieve action from collection'}
       else
-        # Transform fields from array to an object to ease usage in hook, adds null value.
+        # Get the smart action hook load context
         context = get_smart_action_load_ctx(action.fields)
-        formatted_fields = context[:fields].clone # clone for following test on is_same_data_structure
 
         # Call the user-defined load hook.
         result = action.hooks[:load].(context)
 
-        handle_result(result, formatted_fields, action)
+        handle_result(result, action)
       end
     end
 
@@ -96,17 +106,22 @@ module ForestLiana
       action = get_action(params[:collectionName])
 
       if !action
-        render status: 500, json: {error: 'Error in smart action change hook: cannot retrieve action from collection'}
-      else
-        # Transform fields from array to an object to ease usage in hook.
-        context = get_smart_action_change_ctx(params[:fields])
-        formatted_fields = context[:fields].clone # clone for following test on is_same_data_structure
+        return render status: 500, json: {error: 'Error in smart action change hook: cannot retrieve action from collection'}
+      elsif params[:fields].nil?
+        return render status: 500, json: {error: 'Error in smart action change hook: fields params is mandatory'}
+      elsif !params[:fields].is_a?(Array)
+        return render status: 500, json: {error: 'Error in smart action change hook: fields params must be an array'}
+      end
 
-        # Call the user-defined change hook.
-        result = action.hooks[:change][params[:changedField]].(context)
+      # Get the smart action hook change context
+      context = get_smart_action_change_ctx(params[:fields], params[:changedField])
 
-        handle_result(result, formatted_fields, action)
-      end
+      field_changed_hook = context[:field_changed][:hook]
+
+      # Call the user-defined change hook.
+      result = action.hooks[:change][field_changed_hook].(context)
+
+      handle_result(result, action)
     end
   end
 end

data/app/services/forest_liana/apimap_sorter.rb

@@ -52,6 +52,7 @@ module ForestLiana
       'description',
       'position',
       'widget',
+      'hook',
     ]
     KEYS_SEGMENT = ['name']
 

data/app/services/forest_liana/smart_action_field_validator.rb

@@ -0,0 +1,49 @@
+module ForestLiana
+  class SmartActionFieldValidator
+
+    @@accepted_primitive_field_type = [
+      'String',
+      'Number',
+      'Date',
+      'Boolean',
+      'File',
+      'Enum',
+      'Json',
+      'Dateonly',
+    ]
+
+    @@accepted_array_field_type = [
+      'String',
+      'Number',
+      'Date',
+      'boolean',
+      'File',
+      'Enum',
+    ]
+
+    def self.validate_field(field, action_name)
+      raise ForestLiana::Errors::SmartActionInvalidFieldError.new(action_name, nil, "The field attribute must be defined") if !field || field[:field].nil?
+      raise ForestLiana::Errors::SmartActionInvalidFieldError.new(action_name, nil, "The field attribute must be a string.") if !field[:field].is_a?(String)
+      raise ForestLiana::Errors::SmartActionInvalidFieldError.new(action_name, field[:field], "The description attribute must be a string.") if field[:description] && !field[:description].is_a?(String)
+      raise ForestLiana::Errors::SmartActionInvalidFieldError.new(action_name, field[:field], "The enums attribute must be an array.") if field[:enums] && !field[:enums].is_a?(Array)
+      raise ForestLiana::Errors::SmartActionInvalidFieldError.new(action_name, field[:field], "The reference attribute must be a string.") if field[:reference] && !field[:reference].is_a?(String)
+
+      is_type_valid = field[:type].is_a?(Array) ?
+        @@accepted_array_field_type.include?(field[:type][0]) :
+        @@accepted_primitive_field_type.include?(field[:type])
+        
+      raise ForestLiana::Errors::SmartActionInvalidFieldError.new(action_name, field[:field], "The type attribute must be a valid type. See the documentation for more information. https://docs.forestadmin.com/documentation/reference-guide/fields/create-and-manage-smart-fields#available-field-options.") if !is_type_valid
+    end
+
+    def self.validate_field_change_hook(field, action_name, hooks)
+      raise ForestLiana::Errors::SmartActionInvalidFieldHookError.new(action_name, field[:field], field[:hook]) if field[:hook] && !hooks.find{|hook| hook == field[:hook]}
+    end
+
+    def self.validate_smart_action_fields(fields, action_name, change_hooks)
+      fields.map{|field|
+        self.validate_field(field.symbolize_keys, action_name)
+        self.validate_field_change_hook(field.symbolize_keys, action_name, change_hooks) if change_hooks
+      }
+    end
+  end
+end

data/config/initializers/errors.rb

@@ -13,6 +13,23 @@ module ForestLiana
       end
     end
 
+    class SmartActionInvalidFieldError < StandardError
+      def initialize(action_name=nil, field_name=nil, message=nil)
+        error_message = ""
+        error_message << "Error while parsing action \"#{action_name}\"" if !action_name.nil?
+        error_message << " on field \"#{field_name}\"" if !field_name.nil?
+        error_message << ": " if !field_name.nil? || !action_name.nil?
+        error_message << message if !message.nil?
+        super(error_message)
+      end
+    end
+
+    class SmartActionInvalidFieldHookError < StandardError
+      def initialize(action_name=nil, field_name=nil, hook_name=nil)
+        super("The hook \"#{hook_name}\" of \"#{field_name}\" field on the smart action \"#{action_name}\" is not defined.")
+      end
+    end
+
     class ExpectedError < StandardError
       attr_reader :error_code, :status, :message, :name
 

data/lib/forest_liana/bootstrapper.rb

@@ -60,7 +60,7 @@ module ForestLiana
           a = get_action(c, action['name'])
           load = !a.hooks.nil? && a.hooks.key?(:load) && a.hooks[:load].is_a?(Proc)
           change = !a.hooks.nil? && a.hooks.key?(:change) && a.hooks[:change].is_a?(Hash) ? a.hooks[:change].keys : []
-          action['hooks'] = {:load => load, :change => change}
+          action['hooks'] = {'load' => load, 'change' => change}
         end
       end
     end

data/lib/forest_liana/schema_file_updater.rb

@@ -63,6 +63,7 @@ module ForestLiana
       'description',
       'position',
       'widget',
+      'hook',
     ]
     KEYS_SEGMENT = ['name']
 
@@ -96,6 +97,13 @@ module ForestLiana
         end
 
         collection['actions'] = collection['actions'].map do |action|
+          begin
+            SmartActionFieldValidator.validate_smart_action_fields(action['fields'], action['name'], action['hooks']['change'])
+          rescue ForestLiana::Errors::SmartActionInvalidFieldError => invalid_field_error
+            FOREST_LOGGER.warn invalid_field_error.message
+          rescue ForestLiana::Errors::SmartActionInvalidFieldHookError => invalid_hook_error
+            FOREST_LOGGER.error invalid_hook_error.message
+          end
           action['fields'] = action['fields'].map { |field| field.slice(*KEYS_ACTION_FIELD) }
           action.slice(*KEYS_ACTION)
         end

data/lib/forest_liana/version.rb

@@ -1,3 +1,3 @@
 module ForestLiana
-  VERSION = "7.0.0.beta.1"
+  VERSION = "7.0.0.beta.2"
 end

data/spec/lib/forest_liana/schema_file_updater_spec.rb

@@ -0,0 +1,94 @@
+module ForestLiana
+  describe SchemaFileUpdater do
+    describe "initialize" do
+      describe "without any collections nor meta" do
+        it "should set collections as an empty array and meta as an empty object" do
+          schema_file_updater = ForestLiana::SchemaFileUpdater.new("test.txt", [], {})
+          expect(schema_file_updater.instance_variable_get(:@collections)).to eq([])
+          expect(schema_file_updater.instance_variable_get(:@meta)).to eq({})
+        end
+      end
+
+      describe "with a given collection" do
+        describe "when the collection has a smart action action" do
+          it "should save the smart action" do
+            collections = [{
+              "fields" => [],
+              "actions" => [{
+                "fields" => [],
+                "name" => "test",
+                "hooks" => {
+                  "change" => []
+                }
+              }],
+              "segments" => []
+            }]
+            schema_file_updater = ForestLiana::SchemaFileUpdater.new("test.txt", collections, {})
+            expect(schema_file_updater.instance_variable_get(:@collections))
+              .to eq(collections)
+          end
+
+          describe "when a smart action field is malformed" do
+            it "should display a warning message" do
+              collections = [{
+                "fields" => [],
+                "actions" => [{
+                  "fields" => [{}],
+                  "name" => "test",
+                  "hooks" => {
+                    "change" => []
+                  }
+                }],
+                "segments" => []
+              }]
+              allow(FOREST_LOGGER).to receive(:warn)
+              schema_file_updater = ForestLiana::SchemaFileUpdater.new("test.txt", collections, {})
+              expect(FOREST_LOGGER).to have_received(:warn).with('Error while parsing action "test": The field attribute must be defined')
+            end
+          end
+
+          describe "when a smart action change field hook does not exist" do
+            it "should display an error message" do
+              collections = [{
+                "fields" => [],
+                "actions" => [{
+                  "fields" => [{
+                    "field" => "testField",
+                    "hook" => "undefinedHook",
+                    "type" => "String",
+                  }],
+                  "name" => "test",
+                  "hooks" => {
+                    "change" => []
+                  }
+                }],
+                "segments" => []
+              }]
+
+              allow(FOREST_LOGGER).to receive(:error)
+              schema_file_updater = ForestLiana::SchemaFileUpdater.new("test.txt", collections, {})
+              expect(FOREST_LOGGER).to have_received(:error).with('The hook "undefinedHook" of "testField" field on the smart action "test" is not defined.')
+            end
+          end
+        end
+      end
+    end
+
+    describe "perform" do
+      it "should call file puts with pretty printed data" do
+        file = instance_double(File, read: "stubbed read")
+
+        allow(File).to receive(:open).with("test.txt", "w") { |&block| block.call(file) }
+
+        schema_file_updater = ForestLiana::SchemaFileUpdater.new("test.txt", [], {})
+        expected_result = schema_file_updater.pretty_print({
+          "collections" => [],
+          "meta" => {}
+        })
+
+        expect(file).to receive(:puts).with(expected_result)
+        schema_file_updater.perform
+      end
+    end
+  end
+end

data/spec/requests/actions_controller_spec.rb

@@ -30,6 +30,7 @@ describe 'Requesting Actions routes', :type => :request  do
         reference: nil,
         description: nil,
         widget: nil,
+        hook: 'on_foo_changed'
     }
     enum = {
         field: 'enum',
@@ -50,10 +51,10 @@ describe 'Requesting Actions routes', :type => :request  do
               context[:fields]
             },
             :change => {
-              'foo' => -> (context) {
-                fields = context[:fields]
-                fields['foo'][:value] = 'baz'
-                return fields
+              'on_foo_changed' => -> (context) {
+                foo = context[:fields].find{|field| field[:field] == 'foo'}
+                foo[:value] = 'baz'
+                context[:fields]
               }
             }
         }
@@ -66,7 +67,7 @@ describe 'Requesting Actions routes', :type => :request  do
               1
             },
             :change => {
-                'foo' => -> (context) {
+                'on_foo_changed' => -> (context) {
                   1
                 }
             }
@@ -77,11 +78,10 @@ describe 'Requesting Actions routes', :type => :request  do
         fields: [foo],
         hooks: {
             :load => -> (context) {
-              context[:fields]['baz'] = foo.clone.update({field: 'baz'})
-              context[:fields]
+              {}
             },
             :change => {
-                'foo' => -> (context) {
+                'on_foo_changed' => -> (context) {
                   context[:fields]['baz'] = foo.clone.update({field: 'baz'})
                   context[:fields]
                 }
@@ -93,10 +93,11 @@ describe 'Requesting Actions routes', :type => :request  do
       fields: [foo, enum],
       hooks: {
         :change => {
-          'foo' => -> (context) {
+          'on_foo_changed' => -> (context) {
             fields = context[:fields]
-            fields['enum'][:enums] = %w[c d e]
-            return fields
+            enum_field = fields.find{|field| field[:field] == 'enum'}
+            enum_field[:enums] = %w[c d e]
+            fields
           }
         }
       }
@@ -107,10 +108,11 @@ describe 'Requesting Actions routes', :type => :request  do
         fields: [foo, multiple_enum],
         hooks: {
             :change => {
-                'foo' => -> (context) {
+                'on_foo_changed' => -> (context) {
                   fields = context[:fields]
-                  fields['multipleEnum'][:enums] = %w[c d z]
-                  return fields
+                  enum_field = fields.find{|field| field[:field] == 'multipleEnum'}
+                  enum_field[:enums] = %w[c d z]
+                  fields
                 }
             }
         }
@@ -136,16 +138,19 @@ describe 'Requesting Actions routes', :type => :request  do
       it 'should respond 500 with bad params' do
         post '/forest/actions/my_action/hooks/load', params: {}
         expect(response.status).to eq(500)
+        expect(JSON.parse(response.body)).to eq({'error' => 'Error in smart action load hook: cannot retrieve action from collection'})
       end
 
       it 'should respond 500 with bad hook result type' do
         post '/forest/actions/fail_action/hooks/load', params: JSON.dump(params), headers: { 'CONTENT_TYPE' => 'application/json' }
         expect(response.status).to eq(500)
+        expect(JSON.parse(response.body)).to eq({'error' => 'Error in smart action load hook: hook must return an array of fields'})
       end
 
       it 'should respond 500 with bad hook result data structure' do
         post '/forest/actions/cheat_action/hooks/load', params: JSON.dump(params), headers: { 'CONTENT_TYPE' => 'application/json' }
         expect(response.status).to eq(500)
+        expect(JSON.parse(response.body)).to eq({'error' => 'Error in smart action load hook: hook must return an array of fields'})
       end
     end
 
@@ -163,18 +168,15 @@ describe 'Requesting Actions routes', :type => :request  do
       end
 
       it 'should respond 500 with bad params' do
-        post '/forest/actions/my_action/hooks/change', params: {}
+        post '/forest/actions/my_action/hooks/change', params: JSON.dump({collectionName: 'Island'}), headers: { 'CONTENT_TYPE' => 'application/json' }
         expect(response.status).to eq(500)
+        expect(JSON.parse(response.body)).to eq({'error' => 'Error in smart action change hook: fields params is mandatory'})
       end
 
       it 'should respond 500 with bad hook result type' do
         post '/forest/actions/fail_action/hooks/change', params: JSON.dump(params), headers: { 'CONTENT_TYPE' => 'application/json' }
         expect(response.status).to eq(500)
-      end
-
-      it 'should respond 500 with bad hook result data structure' do
-        post '/forest/actions/cheat_action/hooks/change', params: JSON.dump(params), headers: { 'CONTENT_TYPE' => 'application/json' }
-        expect(response.status).to eq(500)
+        expect(JSON.parse(response.body)).to eq({'error' => 'Error in smart action load hook: hook must return an array of fields'})
       end
 
       it 'should reset value when enums has changed' do

data/spec/services/forest_liana/smart_action_field_validator_spec.rb

@@ -0,0 +1,70 @@
+module ForestLiana
+  describe SmartActionFieldValidator do
+    describe "self.validate_field" do
+      it "should raise an SmartActionInvalidFieldError with nil field" do
+        expect { SmartActionFieldValidator.validate_field(nil, "actionName") }.to raise_error(ForestLiana::Errors::SmartActionInvalidFieldError, 'Error while parsing action "actionName": The field attribute must be defined')
+      end
+
+      it "should raise an SmartActionInvalidFieldError with a field that is not a string" do
+        expect { SmartActionFieldValidator.validate_field({
+          :field => 5
+        }, "actionName") }.to raise_error(ForestLiana::Errors::SmartActionInvalidFieldError, 'Error while parsing action "actionName": The field attribute must be a string.')
+      end
+
+      it "should raise an SmartActionInvalidFieldError with description that is not a string" do
+        expect { SmartActionFieldValidator.validate_field({
+          :field => "field",
+          :description => 5
+        }, "actionName") }.to raise_error(ForestLiana::Errors::SmartActionInvalidFieldError, 'Error while parsing action "actionName" on field "field": The description attribute must be a string.')
+      end
+
+      it "should raise an SmartActionInvalidFieldError with an enums that is not an array" do
+        expect { SmartActionFieldValidator.validate_field({
+          :field => "field",
+          :enums => "NotAnArray"
+        }, "actionName") }.to raise_error(ForestLiana::Errors::SmartActionInvalidFieldError, 'Error while parsing action "actionName" on field "field": The enums attribute must be an array.')
+      end
+
+      it "should raise an SmartActionInvalidFieldError with a reference that is not a string" do
+        expect { SmartActionFieldValidator.validate_field({
+          :field => "field",
+          :type => "String",
+          :reference => 5
+        }, "actionName") }.to raise_error(ForestLiana::Errors::SmartActionInvalidFieldError, 'Error while parsing action "actionName" on field "field": The reference attribute must be a string.')
+      end
+
+      it "should raise an SmartActionInvalidFieldError with an invalid type" do
+        expect { SmartActionFieldValidator.validate_field({
+          :field => "field",
+          :type => "AbsolutelyNotAValidType"
+        }, "actionName") }.to raise_error(ForestLiana::Errors::SmartActionInvalidFieldError, 'Error while parsing action "actionName" on field "field": The type attribute must be a valid type. See the documentation for more information. https://docs.forestadmin.com/documentation/reference-guide/fields/create-and-manage-smart-fields#available-field-options.')
+      end
+
+      it "should not raise any error when everything is configured correctly" do
+        expect { SmartActionFieldValidator.validate_field({
+          :field => "field",
+          :type => "String",
+          :description => "field description"
+        }, "actionName") }.not_to raise_error
+      end
+    end
+
+    describe "self.validate_field_change_hook" do
+      it "should raise an SmartActionInvalidFieldHookError with an invalid type" do
+        expect { SmartActionFieldValidator.validate_field_change_hook({
+          :field => "field",
+          :type => "AbsolutelyNotAValidType",
+          :hook => "hookThatDoesNotExist"
+        }, "actionName", []) }.to raise_error(ForestLiana::Errors::SmartActionInvalidFieldHookError)
+      end
+
+      it "should not raise any error when everything is configured correctly" do
+        expect { SmartActionFieldValidator.validate_field_change_hook({
+          :field => "field",
+          :type => "AbsolutelyNotAValidType",
+          :hook => "on_field_changed"
+        }, "actionName", ["on_field_changed"]) }.not_to raise_error
+      end
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: forest_liana
 version: !ruby/object:Gem::Version
-  version: 7.0.0.beta.1
+  version: 7.0.0.beta.2
 platform: ruby
 authors:
 - Sandro Munda
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-06-01 00:00:00.000000000 Z
+date: 2021-06-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -225,7 +225,6 @@ files:
 - app/helpers/forest_liana/adapter_helper.rb
 - app/helpers/forest_liana/application_helper.rb
 - app/helpers/forest_liana/decoration_helper.rb
-- app/helpers/forest_liana/is_same_data_structure_helper.rb
 - app/helpers/forest_liana/query_helper.rb
 - app/helpers/forest_liana/schema_helper.rb
 - app/helpers/forest_liana/widgets_helper.rb
@@ -283,6 +282,7 @@ files:
 - app/services/forest_liana/schema_utils.rb
 - app/services/forest_liana/scope_validator.rb
 - app/services/forest_liana/search_query_builder.rb
+- app/services/forest_liana/smart_action_field_validator.rb
 - app/services/forest_liana/stat_getter.rb
 - app/services/forest_liana/stripe_base_getter.rb
 - app/services/forest_liana/stripe_invoice_getter.rb
@@ -368,9 +368,9 @@ files:
 - spec/dummy/db/schema.rb
 - spec/dummy/lib/forest_liana/collections/location.rb
 - spec/dummy/lib/forest_liana/collections/user.rb
-- spec/helpers/forest_liana/is_same_data_structure_helper_spec.rb
 - spec/helpers/forest_liana/query_helper_spec.rb
 - spec/helpers/forest_liana/schema_helper_spec.rb
+- spec/lib/forest_liana/schema_file_updater_spec.rb
 - spec/rails_helper.rb
 - spec/requests/actions_controller_spec.rb
 - spec/requests/authentications_spec.rb
@@ -387,6 +387,7 @@ files:
 - spec/services/forest_liana/permissions_getter_spec.rb
 - spec/services/forest_liana/resources_getter_spec.rb
 - spec/services/forest_liana/schema_adapter_spec.rb
+- spec/services/forest_liana/smart_action_field_validator_spec.rb
 - spec/spec_helper.rb
 - test/dummy/README.rdoc
 - test/dummy/Rakefile
@@ -603,13 +604,13 @@ test_files:
 - spec/services/forest_liana/permissions_checker_acl_enabled_spec.rb
 - spec/services/forest_liana/filters_parser_spec.rb
 - spec/services/forest_liana/schema_adapter_spec.rb
+- spec/services/forest_liana/smart_action_field_validator_spec.rb
 - spec/services/forest_liana/line_stat_getter_spec.rb
 - spec/services/forest_liana/permissions_formatter_spec.rb
 - spec/services/forest_liana/permissions_checker_live_queries_spec.rb
 - spec/services/forest_liana/apimap_sorter_spec.rb
 - spec/services/forest_liana/permissions_checker_acl_disabled_spec.rb
 - spec/config/initializers/logger_spec.rb
-- spec/helpers/forest_liana/is_same_data_structure_helper_spec.rb
 - spec/helpers/forest_liana/schema_helper_spec.rb
 - spec/helpers/forest_liana/query_helper_spec.rb
 - spec/dummy/db/schema.rb
@@ -663,6 +664,7 @@ test_files:
 - spec/dummy/app/models/location.rb
 - spec/dummy/app/models/island.rb
 - spec/dummy/app/models/reference.rb
+- spec/lib/forest_liana/schema_file_updater_spec.rb
 - spec/rails_helper.rb
 - spec/requests/stats_spec.rb
 - spec/requests/resources_spec.rb

data/app/helpers/forest_liana/is_same_data_structure_helper.rb

@@ -1,44 +0,0 @@
-require 'set'
-
-module ForestLiana
-  module IsSameDataStructureHelper
-    class Analyser
-      def initialize(object, other, deep = 0)
-        @object = object
-        @other = other
-        @deep = deep
-      end
-
-      def are_objects(object, other)
-        object && other && object.is_a?(Hash) && other.is_a?(Hash)
-      end
-
-      def check_keys(object, other, step = 0)
-        unless are_objects(object, other)
-          return false
-        end
-
-        object_keys = object.keys
-        other_keys = other.keys
-
-        if object_keys.length != other_keys.length
-          return false
-        end
-
-        object_keys_set = object_keys.to_set
-        other_keys.each { |key|
-          if !object_keys_set.member?(key) || (step + 1 <= @deep && !check_keys(object[key], other[key], step + 1))
-            return false
-          end
-        }
-
-        return true
-      end
-
-      def perform
-        check_keys(@object, @other)
-      end
-    end
-  end
-end
-

data/spec/helpers/forest_liana/is_same_data_structure_helper_spec.rb

@@ -1,87 +0,0 @@
-module ForestLiana
-  context 'IsSameDataStructure class' do
-    it 'should: be valid with simple data' do
-      object = {:a => 'a', :b => 'b'}
-      other = {:a => 'a', :b => 'b'}
-      result = IsSameDataStructureHelper::Analyser.new(object, other).perform
-      expect(result).to be true
-    end
-
-    it 'should: be invalid with simple data' do
-      object = {:a => 'a', :b => 'b'}
-      other = {:a => 'a', :c => 'c'}
-      result = IsSameDataStructureHelper::Analyser.new(object, other).perform
-      expect(result).to be false
-    end
-
-    it 'should: be invalid with not same hash' do
-      object = {:a => 'a', :b => 'b'}
-      other = {:a => 'a', :b => 'b', :c => 'c'}
-      result = IsSameDataStructureHelper::Analyser.new(object, other).perform
-      expect(result).to be false
-    end
-
-    it 'should: be invalid with nil' do
-      object = nil
-      other = {:a => 'a', :b => 'b', :c => 'c'}
-      result = IsSameDataStructureHelper::Analyser.new(object, other).perform
-      expect(result).to be false
-    end
-
-    it 'should: be invalid with not hash' do
-      object = nil
-      other = {:a => 'a', :b => 'b', :c => 'c'}
-      result = IsSameDataStructureHelper::Analyser.new(object, other).perform
-      expect(result).to be false
-    end
-
-    it 'should: be invalid with integer' do
-      object = 1
-      other = {:a => 'a', :b => 'b', :c => 'c'}
-      result = IsSameDataStructureHelper::Analyser.new(object, other).perform
-      expect(result).to be false
-    end
-
-    it 'should: be invalid with string' do
-      object = 'a'
-      other = {:a => 'a', :b => 'b', :c => 'c'}
-      result = IsSameDataStructureHelper::Analyser.new(object, other).perform
-      expect(result).to be false
-    end
-
-    it 'should: be valid with depth 1' do
-      object = {:a => {:c => 'c'}, :b => {:d => 'd'}}
-      other = {:a => {:c => 'c'}, :b => {:d => 'd'}}
-      result = IsSameDataStructureHelper::Analyser.new(object, other, 1).perform
-      expect(result).to be true
-    end
-
-    it 'should: be invalid with depth 1' do
-      object = {:a => {:c => 'c'}, :b => {:d => 'd'}}
-      other = {:a => {:c => 'c'}, :b => {:e => 'e'}}
-      result = IsSameDataStructureHelper::Analyser.new(object, other, 1).perform
-      expect(result).to be false
-    end
-
-    it 'should: be invalid with depth 1 and nil' do
-      object = {:a => {:c => 'c'}, :b => {:d => 'd'}}
-      other = {:a => {:c => 'c'}, :b => nil}
-      result = IsSameDataStructureHelper::Analyser.new(object, other, 1).perform
-      expect(result).to be false
-    end
-
-    it 'should: be invalid with depth 1 and integer' do
-      object = {:a => {:c => 'c'}, :b => {:d => 'd'}}
-      other = {:a => {:c => 'c'}, :b => 1}
-      result = IsSameDataStructureHelper::Analyser.new(object, other, 1).perform
-      expect(result).to be false
-    end
-
-    it 'should: be invalid with depth 1 and string' do
-      object = {:a => {:c => 'c'}, :b => {:d => 'd'}}
-      other = {:a => {:c => 'c'}, :b => 'b'}
-      result = IsSameDataStructureHelper::Analyser.new(object, other, 1).perform
-      expect(result).to be false
-    end
-  end
-end