Merge pull request #270 from specklesystems/oguzhan/hash-only-hostname-of-server-url

- Clear, Isolate, Hide, Select

.circleci/config.yml

@@ -9,22 +9,19 @@ 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:
@@ -39,20 +36,41 @@ jobs:
       - attach_workspace:
           at: ./
       - run:
-          name: Patch
+          name: Create Innosetup signing cert
           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
+          command: |
+            echo $env:PFX_B64 > "speckle-sharp-ci-tools\SignTool\AEC Systems Ltd.txt"
+            certutil -decode "speckle-sharp-ci-tools\SignTool\AEC Systems Ltd.txt" "speckle-sharp-ci-tools\SignTool\AEC Systems Ltd.pfx"
+      - 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 >>
+      - 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
+
+      #- 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.0" } else { $env:CIRCLE_TAG }
+      #      $semver = if($tag.Contains('/')) {$tag.Split("/")[1] } else { $tag }
+      #      $ver = if($semver.Contains('-')) {$semver.Split("-")[0] } else { $semver }
+      #      $channel = if($semver.Contains('-')) {$semver.Split("-")[1] } else { "latest" }
+      #      $version = "$($ver).$($env:CIRCLE_BUILD_NUM)"
+      #      New-Item -Force "speckle-sharp-ci-tools/Installers/sketchup/$channel.yml" -ItemType File -Value "version: $semver"
+      #      echo $version
+      #      python patch_version.py $semver
+      #      speckle-sharp-ci-tools\InnoSetup\ISCC.exe speckle-sharp-ci-tools\sketchup.iss
       - persist_to_workspace:
           root: ./
           paths:
@@ -62,9 +80,17 @@ jobs:
     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
+          command: git clone git@github.com:specklesystems/speckle-sharp-ci-tools.git speckle-sharp-ci-tools
       - persist_to_workspace:
           root: ./
           paths:
@@ -73,23 +99,29 @@ jobs:
           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 +144,19 @@ workflows:
           filters:
             tags:
               only: /.*/
+          context: innosetup
 
-      - deploy:
+      - deploy-manager2:
+          context: do-spaces-speckle-releases
+          slug: sketchup
+          os: Win
+          extension: exe
           requires:
             - get-ci-tools
             - build-ui
             - build-connector
           filters:
             tags:
-              only: /[0-9]+(\.[0-9]+)*/
+              only: /([0-9]+)\.([0-9]+)\.([0-9]+)(?:-\w+)?$/
             branches:
               ignore: /.*/ # For testing only! /ci\/.*/

.github/workflows/ruby.yml

@@ -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

.gitignore

@@ -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
 

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "_sqlite3"]
+	path = _sqlite3
+	url = git@github.com:specklesystems/sketchup-sqlite3.git

.rubocop.yml

@@ -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

.vscode/tasks.json

@@ -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": []
+    },
   ]
 }

Gemfile

@@ -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"

Gemfile.lock

@@ -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

README.md

@@ -41,27 +41,42 @@ Give Speckle a try in no time by:
 - [![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`).
 
-You'll need to serve the ui before launching the connector:
+## Contribution Guide
 
-    cd ui
-    npm install
-    npm run serve
+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 +92,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 +168,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 
+   ```

Rakefile

@@ -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

_tools/README.md

@@ -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. 

_tools/jf_RubyPanel.rb

@@ -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)

_tools/jf_RubyPanel/rubytoolbar.rb

@@ -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

_tools/speckle_connector_loader.rb

@@ -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

_tools/su_attributes.rb

@@ -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__)
+
+#-------------------------------------------------------------------------------

_tools/su_attributes/core.rb

@@ -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

_tools/su_attributes/extension_info.txt

@@ -0,0 +1,2 @@
+ID=f4d9d053-4479-4a9a-90da-b79fa16e28c4
+VERSION_ID=b787af5e-8e8e-4932-92ef-a3c99681795d

bin/console

@@ -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__)

bin/setup

@@ -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

lib/speckle_connector.rb

@@ -1,8 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "speckle_connector/version"
-
-module SpeckleConnector
-  class Error < StandardError; end
-  # Your code goes here...
-end

lib/speckle_connector/version.rb

@@ -1,5 +0,0 @@
-# frozen_string_literal: true
-
-module SpeckleConnector
-  VERSION = "0.1.0"
-end

patch_version.py

@@ -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}")

scratch.rb

@@ -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)

speckle_connector.rb

@@ -1,45 +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
-    puts("Loading Speckle Connector v#{CONNECTOR_VERSION} from #{DEV_MODE ? 'dev' : 'build'}")
+  # Path to the root .rb file (this file).
+  PATH_ROOT = File.dirname(file).freeze
 
+  # Path to the support folder.
+  PATH = File.join(PATH_ROOT, folder_name).freeze
 
-    unless file_loaded?(__FILE__)
+  # Run from localhost or from build files
+  DEV_MODE = false
+  puts("Loading Speckle Connector v#{CONNECTOR_VERSION} from #{DEV_MODE ? 'dev' : 'build'}")
 
-      ex = SketchupExtension.new("Speckle SketchUp", File.join(PATH, "main"))
+  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.description = "Speckle Connector for SketchUp"
-
-      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

speckle_connector/accounts.rb

@@ -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

speckle_connector/bootstrap.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require 'sketchup'
+require 'pathname'
+require 'speckle_connector/debug'
+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

speckle_connector/converter/converter_sketchup.rb

@@ -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

speckle_connector/converter/to_native.rb

@@ -1,164 +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 unless key.start_with?("_") }
-      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) }
-    puts("definition finished: #{block_def["name"]} (#{block_def["id"]})")
-    puts("    entity count: #{definition.entities.count}")
-    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?
-    if instance.nil?
-      p(definition.name)
-      p(definition.entities.to_a)
-    end
-    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

speckle_connector/converter/to_speckle.rb

@@ -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

speckle_connector/debug.rb

@@ -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

speckle_connector/dialog.rb

@@ -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
-      if DEV_MODE
-        puts('Launching Speckle Connector from http://localhost:8081')
-        @dialog.set_url("http://localhost:8081")
-      else
-        html_file = File.join(File.dirname(File.expand_path(__FILE__)), "html", "index.html")
-        puts("Launching Speckle Connector from #{html_file}")
-        @dialog.set_file(html_file)
-      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

speckle_connector/main.rb

@@ -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

speckle_connector/src/accounts/accounts.rb

@@ -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

speckle_connector/src/actions/action.rb

@@ -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

speckle_connector/src/actions/activate_diffing.rb

@@ -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

speckle_connector/src/actions/add_material.rb

@@ -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

speckle_connector/src/actions/apply_mappings.rb

@@ -0,0 +1,66 @@
+# 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, name, is_definition)
+        super()
+        @entities_to_map = entities_to_map
+        @method = method
+        @category = category
+        @name = name
+        @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)
+          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

speckle_connector/src/actions/clear_mappings.rb

@@ -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

speckle_connector/src/actions/clear_mappings_from_table.rb

@@ -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

speckle_connector/src/actions/clear_queue.rb

@@ -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

speckle_connector/src/actions/collect_preferences.rb

@@ -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

speckle_connector/src/actions/collect_versions.rb

@@ -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

speckle_connector/src/actions/connected.rb

@@ -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

speckle_connector/src/actions/create_stream.rb

@@ -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

speckle_connector/src/actions/deactivate_diffing.rb

@@ -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

speckle_connector/src/actions/events/app_event_action.rb

@@ -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

speckle_connector/src/actions/events/entities_event_action.rb

@@ -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

speckle_connector/src/actions/events/event_action.rb

@@ -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

speckle_connector/src/actions/events/model_event_action.rb

@@ -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

speckle_connector/src/actions/events/selection_event_action.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative 'event_action'
+require_relative '../../mapping/category/revit_category'
+require_relative '../../sketchup_model/reader/speckle_entities_reader'
+require_relative '../../sketchup_model/query/entity'
+
+module SpeckleConnector
+  module Actions
+    module Events
+      # Update selected speckle objects when the selection changes for mapping 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?
+
+          sketchup_selection = state.sketchup_state.sketchup_model.selection
+          selection = {
+            selection: SketchupModel::Reader::SpeckleEntitiesReader.entities_schema_details(sketchup_selection),
+            mappingMethods: [
+              'Direct Shape'
+            ],
+            categories: Mapping::Category::RevitCategory.to_a
+          }
+          selection = { selection: [], mappingMethods: [], categories: [] } if sketchup_selection.none?
+
+          state.with_selection_queue(selection)
+        end
+      end
+    end
+  end
+end

speckle_connector/src/actions/hide_mappings_from_table.rb

@@ -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

speckle_connector/src/actions/init_local_accounts.rb

@@ -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

speckle_connector/src/actions/initialize_materials.rb

@@ -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

speckle_connector/src/actions/initialize_speckle.rb

@@ -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

speckle_connector/src/actions/isolate_mappings_from_table.rb

@@ -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

speckle_connector/src/actions/load_saved_streams.rb

@@ -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

speckle_connector/src/actions/load_sketchup_model.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require_relative 'action'
+require_relative 'initialize_materials'
+require_relative '../sketchup_model/reader/speckle_entities_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::SpeckleEntitiesReader.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

speckle_connector/src/actions/mapped_entities_updated.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative 'action'
+require_relative '../sketchup_model/reader/speckle_entities_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::SpeckleEntitiesReader
+                          .mapped_entity_details(state.speckle_state.mapped_entities.values.to_a)
+
+        state.with_mapped_entities_queue(mapped_entities)
+      end
+    end
+  end
+end

speckle_connector/src/actions/model_preference_updated.rb

@@ -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

speckle_connector/src/actions/on_events_action.rb

@@ -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

speckle_connector/src/actions/one_click_send.rb

@@ -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

speckle_connector/src/actions/queue_send.rb

@@ -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

speckle_connector/src/actions/receive_objects.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative 'action'
+require_relative '../convertors/units'
+require_relative '../convertors/to_native'
+
+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 = converter.receive_commit_object(@base)
+        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

speckle_connector/src/actions/reload_accounts.rb

@@ -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

speckle_connector/src/actions/remove_stream.rb

@@ -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

speckle_connector/src/actions/save_stream.rb

@@ -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

speckle_connector/src/actions/select_mappings_from_table.rb

@@ -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

speckle_connector/src/actions/send_from_queue.rb

@@ -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

speckle_connector/src/actions/send_selection.rb

@@ -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

speckle_connector/src/actions/show_all_entities.rb

@@ -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

speckle_connector/src/actions/user_preferences_updated.rb

@@ -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

speckle_connector/src/app/speckle_connector_app.rb

@@ -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

speckle_connector/src/callbacks/callback_message.rb

@@ -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

speckle_connector/src/commands/action_command.rb

@@ -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

speckle_connector/src/commands/activate_diffing.rb

@@ -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

speckle_connector/src/commands/apply_mappings.rb

@@ -0,0 +1,21 @@
+# 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']
+        name = data['name']
+        is_definition = data['isDefinition']
+        action = Actions::ApplyMappings.new(entities_to_map, method, category, name, is_definition)
+        app.update_state!(action)
+      end
+    end
+  end
+end

speckle_connector/src/commands/clear_mappings.rb

@@ -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

speckle_connector/src/commands/command.rb

@@ -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

speckle_connector/src/commands/dialog_ready.rb

@@ -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

speckle_connector/src/commands/initialize_speckle.rb

@@ -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 #{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

speckle_connector/src/commands/menu_command_handler.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module SpeckleConnector
+  module Commands
+    # Helper class to register, handle menu and toolbar commands.
+    class MenuCommandHandler
+      # @param command [#run] command that can be run
+      # @param menu_text [String] name of the command that will be displayed on the menu
+      # @return [UI::Command] the command that can be added to Sketchup menu or toolbar
+      def self.sketchup_command(command, menu_text)
+        UI::Command.new(menu_text) do
+          command.run
+        end
+      end
+
+      # Validate if the user has started the Speckle and return a status code that can be used by
+      # {UI::Command#set_validation_proc} to disable menu entries and toolbar entries before Speckle is loaded.
+      def self.speckle_started(app)
+        return MF_ENABLED if app.speckle_loaded?
+
+        MF_GRAYED
+      end
+
+      def initialize
+        @menu_commands = {}
+        @added_to_menu = []
+        @added_to_toolbar = []
+      end
+
+      def []=(command_id, command)
+        @menu_commands[command_id] = command
+      end
+
+      # Add command to menu.
+      def add_to_menu!(command_id, menu)
+        return if @added_to_menu.include? command_id
+
+        menu.add_item(@menu_commands[command_id])
+        @added_to_menu << command_id
+      end
+
+      # Add command to toolbar.
+      def add_to_toolbar!(command_id, toolbar)
+        return if @added_to_toolbar.include? command_id
+
+        toolbar.add_item(@menu_commands[command_id])
+        @added_to_toolbar << command_id
+      end
+    end
+  end
+end

speckle_connector/src/commands/model_preferences_updated.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require_relative 'command'
+require_relative '../accounts/accounts'
+require_relative '../actions/model_preference_updated'
+
+module SpeckleConnector
+  module Commands
+    # Command to update theme.
+    class ModelPreferencesUpdated < Command
+      def _run(data)
+        preference = data['preference']
+        new_value = data['value']
+        app.update_state!(Actions::ModelPreferencesUpdated.new(preference, new_value))
+      end
+    end
+  end
+end

speckle_connector/src/commands/notify_connected.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require_relative 'command'
+require_relative '../actions/connected'
+require_relative '../actions/send_from_queue'
+
+module SpeckleConnector
+  module Commands
+    # Command to notify connected.
+    class NotifyConnected < Command
+      def _run(data)
+        stream_id = data['stream_id']
+        app.update_state!(Actions::Connected)
+        app.update_state!(Actions::SendFromQueue.new(stream_id))
+      end
+    end
+  end
+end

speckle_connector/src/commands/receive_objects.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative 'command'
+require_relative '../actions/receive_objects'
+
+module SpeckleConnector
+  module Commands
+    # Command to receive objects from Speckle Server.
+    class ReceiveObjects < Command
+      def _run(data)
+        stream_id = data['stream_id']
+        base = data['base']
+        branch_name = data['branch_name']
+        branch_id = data['branch_id']
+        stream_name = data['stream_name']
+        source_app = data['source_app']
+        action = Actions::ReceiveObjects.new(stream_id, base, stream_name, branch_name, branch_id, source_app)
+        app.update_state!(action)
+      end
+    end
+  end
+end