glimmer 0.7.7 → 0.9.0

data/lib/glimmer/ui/custom_shell.rb

@@ -1,45 +0,0 @@
-require 'glimmer/error'
-
-module Glimmer
-  module UI
-    module CustomShell
-      include SuperModule
-      include Glimmer::UI::CustomWidget
-
-      def initialize(parent, *swt_constants, options, &content)
-        super
-        raise Error, 'Invalid custom shell body root! Must be a shell or another custom shell.' unless body_root.swt_widget.is_a?(org.eclipse.swt.widgets.Shell)
-      end
-
-      # Classes may override
-      def open
-        body_root.open
-      end
-
-      # DO NOT OVERRIDE. JUST AN ALIAS FOR `#open`. OVERRIDE `#open` INSTEAD.
-      def show
-        open
-      end
-
-      def close
-        body_root.close
-      end
-
-      def hide
-        body_root.hide
-      end
-
-      def visible?
-        body_root.visible?
-      end
-
-      def center
-        body_root.center
-      end
-
-      def start_event_loop
-        body_root.start_event_loop
-      end
-    end
-  end
-end

data/lib/glimmer/ui/custom_widget.rb

@@ -1,241 +0,0 @@
-require 'glimmer'
-require 'glimmer/error'
-require 'glimmer/swt/swt_proxy'
-require 'glimmer/swt/display_proxy'
-require 'glimmer/util/proc_tracker'
-require 'glimmer/data_binding/observer'
-require 'glimmer/data_binding/observable_model'
-require 'glimmer/data_binding/observable_widget'
-
-module Glimmer
-  module UI
-    module CustomWidget
-      include SuperModule
-      include DataBinding::ObservableModel
-
-      super_module_included do |klass|
-        klass.include(Glimmer) unless klass.name.include?('Glimmer::UI::CustomShell')
-        klass.prepend DataBinding::ObservableWidget
-        Glimmer::UI::CustomWidget.add_custom_widget_namespaces_for(klass) unless klass.name.include?('Glimmer::UI::CustomShell')
-      end
-
-      class << self
-        def for(underscored_custom_widget_name)
-          extracted_namespaces = underscored_custom_widget_name.
-            to_s.
-            split(/__/).map do |namespace|
-              namespace.camelcase(:upper)
-            end
-          custom_widget_namespaces.each do |base|
-            extracted_namespaces.reduce(base) do |result, namespace|
-              if !result.constants.include?(namespace)
-                namespace = result.constants.detect {|c| c.to_s.upcase == namespace.to_s.upcase } || namespace
-              end
-              begin
-                constant = result.const_get(namespace)
-                return constant if constant.ancestors.include?(Glimmer::UI::CustomWidget)
-                constant
-              rescue => e
-                # Glimmer::Config.logger&.debug "#{e.message}\n#{e.backtrace.join("\n")}"
-                result
-              end
-            end
-          end
-          raise "#{underscored_custom_widget_name} has no custom widget class!"
-        rescue => e
-          Glimmer::Config.logger&.debug e.message
-          Glimmer::Config.logger&.debug "#{e.message}\n#{e.backtrace.join("\n")}"
-          nil
-        end
- 
-        def add_custom_widget_namespaces_for(klass)
-          Glimmer::UI::CustomWidget.namespaces_for_class(klass).drop(1).each do |namespace|
-            Glimmer::UI::CustomWidget.custom_widget_namespaces << namespace
-          end
-        end
-
-        def namespaces_for_class(m)
-          return [m] if m.name.nil?
-          namespace_constants = m.name.split(/::/).map(&:to_sym)
-          namespace_constants.reduce([Object]) do |output, namespace_constant|
-            output += [output.last.const_get(namespace_constant)]
-          end[1..-1].uniq.reverse
-        end
-
-        def custom_widget_namespaces
-          @custom_widget_namespaces ||= reset_custom_widget_namespaces
-        end
-
-        def reset_custom_widget_namespaces
-          @custom_widget_namespaces = Set[Object, Glimmer::UI]
-        end
-
-        # Allows defining convenience option readers for an array of option names
-        # Example: `options :color1, :color2` defines `#color1` and `#color2`
-        # where they return the instance values `options[:color1]` and `options[:color2]`
-        # respectively.
-        # Can be called multiple times to set more options additively.
-        # When passed no arguments, it returns list of all option names captured so far
-        def options(*new_options)
-          new_options = new_options.compact.map(&:to_s).map(&:to_sym)
-          if new_options.empty?
-            @options ||= {} # maps options to defaults
-          else
-            new_options = new_options.reduce({}) {|new_options_hash, new_option| new_options_hash.merge(new_option => nil)}
-            @options = options.merge(new_options)
-            def_option_attr_readers(new_options)
-          end
-        end
-
-        def option(new_option, new_option_default = nil)
-          new_option = new_option.to_s.to_sym
-          new_options = {new_option => new_option_default}
-          @options = options.merge(new_options)
-          def_option_attr_readers(new_options)
-        end
-
-        def def_option_attr_readers(new_options)
-          new_options.each do |option, default|
-            class_eval <<-end_eval, __FILE__, __LINE__
-              def #{option}
-                options[:#{option}]
-              end
-            end_eval
-          end
-        end
-
-        def before_body(&block)
-          @before_body_blocks ||= []
-          @before_body_blocks << block
-        end
-
-        def body(&block)
-          @body_block = block
-        end
-
-        def after_body(&block)
-          @after_body_blocks ||= []
-          @after_body_blocks << block
-        end
-      end
-
-      attr_reader :body_root, :swt_widget, :parent, :swt_style, :options
-
-      def initialize(parent, *swt_constants, options, &content)
-        @parent = parent
-        @swt_style = SWT::SWTProxy[*swt_constants]
-        options ||= {}
-        @options = self.class.options.merge(options)
-        @content = Util::ProcTracker.new(content) if content
-        execute_hooks('before_body')
-        body_block = self.class.instance_variable_get("@body_block")
-        raise Glimmer::Error, 'Invalid custom widget for having no body! Please define body block!' if body_block.nil?
-        @body_root = instance_exec(&body_block)
-        execute_hooks('after_body')
-        @swt_widget = @body_root.swt_widget
-      end
-
-      def can_handle_observation_request?(observation_request)
-        result = false
-        if observation_request.start_with?('on_updated_')
-          property = observation_request.sub(/^on_updated_/, '')
-          result = can_add_observer?(property)
-        end
-        result || body_root&.can_handle_observation_request?(observation_request)
-      end
-
-      def handle_observation_request(observation_request, &block)
-        if observation_request.start_with?('on_updated_')
-          property = observation_request.sub(/^on_updated_/, '') # TODO look into eliminating duplication from above
-          add_observer(DataBinding::Observer.proc(&block), property) if can_add_observer?(property)
-        else
-          body_root.handle_observation_request(observation_request, &block)
-        end
-      end
-
-      def can_add_observer?(attribute_name)
-        has_instance_method?(attribute_name) || respond_to?("#{attribute_name}?") || @body_root.can_add_observer?(attribute_name)
-      end
-
-      def add_observer(observer, attribute_name)
-        if has_instance_method?(attribute_name)
-          super
-        else
-          @body_root.add_observer(observer, attribute_name)
-        end
-      end
-
-      def has_attribute?(attribute_name, *args)
-        respond_to?(attribute_setter(attribute_name), args) ||
-          @body_root.has_attribute?(attribute_name, *args)
-      end
-
-      def set_attribute(attribute_name, *args)
-        if respond_to?(attribute_setter(attribute_name), args)
-          send(attribute_setter(attribute_name), *args)
-        else
-          @body_root.set_attribute(attribute_name, *args)
-        end
-      end
-
-      # This method ensures it has an instance method not coming from Glimmer DSL
-      def has_instance_method?(method_name)
-        respond_to?(method_name) && !method(method_name)&.source_location&.first&.include?('glimmer/dsl/engine.rb')
-      end
-
-      def get_attribute(attribute_name)
-        if has_instance_method?(attribute_name)
-          send(attribute_name)
-        else
-          @body_root.get_attribute(attribute_name)
-        end
-      end
-
-      def attribute_setter(attribute_name)
-        "#{attribute_name}="
-      end
-
-
-      def has_style?(style)
-        (swt_style & SWT::SWTProxy[style]) == SWT::SWTProxy[style]
-      end
-
-      # TODO see if it is worth it to eliminate duplication of async_exec/sync_exec
-      # delegation to DisplayProxy, via a module
-
-      def async_exec(&block)
-        SWT::DisplayProxy.instance.async_exec(&block)
-      end
-
-      def sync_exec(&block)
-        SWT::DisplayProxy.instance.sync_exec(&block)
-      end
-
-      # Returns content block if used as an attribute reader (no args)
-      # Otherwise, if a block is passed, it adds it as content to this custom widget
-      def content(&block)
-        if block_given?
-          body_root.content(&block)
-        else
-          @content
-        end
-      end
-
-      def dispose
-        body_root.dispose
-      end
-      
-      def method_missing(method, *args, &block)
-        body_root.send(method, *args, &block)
-      end
-
-      private
-
-      def execute_hooks(hook_name)
-        self.class.instance_variable_get("@#{hook_name}_blocks")&.each do |hook_block|
-          instance_exec(&hook_block)
-        end
-      end
-    end
-  end
-end

data/lib/glimmer/util/proc_tracker.rb

@@ -1,16 +0,0 @@
-module Glimmer
-  module Util
-    class ProcTracker < DelegateClass(Proc)
-      def initialize(proc)
-        super(proc)
-      end
-      def call(*args)
-        __getobj__.call(*args)
-        @called = true
-      end
-      def called?
-        !!@called
-      end
-    end
-  end
-end

data/lib/glimmer/xml/depth_first_search_iterator.rb

@@ -1,22 +0,0 @@
-require 'glimmer/xml/node'
-
-module Glimmer
-  module XML
-    class DepthFirstSearchIterator
-      def initialize(node, node_visitor)
-        @node = node
-        @node_visitor = node_visitor
-      end
-
-      def iterate
-        process(@node)
-      end
-
-      def process(node)
-        @node_visitor.process_before_children(node)
-        node.children.each { |child| process(child) } if node.is_a?(Node)
-        @node_visitor.process_after_children(node)
-      end
-    end
-  end
-end

data/lib/glimmer/xml/name_space_visitor.rb

@@ -1,21 +0,0 @@
-require File.dirname(__FILE__) + "/node_visitor"
-
-module Glimmer
-  module XML
-    class NameSpaceVisitor < NodeVisitor
-
-      def initialize(name_space_name)
-        @name_space_name = name_space_name
-      end
-
-      def process_before_children(node)
-        return if node.is_a?(String)
-        node.name_space = Node.new(nil, @name_space_name, nil) if node and !node.name_space
-      end
-
-      def process_after_children(node)
-        #NOOP
-      end
-    end
-  end
-end

data/lib/glimmer/xml/node.rb

@@ -1,75 +0,0 @@
-require 'glimmer'
-require 'glimmer/xml/depth_first_search_iterator'
-require 'glimmer/xml/xml_visitor'
-
-module Glimmer
-  module XML
-    class Node
-      include Glimmer
-
-      attr_accessor :children, :name, :contents, :attributes, :is_name_space, :is_attribute, :name_space, :parent
-
-      def initialize(parent, name, attributes, &contents)
-        @is_name_space = false
-        @children = []
-        @parent = parent
-        if attributes.is_a?(Array)
-          attributes = attributes.compact
-          hash_attributes = attributes.last.is_a?(Hash) ? attributes.delete(attributes.last) : {}
-          hash_attributes = attributes.reduce(hash_attributes) do |hash, attribute|
-            hash.merge(attribute => nil)
-          end
-          attributes = hash_attributes
-        end
-        if (parent and parent.is_name_space)
-          @name_space = parent
-          @parent = @name_space.parent
-        end
-        @parent.children << self if @parent
-        @name = name
-        @contents = contents
-        @attributes = attributes
-        if @attributes
-          @attributes.each_key do |attribute|
-            if attribute.is_a?(Node)
-              attribute.is_attribute = true
-              attribute.parent.children.delete(attribute) if attribute.parent
-              attribute.parent = nil #attributes do not usually have parents
-            end
-          end
-          Glimmer::Config.logger&.debug(attributes)
-        end
-      end
-
-      def method_missing(symbol, *args, &block)
-        @is_name_space = true
-        parent.children.delete(self) if parent
-        Glimmer::DSL::Engine.add_content(self, Glimmer::DSL::XML::HtmlExpression.new) {@tag = super}
-        @tag
-      end
-
-      def to_xml
-        xml_visitor = XmlVisitor.new
-        DepthFirstSearchIterator.new(self, xml_visitor).iterate
-        xml_visitor.document
-      end
-      alias to_html to_xml
-      alias to_s to_xml
-
-      def text_command(text)
-        "text \"#{text}\""
-      end
-
-      def rubyize(text)
-        text = text.gsub(/[}]/, '"}')
-        text = text.gsub(/[{]/, '{"')
-        text = text.gsub(/[#]/, '')
-      end
-
-      #override Object default id method and route it to Glimmer engine
-      def id
-        method_missing(:id)
-      end
-    end
-  end
-end

data/lib/glimmer/xml/node_visitor.rb

@@ -1,13 +0,0 @@
-module Glimmer
-  module XML
-    class NodeVisitor
-      def process_before_children
-        raise "must be implemented by a class"
-      end
-
-      def process_after_children
-        raise "must be implemented by a class"
-      end
-    end
-  end
-end

data/lib/glimmer/xml/xml_visitor.rb

@@ -1,65 +0,0 @@
-require File.dirname(__FILE__) + "/node_visitor"
-require File.dirname(__FILE__) + "/node"
-
-module Glimmer
-  module XML
-    class XmlVisitor < NodeVisitor
-
-      attr_reader :document
-
-      def initialize
-        @document = ""
-      end
-
-      def process_before_children(node)
-        if (!node.is_a?(Glimmer::XML::Node))          
-          @document << node.to_s
-          return
-        end
-        begin_open_tag(node)
-        append_attributes(node) if node.attributes
-        end_open_tag(node)
-      end
-
-      def process_after_children(node)
-        return if (!node.is_a?(Glimmer::XML::Node))
-        append_close_tag(node)
-      end
-
-      def begin_open_tag(node)
-        @document << "<"
-        @document << "#{node.name_space.name}:" if node.name_space
-        @document << node.name
-      end
-
-      def end_open_tag(node)
-        if (node.contents)
-          @document << ">"
-        else
-          @document << " " if node.attributes.keys.size > 0
-          @document << "/>"
-        end
-      end
-
-      def append_close_tag(node)
-        if (node.contents)
-          @document << "</"
-          @document << "#{node.name_space.name}:" if node.name_space
-          @document << "#{node.name}>"
-        end
-      end
-
-      def append_attributes(node)
-        Glimmer::Config.logger&.debug "Take 3"
-        Glimmer::Config.logger&.debug(node.attributes)
-        node.attributes.each do |attribute, value|
-          attribute_name = attribute
-          attribute_name = "#{attribute.name_space.name}:#{attribute.name}" if attribute.is_a?(Node)
-          @document << " #{attribute_name}"
-          @document << "=\"#{value}\"" unless value.nil?
-        end
-      end
-
-    end
-  end
-end