legacy connector cosmetic changes (#430 )

* replace logo * change copy
Add legacy dialog to v2 (#420 )
2025-05-22 20:24:00 +03:00 · 2025-03-19 11:24:47 +03:00 · 2025-03-19 10:26:54 +03:00 · 2025-03-11 19:37:57 +03:00 · 2025-01-23 20:42:37 +03:00 · 2024-11-01 18:03:35 +00:00
286 changed files with 48626 additions and 8118 deletions
@@ -9,87 +9,226 @@ orbs:
 jobs:
  build-ui:
    docker:
-      - image: 'circleci/node:14'
+      - image: "circleci/node:16"
    steps:
      - checkout
      - run:
-          command: 'rm package-lock.json'
-          working_directory: 'ui'
+          command: "npm install"
+          working_directory: "ui"
      - run:
-          command: 'npm install'
-          working_directory: 'ui'
-      - run:
-          command: 'npm run build'
-          working_directory: 'ui'
+          command: "npm run build"
+          working_directory: "ui"
      - persist_to_workspace:
          root: ./
          paths:
-            - speckle_connector/html
+            - speckle_connector/vue_ui

  build-connector: # Reusable job for basic connectors
    executor:
      name: win/default # comes with python 3.7.3
-      shell: cmd.exe
+      shell: powershell.exe
    parameters:
      slug:
        type: string
        default: ""
+    environment:
+      SSM: 'C:\Program Files\DigiCert\DigiCert One Signing Manager Tools'
+    steps:
+      - checkout
+      - attach_workspace:
+          at: ./
+      - run:
+          name: Set Environment Variable
+          shell: powershell.exe
+          command: |
+            $tag = if([string]::IsNullOrEmpty($env:CIRCLE_TAG)) { "2.0.999" } else { $env:CIRCLE_TAG }
+            $semver = if($tag.Contains('/')) {$tag.Split("/")[0] } else { $tag }
+            $ver = if($semver.Contains('-')) {$semver.Split("-")[0] } else { $semver }
+            $version = "$($ver).$($env:WORKFLOW_NUM)"
+            python patch_version.py $semver
+          environment:
+            WORKFLOW_NUM: << pipeline.number >>
+      - unless: # Build installers unsigned on non-tagged builds
+          condition: << pipeline.git.tag >>
+          steps:
+            - run:
+                name: Build Installer
+                command: speckle-sharp-ci-tools\InnoSetup\ISCC.exe speckle-sharp-ci-tools\sketchup.iss /Sbyparam=$p
+                shell: cmd.exe # does not work in powershell
+      - when: # Setup certificates and build installers signed for tagged builds
+          condition: << pipeline.git.tag >>
+          steps:
+            - run:
+                name: "Digicert Signing Manager Setup"
+                command: |
+                  cd C:\
+                  curl.exe -X GET https://one.digicert.com/signingmanager/api-ui/v1/releases/smtools-windows-x64.msi/download -H "x-api-key:$env:SM_API_KEY" -o smtools-windows-x64.msi
+                  msiexec.exe /i smtools-windows-x64.msi /quiet /qn | Wait-Process
+            - run:
+                name: "Create Auth & OV Signing Cert"
+                command: |
+                  cd C:\
+                  echo $env:SM_CLIENT_CERT_FILE_B64 > certificate.txt
+                  certutil -decode certificate.txt certificate.p12
+            - run:
+                name: "Sync Certs"
+                command: |
+                  & $env:SSM\smksp_cert_sync.exe
+            - run:
+                name: "Build Installer"
+                command: speckle-sharp-ci-tools\InnoSetup\ISCC.exe speckle-sharp-ci-tools\sketchup.iss /Sbyparam=$p /DSIGN_INSTALLER /DCODE_SIGNING_CERT_FINGERPRINT=%SM_CODE_SIGNING_CERT_SHA1_HASH%
+                shell: cmd.exe
+      - persist_to_workspace:
+          root: ./
+          paths:
+            - speckle-sharp-ci-tools/Installers
+
+  build-connector-mac:
+    macos:
+      xcode: 13.4.1
+    parameters:
+      projname:
+        type: string
+        default: ""
+      slug:
+        type: string
+        default: ""
+      installer:
+        type: boolean
+        default: false
+      converter-files:
+        type: string
+        default: ""
+      installername:
+        type: string
+        default: ""
+      build-config:
+        type: string
+        default: Release
+      bundlename:
+        type: string
+        default: ""
    steps:
      - checkout
      - attach_workspace:
          at: ./
      - run:
-          name: Patch
-          shell: powershell.exe
-          command:
-            | # If no tag, use 0.0.0.1 and don't make any YML (for testing only!)
-            $tag = if([string]::IsNullOrEmpty($env:CIRCLE_TAG)) { "0.0.1" } else { $env:CIRCLE_TAG }
-            $semver = $tag.replace("-beta","")
-            $version = "$($semver).$($env:CIRCLE_BUILD_NUM)"
-            $channel = "latest"
-            if($tag -like "*-beta") { $channel = "beta" }
-            # only create the yml if we have a tag
-            New-Item -Force "speckle-sharp-ci-tools/Installers/sketchup/$channel.yml" -ItemType File -Value "version: $version"
-            echo $version
-            python patch_version.py $version
-            speckle-sharp-ci-tools\InnoSetup\ISCC.exe speckle-sharp-ci-tools\sketchup.iss
-      - persist_to_workspace:
-          root: ./
-          paths:
-            - speckle-sharp-ci-tools/Installers
+          name: Install dotnet
+          command: |
+            curl -sSL https://dot.net/v1/dotnet-install.sh | bash /dev/stdin --channel Current
+
+            $HOME/.dotnet/dotnet --version
+            $HOME/.dotnet/dotnet --list-runtimes
+            $HOME/.dotnet/dotnet --list-sdks
+      - run:
+          name: Create installer target dir
+          command: |
+            mkdir -p speckle-sharp-ci-tools/Installers/<< parameters.slug >>
+      - run:
+          name: Set Environment Variable
+          command: |
+            TAG=$(if [ "${CIRCLE_TAG}" ]; then echo $CIRCLE_TAG; else echo "2.0.999"; fi;)
+            SEMVER=$(echo "$TAG" | sed -e 's/\/[a-zA-Z-]*//')
+            VER=$(echo "$SEMVER" | sed -e 's/-.*//')
+            VERSION=$(echo $VER.$WORKFLOW_NUM)
+            python3 patch_version.py $SEMVER
+          environment:
+            WORKFLOW_NUM: << pipeline.number >>
+      - run:
+          name: Zip Connector files
+          command: |
+            zip -r << parameters.slug >>-mac.zip "./speckle_connector" "./speckle_connector.rb"
+            # Copy installer files
+      - run:
+          name: Copy files to installer
+          command: |
+            mkdir -p speckle-sharp-ci-tools/Mac/<< parameters.installername >>/.installationFiles/
+            cp << parameters.slug >>-mac.zip speckle-sharp-ci-tools/Mac/<<parameters.installername>>/.installationFiles
+      # Create installer
+      - run:
+          name: Exit if External PR
+          command: if [ "$CIRCLE_PR_REPONAME" ]; then circleci-agent step halt; fi
+      - run:
+          name: Build Mac installer
+          command: ~/.dotnet/dotnet publish speckle-sharp-ci-tools/Mac/<<parameters.installername>>/<<parameters.installername>>.sln -r osx-x64 -c Release
+      - run:
+          name: Zip installer
+          command: |
+            cd speckle-sharp-ci-tools/Mac/<<parameters.installername>>/bin/Release/net6.0/osx-x64/publish/
+            zip -r <<parameters.slug>>.zip ./
+      - store_artifacts:
+          path: speckle-sharp-ci-tools/Mac/<<parameters.installername>>/bin/Release/net6.0/osx-x64/publish/<<parameters.slug>>.zip
+      - run:
+          name: Copy to installer location
+          command: |
+            TAG=$(if [ "${CIRCLE_TAG}" ]; then echo $CIRCLE_TAG; else echo "2.0.999"; fi;)
+            SEMVER=$(echo "$TAG" | sed -e 's/\/[a-zA-Z-]*//')
+            VER=$(echo "$SEMVER" | sed -e 's/-.*//')
+            VERSION=$(echo $VER.$WORKFLOW_NUM)
+            cp speckle-sharp-ci-tools/Mac/<<parameters.installername>>/bin/Release/net6.0/osx-x64/publish/<<parameters.slug>>.zip speckle-sharp-ci-tools/Installers/<< parameters.slug >>/<<parameters.slug>>-$SEMVER.zip
+          environment:
+            WORKFLOW_NUM: << pipeline.number >>
+      - when:
+          condition: << pipeline.git.tag >>
+          steps:
+            - persist_to_workspace:
+                root: ./
+                paths:
+                  - speckle-sharp-ci-tools/Installers

  get-ci-tools: # Clones our ci tools and persists them to the workspace
    docker:
      - image: cimg/base:2021.01
    steps:
-      - run: 
+      - add_ssh_keys:
+          fingerprints:
+            - "03:2e:ee:4f:14:67:2b:88:32:e8:cc:f0:cb:df:92:29"
+      - run:
+          name: I know Github as a host
+          command: |
+            mkdir ~/.ssh
+            ssh-keyscan github.com >> ~/.ssh/known_hosts
+      - run:
          name: Clone
-          command: git clone https://$GITHUB_TOKEN@github.com/specklesystems/speckle-sharp-ci-tools.git speckle-sharp-ci-tools
-      - persist_to_workspace:
-          root: ./
-          paths:
-            - speckle-sharp-ci-tools
+          command: git clone git@github.com:specklesystems/speckle-sharp-ci-tools.git speckle-sharp-ci-tools
+      - run:
+          name: Checkout branch
+          command: |
+            cd speckle-sharp-ci-tools
+            if [ -z "$CIRCLE_TAG" ]
+            then
+                  git checkout ${CIRCLE_BRANCH} || git checkout main
+            else
+                  git checkout ${CIRCLE_TAG} || git checkout main
+            fi
      - persist_to_workspace:
          root: ./
          paths:
            - speckle-sharp-ci-tools

-  deploy: # Uploads all installers found to S3
+  deploy-manager2:
    docker:
-      - image: cimg/base:2021.01
+      - image: mcr.microsoft.com/dotnet/sdk:6.0
+    parameters:
+      slug:
+        type: string
+      os:
+        type: string
+      extension:
+        type: string
    steps:
+      - checkout
      - attach_workspace:
          at: ./
      - run:
-          name: List contents
-          command: ls -R speckle-sharp-ci-tools/Installers
-      - aws-s3/copy:
-          arguments: "--recursive --endpoint=https://$SPACES_REGION.digitaloceanspaces.com --acl public-read"
-          aws-access-key-id: SPACES_KEY
-          aws-region: SPACES_REGION
-          aws-secret-access-key: SPACES_SECRET
-          from: '"speckle-sharp-ci-tools/Installers/"'
-          to: s3://speckle-releases/installers/
+          name: Install Manager Feed CLI
+          command: dotnet tool install --global Speckle.Manager.Feed
+      - run:
+          name: Upload new version
+          command: |
+            TAG=$(if [ "${CIRCLE_TAG}" ]; then echo $CIRCLE_TAG; else echo "0.0.0"; fi;)
+            SEMVER=$(echo "$TAG" | sed -e 's/\/[a-zA-Z-]*//')
+            /root/.dotnet/tools/Speckle.Manager.Feed deploy -s << parameters.slug >> -v ${SEMVER} -u https://releases.speckle.dev/installers/<< parameters.slug >>/<< parameters.slug >>-${SEMVER}.<< parameters.extension >> -o << parameters.os >> -f speckle-sharp-ci-tools/Installers/<< parameters.slug >>/<< parameters.slug >>-${SEMVER}.<< parameters.extension >>

 workflows:
  build-and-deploy:
@@ -112,14 +251,39 @@ workflows:
          filters:
            tags:
              only: /.*/
+          context: digicert-keylocker

-      - deploy:
+      - build-connector-mac:
+          slug: sketchup
          requires:
            - get-ci-tools
            - build-ui
+          filters:
+            tags:
+              only: /.*/
+          installername: SpeckleSketchUpInstall
+
+      - deploy-manager2:
+          context: do-spaces-speckle-releases
+          slug: sketchup
+          os: Win
+          extension: exe
+          requires:
            - build-connector
          filters:
            tags:
-              only: /[0-9]+(\.[0-9]+)*/
+              only: /([0-9]+)\.([0-9]+)\.([0-9]+)(?:-\w+)?$/
+            branches:
+              ignore: /.*/ # For testing only! /ci\/.*/
+      - deploy-manager2:
+          context: do-spaces-speckle-releases
+          slug: sketchup
+          os: OSX
+          extension: zip
+          requires:
+            - build-connector-mac
+          filters:
+            tags:
+              only: /([0-9]+)\.([0-9]+)\.([0-9]+)(?:-\w+)?$/
            branches:
              ignore: /.*/ # For testing only! /ci\/.*/
@@ -0,0 +1,38 @@
+# This workflow uses actions that are not certified by GitHub.
+# They are provided by a third-party and are governed by
+# separate terms of service, privacy policy, and support
+# documentation.
+# This workflow will download a prebuilt Ruby version, install dependencies and run tests with Rake
+# For more information see: https://github.com/marketplace/actions/setup-ruby-jruby-and-truffleruby
+
+name: Ruby
+
+on:
+  push:
+    branches: [ "main" ]
+  pull_request:
+    branches: [ "main" ]
+
+permissions:
+  contents: read
+
+jobs:
+  test:
+
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        ruby-version: ['2.7']
+
+    steps:
+      - uses: actions/checkout@v3
+      - name: Set up Ruby
+        # To automatically get bug fixes and new Ruby versions for ruby/setup-ruby,
+        # change this to (see https://github.com/ruby/setup-ruby#versioning):
+        # uses: ruby/setup-ruby@v1
+        uses: ruby/setup-ruby@0a29871fe2b0200a17a4497bae54fe5df0d973aa # v1.115.3
+        with:
+          ruby-version: ${{ matrix.ruby-version }}
+          bundler-cache: true # runs 'bundle install' and caches installed gems automatically
+      - name: Run tests
+        run: bundle exec rake
@@ -10,8 +10,23 @@
 settings.json

 # vue app build dist folder
+speckle_connector/vue_ui
 speckle_connector/html
-  
+
+# speckle-sharp-ci-tools
+/speckle-sharp-ci-tools
+
+# _sqlite3
+/_sqlite3/.vs
+/_sqlite3/Release (2.7)
+/_sqlite3/Release (2.5)
+/_sqlite3/Release (2.2)
+/_sqlite3/Release (2.0)
+/_sqlite3/Debug (2.7)
+/_sqlite3/Debug (2.5)
+/_sqlite3/Debug (2.2)
+/_sqlite3/Debug (2.0)
+
 *.gem
 *.rbc
 /.config
@@ -24,6 +39,9 @@ speckle_connector/html
 /test/version_tmp/
 /tmp/

+# IDE
+.idea
+
 # Used by dotenv library to load environment variables.
 .env

@@ -0,0 +1,3 @@
+[submodule "_sqlite3"]
+	path = _sqlite3
+	url = https://github.com/specklesystems/sketchup-sqlite3.git
@@ -1,46 +1,132 @@
+require:
+  - rubocop-sketchup
+  - rubocop-minitest
+  - rubocop-rake
+
 AllCops:
-  TargetRubyVersion: 2.7
-  EnabledByDefault: true
-  AutoCorrect: true
+  TargetRubyVersion: 2.5
+  DisabledByDefault: false
+  NewCops: enable
+  DisplayCopNames: true
+  ExtraDetails: true
  SuggestExtensions: false
+  Exclude:
+    - '_tools/jf_RubyPanel.rb'
+    - '_tools/jf_RubyPanel/**/*.rb'
+    - '_tools/su_attributes.rb'
+    - '_tools/su_attributes/**/*.rb'
+    - '_tools/su_attributes/**/*.rb'
+    - '_sqlite3/**/*.rb'
+    - 'ui/**/*'
+    - 'speckle_connector/src/ext/**/*.rb'
+    - 'vendor/bundle/**/*'
+    - 'tests/**/*.rb'
+  SketchUp:
+    SourcePath: .
+    TargetSketchUpVersion: 2021
+    Exclude: # Exclude common folders.
+      - 'tests/**/*'
+      - 'benchmarks/**/*'
+      - '_tools/**/*'
+      - 'Rakefile'

-Style/StringLiterals:
+Layout:
  Enabled: true
-  EnforcedStyle: double_quotes

-Style/StringLiteralsInInterpolation:
+Layout/IndentationStyle:
+  EnforcedStyle: spaces
+  IndentationWidth: 2
+
+# If DisabledByDefault is set to true then we need to enable the SketchUp
+# related departments:
+
+SketchupDeprecations:
  Enabled: true
-  EnforcedStyle: double_quotes

-Layout/LineLength:
-  Max: 120
+SketchupPerformance:
+  Enabled: true

-Lint/ConstantResolution:
+SketchupRequirements:
+  Enabled: true
+
+SketchupSuggestions:
+  Enabled: true
+
+SketchupBugs:
+  Enabled: true
+
+SketchupRequirements/FileStructure:
  Enabled: false

-Style/Copyright:
-  Enabled: false
-
-Style/DocumentationMethod:
+SketchupSuggestions/ModelEntities:
  Enabled: false

 Metrics/AbcSize:
-  Enabled: false
-  
-Metrics/ClassLength:
-  Enabled: false
+  Max: 30

-Metrics/ModuleLength:
-  Enabled: false
+Metrics/BlockLength:
+  # Exclude spec tests
+  Exclude:
+    - "**/*_spec.rb"

 Metrics/MethodLength:
+  Max: 20
+
+Metrics/ClassLength:
+  Max: 200
+
+Layout/EndOfLine:
+  Enabled: false
+  EnforcedStyle: lf
+
+Minitest/MultipleAssertions:
+  Max: 5
+
+Naming/MethodParameterName:
+  AllowedNames: [x, y, z, id]
+
+Naming/VariableNumber:
+  EnforcedStyle: snake_case
+
+# SketchUp 2017 uses Ruby 2.2 where safe navigation is not available
+Style/SafeNavigation:
  Enabled: false

-Metrics/ParameterLists:
+Style/AndOr:
  Enabled: false

-Metrics/CyclomaticComplexity:
+Style/Documentation:
+  Exclude:
+    - "*tests/**/*_spec.rb"
+    - "*tests/**/*_test.rb"
+
+Style/Not:
  Enabled: false

-Metrics/PerceivedComplexity:
+Style/NumericLiterals:
+  Enabled: false
+
+Style/NumericPredicate:
+  EnforcedStyle: comparison
+
+Style/Proc:
+  Enabled: false
+
+Style/RedundantReturn:
+  Enabled: false
+
+# SketchUp 2017 uses Ruby 2.2 where safe navigation is not available
+Style/SlicingWithRange:
+  Enabled: false
+
+# SketchUp 2017 uses Ruby 2.2 where transform_values is not available
+Style/HashTransformValues:
+  Enabled: false
+
+# SketchUp 2017 uses Ruby 2.2 where transform_keys is not available
+Style/HashTransformKeys:
+  Enabled: false
+
+# SketchUp 2017 uses Ruby 2.2 where block needs to be wrapped in begin/end if ensure can be used
+Style/RedundantBegin:
  Enabled: false
@@ -12,6 +12,15 @@
        "command": "&'C:/Program Files/SketchUp/SketchUp 2021/SketchUp.exe' -rdebug 'ide port=7000'",
      },
      "problemMatcher": []
-    }
+    },
+    {
+      "label": "Debug SketchUp 2022",
+      "type": "shell",
+      "command": "open -a '/Applications/SketchUp 2022/SketchUp.app' --args -rdebug 'ide port=7000'",
+      "windows": {
+        "command": "&'C:/Program Files/SketchUp/SketchUp 2022/SketchUp.exe' -rdebug 'ide port=7000'",
+      },
+      "problemMatcher": []
+    },
  ]
 }
@@ -1,16 +1,29 @@
 # frozen_string_literal: true

-source "https://rubygems.org"
-
-# gem "rake", "~> 13.0"
-
-gem "rubocop", "~> 1.7"
-
+source 'https://rubygems.org'

 group :development do
-  gem "minitest"
-  gem "sketchup-api-stubs"
-  gem "solargraph"
+  # mini tests for ruby classes
+  gem 'minitest'
+  # Git hooks manager
+  gem 'overcommit', require: false
+  # Pry is a runtime developer console and IRB alternative with powerful introspection capabilities.
+  # Pry aims to be more than an IRB replacement. It is an attempt to bring REPL driven programming to the Ruby language.
+  gem 'pry'
+  # Make-like program implemented in Ruby. Tasks and dependencies are specified in standard Ruby syntax.
+  gem 'rake'
+  # RuboCop is a Ruby static code analyzer (a.k.a. linter) and code formatter.
+  gem 'rubocop'
+  # A RuboCop extension focused on enforcing Minitest best practices and coding conventions.
+  gem 'rubocop-minitest'
+  # A RuboCop plugin for Rake.
+  gem 'rubocop-rake'
+  # Code analysis for SketchUp extensions using the SketchUp Ruby API.
+  gem 'rubocop-sketchup'
+  # wraps around static analysis gems such as Reek, Flay and Flog to provide a quality report of your Ruby code.
+  gem 'rubycritic', '~> 4.3', '>= 4.3.3', require: false
+  # Auto completions for SketchUp API.
+  gem 'sketchup-api-stubs'
+  # Aid with common SketchUp extension tasks.
+  gem 'skippy', '~> 0.4.1.a'
 end
-
-gem "sqlite3", "~> 1.4"
@@ -1,74 +1,133 @@
 GEM
  remote: https://rubygems.org/
  specs:
+    addressable (2.8.4)
+      public_suffix (>= 2.0.2, < 6.0)
    ast (2.4.2)
-    backport (1.2.0)
-    benchmark (0.1.1)
-    diff-lcs (1.4.4)
-    e2mmap (0.1.0)
-    jaro_winkler (1.5.4)
-    kramdown (2.3.1)
-      rexml
-    kramdown-parser-gfm (1.1.0)
-      kramdown (~> 2.0)
-    minitest (5.14.4)
-    nokogiri (1.12.5-x64-mingw32)
-      racc (~> 1.4)
-    nokogiri (1.12.5-x86_64-linux)
-      racc (~> 1.4)
-    parallel (1.20.1)
-    parser (3.0.2.0)
+    axiom-types (0.1.1)
+      descendants_tracker (~> 0.0.4)
+      ice_nine (~> 0.11.0)
+      thread_safe (~> 0.3, >= 0.3.1)
+    childprocess (4.1.0)
+    coderay (1.1.3)
+    coercible (1.0.0)
+      descendants_tracker (~> 0.0.1)
+    descendants_tracker (0.0.4)
+      thread_safe (~> 0.3, >= 0.3.1)
+    docile (1.4.0)
+    equalizer (0.0.11)
+    erubi (1.11.0)
+    flay (2.13.0)
+      erubi (~> 1.10)
+      path_expander (~> 1.0)
+      ruby_parser (~> 3.0)
+      sexp_processor (~> 4.0)
+    flog (4.6.6)
+      path_expander (~> 1.0)
+      ruby_parser (~> 3.1, > 3.1.0)
+      sexp_processor (~> 4.8)
+    git (1.18.0)
+      addressable (~> 2.8)
+      rchardet (~> 1.8)
+    ice_nine (0.11.2)
+    iniparse (1.5.0)
+    kwalify (0.7.2)
+    launchy (2.5.0)
+      addressable (~> 2.7)
+    method_source (1.0.0)
+    minitest (5.16.3)
+    naturally (2.2.1)
+    overcommit (0.59.1)
+      childprocess (>= 0.6.3, < 5)
+      iniparse (~> 1.4)
+      rexml (~> 3.2)
+    parallel (1.22.1)
+    parser (3.1.2.1)
      ast (~> 2.4.1)
-    racc (1.6.0)
-    rainbow (3.0.0)
-    regexp_parser (2.1.1)
-    reverse_markdown (2.0.0)
-      nokogiri
+    path_expander (1.1.1)
+    pry (0.14.1)
+      coderay (~> 1.1)
+      method_source (~> 1.0)
+    public_suffix (5.0.1)
+    rainbow (3.1.1)
+    rake (13.0.6)
+    rchardet (1.8.0)
+    reek (6.1.1)
+      kwalify (~> 0.7.0)
+      parser (~> 3.1.0)
+      rainbow (>= 2.0, < 4.0)
+    regexp_parser (2.6.0)
    rexml (3.2.5)
-    rubocop (1.19.1)
+    rubocop (1.7.0)
      parallel (~> 1.10)
-      parser (>= 3.0.0.0)
+      parser (>= 2.7.1.5)
      rainbow (>= 2.2.2, < 4.0)
      regexp_parser (>= 1.8, < 3.0)
      rexml
-      rubocop-ast (>= 1.9.1, < 2.0)
+      rubocop-ast (>= 1.2.0, < 2.0)
      ruby-progressbar (~> 1.7)
-      unicode-display_width (>= 1.4.0, < 3.0)
-    rubocop-ast (1.11.0)
-      parser (>= 3.0.1.1)
+      unicode-display_width (>= 1.4.0, < 2.0)
+    rubocop-ast (1.4.1)
+      parser (>= 2.7.1.5)
+    rubocop-minitest (0.23.0)
+      rubocop (>= 0.90, < 2.0)
+    rubocop-rake (0.6.0)
+      rubocop (~> 1.0)
+    rubocop-sketchup (1.3.0)
+      rubocop (>= 0.82, < 2.0)
    ruby-progressbar (1.11.0)
-    sketchup-api-stubs (0.7.7)
-    solargraph (0.43.0)
-      backport (~> 1.2)
-      benchmark
-      bundler (>= 1.17.2)
-      diff-lcs (~> 1.4)
-      e2mmap
-      jaro_winkler (~> 1.5)
-      kramdown (~> 2.3)
-      kramdown-parser-gfm (~> 1.1)
-      parser (~> 3.0)
-      reverse_markdown (>= 1.0.5, < 3)
-      rubocop (>= 0.52)
-      thor (~> 1.0)
-      tilt (~> 2.0)
-      yard (~> 0.9, >= 0.9.24)
-    sqlite3 (1.4.2)
-    thor (1.1.0)
-    tilt (2.0.10)
-    unicode-display_width (2.0.0)
-    yard (0.9.26)
+    ruby_parser (3.19.1)
+      sexp_processor (~> 4.16)
+    rubycritic (4.7.0)
+      flay (~> 2.8)
+      flog (~> 4.4)
+      launchy (>= 2.0.0)
+      parser (>= 2.6.0)
+      rainbow (~> 3.0)
+      reek (~> 6.0, < 7.0)
+      ruby_parser (~> 3.8)
+      simplecov (>= 0.17.0)
+      tty-which (~> 0.4.0)
+      virtus (~> 1.0)
+    sexp_processor (4.16.1)
+    simplecov (0.21.2)
+      docile (~> 1.1)
+      simplecov-html (~> 0.11)
+      simplecov_json_formatter (~> 0.1)
+    simplecov-html (0.12.3)
+    simplecov_json_formatter (0.1.4)
+    sketchup-api-stubs (0.7.8)
+    skippy (0.4.3.a)
+      git (~> 1.3)
+      naturally (~> 2.1)
+      thor (~> 0.19)
+    thor (0.20.3)
+    thread_safe (0.3.6)
+    tty-which (0.4.2)
+    unicode-display_width (1.8.0)
+    virtus (1.0.5)
+      axiom-types (~> 0.1)
+      coercible (~> 1.0)
+      descendants_tracker (~> 0.0, >= 0.0.3)
+      equalizer (~> 0.0, >= 0.0.9)

 PLATFORMS
  x64-mingw32
+  x64-unknown
  x86_64-linux

 DEPENDENCIES
  minitest
-  rubocop (~> 1.7)
+  overcommit
+  pry
+  rake
+  rubocop
+  rubocop-minitest
+  rubocop-rake
+  rubocop-sketchup
+  rubycritic (~> 4.3, >= 4.3.3)
  sketchup-api-stubs
-  solargraph
-  sqlite3 (~> 1.4)
+  skippy (~> 0.4.1.a)

 BUNDLED WITH
-   2.2.26
+   2.3.25
@@ -2,66 +2,60 @@
  <img src="https://user-images.githubusercontent.com/2679513/131189167-18ea5fe1-c578-47f6-9785-3748178e4312.png" width="150px"/><br/>
  Speckle | SketchUp
 </h1>
+
+<p align="center"><a href="https://twitter.com/SpeckleSystems"><img src="https://img.shields.io/twitter/follow/SpeckleSystems?style=social" alt="Twitter Follow"></a> <a href="https://speckle.community"><img src="https://img.shields.io/discourse/users?server=https%3A%2F%2Fspeckle.community&amp;style=flat-square&amp;logo=discourse&amp;logoColor=white" alt="Community forum users"></a> <a href="https://speckle.systems"><img src="https://img.shields.io/badge/https://-speckle.systems-royalblue?style=flat-square" alt="website"></a> <a href="https://speckle.guide/dev/"><img src="https://img.shields.io/badge/docs-speckle.guide-orange?style=flat-square&amp;logo=read-the-docs&amp;logoColor=white" alt="docs"></a></p>
+
+> Speckle is the first AEC data hub that connects with your favorite AEC tools. Speckle exists to overcome the challenges of working in a fragmented industry where communication, creative workflows, and the exchange of data are often hindered by siloed software and processes. It is here to make the industry better.
+
 <h3 align="center">
    Connector for SketchUp
 </h3>
-<p align="center"><b>Speckle</b> is the data infrastructure for the AEC industry.</p><br/>

-<p align="center"><a href="https://twitter.com/SpeckleSystems"><img src="https://img.shields.io/twitter/follow/SpeckleSystems?style=social" alt="Twitter Follow"></a> <a href="https://speckle.community"><img src="https://img.shields.io/discourse/users?server=https%3A%2F%2Fspeckle.community&amp;style=flat-square&amp;logo=discourse&amp;logoColor=white" alt="Community forum users"></a> <a href="https://speckle.systems"><img src="https://img.shields.io/badge/https://-speckle.systems-royalblue?style=flat-square" alt="website"></a> <a href="https://speckle.guide/dev/"><img src="https://img.shields.io/badge/docs-speckle.guide-orange?style=flat-square&amp;logo=read-the-docs&amp;logoColor=white" alt="docs"></a></p>
-<p align="center"><a href="https://github.com/specklesystems/speckle-blender/"><img src="https://circleci.com/gh/specklesystems/speckle-blender.svg?style=svg&amp;circle-token=76eabd350ea243575cbb258b746ed3f471f7ac29" alt="Speckle-Next"></a> </p>
-
-# About Speckle
-
-What is Speckle? Check our ![YouTube Video Views](https://img.shields.io/youtube/views/B9humiSpHzM?label=Speckle%20in%201%20minute%20video&style=social)
-
-### Features
-
- **Object-based:** say goodbye to files! Speckle is the first object based platform for the AEC industry
- **Version control:** Speckle is the Git & Hub for geometry and BIM data
- **Collaboration:** share your designs collaborate with others
- **3D Viewer:** see your CAD and BIM models online, share and embed them anywhere
- **Interoperability:** get your CAD and BIM models into other software without exporting or importing
- **Real time:** get real time updates and notifications and changes
- **GraphQL API:** get what you need anywhere you want it
- **Webhooks:** the base for a automation and next-gen pipelines
- **Built for developers:** we are building Speckle with developers in mind and got tools for every stack
- **Built for the AEC industry:** Speckle connectors are plugins for the most common software used in the industry such as Revit, Rhino, Grasshopper, AutoCAD, Civil 3D, Excel, Unreal Engine, Unity, QGIS, Blender and more!
-
-### Try Speckle now!
-
-Give Speckle a try in no time by:
-
- [![speckle XYZ](https://img.shields.io/badge/https://-speckle.xyz-0069ff?style=flat-square&logo=hackthebox&logoColor=white)](https://speckle.xyz) ⇒ creating an account at our public server
- [![create a droplet](https://img.shields.io/badge/Create%20a%20Droplet-0069ff?style=flat-square&logo=digitalocean&logoColor=white)](https://marketplace.digitalocean.com/apps/speckle-server?refcode=947a2b5d7dc1) ⇒ deploying an instance in 1 click 
-
-### Resources
-
- [![Community forum users](https://img.shields.io/badge/community-forum-green?style=for-the-badge&logo=discourse&logoColor=white)](https://speckle.community) for help, feature requests or just to hang with other speckle enthusiasts, check out our community forum!
- [![website](https://img.shields.io/badge/tutorials-speckle.systems-royalblue?style=for-the-badge&logo=youtube)](https://speckle.systems) our tutorials portal is full of resources to get you started using Speckle
- [![docs](https://img.shields.io/badge/docs-speckle.guide-orange?style=for-the-badge&logo=read-the-docs&logoColor=white)](https://speckle.guide/user/blender.html) reference on almost any end-user and developer functionality
-
-
-# Repo structure
+#  Repo structure

 This is the beginning of the Speckle SketchUp Connector. It is still in very early development and is not ready for general use.
+This repo is split into three parts:

-This repo is split into two parts: `speckle_connector` which is the Ruby SketchUp plugin and `ui` which is the Vue frontend.
+### 1. **Speckle Connector extension** 
+   
+   Includes the `ruby` source files to run extension on SketchUp environment. SketchUp Extensions are composed of
+   a **.rb** file as entry and **folder** that .rb file refers to. In our case entry file is `speckle_connector.rb`
+   that responsible to register Speckle Connector extension to SketchUp and also it shows address to where extension
+   will start to read extension. Source folder is `speckle_connector`.

-## Usage
+### 2. **User Interface**

-> NOTE: this connector is still in early development and isn't ready for general use.
+   Includes the `Vue` frontend lives in the `ui` folder.

-Copy the whole `speckle_connector` folder to you SketchUp Plugins folder. You will likely find this at: 
+### 3. **SketchUp Sqlite3 extension** [submodule](https://github.com/specklesystems/sketchup-sqlite3)

-    C:\Users\{YOU}\AppData\Roaming\SketchUp\SketchUp 2021\SketchUp\Plugins
+   Includes source codes of base `SQLite3` C/C++ library and `ruby` compiler files to be able to run SQLite3
+   functionality on SketchUp in the same ruby module like `SpeckleConnector::Sqlite3::Database`. By this way
+   we use extensions as native part of the source `ruby` code. 

+   After building `sqlite3.sln` file, compiled `sqlite3.so` (for Windows) and `sqlite3.bundle` (for OSX) dynamic library files are created
+   by solution to place them into source code into `speckle_connector/src/ext`. Building this project should be only
+   happen when SketchUp starts to support newer Ruby versions (currently it is `2.7`).
+   
+### Other repos

-You'll need to serve the ui before launching the connector:
+Make sure to also check and ⭐️ these other Speckle next generation repositories:

-    cd ui
-    npm install
-    npm run serve
+- [`speckle-sharp-connectors`](https://github.com/specklesystems/speckle-sharp-connectors): .NET connectors and desktop UI
+- [`speckle-sharp-sdk`](https://github.com/specklesystems/speckle-sharp-sdk): our .NET SDK for next gen connectors and development
+- [`speckle-powerbi`](https://github.com/specklesystems/speckle-powerbi): PowerBi connector
+- and more [connectors & tooling](https://github.com/specklesystems/)!

+## Contribution Guide
+
+Before start to contribute, it is better to understand how align with other contributors. It will make easier job
+of reviewer when you submit an issue or PR. If it is your first repo to contribute Speckle environment make sure that you read 
+[Contribution Guideline](https://github.com/specklesystems/speckle-sharp/blob/main/.github/CONTRIBUTING.md).
+
+Additionally as mentioned on [Repo Structure](#3-sketchup-sqlite3-extension-submodulehttpsgithubcomspecklesystemssketchup-sqlite3),
+this repo includes a submodule. Contributions on this source files should be done on the [sketchup-sqlite](https://github.com/specklesystems/sketchup-sqlite3)
+by creating issues and PRs on it. If it is your first time works with submodules, please read [git docs](https://git-scm.com/book/en/v2/Git-Tools-Submodules)
+briefly to get some insight about it.

 ## Development

@@ -77,55 +71,75 @@ This should have also have set up the package installer `gem` and interactive ru
    gem -v
    irb -v

-Let's also install our first gem `bundle` which is a package manager that will help us with development.
+Let's also install our first gem `bundler` which is a package manager that will help us with development.

-    gem install bundle
+    gem install bundler

 ### Editor Setup

 Clone this repo and run:

-    bundle install
+    bundler install

 This will install all the necessary packages for the connector.

-Next, install the Sketchup Ruby Debugger. You can find installation instructions [here](https://github.com/SketchUp/sketchup-ruby-debugger/blob/main/README.md). This will involve downloading the `dll` and copying it into the SketchUp installation directory:
+Next, install the Sketchup Ruby Debugger. You can find installation instructions 
+[here](https://github.com/SketchUp/sketchup-ruby-debugger/blob/main/README.md). 
+This will involve downloading the `dll` and copying it into the SketchUp installation 
+directory:

-    C:\Program Files\SketchUp\SketchUp 2021\
+    C:\Program Files\SketchUp\SketchUp 20XX\

-You can now open up the repo in VS Code.
+You can now open up the repo in VS Code or you can use JetBrains' tools RubyMine and Webstorm.

-Make sure you've installed the Ruby extension for VS Code.
+If you will use VS Code, make sure you've installed the Ruby extension for VS Code.

-### Loading the Plugin
+### Loading the Speckle Connector Plugin

-To tell SketchUp to load the plugin from wherever you happen to be developing, you'll need to create a ruby file with the following contents:
+1. Find already prepared `speckle_connector_loader.rb` file on the `_tools`
+folder.
+2. Copy this Ruby file into your SketchUp Plugins directory. You will likely find this at:
+    `C:\Users\{YOU}\AppData\Roaming\SketchUp\SketchUp 20XX\SketchUp\Plugins`
+3. Update below line on the copied file with your local git file.
+   ```ruby
+    speckle_path = File.join(home_folder, 'Git', 'Speckle', 'speckle-sketchup')
+   ```
+   By this way SketchUp will directly read your local repository. Do not forget, 
+   this file also loads additional tools on the `_tools` folder. 
+   Those are will be only available on dev mode.

-```ruby
-$LOAD_PATH << 'C:\YOUR\PATH\TO\THE\sketchup_connector'
-require 'speckle_connector.rb'
-```
+Due to the fact that Ruby is interpreted language, so you can reload your file(s) when
+you changed them. There are different kinds of ways to reload them.

-Drop this Ruby file into your SketchUp Plugins directory. You will likely find this at: 
+1. To reload the whole plugin files while SketchUp is running, open up the Ruby console
+and run the following:
+    ```ruby
+    SpeckleConnector.reload
+    ```
+2. To reload only specific files, use `jf ruby toolbar` plugin that already available
+on SketchUp toolbar.

-    C:\Users\{YOU}\AppData\Roaming\SketchUp\SketchUp 2021\SketchUp\Plugins 
+### User Interface

-To reload the plugin while SketchUp is running, open up the Ruby console and run the following:
+If it is your first time you cloned the project and willing to see Speckle UI, you
+should make sure that you compiled the `vue.js` project in the `ui` folder.

-    SpeckleSystems::SpeckleConnector.reload
-
-To run the `ui`, create a `.env` based on `.env-example` and paste in your Speckle token. Then:
+To run the `ui`, create a `.env` based on `.env-example` and paste in your 
+Speckle token. Then:

    cd ui
    npm run serve

 ### Debugging 

-To run SketchUp in debug mode, you will run the task specified in `tasks.json`. Before you do this, make sure your integrated shell for tasks is using powershell. You can specify this by adding the following option to your workspace's `settings.json`
+To run SketchUp in debug mode, you will run the task specified in `tasks.json`.
+Before you do this, make sure your integrated shell for tasks is using powershell. 
+You can specify this by adding the following option to your workspace's `settings.json`

    "terminal.integrated.automationShell.windows": "powershell.exe",

-To start the task, use the keyboard shortcut `ctrl` + `shift` + `p` to open up the Command Palette. Search for `Tasks: Run Task` and select it:
+To start the task, use the keyboard shortcut `ctrl` + `shift` + `p` to open up 
+the Command Palette. Search for `Tasks: Run Task` and select it:

 ![command palette](https://user-images.githubusercontent.com/7717434/135051668-35fee34e-5270-4b83-9c7b-dabb872370ee.png)

@@ -133,9 +147,30 @@ Then choose the `Debug Sketchup 2021` task to run it:

 ![debug sketchup task](https://user-images.githubusercontent.com/7717434/135051777-4c350a62-45fb-400e-9b24-4fbb02331b83.png)

-Once Sketchup has launched, start the `Listen for rdebug-ide` debug configuration. Once the debugger has connected, you'll be able to debug the connector normally.
+Once Sketchup has launched, start the `Listen for rdebug-ide` debug configuration. 
+Once the debugger has connected, you'll be able to debug the connector normally.

 Make sure you run the `ui` before starting the SketchUp Connector

    cd ui
-    npm run serve
+    npm run serve
+
+### Code Quality
+
+Tracking your code quality before merging any code to `main` branch might not seem at the
+first time crucial, but when repo became huge, you might have many spaghetti code and technical
+depth. It is always better to keep your work tough from the beginning. For this reason some
+workflows have already setup on CI, those workflows must be passed before considering to
+merge.
+
+To track your code quality locally,
+
+1. Make sure that you do not have any RuboCop issue, run below
+   ```ruby
+   bundle exec rake 
+   ```
+   
+2. To check overall state of repository by RubyCritic, run below
+   ```ruby
+   rake rubycritic 
+   ```
@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require 'rake/testtask'
+require 'rubocop/rake_task'
+require 'rubycritic/rake_task'
+
+module SpeckleConnector
+  # Custom utility functions for rake tasks
+  module RakeUtils
+    module_function
+
+    # Find ruby files that were changed from `main` to the latest revision
+    def changed_rb_files(previous_revision: 'main', latest_revision: '')
+      range = latest_revision.empty? ? previous_revision : "#{latest_revision}..#{previous_revision}"
+      command = "git diff #{range} --name-only"
+      changed_files = `#{command}`.split("\n")
+      # filter changed files with ruby files (.rb), Gemfile and Rakefile.
+      filtered_files = changed_files.grep(/.*\.rb$|Gemfile|Rakefile/)
+      filtered_files.select { |file| File.exist?(file) }
+    end
+  end
+end
+
+# Add default rubocop task
+RuboCop::RakeTask.new(:default)
+
+# Add task to only verify ruby files that are different than in the `main` branch
+desc('Run rubocop on changed files')
+RuboCop::RakeTask.new(:rubocop_changed) do |t|
+  t.patterns = FileList.new(SpeckleConnector::RakeUtils.changed_rb_files)
+end
+
+# Glob pattern to match source files. Defaults to FileList['.'].
+ruby_critic_paths = FileList[
+  'speckle_connector/**/*.rb',
+  'speckle_connector.rb',
+  'tests/**/*.rb'] -
+                    FileList[
+                    '_tools/**/*.rb',
+                    'speckle_connector/src/ext/**/*.rb',
+                    ]
+
+# for local
+RubyCritic::RakeTask.new('rubycritic') do |task|
+  task.paths = ruby_critic_paths
+end
+
+# for CI
+RubyCritic::RakeTask.new('rubycritic-ci') do |task|
+  task.options = '--mode-ci --format console --no-browser --branch main'
+  task.paths = ruby_critic_paths
+end
@@ -0,0 +1,25 @@
+# Tools
+
+This folder stores the external tools and helper scripts to make easier life of the developer,
+they are not the part of the main functionality of the Speckle.
+
+Tools and scripts inside the folder will be loaded with `sketchup_connector_loader.rb` file.
+In order to load your own `.rb` files please add this file names into list in the loader.
+
+````ruby
+...
+  
+files = %w[speckle_connector jf_RubyPanel su_attributes <put-your-file-here>]
+# This line placed before loading started. 
+
+files.each do |ruby_file|
+  puts "Loading #{ruby_file}"
+  begin
+    require ruby_file
+  rescue LoadError
+    puts "Could not load #{ruby_file}"
+  end
+end
+````
+
+Track load status of your tools and scripts on the ruby console when SketchUp UI initializing. 
@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+# #-------------------------------------------------------------------------------------------------
+# *************************************************************************************************
+# RubyPanel Toolbar (C) 2007 jim.foltz@gmail.com
+#
+# With special thanks to Chris Phillips (Sketchy Physics)
+# for the Win32API code examples.
+#
+# 2011-01-05 <jim.foltz@gmail.com>
+#   * Changed Toolbar name from "Ruby COnsole" to "Ruby Toolbar"  (TT)
+#     http://forums.sketchucation.com/viewtopic.php?f=323&t=1542&p=298587#p298587
+#   * Wrapped in addition module RubyToolbar
+#   * Use $suString.GetSting to get proper "Ruby Console" name string.
+#   * Better check if TB was previously visible
+#   * Use UI.start_timer to restore Toolbar
+# ICONS: located in the subfolder "rubytoolbar"
+# MODIFICATION: by Fredo6 for compliance with SU 2014 (and no dependency on Win32API) - 18 Sep 2013
+# *************************************************************************************************
+#-------------------------------------------------------------------------------------------------
+
+require 'sketchup'
+require 'extensions'
+
+ext = SketchupExtension.new('Ruby Toolbar', 'jf_RubyPanel/rubytoolbar.rb')
+ext.creator = 'Jim Foltz <jim.foltz@gmail.com>'
+ext.description = 'Toolbar for manipulating the Ruby Console. Compatible with SketchUp 2014'
+ext.version = '2014'
+Sketchup.register_extension(ext, true)
@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+#-------------------------------------------------------------------------------------------------------------------------------------------------
+# RubyPanel Toolbar (C) 2007 jim.foltz@gmail.com
+
+# Permission to use, copy, modify, and distribute this software for # any purpose and without fee is hereby granted,
+# provided that the above copyright notice appear in all copies.
+
+# THIS SOFTWARE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR  IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION,
+# THE IMPLIED  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+
+# Description:   Manage the loading of Ruby files and display of the Ruby console
+# CREDITS: Special thanks to Chris Phillips (Sketchy Physics) for the Win32API code examples
+# Revision:  3 Aug 2009, by Fredo6
+# ICONS: located in the subfolder "rubytoolbar"
+# MODIFICATION: by Fredo6 for compliance with SU 2014 (and no dependency on Win32API) - 18 Sep 2013
+#-------------------------------------------------------------------------------------------------------------------------------------------------
+
+require 'English'
+require 'sketchup'
+
+module JF_RubyToolbar
+  # Load the toolbar icons and commands, and do some initialization
+  def self.load_toolbar
+    @last_dir = "#{$LOAD_PATH[0]}/"
+    @last_dir = @last_dir.gsub('/', '\\\\\\\\')
+    @last_dir = File.join($JF_RUBYTOOLBAR, 'speckle_connector')
+    curdir = File.dirname __FILE__
+
+    # create toolbar
+    tb = UI::Toolbar.new 'Ruby Toolbar'
+
+    # Toggle console
+    cmd = UI::Command.new('Show/Hide') { SKETCHUP_CONSOLE.visible? ? SKETCHUP_CONSOLE.hide : SKETCHUP_CONSOLE.show }
+    cmd.large_icon = cmd.small_icon = File.join(curdir, 'rubypanel.png')
+    cmd.status_bar_text = cmd.tooltip = 'Show/Hide Ruby Console'
+    tb.add_item cmd
+
+    # Clear Console
+    cmd = UI::Command.new('Clear') { SKETCHUP_CONSOLE.clear }
+    cmd.status_bar_text = cmd.tooltip = 'Clear Console'
+    cmd.large_icon = cmd.small_icon = File.join(curdir, 'Delete24.png')
+    tb.add_item cmd
+
+    # Load a Ruby script
+    cmd = UI::Command.new('LoadScript') { load_script }
+    cmd.large_icon = cmd.small_icon = File.join(curdir, 'doc_ruby.png')
+    cmd.tooltip = cmd.status_bar_text = 'Load Script'
+    tb.add_item cmd
+
+    # Reload the last Ruby Script
+    @cmd_reload = UI::Command.new('Reload') { load_script @last_file }
+    @cmd_reload.large_icon = @cmd_reload.small_icon = File.join(curdir, 'reload.png')
+    @cmd_reload.status_bar_text = @cmd_reload.tooltip = 'Reload Script'
+    tb.add_item @cmd_reload
+
+    # Open the SU plugins directory panel
+    cmd = UI::Command.new('PluginsDir') { UI.openURL @last_dir }
+    cmd.tooltip = cmd.status_bar_text = 'Browse Plugins Folder'
+    cmd.large_icon = cmd.small_icon = File.join(curdir, 'open_folder.png')
+    tb.add_item cmd
+
+    # showing the toolbar
+    tb.get_last_state == -1 ? tb.show : tb.restore
+  end
+
+  # Load a script file - if <file> is nil, open the dialog panel to select the file
+  def self.load_script(file = nil)
+    file ||= UI.openpanel 'Load Script', @last_dir, '*.rb*'
+    return unless file
+
+    begin
+      load file
+      Sketchup.set_status_text "#{File.basename(file)} loaded (#{Time.now.strftime('%H:%M:%S')})"
+      @last_file = file
+      @last_dir = "#{File.dirname(file)}/"
+      @last_dir = @last_dir.gsub('/', '\\\\\\\\')
+      @cmd_reload.status_bar_text = @cmd_reload.tooltip = "Reload Script: #{File.basename(file)}"
+    rescue StandardError
+      UI.messagebox("Couldn't load #{File.basename(file)}: #{$ERROR_INFO}")
+    end
+  end
+
+  # Loading the toolbar once
+  unless file_loaded?('RubyToolbar.rb')
+    load_toolbar
+    file_loaded('RubyToolbar.rb')
+  end
+end
@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+# The purpose of this file is customizing environment of the developer on SketchUp.
+# Each developer can customize it's own loader(this file), by this way developer can load their helper tools
+# and helper methods ONLY in dev mode.
+
+# Change the base folder and copy this file to Sketchup Plugins directory
+# If you need to test in several versions of SketchUp, create symlinks to this file
+# ( AppData\Roaming\SketchUp\SketchUp <version>\SketchUp\Plugins )
+# Create a link to Plugins folder with this command
+
+# rubocop:disable Layout/LineLength
+# New-Item -ItemType SymbolicLink -Path '~\AppData\Roaming\SketchUp\SketchUp 2022\SketchUp\Plugins\speckle_connector_loader.rb' -Target ~\Git\Speckle\speckle-sketchup\_tools\speckle_connector_loader.rb
+# rubocop:enable Layout/LineLength
+
+SKETCHUP_CONSOLE.show # if you want to show Ruby console on startup
+# base location of your repos - will be merged with specific repos in next step
+home_folder = File.expand_path('~')
+# If you use some other location for your repository, you can change it here
+# but make sure it is not committed as it will change thi setting for all
+# users that use the default setup. Eg:
+
+# Add Speckle folder - uncomment the one you need
+speckle_path = File.join(home_folder, 'Git', 'Speckle', 'speckle-sketchup')
+
+$LOAD_PATH << speckle_path
+$LOAD_PATH << File.join(speckle_path, '_tools')
+
+# Defining this path will help to tool to browse related source file directly when
+# developer attempted to reload/load file.
+# rubocop:disable Style/GlobalVars
+$JF_RUBYTOOLBAR = speckle_path
+# rubocop:enable Style/GlobalVars
+
+files = %w[speckle_connector jf_RubyPanel su_attributes]
+
+files.each do |ruby_file|
+  puts "Loading #{ruby_file}"
+  begin
+    require ruby_file
+  rescue LoadError
+    puts "Could not load #{ruby_file}"
+  end
+end
@@ -0,0 +1,49 @@
+# Copyright 2014-2021, Trimble Inc.
+#
+# License: The MIT License (MIT)
+#
+# A SketchUp Ruby Extension that surfaces attributes attached to components.
+# More info at https://github.com/SketchUp/sketchup-attribute-helper
+
+
+require 'sketchup.rb'
+require 'extensions.rb'
+
+#-------------------------------------------------------------------------------
+
+module Trimble
+  module AttributeHelper
+
+  ### CONSTANTS ### ------------------------------------------------------------
+
+  # Plugin information
+  PLUGIN_ID       = 'AttributeHelper'.freeze
+  PLUGIN_NAME     = 'SketchUp Attribute Helper'.freeze
+  PLUGIN_VERSION  = '1.0.3'.freeze
+
+  # Resource paths
+  FILENAMESPACE = File.basename(__FILE__, '.*')
+  PATH_ROOT     = File.dirname(__FILE__).freeze
+  PATH          = File.join(PATH_ROOT, FILENAMESPACE).freeze
+
+
+  ### EXTENSION ### ------------------------------------------------------------
+
+  unless file_loaded?(__FILE__)
+    loader = File.join( PATH, 'core.rb' )
+    ex = SketchupExtension.new(PLUGIN_NAME, loader)
+    ex.description = 'Visually inspect nested attributes in SketchUp.'
+    ex.version     = PLUGIN_VERSION
+    ex.copyright   = 'Trimble Inc © 2015-2021'
+    ex.creator     = 'SketchUp'
+    Sketchup.register_extension(ex, true)
+  end
+
+  end # module AttributeHelper
+end # module Trimble
+
+#-------------------------------------------------------------------------------
+
+file_loaded(__FILE__)
+
+#-------------------------------------------------------------------------------
@@ -0,0 +1,285 @@
+# Copyright 2014-2021, Trimble Inc.
+#
+# License: The MIT License (MIT)
+
+require "sketchup.rb"
+require "stringio"
+
+module Trimble
+  module AttributeHelper
+
+  PLUGIN = self
+
+  class << self
+    attr_reader :app_observer
+    attr_reader :model_observer
+    attr_reader :selection_observer
+  end
+
+
+  def self.visualize_selected
+    content = self.traverse_selected
+    html = self.wrap_content(content)
+
+    options = {
+      :dialog_title => "Attribute Visualizer",
+      :preferences_key => 'AttributeVisualizer',
+      :scrollable => true,
+      :resizable => true,
+      :height => 300,
+      :width => 400,
+      :left => 200,
+      :top => 200
+    }
+    @window ||= UI::WebDialog.new(options)
+    @window.set_html(html)
+    @window.set_on_close {
+      @window = nil
+      self.detach_observers
+    }
+    unless @window.visible?
+      @window.show
+      self.attach_observers
+    end
+  end
+
+
+  def self.attach_observers
+    @app_observer ||= AppObserver.new
+    @model_observer ||= ModelObserver.new
+    @selection_observer ||= SelectionObserver.new
+    model = Sketchup.active_model
+    Sketchup.remove_observer(@app_observer)
+    model.remove_observer(@model_observer)
+    model.selection.remove_observer(@selection_observer)
+    Sketchup.add_observer(@app_observer)
+    model.add_observer(@model_observer)
+    model.selection.add_observer(@selection_observer)
+  end
+
+
+  def self.detach_observers
+    Sketchup.remove_observer(@app_observer)
+    Sketchup.active_model.remove_observer(@model_observer)
+    Sketchup.active_model.selection.remove_observer(@selection_observer)
+  end
+
+
+  def self.traverse_selected
+    html = StringIO.new
+
+    model = Sketchup.active_model
+    selection = model.selection
+
+    if selection.empty?
+      if model.active_path.nil?
+        entity = model
+      else
+        entity = model.active_path.last
+      end
+    else
+      return "Invalid selection size" unless selection.size == 1
+      entity = selection[0]
+    end
+
+    html.puts "<h1>#{self.escape_html(entity)}</h1>"
+    if entity.respond_to?(:name)
+      html.puts "<h2>#{self.escape_html(entity.name)}</h2>"
+    end
+    if entity.attribute_dictionaries
+      entity.attribute_dictionaries.each { |dictionary|
+        html.puts self.format_dictionary(dictionary)
+      }
+    else
+      html.puts "No dictionaries"
+    end
+
+    if entity.is_a?(Sketchup::Group)
+      definition = entity.entities.parent
+    elsif entity.is_a?(Sketchup::ComponentInstance)
+      definition = entity.definition
+    else
+      definition = nil
+    end
+
+    if definition && definition.attribute_dictionaries
+      html.puts "<h1>#{self.escape_html(definition)}</h1>"
+      html.puts "<h2>#{self.escape_html(definition.name)}</h2>"
+      definition.attribute_dictionaries.each { |dictionary|
+        html.puts self.format_dictionary(dictionary)
+      }
+    end
+
+    html.string
+  end
+
+
+  def self.format_dictionary(dictionary, path = "")
+    html_name = self.escape_html(dictionary.name)
+    path = "#{path}:#{html_name}"
+    html = StringIO.new
+    html.puts "<table>"
+    html.puts "<caption title='#{path}'>#{html_name}</caption>"
+    html.puts "<tbody>"
+    dictionary.each { |key, value|
+      html_key = self.escape_html(key)
+      html_value = self.escape_html(value)
+      node_path = "#{path}:#{html_key}"
+      html.puts "<tr title='#{node_path}'><td>#{html_key}</td><td>#{html_value}</td><td class='value_type'>#{value.class}</td></tr>"
+    }
+    if dictionary.attribute_dictionaries
+      dictionary.attribute_dictionaries.each { |sub_dic|
+        html.puts "<tr><td colspan='3' class='dictionary'>"
+        html.puts self.format_dictionary(sub_dic, path)
+        html.puts "</td></tr>"
+      }
+    end
+    html.puts "</tbody>"
+    html.puts "</table>"
+    html.string
+  end
+
+
+  def self.escape_html(data)
+    data.to_s.gsub("&", "&amp;").gsub("<", "&lt;").gsub(">", "&gt;")
+  end
+
+
+  def self.wrap_content(content)
+    html = <<-EOT
+<!DOCTYPE html>
+<html>
+<head>
+<meta http-equiv="X-UA-Compatible" content="IE=edge"/>
+<meta charset="UTF-8">
+<style>
+  html {
+    font-family: "Calibri", sans-serif;
+    font-size: 10pt;
+  }
+  h1 {
+    font-size: 1.5em;
+  }
+  h2 {
+    font-size: 1.2em;
+  }
+  table {
+    width: 100%;
+    /*padding: 0.5em;*/
+    border: 1px solid #666;
+  }
+  caption {
+    font-weight: bold;
+    text-align: left;
+    /*border-bottom: 1px solid silver;*/
+    padding: 0.2em;
+  }
+  td {
+    background: #f3f3f3;
+    padding: 0.2em;
+  }
+  td.dictionary {
+    background: none;
+    padding-left: 1em;
+  }
+  tr:hover td {
+    background: rgba(255,210,180,0.2);
+  }
+  .value_type {
+    text-align: right;
+    width: 5%;
+  }
+</style>
+<head>
+<body>
+#{content}
+</body>
+</html>
+    EOT
+  end
+
+
+  class SelectionObserver < Sketchup::SelectionObserver
+    def onSelectionAdded(selection, element)
+      selection_changed()
+    end
+    def onSelectionBulkChange(selection)
+      selection_changed()
+    end
+    def onSelectionCleared(selection)
+      selection_changed()
+    end
+    def onSelectionRemoved(selection, element)
+      selection_changed()
+    end
+
+    private
+
+    def selection_changed
+      PLUGIN.visualize_selected
+    end
+  end # class SelectionObserver
+
+
+  class ModelObserver < Sketchup::ModelObserver
+    def onActivePathChanged(model)
+      PLUGIN.visualize_selected
+    end
+
+    def onTransactionCommit(model)
+      model_changed(model)
+    end
+    def onTransactionEmpty(model)
+      model_changed(model)
+    end
+    def onTransactionRedo(model)
+      model_changed(model)
+    end
+    def onTransactionUndo(model)
+      model_changed(model)
+    end
+
+    private
+
+    def model_changed(model)
+      if @timer.nil?
+        @timer = UI.start_timer(0.0, false) {
+          @timer = nil
+          PLUGIN.visualize_selected
+        }
+      end
+    end
+  end # class ModelObserver
+
+
+  class AppObserver < Sketchup::AppObserver
+    def onNewModel(model)
+      observe_model(model)
+    end
+    def onOpenModel(model)
+      observe_model(model)
+    end
+
+    private
+
+    def observe_model(model)
+      model.add_observer(PLUGIN.model_observer)
+      model.selection.add_observer(PLUGIN.selection_observer)
+      PLUGIN.visualize_selected
+    end
+  end # class AppObserver
+
+
+  unless file_loaded?(__FILE__)
+    command = UI::Command.new("Attribute Helper") { self.visualize_selected }
+    command.status_bar_text = "Inspect and edit the attributes of a selection."
+
+    menu_name = Sketchup.version.to_f < 21.1 ? 'Plugins' : 'Developer'
+    menu = UI.menu(menu_name)
+    menu.add_item(command)
+    file_loaded(__FILE__)
+  end
+
+
+  end # module AttributeHelper
+end # module Sketchup
@@ -0,0 +1,2 @@
+ID=f4d9d053-4479-4a9a-90da-b79fa16e28c4
+VERSION_ID=b787af5e-8e8e-4932-92ef-a3c99681795d
@@ -1,15 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-require "bundler/setup"
-require "speckle_connector"
-
-# You can add fixtures and/or initialization code here to make experimenting
-# with your gem easier. You can also use a different console, if you like.
-
-# (If you use this, don't forget to add pry to your Gemfile!)
-# require "pry"
-# Pry.start
-
-require "irb"
-IRB.start(__FILE__)
@@ -1,8 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-IFS=$'\n\t'
-set -vx
-
-bundle install
-
-# Do any other automated setup that you need to do here
@@ -1,8 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "speckle_connector/version"
-
-module SpeckleConnector
-  class Error < StandardError; end
-  # Your code goes here...
-end
@@ -25,7 +25,8 @@ def patch_installer(tag):

    with open(iss_file, "r") as file:
        lines = file.readlines()
-        lines.insert(11, f'#define AppVersion "{tag}"\n')
+        lines.insert(11, f'#define AppVersion "{tag.split("-")[0]}"\n')
+        lines.insert(12, f'#define AppInfoVersion "{tag}"\n')

        with open(iss_file, "w") as file:
            file.writelines(lines)
@@ -39,7 +40,7 @@ def main():
        return

    tag = sys.argv[1]
-    if not re.match(r"[0-9]+(\.[0-9]+)*$", tag):
+    if not re.match(r"([0-9]+)\.([0-9]+)\.([0-9]+)", tag):
        raise ValueError(f"Invalid tag provided: {tag}")

    print(f"Patching version: {tag}")
@@ -1,59 +0,0 @@
-require "net/http"
-
-require "json"
-
-require "uri"
-
-server = "https://latest.speckle.dev"
-
-token = "1dc2e3330a56371dc9011e5bed406264c9e65dd355"
-
-limit = 20
-streams_list = "
-query User {
-  user {
-    id
-    email
-    name
-    bio
-    company
-    avatar
-    verified
-    profiles
-    role
-    streams(limit: #{limit}) {
-      totalCount
-      cursor
-      items {
-        id
-        name
-        description
-        isPublic
-        createdAt
-        updatedAt
-        collaborators {
-          id
-          name
-          role
-        }
-      }
-    }
-  }
-}
-"
-
-endpoint = URI("#{server}/graphql")
-
-res =
-  ::Net::HTTP.start(endpoint.host, endpoint.port, use_ssl: true) do |http|
-    req = ::Net::HTTP::Post.new(endpoint)
-    req["Content-Type"] = "application/json"
-    req["Authorization"] = "Bearer #{token}"
-    # The body needs to be a JSON string.
-    req.body = ::JSON[{ query: streams_list }]
-    puts(req.body)
-    http.request(req)
-  end
-
-streams = ::JSON.parse(res.body)["data"]["user"]["streams"]["items"]
-puts(streams)
@@ -1,43 +1,39 @@
-require "sketchup"
+# frozen_string_literal: true

-require "extensions"
+require 'sketchup'
+require 'extensions'

-module SpeckleSystems
-  module SpeckleConnector
-    # Version - patched by CI
-    CONNECTOR_VERSION = "0.0.0"
+# Speckle connector module to enable multiplayer mode ON!
+module SpeckleConnector
+  # Version - patched by CI
+  CONNECTOR_VERSION = '0.0.0'

-    file = __FILE__.dup
-    # Account for Ruby encoding bug under Windows.
-    file.force_encoding("UTF-8") if file.respond_to?(:force_encoding)
-    # Support folder should be named the same as the root .rb file.
-    folder_name = File.basename(file, ".*")
+  file = __FILE__.dup

-    # Path to the root .rb file (this file).
-    PATH_ROOT = File.dirname(file).freeze
+  # Account for Ruby encoding bug under Windows.
+  file.force_encoding('UTF-8') if file.respond_to?(:force_encoding)

-    # Path to the support folder.
-    PATH = File.join(PATH_ROOT, folder_name).freeze
+  # Support folder should be named the same as the root .rb file.
+  folder_name = File.basename(file, '.*')

-    # Run from localhost or from build files
-    DEV_MODE = false
+  # Path to the root .rb file (this file).
+  PATH_ROOT = File.dirname(file).freeze

-    unless file_loaded?(__FILE__)
+  # Path to the support folder.
+  PATH = File.join(PATH_ROOT, folder_name).freeze

-      ex = SketchupExtension.new("Speckle SketchUp", File.join(PATH, "main"))
+  # Run from localhost or from build files
+  DEV_MODE = false
+  puts("Loading Speckle (Legacy) Connector v#{CONNECTOR_VERSION} from #{DEV_MODE ? 'dev' : 'build'}")

-      ex.description = "Speckle Connector for SketchUp"
+  unless file_loaded?(__FILE__)
+    ex = SketchupExtension.new('Speckle SketchUp', File.join(PATH, 'bootstrap'))
+    ex.description = 'Speckle Connector for SketchUp'
+    ex.version     = CONNECTOR_VERSION
+    ex.copyright   = 'AEC Systems Ltd.'
+    ex.creator     = 'Speckle Systems'
+    Sketchup.register_extension(ex, true)

-      ex.version     = CONNECTOR_VERSION
-
-      ex.copyright   = "AEC Systems Ltd."
-
-      ex.creator     = "Speckle Systems"
-
-      Sketchup.register_extension(ex, true)
-
-      file_loaded(__FILE__)
-
-    end
+    file_loaded(__FILE__)
  end
 end
@@ -1,54 +0,0 @@
-require "JSON"
-
-begin
-  require("sqlite3")
-rescue LoadError
-  # ty msp-greg! https://github.com/MSP-Greg/SUMisc/releases/tag/sqlite3-mingw-1
-  Gem.install(File.join(File.dirname(File.expand_path(__FILE__)), "utils/sqlite3-1.4.2.mspgreg-x64-mingw32.gem"))
-else
-  require("sqlite3")
-end
-
-module SpeckleSystems::SpeckleConnector
-  module Accounts
-    def self.load_accounts
-      dir = _get_speckle_dir
-      db_path = File.join(dir, "Accounts.db")
-      unless File.exist?(db_path)
-        raise(IOError, "No Accounts db found. Please read the guide for different options for adding your account: \nhttps://speckle.guide/user/manager.html#adding-accounts")
-      end
-
-      db = SQLite3::Database.new(db_path)
-      rows = db.execute("SELECT * FROM objects")
-      db.close
-      rows.map { |row| JSON.parse(row[1]) }
-    end
-
-    def self.get_suuid
-      dir = _get_speckle_dir
-      suuid_path = File.join(dir, "suuid")
-      return unless File.exist?(suuid_path)
-
-      File.read(suuid_path)
-    end
-
-    def self._get_speckle_dir
-      platform = RUBY_PLATFORM.downcase
-
-      speckle_dir =
-        if platform =~ (/mingw/) || platform =~ (/win/)
-          # win
-          File.join(Dir.home, "AppData/Roaming/Speckle")
-        elsif platform =~ /linux/
-          # linux
-          File.expand_path("~/.local/share/Speckle")
-        else
-          # mac
-          File.expand_path("~/.config/Speckle")
-        end
-      return speckle_dir if Dir.exist?(speckle_dir)
-
-      raise(IOError, "No Speckle Directory exists. Please read the guide to get Speckle set up on your machine: \nhttps://speckle.guide/user/manager.html")
-    end
-  end
-end
@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+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'
+require_relative 'src/app/speckle_connector_app'
+require_relative 'src/states/user_state'
+require_relative 'src/states/initial_state'
+require_relative 'src/commands/speckle_menu_commands'
+
+# Speckle Connector on SketchUp to enable Multiplayer mode ON!
+module SpeckleConnector
+  SKETCHUP_VERSION = Sketchup.version.to_i
+
+  dir = __dir__.dup
+  dir.force_encoding('UTF-8') if dir.respond_to?(:force_encoding)
+  SPECKLE_CONNECTOR_SRC_PATH = Pathname.new(File.expand_path(dir)).cleanpath.to_s
+
+  def self.initialize_app
+    sketchup_ui = Ui::SketchupUi.new
+    ui_controller = Ui::UiController.new(sketchup_ui)
+    menu_commands = Commands::MenuCommandHandler.new
+    user_state = SpeckleConnector::States::UserState.new({})
+    initial_state = SpeckleConnector::States::InitialState.new(user_state)
+    app = SpeckleConnector::App::SpeckleConnectorApp.new(menu_commands, initial_state, ui_controller)
+    # Add menu commands to SketchUp and Speckle application
+    Commands::SpeckleMenuCommands.add_initial_commands!(app)
+    app
+  end
+
+  app = initialize_app
+  SPECKLE_APP = app
+end
@@ -1,30 +0,0 @@
-require "sketchup"
-require "speckle_connector/converter/to_speckle"
-require "speckle_connector/converter/to_native"
-
-module SpeckleSystems::SpeckleConnector
-  SKETCHUP_UNIT_STRINGS = { "m" => "m", "mm" => "mm", "ft" => "feet", "in" => "inch", "yd" => "yard" }.freeze
-  public_constant :SKETCHUP_UNIT_STRINGS
-  class ConverterSketchup
-    include ToNative
-    include ToSpeckle
-
-    attr_accessor :units, :component_defs
-
-    def initialize(units = "m")
-      @units = units
-      @component_defs = {}
-    end
-
-    def convert_to_speckle(obj)
-      case obj.typename
-      when "Edge" then edge_to_speckle(obj)
-      when "Face" then face_to_speckle(obj)
-      when "Group" then component_instance_to_speckle(obj, is_group: true)
-      when "ComponentDefinition" then component_definition_to_speckle(obj)
-      when "ComponentInstance" then component_instance_to_speckle(obj)
-      else nil
-      end
-    end
-  end
-end
@@ -1,150 +0,0 @@
-require "sketchup"
-
-# To Native conversions for the ConverterSketchup
-module SpeckleSystems::SpeckleConnector::ToNative
-  def traverse_commit_object(obj)
-    if can_convert_to_native(obj)
-      convert_to_native(obj, Sketchup.active_model.entities)
-    elsif obj.is_a?(Hash) && obj.key?("speckle_type")
-      props = obj.keys.filter_map { |key| key if key.start_with?("@") }
-      %w[displayMesh displayValue data].each { |prop| props.push(prop) if obj.key?(prop) }
-      props.each { |prop| traverse_commit_object(obj[prop]) }
-    elsif obj.is_a?(Hash)
-      obj.each_value { |value| traverse_commit_object(value) }
-    elsif obj.is_a?(Array)
-      obj.each { |value| traverse_commit_object(value) }
-    else
-      nil
-    end
-  end
-
-  def can_convert_to_native(obj)
-    return false unless obj.is_a?(Hash) && obj.key?("speckle_type")
-
-    [
-      "Objects.Geometry.Line",
-      "Objects.Geometry.Polyline",
-      "Objects.Geometry.Mesh",
-      "Objects.Other.BlockInstance",
-      "Objects.Other.BlockDefinition",
-      "Objects.Other.RenderMaterial"
-    ].include?(obj["speckle_type"])
-  end
-
-  def convert_to_native(obj, entities = SketchUp.active_model.entities)
-    case obj["speckle_type"]
-    when "Objects.Geometry.Line", "Objects.Geometry.Polyline" then edge_to_native(obj, entities)
-    when "Objects.Other.BlockInstance" then component_instance_to_native(obj, entities)
-    when "Objects.Other.BlockDefinition" then component_definition_to_native(obj)
-    when "Objects.Geometry.Mesh" then mesh_to_native(obj, entities)
-    else
-      nil
-    end
-  # rescue StandardError => e
-  #   puts("Failed to convert #{obj["speckle_type"]} (id: #{obj["id"]})")
-  #   puts(e)
-  #   nil
-  end
-
-  def length_to_native(length, units = @units)
-    length.__send__(SpeckleSystems::SpeckleConnector::SKETCHUP_UNIT_STRINGS[units])
-  end
-
-  def edge_to_native(line, entities)
-    return unless line.key?("value")
-
-    values = line["value"]
-    points = values.each_slice(3).to_a.map { |pt| point_to_native(pt[0], pt[1], pt[2], line["units"]) }
-    entities.add_edges(*points)
-  end
-
-  def face_to_native
-    nil
-  end
-
-  def point_to_native(x, y, z, units)
-    Geom::Point3d.new(length_to_native(x, units), length_to_native(y, units), length_to_native(z, units))
-  end
-
-  def component_definition_to_native(block_def)
-    definition = Sketchup.active_model.definitions[block_def["name"]]
-    return definition if definition&.guid == block_def["applicationId"]
-
-    definition&.entities&.clear!
-    definition ||= Sketchup.active_model.definitions.add(block_def["name"])
-    block_def["geometry"].each { |obj| convert_to_native(obj, definition.entities) }
-    definition
-  end
-
-  def mesh_to_native(mesh, entities)
-    native_mesh = Geom::PolygonMesh.new
-    points = [] # to preserve indices - duplicate points won't be added in `point_to_native`
-    mesh["vertices"].each_slice(3) do |pt|
-      points.push(point_to_native(pt[0], pt[1], pt[2], mesh["units"]))
-    end
-    faces = mesh["faces"]
-    while faces.count.positive?
-      size = faces.shift
-      num_pts =
-        case size
-        when 0 then 3
-        when 1 then 4
-        else size
-        end
-      indices = faces.shift(num_pts)
-      native_mesh.add_polygon(indices.map { |index| points[index] })
-    end
-    entities.add_faces_from_mesh(native_mesh, 4, material_to_native(mesh["renderMaterial"]))
-
-    native_mesh
-  end
-
-  def component_instance_to_native(block, entities)
-    is_group = block.key?("is_sketchup_group") && block["is_sketchup_group"]
-
-    definition = component_definition_to_native(block["blockDefinition"])
-    # return unless definition.entities.count.positive?
-
-    transform = transform_to_native(block["transform"], block["units"])
-    instance =
-      if is_group
-        entities.add_group(definition.entities.to_a)
-      else
-        entities.add_instance(definition, transform)
-      end
-    puts("Failed to create instance for speckle object #{block["id"]}") if instance.nil?
-    instance.transformation = transform if is_group
-    instance.material = material_to_native(block["renderMaterial"])
-    instance
-  end
-
-  def transform_to_native(t_arr, units = @units)
-    Geom::Transformation.new(
-      [
-      t_arr[0], t_arr[4], t_arr[8],  t_arr[12],
-      t_arr[1], t_arr[5], t_arr[9],  t_arr[13],
-      t_arr[2], t_arr[6], t_arr[10], t_arr[14],
-      length_to_native(t_arr[3], units),
-      length_to_native(t_arr[7], units),
-      length_to_native(t_arr[11], units),
-      t_arr[15]
-      ]
-    )
-  end
-
-  def material_to_native(render_mat)
-    return if render_mat.nil?
-
-    # return material with same name if it exists
-    name = render_mat["name"] || render_mat["id"]
-    material = Sketchup.active_model.materials[name]
-    return material if material
-
-    # create a new sketchup material
-    material = Sketchup.active_model.materials.add(name)
-    material.alpha = render_mat["opacity"]
-    argb = render_mat["diffuse"]
-    material.color = Sketchup::Color.new((argb >> 16) & 255, (argb >> 8) & 255, argb & 255, (argb >> 24) & 255)
-    material
-  end
-end
@@ -1,228 +0,0 @@
-require "sketchup"
-
-# To Speckle conversions for the ConverterSketchup
-module SpeckleSystems::SpeckleConnector::ToSpeckle
-  def length_to_speckle(length)
-    length.__send__("to_#{SpeckleSystems::SpeckleConnector::SKETCHUP_UNIT_STRINGS[@units]}")
-  end
-
-  def edge_to_speckle(edge)
-    {
-      speckle_type: "Objects.Geometry.Line",
-      applicationId: edge.persistent_id.to_s,
-      units: @units,
-      start: vertex_to_speckle(edge.start),
-      end: vertex_to_speckle(edge.end),
-      domain: speckle_interval(0, Float(edge.length)),
-      bbox: bounds_to_speckle(edge.bounds)
-    }
-  end
-
-  def component_definition_to_speckle(definition)
-    guid = definition.guid
-    return @component_defs[guid] if @component_defs.key?(guid)
-
-    speckle_def = {
-      speckle_type: "Objects.Other.BlockDefinition",
-      applicationId: guid,
-      units: @units,
-      name: definition.name,
-      # i think the base point is always the origin?
-      basePoint: speckle_point,
-      "@geometry" => if %w[Edge Face].include?(definition.entities[0].typename)
-                       group_mesh_to_speckle(definition)
-                     else
-                       definition.entities.map { |entity| convert_to_speckle(entity) }
-                     end
-    }
-    @component_defs[guid] = speckle_def
-  end
-
-  def component_instance_to_speckle(instance, is_group: false)
-    transform = instance.transformation
-    origin = transform.origin
-    {
-      speckle_type: "Objects.Other.BlockInstance",
-      applicationId: instance.guid,
-      is_sketchup_group: is_group,
-      units: @units,
-      bbox: bounds_to_speckle(instance.bounds),
-      name: instance.name,
-      renderMaterial: instance.material.nil? ? nil : material_to_speckle(instance.material),
-      transform: transform_to_speckle(transform),
-      insertionPoint: speckle_point(origin[0], origin[1], origin[2]),
-      "@blockDefinition" => component_definition_to_speckle(instance.definition)
-    }
-  end
-
-  def group_mesh_to_speckle(component_def)
-    mat_groups = {}
-
-    component_def.entities.each do |face|
-      next unless face.typename == "Face"
-
-      # convert material
-      mat_id = face.material.nil? ? "none" : face.material.entityID
-      mat_groups[mat_id] = initialise_group_mesh(face, component_def.bounds) unless mat_groups.key?(mat_id)
-
-      # add points and texture coordinates
-      mesh = face.mesh(1)
-      mat_groups[mat_id]["@(31250)vertices"].push(*points_to_array(mesh))
-      mat_groups[mat_id]["@(31250)textureCoordinates"].push(*uvs_to_array(mesh))
-
-      # add faces
-      mat_groups[mat_id]["@(62500)faces"].push(*faces_to_array(mesh, mat_groups[mat_id][:pt_count]))
-      mat_groups[mat_id][:pt_count] += mesh.points.count
-    end
-
-    mat_groups.values.map { |group| group.delete(:pt_count) }
-    mat_groups.values
-  end
-
-  def transform_to_speckle(transform)
-    t_arr = transform.to_a
-    [
-      t_arr[0], t_arr[4], t_arr[8],  length_to_speckle(t_arr[12]),
-      t_arr[1], t_arr[5], t_arr[9],  length_to_speckle(t_arr[13]),
-      t_arr[2], t_arr[6], t_arr[10], length_to_speckle(t_arr[14]),
-      t_arr[3], t_arr[7], t_arr[11], t_arr[15]
-    ]
-  end
-
-  def initialise_group_mesh(face, bounds)
-    {
-      speckle_type: "Objects.Geometry.Mesh",
-      units: @units,
-      bbox: bounds_to_speckle(bounds),
-      "@(31250)vertices" => [],
-      "@(62500)faces" => [],
-      "@(31250)textureCoordinates" => [],
-      pt_count: -1, # faces are 1 indexed
-      renderMaterial: face.material.nil? ? nil : material_to_speckle(face.material)
-    }
-  end
-
-  def faces_to_array(mesh, offset)
-    faces = []
-    mesh.polygons.each do |poly|
-      faces.push(
-        case poly.count
-        when 3 then 0   # tris
-        when 4 then 1   # polys
-        else
-          poly.count # ngons
-        end,
-        *poly.map { |coord| coord.abs + offset }
-      )
-    end
-    faces
-  end
-
-  def points_to_array(mesh)
-    pts_array = []
-    mesh.points.each do |pt|
-      pts_array.push(
-        length_to_speckle(pt[0]),
-        length_to_speckle(pt[1]),
-        length_to_speckle(pt[2])
-      )
-    end
-    pts_array
-  end
-
-  def uvs_to_array(mesh)
-    uvs_array = []
-    mesh.uvs(true).each do |pt|
-      uvs_array.push(
-        length_to_speckle(pt[0] / pt[2]),
-        length_to_speckle(pt[1] / pt[2])
-      )
-    end
-    uvs_array
-  end
-
-  def face_to_speckle(face)
-    mesh = face.mesh(1)
-    {
-      speckle_type: "Objects.Geometry.Mesh",
-      units: @units,
-      renderMaterial: face.material.nil? ? nil : material_to_speckle(face.material),
-      bbox: bounds_to_speckle(face.bounds),
-      "@(31250)vertices" => points_to_array(mesh),
-      "@(62500)faces" => faces_to_array(mesh, -1),
-      "@(31250)textureCoordinates" => uvs_to_array(mesh)
-    }
-  end
-
-  def vertex_to_speckle(vertex)
-    point = vertex.position
-    {
-      speckle_type: "Objects.Geometry.Point",
-      units: @units,
-      x: length_to_speckle(point[0]),
-      y: length_to_speckle(point[1]),
-      z: length_to_speckle(point[2])
-    }
-  end
-
-  def material_to_speckle(material)
-    rgba = material.color.to_a
-    {
-      speckle_type: "Objects.Other.RenderMaterial",
-      name: material.name,
-      diffuse: [rgba[3] << 24 | rgba[0] << 16 | rgba[1] << 8 | rgba[2]].pack("l").unpack1("l"),
-      opacity: material.alpha,
-      emissive: -16_777_216,
-      metalness: 0,
-      roughness: 1
-    }
-  end
-
-  def bounds_to_speckle(bounds)
-    min_pt = bounds.min
-    {
-      speckle_type: "Objects.Geometry.Box",
-      units: @units,
-      area: 0,
-      volume: 0,
-      xSize: speckle_interval(min_pt[0], bounds.width),
-      ySize: speckle_interval(min_pt[1], bounds.height),
-      zSize: speckle_interval(min_pt[2], bounds.depth),
-      basePlane: speckle_plane
-    }
-  end
-
-  def speckle_interval(start_val, end_val)
-    {
-      speckle_type: "Objects.Primitive.Interval",
-      units: @units,
-      start: start_val.is_a?(Length) ? length_to_speckle(start_val) : start_val,
-      end: end_val.is_a?(Length) ? length_to_speckle(end_val) : end_val
-    }
-  end
-
-  def speckle_point(x = 0.0, y = 0.0, z = 0.0, vector: false)
-    {
-      speckle_type: vector ? "Objects.Geometry.Vector" : "Objects.Geometry.Point",
-      units: @units,
-      x: x.is_a?(Length) ? length_to_speckle(x) : x,
-      y: y.is_a?(Length) ? length_to_speckle(y) : y,
-      z: z.is_a?(Length) ? length_to_speckle(z) : z
-    }
-  end
-
-  def speckle_vector(x = 0.0, y = 0.0, z = 0.0)
-    speckle_point(x, y, z, vector: true)
-  end
-
-  def speckle_plane(xdir: [1, 0, 0], ydir: [0, 1, 0], normal: [0, 0, 1], origin: [0, 0, 0])
-    {
-      speckle_type: "Objects.Geometry.Plane",
-      units: @units,
-      xdir: speckle_vector(*xdir),
-      ydir: speckle_vector(*ydir),
-      normal: speckle_vector(*normal),
-      origin: speckle_point(*origin)
-    }
-  end
-end
@@ -1,17 +1,24 @@
-module SpeckleSystems::SpeckleConnector
+# frozen_string_literal: true
+
+# Speckle connector module to enable multiplayer mode ON!
+module SpeckleConnector
  # from thomthom
  # https://github.com/thomthom/true-bend/blob/master/src/tt_truebend/debug.rb

  # @note Debug method to reload the plugin.
  #
  # @example
-  #   SpeckleSystems::SpeckleConnector.reload
+  #   SpeckleConnector.reload
  #
  # @return [Integer] Number of files reloaded.
+  # rubocop:disable SketchupSuggestions/FileEncoding
  def self.reload
    load(__FILE__)
-    pattern = File.join(__dir__, "**/*.rb")
-    Dir.glob(pattern).each { |file| load(file) }
+    pattern = File.join(__dir__, '**/*.rb')
+    # TODO: Here is a opportunity to improve reloading process.
+    #  We can cache last edited time of the each file later to check which file need to be reloaded.
+    Dir.glob(pattern).each { |file| load(file) unless file.include?('bootstrap') }
       .size
  end
+  # rubocop:enable SketchupSuggestions/FileEncoding
 end
@@ -1,90 +0,0 @@
-require "JSON"
-require "json"
-require "sketchup"
-require "speckle_connector/converter/converter_sketchup"
-require "speckle_connector/accounts"
-
-module SpeckleSystems::SpeckleConnector
-  UNITS = { 0 => "in", 1 => "ft", 2 => "mm", 3 => "cm", 4 => "m", 5 => "yd" }.freeze
-  public_constant :UNITS
-
-  def self.create_dialog
-    options = {
-      dialog_title: "SpeckleSketchUp",
-      preferences_key: "example.htmldialog.materialinspector",
-      style: UI::HtmlDialog::STYLE_DIALOG,
-      min_width: 250,
-      min_height: 50
-    }
-    dialog = UI::HtmlDialog.new(options)
-    dialog.center
-    dialog
-  end
-
-  def self.show_dialog
-    if @dialog&.visible?
-      @dialog.bring_to_front
-    else
-      @dialog ||= create_dialog
-      @dialog.add_action_callback("send_selection") do |_action_context, stream_id|
-        send_selection(stream_id)
-        nil
-      end
-      @dialog.add_action_callback("receive_objects") do |_action_context, base, stream_id|
-        receive_objects(base, stream_id)
-        nil
-      end
-      @dialog.add_action_callback("reload_accounts") do |_action_context|
-        reload_accounts
-      end
-
-      @dialog.add_action_callback("init_local_accounts") do |_action_context|
-        init_local_accounts
-
-      end
-      puts DEV_MODE
-      if DEV_MODE
-        @dialog.set_url("http://localhost:8081")
-      else
-        basedir = File.join(File.dirname(File.expand_path(__FILE__)), "html")
-        html = File.read(File.join(basedir, "index.html"))
-        @dialog.set_html(html)
-      end
-
-      @dialog.show
-
-      @dialog
-    end
-  end
-
-  def self.send_selection(stream_id)
-    model = Sketchup.active_model
-    converter = ConverterSketchup.new(UNITS[model.options["UnitsOptions"]["LengthUnit"]])
-    converted = model.selection.map { |entity| converter.convert_to_speckle(entity) }
-    puts("converted #{converted.count} objects for stream #{stream_id}")
-    # puts(converted.to_json)
-    @dialog.execute_script("convertedFromSketchup('#{stream_id}',#{converted.to_json})")
-  rescue StandardError => e
-    puts(e)
-    @dialog.execute_script("sketchupOperationFailed('#{stream_id}')")
-  end
-
-  def self.receive_objects(base, stream_id)
-    puts("received objects from stream #{stream_id}")
-    model = Sketchup.active_model
-    converter = ConverterSketchup.new(UNITS[model.options["UnitsOptions"]["LengthUnit"]])
-    converter.traverse_commit_object(base)
-    @dialog.execute_script("finishedReceiveInSketchup('#{stream_id}')")
-  rescue StandardError => e
-    puts(e)
-    @dialog.execute_script("sketchupOperationFailed('#{stream_id}')")
-  end
-
-  def self.init_local_accounts
-    @dialog.execute_script("loadAccounts(#{Accounts.load_accounts.to_json}, #{Accounts.get_suuid.to_json})")
-  end
-
-  def self.reload_accounts
-    @dialog.execute_script("loadAccounts(#{Accounts.load_accounts.to_json})")
-  end
-end
@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-require "sketchup"
-require "speckle_connector/dialog.rb"
-require "speckle_connector/debug.rb"
-
-module SpeckleSystems
-  module SpeckleConnector
-    unless file_loaded?(__FILE__)
-      cmd_cube = UI::Command.new("Dialog") { show_dialog }
-      cmd_cube.tooltip = "Launch Connector"
-      cmd_cube.status_bar_text = "Opens the Speckle Connector window"
-      cmd_cube.small_icon  = "icons/s2logo.png"
-      cmd_cube.large_icon  = "icons/s2logo.png"
-
-      menu = UI.menu("Tools")
-      menu.add_item(cmd_cube)
-
-      toolbar = UI::Toolbar.new("Speckle")
-      toolbar.add_item(cmd_cube)
-      toolbar.restore
-
-      file_loaded(__FILE__)
-
-    end
-  end
-end
@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require 'JSON'
+require_relative '../ext/sqlite3'
+require_relative '../constants/path_constants'
+
+module SpeckleConnector
+  # Accounts to communicate with models on user's account.
+  module Accounts
+    def self.load_accounts
+      db_path = SPECKLE_ACCOUNTS_DB_PATH
+      unless File.exist?(db_path)
+        raise(
+          IOError,
+          "No Accounts db found. Please read the guide for different options for adding your account:\n
+             https://speckle.guide/user/manager.html#adding-accounts"
+        )
+      end
+
+      db = Sqlite3::Database.new(db_path)
+      rows = db.exec('SELECT * FROM objects')
+      db.close
+      rows.map { |row| JSON.parse(row[1]) }
+    end
+
+    def self.default_account
+      accounts = load_accounts
+      accounts.select { |acc| acc['isDefault'] }[0] || accounts[0]
+    end
+  end
+end
@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module SpeckleConnector
+  module Actions
+    # State changer object.
+    class Action
+      # @param state [States::State] the current state of the {App::SpeckleConnectorApp}
+      # @param parameters [Array] parameters that the action takes
+      # @return [States::State] the new updated state object
+      def self.update_state(_state, *_parameters)
+        raise NotImplementedError, 'Implement in subclass.'
+      end
+    end
+  end
+end
@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative 'action'
+require_relative 'deactivate_diffing'
+
+module SpeckleConnector
+  module Actions
+    # Deactivate diffing for stream.
+    class ActivateDiffing < Action
+      def initialize(stream_id)
+        super()
+        @stream_id = stream_id
+      end
+
+      # @param state [States::State] the current state of the {App::SpeckleConnectorApp}
+      # @return [States::State] the new updated state object
+      def update_state(state)
+        state = DeactivateDiffing.update_state(state, {})
+        puts "Diffing activated for #{@stream_id}"
+        speckle_entities = state.speckle_state.speckle_entities
+        invalid_speckle_entities = speckle_entities.select do |_id, entity|
+          entity.invalid_stream_ids.include?(@stream_id) && entity.sketchup_entity.is_a?(Sketchup::Face)
+        end
+        invalid_speckle_entities.each do |id, entity|
+          new_entity = entity.activate_diffing(@stream_id, state.sketchup_state.materials.by_id(MAT_EDIT))
+          speckle_entities = speckle_entities.put(id, new_entity)
+        end
+        new_speckle_state = state.speckle_state.with_speckle_entities(speckle_entities)
+        state.with_speckle_state(new_speckle_state)
+      end
+    end
+  end
+end
@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require_relative 'action'
+
+module SpeckleConnector
+  module Actions
+    # Adds material to speckle state and Sketchup.
+    class AddMaterial < Action
+      def self.update_state(state, material_name:, color:, material_id:, alpha: nil)
+        materials = state.sketchup_state.materials
+        existing_material = materials.by_id(material_id)
+        return state if existing_material&.valid?
+
+        new_material = create_or_get_material(state.sketchup_state.sketchup_model,
+                                              material_name,
+                                              color,
+                                              material_id,
+                                              alpha: alpha)
+        new_materials = materials.add_material(material_id, new_material)
+        new_sketchup_state = state.sketchup_state.with(:@materials => new_materials)
+        state.with(:@sketchup_state => new_sketchup_state)
+      end
+
+      def self.create_or_get_material(model, material_name, color, material_id, alpha: nil)
+        materials = model.materials
+        existing_material = materials.find { |mat| mat.name == material_name }
+        return existing_material if existing_material&.valid?
+
+        existing_material = materials.add material_name
+        existing_material.set_attribute(MAT_DICTIONARY, MAT_ID, material_id.to_s)
+        set_hex_color(existing_material, color)
+        existing_material.alpha = alpha if alpha
+        existing_material
+      end
+
+      def self.set_hex_color(skp_material, hex_value)
+        hex_value = hex_value.to_s
+        col_blue, col_green, col_red = parse_hex_color(hex_value)
+        skp_material.color = col_red, col_green, col_blue
+      end
+
+      def self.parse_hex_color(hex_value)
+        split_values = hex_value.match(/^#([a-fA-F\d]{2})([a-fA-F\d]{2})([a-fA-F\d]{2})$/) ||
+                       hex_value.match(/^#([a-fA-F\d])([a-fA-F\d])([a-fA-F\d])$/)
+        col_red = split_values[1].hex
+        col_green = split_values[2].hex
+        col_blue = split_values[3].hex
+        return col_blue, col_green, col_red
+      end
+    end
+  end
+end
@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require_relative 'action'
+require_relative 'mapped_entities_updated'
+require_relative 'events/selection_event_action'
+require_relative '../sketchup_model/dictionary/speckle_schema_dictionary_handler'
+
+module SpeckleConnector
+  module Actions
+    # Apply mappings for selected entities.
+    class ApplyMappings < Action
+      def initialize(entities_to_map, method, category, family,
+                     family_type, level, name, is_definition)
+        super()
+        @entities_to_map = entities_to_map
+        @method = method
+        @category = category
+        @name = name
+        @family = family
+        @family_type = family_type
+        @level = level
+        @is_definition = is_definition
+      end
+
+      # @param state [States::State] the current state of the {App::SpeckleConnectorApp}
+      # @return [States::State] the new updated state object
+      # rubocop:disable Metrics/AbcSize
+      # rubocop:disable Metrics/CyclomaticComplexity
+      # rubocop:disable Metrics/PerceivedComplexity
+      # rubocop:disable Metrics/MethodLength
+      def update_state(state)
+        sketchup_model = state.sketchup_state.sketchup_model
+        entities = if sketchup_model.active_path.nil?
+                     sketchup_model.entities
+                   else
+                     sketchup_model.active_path.last.definition.entities
+                   end
+
+        # Collect entities from entity ids that comes from UI as list
+        entities_to_map = entities.select { |e| @entities_to_map.include?(e.persistent_id) }
+
+        # Switch to definitions if all entities are component instance and UI flag shows that
+        if entities_to_map.all? { |e| e.is_a?(Sketchup::ComponentInstance) } && @is_definition
+          entities_to_map = entities_to_map.collect(&:definition).uniq
+        end
+
+        # Store speckle state to update with mapped entities.
+        speckle_state = state.speckle_state
+        entities_to_map.each do |entity|
+          name = if @name == '<Mixed>'
+                   entity.respond_to?(:name) ? entity.name : ''
+                 else
+                   @name
+                 end
+          SketchupModel::Dictionary::SpeckleSchemaDictionaryHandler.set_attribute(entity, :category, @category)
+          SketchupModel::Dictionary::SpeckleSchemaDictionaryHandler.set_attribute(entity, :name, name)
+          SketchupModel::Dictionary::SpeckleSchemaDictionaryHandler.set_attribute(entity, :method, @method)
+          SketchupModel::Dictionary::SpeckleSchemaDictionaryHandler.set_attribute(entity, :family, @family)
+          SketchupModel::Dictionary::SpeckleSchemaDictionaryHandler.set_attribute(entity, :family_type, @family_type)
+          SketchupModel::Dictionary::SpeckleSchemaDictionaryHandler.set_attribute(entity, :level, @level)
+          speckle_state = speckle_state.with_mapped_entity(entity)
+        end
+
+        new_state = MappedEntitiesUpdated.update_state(state.with_speckle_state(speckle_state))
+        Events::SelectionEventAction.update_state(new_state, { apply: true })
+      end
+      # rubocop:enable Metrics/AbcSize
+      # rubocop:enable Metrics/CyclomaticComplexity
+      # rubocop:enable Metrics/PerceivedComplexity
+      # rubocop:enable Metrics/MethodLength
+    end
+  end
+end
@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative 'action'
+require_relative '../sketchup_model/dictionary/speckle_entity_dictionary_handler'
+
+module SpeckleConnector
+  module Actions
+    # Clear mapper source.
+    class ClearMapperSource < Action
+      # @param state [States::State] the current state of the {App::SpeckleConnectorApp}
+      # @return [States::State] the new updated state object
+      def self.update_state(state, _data)
+        new_speckle_state = state.speckle_state.with_removed_mapper_source
+        erase_levels(state)
+        state.with_speckle_state(new_speckle_state)
+      end
+
+      # @param state [States::State] the current state of the {App::SpeckleConnectorApp}
+      def self.erase_levels(state)
+        levels = state.sketchup_state.sketchup_model.definitions.select do |definition|
+          SketchupModel::Dictionary::SpeckleEntityDictionaryHandler.get_attribute(definition, :speckle_type) ==
+            OBJECTS_BUILTELEMENTS_REVIT_LEVEL
+        end
+        levels.each do |level|
+          level.entities.clear!
+          level.instances.each(&:erase!)
+        end
+      end
+    end
+  end
+end
@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require_relative 'action'
+require_relative 'mapped_entities_updated'
+require_relative 'events/selection_event_action'
+require_relative '../sketchup_model/dictionary/speckle_schema_dictionary_handler'
+
+module SpeckleConnector
+  module Actions
+    # Clear mappings for selected entities.
+    class ClearMappings < Action
+      def initialize(entities_to_map, is_definition)
+        super()
+        @entities_to_map = entities_to_map
+        @is_definition = is_definition
+      end
+
+      # @param state [States::State] the current state of the {App::SpeckleConnectorApp}
+      # @return [States::State] the new updated state object
+      # rubocop:disable Metrics/CyclomaticComplexity
+      # rubocop:disable Metrics/PerceivedComplexity
+      def update_state(state)
+        sketchup_model = state.sketchup_state.sketchup_model
+        entities = if sketchup_model.active_path.nil?
+                     sketchup_model.entities
+                   else
+                     sketchup_model.active_path.last.definition.entities
+                   end
+
+        # Collect entities from entity ids that comes from UI as list
+        entities_to_map = entities.select { |e| @entities_to_map.include?(e.persistent_id) }
+
+        # Switch to definitions if all entities are component instance and UI flag shows that
+        if entities_to_map.all? { |e| e.is_a?(Sketchup::ComponentInstance) } && @is_definition
+          entities_to_map = entities_to_map.collect(&:definition).uniq
+        end
+
+        # Store speckle state to update with mapped entities.
+        speckle_state = state.speckle_state
+        entities_to_map.each do |entity|
+          SketchupModel::Dictionary::SpeckleSchemaDictionaryHandler.remove_dictionary(entity)
+          speckle_state = speckle_state.with_removed_mapped_entity(entity)
+        end
+
+        new_state = MappedEntitiesUpdated.update_state(state.with_speckle_state(speckle_state))
+        Events::SelectionEventAction.update_state(new_state, { clear: true })
+      end
+      # rubocop:enable Metrics/CyclomaticComplexity
+      # rubocop:enable Metrics/PerceivedComplexity
+    end
+  end
+end
@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative 'action'
+require_relative 'mapped_entities_updated'
+require_relative 'events/selection_event_action'
+require_relative '../sketchup_model/dictionary/speckle_schema_dictionary_handler'
+
+module SpeckleConnector
+  module Actions
+    # Clear mappings for selected entities from mapped elements table.
+    class ClearMappingsFromTable < Action
+      # @param state [States::State] the current state of the {App::SpeckleConnectorApp}
+      # @return [States::State] the new updated state object
+      def self.update_state(state, data)
+        # Flat entities to clear mappings
+        flat_entities = SketchupModel::Query::Entity.flat_entities(state.sketchup_state.sketchup_model.entities)
+
+        # Collect entity ids to clear mappings
+        entity_ids = data.collect { |_, entities| entities['selectedElements'].collect { |e| e['entityId'] } }.flatten
+        # Store speckle state to update with mapped entities.
+        speckle_state = state.speckle_state
+        flat_entities.each do |entity|
+          next unless entity_ids.include?(entity.persistent_id)
+
+          SketchupModel::Dictionary::SpeckleSchemaDictionaryHandler.remove_dictionary(entity)
+          speckle_state = speckle_state.with_removed_mapped_entity(entity)
+        end
+
+        new_state = MappedEntitiesUpdated.update_state(state.with_speckle_state(speckle_state))
+        Events::SelectionEventAction.update_state(new_state, { clear: true })
+      end
+    end
+  end
+end
@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative 'action'
+
+module SpeckleConnector
+  module Actions
+    # Clear queue from state.
+    class ClearQueue < Action
+      # @param state [States::State] the current state of the {App::SpeckleConnectorApp}
+      # @return [States::State] the new updated state object
+      def self.update_state(state)
+        new_speckle_state = state.speckle_state.with(:@message_queue => {})
+        state.with(:@speckle_state => new_speckle_state)
+      end
+    end
+  end
+end
@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require_relative 'action'
+require_relative '../ext/sqlite3'
+require_relative '../constants/path_constants'
+
+module SpeckleConnector
+  module Actions
+    # Action to collect preferences from database to UI.
+    class CollectPreferences < Action
+      # @param state [States::State] the current state of the {App::SpeckleConnectorApp}
+      # @return [States::State] the new updated state object
+      def self.update_state(state, _data)
+        state.with_add_queue('collectPreferences', state.user_state.preferences.to_json, [])
+      end
+    end
+  end
+end
@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative 'action'
+
+module SpeckleConnector
+  module Actions
+    # Action to collect versions from sketchup and connector to track user's version by mixpanel.
+    class CollectVersions < Action
+      # @param state [States::State] the current state of the {App::SpeckleConnectorApp}
+      # @return [States::State] the new updated state object
+      def self.update_state(state, _data)
+        versions = {
+          sketchup: Sketchup.version.to_i,
+          speckle: SpeckleConnector::CONNECTOR_VERSION
+        }
+        state.with_add_queue('collectVersions', versions.to_json, [])
+      end
+    end
+  end
+end
@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module SpeckleConnector
+  module Actions
+    # Action to update connected state of application.
+    class Connected < Action
+      # @param state [States::State] the current state of the {App::SpeckleConnectorApp}
+      # @return [States::State] the new updated state object
+      def self.update_state(state)
+        puts 'Speckle connected!'
+        state.with(:@connected => true)
+      end
+    end
+  end
+end
@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require_relative 'action'
+require_relative '../accounts/accounts'
+require_relative '../actions/save_stream'
+require_relative '../actions/queue_send'
+require_relative '../convertors/converter'
+
+module SpeckleConnector
+  module Actions
+    # Create stream.
+    class CreateStream < Action
+      def initialize(stream_name: nil)
+        super()
+        @stream_name = stream_name
+      end
+
+      # @param state [States::State] the current state of the {App::SpeckleConnectorApp}
+      # @return [States::State] the new updated state object
+      # rubocop:disable Metrics/MethodLength
+      def update_state(state)
+        puts 'send to speckle'
+        acct = Accounts.default_account
+        if acct.nil?
+          puts 'No local account found. Please refer to speckle.guide for more information.'
+          return state
+        end
+        sketchup_model = state.sketchup_state.sketchup_model
+        path = sketchup_model.path
+        if @stream_name.nil?
+          @stream_name = path ? File.basename(path, '.*') : 'Untitled SketchUp Model'
+        end
+        query = 'mutation streamCreate($stream: StreamCreateInput!) {streamCreate(stream: $stream)}'
+        vars = { stream: { name: @stream_name, description: 'Stream created from SketchUp' } }
+        request = Sketchup::Http::Request.new("#{acct['serverInfo']['url']}/graphql", Sketchup::Http::POST)
+        request.headers = { 'Authorization' => "Bearer #{acct['token']}", 'Content-Type' => 'application/json' }
+        request.body = { query: query, variables: vars }.to_json
+        to_convert = if sketchup_model.selection.count > 0
+                       sketchup_model.selection
+                     else
+                       sketchup_model.entities
+                     end
+        state = evaluate_request(sketchup_model, request, state, to_convert)
+        Actions::LoadSavedStreams.update_state(state, {})
+      end
+      # rubocop:enable Metrics/MethodLength
+
+      private
+
+      def evaluate_request(sketchup_model, request, state, to_convert)
+        converter = Converters::Converter.new(sketchup_model)
+
+        request.start do |_req, res|
+          res_data = JSON.parse(res.body)['data']
+          raise(StandardError) unless res_data
+
+          stream_id = res_data['streamCreate']
+          state = Actions::SaveStream.new(stream_id).update_state(state)
+          converted = to_convert.map { |entity| converter.convert_to_speckle(entity) }
+          state = Actions::QueueSend.new(stream_id, converted).update_state(state)
+        end
+        state
+      end
+    end
+  end
+end
@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative 'action'
+
+module SpeckleConnector
+  module Actions
+    # Deactivate diffing.
+    class DeactivateDiffing < Action
+      # @param state [States::State] the current state of the {App::SpeckleConnectorApp}
+      # @return [States::State] the new updated state object
+      def self.update_state(state, _data)
+        puts 'Diffing deactivated!'
+        speckle_entities = state.speckle_state.speckle_entities
+        diffing_activated_speckle_entities = speckle_entities.reject do |_id, entity|
+          entity.active_diffing_stream_id.nil?
+        end
+        diffing_activated_speckle_entities.each do |id, entity|
+          new_entity = entity.deactivate_diffing
+          speckle_entities = speckle_entities.put(id, new_entity)
+        end
+        new_speckle_state = state.speckle_state.with_speckle_entities(speckle_entities)
+        state.with_speckle_state(new_speckle_state)
+      end
+    end
+  end
+end
@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require_relative 'event_action'
+require_relative '../load_sketchup_model'
+require_relative '../collect_preferences'
+
+module SpeckleConnector
+  module Actions
+    module Events
+      # Handle events that are triggered by the {AppObserver}.
+      class AppEventAction < EventAction
+        # Handle loading new or existing model
+        class OnNewOrChangedModel
+          # Handle events when the new or existing model is loaded in Sketchup
+          # @param state [States::State] the current state of speckle application
+          # @param event_data [Array<(Sketchup::Model)>] the event data for the given event. It consists of
+          #  a double array with a single element that is the {Sketchup::Model} object of the loaded model.
+          def self.update_state(state, event_data)
+            return state unless event_data&.any?
+
+            model = event_data.flatten.first
+            # LoadSketchupModel action should be responsible to update all model specific data for state and then
+            #  should notify the UI to update it's components.
+            new_state = Actions::LoadSketchupModel.update_state(state, model)
+            # Action to let UI to render itself with new preferences state
+            # TODO: Later UI should be updated if any stream is invalid after
+            #  we collected speckle_entities appropriately
+            CollectPreferences.update_state(new_state, {})
+          end
+        end
+
+        # Run actions that are needed before the sketchup quits
+        class OnQuit
+          # Handle when Sketchup application closes
+          # @param state [States::State] the current state of speckle application
+          # @param _event_data [Array] the event data
+          # @return [States::State] the transformed state object
+          def self.update_state(state, _event_data)
+            state
+          end
+        end
+
+        # Handlers that are used to handle specific events
+        ACTIONS = {
+          onNewModel: OnNewOrChangedModel,
+          onOpenModel: OnNewOrChangedModel,
+          onQuit: OnQuit
+        }.freeze
+
+        def self.actions
+          ACTIONS
+        end
+      end
+    end
+  end
+end
@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require_relative 'event_action'
+require_relative '../../sketchup_model/utils/face_utils'
+require_relative '../../constants/dict_constants'
+
+module SpeckleConnector
+  module Actions
+    module Events
+      # Event actions related to entities.
+      class EntitiesEventAction < EventAction
+        # Event action when element added.
+        class OnElementAdded
+          # @param state [States::State] the current state of the SpeckleConnector Application
+          def self.update_state(state, event_data)
+            modified_entities = event_data.to_a.collect { |e| e[1] }
+            # do not copy speckle base object specific attributes, because they are entity specific
+            modified_entities.each { |entity| entity.delete_attribute(SPECKLE_BASE_OBJECT) }
+            state
+          end
+        end
+
+        # Event action when element modified.
+        class OnElementModified
+          # @param state [States::State] the current state of the SpeckleConnector Application
+          def self.update_state(state, event_data)
+            speckle_state = state.speckle_state
+            modified_entity = event_data[0][1]
+            if modified_entity.is_a?(Sketchup::Face)
+              path = state.sketchup_state.sketchup_model.active_path
+              modified_faces = SketchupModel::Utils::FaceUtils.near_faces(modified_entity.edges)
+              path_objects = path.nil? ? [] : path + path.collect(&:definition)
+              parent_ids = path_objects.collect(&:persistent_id)
+              ids_to_invalidate = modified_faces.collect(&:persistent_id) + parent_ids
+              entities_to_invalidate = speckle_entities_to_invalidate(speckle_state, ids_to_invalidate)
+              new_speckle_state = invalidate_speckle_entities(speckle_state, entities_to_invalidate)
+              # This is the place we can send information to UI for diffing check
+              diffing = state.user_state.preferences[:user][:diffing]
+              new_speckle_state = new_speckle_state.with_invalid_streams_queue if diffing
+              return state.with_speckle_state(new_speckle_state)
+            end
+
+            state
+          end
+
+          # @param speckle_state [States::SpeckleState] the current state of the Speckle
+          def self.speckle_entities_to_invalidate(speckle_state, ids)
+            speckle_state.speckle_entities.to_h.select { |id, _| ids.include?(id) }
+          end
+
+          # @param speckle_state [States::SpeckleState] the current state of the Speckle
+          def self.invalidate_speckle_entities(speckle_state, entities_to_invalidate)
+            speckle_entities = speckle_state.speckle_entities
+            entities_to_invalidate.each do |id, speckle_entity|
+              edited_speckle_entity = speckle_entity.with_invalid
+              speckle_entities = speckle_entities.put(id, edited_speckle_entity)
+            end
+            speckle_state.with_speckle_entities(speckle_entities)
+          end
+        end
+
+        # Event action when element removed.
+        class OnElementRemoved
+          # @param state [States::State] the current state of the SpeckleConnector Application
+          def self.update_state(state, _event_data)
+            # TODO: Do state updates when element removed
+            state
+          end
+        end
+
+        # Handlers that are used to handle specific events
+        ACTIONS = {
+          onElementRemoved: OnElementRemoved,
+          onElementAdded: OnElementAdded,
+          onElementModified: OnElementModified
+        }.freeze
+
+        def self.actions
+          ACTIONS
+        end
+      end
+    end
+  end
+end
@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module SpeckleConnector
+  module Actions
+    # This module contains actions that are performed to handle events triggered by observers in Sketchup.
+    module Events
+      # Base action for Handling events
+      class EventAction
+        def self.actions
+          raise NoMethodError, 'Implement in a subclass'
+        end
+
+        # Handle the events that were collected by the observer. In case of the selection observer,
+        # we only need to handle the events once if any of the events actually happened.
+        # @param state [States::State] the current state of the SpeckleConnector Application
+        # @param events [Hash{Symbol=>Array}] the event data grouped by the event name
+        # @return [States::State] the transformed state
+        def self.update_state(state, events)
+          # Don't do anything if there are no events for this action
+          return state unless events
+
+          actions = self.actions
+          actions.each do |event_name, action|
+            next unless events.key?(event_name)
+
+            event_data = events[event_name]
+            state = action.update_state(state, event_data)
+          end
+          state
+        end
+      end
+    end
+  end
+end
@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require_relative 'event_action'
+require_relative '../load_sketchup_model'
+
+module SpeckleConnector
+  module Actions
+    module Events
+      # Handle events that are triggered by the {ModelObserver}.
+      class ModelEventAction < EventAction
+        # Handle loading new or existing model
+        class OnActivePathChanged
+          # Handle events when the new or existing model is loaded in Sketchup
+          # @param state [States::State] the current state of speckle application
+          # @param event_data [Array<(Sketchup::Model)>] the event data for the given event. It consists of
+          #  a double array with a single element that is the {Sketchup::Model} object of the loaded model.
+          def self.update_state(state, _event_data)
+            sketchup_state = state.sketchup_state
+            active_path = sketchup_state.sketchup_model.active_path
+            observers = state.speckle_state.observers
+            update_object_observers(active_path, observers)
+            return state
+          end
+
+          def self.update_object_observers(path, observers)
+            path[-1].definition.entities.add_observer(observers[ENTITIES_OBSERVER]) unless path.nil?
+          end
+        end
+
+        # Handlers that are used to handle specific events
+        ACTIONS = {
+          onActivePathChanged: OnActivePathChanged
+        }.freeze
+
+        def self.actions
+          ACTIONS
+        end
+      end
+    end
+  end
+end
@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative 'event_action'
+require_relative '../mapper_selection_changed'
+require_relative '../../mapper/category/revit_category'
+require_relative '../../sketchup_model/reader/speckle_entities_reader'
+require_relative '../../sketchup_model/reader/mapper_reader'
+require_relative '../../sketchup_model/query/entity'
+
+module SpeckleConnector
+  module Actions
+    module Events
+      # Update selected speckle objects when the selection changes for mapper tool.
+      class SelectionEventAction < EventAction
+        # @param state [States::State] the current state of Speckle application.
+        # @return [States::State] the new updated state object
+        def self.update_state(state, event_data)
+          return state unless event_data&.any?
+
+          # Get sketchup selection
+          sketchup_selection = state.sketchup_state.sketchup_model.selection
+
+          # Collect and return mapper selection info.
+          # Later we can add more selection info for different scopes.
+          MapperSelectionChanged.new(sketchup_selection).update_state(state)
+        end
+      end
+    end
+  end
+end
@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require_relative 'action'
+require_relative 'events/selection_event_action'
+require_relative '../sketchup_model/dictionary/speckle_schema_dictionary_handler'
+
+module SpeckleConnector
+  module Actions
+    # Hide entities that selected from mapped elements table.
+    class HideMappingsFromTable < Action
+      # @param state [States::State] the current state of the {App::SpeckleConnectorApp}
+      # @return [States::State] the new updated state object
+      def self.update_state(state, data)
+        # Flat entities to clear mappings
+        flat_entities = SketchupModel::Query::Entity.flat_entities(state.sketchup_state.sketchup_model.entities)
+
+        # Collect entity ids to clear mappings
+        entity_ids = data.collect { |_, entities| entities['selectedElements'].collect { |e| e['entityId'] } }.flatten
+
+        # Store speckle state to update with mapped entities.
+        flat_entities.each do |entity|
+          next unless entity_ids.include?(entity.persistent_id)
+
+          if entity.is_a?(Sketchup::ComponentDefinition)
+            entity.instances.each do |instance|
+              instance.hidden = true
+            end
+          end
+          entity.hidden = true
+        end
+
+        Events::SelectionEventAction.update_state(state, { clear: true })
+      end
+    end
+  end
+end
@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative 'action'
+require_relative '../accounts/accounts'
+require_relative 'load_saved_streams'
+
+module SpeckleConnector
+  module Actions
+    # Action to initialize local accounts from database.
+    class InitLocalAccounts < Action
+      # @param state [States::State] the current state of the {App::SpeckleConnectorApp}
+      # @return [States::State] the new updated state object
+      def self.update_state(state, _data)
+        puts 'Initialisation of Speckle accounts requested by plugin'
+        accounts_data = state.speckle_state.accounts
+        state.with_add_queue('loadAccounts', accounts_data.to_json, [])
+      end
+    end
+  end
+end
@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative 'action'
+require_relative 'add_material'
+require_relative '../constants/mat_constants'
+
+module SpeckleConnector
+  module Actions
+    # Action to initialize materials
+    class InitializeMaterials < Action
+      # @param state [States::State] the current state of the {App::SpeckleConnectorApp}
+      # @return [States::State] the new updated state object
+      def self.update_state(state)
+        new_state = recreate_material(state, DEFAULT_NAMES[MAT_ADD], DEFAULT_COLORS[MAT_ADD], MAT_ADD)
+        new_state = recreate_material(new_state, DEFAULT_NAMES[MAT_EDIT], DEFAULT_COLORS[MAT_EDIT], MAT_EDIT)
+        recreate_material(new_state, DEFAULT_NAMES[MAT_REMOVE], DEFAULT_COLORS[MAT_REMOVE], MAT_REMOVE)
+      end
+
+      def self.recreate_material(state, name, color, id, alpha: nil)
+        Actions::AddMaterial.update_state(
+          state,
+          material_name: name,
+          color: color,
+          material_id: id,
+          alpha: alpha
+        )
+      end
+    end
+  end
+end
@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative 'action'
+require_relative '../states/state'
+require_relative '../states/speckle_state'
+require_relative '../states/sketchup_state'
+require_relative '../accounts/accounts'
+require_relative '../preferences/preferences'
+require_relative '../constants/observer_constants'
+
+module SpeckleConnector
+  module Actions
+    # Initialization of the real state of the speckle.
+    class InitializeSpeckle < Action
+      # @param state [States::State] the current state of the {App::SpeckleConnectorApp}
+      # @return [States::State] the new updated state object
+      def self.update_state(state, observers)
+        attach_app_observer!(observers[APP_OBSERVER])
+        accounts = SpeckleConnector::Accounts.load_accounts
+        speckle_state = States::SpeckleState.new(accounts, observers, {}, {})
+        # This should be the only point that `Sketchup_active_model` passed to application state.
+        sketchup_state = States::SketchupState.new(Sketchup.active_model)
+        preferences = Preferences.read_preferences(sketchup_state.sketchup_model)
+        user_state_with_preferences = state.user_state.with_preferences(preferences)
+        state = States::State.new(user_state_with_preferences, speckle_state, sketchup_state, false)
+        # This is where we attach observers to related model objects like selection, entities..
+        Actions::LoadSketchupModel.update_state(state, sketchup_state.sketchup_model)
+      end
+
+      def self.attach_app_observer!(observer)
+        Sketchup.add_observer(observer)
+      end
+    end
+  end
+end
@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require_relative 'action'
+require_relative 'events/selection_event_action'
+require_relative '../sketchup_model/dictionary/speckle_schema_dictionary_handler'
+
+module SpeckleConnector
+  module Actions
+    # Isolate entities that selected from mapped elements table.
+    class IsolateMappingsFromTable < Action
+      # @param state [States::State] the current state of the {App::SpeckleConnectorApp}
+      # @return [States::State] the new updated state object
+      # rubocop:disable Metrics/AbcSize
+      # rubocop:disable Metrics/MethodLength
+      # rubocop:disable Metrics/PerceivedComplexity
+      # rubocop:disable Metrics/CyclomaticComplexity
+      def self.update_state(state, data)
+        sketchup_model = state.sketchup_state.sketchup_model
+
+        # Hide all entities first
+        sketchup_model.entities.each do |ent|
+          ent.hidden = true
+        end
+
+        # Flat entities to isolate mappings
+        flat_entities = SketchupModel::Query::Entity.flat_entities(sketchup_model.entities)
+
+        comp_flat_entities = flat_entities.grep(Sketchup::ComponentInstance) + flat_entities.grep(Sketchup::Group) +
+                             flat_entities.grep(Sketchup::ComponentDefinition)
+        face_edge_flat_entities = flat_entities.grep(Sketchup::Face) + flat_entities.grep(Sketchup::Edge)
+
+        # Collect entity ids to clear mappings
+        selected_elements = data.collect { |_, entities| entities['selectedElements'] }.flatten
+
+        comps_or_groups, faces_or_edges = selected_elements.partition do |e|
+          e['entityType'] == 'Component' || e['entityType'] == 'Definition' || e['entityType'] == 'Group'
+        end
+
+        faces_or_edges_ids = faces_or_edges.collect { |e| e['entityId'] }
+
+        face_edge_flat_entities.select { |e| faces_or_edges_ids.include?(e.persistent_id) }.each do |entity|
+          entity.hidden = false
+        end
+
+        comps_or_groups_ids = comps_or_groups.collect { |e| e['entityId'] }
+
+        comp_flat_entities.select { |e| comps_or_groups_ids.include?(e.persistent_id) }.each do |entity|
+          if entity.is_a?(Sketchup::ComponentDefinition)
+            entity.instances.each do |instance|
+              instance.hidden = false
+            end
+          end
+          entity.hidden = false
+        end
+
+        Events::SelectionEventAction.update_state(state, { clear: true })
+      end
+      # rubocop:enable Metrics/AbcSize
+      # rubocop:enable Metrics/MethodLength
+      # rubocop:enable Metrics/PerceivedComplexity
+      # rubocop:enable Metrics/CyclomaticComplexity
+    end
+  end
+end
@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require_relative 'action'
+
+module SpeckleConnector
+  module Actions
+    # Action to load saved streams.
+    class LoadSavedStreams < Action
+      # @param state [States::State] the current state of the {App::SpeckleConnectorApp}
+      # @return [States::State] the new updated state object
+      def self.update_state(state, _data)
+        (saved_streams = state.sketchup_state.sketchup_model
+                              .attribute_dictionary('Speckle', true)['saved_streams']) or []
+        state.with_add_queue('setSavedStreams', saved_streams, [])
+      end
+    end
+  end
+end
@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require_relative 'action'
+require_relative 'initialize_materials'
+require_relative '../sketchup_model/reader/speckle_entities_reader'
+require_relative '../sketchup_model/reader/mapper_reader'
+require_relative '../preferences/preferences'
+require_relative '../states/state'
+require_relative '../states/sketchup_state'
+require_relative '../constants/observer_constants'
+
+module SpeckleConnector
+  module Actions
+    # Switch sketchup model wit a new one
+    class LoadSketchupModel < Action
+      # Replace current model state with the state of a new model. This action is triggered when user opens new or
+      # existing Sketchup model.
+      # @param state [States::State] the current state of Speckle
+      # @param additional_parameters [Array] parameters that the action takes
+      # @return [States::State] the new updated state object
+      def self.update_state(state, sketchup_model)
+        # Init sketchup state again with new model
+        new_sketchup_state = States::SketchupState.new(sketchup_model)
+        sketchup_model.rendering_options['DisplaySectionPlanes'] = true
+        new_state = state.with(:@sketchup_state => new_sketchup_state)
+        # Init materials again
+        new_state = InitializeMaterials.update_state(new_state)
+
+        # Read speckle entities
+        new_speckle_entities = SketchupModel::Reader::SpeckleEntitiesReader.read(sketchup_model.entities)
+        new_speckle_state = new_state.speckle_state.with_speckle_entities(Immutable::Hash.new(new_speckle_entities))
+        # Read mapped entities
+        new_mapped_entities = SketchupModel::Reader::MapperReader.read_mapped_entities(sketchup_model.entities)
+        new_speckle_state = new_speckle_state.with_mapped_entities(Immutable::Hash.new(new_mapped_entities))
+        new_state = new_state.with_speckle_state(new_speckle_state)
+
+        # Read preferences from database and model.
+        preferences = Preferences.read_preferences(new_state.sketchup_state.sketchup_model)
+        new_user_state = new_state.user_state.with_preferences(preferences)
+        new_state = new_state.with(:@user_state => new_user_state)
+        attach_observers(sketchup_model, new_state.speckle_state.observers)
+        new_state
+      end
+
+      # Attach observers to the sketchup model
+      # @param sketchup_model [Sketchup::Model] the model to attach observers to
+      # @param observers [Hash{Class=>}] the observer objects indexed by their class that will be attached
+      def self.attach_observers(sketchup_model, observers)
+        selection = sketchup_model.selection
+        selection.add_observer(observers[SELECTION_OBSERVER])
+        # layers = sketchup_model.layers
+        # layers.add_observer(observers[LAYERS_OBSERVER_NAME])
+        entities = sketchup_model.entities
+        entities.add_observer(observers[ENTITIES_OBSERVER])
+        sketchup_model.add_observer(observers[MODEL_OBSERVER])
+        # materials = sketchup_model.materials
+        # materials.add_observer(observers[MATERIALS_OBSERVER_NAME])
+        # pages = sketchup_model.pages
+        # pages.add_observer(observers[PAGES_OBSERVER_NAME])
+      end
+    end
+  end
+end
@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative 'action'
+require_relative '../sketchup_model/reader/mapper_reader'
+
+module SpeckleConnector
+  module Actions
+    # Triggers when mapped entities updated.
+    class MappedEntitiesUpdated < Action
+      # @param state [States::State] the current state of the {App::SpeckleConnectorApp}
+      # @return [States::State] the new updated state object
+      def self.update_state(state, _data = nil)
+        mapped_entities = SketchupModel::Reader::MapperReader
+                          .mapped_entity_details(state.speckle_state.speckle_mapper_state.mapped_entities.values.to_a)
+
+        state.with_mapped_entities_queue(mapped_entities)
+      end
+    end
+  end
+end
@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative 'action'
+require_relative '../mapper/category/revit_category'
+require_relative '../mapper/category/revit_family_category'
+
+module SpeckleConnector
+  module Actions
+    # Collects mapper selection info.
+    class MapperInitialized < Action
+      # @param state [States::State] the current state of the {App::SpeckleConnectorApp}
+      # @return [States::State] the new updated state object
+      def self.update_state(state, _data)
+        init_parameters = {
+          categories: Mapper::Category::RevitCategory.to_a,
+          familyCategories: Mapper::Category::RevitFamilyCategory.to_a
+        }.freeze
+        state.with_mapper_init_queue(init_parameters)
+      end
+    end
+  end
+end
@@ -0,0 +1,200 @@
+# frozen_string_literal: true
+
+require_relative 'action'
+require_relative '../mapper/category/revit_category'
+require_relative '../mapper/category/revit_family_category'
+require_relative '../sketchup_model/reader/mapper_reader'
+require_relative '../sketchup_model/reader/speckle_entities_reader'
+require_relative '../sketchup_model/dictionary/speckle_entity_dictionary_handler'
+
+module SpeckleConnector
+  module Actions
+    # Collects mapper selection info.
+    class MapperSelectionChanged < Action
+      READER = SketchupModel::Reader
+      DICTIONARY = SketchupModel::Dictionary
+
+      def initialize(selection)
+        super()
+        @selection = selection
+      end
+
+      # @param state [States::State] the current state of the {App::SpeckleConnectorApp}
+      # @return [States::State] the new updated state object
+      def update_state(state)
+        # Get mapping info from selection.
+        mapping = get_mapping_info(state, @selection)
+
+        state.with_mapper_selection_queue(mapping)
+      end
+
+      def filter_out_levels(selection)
+        selection.reject do |e|
+          DICTIONARY::SpeckleEntityDictionaryHandler
+            .get_attribute(e, :speckle_type) == OBJECTS_BUILTELEMENTS_REVIT_LEVEL
+        end
+      end
+
+      def get_mapping_info(state, selection)
+        source_exist = !state.speckle_state.speckle_mapper_state.mapper_source.nil?
+        selection = filter_out_levels(selection)
+        grouped_by_type = group_by_type(selection)
+
+        supported_entity_count = grouped_by_type.length
+
+        # Return empty method list if there is no supported entity to map.
+        return EMPTY_SELECTION if supported_entity_count == 0
+
+        # Return Direct Shape itself if multiple kinds of element are selected like Edge and Face.
+        # OR single type is equal to only direct shape supports.
+        return multiple_supported_selection_info(selection) if supported_entity_count > 1
+
+        # FIXME: Distinguish selection info according to selection elegantly!!!
+        if grouped_by_type.keys.first == Sketchup::ComponentInstance
+          return component_selection_info(selection, source_exist)
+        end
+
+        return group_selection_info(selection) if grouped_by_type.keys.first == Sketchup::Group
+
+        if supported_entity_count > 1 ||
+           (supported_entity_count == 1 &&
+             MAPPER_DIRECT_SHAPE_SUPPORTED_ENTITY_TYPES.include?(grouped_by_type.keys.first))
+          if source_exist
+            return direct_shape_selection_info_with_source(selection, [])
+          else
+            return direct_shape_selection_info(selection, source_exist)
+          end
+        end
+
+        # Only single type selections remained after this point.
+        return face_selection_info(state, grouped_by_type.values.first) if grouped_by_type.keys.first == Sketchup::Face
+
+        return edge_selection_info(state, grouped_by_type.values.first) if grouped_by_type.keys.first == Sketchup::Edge
+
+        EMPTY_SELECTION
+      end
+
+      MAPPER_SUPPORTED_ENTITY_TYPES = [
+        Sketchup::ComponentInstance,
+        Sketchup::Group,
+        Sketchup::Face,
+        Sketchup::Edge
+      ].freeze
+
+      MAPPER_DIRECT_SHAPE_SUPPORTED_ENTITY_TYPES = [
+        Sketchup::ComponentInstance,
+        Sketchup::Group
+      ].freeze
+
+      EMPTY_SELECTION = {
+        selection: [],
+        mappingMethods: []
+      }.freeze
+
+      def multiple_supported_selection_info(selection)
+        {
+          selection: SketchupModel::Reader::MapperReader.entities_schema_details(selection),
+          mappingMethods: ['Direct Shape']
+        }.freeze
+      end
+
+      def component_selection_info(selection, source_exist)
+        if source_exist
+          {
+            selection: SketchupModel::Reader::MapperReader.entities_schema_details(selection),
+            mappingMethods: ['Direct Shape', 'New Revit Family', 'Family Instance']
+          }.freeze
+        else
+          {
+            selection: SketchupModel::Reader::MapperReader.entities_schema_details(selection),
+            mappingMethods: ['Direct Shape', 'New Revit Family']
+          }.freeze
+        end
+      end
+
+      def group_selection_info(selection)
+        {
+          selection: SketchupModel::Reader::MapperReader.entities_schema_details(selection),
+          mappingMethods: ['Direct Shape']
+        }.freeze
+      end
+
+      def direct_shape_selection_info(selection, source_exist)
+        methods = ['Direct Shape', 'New Revit Family']
+        methods.append('Family Instance') if source_exist
+        {
+          selection: SketchupModel::Reader::MapperReader.entities_schema_details(selection),
+          mappingMethods: methods
+        }.freeze
+      end
+
+      def direct_shape_selection_info_with_default(selection, methods)
+        {
+          selection: SketchupModel::Reader::MapperReader.entities_schema_details(selection),
+          mappingMethods: ['Direct Shape'] + methods
+        }.freeze
+      end
+
+      def direct_shape_selection_info_with_source(filtered_selection, methods)
+        instances = @selection.grep(Sketchup::ComponentInstance)
+        selected_level = instances.find do |i|
+          DICTIONARY::SpeckleEntityDictionaryHandler
+            .get_attribute(i, :speckle_type) == OBJECTS_BUILTELEMENTS_REVIT_LEVEL
+        end
+        selected_level_name = nil
+        if selected_level
+          selected_level_name = DICTIONARY::SpeckleEntityDictionaryHandler.get_attribute(selected_level, :name)
+        end
+        {
+          selection: READER::MapperReader.entities_schema_details(filtered_selection),
+          mappingMethods: ['Direct Shape'] + methods,
+          categories: Mapper::Category::RevitCategory.to_a,
+          selectedLevelName: selected_level_name
+        }.freeze
+      end
+
+      # @param state [States::State] the current state of the {App::SpeckleConnectorApp}
+      def face_selection_info(state, faces)
+        source_exist = !state.speckle_state.speckle_mapper_state.mapper_source.nil?
+        grouped_by_verticality = faces.group_by { |face| face.normal.perpendicular?(VECTOR_Z) }
+        return direct_shape_selection_info(faces, source_exist) if grouped_by_verticality.length == 2
+
+        if source_exist
+          if grouped_by_verticality.keys.first
+            direct_shape_selection_info_with_source(faces, ['Wall'])
+          else
+            direct_shape_selection_info_with_source(faces, ['Floor'])
+          end
+        else
+          if grouped_by_verticality.keys.first
+            direct_shape_selection_info_with_default(faces, ['Default Wall'])
+          else
+            direct_shape_selection_info_with_default(faces, ['Default Floor'])
+          end
+        end
+      end
+
+      def edge_selection_info(state, edges)
+        source_exist = !state.speckle_state.speckle_mapper_state.mapper_source.nil?
+
+        if source_exist
+          methods = ['Column', 'Beam', 'Pipe', 'Duct']
+          direct_shape_selection_info_with_source(edges, methods)
+        else
+          default_methods = ['Default Column', 'Default Beam', 'Default Pipe', 'Default Duct']
+          direct_shape_selection_info_with_default(edges, default_methods)
+        end
+      end
+
+      def group_by_type_old(selection)
+        selection.group_by(&:class).filter_map do |group|
+          [group.first, group] if MAPPER_SUPPORTED_ENTITY_TYPES.include?(group.first)
+        end.to_h
+      end
+
+      def group_by_type(selection)
+        selection.select { |s| MAPPER_SUPPORTED_ENTITY_TYPES.include?(s.class) }.group_by(&:class)
+      end
+    end
+  end
+end
@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require_relative 'action'
+require_relative '../constants/type_constants'
+require_relative '../mapper/mapper_source'
+require_relative '../speckle_objects/built_elements/revit/revit_element_type'
+
+module SpeckleConnector
+  module Actions
+    # Action to update mapper source.
+    class MapperSourceUpdated < Action
+      def initialize(base, stream_id, commit_id)
+        super()
+        @base = base
+        @stream_id = stream_id
+        @commit_id = commit_id
+      end
+
+      # @param state [States::State] the current state of the {App::SpeckleConnectorApp}
+      # @return [States::State] the new updated state object
+      def update_state(state)
+        levels = convert_levels(state, @base['@Levels'])
+        types = convert_types(@base['@Types'])
+        family_instances = convert_family_instance_types(@base['@Types'])
+        mapper_source = Mapper::MapperSource.new(@stream_id, @commit_id, levels, types)
+        new_speckle_state = state.speckle_state.with_mapper_source(mapper_source)
+        state = state.with_speckle_state(new_speckle_state)
+
+        state.with_add_queue('mapperSourceUpdated', @stream_id, [
+                               { is_string: false, val: levels.to_json },
+                               { is_string: false, val: types.to_json },
+                               { is_string: false, val: family_instances.to_json }
+                             ])
+      end
+
+      def convert_types(types)
+        types.collect do |type, type_elements|
+          next if type_elements.nil? || !type_elements.is_a?(Array) || type == '__closure'
+
+          type = type[1..-1] if type[0] == '@'
+          elements = type_elements.map do |type_element|
+            SpeckleObjects::BuiltElements::Revit::RevitElementType.to_native(type_element)
+          end
+          elements = elements.group_by { |e| e[:family] }
+          [type, elements]
+        end.compact.to_h
+      end
+
+      def convert_family_instance_types(types)
+        family_instance_types = {}
+        types.each do |type, type_elements|
+          next if type_elements.nil? || !type_elements.is_a?(Array) || type == '__closure'
+
+          # skip type if there is no any revit symbol element type
+          symbol_element_types = type_elements.select do |t|
+            t['speckle_type'] == OBJECTS_BUILTELEMENTS_REVIT_REVITSYMBOLELEMENTTYPE &&
+              t['placementType'] == 'OneLevelBased'
+          end
+          next if symbol_element_types.empty?
+
+          elements = type_elements.map do |type_element|
+            SpeckleObjects::BuiltElements::Revit::RevitElementType.to_native(type_element)
+          end
+          elements = elements.group_by { |e| e[:family] }
+          family_instance_types.merge!(elements)
+        end
+        family_instance_types
+      end
+
+      def convert_levels(state, levels)
+        levels.collect do |level|
+          SpeckleObjects::BuiltElements::Level.to_native(state, level, @stream_id)
+        end
+      end
+    end
+  end
+end
@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require_relative 'action'
+require_relative '../ext/sqlite3'
+require_relative '../accounts/accounts'
+require_relative '../constants/path_constants'
+require_relative '../sketchup_model/dictionary/speckle_model_dictionary_handler'
+
+module SpeckleConnector
+  module Actions
+    # When preference updated by UI.
+    class ModelPreferencesUpdated < Action
+      def initialize(pref, value)
+        super()
+        @preference = pref
+        @value = value
+      end
+
+      # @param state [States::State] the current state of the {App::SpeckleConnectorApp}
+      # @return [States::State] the new updated state object
+      def update_state(state)
+        model = state.user_state.preferences[:model].dup
+        model[@preference.to_sym] = @value
+        new_preferences = state.user_state.preferences.put(:model, model)
+        SketchupModel::Dictionary::SpeckleModelDictionaryHandler.set_attribute(
+          state.sketchup_state.sketchup_model,
+          @preference.to_sym,
+          @value,
+          'Speckle'
+        )
+        new_user_state = state.user_state.with_preferences(new_preferences)
+        state.with_user_state(new_user_state)
+      end
+    end
+  end
+end
@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative 'action'
+require_relative 'events/app_event_action'
+require_relative 'events/entities_event_action'
+require_relative 'events/model_event_action'
+require_relative 'events/selection_event_action'
+require_relative '../constants/observer_constants'
+
+module SpeckleConnector
+  module Actions
+    # Handle events that were collected by observers
+    class OnEventsAction < Action
+      RUN_ORDER = {
+        APP_OBSERVER => Events::AppEventAction,
+        ENTITIES_OBSERVER => Events::EntitiesEventAction,
+        MODEL_OBSERVER => Events::ModelEventAction,
+        # MATERIALS_OBSERVER => Events::MaterialsEventAction,
+        # LAYERS_OBSERVER => Events::LayerEventAction,
+        # PAGES_OBSERVER => Events::PagesEventAction,
+        SELECTION_OBSERVER => Events::SelectionEventAction
+      }.freeze
+
+      def self.update_state(state, events)
+        RUN_ORDER.each do |observer_name, action|
+          next unless events.key?(observer_name)
+
+          parameters = events[observer_name]
+          state = action.update_state(state, parameters)
+        end
+        state
+      end
+    end
+  end
+end
@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require_relative 'action'
+require_relative '../accounts/accounts'
+require_relative '../actions/create_stream'
+require_relative '../actions/queue_send'
+require_relative '../convertors/to_speckle'
+
+module SpeckleConnector
+  module Actions
+    # Sends to speckle.
+    class OneClickSend < Action
+      # @param state [States::State] the current state of the {App::SpeckleConnectorApp}
+      # @return [States::State] the new updated state object
+      def self.update_state(state)
+        puts 'send to speckle'
+        default_account = Accounts.default_account
+        if default_account.nil?
+          puts 'No local account found. Please refer to speckle.guide for more information.'
+          return state
+        end
+        sketchup_model = state.sketchup_state.sketchup_model
+        to_convert = sketchup_model.selection.count > 0 ? sketchup_model.selection : sketchup_model.entities
+        first_saved_stream = first_saved_stream(sketchup_model)
+        action = if first_saved_stream.nil?
+                   Actions::CreateStream.new
+                 else
+                   Actions::QueueSend.new(first_saved_stream, convert_to_speckle(sketchup_model, to_convert))
+                 end
+
+        action.update_state(state)
+      end
+
+      def self.first_saved_stream(model)
+        (saved_streams = model.attribute_dictionary('speckle', true)['streams']) or []
+        saved_streams.nil? || saved_streams.empty? ? nil : saved_streams[0]
+      end
+
+      def self.convert_to_speckle(sketchup_model, to_convert)
+        converter = Converters::ToSpeckle.new(sketchup_model)
+        to_convert.map { |entity| converter.convert(entity) }
+      end
+    end
+  end
+end
@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative 'action'
+require_relative '../states/state'
+require_relative '../states/speckle_state'
+require_relative '../actions/send_from_queue'
+
+module SpeckleConnector
+  module Actions
+    # Send queue from state.
+    class QueueSend < Action
+      def initialize(stream_id, converted)
+        super()
+        @stream_id = stream_id
+        @converted = converted
+      end
+
+      # @param state [States::State] the current state of the {App::SpeckleConnectorApp}
+      # @return [States::State] the new updated state object
+      def update_state(state)
+        to_send = { stream_id: @stream_id, converted: @converted }
+        new_speckle_state = state.speckle_state.with(:@stream_queue => to_send)
+        new_state = state.with(:@speckle_state => new_speckle_state)
+        if new_state.is_connected
+          action = Actions::SendFromQueue.new(@stream_id)
+          new_state = action.update_state(new_state)
+        end
+        new_state
+      end
+    end
+  end
+end
@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative 'action'
+require_relative '../convertors/units'
+require_relative '../convertors/to_native'
+require_relative '../convertors/clean_up'
+
+module SpeckleConnector
+  module Actions
+    # Action to receive objects from Speckle Server.
+    class ReceiveObjects < Action
+      # rubocop:disable Metrics/ParameterLists
+      def initialize(stream_id, base, stream_name, branch_name, branch_id, source_app)
+        super()
+        @stream_id = stream_id
+        @base = base
+        @stream_name = stream_name
+        @branch_name = branch_name
+        @branch_id = branch_id
+        @source_app = source_app
+      end
+      # rubocop:enable Metrics/ParameterLists
+
+      # @param state [States::State] the current state of the {App::SpeckleConnectorApp}
+      # @return [States::State] the new updated state object
+      def update_state(state)
+        converter = Converters::ToNative.new(state, @stream_id, @stream_name, @branch_name, @source_app)
+        # Have side effects on the sketchup model. It effects directly on the entities by adding new objects.
+        start_time = Time.now.to_f
+        state.sketchup_state.sketchup_model.start_operation('Receive Speckle Objects', true)
+        state = converter.receive_commit_object(@base)
+        if state.user_state.model_preferences[:merge_coplanar_faces]
+          Converters::CleanUp.merge_coplanar_faces(converter.converted_faces)
+        end
+        state.sketchup_state.sketchup_model.commit_operation
+        elapsed_time = (Time.now.to_f - start_time).round(3)
+        puts "==== Converting to Native executed in #{elapsed_time} sec ===="
+        puts "==== Source application is #{@source_app}. ===="
+        state.with_add_queue('finishedReceiveInSketchup', @stream_id, [])
+      end
+    end
+  end
+end
@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative 'action'
+require_relative '../accounts/accounts'
+require_relative 'load_saved_streams'
+
+module SpeckleConnector
+  module Actions
+    # Action to reload accounts from database.
+    class ReloadAccounts < Action
+      # @param state [States::State] the current state of the {App::SpeckleConnectorApp}
+      # @return [States::State] the new updated state object
+      def self.update_state(state, _data)
+        puts 'Reload of Speckle accounts requested by plugin'
+        new_speckle_state = state.speckle_state.with_accounts(Accounts.load_accounts)
+        state = state.with_speckle_state(new_speckle_state)
+        accounts_data = state.speckle_state.accounts
+        state.with_add_queue('loadAccounts', accounts_data.to_json, [])
+      end
+    end
+  end
+end
@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative 'action'
+require_relative '../accounts/accounts'
+require_relative '../convertors/units'
+require_relative '../convertors/converter'
+
+module SpeckleConnector
+  module Actions
+    # Action to remove stream.
+    # Currently it is not a state changer.
+    class RemoveStream < Action
+      def initialize(stream_id)
+        super()
+        @stream_id = stream_id
+      end
+
+      # @param state [States::State] the current state of the {App::SpeckleConnectorApp}
+      # @return [States::State] the new updated state object
+      def update_state(state)
+        speckle_dict = state.sketchup_state.sketchup_model.attribute_dictionary('Speckle', true)
+        saved = speckle_dict['saved_streams'] || []
+        saved -= [@stream_id]
+        speckle_dict['saved_streams'] = saved
+        state
+      end
+    end
+  end
+end
@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative 'action'
+require_relative '../accounts/accounts'
+
+module SpeckleConnector
+  module Actions
+    # Save stream.
+    # Currently it is not a state changer.
+    class SaveStream < Action
+      def initialize(stream_id)
+        super()
+        @stream_id = stream_id
+      end
+
+      # @param state [States::State] the current state of the {App::SpeckleConnectorApp}
+      # @return [States::State] the new updated state object
+      def update_state(state)
+        speckle_dict = state.sketchup_state.sketchup_model.attribute_dictionary('Speckle', true)
+        saved = speckle_dict['saved_streams'] || []
+        saved = saved.empty? ? [@stream_id] : saved.unshift(@stream_id)
+        speckle_dict['saved_streams'] = saved
+        state
+      end
+    end
+  end
+end
@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative 'action'
+require_relative 'events/selection_event_action'
+require_relative '../sketchup_model/dictionary/speckle_schema_dictionary_handler'
+
+module SpeckleConnector
+  module Actions
+    # Select entities that selected from mapped elements table.
+    class SelectMappingsFromTable < Action
+      # @param state [States::State] the current state of the {App::SpeckleConnectorApp}
+      # @return [States::State] the new updated state object
+      def self.update_state(state, data)
+        # Clear first selection
+        state.sketchup_state.sketchup_model.selection.clear
+
+        # Flat entities to clear mappings
+        flat_entities = SketchupModel::Query::Entity.flat_entities(state.sketchup_state.sketchup_model.entities)
+
+        # Collect entity ids to clear mappings
+        entity_ids = data.collect { |_, entities| entities['selectedElements'].collect { |e| e['entityId'] } }.flatten
+
+        # Store speckle state to update with mapped entities.
+        flat_entities.each do |entity|
+          next unless entity_ids.include?(entity.persistent_id)
+
+          if entity.is_a?(Sketchup::ComponentDefinition)
+            state.sketchup_state.sketchup_model.selection.add(entity.instances)
+          end
+          state.sketchup_state.sketchup_model.selection.add(entity)
+        end
+
+        Events::SelectionEventAction.update_state(state, { clear: true })
+      end
+    end
+  end
+end
@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative 'action'
+require_relative '../accounts/accounts'
+
+module SpeckleConnector
+  module Actions
+    # Send already converted objects from queue if exist on stream.
+    class SendFromQueue < Action
+      def initialize(stream_id)
+        super()
+        @stream_id = stream_id
+      end
+
+      # @param state [States::State] the current state of the {App::SpeckleConnectorApp}
+      # @return [States::State] the new updated state object
+      def update_state(state)
+        to_send_stream_id = state.speckle_state.stream_queue[:stream_id]
+        return state if to_send_stream_id == @stream_id || to_send_stream_id.nil?
+
+        to_send_converted = state.speckle_state.stream_queue[:converted].to_json
+        new_state = state.with_add_queue('convertedFromSketchup', to_send_stream_id, [to_send_converted])
+        new_state.with_empty_stream_queue
+      end
+    end
+  end
+end
@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative 'action'
+require_relative 'deactivate_diffing'
+require_relative '../convertors/units'
+require_relative '../convertors/to_speckle'
+
+module SpeckleConnector
+  module Actions
+    # Send selection to server.
+    class SendSelection < Action
+      def initialize(stream_id)
+        super()
+        @stream_id = stream_id
+      end
+
+      # @param state [States::State] the current state of the {App::SpeckleConnectorApp}
+      # @return [States::State] the new updated state object
+      def update_state(state)
+        state = DeactivateDiffing.update_state(state, {})
+        converter = Converters::ToSpeckle.new(state, @stream_id)
+        new_speckle_state, base = converter.convert_selection_to_base(state.user_state.preferences)
+        id, total_children_count, batches, new_speckle_state = converter.serialize(base, new_speckle_state,
+                                                                                   state.user_state.preferences)
+        puts("converted #{base.count} objects for stream #{@stream_id}")
+
+        # This is the place we can send information to UI for diffing check
+        diffing = state.user_state.preferences[:user][:diffing]
+        new_speckle_state = new_speckle_state.with_invalid_streams_queue if diffing
+
+        new_state = state.with_speckle_state(new_speckle_state)
+        new_state.with_add_queue('convertedFromSketchup', @stream_id, [
+                                   { is_string: false, val: batches },
+                                   { is_string: true, val: id },
+                                   { is_string: false, val: total_children_count }
+                                 ])
+      end
+    end
+  end
+end
@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative 'action'
+
+module SpeckleConnector
+  module Actions
+    # Show all entities on the model.
+    class ShowAllEntities < Action
+      # @param state [States::State] the current state of the {App::SpeckleConnectorApp}
+      # @return [States::State] the new updated state object
+      def self.update_state(state, _data)
+        # Show all entities first
+        state.sketchup_state.sketchup_model.entities.each do |ent|
+          ent.hidden = false
+        end
+        state
+      end
+    end
+  end
+end
@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require_relative 'action'
+require_relative '../ext/sqlite3'
+require_relative '../accounts/accounts'
+require_relative '../constants/path_constants'
+
+module SpeckleConnector
+  module Actions
+    # When preference updated by UI.
+    class UserPreferencesUpdated < Action
+      def initialize(pref_hash, pref, value)
+        super()
+        @preference_hash = pref_hash
+        @preference = pref
+        @value = value
+      end
+
+      # @param state [States::State] the current state of the {App::SpeckleConnectorApp}
+      # @return [States::State] the new updated state object
+      # rubocop:disable Metrics/AbcSize
+      # rubocop:disable Metrics/MethodLength
+      def update_state(state)
+        # Init sqlite database
+        db = Sqlite3::Database.new(SPECKLE_CONFIG_DB_PATH)
+
+        # Select data
+        data = db.exec("SELECT content FROM 'objects' WHERE hash = '#{@preference_hash}'").first.first
+
+        # Parse string to hash
+        data_hash = JSON.parse(data).to_h
+
+        # Get current preference value
+        old_preference_value = data_hash[@preference]
+
+        # Return old state if it is equal to new one
+        return state if @value == old_preference_value
+
+        data_hash[@preference] = @value
+
+        # Update entry unless equal old to new
+        db.exec("UPDATE 'objects' SET content = '#{data_hash.to_json}' WHERE hash = '#{@preference_hash}'")
+
+        # Close db when process done
+        db.close
+
+        user = state.user_state.preferences[:user].dup
+        user[@preference.to_sym] = @value
+        new_preferences = state.user_state.preferences.put(:user, user)
+        new_user_state = state.user_state.with_preferences(new_preferences)
+        # This is the place we can send information to UI for diffing check. It is a technical depth!
+        if @preference == 'diffing'
+          new_speckle_state = if @value
+                                state.speckle_state.with_invalid_streams_queue
+                              else
+                                state.speckle_state.with_empty_invalid_streams_queue
+                              end
+          state = state.with_speckle_state(new_speckle_state)
+        end
+        state.with_user_state(new_user_state)
+      end
+      # rubocop:enable Metrics/AbcSize
+      # rubocop:enable Metrics/MethodLength
+    end
+  end
+end
@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require_relative '../actions/clear_queue'
+
+module SpeckleConnector
+  module App
+    # Application for the Speckle Connector.
+    class SpeckleConnectorApp
+      # @return [Commands::MenuCommandHandler] the commands registered in the extension menu in Sketchup
+      attr_reader :menu_commands
+
+      # @return [States::State] the current states of the app
+      attr_reader :state
+
+      # @return [Ui::UiController] controller for ui views
+      attr_reader :ui_controller
+
+      # @return [Observers::Handler] the observers indexed by their classes to handle
+      attr_reader :observer_handler
+
+      def initialize(menu_commands, state, ui_controller)
+        @menu_commands = menu_commands
+        @state = state
+        @ui_controller = ui_controller
+      end
+
+      def speckle_loaded?
+        state.speckle_state?
+      end
+
+      def update_ui!
+        ui_controller.update_ui(state)
+      end
+
+      # Attach observers to application when speckle initialized via menu commands.
+      def add_observer_handler!(observer_handler)
+        @observer_handler = observer_handler
+      end
+
+      # Send messages to HtmlDialog if any.
+      def send_messages!
+        queue = @state.speckle_state.message_queue
+        queue.each_value { |value| ui_controller.user_interfaces[Ui::SPECKLE_UI_ID].dialog.execute_script(value) }
+        update_state!(Actions::ClearQueue)
+      end
+
+      # This is the only function application state will be switched by calling upcoming action with it's parameters
+      #  if any.
+      def update_state!(action, *parameters)
+        old_state = @state
+        @state = action.update_state(old_state, *parameters)
+        send_messages! if @state.speckle_state.message_queue.any?
+        update_ui! unless @state.equal?(old_state)
+      end
+    end
+  end
+end
@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module SpeckleConnector
+  module Callbacks
+    # Helper class to serialize messages to send dialog.
+    class CallbackMessage
+      # @param callback_name [String] name of the callback command
+      # @param stream_id [String] id of the stream
+      # @param parameters [Array<String>] parameters of the callback method call
+      def self.serialize(callback_name, stream_id, parameters)
+        if parameters.any?
+          serialize_with_parameters(callback_name, stream_id, parameters)
+        else
+          serialize_without_parameters(callback_name, stream_id)
+        end
+      end
+
+      # @param callback_name [String] name of the callback command
+      # @param stream_id [String] id of the stream
+      # @param parameters [Array<Object>] parameters of the callback method call
+      def self.serialize_with_parameters(callback_name, stream_id, parameters)
+        message = "#{callback_name}('#{stream_id}'"
+        parameters.each { |par| message += par[:is_string] ? ",'#{par[:val]}'" : ",#{par[:val]}" }
+        message += ')'
+        message
+      end
+
+      # @param callback_name [String] name of the callback command
+      # @param stream_id [String] id of the stream
+      def self.serialize_without_parameters(callback_name, stream_id)
+        if %w[setSavedStreams loadAccounts].include?(callback_name)
+          "#{callback_name}(#{stream_id})"
+        else
+          "#{callback_name}('#{stream_id}')"
+        end
+      end
+    end
+  end
+end
@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative 'command'
+
+module SpeckleConnector
+  module Commands
+    # Command to update state of the application.
+    class ActionCommand < Command
+      # @param app [App::SpeckleConnectorApp] the app object to run command on
+      # @param action [#update_state] the action that knows how to change the state of the speckle app
+      def initialize(app, action)
+        super(app)
+        @app = app
+        @action = action
+      end
+
+      private
+
+      def _run(*parameters)
+        app.update_state!(@action, *parameters)
+      end
+    end
+  end
+end
@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative 'command'
+require_relative '../actions/activate_diffing'
+
+module SpeckleConnector
+  module Commands
+    # Command to activate diffing for stream.
+    class ActivateDiffing < Command
+      def _run(data)
+        stream_id = data['stream_id']
+        action = Actions::ActivateDiffing.new(stream_id)
+        app.update_state!(action)
+      end
+    end
+  end
+end
@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative 'command'
+require_relative '../actions/apply_mappings'
+
+module SpeckleConnector
+  module Commands
+    # Command to apply mapping for selected entities.
+    class ApplyMappings < Command
+      def _run(data)
+        entities_to_map = data['entitiesToMap']
+        method = data['method']
+        category = data['category']
+        family = data['family']
+        family_type = data['familyType']
+        level = data['level']
+        name = data['name']
+        is_definition = data['isDefinition']
+        action = Actions::ApplyMappings.new(entities_to_map, method, category, family,
+                                            family_type, level, name, is_definition)
+        app.update_state!(action)
+      end
+    end
+  end
+end
@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require_relative 'command'
+require_relative '../actions/clear_mappings'
+
+module SpeckleConnector
+  module Commands
+    # Command to clear mapping for selected entities.
+    class ClearMappings < Command
+      def _run(data)
+        entities_to_map = data['entitiesToClearMap']
+        is_definition = data['isDefinition']
+        action = Actions::ClearMappings.new(entities_to_map, is_definition)
+        app.update_state!(action)
+      end
+    end
+  end
+end
@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module SpeckleConnector
+  module Commands
+    # Base command schema to wrap common operations for all commands.
+    class Command
+      # @return [App::SpeckleConnectorApp] the main app object
+      attr_reader :app
+
+      # @return [Ui::View] view object holds dialog and it's state
+      attr_reader :view
+
+      # @@param app [App::SpeckleConnectorApp] the main app object
+      def initialize(app)
+        @app = app
+        @view = app.ui_controller.user_interfaces[Ui::SPECKLE_UI_ID]
+      end
+
+      def run(*parameters)
+        # Run here common operations that same for each command.
+        with_observers_disabled do
+          _run(*parameters)
+        end
+      end
+
+      private
+
+      def with_observers_disabled(&block)
+        observer_handler = @app.observer_handler
+        if observer_handler
+          observer_handler.with_observers_disabled(&block)
+        else
+          block.call
+        end
+      end
+
+      def _run(*_parameters)
+        raise NotImplementedError, 'Implement in subclass'
+      end
+    end
+  end
+end
@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require_relative 'command'
+
+module SpeckleConnector
+  module Commands
+    # Run this command when the UI is ready to get data
+    class DialogReady < Command
+      # Update the selected user interface
+      def _run(_data)
+        view.update_view(app.state)
+      end
+    end
+  end
+end
@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require_relative 'command'
+require_relative '../states/initial_state'
+require_relative '../ui/vue_view'
+require_relative '../actions/initialize_speckle'
+require_relative '../observers/factory'
+
+module SpeckleConnector
+  module Commands
+    # Command to initialize Speckle UI and register it to ui_controller.
+    # This is the command where we show UI to user.
+    class InitializeSpeckle < Command
+      def dialog_title
+        "Speckle (Legacy) #{CONNECTOR_VERSION}"
+      end
+
+      private
+
+      def _run
+        app = self.app
+        unless app.state.instance_of?(States::InitialState)
+          vue_view = app.ui_controller.user_interfaces[Ui::SPECKLE_UI_ID]
+          vue_view.show
+          return
+        end
+
+        initialize_speckle(app)
+      end
+
+      # Do the actual Speckle initialization.
+      def initialize_speckle(app)
+        # TODO: Initialize here speckle states and observers.
+        observer_handler = Observers::Factory.create_handler(app)
+        app.add_observer_handler!(observer_handler)
+        observers = Observers::Factory.create_observers(observer_handler)
+        app.update_state!(Actions::InitializeSpeckle, observers)
+        dialog_specs = {
+          dialog_id: Ui::SPECKLE_UI_ID,
+          htm_file: Ui::VUE_UI_HTML,
+          dialog_title: dialog_title,
+          height: 950,
+          width: 300
+        }
+        vue_view = Ui::VueView.new(dialog_specs, app)
+        app.ui_controller.register_ui(Ui::SPECKLE_UI_ID, vue_view)
+        vue_view.show
+      end
+    end
+  end
+end
--- a/Show More
+++ b/Show More