[-] Apimap - Prevent random sorting collections and useless updates. (ForestAdmin#231)

Author: lucasscariot

.rspec

@@ -0,0 +1 @@
+--require spec_helper

.travis.yml

@@ -6,3 +6,4 @@ rvm:
   - 2.2.0
 script:
   - RAILS_ENV=test bundle exec rake --trace db:migrate test
+  - RAILS_ENV=test bundle exec rspec

CHANGELOG.md

@@ -2,6 +2,7 @@
 
 ## [Unreleased]
 ### Changed
+- Apimap - Prevent random sorting collections and useless updates.
 - Smart Fields - Compute only the necessary Smart Fields values for list views and CSV exports.
 
 ## RELEASE 2.2.2 - 2018-01-30

Gemfile

@@ -11,7 +11,10 @@ gemspec
 # your gem to rubygems.org.
 
 # To use a debugger
-gem 'byebug', group: [:development, :test]
+group :development, :test do
+  gem 'byebug'
+  gem 'rspec'
+end
 
 group :test do
   gem 'rake'

Gemfile.lock

@@ -57,6 +57,7 @@ GEM
     byebug (8.2.2)
     concurrent-ruby (1.0.5)
     crass (1.0.3)
+    diff-lcs (1.3)
     erubis (2.7.0)
     globalid (0.4.1)
       activesupport (>= 4.2.0)
@@ -107,6 +108,19 @@ GEM
       rake (>= 0.8.7)
       thor (>= 0.18.1, < 2.0)
     rake (12.3.0)
+    rspec (3.7.0)
+      rspec-core (~> 3.7.0)
+      rspec-expectations (~> 3.7.0)
+      rspec-mocks (~> 3.7.0)
+    rspec-core (3.7.1)
+      rspec-support (~> 3.7.0)
+    rspec-expectations (3.7.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.7.0)
+    rspec-mocks (3.7.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.7.0)
+    rspec-support (3.7.1)
     sprockets (3.7.1)
       concurrent-ruby (~> 1.0)
       rack (> 1, < 3)
@@ -135,6 +149,7 @@ DEPENDENCIES
   rack-cors
   rails (= 4.2.7.1)
   rake
+  rspec
   sqlite3
   useragent
 

app/services/forest_liana/apimap_sorter.rb

@@ -0,0 +1,117 @@
+module ForestLiana
+  class ApimapSorter
+    def initialize apimap
+      @apimap = apimap.stringify_keys
+    end
+
+    def perform
+      begin
+        @apimap = reorder_keys_basic(@apimap)
+        @apimap['data'] = sort_array_of_objects(@apimap['data']);
+
+        @apimap['data'].map! do |collection|
+          collection = reorder_keys_child(collection)
+          collection['attributes'] = reorder_keys_collection(collection['attributes'])
+          if collection['attributes']['fields']
+            collection['attributes']['fields'] = sort_array_of_fields(collection['attributes']['fields'])
+            collection['attributes']['fields'].map! { |field| reorder_keys_field(field) }
+          end
+          collection
+        end
+
+        if @apimap['included']
+          @apimap['included'] = sort_array_of_objects(@apimap['included'])
+
+          @apimap['included'].map! do |object|
+            object = reorder_keys_child(object)
+            object['attributes'] = reorder_keys_collection(object['attributes'])
+            if object['attributes']['fields']
+              object['attributes']['fields'] = sort_array_of_fields(object['attributes']['fields'])
+              object['attributes']['fields'].map! { |field| reorder_keys_field(field)  }
+            end
+            object
+          end
+        end
+
+        @apimap['meta'] = reorder_keys_basic(@apimap['meta'])
+        @apimap
+      rescue => exception
+        FOREST_LOGGER.warn "An Apimap reordering issue occured: #{exception}"
+        @apimap
+      end
+    end
+
+    private
+
+    def sort_array_of_objects(array)
+      array.sort do |element1, element2|
+        if element1['type'] == element2['type']
+          element1['id'] <=> element2['id']
+        else
+          element1['type'] <=> element2['type']
+        end
+      end
+    end
+
+    def sort_array_of_fields(array)
+      return nil unless array
+
+      array.sort do |field1, field2|
+        if field1['field'] == field2['field']
+          field1['type'] <=> field2['type']
+        else
+          field1['field'] <=> field2['field']
+        end
+      end
+    end
+
+    def reorder_keys_basic(object)
+      object = object.stringify_keys
+      object_reordered = {}
+      object.keys.sort.each do |key|
+        object_reordered[key] = object[key]
+      end
+      object_reordered
+    end
+
+    def reorder_keys_child(object)
+      object = object.stringify_keys
+      object_reordered = {}
+      object_reordered['type'] = object['type']
+      object_reordered['id'] = object['id']
+      object_reordered['attributes'] = object['attributes']
+      object.keys.sort.each { |key| object_reordered[key] = object[key] }
+      object_reordered
+    end
+
+    def reorder_keys_collection(collection)
+      collection = collection.stringify_keys
+      collection_reordered_start = {}
+      collection_reordered_start['name'] = collection['name']
+      collection_reordered_end = {}
+      collection_reordered_end['fields'] = collection['fields'] if collection['fields']
+
+      collection.delete('name')
+      collection.delete('fields')
+
+      collection_reordered_middle = reorder_keys_basic(collection)
+
+      collection = collection_reordered_start.merge(collection_reordered_middle)
+      collection.merge(collection_reordered_end)
+    end
+
+    def reorder_keys_field(field)
+      field = field.stringify_keys
+      field_reordered_start = {}
+      field_reordered_start['field'] = field['field']
+      field_reordered_start['type'] = field['type']
+
+      field.delete('field')
+      field.delete('type')
+
+      field = reorder_keys_basic(field || {})
+
+      field_reordered_start.merge(field)
+    end
+  end
+end

lib/forest_liana/bootstraper.rb

@@ -175,6 +175,7 @@ def send_apimap
         })
 
         begin
+          apimap = ForestLiana::ApimapSorter.new(apimap).perform
           uri = URI.parse("#{forest_url}/forest/apimaps")
           http = Net::HTTP.new(uri.host, uri.port)
           http.use_ssl = true if forest_url.start_with?('https')

spec/apimap_sorter_spec.rb

@@ -0,0 +1,170 @@
+describe ForestLiana::ApimapSorter do
+  describe 'apimap reordering' do
+    context 'on a disordered apimap' do
+      apimap = {
+        'meta': {
+          'orm_version': '4.34.9',
+          'liana_version': '1.5.24',
+          'database_type': 'postgresql',
+          liana: 'forest-rails',
+        },
+        'data': [{
+          id: 'users',
+          type: 'collections',
+          attributes: {
+            fields: [
+              { field: 'id', type: 'Number' },
+              { field: 'name', type: 'String' },
+              { field: 'firstName', type: 'String' },
+              { field: 'lastName', type: 'String' },
+              { field: 'email', type: 'String' },
+              { field: 'url', type: 'String' },
+              { field: 'createdAt', type: 'Date' },
+              { field: 'updatedAt', type: 'Date' },
+            ],
+            name: 'users',
+          }
+        }, {
+          id: 'guests',
+          type: 'collections',
+          attributes: {
+            fields: [
+              { field: 'id', type: 'Number' },
+              { field: 'email', type: 'String' },
+              { field: 'createdAt', type: 'Date' },
+              { field: 'updatedAt', type: 'Date' },
+            ],
+            name: 'guests',
+          }
+        }, {
+          type: 'collections',
+          id: 'animals',
+          attributes: {
+            fields: [
+              { 'is-sortable': false, field: 'id', 'is-filterable': false,  type: 'Number' },
+              { type: 'Date', field: 'createdAt' },
+              { field: 'updatedAt', type: 'Date' },
+            ],
+            name: 'animals',
+            integration: 'close.io',
+            'is-virtual': true,
+          }
+        }],
+        'included': [{
+          id: 'users.Women',
+          type: 'segments',
+          attributes: {
+            name: 'Women'
+          }
+        }, {
+          id: 'users.import',
+          type: 'actions',
+          links: {
+            self: '/actions'
+          },
+          attributes: {
+            name: 'import',
+            fields: [{
+              isRequired: true,
+              type: 'Boolean',
+              field: 'Save',
+              description: 'save the import file if true.',
+              defaultValue: 'true'
+            }, {
+              type: 'File',
+              field: 'File'
+            }],
+            'http-method': nil
+          }
+        }, {
+          attributes: {
+            name: 'Men'
+          },
+          id: 'users.Men',
+          type: 'segments'
+        }, {
+          id: 'animals.ban',
+          type: 'actions',
+          links: {
+            self: '/actions'
+          },
+          attributes: {
+            name: 'import',
+            global: true,
+            download: nil,
+            endpoint: nil,
+            redirect: nil,
+            'http-method': nil
+          }
+        }]
+      }
+
+      apimap = ActiveSupport::JSON.encode(apimap)
+      apimap = ActiveSupport::JSON.decode(apimap)
+      apimap_sorted = ForestLiana::ApimapSorter.new(apimap).perform
+
+      it 'should sort the apimap sections' do
+        expect(apimap_sorted.keys).to eq(['data', 'included', 'meta'])
+      end
+
+      it 'should sort the data collections' do
+        expect(apimap_sorted['data'].map { |collection| collection['id'] }).to eq(
+          ['animals', 'guests', 'users'])
+      end
+
+      it 'should sort the data collection values' do
+        expect(apimap_sorted['data'][0].keys).to eq(['type', 'id', 'attributes'])
+        expect(apimap_sorted['data'][1].keys).to eq(['type', 'id', 'attributes'])
+        expect(apimap_sorted['data'][2].keys).to eq(['type', 'id', 'attributes'])
+      end
+
+      it 'should sort the data collections attributes values' do
+        expect(apimap_sorted['data'][0]['attributes'].keys).to eq(['name', 'integration', 'is-virtual', 'fields'])
+        expect(apimap_sorted['data'][1]['attributes'].keys).to eq(['name', 'fields'])
+        expect(apimap_sorted['data'][2]['attributes'].keys).to eq(['name', 'fields'])
+      end
+
+      it 'should sort the data collections attributes fields by name' do
+        expect(apimap_sorted['data'][0]['attributes']['fields'].map { |field| field['field'] }).to eq(['createdAt', 'id', 'updatedAt'])
+        expect(apimap_sorted['data'][1]['attributes']['fields'].map { |field| field['field'] }).to eq(['createdAt', 'email', 'id', 'updatedAt'])
+        expect(apimap_sorted['data'][2]['attributes']['fields'].map { |field| field['field'] }).to eq(['createdAt', 'email', 'firstName', 'id', 'lastName', 'name', 'updatedAt', 'url'])
+      end
+
+      it 'should sort the data collections attributes fields values' do
+        expect(apimap_sorted['data'][0]['attributes']['fields'][1].keys).to eq(['field', 'type', 'is-filterable', 'is-sortable'])
+      end
+
+      it 'should sort the included actions and segments objects' do
+        expect(apimap_sorted['included'].map { |object| object['id'] }).to eq(
+          ['animals.ban', 'users.import', 'users.Men', 'users.Women'])
+      end
+
+      it 'should sort the included actions and segments objects values' do
+        expect(apimap_sorted['included'][0].keys).to eq(['type', 'id', 'attributes', 'links'])
+        expect(apimap_sorted['included'][1].keys).to eq(['type', 'id', 'attributes', 'links'])
+        expect(apimap_sorted['included'][2].keys).to eq(['type', 'id', 'attributes'])
+        expect(apimap_sorted['included'][3].keys).to eq(['type', 'id', 'attributes'])
+      end
+
+      it 'should sort the included actions and segments objects attributes values' do
+        expect(apimap_sorted['included'][0]['attributes'].keys).to eq(['name', 'download', 'endpoint', 'global', 'http-method', 'redirect'])
+        expect(apimap_sorted['included'][1]['attributes'].keys).to eq(['name', 'http-method', 'fields'])
+        expect(apimap_sorted['included'][2]['attributes'].keys).to eq(['name'])
+        expect(apimap_sorted['included'][3]['attributes'].keys).to eq(['name'])
+      end
+
+      it 'should sort the included action attributes fields by name' do
+        expect(apimap_sorted['included'][1]['attributes']['fields'].map { |field| field['field'] }).to eq(['File', 'Save'])
+      end
+
+      it 'should sort the included action fields values' do
+        expect(apimap_sorted['included'][1]['attributes']['fields'][1].keys).to eq(['field', 'type', 'defaultValue', 'description', 'isRequired'])
+      end
+
+      it 'should sort the meta values' do
+        expect(apimap_sorted['meta'].keys).to eq(
+          ['database_type', 'liana', 'liana_version', 'orm_version'])
+      end
+    end
+  end
+end