xumlidot 0.1.0 → 0.2.0

data/lib/xumlidot/options.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'optparse'
 require 'optparse/time'
 require 'ostruct'
@@ -6,16 +8,41 @@ module Xumlidot
   OptionsError = Class.new(StandardError)
 
   class Options
-    def self.method_missing(m, *args, &block)
-      if @options.respond_to?(m)
-        @options.send(m)
-      else
-        raise OptionsError.new("Unknown Option #{m}")
+    @options = nil
+
+    attr_accessor(*%i[
+                    composition
+                    debug
+                    diagram_type
+                    exclude
+                    inheritance
+                    model_name
+                    rails
+                    respond_to
+                    send
+                    sequence
+                    split
+                    title
+                    usage
+                    use_debug_ids
+                  ])
+
+    class << self
+      attr_accessor :options
+
+      def method_missing(method_name, *_args, &_block)
+        return options.public_send(method_name) if options.respond_to?(method_name)
+
+        raise OptionsError.new, "Unknown Option #{method_name}"
+      end
+
+      def respond_to_missing?(method_name, include_private = false)
+        options.respond_to?(method_name) || super
       end
     end
 
-    def self.parse(args)
-      @options = OpenStruct.new
+    def self.parse(args) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+      @options = new
 
       @options.title = 'Class Diagram'
       @options.model_name = 'My Model'
@@ -28,77 +55,85 @@ module Xumlidot
       @options.split = 1
       @options.sequence = ''
       @options.exclude = ''
+      @options.use_debug_ids = false
 
-      ENV.delete("XUMLIDOT_DEBUG")
+      ENV.delete('XUMLIDOT_DEBUG')
 
       opt_parser = OptionParser.new do |opts|
-        opts.banner = "Usage: xumlidot.rb [options]"
+        opts.banner = 'Usage: xumlidot.rb [options]'
 
-        opts.separator ""
-        opts.separator "Specific options:"
+        opts.separator ''
+        opts.separator 'Specific options:'
 
-        opts.on("-t", "--title [TEXT]", "Title for the diagram") do |v|
+        opts.on('-t', '--title [TEXT]', 'Title for the diagram') do |v|
           @options.title = v
         end
 
-        opts.on("-m", "--model [TEXT]", "Model Name for the diagram") do |v|
+        opts.on('-m', '--model [TEXT]', 'Model Name for the diagram') do |v|
           @options.model_name = v
         end
 
-        opts.on("-d", "--dot", "Output diagram using dot (default)") do |v|
+        opts.on('-d', '--dot', 'Output diagram using dot (default)') do
           @options.diagram_type = :dot
         end
 
-        opts.on("-x", "--xmi", "Output diagram using xmi") do |v|
+        opts.on('-x', '--xmi', 'Output diagram using xmi') do
           @options.diagram_type = :xmi
         end
 
-        opts.on("-d", "--debug", "Output debug information") do |v|
+        opts.on('-d', '--debug', 'Output debug information') do
           @options.debug = true
-          ENV["XUMLIDOT_DEBUG"] = '1'
+          ENV['XUMLIDOT_DEBUG'] = '1'
         end
 
-        opts.on("-i", "--no-inheritance", "Output inheritence links on the diagram") do |v|
+        opts.on('-i', '--no-inheritance', 'Output inheritance links on the diagram') do
           @options.inheritance = false
         end
 
-        opts.on("-c", "--no-composition", "Output composition links on the diagram") do |v|
+        opts.on('-c', '--no-composition', 'Output composition links on the diagram') do
           @options.composition = false
         end
 
-        opts.on("-r", "--rails", "Expect a Rails application") do |v|
+        opts.on('-r', '--rails', 'Expect a Rails application') do |v|
           @options.rails = v
         end
 
-
-        opts.on("-e", "--exclude [TEXT[", "Output usage links on the diagram") do |v|
+        opts.on('-e', '--exclude [TEXT]', 'Exclude directories or files by pattern') do |v|
           @options.exclude = v
         end
 
-        opts.on("-u", "--[no-]usage", "Output usage links on the diagram") do |v|
+        opts.on('-u', '--[no-]usage', 'Output usage links on the diagram') do |v|
           @options.usage = v
         end
-        opts.separator ""
 
-        opts.separator "Common options:"
+        opts.on('-b', '--debug-ids', 'Output from a static list of ids') do |v|
+          @options.use_debug_ids = v
+        end
+
+        opts.separator ''
+        opts.separator 'Common options:'
 
         # No argument, shows at tail.  This will print an options summary.
         # Try it and see!
-        opts.on_tail("-h", "--help", "Show this message") do
+        opts.on_tail('-h', '--help', 'Show this message') do
           puts opts
           exit
         end
 
         # Another typical switch to print the version.
-        opts.on_tail("--version", "Show version") do
+        opts.on_tail('--version', 'Show version') do
           puts ::Version.join('.')
           exit
         end
       end
 
       opt_parser.parse!(args)
+
+      # Rather than pass the options around everywhere, lets set it as a class instance var
+      # TODO: Remove code passing it around everywhere
+      ::Xumlidot::Options.options = @options
+
       @options
     end
-
   end
 end

data/lib/xumlidot/parsers/args.rb

@@ -9,17 +9,15 @@ module Xumlidot
     #
     # e.g. formats def method(a, b = nil)
     #      to a string 'a, b = nil'
-    #
     class Args < MethodBasedSexpProcessor
-
       def initialize(exp)
         super()
 
         @arguments = ::Xumlidot::Types::Arguments.new
 
-        process(exp)
-      rescue => e
-        STDERR.puts " ** bug: unable to process args #{exp} "
+        process(Sexp.new.concat(exp))
+      rescue StandardError => _e
+        warn " ** bug: unable to process args #{exp} "
       end
 
       def to_s
@@ -34,7 +32,7 @@ module Xumlidot
       # means we shouldn't display it and so we use the :nil
       # symbol to represent an *actual assignment of nil* to
       # a variable.
-      def process_nil(exp)
+      def process_nil(_exp)
         @argument.default = :nil
         s()
       end
@@ -44,7 +42,7 @@ module Xumlidot
         s()
       end
 
-      def process_hash(exp)
+      def process_hash(_exp)
         @argument.default = {}
         s()
       end
@@ -73,7 +71,7 @@ module Xumlidot
         # but this is complex since it needs to be inserted into the right
         # place and for that I need the namespace...which suggests this ISNT
         # the place to do that. I possibly need a fake class ...
-        @argument.default = leader + name.map do |v|
+        @argument.default = leader + name.map do |v| # rubocop:disable Style/SymbolProc
           v.to_s
         end.to_a.join('::')
 
@@ -113,16 +111,14 @@ module Xumlidot
           @argument.default << exp.value
         when nil
           @argument.default = exp.value
-        when Symbol
-          @argument.default = exp.value.to_s
-        when String
+        when Symbol, String
           @argument.default = exp.value.to_s
-        when Sexp
-          # binding.pry
-        when Hash
-          # binding.pry
-        else
-          # binding.pry
+          # when Sexp
+          #   binding.pry
+          # when Hash
+          #   binding.pry
+          # else
+          #   binding.pry
         end
         exp.shift
         s()
@@ -133,8 +129,8 @@ module Xumlidot
         @argument.name = "#{exp[0]}:"
         process(exp)
         s()
-      rescue => e
-        STDERR.puts " ** bug: unable to process kwarg #{exp}; failure to parse default value? "
+      rescue StandardError
+        warn " ** bug: unable to process kwarg #{exp}; failure to parse default value?"
         s()
       end
 
@@ -151,8 +147,8 @@ module Xumlidot
 
           @arguments << @argument
         end
-      rescue => e
-        STDERR.puts " ** bug: unable to process args #{exp}; failure to parse default value? "
+      rescue StandardError
+        warn " ** bug: unable to process args #{exp}; failure to parse default value?"
       end
     end
   end

data/lib/xumlidot/parsers/call.rb

@@ -17,16 +17,23 @@ module Xumlidot
         process(exp)
 
         return if klass.definition.nil?
+
         klass.definition.inherited_modules << @modules
       end
 
+      # rubocop:disable Metrics/AbcSize
+      # rubocop:disable Metrics/MethodLength
       def process_call(exp)
-        exp.shift # remove the :call
+        _call = exp.shift # remove the :call
 
         begin
-          recv = process(exp.shift)
-        rescue => e
-          STDERR.puts " ** bug: unable to calculate reciever for #{exp}"
+          shifted = exp.shift
+          _recv = process(shifted)
+        rescue StandardError => _e
+          # Reaching here when the shifted value is an array, hash, or iter
+          # one example:
+          # BaseMailer.view_paths = [File.join(FIXTURE_LOAD_PATH, "another.path")] + old.dup
+          warn " ** bug: unable to calculate reciever for #{exp}"
         end
 
         name = exp.shift
@@ -44,22 +51,39 @@ module Xumlidot
         when :prepend
           @modules.type = :prepend
           process(args)
-        when :module_function
-          # TODO: expose as an instance method on the module
+        # when :module_function
+        #   TODO: expose as an instance method on the module
+        # when :public_constant
+        # TODO:
         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?}"
+          # else
+          # warn "CALL RECV:#{recv unless recv.nil? || recv.empty?} " \
+          # "NAME:#{name} ARGS:#{args unless args.nil? || args.empty?}"
+        end
+        s()
+      end
+      # rubocop:enable Metrics/AbcSize
+      # rubocop:enable Metrics/MethodLength
+
+      # If we have e.g a constant in the class definition which is assigned an
+      # array this prevents us having those constants defined as a parent
+      # class. See issue #30
+      def process_array(exp)
+        exp.shift # remove :array
+        exp.each do |element|
+          process_until_empty(element)
         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
@@ -86,7 +110,6 @@ module Xumlidot
         process_until_empty(exp)
         s()
       end
-
     end
   end
 end

data/lib/xumlidot/parsers/file.rb

@@ -10,6 +10,5 @@ module Xumlidot
     # the SexpProcessors methods to contert to a graph
     class File < Generic
     end
-
   end
 end

data/lib/xumlidot/parsers/generic.rb

@@ -5,7 +5,6 @@ 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
@@ -15,7 +14,7 @@ module Xumlidot
     class Generic < MethodBasedSexpProcessor
       attr_reader :constants
 
-      def initialize(string, constants = Stack::Constants.new )
+      def initialize(string, constants = Stack::Constants.new)
         @parsed = RubyParser.new.parse(string)
         @constants = constants
         super()
@@ -33,11 +32,8 @@ module Xumlidot
         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
+      rescue StandardError => e
+        sdebug('#process_sclass', e)
         exp
       end
 
@@ -52,55 +48,52 @@ module Xumlidot
                         type: Xumlidot::Types::Klass)
 
         Scope.set_visibility
-        definition = definition_parser.new(exp.dup[0..2], @class_stack).definition
+        definition = definition_parser.new(Sexp.new.concat(exp[0..2]), @class_stack).definition
 
-        STDERR.puts definition.to_s if ::Xumlidot::Options.debug == true
+        warn 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)
+            @constants.pop_last_added
           end
         end
-      rescue Exception => e
-        if ENV["XUMLIDOT_DEBUG"]
-          STDERR.puts e.backtrace.reverse
-          STDERR.puts "ERROR (#process_class) #{e.message}"
-        end
+      rescue StandardError => e
+        sdebug('#process_class', e)
         exp
       end
 
       # METHODS & METHOD SIGNATURES
-      def process_defn(exp, superclass_method = false)
-        method = ::Xumlidot::Parsers::MethodSignature.new(exp, superclass_method || @sclass.last)
+      def process_defn(exp, superclass_method: false)
+        method = ::Xumlidot::Parsers::MethodSignature.new(exp, superclass_method: 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
+        warn method.to_s if ::Xumlidot::Options.debug == true
+        # super(exp) { process_until_empty(exp) } # DISABLING since parsing the method is crashing
         s()
+      rescue StandardError => e
+        sdebug("#process_def#{superclass_method ? 's' : 'n'}", e)
       end
 
       def process_defs(exp)
-        process_defn(exp, true)
+        process_defn(exp, superclass_method: 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()
+      rescue StandardError => e
+        sdebug('#process_call', e)
       end
 
+      def sdebug(name, error)
+        return s() unless ENV['XUMLIDOT_DEBUG']
+
+        warn error.backtrace.reverse
+        warn "ERROR (#{name}) #{error.message}"
+        s()
+      end
     end
   end
 end

data/lib/xumlidot/parsers/klass_definition.rb

@@ -7,7 +7,6 @@ module Xumlidot
   module Parsers
     # Parser for the KLASS DEFINITION ONLY
     class KlassDefinition < MethodBasedSexpProcessor
-
       attr_reader :definition
 
       def initialize(exp, namespace = nil)
@@ -19,28 +18,30 @@ module Xumlidot
         process(exp)
       end
 
+      # rubocop:disable Metrics/AbcSize
+      # rubocop:disable Metrics/MethodLength
       def process_class(exp)
         exp.shift # remove :class
         definition = exp.shift
 
         # Processes the name of the class
-        if Sexp === definition
+        if Sexp === definition # rubocop:disable Style/CaseEquality
           case definition.sexp_type
-          when :colon2 then # Reached in the event that a name is a compound
+          when :colon2 # 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 ::
+          when :colon3 # 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
+        # TODO: looks like a bug - fix when we get specs
+        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
 
@@ -49,6 +50,8 @@ module Xumlidot
 
         s()
       end
+      # rubocop:enable Metrics/AbcSize
+      # rubocop:enable Metrics/MethodLength
 
       def process_const(exp)
         # TODO: may have removed a shift by mistake

data/lib/xumlidot/parsers/method_signature.rb

@@ -11,14 +11,12 @@ module Xumlidot
     #      to a string 'a, b = nil'
     #
     class MethodSignature < MethodBasedSexpProcessor
-
-      # Container for values assigned to a variable
-      #class Assignments < Hash
-      #end
+      # class Assignments < Hash
+      # end
 
       attr_reader :definition
 
-      def initialize(exp, superclass_method = false)
+      def initialize(exp, superclass_method: false)
         super()
 
         @definition = ::Xumlidot::Types::MethodSignature.new
@@ -26,7 +24,7 @@ module Xumlidot
         @definition.args = Args.new(exp.dup[0..2]).definition # only pass the method definition into args
         @definition.superclass_method = superclass_method
 
-        #@assignments = Assignments.new
+        # @assignments = Assignments.new
 
         process(exp)
       end
@@ -35,6 +33,7 @@ module Xumlidot
         @definition.to_s
       end
 
+      # rubocop:disable Metrics/AbcSize
       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
@@ -47,14 +46,12 @@ module Xumlidot
         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()
+      rescue StandardError => e
+        warn " ** bug: unable to proces defn #{exp}"
+
+        sdebug('MethodSignature#process_defn', e)
       end
+      # rubocop:enable Metrics/AbcSize
 
       def process_defs(exp)
         process_defn(exp)
@@ -66,30 +63,37 @@ module Xumlidot
       def process_call(exp)
         exp.shift # remove the :call
 
-        recv = process(exp.shift) # recv
-        name = exp.shift
-        args = process(exp.shift) # args
+        _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
+      rescue StandardError => e
+        sdebug('MethodSignature#process_call', e)
         exp
       end
 
       def process_lasgn(exp)
         exp.shift # remove :lasgn
 
-        name = exp.shift.to_s
+        _name = exp.shift.to_s
         value = exp.shift
 
-        #@assignments[name] = value
+        # @assignments[name] = value
 
         process(value)
         s()
       end
+
+      private
+
+      def sdebug(name, error)
+        return s() unless ENV['XUMLIDOT_DEBUG']
+
+        warn error.backtrace.reverse
+        warn "ERROR (#{name}) #{error.message}"
+        s()
+      end
     end
   end
 end

data/lib/xumlidot/parsers/module_definition.rb

@@ -10,9 +10,7 @@ module Xumlidot
     #
     # The main parser will handle method,
     # constants, etc
-    #
     class ModuleDefinition < MethodBasedSexpProcessor
-
       attr_reader :definition
 
       def initialize(exp, namespace = nil)
@@ -24,32 +22,34 @@ module Xumlidot
         process(exp)
       end
 
+      # rubocop:disable Metrics/AbcSize
       def process_module(exp)
         exp.shift # remove :module
         definition = exp.shift
 
         # Processes the name of the module
-        if Sexp === definition
+        if Sexp === definition # rubocop:disable Style/CaseEquality
           case definition.sexp_type
-          when :colon2 then # Reached in the event that a name is a compound
+          when :colon2 # 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 ::
+          when :colon3 # 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
+        # FIXME: bug - fix when we've added specs
+        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
+      # rubocop:enable Metrics/AbcSize
     end
   end
 end