metaruby 1.0.0 → 2.0.0

data/lib/metaruby/dsls/find_through_method_missing.rb

@@ -1,5 +1,65 @@
+require 'metaruby/attributes'
+
 module MetaRuby
     module DSLs
+        # Common definition of #respond_to_missing? and #method_missing to be
+        # used in conjunction with {DSLs.find_through_method_missing} and
+        # {DSLs.has_through_method_missing?}
+        #
+        # @example resolve 'event' objects using method_missing
+        #   class Task
+        #      # Tests if this task has an event by this name
+        #      #
+        #      # @param [String] name
+        #      # @return [Boolean]
+        #      def has_event?(name)
+        #      end
+        #
+        #      # Finds an event by name
+        #      #
+        #      # @param [String] name
+        #      # @return [Object,nil] the found event, or nil if there is no
+        #      #   event by this name
+        #      def find_event(name)
+        #      end
+        #
+        #      include MetaRuby::DSLs::FindThroughMethodMissing
+        #
+        #      # Check if the given method matches a find object
+        #      def has_through_method_missing?(m)
+        #        MetaRuby::DSLs.has_through_method_missing?(
+        #           self, m, '_event' => :has_event?) || super
+        #      end
+        #
+        #      # Check if the given method matches a find object
+        #      def find_through_method_missing(m, args)
+        #        MetaRuby::DSLs.find_through_method_missing(
+        #           self, m, args, '_event' => :find_event) || super
+        #      end
+        #   end
+        #
+        module FindThroughMethodMissing
+            # Empty implementation of has_through_method_missing? to allow for
+            # classes to call 'super'
+            def has_through_method_missing?(m)
+            end
+
+            # Empty implementation of find_through_method_missing to allow for
+            # classes to call 'super'
+            def find_through_method_missing(m, args)
+            end
+
+            # Resolves the given method using {#has_through_method_missing?}
+            def respond_to_missing?(m, include_private)
+                has_through_method_missing?(m) || super
+            end
+
+            # Resolves the given method using {#find_through_method_missing}
+            def method_missing(m, *args)
+                find_through_method_missing(m, args) || super
+            end
+        end
+
         # Generic implementation to create suffixed accessors for child objects
         # on a class
         #
@@ -45,32 +105,34 @@ module MetaRuby
         #   object.add_state 'my'
         #   object.my_state # will resolve the 'my' state
         #
-        def self.find_through_method_missing(object, m, args, *suffixes)
-            suffix_match = Hash.new
-            if suffixes.last.kind_of?(Hash)
-                suffix_match.merge!(suffixes.pop)
-            end
-            suffixes.each do |name|
-                suffix_match[name] = "find_#{name}"
-            end
+        def self.find_through_method_missing(object, m, args, suffix_match)
+            return false if m == :to_ary
 
             m = m.to_s
             suffix_match.each do |s, find_method_name|
-                if m == find_method_name
-                    raise NoMethodError.new("#{object} has no method called #{find_method_name}", m)
-                elsif m =~ /(.*)_#{s}$/
-                    name = $1
+                if m.end_with?(s)
+                    name = m[0, m.size - s.size]
                     if !args.empty?
                         raise ArgumentError, "expected zero arguments to #{m}, got #{args.size}", caller(4)
-                    elsif found = object.send(find_method_name, name)
-                        return found
                     else
-                        msg = "#{object} has no #{s} named #{name}"
-                        raise NoMethodError.new(msg, m), msg, caller(4)
+                        return object.send(find_method_name, name)
                     end
                 end
             end
             nil
         end
+
+        def self.has_through_method_missing?(object, m, suffix_match)
+            return false if m == :to_ary
+
+            m = m.to_s
+            suffix_match.each do |s, has_method_name|
+                if m.end_with?(s)
+                    name = m[0, m.size - s.size]
+                    return !!object.send(has_method_name, name)
+                end
+            end
+            false
+        end
     end
 end

data/lib/metaruby/gui.rb

@@ -4,6 +4,7 @@ require 'kramdown'
 require 'pp'
 require 'metaruby/gui/html'
 require 'metaruby/gui/ruby_constants_item_model'
+require 'metaruby/gui/model_hierarchy'
 require 'metaruby/gui/rendering_manager'
 require 'metaruby/gui/model_browser'
 require 'metaruby/gui/model_selector'

data/lib/metaruby/gui/html/exception_view.css

@@ -1,6 +1,6 @@
-.message { font-size: 80%; font-weight: normal; background-color: rgb(176,206,234); text-align: left; }
-.backtrace_links { font-size: 80%; margin-left: 2em;}
-.backtrace { font-size: 80%; background-color: rgb(219,230,241); padding-left: 1em; }
-.backtrace_summary { font-size: 80%; background-color: rgb(219,230,241); padding-left: 1em; }
+.message { font-size: 100%; font-weight: normal; background-color: rgb(176,206,234); text-align: left; }
+.backtrace_links { font-size: 100%; margin-left: 2em;}
+.backtrace { font-size: 100%; background-color: rgb(219,230,241); padding-left: 1em; }
+.backtrace_summary { font-size: 100%; background-color: rgb(219,230,241); padding-left: 1em; }
 .user_file { font-weight: bold; }
 

data/lib/metaruby/gui/html/page_body.rhtml

@@ -3,8 +3,5 @@
 <% end %>
 <% fragments.each do |fragment| %>
     <%= html_fragment(fragment, ressource_dir: ressource_dir) %>
-    <% if fragment.id %>
-        </div>
-    <% end %>
 <% end %>
 

data/lib/metaruby/gui/model_browser.rb

@@ -57,14 +57,19 @@ module MetaRuby
             # A Page object tunes to create URIs for objects that are suitable
             # for {#model_selector}
             class Page < HTML::Page
+                def initialize(model_selector, display_page)
+                    super(display_page)
+                    @model_selector = model_selector
+                end
+
                 # Overloaded from {HTML::Page} to resolve object paths (in the
                 #   constant hierarchy, e.g. A::B::C) into the corresponding
                 #   path expected by {#model_selector} (e.g. /A/B/C)
                 def uri_for(object)
-                    if object.respond_to?(:name) && (obj_name = object.name) && (obj_name =~ /^[\w:]+$/)
-                        path = obj_name.split("::")
-                        "/" + path.join("/")
-                    else super
+                    if resolver = @model_selector.find_resolver_from_model(object)
+                        "/" + resolver.split_name(object).join("/")
+                    else
+                        super
                     end
                 end
             end
@@ -151,9 +156,11 @@ module MetaRuby
             #   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)
+            def register_type(root_model, rendering_class, name, priority = 0, categories: [], resolver: ModelHierarchy::Resolver.new)
+                model_selector.register_type(
+                    root_model, name, priority,
+                    categories: categories, resolver: resolver)
+                manager.register_type(root_model, rendering_class)
             end
 
             # Sets up the widgets that form the central part of the browser
@@ -181,7 +188,7 @@ module MetaRuby
                 end
                 splitter.add_widget(display)
                 splitter.set_stretch_factor(1, 2)
-                self.page = Page.new(display.page)
+                self.page = Page.new(@model_selector, display.page)
 
                 model_selector.connect(SIGNAL('model_selected(QVariant)')) do |mod|
                     mod = mod.to_ruby
@@ -194,20 +201,28 @@ module MetaRuby
             #
             # @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
+                if @page
+                    disconnect(@page, SIGNAL('linkClicked(const QUrl&)'), self, SLOT('linkClicked(const QUrl&)'))
+                    disconnect(@page, SIGNAL('updated()'), self, SLOT('update_exceptions()'))
+                    disconnect(@page, SIGNAL('fileOpenClicked(const QUrl&)'), self, SLOT('fileOpenClicked(const QUrl&)'))
                 end
+                manager.page = page
+                connect(page, SIGNAL('linkClicked(const QUrl&)'), self, SLOT('linkClicked(const QUrl&)'))
                 connect(page, SIGNAL('updated()'), self, SLOT('update_exceptions()'))
                 connect(page, SIGNAL('fileOpenClicked(const QUrl&)'), self, SLOT('fileOpenClicked(const QUrl&)'))
                 connect(manager, SIGNAL('updated()'), self, SLOT('update_exceptions()'))
                 @page = page
             end
 
+            def linkClicked(url)
+                if url.scheme == "link"
+                    path = url.path
+                    path = path.split('/')[1..-1]
+                    select_by_path(*path)
+                end
+            end
+            slots 'linkClicked(const QUrl&)'
+
             signals 'fileOpenClicked(const QUrl&)'
 
             # Call to render the given model
@@ -239,16 +254,16 @@ module MetaRuby
             end
             slots 'update_exceptions()'
 
-            # (see ModelSelector#select_by_module)
+            # (see ModelSelector#select_by_model)
             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)
+            # (see ModelSelector#select_by_model)
+            def select_by_model(model)
+                if model_selector.select_by_model(model)
                     push_to_history(model)
                 end
             end
@@ -289,7 +304,7 @@ module MetaRuby
             def select_by_history_element(h)
                 if h.respond_to?(:to_ary)
                     select_by_path(*h)
-                else select_by_module(h)
+                else select_by_model(h)
                 end
             end
 

data/lib/metaruby/gui/model_hierarchy.rb

@@ -0,0 +1,267 @@
+module MetaRuby
+    module GUI
+        class ModelHierarchy < Qt::StandardItemModel
+            Metadata = Struct.new :name, :search_key, :categories do
+                def merge(other)
+                    a, b = search_key, other.search_key.dup
+                    if a.size < b.size
+                        a, b = b, a
+                    end
+                    b.size.times do |i|
+                        a[i] |= b[i]
+                    end
+                    self.search_key = a
+                    self.categories = categories | other.categories
+                end
+
+                def to_user_role
+                    categories = self.categories.to_a.join(",")
+                    search_key = self.search_key.map do |level_keys|
+                        level_keys.join(",")
+                    end.join(",;,")
+                    ",#{categories},;,#{search_key},"
+                end
+            end
+
+            class Resolver
+                def initialize(root_model)
+                    @root_model = root_model
+                end
+
+                def split_name(model)
+                    name = model.name
+                    split = model.name.split('::')
+                    if name.start_with?('::')
+                        split[1..-1]
+                    else split
+                    end
+                end
+
+                def each_submodel(model)
+                    if model == @root_model
+                        model.each_submodel do |m|
+                            yield(m, !m.name)
+                        end
+                    end
+                end
+            end
+
+            def initialize
+                super()
+                @root_models = Array.new
+            end
+
+            # Find the resolver object that has been responsible for a given
+            # object's discovery
+            #
+            # @return [Object,nil]
+            def find_resolver_from_model(model)
+                @resolver_from_model[model]
+            end
+
+            # Returns the path to the given model or nil if it is not registered
+            def find_path_from_model(model)
+                if resolver = find_resolver_from_model(model)
+                    resolver.split_name(model)
+                end
+            end
+
+            RootModel = Struct.new :model, :priority, :categories, :resolver
+
+            def add_root(root_model, priority, categories: [], resolver: Resolver.new(root_model))
+                @root_models << RootModel.new(root_model, priority, categories, resolver)
+            end
+
+            # Refresh the model to match the current hierarchy that starts with
+            # this object's root model
+            def reload
+                begin_reset_model
+                clear
+
+                @items_to_models = Hash.new
+                @models_to_items = Hash.new
+                @names_to_item = Hash.new
+                @items_metadata = Hash[self => Metadata.new([], [], Set.new)]
+                @resolver_from_model = Hash.new
+
+                seen = Set.new
+                sorted_roots = @root_models.
+                    sort_by(&:priority).reverse
+                
+                sorted_roots.each do |root_model|
+                    models = discover_model_hierarchy(root_model.model, root_model.categories, root_model.resolver, seen)
+                    models.each do |m|
+                        @resolver_from_model[m] = root_model.resolver
+                    end
+                end
+                
+                rowCount.times do |row|
+                    compute_and_store_metadata(item(row))
+                end
+                self.horizontal_header_labels = [""]
+            ensure
+                end_reset_model
+            end
+
+            # Returns the model that matches the QStandardItem
+            #
+            # @return [Object,nil]
+            def find_model_from_item(item)
+                @items_to_models[item]
+            end
+
+            # Returns the model that matches the QModelIndex
+            #
+            # @return [Object,nil]
+            def find_model_from_index(index)
+                @items_to_models[
+                    item_from_index(index)]
+            end
+
+            # @api private
+            #
+            # Compute each item's metadata and stores it in UserRole. The
+            # metadata is stored as
+            # "Category0|Category1;name/with/slashes/between/parts". This is
+            # meant to be used in a seach/filter function.
+            def compute_and_store_metadata(item)
+                current = @items_metadata[item]
+
+                item.rowCount.times do |row|
+                    current.merge compute_and_store_metadata(item.child(row))
+                end
+
+                item.set_data(Qt::Variant.new(current.to_user_role), Qt::UserRole)
+                current
+            end
+
+            # @api private
+            #
+            # Register a model in the hierarchy
+            def register_model(model, model_categories, resolver)
+                name = resolver.split_name(model)
+                if !name || name.empty?
+                    #raise ArgumentError, "cannot resolve #{model.name}"
+                    puts "Cannot resolve #{model}"
+                    return
+                end
+
+                context = name[0..-2].inject(self) do |item, name|
+                    resolve_namespace(item, name)
+                end
+                if !(item = find_item_child_by_name(context, name.last))
+                    item = Qt::StandardItem.new(name.last)
+                    context.append_row(item)
+                    (@names_to_item[context] ||= Hash.new)[name.last] = item
+                end
+
+                item.flags = Qt::ItemIsEnabled
+
+                @items_metadata[item] = Metadata.new(name, name.map { |n| [n] }, model_categories)
+                @items_to_models[item] = model
+                @models_to_items[model] = item
+            end
+
+            # @api private
+            def find_item_child_by_name(item, name)
+                if context = @names_to_item[item]
+                    context[name]
+                end
+            end
+
+            # Returns the QStandardItem object that sits at the given path
+            #
+            # @return [Qt::StandardItem,nil]
+            def find_item_by_path(*path)
+                path.inject(self) do |parent_item, name|
+                    return if !name
+                    if names = @names_to_item[parent_item]
+                        names[name]
+                    end
+                end
+            end
+
+            # Returns the ModelIndex object that sits at the given path
+            #
+            # @return [Qt::ModelIndex,nil]
+            def find_index_by_path(*path)
+                if item = find_item_by_path(*path)
+                    item.index
+                end
+            end
+
+            # Returns the QStandardItem object that represents the given model
+            def find_item_by_model(model)
+                @models_to_items[model]
+            end
+
+            # Returns the QModelIndex object that represents the given model
+            def find_index_by_model(model)
+                if item = find_item_by_model(model)
+                    item.index
+                end
+            end
+
+            # @api private
+            #
+            # Register a model and its whole submodels hierarchy
+            def discover_model_hierarchy(root_model, categories, resolver, seen)
+                discovered = Array.new
+                queue = [root_model]
+                categories = categories.to_set
+
+                while !queue.empty?
+                    m = queue.shift
+                    next if seen.include?(m)
+                    seen << m
+                    discovered << m
+
+                    register_model(m, categories, resolver)
+                    resolver.each_submodel(m) do |model, excluded|
+                        raise if model.kind_of?(String)
+                        if excluded
+                            seen << model
+                        else
+                            queue << model
+                        end
+                    end
+                end
+                discovered
+            end
+
+            # @api private
+            #
+            # Find or create the StandardItem that represents a root in the
+            # hierarchy
+            #
+            # @param [String] name the name of the namespace
+            # @return [Qt::StandardItem]
+            def resolve_root_namespace(name)
+                resolve_namespace(self, name)
+            end
+
+            # @api private
+            #
+            # Find or create the StandardItem that represents a namespace in the
+            # hierarchy
+            #
+            # @param [Qt::StandardItem] parent_item the parent item
+            # @param [String] name the name of the namespace
+            # @return [Qt::StandardItem]
+            def resolve_namespace(parent_item, name)
+                if item = find_item_child_by_name(parent_item, name)
+                    item
+                else
+                    item = Qt::StandardItem.new(name)
+                    item.flags = 0
+
+                    parent_name = @items_metadata[parent_item].name
+                    @items_metadata[item] = Metadata.new(parent_name + [name], [], Set.new)
+                    parent_item.append_row item
+                    (@names_to_item[parent_item] ||= Hash.new)[name] = item
+                end
+            end
+        end
+    end
+end
+