glimmer-dsl-swt 0.1.1 → 0.2.2

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