xumlidot 0.1.0

data/lib/xumlidot/parsers/call.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require_relative '../parsers'
+require_relative '../types'
+
+module Xumlidot
+  module Parsers
+    class Call < MethodBasedSexpProcessor
+      attr_reader :definition
+
+      def initialize(exp, klass)
+        super()
+
+        @klass = klass
+        @modules = ::Xumlidot::Types::InheritedModule.new(nil)
+
+        process(exp)
+
+        return if klass.definition.nil?
+        klass.definition.inherited_modules << @modules
+      end
+
+      def process_call(exp)
+        exp.shift # remove the :call
+
+        begin
+          recv = process(exp.shift)
+        rescue => e
+          STDERR.puts " ** bug: unable to calculate reciever for #{exp}"
+        end
+
+        name = exp.shift
+        args = exp.shift
+
+        case name
+        when :private, :public, :protected
+          ::Xumlidot::Parsers::Scope.set_visibility(name)
+        when :include
+          @modules.type = :include
+          process(args)
+        when :extend
+          @modules.type = :extend
+          process(args)
+        when :prepend
+          @modules.type = :prepend
+          process(args)
+        when :module_function
+          # TODO: expose as an instance method on the module
+        when :attr_reader
+          add_attributes(args, exp, read: true)
+        when :attr_writer
+          add_attributes(args, exp, write: true)
+        when :attr_accessor
+          add_attributes(args, exp, read: true, write: true)
+        # else
+          # puts "CALL RECV:#{recv unless recv.nil? || recv.empty?} NAME:#{name} ARGS:#{args unless args.nil? || args.empty?}"
+        end
+        s()
+      end
+
+      def add_attributes(name, exp, read: false, write: false)
+        @klass.attributes << ::Xumlidot::Types::Attribute.new(name.value, read, write)
+        exp.each do |attribute|
+          @klass.attributes << ::Xumlidot::Types::Attribute.new(attribute.value, read, write)
+        end
+      end
+
+      def process_const(exp)
+        # exp.shift # remove :const
+        @modules << exp.value
+        process_until_empty(exp)
+        s()
+      end
+
+      def process_colon2(exp)
+        exp.shift # remove :colon2
+        @modules << exp.value
+        process_until_empty(exp)
+        s()
+      end
+
+      def process_colon3(exp)
+        exp.shift # remove :colon3
+        @modules << '::'
+        @modules << exp.value
+        process_until_empty(exp)
+        s()
+      end
+
+    end
+  end
+end

data/lib/xumlidot/parsers/file.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require_relative '../parsers'
+require_relative '../types'
+
+module Xumlidot
+  module Parsers
+    # Takes a file contents (as a string) and parses it into
+    # s expressions using ruby parser. The parse method uses
+    # the SexpProcessors methods to contert to a graph
+    class File < Generic
+    end
+
+  end
+end

data/lib/xumlidot/parsers/generic.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require_relative '../parsers'
+require_relative '../types'
+
+module Xumlidot
+  module Parsers
+
+    # We need a level of indirection between the actual parser
+    # and MethodBasedSexpProcessor since we will probably end up inheriting
+    # from SexpProcessor directly eventually
+    #
+    # The File processor was getting too busy and its obvious we want to share
+    # some bits of the processing
+    class Generic < MethodBasedSexpProcessor
+      attr_reader :constants
+
+      def initialize(string, constants = Stack::Constants.new )
+        @parsed = RubyParser.new.parse(string)
+        @constants = constants
+        super()
+      end
+
+      def parse
+        process(@parsed)
+      end
+
+      # CLASSES, MODULES AND DEFINITIONS
+      #
+      # We process the superclass differently since we dont want an
+      # actual superclass node adding - just the methods
+      def process_sclass(exp)
+        super(exp) do
+          Scope.public { process_until_empty(exp) } # Process the superclass with public visibility
+        end
+      rescue Exception => e
+        if ENV["XUMLIDOT_DEBUG"]
+          STDERR.puts e.backtrace.reverse
+          STDERR.puts "ERROR (#process_sclass) #{e.message}"
+        end
+        exp
+      end
+
+      def process_module(exp)
+        process_class(exp,
+                      definition_parser: ::Xumlidot::Parsers::ModuleDefinition,
+                      type: Xumlidot::Types::Module)
+      end
+
+      def process_class(exp,
+                        definition_parser: ::Xumlidot::Parsers::KlassDefinition,
+                        type: Xumlidot::Types::Klass)
+
+        Scope.set_visibility
+        definition = definition_parser.new(exp.dup[0..2], @class_stack).definition
+
+        STDERR.puts definition.to_s if ::Xumlidot::Options.debug == true
+        super(exp) do
+          Scope.public do
+            klass_or_module = type.new(definition)
+            @constants.add(klass_or_module)
+            process_until_empty(exp)
+          end
+        end
+      rescue Exception => e
+        if ENV["XUMLIDOT_DEBUG"]
+          STDERR.puts e.backtrace.reverse
+          STDERR.puts "ERROR (#process_class) #{e.message}"
+        end
+        exp
+      end
+
+      # METHODS & METHOD SIGNATURES
+      def process_defn(exp, superclass_method = false)
+        method = ::Xumlidot::Parsers::MethodSignature.new(exp, superclass_method || @sclass.last)
+        @constants.last_added.add_method(method)
+        STDERR.puts method.to_s if ::Xumlidot::Options.debug == true
+        #super(exp) { process_until_empty(exp) } # DISABLING since parsing the method is crashing
+        s()
+      rescue Exception => e
+        if ENV["XUMLIDOT_DEBUG"]
+          STDERR.puts e.backtrace.reverse
+          STDERR.puts "ERROR (#process_def#{superclass_method ? 's' : 'n'}) #{e.message}"
+        end
+        s()
+      end
+
+      def process_defs(exp)
+        process_defn(exp, true)
+      end
+
+      # CALLS
+      def process_call(exp)
+        ::Xumlidot::Parsers::Call.new(exp, @constants.last_added)
+        s()
+      rescue Exception => e
+        if ENV["XUMLIDOT_DEBUG"]
+          STDERR.puts e.backtrace.reverse
+          STDERR.puts "ERROR (#process_call) #{e.message}"
+        end
+        s()
+      end
+
+    end
+  end
+end

data/lib/xumlidot/parsers/klass_definition.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require_relative '../parsers'
+require_relative '../types'
+
+module Xumlidot
+  module Parsers
+    # Parser for the KLASS DEFINITION ONLY
+    class KlassDefinition < MethodBasedSexpProcessor
+
+      attr_reader :definition
+
+      def initialize(exp, namespace = nil)
+        super()
+
+        @definition = ::Xumlidot::Types::KlassDefinition.new
+        @namespace = namespace.dup
+
+        process(exp)
+      end
+
+      def process_class(exp)
+        exp.shift # remove :class
+        definition = exp.shift
+
+        # Processes the name of the class
+        if Sexp === definition
+          case definition.sexp_type
+          when :colon2 then # Reached in the event that a name is a compound
+            name = definition.flatten
+            name.delete :const
+            name.delete :colon2
+            name.each do |v|
+              @definition.name << ::Xumlidot::Types::Constant.new(v, @namespace)
+            end
+          when :colon3 then # Reached in the event that a name begins with ::
+            @definition.name << ::Xumlidot::Types::Constant.new(definition.last, '::')
+          else
+            raise "unknown type #{exp.inspect}"
+          end
+        else Symbol === definition
+          #if we have a symbol we have the actual class name
+          # e.g. class Foo; end
+          @definition.name << ::Xumlidot::Types::Constant.new(definition, @namespace)
+        end
+
+        # Processess inheritance
+        process_until_empty(exp)
+
+        s()
+      end
+
+      def process_const(exp)
+        # TODO: may have removed a shift by mistake
+        @definition.superklass << exp.value
+        process_until_empty(exp)
+        s()
+      end
+
+      def process_colon2(exp)
+        exp.shift # remove :colon2
+        @definition.superklass << exp.value
+        process_until_empty(exp)
+        s()
+      end
+
+      def process_colon3(exp)
+        exp.shift # remove :colon3
+        @definition.superklass << '::'
+        @definition.superklass << exp.value
+        process_until_empty(exp)
+        s()
+      end
+    end
+  end
+end

data/lib/xumlidot/parsers/method_signature.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require_relative '../parsers'
+require_relative '../types'
+
+module Xumlidot
+  module Parsers
+    # Parser for the arguments to a method
+    #
+    # e.g. formats def method(a, b = nil)
+    #      to a string 'a, b = nil'
+    #
+    class MethodSignature < MethodBasedSexpProcessor
+
+      # Container for values assigned to a variable
+      #class Assignments < Hash
+      #end
+
+      attr_reader :definition
+
+      def initialize(exp, superclass_method = false)
+        super()
+
+        @definition = ::Xumlidot::Types::MethodSignature.new
+        @definition.visibility = Scope.get_visibility
+        @definition.args = Args.new(exp.dup[0..2]).definition # only pass the method definition into args
+        @definition.superclass_method = superclass_method
+
+        #@assignments = Assignments.new
+
+        process(exp)
+      end
+
+      def to_s
+        @definition.to_s
+      end
+
+      def process_defn(exp)
+        exp.shift unless auto_shift_type # node type
+        exp.shift if exp.first.is_a?(Sexp) && exp.first.value == :self # remove :self
+
+        @definition.name = exp.shift
+        @definition.file = exp.file
+        @definition.line_number = exp.line
+        @definition.line_max = exp.line_max
+
+        more = exp.shift
+        process(more) if more.is_a?(Sexp) && !more.empty?
+        s()
+      rescue Exception => e
+        STDERR.puts " ** bug: unable to proces defn #{exp}"
+        if ENV["XUMLIDOT_DEBUG"]
+          STDERR.puts "ERROR (MethodSignature#process_defn) #{e.message}"
+          STDERR.puts e.backtrace.reverse
+        end
+        s()
+      end
+
+      def process_defs(exp)
+        process_defn(exp)
+      end
+
+      # CALLS
+      # TODO: We need a seperate assignment class to parse these
+      # especially assignments so that we can attempt to work out types
+      def process_call(exp)
+        exp.shift # remove the :call
+
+        recv = process(exp.shift) # recv
+        name = exp.shift
+        args = process(exp.shift) # args
+
+        exp
+      rescue Exception => e
+        if ENV["XUMLIDOT_DEBUG"]
+          STDERR.puts "ERROR (MethodSignature#process_call) #{e.message}"
+          STDERR.puts e.backtrace.reverse
+        end
+        exp
+      end
+
+      def process_lasgn(exp)
+        exp.shift # remove :lasgn
+
+        name = exp.shift.to_s
+        value = exp.shift
+
+        #@assignments[name] = value
+
+        process(value)
+        s()
+      end
+    end
+  end
+end

data/lib/xumlidot/parsers/module_definition.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require_relative '../parsers'
+require_relative '../types'
+
+module Xumlidot
+  module Parsers
+    # Parser for the KLASS DEFINITION ONLY and the name
+    # probably should be changed to reflect that
+    #
+    # The main parser will handle method,
+    # constants, etc
+    #
+    class ModuleDefinition < MethodBasedSexpProcessor
+
+      attr_reader :definition
+
+      def initialize(exp, namespace = nil)
+        super()
+
+        @definition = ::Xumlidot::Types::ModuleDefinition.new
+        @namespace = namespace.dup
+
+        process(exp)
+      end
+
+      def process_module(exp)
+        exp.shift # remove :module
+        definition = exp.shift
+
+        # Processes the name of the module
+        if Sexp === definition
+          case definition.sexp_type
+          when :colon2 then # Reached in the event that a name is a compound
+            name = definition.flatten
+            name.delete :const
+            name.delete :colon2
+            name.each do |v|
+              @definition.name << ::Xumlidot::Types::Constant.new(v, @namespace)
+            end
+          when :colon3 then # Reached in the event that a name begins with ::
+            @definition.name << ::Xumlidot::Types::Constant.new(definition.last, '::')
+          else
+            raise "unknown type #{exp.inspect}"
+          end
+        else Symbol === definition
+          #if we have a symbol we have the actual module name
+          # e.g. module Foo; end
+          @definition.name << ::Xumlidot::Types::Constant.new(definition, @namespace)
+        end
+        s()
+      end
+    end
+  end
+end

data/lib/xumlidot/parsers/scope.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require_relative '../parsers'
+require_relative '../types'
+
+module Xumlidot
+  module Parsers
+
+    # Save current visibility and restore it after processing
+    module Scope
+      # Maintains current state of method visability
+      class Visibility
+        class << self
+
+          def state
+            @state ||= :public
+          end
+
+          def public
+            @state = :public
+          end
+
+          def protected
+            @state = :protected
+          end
+
+          def private
+            @state = :private
+          end
+        end
+      end
+
+      def public(&block)
+        temp_visibility = get_visibility
+        set_visibility
+        yield if block_given?
+        set_visibility(temp_visibility)
+      end
+
+      def set_visibility(state = :public)
+        Visibility.send(state)
+      end
+
+      def get_visibility
+        Visibility.state
+      end
+
+      module_function :set_visibility
+      module_function :get_visibility
+      module_function :public
+    end
+
+  end
+end