glimmer 0.9.1 → 0.9.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9a0e5867d64de61a6733bb4946eb3b366ae854a72bf99cdc048707c00cd9c276
-  data.tar.gz: b3735c7bff7ee61219f822378b59077e00f9957ed1031b09fd1e3f461eb90868
+  metadata.gz: 2d387850f085c102bcaf51d9f9f1250cf02124372beed08612bc2dde2766f387
+  data.tar.gz: 828032e8a3d6779e47d63c054cf15211ec8b989a58af47ba1aedfed36e696b67
 SHA512:
-  metadata.gz: b5e181bff40082c4620fc6ad1a306af61c7d59e24a30c13c6038606f008d9480da5532d07a704d0c39563318c23935efb909f958f596b7c49c5f2a6843ace165
-  data.tar.gz: 0562d569471bb792943cac85d0c3a79462573074e1ad634fb0aac1f1e9b53bbe9121d8534f9ea1ce94f5b30b0c47947618e73938e38d72695cecbfba48684210
+  metadata.gz: 5e7d349b48f19af94bab354eceef736e6c58e9d4e608582fb12c1677c453dfff5ee02c74a968133e985239a18f0058f66b35a4199fc4c3ac63b29cb0d80a7f91
+  data.tar.gz: 2d4f7f4600517ca0f6e9f08946b37f7aaff9740dc3f49b1844147d6635cd4cce053af200e1c58c0a5eac8523d4cce2f9601ead454665049919954498d697c32e

data/README.md

@@ -1,12 +1,19 @@
-# Glimmer - Ruby Desktop Development GUI Library
+# <img src="https://raw.githubusercontent.com/AndyObtiva/glimmer/master/images/glimmer-logo-hi-res.png" height=105 /> Glimmer - Ruby Desktop Development GUI Library
 [![Gem Version](https://badge.fury.io/rb/glimmer.svg)](http://badge.fury.io/rb/glimmer)
-[![Travis CI](https://travis-ci.com/AndyObtiva/glimmer.svg?branch=master)](https://travis-ci.com/github/AndyObtiva/glimmer)
+[![Travis CI](https://travis-ci.com/AndyObtiva/glimmer.svg?branch=master)](https://travis-ci.com/github/AndyObtiva/glimmer) 
+[![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 is a native-GUI cross-platform desktop development library written in Ruby. Glimmer's main innovation is a JRuby DSL that enables productive and efficient authoring of desktop application user-interfaces while relying on the robust Eclipse SWT library. Glimmer additionally innovates by having built-in data-binding support to greatly facilitate synchronizing the GUI with domain models. As a result, that achieves true decoupling of object oriented components, enabling developers to solve business problems without worrying about GUI concerns, or alternatively drive development GUI-first, and then write clean business models test-first afterwards.
 
 [<img src="https://covers.oreillystatic.com/images/9780596519650/lrg.jpg" width=105 /><br /> 
 Featured in<br />JRuby Cookbook](http://shop.oreilly.com/product/9780596519650.do)
 
+Glimmer DSL gems:
+- [glimmer-dsl-swt](https://github.com/AndyObtiva/glimmer-dsl-swt): Glimmer DSL for SWT (Desktop GUI)
+- [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)
+
 ## Examples
 
 ### Hello, World!
@@ -199,13 +206,13 @@ Glimmer might still work on lower versions of Java, JRuby and SWT, but there are
 
 ## Setup
 
-Please follow these instructions to make the `glimmer` command available on your system.
+Please follow these instructions to make the `glimmer` command available on your system via the [`glimmer-dsl-swt`](https://github.com/AndyObtiva/glimmer-dsl-swt) gem.
 
 ### Option 1: Direct Install
 
 Run this command to install directly:
 ```
-jgem install glimmer-dsl-swt -v 0.1.0
+jgem install glimmer-dsl-swt -v 0.1.2
 ```
 
 `jgem` is JRuby's version of `gem` command. 
@@ -216,7 +223,7 @@ Otherwise, you may also run `jruby -S gem install ...`
 
 Add the following to `Gemfile`:
 ```
-gem 'glimmer-dsl-swt', '~> 0.1.0'
+gem 'glimmer-dsl-swt', '~> 0.1.2'
 ```
 
 And, then run:
@@ -224,7 +231,7 @@ And, then run:
 jruby -S bundle install
 ```
 
-You may learn more about other Glimmer related gems at [Multi-DSL Support](#multi-dsl-support)
+You may learn more about other Glimmer related gems ([`glimmer-dsl-opal`](https://github.com/AndyObtiva/glimmer-dsl-opal), [`glimmer-dsl-xml`](https://github.com/AndyObtiva/glimmer-dsl-xml), and [`glimmer-dsl-css`](https://github.com/AndyObtiva/glimmer-dsl-css)) at [Multi-DSL Support](#multi-dsl-support)
 
 ## Glimmer Command
 
@@ -2391,10 +2398,6 @@ By the way, keep in mind that during normal operation, it does also indicate a f
 Exec failed with code 2 command [[/usr/bin/SetFile, -c, icnC, /var/folders/4_/g1sw__tx6mjdgyh3mky7vydc0000gp/T/fxbundler4076750801763032201/images/MathBowling/.VolumeIcon.icns] in unspecified directory
 ```
 
-## Limitations
-
-- Glimmer apps have a long startup up time and can take anywhere between 12 and 30 seconds to start depending on the app and the machine. Once started, Glimmer apps run very fast and perform very responsively since Ruby is more than fast and capable for handling desktop GUIs. In any case, one idea to address this limitation is to include a background service (daemon) that can launch Glimmer apps instantly or near instantly by keeping a JRuby runtime started and ready at all times.
-
 ## Resources
 
 * [Code Master Blog](http://andymaleh.blogspot.com/search/label/Glimmer)
@@ -2412,11 +2415,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.9.1
+0.9.2

data/lib/glimmer/data_binding/model_binding.rb

@@ -0,0 +1,248 @@
+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

@@ -0,0 +1,21 @@
+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

@@ -0,0 +1,86 @@
+require 'set'
+
+require 'glimmer/data_binding/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 <<(element)
+        super(element)
+        notify_observers
+      end
+      
+      def []=(index, value)
+        old_value = self[index]
+        unregister_dependent_observers(old_value)
+        super(index, value)
+        notify_observers
+      end
+      
+      def delete(element)
+        unregister_dependent_observers(element)
+        super(element)
+        notify_observers
+      end
+      
+      def delete_at(index)
+        old_value = self[index]
+        unregister_dependent_observers(old_value)
+        super(index)
+        notify_observers
+      end
+      
+      def clear
+        each do |old_value|
+          unregister_dependent_observers(old_value)
+        end
+        super()
+        notify_observers
+      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

@@ -0,0 +1,104 @@
+require 'glimmer/data_binding/observable'
+require 'glimmer/data_binding/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
+          old_method = self.class.instance_method(property_writer_name)
+          define_singleton_method("__original_#{property_writer_name}", old_method)
+          define_singleton_method(property_writer_name) do |value|
+            old_value = self.send(property_name)
+            unregister_dependent_observers(property_name, old_value)
+            self.send("__original_#{property_writer_name}", value)
+            notify_observers(property_name)
+            ensure_array_object_observer(property_name, value, old_value)
+          end
+        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

@@ -0,0 +1,127 @@
+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
+
+require 'glimmer/data_binding/observable_model'
+require 'glimmer/data_binding/observable_array'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: glimmer
 version: !ruby/object:Gem::Version
-  version: 0.9.1
+  version: 0.9.2
 platform: ruby
 authors:
 - AndyMaleh
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-06-14 00:00:00.000000000 Z
+date: 2020-06-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
@@ -145,6 +145,11 @@ files:
 - VERSION
 - lib/glimmer.rb
 - lib/glimmer/config.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/observer.rb
 - lib/glimmer/dsl/engine.rb
 - lib/glimmer/dsl/expression.rb
 - lib/glimmer/dsl/expression_handler.rb