glimmer-dsl-swt 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: d7caca40c9a1207a97846a5c5511fe24a07f4689979e57d54c395a33b3b341ba
+  data.tar.gz: 4b41ad30f7e63cd67bc87e88668cfb7f5b2d49b3d4cb7081bcfa04b6dcfefa90
+SHA512:
+  metadata.gz: 2f41fda28c273df8bb93810f68c7841f60346b3469b7afeea9992bdf34f06dae28912af64dcce1ebcc6604832383de7a3082d3f4fe7238d5fa6563476792246d
+  data.tar.gz: 92e0b7e06ebcf4e7af47bfbc22189449d5161ebda431bd4be5973c4447ba622bac139bf31d4cbaaf5e92658d6695a49e522086e54f8a4303cd394fd9bdef2e65

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2020 Andy Maleh
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,47 @@
+# Glimmer DSL for SWT 0.1.0 (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)
+
+[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)
+
+## Help
+
+### Issues
+
+You may submit [issues](https://github.com/AndyObtiva/glimmer/issues) on [GitHub](https://github.com/AndyObtiva/glimmer/issues).
+
+[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. 
+
+[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)
+
+## Feature Suggestions
+
+These features have been suggested. You might see them in a future version of Glimmer. You are welcome to contribute more feature suggestions.
+
+[TODO.md](TODO.md)
+
+## Change Log
+
+[CHANGELOG.md](CHANGELOG.md)
+
+## Contributing
+
+[CONTRIBUTING.md](CONTRIBUTING.md)
+
+## Contributors
+
+* [Andy Maleh](https://github.com/AndyObtiva) (Founder)
+
+[Click here to view contributor commits.](https://github.com/AndyObtiva/glimmer-dsl-swt/graphs/contributors)
+
+## License
+
+Copyright (c) 2020 Andy Maleh.
+See LICENSE.txt for further details.

data/RUBY_VERSION

@@ -0,0 +1 @@
+jruby-9.2.11.1

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/bin/girb

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+
+trap "SIGINT" do
+  # No Op for irb
+end
+
+require_relative '../lib/glimmer/launcher'
+
+girb_runner = File.expand_path('../girb_runner.rb', __FILE__)
+Glimmer::Launcher.new(["irb -r #{girb_runner}"] + ARGV).launch

data/bin/girb_runner.rb

@@ -0,0 +1,13 @@
+require 'puts_debuggerer'
+
+include Glimmer
+
+# Hijack Shell#start_event_loop default behavior to ensure disposing a display upon closing a shell inside girb
+
+Glimmer::SWT::ShellProxy.class_eval do
+  alias start_event_loop_original start_event_loop
+  def start_event_loop
+    start_event_loop_original
+    Glimmer::SWT::DisplayProxy.instance.dispose
+  end
+end

data/bin/glimmer

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require_relative '../lib/glimmer/launcher'
+
+Glimmer::Launcher.new(ARGV).launch

data/lib/ext/glimmer.rb

@@ -0,0 +1,13 @@
+require 'glimmer/swt/packages'
+
+module Glimmer
+  class << self
+    def included(klass)
+      if Config.import_swt_packages
+        klass.include(SWT::Packages)
+        klass.extend(SWT::Packages)
+        klass.extend(Glimmer)
+      end
+    end
+  end
+end

data/lib/ext/glimmer/config.rb

@@ -0,0 +1,18 @@
+module Glimmer
+  module Config
+    class << self
+      # Tells Glimmer to import SWT packages into including class (default: true)
+      def import_swt_packages=(value)
+        @@import_swt_packages = !!value
+      end
+  
+      # Returns whether Glimmer will import SWT packages into including class
+      def import_swt_packages
+        unless defined? @@import_swt_packages
+          @@import_swt_packages = true
+        end
+        @@import_swt_packages
+      end
+    end
+  end
+end

data/lib/glimmer-dsl-swt.rb

@@ -0,0 +1,12 @@
+$LOAD_PATH.unshift(File.expand_path('..', __FILE__))
+
+# External requires
+require 'java'
+require 'nested_inherited_jruby_include_package'
+require 'super_module'
+require 'glimmer'
+
+# Internal requires
+require 'ext/glimmer/config'
+require 'ext/glimmer'
+require 'glimmer/dsl/swt/dsl'

data/lib/glimmer/data_binding/list_selection_binding.rb

@@ -0,0 +1,52 @@
+require 'glimmer'
+require 'glimmer/data_binding/observable'
+require 'glimmer/data_binding/observer'
+
+module Glimmer
+  module DataBinding
+    # SWT List widget selection binding
+    class ListSelectionBinding
+      include Glimmer
+      include Observable
+      include Observer
+
+      attr_reader :widget_proxy
+
+      PROPERTY_TYPE_UPDATERS = {
+        :string => lambda { |widget_proxy, value| widget_proxy.swt_widget.select(widget_proxy.swt_widget.index_of(value.to_s)) },
+        :array => lambda { |widget_proxy, value| widget_proxy.swt_widget.selection=(value || []).to_java(:string) }
+      }
+
+      PROPERTY_EVALUATORS = {
+        :string => lambda do |selection_array|
+          return nil if selection_array.empty?
+          selection_array[0]
+        end,
+        :array => lambda do |selection_array|
+          selection_array
+        end
+      }
+
+      # Initialize with list widget and property_type
+      # property_type :string represents default list single selection
+      # property_type :array represents list multi selection
+      def initialize(widget_proxy, property_type)
+        property_type = :string if property_type.nil? or property_type == :undefined
+        @widget_proxy = widget_proxy
+        @property_type = property_type
+        @widget_proxy.on_widget_disposed do |dispose_event|
+          unregister_all_observables
+        end
+      end
+
+      def call(value)
+        PROPERTY_TYPE_UPDATERS[@property_type].call(@widget_proxy, value) unless evaluate_property == value
+      end
+
+      def evaluate_property
+        selection_array = @widget_proxy.swt_widget.send('selection').to_a #TODO refactor send('selection') into proper method invocation
+        PROPERTY_EVALUATORS[@property_type].call(selection_array)
+      end
+    end
+  end
+end

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