lab42_rgxargs 0.1.1 → 0.1.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ad2ab026f6192cc81dd04008d035a79188ed42723b4d687a536a49c010d8a0db
-  data.tar.gz: b4503cbb9403aec807fb871c5d901690d6ba026edb8c6b6080e0af4506b6e2a7
+  metadata.gz: 6c2b779615c5996b97aaa6fbb336adaecaba2119168d9cd6e28665bca4f26587
+  data.tar.gz: d1f125fb9a12342f54c3f6748d0a93c3782fc46d0abefd0330324a1ebe3aee3a
 SHA512:
-  metadata.gz: e41fc413182c5a6e6ca070c8980b9356738df2b956915c1fdf55849136642ff36b97cef4ee01e1fc3505269a7f9c7b9328044bd8c7a1d4b3401e08aa8820a5b8
-  data.tar.gz: e75cbfc5b427e68838513444862d0e3ccca90fe5363f517fe24f40beae2655c830c020f2c55559375069bfe837c4ab55940559f3625e318656b12c9c4ff3d5cc
+  metadata.gz: dab565b74468cc86dfdedcc162343fc9b85eae244d908a0422b78ef68c5cae65c49e1eb0acf8463bc0a492a645f89441c2f71438e7671eac4534aca89b19bbdf
+  data.tar.gz: 7bb8d96d57afeb88a720c6500dcefda5b2f8fc24e877112c0930e6062e0918b5fa304aa3816e757a1885e51567ed24c3cfec238b73d30678d6e99fe7be4b8410

data/lib/lab42/rgxargs.rb

@@ -4,116 +4,151 @@ require 'lab42/enumerable'
 module Lab42
 
   class Rgxargs
+    require_relative 'rgxargs/checker'
+    require_relative 'rgxargs/constrainer'
     require_relative 'rgxargs/predefined_matchers'
+    require_relative 'rgxargs/argument_matcher'
+    require_relative 'rgxargs/syntax_definer'
+    include Checker
+    include Constrainer
+
     Predefined = PredefinedMatchers
 
     extend Forwardable
     def_delegators Predefined, :list_matcher
 
-    attr_reader :args, :conversions, :defined_rules, :errors, :options, :syntaxes
+    attr_reader :allowed, :args, :conversions, :defaults, :defined_rules, :errors, :options, :required, :syntaxes
 
 
-    def add_conversion(param, conversion)
+    def add_conversion(param, conversion, required=nil, &block)
       case conversion
       when Symbol
-        conversions[param] = Predefined.fetch(conversion, conversion)
+        _add_symbolic_conversion(param, conversion, required)
       else
-        conversions[param] = conversion
+        _add_proc_conversion(param, conversion, block, required)
       end
     end
 
-    def add_syntax(rgx, parser=nil)
-      if parser
-        syntaxes << [rgx, parser]
-      else
-        if predef = Predefined.fetch(rgx)
-          syntaxes << predef
-          else
-            raise ArgumentError, "#{rgx} is not a predefined syntax, use one of the following:\n\t#{Predefined.defined_names}"
-          end
+    def add_syntax(rgx, parser=nil, as: nil)
+      case rgx
+      when Symbol, Regexp
+        syntaxes << ArgumentMatcher.new(rgx, parser, arg_name: as)
+      when Array
+        rgx.each do |rg1|
+          add_syntax( rg1, parser, as: as)
         end
       end
+    end
 
-      def parse argv
-        until argv.empty?
-          argv = _parse_next argv
-        end
-        [options, args, errors]
+    def define_arg name, &blk
+      SyntaxDefiner.new(self, name).run(blk)
+    end
+
+    def parse argv
+      until argv.empty?
+        argv = _parse_next argv
       end
+      _check_required_kwds
+      [options, args, errors]
+    end
 
 
-      private
+    private
 
-      def initialize &blk
-        @args          = []
-        @conversions   = {}
-        @defined_rules = []
-        @errors        = []
-        @options       = OpenStruct.new
-        @syntaxes      = []
+    def initialize &blk
+      @args          = []
+      @allowed       = nil
+      @conversions   = {}
+      @defaults      = {}
+      @defined_rules = []
+      @errors        = []
+      @required      = Set.new
+      @syntaxes      = []
 
-        instance_exec(&blk) if blk
-      end
+      instance_exec(&blk) if blk
+      @options       = OpenStruct.new(defaults)
+    end
 
-      def _convert(value, name:) 
-        conv = conversions.fetch(name, nil)
-        case conv
-        when Symbol
-          value.send conv
-        when Proc
-          conv.(value)
-        when Array
-          if (match = conv.first.match(value))
-            conv.last.(match.captures) 
-          else
-            errors << [:syntax_error, name, "#{value} does not match #{conv.first}"]
-            nil
-          end
+    def _convert(value, name:)
+      conv = conversions.fetch(name, nil)
+      case conv
+      when Symbol
+        value.send conv
+      when Proc
+        conv.(value)
+      when Array
+        if (match = conv.first.match(value))
+          conv[1].(*match.captures)
         else
-          value
+          errors << [:syntax_error, name, "#{value} does not match #{conv.first}"]
+          nil
         end
+      else
+        value
       end
+    end
 
-      def _defined_rules(_arg)
-        false
+    def _add_proc_conversion(param, conversion, block, required)
+      Array(param).each do |para|
+        @required.add para if required == :required
+        conversions[para] =  block ? [conversion, block] : conversion
       end
+    end
 
-      def _parse_next argv
-        first, *rest = argv
-        if _defined_rules(first)
-          return rest
-        end
-        _parse_symbolic first, rest
+    def _add_symbolic_conversion(param, conversion, required)
+      Array(param).each do |para|
+        @required.add para if required == :required
+        conversions[para] = Predefined.fetch(conversion, conversion)
       end
+    end
 
-      def _parse_symbolic first, rest
-        case first
-        when %r{\A:(.*)}
-          options[$1.gsub('-','_').to_sym]=true
-          rest
-        when %r{(.*):\z}
-          _parse_value $1.gsub('-', '_').to_sym, rest
-        else
-          _parse_syntax(first)
-          rest
-        end
+    def _parse_next argv
+      first, *rest = argv
+      if first == '--'
+        @args += rest
+        return []
       end
+      _parse_symbolic first, rest
+    end
 
-      def _parse_syntax first
-        args << syntaxes.find_value(first) do |(rgx, converter)|
-          (match = rgx.match(first)) && converter.(match.captures) 
-        end
+    def _parse_symbolic first, rest
+      case first
+      when %r{\A:(.*)}
+        switch = $1.gsub('-','_').to_sym
+        _check_switch(switch)
+        options[switch]=true
+        rest
+      when %r{(.*):\z}
+        kwd = $1.gsub('-', '_').to_sym
+        _check_kwd(kwd)
+        _parse_value kwd, rest
+      when %r{\A\\(.*)}
+        args << $1
+        rest
+      else
+        _parse_syntax(first)
+        rest
       end
+    end
 
-      def _parse_value name, rest
-        value, *rest1 = rest
-        if value
-          options[name] = _convert(value, name: name)
-          return rest1
-        end
-        errors << [:missing_required_value, name]
-        []
+    def _parse_syntax first
+      value, as = syntaxes.find_value(first){ |matcher| matcher.match(first) }
+      if as
+        options[as] = value
+      else
+        args << value
       end
+    end
 
+    def _parse_value name, rest
+      value, *rest1 = rest
+      if value
+        options[name] = _convert(value, name: name)
+        return rest1
+      end
+      errors << [:missing_required_value, name]
+      []
     end
+
   end
+end

data/lib/lab42/rgxargs/argument_matcher.rb

@@ -0,0 +1,35 @@
+class Lab42::Rgxargs::ArgumentMatcher
+  require_relative './error'
+  require_relative './predefined_matchers'
+
+  Predefined = Lab42::Rgxargs::PredefinedMatchers 
+  Error      = Lab42::Rgxargs::Error
+
+  attr_reader :arg_name, :converter, :matcher
+
+
+
+  def match value
+    case matcher
+    when Regexp
+      match = matcher.match(value)
+      match && [converter.(*match.captures), arg_name] 
+    else
+      matcher.to_s == value && [converter.(), arg_name]
+    end
+  end
+
+  private
+
+  def initialize(matcher, converter, arg_name: nil)
+    @arg_name  = arg_name
+    @matcher   = matcher
+    @converter = converter || _get_predefined
+  end
+
+  def _get_predefined
+    @matcher, converter = Predefined.fetch(matcher) { raise Error, "undefined syntax #{matcher}" }
+    converter
+  end
+
+end

data/lib/lab42/rgxargs/checker.rb

@@ -0,0 +1,33 @@
+module Lab42
+  class Rgxargs
+    module Checker
+
+      private
+
+      def _check_kwd(kwd)
+        return if allowed.nil?
+        return if allowed.member? kwd
+        return if required.member? kwd
+        errors << [:unauthorized_kwd, kwd]
+      end
+
+      def _check_required_kwds
+        missing = required - options.to_h.keys
+        @errors += missing.map(&_mk_pair(:required_kwd_missing))
+      end
+      
+
+      def _mk_pair(prefix)
+        -> element do
+          [prefix, element]
+        end
+      end
+
+      def _check_switch(_)
+        
+      end
+
+
+    end
+  end
+end

data/lib/lab42/rgxargs/constrainer.rb

@@ -0,0 +1,15 @@
+module Lab42
+  class Rgxargs
+    module Constrainer
+
+      def allow_kwds(*kwds)
+        @allowed = (allowed||Set.new).union(Set.new(kwds.flatten))
+      end
+
+      def require_kwds(*kwds)
+        @required = (required||Set.new).union(Set.new(kwds.flatten))
+      end
+
+    end
+  end
+end

data/lib/lab42/rgxargs/error.rb

@@ -0,0 +1,2 @@
+class Lab42::Rgxargs::Error < RuntimeError
+end

data/lib/lab42/rgxargs/predefined_matchers.rb

@@ -1,9 +1,10 @@
 module Lab42::Rgxargs::PredefinedMatchers extend self
   PREDEFINED = {
-    int_list: [%r{\A(-?\d+(?:,-?\d+)*)\z}, ->(groups){ groups.first.split(",").map(&:to_i)}],
-    int_range: [%r{\A(-?\d+)(?:-|\.\.)(-?\d+)\z}, ->((f, l)){ Range.new(f.to_i, l.to_i) }],
-    list:  [%r{(\w+)(?:,(\w+))*},   ->(groups){ groups.compact }],
-    range: [%r{\A(\d+)\.\.(\d+)\z}, ->(groups){ Range.new(*groups.map(&:to_i)) }]
+    int: [%r{\A([-+]?\d+)\z}, :to_i.to_proc],
+    int_list: [%r{\A(-?\d+(?:,-?\d+)*)\z}, ->(*groups){ groups.first.split(",").map(&:to_i)}],
+    int_range: [%r{\A(-?\d+)(?:-|\.\.)(-?\d+)\z}, ->(f, l){ Range.new(f.to_i, l.to_i) }],
+    list:  [%r{(\w+)(?:,(\w+))*},   ->(*groups){ groups.compact }],
+    range: [%r{\A(\d+)\.\.(\d+)\z}, ->(*groups){ Range.new(*groups.map(&:to_i)) }]
   }
 
   def defined_names
@@ -16,12 +17,11 @@ module Lab42::Rgxargs::PredefinedMatchers extend self
   end
 
   def list_matcher values
-    [%r{\A((?:#{values.join("|")})(?:,(?:#{values.join("|")}))*)\z}, _list_extractor]
+    [%r{\A((?:#{values.join("|")})(?:,(?:#{values.join("|")}))*)\z}, method(:_list_extractor)]
   end
 
 
-  # Memoized
-  def _list_extractor
-    @__list_extractor__ ||= ->(groups){ groups.first.split(",") }
+  def _list_extractor(*groups)
+    groups.first.split(",")
   end
 end

data/lib/lab42/rgxargs/syntax.rb

@@ -0,0 +1,19 @@
+class Lab42::Rgxargs::Syntax
+
+  attr_reader :converter, :matcher
+
+  def matches? value
+    if match = matcher.match(value)
+      yield converter.(*match.captures)
+      true
+    end
+  end
+
+  private
+  
+  def initialize matcher, converter
+    @converter = converter
+    @matcher   = matcher
+  end
+
+end

data/lib/lab42/rgxargs/syntax_definer.rb

@@ -0,0 +1,34 @@
+# Instanciated with an Rgxargs parser it can run a block
+# in its own context so that the block accesses the
+# parser's functionality with syntactic sugar w/o cluttering
+# ther parser itself with too many methods
+# E.g.:
+#
+#     ```ruby
+#         syntax
+#         
+#     ```
+class Lab42::Rgxargs::SyntaxDefiner
+
+
+  attr_reader :arg_name, :parser
+
+  def run code
+    instance_exec(&code)
+  end
+
+  def syntax(matcher, value=nil, &blk)
+    if value
+      parser.add_syntax(matcher, ->(){value}, as: arg_name )
+    else
+      parser.add_syntax(matcher, blk, as: arg_name)
+    end
+  end
+
+  private
+
+  def initialize(parser, arg_name)
+    @arg_name = arg_name
+    @parser   = parser
+  end
+end

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: lab42_rgxargs
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.6
 platform: ruby
 authors:
 - Robert Dober
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-01-18 00:00:00.000000000 Z
+date: 2020-01-27 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: speculate_about
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.2
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -38,6 +52,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.7'
+- !ruby/object:Gem::Dependency
+  name: pry-doc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
 description: Parse CL args according to regexen
 email: robert.dober@gmail.com
 executables: []
@@ -46,12 +74,18 @@ extra_rdoc_files: []
 files:
 - lib/lab42/enumerable.rb
 - lib/lab42/rgxargs.rb
+- lib/lab42/rgxargs/argument_matcher.rb
+- lib/lab42/rgxargs/checker.rb
+- lib/lab42/rgxargs/constrainer.rb
+- lib/lab42/rgxargs/error.rb
 - lib/lab42/rgxargs/predefined_matchers.rb
+- lib/lab42/rgxargs/syntax.rb
+- lib/lab42/rgxargs/syntax_definer.rb
 homepage: https://github.com/robertdober/lab42_rgxargs
 licenses:
 - Apache-2.0
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -59,15 +93,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 2.7.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.6
-signing_key: 
+rubygems_version: 3.1.2
+signing_key:
 specification_version: 4
 summary: Parse CL args according to regexen
 test_files: []