sirens 0.0.1

data/lib/sirens/components/constants_list.rb

@@ -0,0 +1,22 @@
+module Sirens
+
+    class ConstantsList < Sirens::Component
+
+        # Building
+
+        def renderWith(layout)
+            layout.render do |component|
+                choices_list do
+                    model component.model
+
+                    styles(
+                        show_headers: false
+                    )
+
+                    column label: 'Constants',
+                        get_text_block: proc{ |constant| constant.display_string }
+                end
+            end
+        end
+    end
+end

data/lib/sirens/components/method_source_code.rb

@@ -0,0 +1,22 @@
+module Sirens
+    class MethodSourceCode < Sirens::Component
+
+        # Building
+
+        def renderWith(layout)
+            layout.render do |component|
+                vertical_stack do
+                    text do
+                        model component.model.source_code
+                    end
+
+                    input_text do
+                        model component.model.location
+
+                        styles stack_expand: false
+                    end
+                end
+            end
+        end
+    end
+end

data/lib/sirens/components/methods_list.rb

@@ -0,0 +1,63 @@
+module Sirens
+
+    class MethodsList < Sirens::Component
+
+        # Building
+
+        def renderWith(layout)
+            layout.render do |component|
+                vertical_stack do
+
+                     horizontal_stack do
+                         styles(
+                             height: 30,
+                             stack_expand: false
+                         )
+
+                        radio_buttons_group do
+                            radio_button label: 'instance',
+                                id: :instance,
+                                model: component.props[:instance_or_class_methods_chooser],
+                                stack_expand: false
+
+                            radio_button label: 'class',
+                                id: :class,
+                                model: component.props[:instance_or_class_methods_chooser],
+                                stack_expand: false
+                        end
+
+                        checkbox label: 'include inherit',
+                            model: component.props[:show_inherit_methods]
+                     end
+
+                    choices_list do
+                        model component.model
+
+                        styles id: :methods_list,
+                            show_headers: false
+
+                        column label: 'Methods',
+                            get_text_block: proc{ |method| method }
+                    end
+
+                    horizontal_stack do
+                        styles(
+                            height: 30,
+                            stack_expand: false
+                        )
+
+                        checkbox label: 'public',
+                            model: component.props[:show_public_methods]
+
+                        checkbox label: 'protected',
+                            model: component.props[:show_protected_methods]
+
+                        checkbox label: 'private',
+                            model: component.props[:show_private_methods]
+                    end
+
+                end
+            end
+        end
+    end
+end

data/lib/sirens/components/modules_list.rb

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

data/lib/sirens/components/namespaces_list.rb

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

data/lib/sirens/models/constant_model.rb

@@ -0,0 +1,21 @@
+module Sirens
+    class ConstantModel
+
+        # Initializing
+
+        def initialize(name:, value:)
+            super()
+
+            @name = name
+            @value = value
+        end
+
+        attr_reader :name, :value
+
+        def display_string()
+            value_print_string = value.inspect
+
+            "#{name} = #{value_print_string}"
+        end
+    end
+end

data/lib/sirens/models/method_model.rb

@@ -0,0 +1,111 @@
+require 'stringio'
+
+module Sirens
+    class MethodModel
+
+        # Initializing
+
+        def initialize()
+            super()
+
+            @method_name = ValueModel.new
+            @location = ValueModel.new
+            @source_code = ValueModel.new
+        end
+
+        attr_reader :method_name,
+            :location,
+            :source_code
+
+        def set_method(method)
+            if method.nil?
+                method_name.set_value(nil)
+                location.set_value(nil)
+                source_code.set_value(nil)
+
+                return
+            end
+
+            method_name.set_value(method.name)
+
+            method_filename, method_line_number = method.source_location
+
+            location.set_value("#{method_filename}:#{method_line_number}")
+
+            source_code.set_value(
+                get_source_code_of(method: method, filename: method_filename, line_number: method_line_number)
+            )
+        end
+
+        def get_source_code_of(method:, filename:, line_number:)
+            return 'Native method' if filename.nil? || ! File.exists?(filename)
+
+            source_code = StringIO.new
+
+            lines = File.read(filename).lines
+
+            method_comment = ''
+            comment_line = line_number - 1
+            while line_number >= 0
+                line = lines[comment_line - 1]
+
+                break if ! /^\s*#/.match(line)
+
+                method_comment = line + method_comment
+
+                comment_line -= 1
+            end
+
+            source_code.write(method_comment)
+
+            tail = lines[line_number -1 .. -1].join
+
+            stream = StringIO.new(tail)
+
+            counter = 0
+
+            keywords = ['module', 'class', 'def', 'if', 'while', 'do', 'begin']
+
+            while !stream.eof?
+
+                while !stream.eof? && (c = stream.getc) == ' '
+                    source_code.write(' ')
+                end
+
+                stream.ungetc(c)
+
+                token = stream.gets(' ')
+
+                source_code.write(token)
+
+                token = token.strip
+
+                if token == 'end'
+                    counter -= 1
+                elsif keywords.include?(token)
+                    counter += 1
+                end
+
+                break if counter == 0
+            end
+
+            fix_indentation(source_code.string)
+        end
+
+        def fix_indentation(source_code)
+            lines = source_code.lines
+
+            indentation = 0
+
+            /^(\s*).*$/.match(lines.first) do |matches|
+                indentation = matches[1].size
+            end
+
+            lines = lines.collect { |line|
+                line.gsub!(/^\s{#{indentation}}/, '')
+            }
+
+            lines.join
+        end
+    end
+end

data/lib/sirens/models/module_browser_model.rb

@@ -0,0 +1,225 @@
+module Sirens
+    class ModuleBrowserModel
+
+        # Initializing
+
+        def initialize()
+            super()
+
+            @namespaces = TreeChoiceModel.new(
+                selection: nil,
+                roots: get_root_namespaces,
+                get_children_block: proc { |namespace| get_modules_in(namespace) }
+            )
+
+            @modules = ChoiceModel.new(selection: nil, choices: [])
+            @module_ancestors = ChoiceModel.new(selection: nil, choices: [])
+            @methods = ChoiceModel.new(selection: nil, choices: [])
+            @constants = ChoiceModel.new(selection: nil, choices: [])
+
+            @instance_or_class_methods_chooser = ChoiceModel.new(selection: :instance, choices: [:instance, :class])
+            @show_inherit_methods = ValueModel.on(false)
+
+            @show_public_methods = ValueModel.on(true)
+            @show_protected_methods = ValueModel.on(false)
+            @show_private_methods = ValueModel.on(false)
+
+            @method_source_code = MethodModel.new
+
+            connect_models
+        end
+
+        attr_reader :namespaces,
+            :modules,
+            :module_ancestors,
+            :methods,
+            :constants,
+            :instance_or_class_methods_chooser,
+            :show_public_methods,
+            :show_protected_methods,
+            :show_private_methods,
+            :show_inherit_methods,
+            :method_source_code
+
+        def connect_models()
+            @namespaces.selection.add_observer(self, :on_namespace_changed)
+            @modules.selection.add_observer(self, :on_class_changed)
+            @module_ancestors.selection.add_observer(self, :on_module_changed)
+            @methods.selection.add_observer(self, :on_method_changed)
+
+            @instance_or_class_methods_chooser.selection.add_observer(self, :on_methods_filter_changed)
+            @show_inherit_methods.add_observer(self, :on_methods_filter_changed)
+
+            @show_public_methods.add_observer(self, :on_methods_filter_changed)
+            @show_protected_methods.add_observer(self, :on_methods_filter_changed)
+            @show_private_methods.add_observer(self, :on_methods_filter_changed)
+        end
+
+        # Actions
+
+        def actual_namespace_hierarchy(a_module)
+            namespaces = a_module.name.split('::')
+
+            namespaces.pop if a_module.kind_of?(Class)
+
+            hierarchy = [Object]
+
+            namespaces.each { |module_name|
+                hierarchy << hierarchy.last.const_get(module_name)
+            }
+
+            hierarchy
+        end
+
+        def select_namespace(namespace)
+            hierarchy = actual_namespace_hierarchy(namespace)
+
+            @namespaces.set_selection(hierarchy)
+        end
+
+        def select_class(a_class)
+            hierarchy = actual_namespace_hierarchy(a_class)
+
+            @namespaces.set_selection(hierarchy)
+            @modules.set_selection(a_class)
+            @module_ancestors.set_selection(a_class)
+        end
+
+        # Events
+
+        def on_namespace_changed(announcement)
+            namespace_hierarchy = announcement.new_value
+
+            modules.set_choices(get_modules_in(namespace_hierarchy.last))
+        end
+
+        def on_class_changed(announcement)
+            a_class = announcement.new_value
+
+            ancestors = get_all_ancestors_of(a_class)
+
+            module_ancestors.set_choices(ancestors)
+
+            module_ancestors.set_selection(ancestors.last) unless ancestors.empty?
+        end
+
+        def on_module_changed(announcement)
+            on_methods_filter_changed()
+        end
+
+        def on_methods_filter_changed(announcement = nil)
+            a_module = module_ancestors.selection.value
+
+            methods.set_choices(get_all_methods_in(a_module))
+            constants.set_choices(get_all_constants_in(a_module))
+        end
+
+        def on_method_changed(announcement)
+            method_name = announcement.new_value
+
+            if method_name.nil?
+                method_source_code.set_method(nil)
+                return
+            end
+
+            a_module = module_ancestors.selection.value
+
+            if showing_instance_methods?
+                method = a_module.instance_method(method_name)
+            else
+                method = a_module.method(method_name)
+            end
+
+            method_source_code.set_method(method)
+        end
+
+        # Calculated
+
+        ##
+        # Answers all the namespaces in the running environment
+        #
+        def get_root_namespaces()
+            return [Object]
+        end
+
+        ##
+        # Answers child modules of a namespace
+        #
+        def get_modules_in(a_module)
+            return [] if a_module.nil?
+
+            modules = a_module.constants(false)
+                .collect { |constant| a_module.const_get(constant) }
+                .select { |constant| constant.kind_of?(Module) }
+                .sort_by { |a_module| a_module.name }
+
+            modules.prepend(a_module)
+        end
+
+        ##
+        # Answers all the modules in the given class
+        #
+        def get_all_ancestors_of(a_class)
+            return [] if a_class.nil?
+
+            a_class.ancestors.reverse
+        end
+
+        ##
+        # Answers all the methods in the given class
+        #
+        def get_all_methods_in(a_module)
+            return [] if a_module.nil?
+
+            methods = []
+
+            inherit = show_inherit_methods.value
+
+            if showing_instance_methods?
+                methods.concat(a_module.private_instance_methods(inherit)) if showing_private_methods?
+                methods.concat(a_module.protected_instance_methods(inherit)) if showing_protected_methods?
+                methods.concat(a_module.public_instance_methods(inherit)) if showing_public_methods?
+            else
+                methods.concat(a_module.private_methods(inherit)) if showing_private_methods?
+                methods.concat(a_module.protected_methods(inherit)) if showing_protected_methods?
+                methods.concat(a_module.public_methods(inherit)) if showing_public_methods?
+            end
+
+            methods.sort
+        end
+
+        ##
+        # Answers all the constants in the given class
+        #
+        def get_all_constants_in(a_module)
+            return [] if a_module.nil?
+
+            inherit = show_inherit_methods.value
+
+            a_module.constants(inherit)
+                .collect { |constant_name|
+                    ConstantModel.new(name: constant_name, value: a_module.const_get(constant_name))
+                }
+                .select { |constant_model| ! constant_model.value.kind_of?(Module) }
+                .sort_by { |constant_model| constant_model.name }
+        end
+
+        # Asking
+
+        def showing_instance_methods?()
+            instance_or_class_methods_chooser.selection.value == :instance
+        end
+
+        def showing_private_methods?()
+            show_private_methods.value
+        end
+
+        def showing_protected_methods?()
+            show_protected_methods.value
+        end
+
+        def showing_public_methods?()
+            show_public_methods.value
+        end
+    end
+end

data/lib/sirens/models/object_browser_model.rb

@@ -0,0 +1,125 @@
+module Sirens
+    class ObjectBrowserModel
+
+        # Initializing
+
+        def initialize()
+            super()
+
+            @object = ValueModel.on(nil)
+
+            @object_instance_variables = TreeChoiceModel.new(
+                    selection: object,
+                    roots: [InstanceVariable.new(key: nil, value: object)],
+                    get_children_block: proc { |instance_variable|
+                        get_child_instance_variables_of(instance_variable.value)
+                    }
+                )
+
+            @text = ValueModel.on('')
+
+            connect_models
+        end
+
+        def connect_models()
+            @object.add_observer(self, :on_object_changed)
+            @object_instance_variables.selection.add_observer(self, :on_instance_variable_changed)
+        end
+
+        # Accessors
+
+        attr_reader :object,
+            :object_instance_variables,
+            :text
+
+        def selected_inst_var_value()
+            tree_selection = object_instance_variables.selection.value.last
+
+            tree_selection.nil? ? nil : tree_selection.value
+        end
+
+        # Events
+
+        def on_object_changed(announcement)
+            new_object = announcement.new_value
+
+            @object_instance_variables.set_tree_roots(
+                [InstanceVariable.new(key: nil, value: new_object)]
+            )
+        end
+
+        def on_instance_variable_changed(announcement)
+            instance_variable = announcement.new_value.last
+
+            value = instance_variable.nil? ? '' : instance_variable.value.inspect
+
+            @text.set_value(value)
+        end
+
+        ##
+        # Get the child instance variables of an object.
+        #
+        def get_child_instance_variables_of(object)
+            if object.kind_of?(Array)
+                i = -1
+                object.collect{ |value|
+                    i += 1
+                    InstanceVariable.new(
+                        key: i,
+                        value: value
+                    )
+                }
+            elsif object.kind_of?(Hash)
+              object.collect{ |key, value|
+                  InstanceVariable.new(
+                      key: "[#{key.inspect}]",
+                      value: value
+                  )
+              }
+            else
+                object.instance_variables.collect{ |inst_var_name|
+                    InstanceVariable.new(
+                        key: inst_var_name,
+                        value: object.instance_variable_get(inst_var_name)
+                    )
+                }
+            end
+        end
+
+        class InstanceVariable
+            def initialize(key:, value:)
+                @key = key
+                @value = value
+            end
+
+            attr_reader :key, :value
+
+            def display_string()
+                return value_display_string if key.nil?
+
+                "#{key_display_string} = #{value_display_string}"
+            end
+
+            def key_display_string()
+                if key.kind_of?(Numeric)
+                    "[#{key}]"
+                else
+                    key.to_s
+                end
+            end
+
+            def value_display_string()
+                return "an Array(#{value.size})" if value.kind_of?(Array)
+                return 'a Hash' if value.kind_of?(Hash)
+
+                string = value.to_s
+
+                if string.start_with?('#<')
+                    "a " + value.class.name
+                else
+                    value.inspect
+                end
+            end
+        end
+    end
+end