sirens 0.0.1

data/lib/models/list_model.rb

@@ -0,0 +1,173 @@
+require 'observer'
+
+module Sirens
+    class ListModel
+        include Observable
+
+        class << self
+            def with(item)
+                self.on([items])
+            end
+
+            def with_all(items)
+                self.on(items.clone)
+            end
+
+            def on(list)
+                self.new(list)
+            end
+        end
+
+        # Initializing
+
+        def initialize(list = [])
+            super()
+
+            @list = list
+        end
+
+        # Accessing
+
+        def list()
+            @list
+        end
+
+        def set_list(new_list)
+            return if @list == new_list
+
+            old_list = @list
+
+            @list = new_list
+
+            changed
+
+            notify_observers(
+                ListChanged.new(new_list: new_list, old_list: old_list)
+            )
+        end
+
+        def value()
+            list
+        end
+
+        def set_value(new_list)
+            set_list(new_list)
+        end
+
+        # Adding
+
+        ##
+        # Adds the given item at the end of the list.
+        #
+        def <<(item)
+            add_at(items: [item], index: -1)
+        end
+
+        ##
+        # Adds the given items at the end of the list.
+        #
+        def add_at(index:, items:)
+            list.insert(index, *items)
+
+            changed
+
+            notify_observers(
+                ItemsAdded.new(list: list, index: index, items: items)
+            )
+        end
+
+        # Updating
+
+        ##
+        # Updates the items at the given indices in the list.
+        #
+        def update_at(indices:, items:)
+            (0 ... items.size).each do |i|
+                list[ indices[i] ] = items[i]
+            end
+
+            changed
+
+            notify_observers(
+                ItemsUpdated.new(list: list, indices: indices, items: items)
+            )
+        end
+
+        # Removing
+
+        ##
+        # Removes the items at the given indices in the list.
+        #
+        def remove_at(indices:)
+            indices = indices.sort.reverse
+            items = []
+
+            indices.sort.reverse.each do |i|
+                items << list.delete_at(i)
+            end
+
+            changed
+
+            notify_observers(
+                ItemsRemoved.new(list: list, indices: indices, items: items)
+            )
+        end
+
+        # Iterating
+
+        include Enumerable
+
+        def each(&block)
+            @list.each(&block)
+        end
+
+        def [](index)
+            @list[index]
+        end
+
+        def []=(index, value)
+            @list[index] = value
+        end
+    end
+
+    # Announcements
+
+    class ListChanged
+        def initialize(new_list:, old_list:)
+            @new_list = new_list
+            @old_list = old_list
+        end
+
+        attr_reader :new_list, :old_list
+    end
+
+    class ItemsAdded
+        def initialize(list:, index:, items:)
+            @list = list
+            @index = index
+            @items = items
+        end
+
+        attr_reader :list, :index, :items
+    end
+
+    class ItemsUpdated
+        def initialize(list:, indices:, items:)
+            @list = list
+            @indices = indices
+            @items = items
+        end
+
+        attr_reader :list, :indices, :items
+    end
+
+    class ItemsRemoved
+        def initialize(list:, indices:, items:)
+            @list = list
+            @indices = indices
+            @items = items
+        end
+
+        attr_reader :list, :indices, :items
+    end
+end

data/lib/models/tree_choice_model.rb

@@ -0,0 +1,102 @@
+module Sirens
+    class TreeChoiceModel
+
+        # Initializing
+
+        def initialize(selection: nil, roots: [], get_children_block:)
+            super()
+
+            @selection = ValueModel.on(selection)
+            @tree = VirtualTreeModel.on(
+                roots: roots,
+                get_children_block: get_children_block
+            )
+        end
+
+        # Accessing
+
+        ##
+        # Returns the selection model, not the selected item.
+        # This model can be observed for changes.
+        # This model value is an array with the objects path from the tree root object to the selected item.
+        #
+        def selection()
+            @selection
+        end
+
+        ##
+        # Sets the item currently selected.
+        # The objects_hierarchy is an array with the objects path from the tree root object to the
+        # selected item.
+        # The selection model triggers an announcement that its value changed.
+        #
+        def set_selection(objects_hierarchy)
+            @selection.set_value(objects_hierarchy)
+        end
+
+        ##
+        # Sets the item currently selected.
+        # The objects_hierarchy is an array with the objects path from the tree root object to the
+        # selected item.
+        # The selection model triggers an announcement that its value changed.
+        #
+        def set_selection_from_path(path:)
+            objects_hierarchies = objects_hierarchy_at(path: path)
+
+            set_selection(objects_hierarchies)
+        end
+
+        ##
+        # Returns the tree model.
+        # The tree model holds the tree items and announces changes on it.
+        #
+        def tree()
+            @tree
+        end
+
+        ##
+        # Sets the tree model roots.
+        # Announces that the tree changed.
+        #
+        def set_tree_roots(items)
+            @tree.set_roots(items)
+        end
+
+        ##
+        # Returns the item in the tree at the given path.
+        # The path is an array of Integers, each Integer being the index in each level of the tree.
+        # Example:
+        #       [1, 0, 3] returns the item taken from the second root, its first child and its fourth child.
+        #
+        def item_at(path:)
+            @tree.item_at(path: path)
+        end
+
+        ##
+        # Returns an array with the children of the item in the tree at the given path.
+        #
+        def children_at(path:)
+            @tree.children_at(path: path)
+        end
+
+        ##
+        # Given a hierarchy of objects in the tree, returns an array with the path indices.
+        #
+        def path_of(objects_hierarchy)
+            @tree.path_of(objects_hierarchy)
+        end
+
+        ##
+        # Given a path returns an array with the objects on each tree level corresponding to each index in the path.
+        #
+        def objects_hierarchy_at(path:)
+            @tree.objects_hierarchy_at(path: path)
+        end
+
+        # Asking
+
+        def has_selection()
+            ! @selection.value.nil? && ! @selection.value.empty?
+        end
+    end
+end

data/lib/models/value_model.rb

@@ -0,0 +1,56 @@
+require 'observer'
+
+module Sirens
+    class ValueModel
+        include Observable
+
+        class << self
+            def on(value)
+                self.new(value)
+            end
+        end
+
+        # Initializing
+
+        def initialize(value = nil)
+            super()
+
+            @value = value
+        end
+
+        # Accessing
+
+        def value()
+            @value
+        end
+
+        def set_value(new_value)
+            return if value == new_value
+
+            old_value = value
+
+            @value = new_value
+
+            announce_value_changed(new_value: new_value, old_value: old_value)
+        end
+
+        def announce_value_changed(new_value:, old_value:)
+            changed
+
+            notify_observers(
+                ValueChanged.new(new_value: new_value, old_value: old_value)
+            )
+        end
+    end
+
+    # Events
+
+    class ValueChanged
+        def initialize(new_value:, old_value:)
+            @new_value = new_value
+            @old_value = old_value
+        end
+
+        attr_reader :new_value, :old_value
+    end
+end

data/lib/models/virtual_tree_model.rb

@@ -0,0 +1,150 @@
+require 'observer'
+
+module Sirens
+    class VirtualTreeModel
+        include Observable
+
+        class << self
+            def with(root_item)
+                self.on([root_item])
+            end
+
+            def with_all(root_items)
+                self.on(root_items.clone)
+            end
+
+            def on(root_items)
+                self.new(root_items)
+            end
+        end
+
+        # Initializing
+
+        def initialize(roots: [], get_children_block:)
+            super()
+
+            @get_children_block = get_children_block
+
+            @roots = roots.collect{ |item| new_tree_node_on(item) }
+        end
+
+        def new_tree_node_on(item)
+            TreeNode.new(value: item, get_children_block: @get_children_block)
+        end
+
+        # Accessing
+
+        def roots()
+            @roots.collect{ |node| node.value }
+        end
+
+        def set_roots(new_roots)
+            old_roots = roots
+
+            @roots = new_roots.collect{ |item| new_tree_node_on(item) }
+
+            changed
+
+            notify_observers(
+                TreeChanged.new(new_roots: new_roots, old_roots: old_roots)
+            )
+        end
+
+        def node_at(path:)
+            node = @roots[path.first]
+
+            path[1..-1].each do |child_index|
+                node = node.child_at(index: child_index)
+            end
+
+            node
+        end
+
+        def item_at(path:)
+            node_at(path: path).value
+        end
+
+        def children_at(path:)
+            node_at(path: path).children.collect{ |node| node.value }
+        end
+
+        ##
+        # Given a hierarchy of objects in the tree, returns an array with the path indices.
+        #
+        def path_of(objects_hierarchy)
+            objects = @roots
+
+            objects_hierarchy.inject([]) { |path, each_object|
+                index = objects.index { |node| node.value == each_object }
+
+                path << index
+
+                objects = objects[index].children
+
+                path
+            }
+        end
+
+        ##
+        # Given a path returns an array with the objects on each tree level corresponding to each index in the path.
+        #
+        def objects_hierarchy_at(path:)
+            return [] if path.nil?
+
+            nodes = @roots
+
+            path.inject([]) { |hierarchy, index|
+                node = nodes[index]
+
+                hierarchy << node.value
+
+                nodes = node.children
+
+                hierarchy
+            }
+        end
+
+        # Announcements
+
+        class TreeChanged
+            def initialize(new_roots:, old_roots:)
+                @new_roots = new_roots
+                @old_roots = old_roots
+            end
+
+            attr_reader :new_roots, :old_roots
+        end
+
+        # Tree node class
+
+        class TreeNode
+            def initialize(value:, get_children_block:)
+                @value = value
+                @children = nil
+                @get_children_block = get_children_block
+            end
+
+            def value()
+                @value
+            end
+
+            def children()
+                if @children.nil?
+                    @children = get_children.collect{ |item|
+                        self.class.new(value: item, get_children_block: @get_children_block)
+                    }
+                end
+
+                @children
+            end
+
+            def child_at(index:)
+                children[index]
+            end
+
+            def get_children()
+                @get_children_block.call(value)
+            end
+        end
+    end
+end

data/lib/sirens/browsers/module_browser.rb

@@ -0,0 +1,67 @@
+module Sirens
+
+    class ModuleBrowser < Sirens::Component
+
+        def self.open_on(klass: nil)
+            self.open.tap { |browser|
+                if klass.kind_of?(Class)
+                    browser.model.select_class(klass)
+                else
+                    browser.model.select_namespace(namespace)
+                end
+            }
+        end
+
+        # Model
+
+        def default_model()
+            ModuleBrowserModel.new
+        end
+
+        # Building
+
+        def renderWith(layout)
+            browser_model = model
+
+            layout.render do |component|
+
+                window do
+
+                    styles title: 'Namespace Browser',
+                        width: 900,
+                        height: 400
+
+                    vertical_splitter do
+
+                        horizontal_splitter do
+
+                            styles splitter_proportion: 1.0/2.0
+
+                            component NamespacesList.new(
+                                model: browser_model.namespaces,
+                                splitter_proportion: 1.0/4.0
+                            )
+
+                            component ModulesList.new(
+                                model: browser_model.modules,
+                                splitter_proportion: 1.0/4.0,
+                            )
+
+                            component ClassBrowser.new(
+                                model: browser_model,
+                                splitter_proportion: 2.0/4.0
+                            )
+                        end
+
+                        component MethodSourceCode.new(
+                            model: browser_model.method_source_code,
+                            splitter_proportion: 1.0/2.0
+                        )
+
+                    end
+
+                end
+            end
+        end
+    end
+end

data/lib/sirens/browsers/object_browser.rb

@@ -0,0 +1,103 @@
+module Sirens
+
+    class ObjectBrowser < Sirens::Component
+
+        def self.open_on(object:)
+            self.open.tap { |browser|
+                browser.model.object.set_value(object)
+            }
+        end
+
+        # Model
+
+        def default_model()
+            ObjectBrowserModel.new
+        end
+
+        # Building
+
+        def renderWith(layout)
+            browser_model = model
+
+            layout.render do |component|
+
+                window do
+
+                    styles title: 'Object Browser',
+                        width: 400,
+                        height: 400
+
+                    vertical_splitter do
+
+                        choices_tree do
+                            model browser_model.object_instance_variables
+
+                            styles splitter_proportion: 2.0/3.0
+
+                            handlers on_selection_action: proc { |index_path:, item:|
+                                component.browse(object: item.value)
+                            }
+
+                            column label: 'Instance variables',
+                                get_text_block: proc { |inst_var| inst_var.display_string }
+
+                            popup_menu { |menu:, menu_owner:|
+                                selected_object = component.model.selected_inst_var_value
+
+                                menu.item label: 'Browse it', enabled: ! selected_object.nil?,
+                                    action: proc{ component.browse(object: selected_object) }
+
+                                menu.separator
+
+                                menu.item label: 'Browse class', enabled: ! selected_object.nil?,
+                                    action: proc{ component.browse_class_of(object: selected_object) }
+                            }
+                        end
+
+                        text do
+                            model browser_model.text
+
+                            styles(
+                                splitter_proportion: 1.0/3.0,
+                                wrap_mode: :char
+                            )
+
+                            popup_menu { |menu:, menu_owner:|
+                                selected_text = menu_owner.selected_text
+
+                                menu.separator
+
+                                menu.item label: 'Browse it', enabled: ! selected_text.nil?,
+                                    action: proc{ component.browse_text_selection(text: selected_text) }
+                            }
+                        end
+
+                    end
+                end
+            end
+        end
+
+        # Actions
+
+        def browse(object:)
+            Sirens.browse(object: object)
+        end
+
+        def browse_class_of(object:)
+            Sirens.browse(klass: object.class)
+        end
+
+        def browse_text_selection(text:)
+            selected_object = model.selected_inst_var_value
+
+            evaluation_result =
+                begin
+                    selected_object.instance_exec { eval(text) }
+                rescue Exception => e
+                    e
+                end
+
+            browse(object: evaluation_result)
+        end
+    end
+end

data/lib/sirens/components/ancestors_list.rb

@@ -0,0 +1,22 @@
+module Sirens
+    class AncestorsList < Sirens::Component
+
+        # Building
+
+        def renderWith(layout)
+
+            layout.render do |component|
+                choices_list do
+                    model component.model
+
+                    styles(
+                        show_headers: true
+                    )
+
+                    column label: 'Module ancestors',
+                        get_text_block: proc{ |a_module| a_module.name }
+                end
+            end
+        end
+    end
+end

data/lib/sirens/components/class_browser.rb

@@ -0,0 +1,38 @@
+module Sirens
+    class ClassBrowser < Sirens::Component
+
+        # Building
+
+        def renderWith(layout)
+            browser_model = model
+
+            layout.render do |component|
+                horizontal_splitter do
+                    component AncestorsList.new(
+                        model: browser_model.module_ancestors,
+                        splitter_proportion: 1.0/3.0
+                    )
+
+                    tabs do
+                        styles splitter_proportion: 2.0/3.0
+
+                        component MethodsList.new(
+                            model: browser_model.methods,
+                            instance_or_class_methods_chooser: browser_model.instance_or_class_methods_chooser,
+                            show_inherit_methods: browser_model.show_inherit_methods,
+                            show_public_methods: browser_model.show_public_methods,
+                            show_protected_methods: browser_model.show_protected_methods,
+                            show_private_methods: browser_model.show_private_methods,
+                            tab_label: 'Methods'
+                        )
+
+                        component ConstantsList.new(
+                            model: browser_model.constants,
+                            tab_label: 'Constants'
+                        )
+                    end
+                end
+            end
+        end
+    end
+end