glimmer-dsl-swt 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6b7dbe91f4446b09448aa58ad33e7192060feb314ad3cb6e146c95f6aef034c4
-  data.tar.gz: 030a51954d8ed32fc128a729c7469e3c313e18615aa47caa588920dd9706c49e
+  metadata.gz: 4b54809644b379821d606ce742901ec5ce91197bfccb33ee15893d9b809ef766
+  data.tar.gz: f322c7d1c9f2a7aa9b97709739978317c727a0988dec41c397db205c544c3c7b
 SHA512:
-  metadata.gz: 3240f754fb9948de06ed1d84af8f037ca8a520aaf4d0b2d6958bf856a650ee53c13f49391e1be23566ff6f51b8792bb21e99f7bbc781c5c6c3b16b378f52193f
-  data.tar.gz: 6e7f3a1fb5614ece07eb98dd0f44cdefe011e69b1bb686bd8ff5c8b9968a96b692a5bace1b648c16d4aa7d66ac5e716127097fe6f08c6e744adfa307f42dfc33
+  metadata.gz: 54539c2fa3414d637fa6e29578e88c592f09d292c7027308ced2a8ddd84f11ed6d36ec769ec9e8c06113c3fed16c08cba4774f92b5d167e8f16867788fd7106d
+  data.tar.gz: 8f3f36715b553078f72f0fd66f635437344ba0151a1ba2665852cee9fb81658afb265d66493d0b61d42083f1ebb3c963368fc43c6f74133e4b9bf73d79fb8395

data/README.md

@@ -1,11 +1,16 @@
-# Glimmer DSL for SWT 0.1.1 (Desktop GUI)
+# <img src="https://raw.githubusercontent.com/AndyObtiva/glimmer/master/images/glimmer-logo-hi-res.png" height=105 /> Glimmer DSL for SWT 0.1.2 (Desktop GUI)
 [![Gem Version](https://badge.fury.io/rb/glimmer-dsl-swt.svg)](http://badge.fury.io/rb/glimmer-dsl-swt)
 [![Travis CI](https://travis-ci.com/AndyObtiva/glimmer-dsl-swt.svg?branch=master)](https://travis-ci.com/github/AndyObtiva/glimmer-dsl-swt)
+[![Join the chat at https://gitter.im/AndyObtiva/glimmer](https://badges.gitter.im/AndyObtiva/glimmer.svg)](https://gitter.im/AndyObtiva/glimmer?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
 
 [Glimmer](https://github.com/AndyObtiva/glimmer) DSL for SWT enables desktop development with Glimmer.
 
-You may find full setup/usage instructions at the main Glimmer project page: 
-[https://github.com/AndyObtiva/glimmer](https://github.com/AndyObtiva/glimmer)
+You may find full setup/usage instructions at the main [Glimmer project page](https://github.com/AndyObtiva/glimmer).
+
+Other Glimmer DSL gems:
+- [glimmer-dsl-opal](https://github.com/AndyObtiva/glimmer-dsl-opal): Glimmer DSL for Opal (Web GUI Adapter for Desktop Apps)
+- [glimmer-dsl-xml](https://github.com/AndyObtiva/glimmer-dsl-xml): Glimmer DSL for XML (& HTML)
+- [glimmer-dsl-css](https://github.com/AndyObtiva/glimmer-dsl-css): Glimmer DSL for CSS (Cascading Style Sheets)
 
 ## Help
 
@@ -15,11 +20,9 @@ You may submit [issues](https://github.com/AndyObtiva/glimmer/issues) on [GitHub
 
 [Click here to submit an issue.](https://github.com/AndyObtiva/glimmer/issues)
 
-### IRC Channel
-
-If you need live help, try the [#glimmer](http://widget.mibbit.com/?settings=7514b8a196f8f1de939a351245db7aa8&server=irc.mibbit.net&channel=%23glimmer) IRC channel on [irc.mibbit.net](http://widget.mibbit.com/?settings=7514b8a196f8f1de939a351245db7aa8&server=irc.mibbit.net&channel=%23glimmer). If no one was available, you may [leave a GitHub issue](https://github.com/AndyObtiva/glimmer/issues) to schedule a meetup on IRC. 
+### Chat
 
-[Click here to connect to #glimmer IRC channel immediately via a web interface.](http://widget.mibbit.com/?settings=7514b8a196f8f1de939a351245db7aa8&server=irc.mibbit.net&channel=%23glimmer)
+If you need live help, try to [![Join the chat at https://gitter.im/AndyObtiva/glimmer](https://badges.gitter.im/AndyObtiva/glimmer.svg)](https://gitter.im/AndyObtiva/glimmer?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
 
 ## Feature Suggestions
 

data/VERSION

@@ -1 +1 @@
-0.1.1
+0.1.2

data/lib/glimmer/data_binding/widget_binding.rb

@@ -1,6 +1,5 @@
-require 'glimmer'
-require_relative 'observable'
-require_relative 'observer'
+require 'glimmer/data_binding/observable'
+require 'glimmer/data_binding/observer'
 
 module Glimmer
   module DataBinding
@@ -10,10 +9,10 @@ module Glimmer
       include Observer
 
       attr_reader :widget, :property
-      def initialize(model, property, translator = nil)
-        @widget = model
+      def initialize(widget, property, translator = nil)
+        @widget = widget
         @property = property
-        @translator = translator || proc {|value| value}
+        @translator = translator || proc {|value| value} #TODO check on this it doesn't seem used
 
         if @widget.respond_to?(:dispose)
           @widget.on_widget_disposed do |dispose_event|
@@ -21,10 +20,12 @@ module Glimmer
           end
         end
       end
+      
       def call(value)
         converted_value = translated_value = @translator.call(value)
         @widget.set_attribute(@property, converted_value) unless evaluate_property == converted_value
       end
+      
       def evaluate_property
         @widget.get_attribute(@property)
       end

data/lib/glimmer/swt/widget_proxy.rb

@@ -1,4 +1,3 @@
-require 'glimmer'
 require 'glimmer/swt/widget_listener_proxy'
 require 'glimmer/swt/color_proxy'
 require 'glimmer/swt/font_proxy'

metadata

@@ -1,21 +1,21 @@
 --- !ruby/object:Gem::Specification
 name: glimmer-dsl-swt
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - AndyMaleh
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-06-15 00:00:00.000000000 Z
+date: 2020-06-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.9.0
+        version: 0.9.2
   name: glimmer
   type: :runtime
   prerelease: false
@@ -23,7 +23,7 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.9.0
+        version: 0.9.2
 - !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
     requirements:
@@ -216,12 +216,7 @@ files:
 - lib/ext/glimmer/config.rb
 - lib/glimmer-dsl-swt.rb
 - lib/glimmer/data_binding/list_selection_binding.rb
-- lib/glimmer/data_binding/model_binding.rb
-- lib/glimmer/data_binding/observable.rb
-- lib/glimmer/data_binding/observable_array.rb
-- lib/glimmer/data_binding/observable_model.rb
 - lib/glimmer/data_binding/observable_widget.rb
-- lib/glimmer/data_binding/observer.rb
 - lib/glimmer/data_binding/shine.rb
 - lib/glimmer/data_binding/table_items_binding.rb
 - lib/glimmer/data_binding/tree_items_binding.rb

data/lib/glimmer/data_binding/model_binding.rb

@@ -1,248 +0,0 @@
-require 'glimmer/data_binding/observable'
-require 'glimmer/data_binding/observer'
-
-module Glimmer
-  module DataBinding
-    class ModelBinding
-      include Observable
-      include Observer
-
-      attr_reader :binding_options
-
-      def initialize(base_model, property_name_expression, binding_options = nil)
-        @base_model = base_model
-        @property_name_expression = property_name_expression
-        @binding_options = binding_options || {}
-        if computed?
-          @computed_model_bindings = computed_by.map do |computed_by_property_expression|
-            self.class.new(base_model, computed_by_property_expression)
-          end
-        end
-      end
-
-      def model
-        nested_property? ? nested_model : base_model
-      end
-
-      # e.g. person.address.state returns [person, person.address]
-      def nested_models
-        @nested_models = [base_model]
-        model_property_names.reduce(base_model) do |reduced_model, nested_model_property_name|
-          if reduced_model.nil?
-            nil
-          else
-            invoke_property_reader(reduced_model, nested_model_property_name).tap do |new_reduced_model|
-              @nested_models << new_reduced_model
-            end
-          end
-        end
-        @nested_models
-      end
-
-      def nested_model
-        nested_models.last
-      end
-
-      def base_model
-        @base_model
-      end
-
-      def property_name
-        nested_property? ? nested_property_name : property_name_expression
-      end
-
-      def convert_on_read(value)
-        apply_converter(@binding_options[:on_read], value)
-      end
-
-      def convert_on_write(value)
-        apply_converter(@binding_options[:on_write], value)
-      end
-
-      def apply_converter(converter, value)
-        if converter.nil?
-          value
-        elsif converter.is_a?(String) || converter.is_a?(Symbol)
-          if value.respond_to?(converter)
-            value.send(converter)
-          else
-            raise Glimmer::Error, "Unsupported bind converter: #{converter.inspect}"
-          end
-        elsif converter.respond_to?(:call, value)
-          converter.call(value)
-        else
-          raise Glimmer::Error, "Unsupported bind converter: #{converter.inspect}"
-        end
-      end
-
-      # All nested property names
-      # e.g. property name expression "address.state" gives ['address', 'state']
-      # If there are any indexed property names, this returns indexes as properties.
-      # e.g. property name expression "addresses[1].state" gives ['addresses', '[1]', 'state']
-      def nested_property_names
-        @nested_property_names ||= property_name_expression.split(".").map {|pne| pne.match(/([^\[]+)(\[[^\]]+\])?/).to_a.drop(1)}.flatten.compact
-      end
-
-      # Final nested property name
-      # e.g. property name expression "address.state" gives :state
-      def nested_property_name
-        nested_property_names.last
-      end
-
-      # Model representing nested property names
-      # e.g. property name expression "address.state" gives [:address]
-      def model_property_names
-        nested_property_names[0...-1]
-      end
-
-      def nested_property?
-        property_name_expression.match(/[.\[]/)
-      end
-
-      def property_name_expression
-        @property_name_expression
-      end
-
-      def computed?
-        !computed_by.empty?
-      end
-
-      def computed_by
-        [@binding_options[:computed_by]].flatten.compact
-      end
-
-      def nested_property_observers_for(observer)
-        @nested_property_observers_collection ||= {}
-        unless @nested_property_observers_collection.has_key?(observer)
-          @nested_property_observers_collection[observer] = nested_property_names.reduce({}) do |output, property_name|
-            output.merge(
-              property_name => Observer.proc do |new_value|
-                # Ensure reattaching observers when a higher level nested property is updated (e.g. person.address changes reattaches person.address.street observer)
-                add_observer(observer)
-                observer.call(evaluate_property)
-              end
-            )
-          end
-        end
-        @nested_property_observers_collection[observer]
-      end
-
-      def add_observer(observer)
-        if computed?
-          add_computed_observers(observer)
-        elsif nested_property?
-          add_nested_observers(observer)
-        else
-          model_binding_observer = Observer.proc do |new_value|
-            observer.call(evaluate_property)
-          end
-          observer_registration = model_binding_observer.observe(model, property_name)
-          my_registration = observer.registration_for(self)
-          observer.add_dependent(my_registration => observer_registration)
-        end
-      end
-
-      def remove_observer(observer)
-        if computed?
-          @computed_model_bindings.each do |computed_model_binding|
-            computed_observer_for(observer).unobserve(computed_model_binding)
-          end
-          @computed_observer_collection.delete(observer)
-        elsif nested_property?
-          nested_property_observers_for(observer).clear
-        else
-          observer.unobserve(model, property_name)
-        end
-      end
-
-      def computed_observer_for(observer)
-        @computed_observer_collection ||= {}
-        unless @computed_observer_collection.has_key?(observer)
-          @computed_observer_collection[observer] = Observer.proc do |new_value|
-            observer.call(evaluate_property)
-          end
-        end
-        @computed_observer_collection[observer]
-      end
-
-      def add_computed_observers(observer)
-        @computed_model_bindings.each do |computed_model_binding|
-          observer_registration = computed_observer_for(observer).observe(computed_model_binding)
-          my_registration = observer.registration_for(self)
-          observer.add_dependent(my_registration => observer_registration)
-        end
-      end
-
-      def add_nested_observers(observer)
-        nested_property_observers = nested_property_observers_for(observer)
-        nested_models.zip(nested_property_names).each_with_index do |zip, i|
-          model, property_name = zip
-          nested_property_observer = nested_property_observers[property_name]
-          previous_index = i - 1
-          parent_model = previous_index.negative? ? self : nested_models[previous_index]
-          parent_property_name = previous_index.negative? ? nil : nested_property_names[previous_index]
-          parent_observer = previous_index.negative? ? observer : nested_property_observers[parent_property_name]
-          parent_property_name = nil if parent_property_name.to_s.start_with?('[')
-          unless model.nil?
-            if property_indexed?(property_name)
-              # TODO figure out a way to deal with this more uniformly
-              observer_registration = nested_property_observer.observe(model)
-            else
-              observer_registration = nested_property_observer.observe(model, property_name)
-            end
-            parent_registration = parent_observer.registration_for(parent_model, parent_property_name)
-            parent_observer.add_dependent(parent_registration => observer_registration)
-          end
-        end
-      end
-
-      def call(value)
-        return if model.nil?
-        converted_value = value
-        invoke_property_writer(model, "#{property_name}=", converted_value) unless evaluate_property == converted_value
-      end
-
-      def evaluate_property
-        value = nil        
-        value = invoke_property_reader(model, property_name) unless model.nil?
-        convert_on_read(value)
-      end
-
-      def evaluate_options_property
-        model.send(options_property_name) unless model.nil?
-      end
-
-      def options_property_name
-        self.property_name + "_options"
-      end
-
-      def property_indexed?(property_expression)
-        property_expression.to_s.start_with?('[')
-      end
-
-      def invoke_property_reader(object, property_expression)
-        if property_indexed?(property_expression)
-          property_method = '[]'
-          property_argument = property_expression[1...-1]
-          property_argument = property_argument.to_i if property_argument.match(/\d+/)
-          object.send(property_method, property_argument)
-        else
-          object.send(property_expression)
-        end
-      end
-
-      def invoke_property_writer(object, property_expression, value)
-        return if @binding_options[:read_only]
-        value = convert_on_write(value)
-        if property_indexed?(property_expression)
-          property_method = '[]='
-          property_argument = property_expression[1...-2]
-          property_argument = property_argument.to_i if property_argument.match(/\d+/)
-          object.send(property_method, property_argument, value)
-        else
-          object.send(property_expression, value)
-        end
-      end
-    end
-  end
-end

data/lib/glimmer/data_binding/observable.rb

@@ -1,21 +0,0 @@
-require 'glimmer/error'
-
-module Glimmer
-  module DataBinding
-    module Observable
-      # TODO rename methods to observe/unobserve
-      def add_observer(observer, property_or_properties=nil)
-        raise Error, 'Not implemented!'
-      end
-
-      def remove_observer(observer, property_or_properties=nil)
-        raise Error, 'Not implemented!'
-      end
- 
-      # Overriding inspect to avoid printing very long observer hierarchies
-      def inspect
-        "#<#{self.class.name}:0x#{self.hash.to_s(16)}>"
-      end
-    end
-  end
-end

data/lib/glimmer/data_binding/observable_array.rb

@@ -1,107 +0,0 @@
-require 'set'
-
-require_relative 'observable'
-
-module Glimmer
-  module DataBinding
-    # TODO prefix utility methods with double-underscore
-    module ObservableArray
-      include Observable
-
-      def add_observer(observer, element_properties=nil)
-        return observer if has_observer?(observer) && element_properties.nil?
-        property_observer_list << observer
-        [element_properties].flatten.compact.each do |property|
-          each do |element|
-            observer.observe(element, property)
-          end
-        end
-        observer
-      end
-
-      def remove_observer(observer, element_properties=nil)
-        property_observer_list.delete(observer)
-        [element_properties].flatten.compact.each do |property|
-          each do |element|
-            observer.unobserve(element, property)
-          end
-        end
-        observer
-      end
-
-      def has_observer?(observer)
-        property_observer_list.include?(observer)
-      end
-
-      def property_observer_list
-        @property_observer_list ||= Set.new
-      end
-
-      def notify_observers
-        property_observer_list.each {|observer| observer.call}
-      end
-
-      def self.extend_object(array)
-        # TODO consider alias_method, and define_method instead
-
-        array.instance_eval("alias __original_add <<")
-        array.instance_eval <<-end_eval, __FILE__, __LINE__
-        def <<(value)
-          self.__original_add(value)
-          notify_observers
-        end
-        end_eval
-
-        array.instance_eval("alias __original_set_value []=")
-        array.instance_eval <<-end_eval, __FILE__, __LINE__
-        def []=(index, value)
-          old_value = self[index]
-          unregister_dependent_observers(old_value)
-          self.__original_set_value(index, value)
-          notify_observers
-        end
-        end_eval
-
-        array.instance_eval("alias __original_delete delete")
-        array.instance_eval <<-end_eval, __FILE__, __LINE__
-        def delete(value)
-          unregister_dependent_observers(value)
-          self.__original_delete(value)
-          notify_observers
-        end
-        end_eval
-
-        array.instance_eval("alias __original_delete_at delete_at")
-        array.instance_eval <<-end_eval, __FILE__, __LINE__
-        def delete_at(index)
-          old_value = self[index]
-          unregister_dependent_observers(old_value)
-          self.__original_delete_at(index)
-          notify_observers
-        end
-        end_eval
-
-        array.instance_eval("alias __original_clear clear")
-        array.instance_eval <<-end_eval, __FILE__, __LINE__
-        def clear
-          each do |old_value|
-            unregister_dependent_observers(old_value)
-          end
-          self.__original_clear
-          notify_observers
-        end
-        end_eval
-
-        super
-      end
-
-      def unregister_dependent_observers(old_value)
-        # TODO look into optimizing this
-        return unless old_value.is_a?(ObservableModel) || old_value.is_a?(ObservableArray)
-        property_observer_list.each do |observer|
-          observer.unregister_dependents_with_observable(observer.registration_for(self), old_value)
-        end
-      end
-    end
-  end
-end

data/lib/glimmer/data_binding/observable_model.rb

@@ -1,108 +0,0 @@
-require 'glimmer'
-
-require_relative 'observable'
-require_relative 'observer'
-
-module Glimmer
-  module DataBinding
-    # TODO prefix utility methods with double-underscore
-    module ObservableModel
-      include Observable
-
-      class Notifier
-        include Observer
-        def initialize(observable_model, property_name)
-          @observable_model = observable_model
-          @property_name = property_name
-        end
-        def call(new_value=nil)
-          @observable_model.notify_observers(@property_name)
-        end
-      end
-
-      def add_observer(observer, property_name)
-        return observer if has_observer?(observer, property_name)
-        property_observer_list(property_name) << observer
-        add_property_writer_observers(property_name)
-        observer
-      end
-
-      def remove_observer(observer, property_name)
-        property_observer_list(property_name).delete(observer)
-      end
-
-      def has_observer?(observer, property_name)
-        property_observer_list(property_name).include?(observer)
-      end
-
-      def has_observer_for_any_property?(observer)
-        property_observer_hash.values.map(&:to_a).sum.include?(observer)
-      end
-
-      def property_observer_hash
-        @property_observers ||= Hash.new
-      end
-
-      def property_observer_list(property_name)
-        property_observer_hash[property_name.to_sym] = Set.new unless property_observer_hash[property_name.to_sym]
-        property_observer_hash[property_name.to_sym]
-      end
-
-      def notify_observers(property_name)
-        property_observer_list(property_name).each {|observer| observer.call(send(property_name))}
-      end
-      #TODO upon updating values, make sure dependent observers are cleared (not added as dependents here)
-
-      def add_property_writer_observers(property_name)
-        property_writer_name = "#{property_name}="
-        method(property_writer_name)
-        ensure_array_object_observer(property_name, send(property_name))
-        begin
-          method("__original_#{property_writer_name}")
-        rescue
-          # TODO consider alias_method or define_method instead
-          instance_eval "alias __original_#{property_writer_name} #{property_writer_name}"
-          instance_eval <<-end_eval, __FILE__, __LINE__
-          def #{property_writer_name}(value)
-            old_value = self.#{property_name}
-            unregister_dependent_observers('#{property_name}', old_value)
-            self.__original_#{property_writer_name}(value)
-            notify_observers('#{property_name}')
-            ensure_array_object_observer('#{property_name}', value, old_value)
-          end
-          end_eval
-        end
-      rescue => e
-        # ignore writing if no property writer exists
-        Glimmer::Config.logger&.debug "No need to observe property writer: #{property_writer_name}\n#{e.message}\n#{e.backtrace.join("\n")}"
-      end
-
-      def unregister_dependent_observers(property_name, old_value)
-        # TODO look into optimizing this
-        return unless old_value.is_a?(ObservableModel) || old_value.is_a?(ObservableArray)
-        property_observer_list(property_name).each do |observer|
-          observer.unregister_dependents_with_observable(observer.registration_for(self, property_name), old_value)
-        end
-      end
-
-      def ensure_array_object_observer(property_name, object, old_object = nil)
-        return unless object.is_a?(Array)
-        array_object_observer = array_object_observer_for(property_name)
-        array_observer_registration = array_object_observer.observe(object)
-        property_observer_list(property_name).each do |observer|
-          my_registration = observer.registration_for(self, property_name) # TODO eliminate repetition
-          observer.add_dependent(my_registration => array_observer_registration)
-        end
-        array_object_observer_for(property_name).unregister(old_object) if old_object.is_a?(ObservableArray)
-      end
-
-      def array_object_observer_for(property_name)
-        @array_object_observers ||= {}
-        unless @array_object_observers.has_key?(property_name)
-          @array_object_observers[property_name] = ObservableModel::Notifier.new(self, property_name)
-        end
-        @array_object_observers[property_name]
-      end
-    end
-  end
-end

data/lib/glimmer/data_binding/observer.rb

@@ -1,124 +0,0 @@
-require 'glimmer/error'
-
-module Glimmer
-  module DataBinding
-    # Mixin representing Observer trait from Observer Design Pattern
-    # Allows classes to include without interfering with their
-    # inheritance hierarchy.
-    #
-    # Includes a default implementation that can receive an observer block
-    # Example: Observer.proc {|new_value| puts new_value}
-    # Subclasses may override
-    module Observer
-      # Observer Proc default implementation that takes an observer block to process updates
-      # via call method
-      class Proc
-        include Observer
-
-        def initialize(&observer_block)
-          @observer_block = observer_block
-        end
-
-        # Called by observables once updates occur sending in the new_value if any
-        def call(new_value=nil)
-          @observer_block.call(new_value)
-        end
-      end
-
-      class Registration < Struct.new(:observer, :observable, :property, keyword_init: true)
-        def unregister
-          observer.unobserve(observable, property)
-        end
-        alias unobserve unregister
-      end
-
-      class << self
-        def proc(&observer_block)
-          Proc.new(&observer_block)
-        end
-      end
-
-      def registrations
-        @registrations ||= Set.new
-      end
-
-      def registration_for(observable, property = nil)
-        Registration.new(observer: self, observable: observable, property: property)
-      end
-
-      # mapping of registrations to dependents
-      # {[observable, property] => [[dependent, dependent_observable, dependent_property], ...]}
-      def dependents
-        @dependents ||= Hash.new
-      end
-
-      def dependents_for(registration)
-        dependents[registration] ||= Set.new
-      end
-
-      # registers observer in an observable on a property (optional)
-      # observer maintains registration list to unregister later
-      def register(observable, property = nil)
-        unless observable.is_a?(Observable)
-          # TODO refactor code to be more smart/polymorphic/automated and honor open/closed principle
-          if observable.is_a?(Array)
-            observable.extend(ObservableArray)
-          else
-            observable.extend(ObservableModel)
-          end
-        end
-        observable.add_observer(*[self, property].compact)
-        registration_for(observable, property).tap do |registration|
-          self.registrations << registration
-        end
-      end
-      alias observe register
-
-      def unregister(observable, property = nil)
-        # TODO optimize performance in the future via indexing and/or making a registration official object/class
-        observable.remove_observer(*[self, property].compact)
-        registration = registration_for(observable, property)
-        dependents_for(registration).each do |dependent|
-          dependent.unregister
-          remove_dependent(registration => dependent)
-        end
-        registrations.delete(registration)
-      end
-      alias unobserve unregister
-
-      def unregister_dependents_with_observable(registration, dependent_observable)
-        thedependents = dependents_for(registration).select do |thedependent|
-          thedependent.observable == dependent_observable
-        end
-        thedependents.each do |thedependent|
-          thedependent.unregister
-        end
-      end
-
-      # cleans up all registrations in observables
-      def unregister_all_observables
-        registrations.each do |registration|
-          registration.unregister
-        end
-      end
-      alias unobserve_all_observables unregister_all_observables
-
-      # add dependent observer to unregister when unregistering observer
-      def add_dependent(parent_to_dependent_hash)
-        registration = parent_to_dependent_hash.keys.first
-        dependent = parent_to_dependent_hash.values.first
-        dependents_for(registration) << dependent
-      end
-
-      def remove_dependent(parent_to_dependent_hash)
-        registration = parent_to_dependent_hash.keys.first
-        dependent = parent_to_dependent_hash.values.first
-        dependents_for(registration).delete(dependent)
-      end
-
-      def call(new_value)
-        raise Error, 'Not implemented!'
-      end
-    end
-  end
-end