crimson 0.1.0

data/lib/crimson/mash.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require 'hashie'
+
+module Crimson
+  class Mash < Hashie::Mash
+    disable_warnings :display, :drop
+  end
+end

data/lib/crimson/model.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require 'hashie'
+require_relative 'model_change'
+require_relative 'utilities'
+require_relative 'mash'
+
+module Crimson
+  class Model < SimpleDelegator
+    attr_reader :observers, :revisions, :local, :revision_number
+
+    def initialize
+      @observers = {}
+      @revisions = [Mash.new]
+      @revision_number = 1
+      @max_number_of_revisions = 2
+      @local = Mash.new
+
+      super(local)
+    end
+
+    def add_observer(observer, handler = :on_commit)
+      observers[observer] = observer.method(handler)
+    end
+
+    def remove_observer(observer)
+      observers.delete(observer)
+    end
+
+    def notify_observers(changes)
+      observers.each { |_observer, handler| handler.call(self, changes) }
+    end
+
+    def modify(modifications = {})
+      local.merge(modifications)
+    end
+
+    def changed?(*keys)
+      if keys.empty?
+        local != master
+      else
+        keys.map { |key| local[key] != master[key] }.any?(true)
+      end
+    end
+
+    def changes(*keys)
+      keys = ( master.keys | local.keys ) if keys.empty?
+      diff = Mash.new
+
+      keys.each do |k|
+        v1 = master[k]
+        v2 = local[k]
+        diff[k] = ModelChange.new(v1, v2) if v1 != v2
+      end
+
+      diff
+    end
+
+    def new_changes(*keys)
+      changes(*keys).transform_values(&:new_value)
+    end
+
+    def master
+      revisions.last
+    end
+
+    def commit!(*keys)
+      if changed?(*keys)
+        notify_observers(new_changes(*keys))
+        apply_changes!(*keys)
+      end
+    end
+
+    def apply_changes!(*keys)
+      if keys.empty?
+        revisions << Utilities.deep_copy(local)
+      else
+        revisions << Utilities.deep_copy(master)
+        keys.each { |key| master[key] = Utilities.deep_copy(local[key]) }
+      end
+
+      @revision_number += 1
+      revisions.shift if revisions.length > @max_number_of_revisions
+    end
+
+    def reload!
+      @local = Utilities.deep_copy(master)
+    end
+
+    def rollback!
+      if revisions.length > 1
+        @local = revisions.pop
+      else
+        reload!
+      end
+    end
+  end
+end

data/lib/crimson/model_change.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Crimson
+  class ModelChange
+    attr_reader :old_value, :new_value
+
+    def initialize(old_value, new_value)
+      @old_value = old_value
+      @new_value = new_value
+    end
+
+    def inspect
+      to_s
+    end
+
+    def to_s
+      return "<#{old_value.inspect}, #{new_value.inspect}>"
+    end
+  end
+end

data/lib/crimson/notification_bus.rb

@@ -0,0 +1,35 @@
+
+require 'hashie'
+require_relative 'object'
+
+module Crimson
+  class NotificationBus
+    attr_reader :notification_handlers
+
+    def initialize
+      @notification_handlers = Hashie::Mash.new
+    end
+
+    def register(object)
+      raise ArgumentError unless object.is_a?(Crimson::Object)
+      raise ArgumentError if notification_handlers.key?(object.id)
+
+      notification_handlers[object.id] = object.method(:on_event)
+    end
+
+    def unregister(object)
+      raise ArgumentError unless object.is_a?(Crimson::Object)
+      raise ArgumentError unless notification_handlers.key?(object.id)
+
+      notification_handlers.delete(object.id)
+    end
+
+    def notify(message)
+      unless notification_handlers.key?(message.id)
+        raise ArgumentError, "[NotificationBus] Trying to notify unregistered '#{message.id}'."
+      end
+
+      notification_handlers[message.id].call(message)
+    end
+  end
+end

data/lib/crimson/object.rb

@@ -0,0 +1,196 @@
+# frozen_string_literal: true
+
+require 'tree'
+require 'set'
+require_relative 'model'
+require_relative 'utilities'
+require_relative 'mash'
+
+module Crimson
+  class Object < Model
+    attr_reader :id, :tag, :node, :event_handlers, :added_children, :removed_children
+
+    def initialize(tag)
+      super()
+
+      @id = :"object_#{Utilities.generate_id}"
+      @tag = tag.to_sym
+      @node = Tree::TreeNode.new(id, self)
+      @event_handlers = Mash.new
+
+      @added_children = Set.new
+      @removed_children = Set.new
+
+      self.style = Mash.new
+
+      show
+    end
+
+    def hidden?
+      style.display.to_sym == :none
+    end
+
+    def shown?
+      !hidden?
+    end
+
+    def hide
+      style.display = :none
+    end
+
+    def show
+      style.display = :block
+    end
+
+    def on_event(message)
+      unless event_handlers.key?(message.event)
+        raise ArgumentError, "[Object] Trying to handle unknown event '#{message.event}' for '#{id}'."
+      end
+
+      event_handlers[message.event].each { |functor| functor.call(message.data) }
+    end
+
+    def on(event, handler = nil, &block)
+      raise ArgumentError unless handler.nil? || handler.is_a?(Method) || handler.is_a?(Proc)
+
+      event_handlers[event] = [] unless event_handlers[event]
+      event_handlers[event] << handler unless handler.nil?
+      event_handlers[event] << block if block_given?
+
+      self[:events] = event_handlers.keys
+      commit!(:events)
+    end
+
+    def un(event, handler = nil)
+      raise ArgumentError unless event_handlers.key?(event)
+      
+      event_handlers[event].delete(handler) if handler
+
+      if event_handlers[event].empty? || handler.nil?
+        event_handlers.delete(event)
+      end
+
+      self[:events] = event_handlers.keys
+      commit!(:events)
+    end
+
+    def parent
+      node.parent&.content
+    end
+
+    def parent=(new_parent)
+      raise ArgumentError unless new_parent.nil? || new_parent.is_a?(Crimson::Object)
+
+      parent&.remove(self)
+      new_parent&.add(self)
+    end
+
+    def add(child, at_index = -1)
+      raise ArgumentError unless child.is_a?(Crimson::Object)
+      raise ArgumentError if children.include?(child)
+
+      node.add(child.node, at_index)
+
+      self[:children] = children.map(&:id)
+
+      added_children << child
+    end
+
+    def remove(child)
+      raise ArgumentError unless child.is_a?(Crimson::Object)
+      raise ArgumentError unless children.include?(child)
+      
+      node.remove!(child.node)
+
+      self[:children] = children.map(&:id)
+
+      removed_children << child
+    end
+
+    def move(child, at_index)
+      raise ArgumentError unless child.is_a?(Crimson::Object)
+      raise ArgumentError unless children.include?(child)
+
+      remove(child)
+      add(child, at_index)
+
+      added_children.delete(child)
+      removed_children.delete(child)
+    end
+
+    def siblings
+      node.siblings.map(&:content)
+    end
+
+    def children
+      node.children.map(&:content)
+    end
+
+    def root
+      node.root.content
+    end
+
+    def commit_tree!(*keys)
+      # TODO: Unsure if this algorithm works for moved objects
+      # eg. added, removed, then added again, under the same commit.
+
+      breadth_each do |object|
+        observers.keys.each do |observer|
+          object.added_children.each do |child|
+            observer.observe(child)
+          end
+
+          object.removed_children.each do |child|
+            observer.unobserve(child)
+          end
+        end
+
+        object.added_children.clear
+        object.removed_children.clear
+        object.commit!(*keys)
+      end
+    end
+
+    def breadth_each
+      node.breadth_each do |subnode|
+        yield(subnode.content)
+      end
+    end
+
+    def postordered_each
+      node.postordered_each do |subnode|
+        yield(subnode.content)
+      end
+    end
+
+    def preordered_each
+      node.preordered_each do |subnode|
+        yield(subnode.content)
+      end
+    end
+
+    def find_descendant(descendent_id)
+      breadth_each { |descendent| return descendent if descendent_id == descendent.id }
+    end
+
+    def inspect
+      to_s
+    end
+
+    def to_s
+      id.to_s
+    end
+
+    def ==(other)
+      other.is_a?(Object) && other.id == id
+    end
+
+    def eql?(other)
+      self == other
+    end
+
+    def hash
+      id.hash
+    end
+  end
+end

data/lib/crimson/server.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require 'thin'
+require 'websocket-eventmachine-server'
+require_relative 'client'
+require_relative 'webserver'
+require_relative 'utilities'
+
+module Crimson
+  class Server
+    attr_reader :clients
+
+    def initialize(opts = {})
+      @opts = opts || {}
+      @clients = {}
+    end
+
+    def host
+      @opts[:host] || '0.0.0.0'
+    end
+
+    def on_connect(&block)
+      @on_connect = block if block_given?
+    end
+
+    def on_disconnect(&block)
+      @on_disconnect = block if block_given?
+    end
+
+    def port
+      @opts[:port] || 10_000
+    end
+
+    def run(websocket_enabled: true, webserver_enabled: true)
+      EM.run do
+        start_websocket if websocket_enabled
+        start_webserver if webserver_enabled
+      end
+    end
+
+    def start_webserver
+      template = File.read("#{__dir__}/../html/template.html")
+      template.sub!("{PORT}", websocket_port.to_s)
+
+      Thin::Server.start(WebServer.new(template), host, port, signals: false)
+    end
+
+    def start_websocket
+      WebSocket::EventMachine::Server.start(host: host, port: websocket_port) do |ws|
+        id = :"client_#{Utilities.generate_id}"
+        client = Client.new(id, ws)
+
+        ws.onopen {
+          clients[id] = client
+          @on_connect.call(client)
+        }
+
+        ws.onclose {
+          @on_disconnect.call(client)
+          clients.delete(id)
+        }
+      end
+    end
+
+    def websocket_port
+      port + 1
+    end
+  end
+end

data/lib/crimson/utilities.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Crimson
+  module Utilities
+    def self.generate_id
+      (Time.now.to_f * 100_000_000.0).to_i
+    end
+
+    def self.deep_copy(o)
+      Marshal.load(Marshal.dump(o))
+    end
+  end
+end