xumlidot 0.1.0

data/lib/xumlidot/parsers/stack.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require_relative '../parsers'
+require_relative '../types'
+
+module Xumlidot
+  module Parsers
+    module Stack
+      class Constants
+        attr_reader :last_added
+
+        def initialize
+          # This should be main or object
+          @nesting = Xumlidot::Types::Klass.new(nil)
+          @last_added = @nesting
+        end
+
+        def traverse(&block)
+          @nesting.constants.traverse(&block)
+        end
+
+        # when we add a constant we might want to add to the top of the tree
+        # e.g.
+        # Module A
+        # Moudle B
+        #
+        # or we might want to add onto a given const
+        # e,g
+        # Module A
+        #   Module B
+        #
+        # add(Module C, Module B)
+        #
+        def add(c)
+          return if @nesting.constants.find_first(c)
+
+          root = @nesting.constants.root_namespace_for(c)
+          (root.nil? ? @nesting.constants : root.constants) <<  c
+          @last_added = c
+        end
+
+        class ExternalKlassReferences < Array
+          def <<(external_klass)
+            return if find do |klass|
+              klass.definition == external_klass.definition
+            end
+
+            super(external_klass)
+          end
+        end
+
+        def resolve_inheritance(constant = nil)
+          external_klasses = ExternalKlassReferences.new
+
+          # The first traversal we are going through finding all
+          # classes with a superklass. The second traversal we are
+          # trying to find the klass which is the superklass of the superklass
+          # found in the first traversal.
+          #
+          # Note Im hacking through this so poor code
+          @nesting.constants.traverse do |klass|
+            next if klass.definition.superklass.empty?
+
+            # If we reach here we have a superklass
+            @nesting.constants.traverse do |other_klass|
+              if other_klass.definition.superklass_of?(klass.definition.superklass)
+                if ::Xumlidot::Options.debug == true
+                  STDERR.puts "SETTING SUPERKLASS REFERENCE FOR #{klass} to #{other_klass}"
+                end
+                klass.superklass.reference = other_klass
+                break
+              end
+            end
+
+            if klass.superklass.reference.nil?
+              # See if we have added it already to the list of external_klasses
+              found = external_klasses.find do |external_klass|
+                klass.definition == external_klass.definition
+              end
+
+              if found
+                klass.superklass.reference = found
+              else
+                new_klass = klass.definition.superklass.to_klass
+                klass.superklass.reference = new_klass
+                external_klasses << new_klass
+
+                add(new_klass)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/xumlidot/types.rb

@@ -0,0 +1,18 @@
+require_relative 'types/method'
+require_relative 'types/methods'
+require_relative 'types/instance_methods'
+require_relative 'types/constant'
+require_relative 'types/superklass'
+require_relative 'types/inherited_module'
+require_relative 'types/klass_definition'
+require_relative 'types/klass'
+require_relative 'types/klass_methods'
+require_relative 'types/argument'
+require_relative 'types/arguments'
+require_relative 'types/method_signature'
+require_relative 'types/constants'
+require_relative 'types/module_definition'
+require_relative 'types/module'
+require_relative 'types/klass'
+require_relative 'types/attribute'
+require_relative 'types/attributes'

data/lib/xumlidot/types/argument.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require_relative '../types'
+
+module Xumlidot
+  module Types
+    # Value object for an argument as specified within a methods definition.
+    #
+    # e.g. def foo(a, b)
+    #
+    # a and b are the arguments
+    #
+    # Depending on the argument; type (TODO), assign and default may be
+    # unpopulated e.g.
+    #
+    #    def foo(a, b)
+    #
+    # will be parsed with an empty assign and default, whereas
+    #
+    #    def bar(a = 1, b = nil)
+    #
+    # will both have an assign of '=' and defaults of 1 and :nil respectively.
+    #
+    # This is :nil rather than nill since an assignment to a variable of nil
+    # is parsed in Args and the default value set to the *symbol* :nil
+    class Argument
+      attr_accessor :assign,
+                    :default
+                    # :types # TODO: determine the type of the argument
+
+      attr_reader :name
+
+      def initialize
+        # @types = []
+      end
+
+      def name=(val)
+        @name = val.tr('&', '')
+      end
+
+      def to_s
+        str_default = case default
+                      when :nil
+                        'nil'
+                      when String
+                        default
+                      when NilClass
+                        nil
+                      when Symbol
+                        ":#{default}"
+                      when Hash
+                        '{}' # TODO: Some hashes were crashing the parser, why?
+                      else
+                        default.to_s
+                      end
+
+        [@name, @assign, str_default || nil].compact.join(' ')
+      end
+    end
+  end
+end

data/lib/xumlidot/types/arguments.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require_relative '../types'
+
+module Xumlidot
+  module Types
+    # Container class
+    class Arguments < Array
+      def to_s
+        each.map(&:to_s).join(', ')
+      end
+    end
+  end
+end

data/lib/xumlidot/types/attribute.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative '../types'
+
+module Xumlidot
+  module Types
+    # Value object for an attribute, i.e. accessor defined
+    # via attr_reader, attr_writer or attribute
+    #
+    class Attribute
+      attr_accessor :read,
+                    :write,
+                    :name
+
+      def initialize(name, read, write)
+        @name = name.to_s
+        @read = read
+        @write = write
+      end
+
+      def to_s
+        "(#{accessibility}) #{@name}"
+      end
+
+      private
+
+      def accessibility
+        return 'r+w' if @read && @write
+        return 'ro' if @read && !@write
+        return 'wo' if !@read && @write
+      end
+    end
+  end
+end

data/lib/xumlidot/types/attributes.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require_relative '../types'
+
+module Xumlidot
+  module Types
+    # Container class
+    class Attributes < Array
+    end
+  end
+end

data/lib/xumlidot/types/constant.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require_relative '../types'
+
+module Xumlidot
+  module Types
+    # Our representation of a constant - although just
+    # a string we need to be able to be unambigous in
+    # the representation.
+    #
+    # name is a single constant, namespace is the remaining full path
+    #
+    # e.g
+    # For ::Xumlidot::Types::Constant tne name would be Constant and the
+    # namespace [Types, Xumlidot]
+    #
+    # Note I am REALLY not happy with this design ...
+    class Constant
+      attr_reader :name,
+                  :namespace
+
+      attr_accessor :reference # TODO: What IS this? I think I may have thrown this
+                               # in to fix a traversal issue if so...hack!
+
+      def initialize(name, namespace = nil)
+        @name = name
+        @namespace = namespace ? namespace.dup : []
+      end
+
+      def to_s
+        "#{@name} (#{formatted_namespace})"
+      end
+
+      def empty?
+        @name.nil? && @namespace.empty?
+      end
+
+      private
+
+      def root
+        return '::' if @namespace.empty?
+      end
+
+      def formatted_namespace
+        [@namespace].flatten.reverse.each(&:to_s).join('::')
+      end
+    end
+  end
+end

data/lib/xumlidot/types/constants.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require_relative '../types'
+
+module Xumlidot
+  module Types
+    # Container class
+    #
+    # I'm thinking a hash to make lookup quicker ...
+    class Constants < Array
+      # return exact matches
+      def find_first(constant)
+        found = find do |klass|
+          klass.definition == constant.definition
+        end
+        return found unless found.nil?
+
+        each do |k|
+          k.constants.each do |klass|
+             found = klass.constants.find_first(constant)
+             return found unless found.nil?
+          end
+        end
+        nil
+      end
+
+      # find any constant that is the root of the namespace for
+      # the supplied constant
+      def root_namespace_for(constant)
+        found = find do |klass|
+          klass.definition.root_namespace_for?(constant)
+        end
+
+        return found unless found.nil?
+
+        each do |k|
+          k.constants.each do |klass|
+            return klass if klass.definition.root_namespace_for?(constant)
+            found = klass.constants.root_namespace_for(constant)
+            return found unless found.nil?
+          end
+        end
+        nil
+      end
+
+      def traverse(&block)
+        each do |k|
+          yield k if block_given?
+          k.constants.each do |klass|
+            yield klass if block_given?
+            klass.constants.traverse(&block)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/xumlidot/types/inherited_module.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative '../types'
+
+module Xumlidot
+  module Types
+    class InheritedModule < Superklass
+      attr_reader :type
+
+      def initialize(name, namespace = nil)
+        super
+        @has_root = false
+        @type = nil
+      end
+
+      def type=(value)
+        case value
+        when :extend, :prepend, :include
+          @type = value
+        end
+      end
+    end
+  end
+end

data/lib/xumlidot/types/instance_methods.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require_relative '../types'
+
+module Xumlidot
+  module Types
+    class InstanceMethods < Methods
+    end
+  end
+end

data/lib/xumlidot/types/klass.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+
+require_relative '../types'
+
+module Xumlidot
+  module Types
+    # representation for a class
+    class Klass
+      # Definition currently holds the superclass ... may change these to nesting and
+      # ancestors yet...
+      attr_accessor :definition,
+                    # we *could* just have a single methods type
+                    # and construct the instance/class list dynamically...
+                    :attributes,
+                    :instance_methods,
+                    :class_methods,
+                    # New additions as I attempt to resolve ancestry
+
+                    # Okay so lets say we keep in constants all constants,
+                    # modules and clasess (to make it easy to iterate over everything)
+                    # are there any drawbacks ... well, well have to test each ...
+                    # lets go with it
+                    #
+                    # Technically (for our purposes) a class, a module, and a constant are
+                    # the same thing apart from being semantically different so the constants
+                    # within a module or class with hold actual constants such as FOO = 1,
+                    # but also Modules and Klasses
+                    :constants,
+                    :calls # Not yet implemented
+
+      extend Forwardable
+      def_delegator :@definition, :superklass, :superklass
+
+      def initialize(definition)
+        @definition = definition
+
+        @instance_methods = InstanceMethods.new
+        @class_methods = KlassMethods.new
+        @attributes = Attributes.new
+        @constants = Constants.new
+      end
+
+      def to_s
+        "#{definition} "
+      end
+
+      def add_method(m)
+        m = m.definition if m.respond_to?(:definition)
+
+        if m.superclass_method == true
+          @class_methods << m
+        else
+          @instance_methods << m
+        end
+      end
+    end
+  end
+end