Convert layers as flat list from Rhino

speckle_connector/bootstrap.rb

@@ -3,6 +3,7 @@
 require 'sketchup'
 require 'pathname'
 require 'speckle_connector/debug'
+require_relative 'src/log/log'
 require_relative 'src/ui/sketchup_ui'
 require_relative 'src/ui/ui_controller'
 require_relative 'src/commands/menu_command_handler'

speckle_connector/src/convertors/to_native.rb

@@ -2,6 +2,7 @@
 
 require_relative 'converter'
 require_relative '../constants/type_constants'
+require_relative '../speckle_entities/speckle_entity'
 require_relative '../speckle_objects/gis/polygon_element'
 require_relative '../speckle_objects/other/transform'
 require_relative '../speckle_objects/other/render_material'
@@ -76,6 +77,10 @@ module SpeckleConnector
         @from_revit ||= source_app.include?('revit')
       end
 
+      def from_rhino
+        @from_rhino ||= source_app.include?('rhino')
+      end
+
       def from_sketchup
         @from_sketchup ||= source_app.include?('sketchup')
       end
@@ -89,14 +94,9 @@ module SpeckleConnector
       # UI is responsible currently to fetch objects from ObjectLoader module by calling getAndConstruct method.
       # @param obj [Object] speckle commit object.
       def receive_commit_object(obj)
-        # First create layers on the sketchup before starting traversing
-        # @Named Views are exception here. It does not mean a layer. But it is anti-pattern for now.
-        # layers_relation = obj['layers_relation']
-
         unless from_revit
-          layers_relation = SpeckleObjects::Relations::Layers.extract_relations(obj)
           # Create layers and it's folders from layers relation on the model collection.
-          SpeckleObjects::Relations::Layers.to_native(layers_relation, sketchup_model) if layers_relation
+          SpeckleObjects::Relations::Layers.to_native(obj, source_app, sketchup_model)
         end
 
         # By default entities to fill is sketchup model's entities.
@@ -304,7 +304,7 @@ module SpeckleConnector
           create_layers_from_categories(state, obj, converted_entities)
         end
         # Create speckle entities from sketchup entities to achieve continuous traversal.
-        convert_to_speckle_entities(state, obj, converted_entities)
+        SpeckleEntities::SpeckleEntity.from_speckle_object(state, obj, converted_entities, stream_id)
       rescue StandardError => e
         puts("Failed to convert #{obj['speckle_type']} (id: #{obj['id']})")
         puts(e)
@@ -353,30 +353,11 @@ module SpeckleConnector
       end
 
       # @param state [States::State] state of the application
-      # rubocop:disable Metrics/PerceivedComplexity
-      # rubocop:disable Metrics/CyclomaticComplexity
-      def convert_to_speckle_entities(state, speckle_object, entities)
-        return state if entities.empty?
+      def convert_to_speckle_entities(state, speckle_objects_with_entities)
+        return state if speckle_objects_with_entities.empty?
 
-        speckle_id = speckle_object['id']
-        application_id = speckle_object['applicationId']
-        speckle_type = speckle_object['speckle_type']
-        children = speckle_object['__closure'].nil? ? [] : speckle_object['__closure']
-        speckle_state = state.speckle_state
-        entities.each do |entity|
-          next if entity.is_a?(Sketchup::Material) || entity.is_a?(Sketchup::Page)
-          next if (entity.is_a?(Sketchup::Face) || entity.is_a?(Sketchup::Edge)) &&
-                  !state.user_state.user_preferences[:register_speckle_entity]
 
-          ent = SpeckleEntities::SpeckleEntity.new(entity, speckle_id, application_id, speckle_type, children,
-                                                   [stream_id])
-          ent.write_initial_base_data
-          speckle_state = speckle_state.with_speckle_entity(ent)
-        end
-        state.with_speckle_state(speckle_state)
       end
-      # rubocop:enable Metrics/PerceivedComplexity
-      # rubocop:enable Metrics/CyclomaticComplexity
     end
     # rubocop:enable Metrics/ClassLength
   end

speckle_connector/src/log/log.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module SpeckleConnector
+  # Helper module for logging.
+  module Log
+    def self.write_to_file(text, file_name = 'log', path = "#{ENV['HOME']}/Desktop")
+      file_path = path + "/#{file_name}.json"
+      File.delete(file_path) if File.exist?(file_path)
+      File.write(file_path, text)
+    end
+  end
+end

speckle_connector/src/speckle_entities/speckle_entity.rb

@@ -119,6 +119,31 @@ module SpeckleConnector
       def valid?
         sketchup_entity.valid?
       end
+
+      # @param state [States::State] state of the application
+      # rubocop:disable Metrics/PerceivedComplexity
+      # rubocop:disable Metrics/CyclomaticComplexity
+      def self.from_speckle_object(state, speckle_object, entities, stream_id)
+        return state if entities.empty?
+
+        speckle_id = speckle_object['id']
+        application_id = speckle_object['applicationId']
+        speckle_type = speckle_object['speckle_type']
+        children = speckle_object['__closure'].nil? ? [] : speckle_object['__closure']
+        speckle_state = state.speckle_state
+        entities.each do |entity|
+          next if entity.is_a?(Sketchup::Material) || entity.is_a?(Sketchup::Page)
+          next if (entity.is_a?(Sketchup::Face) || entity.is_a?(Sketchup::Edge)) &&
+                  !state.user_state.user_preferences[:register_speckle_entity]
+
+          ent = SpeckleEntity.new(entity, speckle_id, application_id, speckle_type, children, [stream_id])
+          ent.write_initial_base_data
+          speckle_state = speckle_state.with_speckle_entity(ent)
+        end
+        state.with_speckle_state(speckle_state)
+      end
+      # rubocop:enable Metrics/PerceivedComplexity
+      # rubocop:enable Metrics/CyclomaticComplexity
     end
   end
 end

speckle_connector/src/speckle_objects/relations/layer.rb

@@ -11,7 +11,7 @@ module SpeckleConnector
         SPECKLE_TYPE = 'Speckle.Core.Models.Collection'
 
         # rubocop:disable Metrics/ParameterLists
-        def initialize(name:, visible:, is_folder:, line_style: nil, color: nil, layers_and_folders: [],
+        def initialize(name:, visible:, is_folder:, full_path: nil, line_style: nil, color: nil, layers_and_folders: [],
                        application_id: nil)
           super(
             speckle_type: SPECKLE_TYPE,
@@ -23,6 +23,7 @@ module SpeckleConnector
           self[:color] = color
           self[:visible] = visible
           self[:is_folder] =  is_folder
+          self[:full_path] =  full_path unless full_path.nil?
           self[:line_style] = line_style unless line_style.nil?
           self[:collectionType] = 'layer'
           self[:elements] = layers_and_folders if layers_and_folders.any?
@@ -43,14 +44,28 @@ module SpeckleConnector
           folder.add_layer(layer) if folder.is_a?(Sketchup::LayerFolder)
         end
 
-        def self.to_native_layer_folder(speckle_layer_folder, folder, sketchup_model)
-          speckle_layers = speckle_layer_folder[:elements].select { |layer_or_fol| layer_or_fol[:elements].nil? }
+        def self.to_native_flat_layers(layers_relation, sketchup_model)
+          speckle_layers = layers_relation[:elements]
+
+          elements_to_layers(speckle_layers, sketchup_model)
+        end
+
+        def self.elements_to_layers(elements, sketchup_model)
+          elements.each do |element|
+            element[:name] = element[:full_path]
+            to_native_layer(element, sketchup_model.layers, sketchup_model)
+            elements_to_layers(element[:elements], sketchup_model) unless element[:elements].nil?
+          end
+        end
+
+        def self.to_native_layer_folder(layers_relation, folder, sketchup_model)
+          speckle_layers = layers_relation[:elements].select { |layer_or_fol| layer_or_fol[:elements].nil? }
 
           speckle_layers.each do |speckle_layer|
             to_native_layer(speckle_layer, folder, sketchup_model)
           end
 
-          speckle_folders = speckle_layer_folder[:elements].reject { |layer_or_fol| layer_or_fol[:elements].nil? }
+          speckle_folders = layers_relation[:elements].reject { |layer_or_fol| layer_or_fol[:elements].nil? }
 
           speckle_folders.each do |speckle_folder|
             sub_folder = folder.add_folder(speckle_folder[:name])

speckle_connector/src/speckle_objects/relations/layers.rb

@@ -22,10 +22,29 @@ module SpeckleConnector
           self[:elements] = layers
         end
 
-        def self.element_to_relation(elements)
+        LAYER_FUNCTIONS = {
+          # 'rhino' => RhinoLayers.method(:to_native),
+          # 'revit' => RevitLayers.method(:to_native),
+          # 'sketchup' => SketchupLayers.method(:to_native),
+          # 'qgis' => QgisLayers.method(:to_native)
+        }.freeze
+
+        def self.element_to_relation(elements, source_app, parent_layers)
           elements.collect do |element|
             next unless element['speckle_type'] == SPECKLE_CORE_MODELS_COLLECTION
 
+            layers_tree = parent_layers.dup.append(element['name'])
+            full_path = ''
+            layers_tree.each_with_index do |parent, i|
+              full_path += if i == layers_tree.length - 1
+                             parent
+                           else
+                             "#{parent}::"
+                           end
+            end
+            # Add this info to commit object to check later layer_collection conversion
+            element['full_path'] = full_path if source_app.include?('rhino')
+
             is_folder = element['elements'].any? { |e| e['speckle_type'] == SPECKLE_CORE_MODELS_COLLECTION }
             color = element['color'] || element['displayStyle']['color'] unless element['displayStyle'].nil?
             Layer.new(
@@ -33,15 +52,16 @@ module SpeckleConnector
               visible: element['visible'],
               is_folder: is_folder,
               color: color,
-              layers_and_folders: element_to_relation(element['elements'])
+              full_path: full_path,
+              layers_and_folders: element_to_relation(element['elements'], source_app, layers_tree)
             )
           end.compact
         end
 
-        def self.extract_relations(commit_obj)
+        def self.extract_relations(commit_obj, source_app)
           return nil unless commit_obj['speckle_type'] == SPECKLE_CORE_MODELS_COLLECTION
 
-          elements = element_to_relation(commit_obj['elements'])
+          elements = element_to_relation(commit_obj['elements'], source_app, [])
 
           Layers.new(
             active: commit_obj['active_layer'],
@@ -49,10 +69,18 @@ module SpeckleConnector
           )
         end
 
-        def self.to_native(layers_relation, sketchup_model)
-          folder = sketchup_model.layers
+        def self.to_native(obj, source_app, sketchup_model)
+          layers_relation = extract_relations(obj, source_app)
+          return if layers_relation.nil?
 
-          SpeckleObjects::Relations::Layer.to_native_layer_folder(layers_relation, folder, sketchup_model)
+          folder = sketchup_model.layers
+          is_flat = source_app.include?('rhino')
+
+          if is_flat
+            SpeckleObjects::Relations::Layer.to_native_flat_layers(layers_relation, sketchup_model)
+          else
+            SpeckleObjects::Relations::Layer.to_native_layer_folder(layers_relation, folder, sketchup_model)
+          end
 
           active_layer = folder.to_a.find { |layer| layer.display_name == layers_relation['active_layer'] }
           sketchup_model.active_layer = active_layer unless active_layer.nil?
@@ -73,6 +101,7 @@ module SpeckleConnector
             layers: headless_layers + folders
           )
         end
+
       end
     end
   end

speckle_connector/src/speckle_objects/speckle/core/models/layer_collection.rb

@@ -99,6 +99,7 @@ module SpeckleConnector
               sketchup_model = state.sketchup_state.sketchup_model
               elements = layer_collection['elements']
               name = layer_collection['name']
+              name = layer_collection['full_path'] if layer_collection['full_path']
 
               layer = sketchup_model.layers.find { |l| l.display_name == name }
               layer_or_folder = layer if layer