shellopts 2.0.0.pre.14 → 2.0.2

data/lib/shellopts/argument_type.rb

@@ -0,0 +1,139 @@
+module ShellOpts
+  module Grammar
+    class ArgumentType
+      # Name of type
+      def name() self.class.to_s.sub(/.*::/, "").sub(/Argument/, "") end
+
+      # Return truish if value literal (String) match the type. Returns false
+      # and set #message if the value doesn't match. <name> is used to
+      # construct the error message and is the name/alias the user specified on
+      # the command line
+      def match?(name, literal) true end
+
+      # Error message if match? returned false. Note that this method is not
+      # safe for concurrent processing
+      attr_reader :message
+
+      # Return true if .value is an "instance" of self. Ie. an Integer object
+      # if type is an IntegerArgument
+      def value?(value) true end
+
+      # Convert value to Ruby type
+      def convert(value) value end
+
+      # String representation. Equal to #name
+      def to_s() name end
+
+    protected
+      # it is important that #set_message return false
+      def set_message(msg)
+        @message = msg
+        false
+      end
+    end
+
+    class StringType < ArgumentType
+    end
+
+    class IntegerArgument < ArgumentType
+      def match?(name, literal) 
+        literal =~ /^-?\d+$/ or 
+            set_message "Illegal integer value in #{name}: #{literal}" 
+      end
+
+      def value?(value) value.is_a?(Integer) end
+      def convert(value) value.to_i end
+    end
+
+    class FloatArgument < ArgumentType
+      def match?(name, literal) 
+        # https://stackoverflow.com/a/21891705/2130986
+        literal =~ /^[+-]?(?:0|[1-9]\d*)(?:\.(?:\d*[1-9]|0))?$/ or 
+            set_message "Illegal decimal value in #{name}: #{literal}"
+      end
+
+      def value?(value) value.is_a?(Numeric) end
+      def convert(value) value.to_f end
+    end
+
+    class FileArgument < ArgumentType
+      attr_reader :kind
+
+      def initialize(kind)
+        constrain kind, :file, :dir, :path, :efile, :edir, :epath, :nfile, :ndir, :npath
+        @kind = kind 
+      end
+
+      def match?(name, literal)
+        case kind
+          when :file; match_path(name, literal, kind, :file?, :default)
+          when :dir; match_path(name, literal, kind, :directory?, :default)
+          when :path; match_path(name, literal, kind, :exist?, :default)
+
+          when :efile; match_path(name, literal, kind, :file?, :exist)
+          when :edir; match_path(name, literal, kind, :directory?, :exist)
+          when :epath; match_path(name, literal, kind, :exist?, :exist)
+
+          when :nfile; match_path(name, literal, kind, :file?, :new)
+          when :ndir; match_path(name, literal, kind, :directory?, :new)
+          when :npath; match_path(name, literal, kind, :exist?, :new)
+        else
+          raise InternalError, "Illegal kind: #{kind.inspect}"
+        end
+      end
+
+      # Note: No checks done, not sure if it is a feature or a bug
+      def value?(value) value.is_a?(String) end
+
+    protected
+      def match_path(name, literal, kind, method, mode)
+        subject = 
+            case kind
+              when :file, :efile, :nfile; "regular file"
+              when :dir, :edir, :ndir; "directory"
+              when :path, :epath, :npath; "path"
+            else
+              raise ArgumentError
+            end
+
+        if File.send(method, literal) # exists?
+          if mode == :new
+            set_message "#{subject.capitalize} already exists in #{name}: #{literal}"
+          elsif kind == :path || kind == :epath
+            if File.file?(literal) || File.directory?(literal)
+              true
+            else
+              set_message "Expected regular file or directory as #{name} argument: #{literal}"
+            end
+          else
+            true
+          end
+        elsif File.exist?(literal) # exists but not the right type
+          if mode == :new
+            set_message "#{subject.capitalize} already exists"
+          else
+            set_message "Expected #{subject} as #{name} argument: #{literal}"
+          end
+        else # does not exist
+          if [:default, :new].include? mode
+            if File.exist?(File.dirname(literal))
+              true
+            else
+              set_message "Illegal path in #{name}: #{literal}"
+            end
+          else
+            set_message "Error in #{name} argument: Can't find #{literal}"
+          end
+        end
+      end
+    end
+
+    class EnumArgument < ArgumentType
+      attr_reader :values
+      def initialize(values) @values = values.dup end
+      def match?(name, literal) value?(literal) or set_message "Illegal value in #{name}: '#{literal}'" end
+      def value?(value) @values.include?(value) end
+    end
+  end
+end
+

data/lib/shellopts/dump.rb

@@ -0,0 +1,158 @@
+module ShellOpts
+  module Grammar
+    class IdrNode
+      def dump_doc
+        puts "#{self.class} #{ident}"
+        indent {
+          children.each(&:dump_doc)
+        }
+      end
+    end
+  end
+
+  module Grammar
+    class Command
+      # Usable after parsing
+      def render_structure
+        io = StringIO.new
+        dump_structure(io)
+        io.string
+      end
+
+      def dump_structure(device = $stdout)
+        device.puts ident
+        device.indent { |dev|
+          option_groups.each { |group| dev.puts group.options.map(&:name).join(" ") }
+          commands.each { |command| command.dump_structure(dev) }
+          descrs.each { |descr| dev.puts descr.text }
+        }
+      end
+    end
+  end
+
+  module Grammar
+    class Node
+      def dump_ast
+        puts "#{classname} @ #{token.pos} #{token.source}"
+        indent { children.each(&:dump_ast) }
+      end
+
+      def dump_idr(short = false)
+        puts "#{classname}" if !short
+      end
+
+      def dump_attrs(*attrs)
+        indent {
+          Array(attrs).flatten.select { |attr| attr.is_a?(Symbol) }.each { |attr|
+            value = self.send(attr)
+            case value
+              when Brief
+                puts "#{attr}: #{value.text}"
+              when Node
+                puts "#{attr}:"
+                indent { value.dump_idr }
+              when Array
+                case value.first
+                  when nil
+                    puts "#{attr}: []"
+                  when Node
+                    puts "#{attr}:"
+                    indent { value.each(&:dump_idr) }
+                else
+                  puts "#{attr}: #{value.inspect}"
+                end
+              when ArgumentType
+                puts "#{attr}: #{value}"
+            else
+#             value = value.inspect if value.nil? || !value.respond_to?(:to_s)
+              puts "#{attr}: #{value.inspect}"
+            end
+          }
+        }
+      end
+
+    protected
+      def classname() self.class.to_s.sub(/.*::/, "") end
+    end
+
+    class Option
+      def dump_idr(short = false)
+        if short
+          s = [
+              name, 
+              argument? ? argument_type.name : nil, 
+              optional? ? "?" : nil, 
+              repeatable? ? "*" : nil
+          ].compact.join(" ")
+          puts s
+        else
+          puts "#{name}: #{classname}"
+          dump_attrs(
+              :uid, :path, :attr, :ident, :name, :idents, :names,
+              :repeatable?, 
+              :argument?, argument? && :argument_name, argument? && :argument_type, 
+              :enum?, enum? && :argument_enum, 
+              :optional?)
+          indent { puts "brief: #{group.brief}" }
+        end
+      end
+    end
+
+    class Command
+      def dump_idr(short = false)
+        if short
+          puts name
+          indent { 
+            options.each { |option| option.dump_idr(short) }
+            commands.each { |command| command.dump_idr(short) }
+            descrs.each { |descr| descr.dump_idr(short) }
+          } 
+        else
+          puts "#{name}: #{classname}"
+          dump_attrs :uid, :path, :ident, :name, :options, :commands, :specs, :descrs, :brief
+        end
+      end
+    end
+
+    class ArgDescr
+      def dump_idr(short = false)
+        super
+        indent { puts token.to_s }
+      end
+    end
+
+    class ArgSpec < Node
+      def dump_idr(short = false)
+        super
+        dump_attrs :arguments
+      end
+    end
+
+    class Arg < Node
+      def dump_idr(short = false)
+        puts "<type>"
+      end
+    end
+  end
+
+class Command
+    def __dump__(argv = [])
+      ::Kernel.puts __name__
+      ::Kernel.indent {
+        __options__.each { |ident, value| ::Kernel.puts "#{ident}: #{value.inspect}" }
+        __subcommand__!&.__dump__
+        ::Kernel.puts argv.map(&:inspect).join(" ") if !argv.empty?
+      }
+    end
+
+    # Class-level accessor methods
+    def self.dump(expr, argv = []) expr.__dump__(argv) end
+  end
+
+  class Option
+    def dump
+      ::Kernel.puts [name, argument].compact.join(" ")
+    end
+  end
+end
+