glimmer 0.4.3 → 0.4.4

data/lib/glimmer/command_handlers/models/model_binding.rb

@@ -1,206 +0,0 @@
-require_relative 'observable'
-require_relative 'observer'
-
-module Glimmer
-  class ModelBinding
-    include Observable
-    include Observer
-
-    attr_reader :property_type, :binding_options
-    @@property_type_converters = {
-      :undefined => lambda { |value| value },
-      :fixnum => lambda { |value| value.to_i },
-      :array => lambda { |value| value.to_a }
-    }
-    def initialize(base_model, property_name_expression, property_type = :undefined, binding_options = nil)
-      property_type = :undefined if property_type.nil?
-      @base_model = base_model
-      @property_name_expression = property_name_expression
-      @property_type = property_type
-      @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, :undefined, computed_binding_options)
-        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
-    # 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 computed_binding_options
-      @binding_options.reject {|k,v| k == :computed_by}
-    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].keys.each_with_index do |property_name, i|
-      #   previous_property_name = nested_property_names[i-1]
-      #   previous_observer = @nested_property_observers_collection[observer][previous_property_name]
-      #   nested_property_observer = @nested_property_observers_collection[observer][property_name]
-      #   previous_observer.add_dependent(nested_property_observer) unless previous_observer.nil?
-      # end
-      # TODO remove this brainstorming
-      # person.addresses[1].streets[2].number
-      # person.addresses[1] = ...
-      @nested_property_observers_collection[observer]
-    end
-    def add_observer(observer)
-      if computed?
-        add_computed_observers(observer)
-      elsif nested_property?
-        add_nested_observers(observer)
-      else
-        observer.observe(model, property_name)
-        observer.add_dependent([self, nil] => [observer, model, property_name])
-      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|
-        computed_observer_for(observer).observe(computed_model_binding)
-        observer.add_dependent([self, nil] => [computed_observer_for(observer), computed_model_binding, nil])
-      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
-            nested_property_observer.observe(model)
-            parent_observer.add_dependent([parent_model, parent_property_name] => [nested_property_observer, model, nil])
-          else
-            nested_property_observer.observe(model, property_name)
-            parent_observer.add_dependent([parent_model, parent_property_name] => [nested_property_observer, model, property_name])
-          end
-        end
-      end
-    end
-    def call(value)
-      return if model.nil?
-      converted_value = @@property_type_converters[@property_type].call(value)
-      invoke_property_writer(model, "#{property_name}=", converted_value) unless evaluate_property == converted_value
-    end
-    def evaluate_property
-      invoke_property_reader(model, property_name) unless model.nil?
-    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.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)
-      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

data/lib/glimmer/command_handlers/models/observable.rb

@@ -1,11 +0,0 @@
-module Glimmer
-  module Observable
-    def add_observer(observer, property_or_properties=nil)
-      raise 'Not implemented!'
-    end
-
-    def remove_observer(observer, property_or_properties=nil)
-      raise 'Not implemented!'
-    end
-  end
-end

data/lib/glimmer/command_handlers/models/observable_array.rb

@@ -1,104 +0,0 @@
-require 'set'
-
-require_relative 'observable'
-
-module Glimmer
-  # 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)
-      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([self, nil], old_value)
-      end
-    end
-
-  end
-end

data/lib/glimmer/command_handlers/models/observable_model.rb

@@ -1,105 +0,0 @@
-require 'set'
-
-require_relative 'observable'
-require_relative 'observer'
-
-module Glimmer
-  # 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 unless @property_observers
-      @property_observers
-    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
-        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.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([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_object_observer.observe(object)
-      property_observer_list(property_name).each do |observer|
-        observer.add_dependent([self, property_name] => [array_object_observer, object, nil])
-      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

data/lib/glimmer/command_handlers/models/observer.rb

@@ -1,115 +0,0 @@
-require 'set'
-
-module Glimmer
-  # 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 << self
-      def proc(&observer_block)
-        Proc.new(&observer_block)
-      end
-    end
-
-    def registrations
-      @registrations ||= Set.new
-    end
-
-    def registrations_for(observable, property = nil)
-      registrations.select {|o, p| o == observable && p == 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)
-      [observable, property].tap do |registration|
-        self.registrations << registration
-      end
-    end
-    alias observe register
-
-    def unregister(observable, property = nil)
-      observable.remove_observer(*[self, property].compact)
-      registration = [observable, property]
-      dependents_for(registration).each do |dependent|
-        dependent_observer, dependent_observable, dependent_property = dependent
-        dependent_observer.unregister(dependent_observable, dependent_property)
-        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 |d_observer, d_observable, d_property|
-        d_observable == dependent_observable
-      end
-      thedependents.each do |d_observer, d_observable, d_property|
-        d_observer.unregister(d_observable, d_property)
-      end
-    end
-
-    # cleans up all registrations in observables
-    def unregister_all_observables
-      registrations.each do |observable, property|
-        unregister(observable, property)
-      end
-    end
-    alias unobserve_all_observables unregister_all_observables
-
-    # add dependent observer to unregister when unregistering observer
-    def add_dependent(parent_to_dependent_hash)
-      observable, property = registration = parent_to_dependent_hash.keys.first
-      dependent_observer, dependent_observable, dependent_property = dependent = parent_to_dependent_hash.values.first
-      dependents_for(registration) << dependent
-    end
-
-    def remove_dependent(parent_to_dependent_hash)
-      observable, property = registration = parent_to_dependent_hash.keys.first
-      dependent_observer, dependent_observable, dependent_property = dependent = parent_to_dependent_hash.values.first
-      dependents_for(registration).delete(dependent)
-    end
-
-    def call(new_value)
-      raise 'Not implemented!'
-    end
-  end
-end