metaruby 1.0.0.rc1

data/lib/metaruby/gui/html.rb

@@ -0,0 +1,16 @@
+require 'metaruby/gui/html/button'
+require 'metaruby/gui/html/page'
+require 'metaruby/gui/html/collection'
+
+module MetaRuby
+    module GUI
+        module HTML
+            def self.escape_html(string)
+                string.
+                    gsub('<', '&lt;').
+                    gsub('>', '&gt;')
+            end
+        end
+    end
+end
+

data/lib/metaruby/gui/model_browser.rb

@@ -0,0 +1,262 @@
+module MetaRuby
+    module GUI
+        # Widget that allows to browse the currently available models and
+        # display information about them
+        #
+        # It contains a model selection widget, which lists all available models
+        # and allows to select them, and a visualization pane in which the
+        # corresponding model visualizations are rendered as HTML
+        #
+        # The object display itself is delegated to rendering objects. These
+        # objects must respond to:
+        #
+        #   #enable: enable this renderer. This is called so that the rendering
+        #     object listens to relevant Qt signals if it has e.g. the ability to
+        #     interact with the user through HTML buttons
+        #   #disable: disables this renderer. This is called so that the rendering
+        #     object can stop listening to relevant Qt signals if it has e.g. the ability to
+        #     interact with the user through HTML buttons
+        #   #clear: clear existing data
+        #   #render(model): render the given model
+        #
+        class ModelBrowser < Qt::Widget
+            # @return [ModelSelector] the widget that lists available models and
+            #   allows to select them
+            attr_reader :model_selector
+            # @return [Page] the page object that handles compositing the
+            #   results of different rendering objects, as well as the ability
+            #   to e.g. handle buttons
+            attr_reader :page
+            # @return [Qt::WebView] the HTML view widget
+            attr_reader :display
+            # @return [ExceptionView] view that allows to display errors to the
+            #   user
+            attr_reader :exception_view
+            # @return [Qt::PushButton] button that causes model reloading
+            attr_reader :btn_reload_models
+            # @return [RenderingManager] the object that manages all the
+            #   rendering objects available
+            attr_reader :manager
+            # @return [Array<Exception>] set of exceptions raised during the
+            #   last rendering step
+            attr_reader :registered_exceptions
+            # @return [Array<Model,[String]>] the browsing history, as either
+            #   direct modules or module name path (suitable to be given to
+            #   #select_by_path)
+            attr_reader :history
+            # @return [Integer] the index of the current link in the history
+            attr_reader :history_index
+
+            # A Page object with a #link_to method that is suitable for the
+            # model browser
+            class Page < HTML::Page
+                def uri_for(object)
+                    if (obj_name = object.name) && (obj_name =~ /^[\w:]+$/)
+                        path = obj_name.split("::")
+                        "/" + path.join("/")
+                    else super
+                    end
+                end
+            end
+
+
+            def initialize(main = nil)
+                super
+
+                @manager = RenderingManager.new
+
+                main_layout = Qt::VBoxLayout.new(self)
+
+                menu_layout = Qt::HBoxLayout.new
+                main_layout.add_layout(menu_layout)
+                central_layout = Qt::HBoxLayout.new
+                main_layout.add_layout(central_layout, 3)
+                splitter = Qt::Splitter.new(self)
+                central_layout.add_widget(splitter)
+                @exception_view = ExceptionView.new
+                main_layout.add_widget(exception_view, 1)
+
+                @available_renderers = Hash.new
+                @registered_exceptions = Array.new
+
+                @btn_reload_models = Qt::PushButton.new("Reload", self)
+                menu_layout.add_widget(btn_reload_models)
+                menu_layout.add_stretch(1)
+                update_exceptions
+
+                @history = Array.new
+                @history_index = -1
+
+                add_central_widgets(splitter)
+                setTabOrder(model_selector, display)
+                setTabOrder(display, btn_reload_models)
+            end
+
+            # Update the model selector after {register_type} got called
+            def update_model_selector
+                model_selector.update
+            end
+
+            # Registers a certain kind of model as well as the information
+            # needed to display it
+            #
+            # It registers the given type on the model browser so that it gets
+            # displayed there.
+            #
+            # You must call {update_model_selector} after this call for the
+            # modification to have any effect (i.e. for the newly registered
+            # models to appear on the selector)
+            #
+            # @param [Model] type the base model class for the models that are
+            #   considered here
+            # @param [Class] rendering_class a class from which a relevant
+            #   rendering object can be created. The generated instances must
+            #   follow the rules described in the documentation of
+            #   {ModelBrowser}
+            # @param [String] name the name that should be used for this
+            #   category
+            # @param [Integer] priority the priority of this category. Some
+            #   models might be submodels of various types at the same time (as
+            #   e.g. when both a model and its supermodel are registered here).
+            #   The one with the highest priority will be used.
+            def register_type(type, rendering_class, name, priority = 0)
+                model_selector.register_type(type, name, priority)
+                manager.register_type(type, rendering_class)
+            end
+
+            # Sets up the widgets that form the central part of the browser
+            def add_central_widgets(splitter)
+                @model_selector = ModelSelector.new
+                splitter.add_widget(model_selector)
+
+                # Create a central stacked layout
+                display = @display = Qt::WebView.new
+                browser = self
+                display.singleton_class.class_eval do
+                    define_method :contextMenuEvent do |event|
+                        menu = Qt::Menu.new(self)
+                        act = page.action(Qt::WebPage::Back)
+                        act.enabled = true
+                        menu.add_action act
+                        connect(act, SIGNAL(:triggered), browser, SLOT(:back))
+                        act = page.action(Qt::WebPage::Forward)
+                        act.enabled = true
+                        connect(act, SIGNAL(:triggered), browser, SLOT(:forward))
+                        menu.add_action act
+                        menu.popup(event.globalPos)
+                        event.accept
+                    end
+                end
+                splitter.add_widget(display)
+                splitter.set_stretch_factor(1, 2)
+                self.page = Page.new(display.page)
+
+                model_selector.connect(SIGNAL('model_selected(QVariant)')) do |mod|
+                    mod = mod.to_ruby
+                    push_to_history(mod)
+                    render_model(mod)
+                end
+            end
+
+            # Sets the page object that should be used for rendering
+            #
+            # @param [Page] page the new page object
+            def page=(page)
+                manager.page = page
+                page.connect(SIGNAL('linkClicked(const QUrl&)')) do |url|
+                    if url.scheme == "link"
+                        path = url.path
+                        path = path.split('/')[1..-1]
+                        select_by_path(*path)
+                    end
+                end
+                connect(page, SIGNAL('updated()'), self, SLOT('update_exceptions()'))
+                connect(manager, SIGNAL('updated()'), self, SLOT('update_exceptions()'))
+                @page = page
+            end
+
+            # Call to render the given model
+            #
+            # @param [Model] mod the model that should be rendered
+            # @raises [ArgumentError] if there is no view available for the
+            #   given model
+            def render_model(mod, options = Hash.new)
+                page.clear
+                @registered_exceptions.clear
+                reference_model, _ = manager.find_renderer(mod)
+                if mod
+                    page.title = "#{mod.name} (#{reference_model.name})"
+                    begin
+                        manager.render(mod, options)
+                    rescue ::Exception => e
+                        @registered_exceptions << e
+                    end
+                else
+                    @registered_exceptions << ArgumentError.new("no view available for #{mod} (#{mod.class})")
+                end
+                update_exceptions
+            end
+
+            # Updates {#exception_view} from the set of registered exceptions
+            def update_exceptions
+                exception_view.exceptions = registered_exceptions +
+                    manager.registered_exceptions
+            end
+            slots 'update_exceptions()'
+
+            # (see ModelSelector#select_by_module)
+            def select_by_path(*path)
+                if model_selector.select_by_path(*path)
+                    push_to_history(path)
+                end
+            end
+
+            # (see ModelSelector#select_by_module)
+            def select_by_module(model)
+                if model_selector.select_by_module(model)
+                    push_to_history(model)
+                end
+            end
+
+            # (see ModelSelector#current_selection)
+            def current_selection
+                model_selector.current_selection
+            end
+
+            # Pushes one element in the history
+            #
+            # If the history index is not at the end, the remainder is discarded
+            def push_to_history(object)
+                return if object == history[history_index]
+
+                @history = history[0, history_index + 1]
+                history << object
+                @history_index = history.size - 1
+            end
+
+            # Go forward in the browsing history
+            def forward
+                return if history_index == history.size - 1
+                @history_index += 1
+                select_by_history_element(history[history_index])
+            end
+
+            # Go back in the browsing history
+            def back
+                return if history_index <= 0
+                @history_index -= 1
+                select_by_history_element(history[history_index])
+            end
+
+            slots :back, :forward
+
+            # Selects a given model based on a value in the history
+            def select_by_history_element(h)
+                if h.respond_to?(:to_ary)
+                    select_by_path(*h)
+                else select_by_module(h)
+                end
+            end
+        end
+    end
+end

data/lib/metaruby/gui/model_selector.rb

@@ -0,0 +1,266 @@
+module MetaRuby
+    module GUI
+        # A Qt widget that allows to browse the models registered in the Ruby
+        # constanat hierarchy
+        class ModelSelector < Qt::Widget
+            attr_reader :btn_type_filter_menu
+            attr_reader :type_filters
+            attr_reader :model_list
+            attr_reader :model_filter
+            # @return [Qt::LineEdit] the line edit widget that allows to modify
+            #   the tree view filter
+            attr_reader :filter_box
+            # @return [Qt::Completer] auto-completion for {filter_box}
+            attr_reader :filter_completer
+            attr_reader :type_info
+            attr_reader :browser_model
+
+            def initialize(parent = nil)
+                super
+
+                @type_info = Hash.new
+                @type_filters = Hash.new
+
+                layout = Qt::VBoxLayout.new(self)
+                filter_button = Qt::PushButton.new('Filters', self)
+                layout.add_widget(filter_button)
+                @btn_type_filter_menu = Qt::Menu.new
+                filter_button.menu = btn_type_filter_menu
+
+                setup_tree_view(layout)
+                setTabOrder(filter_box, filter_button)
+                setTabOrder(filter_button, model_list)
+            end
+
+            def register_type(model_base, name, priority = 0)
+                type_info[model_base] = RubyConstantsItemModel::TypeInfo.new(name, priority)
+                action = Qt::Action.new(name, self)
+                action.checkable = true
+                action.checked = true
+                type_filters[model_base] = action
+                btn_type_filter_menu.add_action(action)
+                connect(action, SIGNAL('triggered()')) do
+                    update_model_filter
+                end
+            end
+
+            def update
+                update_model_filter
+                reload
+            end
+
+            def update_model_filter
+                type_rx = type_filters.map do |model_base, act|
+                    if act.checked?
+                        type_info[model_base].name
+                    end
+                end
+                type_rx = type_rx.compact.join("|")
+
+                model_filter.filter_role = Qt::UserRole # this contains the keywords (ancestry and/or name)
+                # This workaround a problem that I did not have time to
+                # investigate. Adding new characters to the filter updates the
+                # browser just fine, while removing some characters does not
+                #
+                # This successfully resets the filter
+                model_filter.filter_reg_exp = Qt::RegExp.new("")
+                # The pattern has to match every element in the hierarchy. We
+                # achieve this by making the suffix part optional
+                name_rx = filter_box.text.downcase.gsub(/:+/, "/")
+                model_filter.filter_reg_exp = Qt::RegExp.new("(#{type_rx}).*;.*#{name_rx}")
+                auto_open
+            end
+
+            def auto_open(threshold = 5)
+                current_level = [Qt::ModelIndex.new]
+                while !current_level.empty?
+                    count = current_level.inject(0) do |total, index|
+                        total + model_filter.rowCount(index)
+                    end
+                    close_this_level = (count > threshold)
+                    current_level.each do |index|
+                        model_filter.rowCount(index).times.each do |row|
+                            model_list.setExpanded(model_filter.index(row, 0, index), !close_this_level)
+                        end
+                    end
+                    return if close_this_level
+
+                    last_level, current_level = current_level, []
+                    last_level.each do |index|
+                        model_filter.rowCount(index).times.each do |row|
+                            current_level << model_filter.index(row, 0, index)
+                        end
+                    end
+                end
+            end
+
+            def model?(obj)
+                type_info.any? do |model_base, _|
+                    obj.kind_of?(model_base) ||
+                        (obj.kind_of?(Module) && obj <= model_base)
+                end
+            end
+
+            class ModelPathCompleter < Qt::Completer
+                def splitPath(path)
+                    path.split('/')
+                end
+                def pathFromIndex(index)
+                    index.data(Qt::UserRole).split(";").last
+                end
+            end
+
+            def all_leaves(model, limit = nil, item = Qt::ModelIndex.new, result = [])
+                if !model.hasChildren(item)
+                    result << item
+                    return result
+                end
+
+                row, child_item = 0, model.index(0, 0, item)
+                while child_item.valid?
+                    all_leaves(model, limit, child_item, result)
+                    if limit && result.size == limit
+                        return result
+                    end
+                    row += 1
+                    child_item = model.index(row, 0, item)
+                end
+                return result
+            end
+
+            def select_first_item
+                if item = all_leaves(model_filter, 1).first
+                    model_list.setCurrentIndex(item)
+                end
+            end
+
+            def setup_tree_view(layout)
+                @model_list = Qt::TreeView.new(self)
+                @model_filter = Qt::SortFilterProxyModel.new
+                model_filter.filter_case_sensitivity = Qt::CaseInsensitive
+                model_filter.dynamic_sort_filter = true
+                model_filter.filter_role = Qt::UserRole
+                model_list.model = model_filter
+
+                @filter_box = Qt::LineEdit.new(self)
+                filter_box.connect(SIGNAL('textChanged(QString)')) do |text|
+                    update_model_filter
+                end
+                filter_box.connect(SIGNAL('returnPressed()')) do |text|
+                    select_first_item
+                end
+                @filter_completer = ModelPathCompleter.new(browser_model, self)
+                filter_completer.case_sensitivity = Qt::CaseInsensitive
+                filter_box.completer = filter_completer
+                layout.add_widget(filter_box)
+                layout.add_widget(model_list)
+
+                model_list.selection_model.connect(SIGNAL('currentChanged(const QModelIndex&, const QModelIndex&)')) do |index, _|
+                    index = model_filter.map_to_source(index)
+                    mod = browser_model.info_from_index(index)
+                    if model?(mod.this)
+                        emit model_selected(Qt::Variant.from_ruby(mod.this, mod.this))
+                    end
+                end
+            end
+            signals 'model_selected(QVariant)'
+
+            def reload
+                if current = current_selection
+                    current_module = current.this
+                    current_path = []
+                    while current
+                        current_path.unshift current.name
+                        current = current.parent
+                    end
+                end
+
+                @browser_model = RubyConstantsItemModel.new(type_info) do |mod|
+                    model?(mod)
+                end
+                browser_model.reload
+                model_filter.source_model = browser_model
+
+                if current_path && !select_by_path(*current_path)
+                    select_by_module(current_module)
+                end
+            end
+
+            # Resets the current filter
+            def reset_filter
+                # If there is a filter, reset it and try again
+                if !filter_box.text.empty?
+                    filter_box.text = ""
+                    true
+                end
+            end
+
+            # Maps a model index from the source index to the filtered index,
+            # e.g. to select something in the view.
+            #
+            # In addition to the normal map_from_source call, it allows to
+            # control whether the filter should be reset if the index given as
+            # parameter is currently filtered out
+            #
+            # @param [Qt::ModelIndex] an index valid in {browser_model}
+            # @option options [Boolean] :reset_filter (true) if true, the filter
+            #   is reset if the requested index is currently filtered out
+            # @return [Qt::ModelIndex] an index filtered by {model_filter}
+            def map_index_from_source(source_index, options = Hash.new)
+                options = Kernel.validate_options options, :reset_filter => true
+                index = model_filter.map_from_source(source_index)
+                if !index
+                    return
+                elsif !index.valid?
+                    if !options[:reset_filter]
+                        return index
+                    end
+                    reset_filter
+                    model_filter.map_from_source(source_index)
+                else index
+                end
+            end
+
+            # Selects the current model given a path in the constant names
+            # This emits the model_selected signal
+            #
+            # @return [Boolean] true if the path resolved to something known,
+            #   and false otherwise
+            def select_by_path(*path)
+                if index = browser_model.find_index_by_path(*path)
+                    index = map_index_from_source(index)
+                    model_list.selection_model.set_current_index(index, Qt::ItemSelectionModel::ClearAndSelect)
+                    true
+                end
+            end
+
+            # Selects the given model if it registered in the model list
+            # This emits the model_selected signal
+            #
+            # @return [Boolean] true if the path resolved to something known,
+            #   and false otherwise
+            def select_by_module(model)
+                if index = browser_model.find_index_by_model(model)
+                    index = map_index_from_source(index)
+                    model_list.selection_model.set_current_index(index, Qt::ItemSelectionModel::ClearAndSelect)
+                    true
+                end
+            end
+
+            # Returns the currently selected item
+            # @return [RubyModuleModel::ModuleInfo,nil] nil if there are no
+            #   selections
+            def current_selection
+                index = model_list.selection_model.current_index
+                if index.valid?
+                    index = model_filter.map_to_source(index)
+                    browser_model.info_from_index(index)
+                end
+            end
+
+            def object_paths
+                browser_model.object_paths
+            end
+        end
+    end
+end

data/lib/metaruby/gui/rendering_manager.rb

@@ -0,0 +1,112 @@
+module MetaRuby
+    module GUI
+        class RenderingManager < Qt::Object
+            # @return [#push] the page object on which we render
+            attr_reader :page
+            # @return [{Model=>Object}] set of rendering objects that are
+            #   declared. The Model is a class or module that represents the
+            #   set of models that the renderer can handle.
+            #   It is ordered by order of priority, i.e. the first model that
+            #   matches will be used.
+            #   Do not modify directly, use {#register_type} instead
+            attr_reader :available_renderers
+            # The last used rendering objects
+            attr_reader :current_renderer
+
+            def initialize(page = nil)
+                super()
+                @page = page
+                @available_renderers = Hash.new
+            end
+
+            def registered_exceptions
+                if current_renderer.respond_to?(:registered_exceptions)
+                    current_renderer.registered_exceptions
+                else []
+                end
+            end
+
+            # Registers a certain kind of model as well as the information
+            # needed to display it
+            #
+            # It registers the given type on the model browser so that it gets
+            # displayed there.
+            #
+            # @param [Class] type the base model class for the models that are
+            #   considered here
+            # @param [Class] rendering_class a class from which a relevant
+            #   rendering object can be created. The generated instances must
+            #   follow the rules described in the documentation of
+            #   {ModelBrowser}
+            def register_type(type, rendering_class, render_options = Hash.new)
+                render = if rendering_class.kind_of?(Class)
+                             rendering_class.new(page)
+                         else
+                             rendering_class
+                         end
+                available_renderers[type] = [render, render_options]
+                connect(render, SIGNAL('updated()'), self, SIGNAL('updated()'))
+            end
+
+            # Changes on which page this rendering manager should act
+            def page=(page)
+                return if @page == page
+                @page = page
+                @available_renderers = available_renderers.map_value do |key, (value, render_options)|
+                    new_render = value.class.new(page)
+                    disconnect(value, SIGNAL('updated()'))
+                    connect(new_render, SIGNAL('updated()'), self, SIGNAL('updated()'))
+                    [new_render, render_options]
+                end
+            end
+
+            def find_renderer(mod)
+                available_renderers.find do |model, _|
+                    mod.kind_of?(model) || (mod.kind_of?(Module) && model.kind_of?(Module) && mod <= model)
+                end
+            end
+
+            def disable
+                if current_renderer
+                    current_renderer.disable
+                end
+            end
+
+            def enable
+                if current_renderer
+                    current_renderer.enable
+                end
+            end
+
+            def clear
+                if current_renderer
+                    current_renderer.clear
+                end
+            end
+
+
+            # Call to render the given model
+            #
+            # @param [Model] mod the model that should be rendered
+            # @raises [ArgumentError] if there is no view available for the
+            #   given model
+            def render(object, push_options = Hash.new)
+                _, (renderer, render_options) = find_renderer(object)
+                if renderer
+                    if current_renderer
+                        current_renderer.clear
+                        current_renderer.disable
+                    end
+                    renderer.enable
+                    renderer.render(object, render_options.merge(push_options))
+                    @current_renderer = renderer
+                else
+                    Kernel.raise ArgumentError, "no view available for #{object} (#{object.class})"
+                end
+            end
+
+            signals 'updated()'
+        end
+    end
+end
+