forest_liana 6.6.1 → 7.0.0.beta.4

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