opt_parse_validator 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 1b0a34c11c84d6fa32580ed925dac42346cee747
+  data.tar.gz: 7c50ea36943042d5cf7f8b77c15fd93b0969339c
+SHA512:
+  metadata.gz: 051c726116d357bd876f87d9a113ba3c00f53a2b146e92e69d2447bef77de471fe2150f2c834356d52a1ec0b5b14f0b8e94e3177e3e6c84190ceac2068be1579
+  data.tar.gz: 910103742d3c7cfab15980043a02a169a9708f4ed3f11086ee280eec9d8cdd57621d82a8cf04f7739083f7384fd50c98e45ac2e5a129175c5a5461f52d2c8ff6

data/.gitignore

@@ -0,0 +1,3 @@
+coverage
+Gemfile.lock
+*.gem

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--fail-fast

data/.rubocop.yml

@@ -0,0 +1,4 @@
+LineLength:
+  Enabled: false
+MethodLength:
+  Max: 20

data/.simplecov

@@ -0,0 +1,4 @@
+SimpleCov.start do
+  add_filter '/spec/'
+  add_filter '_helper.rb'
+end

data/.travis.yml

@@ -0,0 +1,15 @@
+language: ruby
+rvm:
+  - 2.0.0
+  - 2.1.0
+  - 2.1.1
+  - 2.1.2
+  - ruby-head
+matrix:
+  allow_failures:
+    - rvm: ruby-head
+before_script:
+  - chmod 0400 spec/fixtures/r.txt
+script:
+  - bundle exec rspec
+  - bundle exec rubocop

data/Gemfile

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+gemspec
+
+group :test do
+  gem 'coveralls', require: false
+end

data/README.md

@@ -0,0 +1,40 @@
+OptParseValidator
+=================
+
+[![Build Status](https://img.shields.io/travis/wpscanteam/OptParseValidator.svg)](https://travis-ci.org/wpscanteam/OptParseValidator)
+[![Coverage Status](https://img.shields.io/coveralls/wpscanteam/OptParseValidator.svg)](https://coveralls.io/r/wpscanteam/OptParseValidator?branch=master)
+[![Code Climate](https://img.shields.io/codeclimate/github/wpscanteam/OptParseValidator.svg)](https://codeclimate.com/github/wpscanteam/OptParseValidator)
+[![Dependency Status](https://img.shields.io/gemnasium/wpscanteam/OptParseValidator.svg)](https://gemnasium.com/wpscanteam/OptParseValidator)
+
+
+### Available Validators & associated attributes:
+- Boolean
+- Choice
+  - :choices (mandatory)
+  - :case_sensitive
+- Credentials
+- Directory Path
+  - :exists
+  - :executable
+  - :readable
+  - :writable
+- File Path
+  - :exists
+  - :executable
+  - :readable
+  - :writable
+- Integer
+- Positive Integer
+- Path
+  - :file
+  - :directory
+  - :exists
+  - :executable
+  - :readable
+  - :writable
+- Proxy
+  - :protocols
+- String
+- URI
+  - :protocols
+- URL

data/Rakefile

@@ -0,0 +1,9 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+require 'rubocop/rake_task'
+
+RuboCop::RakeTask.new
+RSpec::Core::RakeTask.new(:spec)
+
+# Run rubocop & rspec before the build
+task build: [:rubocop, :spec]

data/lib/opt_parse_validator/hacks.rb

@@ -0,0 +1,15 @@
+class OptionParser
+  # Hack to suppress the completion (expect for the -h/--help) which was leading to
+  # unwanted behaviours
+  # See https://github.com/wpscanteam/CMSScanner/issues/2
+  module Completion
+    class << self
+      alias_method :original_candidate, :candidate
+
+      def candidate(key, icase = false, pat = nil, &block)
+        # Maybe also do this for -v/--version ?
+        key == 'h' ? original_candidate('help', icase, pat, &block) : []
+      end
+    end
+  end
+end

data/lib/opt_parse_validator/options_file.rb

@@ -0,0 +1,62 @@
+require 'json'
+require 'yaml'
+
+module OptParseValidator
+  # TODO
+  class OptParser < OptionParser
+    def options_files
+      @options_files ||= []
+    end
+
+    def load_options_files
+      files_data = {}
+
+      options_files.each do |file|
+        data = parse_file(file)
+        files_data.merge!(data) if data
+      end
+
+      @opts.each do |opt|
+        # Annoying thing: the hash returned from parse_file is a string-full {"key"=>"value"}
+        # and not a ruby hash {key: value} :/ As a result, symbol.to_s has to be used
+        next unless files_data.key?(opt.to_sym.to_s)
+
+        @results[opt.to_sym] = opt.normalize(opt.validate(files_data[opt.to_sym.to_s]))
+      end
+    end
+
+    protected
+
+    # @param [ String ] file_path
+    #
+    # @return [ Hash ]
+    def parse_file(file_path)
+      return unless File.exist?(file_path)
+
+      file_ext       = File.extname(file_path).delete('.')
+      method_to_call = "parse_#{file_ext}"
+
+      fail "The format #{file_ext} is not supported" unless respond_to?(method_to_call, true) # The true allows to check protected & private methods
+
+      begin
+        method(method_to_call).call(file_path)
+      rescue
+        raise "Parse Error, #{file_path} seems to be malformed"
+      end
+    end
+
+    # @param [ String ] file_path
+    #
+    # @return [ Hash ]
+    def parse_json(file_path)
+      JSON.parse(File.read(file_path))
+    end
+
+    # @param [ String ] file_path
+    #
+    # @return [ Hash ]
+    def parse_yml(file_path)
+      YAML.load_file(file_path)
+    end
+  end
+end

data/lib/opt_parse_validator/opts/base.rb

@@ -0,0 +1,74 @@
+module OptParseValidator
+  # Base Option
+  # This Option should not be called, children should be used.
+  class OptBase
+    attr_writer :required
+    attr_reader :option, :attrs
+
+    # @param [ Array ] option See OptionParser#on
+    # @param [ Hash ] attrs
+    # @option attrs [ Boolean ] :required
+    # @option attrs [ Mixed ] :default The default value to use if the option is not supplied
+    # @option attrs [ Boolean ] :to_sym If true, returns the symbol of the validated value
+    # @option attrs [ Array<Symbol> ] :normalize See #normalize
+    #
+    # @note The :default and :normalize 'logics' are done in OptParseValidator::OptParser#add_option
+    def initialize(option, attrs = {})
+      @option = option
+      @attrs  = attrs
+    end
+
+    # @return [ Boolean ]
+    def required?
+      @required || attrs[:required]
+    end
+
+    # @param [ String ] value
+    def validate(value)
+      fail 'Empty option value supplied' if value.nil? || value.to_s.empty?
+      value
+    end
+
+    # Apply each methods from attrs[:normalize] to the value if possible
+    # User input should not be used in this attrs[:normalize]
+    #
+    # e.g: normalize: :to_sym will return the symbol of the value
+    #      normalize: [:to_sym, :upcase] Will return the upercased symbol
+    #
+    # @param [ Mixed ] value
+    #
+    # @return [ Mixed ]
+    def normalize(value)
+      [*attrs[:normalize]].each do |method|
+        next unless method.is_a?(Symbol)
+
+        value = value.send(method) if value.respond_to?(method)
+      end
+
+      value
+    end
+
+    # @return [ Symbol ]
+    def to_sym
+      unless @symbol
+        long_option = to_long
+
+        fail "Could not find option symbol for #{option}" unless long_option
+
+        @symbol = long_option.gsub(/^--/, '').gsub(/-/, '_').to_sym
+      end
+      @symbol
+    end
+
+    # @return [ String ] The raw long option (e.g: --proxy)
+    def to_long
+      option.each do |option_attr|
+        if option_attr =~ /^--/
+          return option_attr.gsub(/ .*$/, '')
+                            .gsub(/\[[^\]]+\]/, '')
+        end
+      end
+      nil
+    end
+  end
+end

data/lib/opt_parse_validator/opts/boolean.rb

@@ -0,0 +1,20 @@
+module OptParseValidator
+  # Implementation of the Boolean Option
+  class OptBoolean < OptBase
+    TRUE_PATTERN  = /\A(true|t|yes|y|1)\z/i
+    FALSE_PATTERN = /\A(false|f|no|n|0)\z/i
+
+    # @return [ Boolean ]
+    def validate(value)
+      value = value.to_s
+
+      if value.match(TRUE_PATTERN)
+        return true
+      elsif value.match(FALSE_PATTERN)
+        return false
+      else
+        fail 'Invalid boolean value, expected true|t|yes|y|1|false|f|no|n|0'
+      end
+    end
+  end
+end

data/lib/opt_parse_validator/opts/choice.rb

@@ -0,0 +1,33 @@
+module OptParseValidator
+  # Implementation of the Choice Option
+  class OptChoice < OptBase
+    # @param [ Array ] option See OptBase#new
+    # @param [ Hash ] attrs
+    #   :choices [ Array ] The available choices (mandatory)
+    #   :case_sensitive [ Boolean ] Default: false
+    def initialize(option, attrs = {})
+      fail 'The :choices attribute is mandatory' unless attrs.key?(:choices)
+      fail 'The :choices attribute must be an array' unless attrs[:choices].is_a?(Array)
+
+      super(option, attrs)
+    end
+
+    # @return [ String ]
+    # If :case_sensitive if false (or nil), the downcased value of the choice
+    # will be returned
+    def validate(value)
+      value   = value.to_s
+      choices = attrs[:choices]
+
+      unless attrs[:case_sensitive]
+        value.downcase!
+        choices.map!(&:downcase)
+      end
+
+      fail "'#{value}' is not a valid choice, expected one " \
+           "of the followings: #{choices.join(',')}" unless choices.include?(value)
+
+      value
+    end
+  end
+end

data/lib/opt_parse_validator/opts/credentials.rb

@@ -0,0 +1,14 @@
+module OptParseValidator
+  # Implementation of the Credentials Option
+  class OptCredentials < OptBase
+    # @return [ Hash ] A hash containing the :username and :password
+    def validate(value)
+      unless value.index(':')
+        fail 'Incorrect credentials format, username:password expected'
+      end
+      creds = value.split(':', 2)
+
+      { username: creds[0], password: creds[1] }
+    end
+  end
+end

data/lib/opt_parse_validator/opts/directory_path.rb

@@ -0,0 +1,10 @@
+module OptParseValidator
+  # Implemetantion of the DirectoryPath Option
+  class OptDirectoryPath < OptPath
+    def initialize(option, attrs = {})
+      super(option, attrs)
+
+      @attrs.merge!(directory: true)
+    end
+  end
+end

data/lib/opt_parse_validator/opts/file_path.rb

@@ -0,0 +1,24 @@
+module OptParseValidator
+  # Implementation of the FilePath Option
+  class OptFilePath < OptPath
+    # @param [ Array ] option See OptBase#new
+    # @param [ Hash ] attrs See OptPath#new
+    # :extensions [ Array | String ] The allowed extension(s)
+    def initialize(option, attrs = {})
+      super(option, attrs)
+
+      @attrs.merge!(file: true)
+    end
+
+    def allowed_attrs
+      # :extensions is put at the first place
+      [:extensions] + super
+    end
+
+    def check_extensions(path)
+      return if [*attrs[:extensions]].include?(path.extname.delete('.'))
+
+      fail "The extension of '#{path}' is not allowed"
+    end
+  end
+end

data/lib/opt_parse_validator/opts/integer.rb

@@ -0,0 +1,12 @@
+module OptParseValidator
+  # Implementation of the Integer Option
+  class OptInteger < OptBase
+    # @param [ String ] value
+    #
+    # @return [ Integer ]
+    def validate(value)
+      fail "#{value} is not an integer" if value.to_i.to_s != value
+      value.to_i
+    end
+  end
+end

data/lib/opt_parse_validator/opts/path.rb

@@ -0,0 +1,61 @@
+module OptParseValidator
+  # Implementation of the Path Option
+  class OptPath < OptBase
+    # Initialize attrs:
+    #
+    # :exists     if set to false, will ignore the file? and directory? checks
+    #
+    # :file       Check if the path is a file
+    # :directory  Check if the path is a directory
+    #
+    # :executable
+    # :readable
+    # :writable
+    #
+
+    # @param [ String ] value
+    #
+    # @return [ String ]
+    def validate(value)
+      path = Pathname.new(value)
+      allowed_attrs.each do |key|
+        method = "check_#{key}"
+        send(method, path) if self.respond_to?(method) && attrs[key]
+      end
+
+      path.to_s
+    end
+
+    def allowed_attrs
+      [:file, :directory, :executable, :readable, :writable]
+    end
+
+    # @param [ Pathname ] path
+    def check_file(path)
+      fail "'#{path}' is not a file" unless path.file? || attrs[:exists] == false
+    end
+
+    # @param [ Pathname ] path
+    def check_directory(path)
+      fail "'#{path}' is not a directory" unless path.directory? || attrs[:exists] == false
+    end
+
+    # @param [ Pathname ] path
+    def check_executable(path)
+      fail "'#{path}' is not executable" unless path.executable?
+    end
+
+    # @param [ Pathname ] path
+    def check_readable(path)
+      fail "'#{path}' is not readable" unless path.readable?
+    end
+
+    # If the path does not exist, it will check for the parent
+    # directory write permission
+    #
+    # @param [ Pathname ] path
+    def check_writable(path)
+      fail "'#{path}' is not writable" if path.exist? && !path.writable? || !path.parent.writable?
+    end
+  end
+end

data/lib/opt_parse_validator/opts/positive_integer.rb

@@ -0,0 +1,13 @@
+module OptParseValidator
+  # Implementation of the Positive Integer Option
+  class OptPositiveInteger < OptInteger
+    # @param [ String ] value
+    #
+    # @return [ Integer ]
+    def validate(value)
+      i = super(value)
+      fail "#{i} is not > 0" unless i > 0
+      i
+    end
+  end
+end

data/lib/opt_parse_validator/opts/proxy.rb

@@ -0,0 +1,5 @@
+module OptParseValidator
+  # Implementation of the Proxy Option
+  class OptProxy < OptURI
+  end
+end

data/lib/opt_parse_validator/opts/string.rb

@@ -0,0 +1,6 @@
+module OptParseValidator
+  # Alias of OptBase
+  # Used for convenience
+  class OptString < OptBase
+  end
+end

data/lib/opt_parse_validator/opts/uri.rb

@@ -0,0 +1,24 @@
+module OptParseValidator
+  # Implementation of the URI Option
+  class OptURI < OptBase
+    def allowed_protocols
+      @allowed_protocols ||= [*attrs[:protocols]]
+    end
+
+    # @param [ String ] value
+    #
+    # @return [ String ]
+    def validate(value)
+      uri       = Addressable::URI.parse(value)
+      protocols = allowed_protocols
+
+      unless protocols.empty? || protocols.include?(uri.scheme)
+        # For future refs: will have to check if the uri.scheme exists,
+        # otherwise it means that the value was empty
+        fail Addressable::URI::InvalidURIError
+      end
+
+      uri.to_s
+    end
+  end
+end

data/lib/opt_parse_validator/opts/url.rb

@@ -0,0 +1,9 @@
+module OptParseValidator
+  # Implementation of the URL Option
+  class OptURL < OptURI
+    # @return [ Array ] The allowed protocols
+    def allowed_protocols
+      %w(http https)
+    end
+  end
+end

data/lib/opt_parse_validator/opts.rb

@@ -0,0 +1,3 @@
+%w(base string integer positive_integer choice boolean uri url proxy credentials path file_path directory_path).each do |opt|
+  require 'opt_parse_validator/opts/' + opt
+end

data/lib/opt_parse_validator/version.rb

@@ -0,0 +1,4 @@
+# Gem Version
+module OptParseValidator
+  VERSION = '0.0.2'
+end

data/lib/opt_parse_validator.rb

@@ -0,0 +1,77 @@
+# Gems
+require 'addressable/uri'
+# Standard Libs
+require 'optparse'
+require 'pathname'
+# Custom Libs
+require 'opt_parse_validator/hacks'
+require 'opt_parse_validator/opts'
+require 'opt_parse_validator/version'
+require 'opt_parse_validator/options_file'
+
+# Gem namespace
+module OptParseValidator
+  # Validator
+  class OptParser < OptionParser
+    attr_reader :symbols_used, :opts
+
+    def initialize(banner = nil, width = 32, indent = ' ' * 4)
+      @results      = {}
+      @symbols_used = []
+      @opts         = []
+
+      super(banner, width, indent)
+    end
+
+    # @param [ OptBase ] options
+    #
+    # @return [ void ]
+    def add(*options)
+      options.each { |option| add_option(option) }
+    end
+
+    # @param [ OptBase ] opt
+    #
+    # @return [ void ]
+    def add_option(opt)
+      fail "The option is not an OptBase, #{opt.class} supplied" unless opt.is_a?(OptBase)
+      fail "The option #{opt.to_sym} is already used !" if @symbols_used.include?(opt.to_sym)
+
+      @opts         << opt
+      @symbols_used << opt.to_sym
+      # Set the default option value if it exists
+      @results[opt.to_sym] = opt.attrs[:default] if opt.attrs.key?(:default)
+
+      on(*opt.option) do |arg|
+        begin
+          @results[opt.to_sym] = opt.normalize(opt.validate(arg))
+        rescue => e
+          # Adds the long option name to the message
+          # e.g --proxy Invalid Scheme format.
+          raise e.class, "#{opt.to_long} #{e}"
+        end
+      end
+    end
+
+    # @return [ Hash ]
+    def results(argv = default_argv)
+      load_options_files
+      self.parse!(argv)
+      post_processing
+
+      @results
+    end
+
+    # Ensure that all required options are supplied
+    # Should be overriden to modify the behavior
+    #
+    # @return [ Void ]
+    def post_processing
+      @opts.each do |opt|
+        next unless opt.required? && !@results.key?(opt.to_sym)
+
+        fail "The option #{opt.to_sym} is required"
+      end
+    end
+  end
+end

data/opt_parse_validator.gemspec

@@ -0,0 +1,32 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+require 'opt_parse_validator/version'
+
+Gem::Specification.new do |s|
+  s.name                  = 'opt_parse_validator'
+  s.version               = OptParseValidator::VERSION
+  s.platform              = Gem::Platform::RUBY
+  s.required_ruby_version = '>= 2.0.0'
+  s.authors               = ['WPScanTeam - Erwan le Rousseau']
+  s.email                 = ['erwan.lr@gmail.com']
+  s.summary               = 'Testing Gem'
+  s.description           = 'Testing Gem ...'
+  s.homepage              = 'https://github.com/wpscanteam/OptParseValidator'
+  s.license               = 'MIT'
+
+  s.files                 = `git ls-files -z`.split("\x0")
+  s.executables           = s.files.grep(/^bin\//) { |f| File.basename(f) }
+  s.test_files            = s.files.grep(/^(test|spec|features)\//)
+  s.require_paths         = ['lib']
+
+  s.add_dependency 'addressable', '~> 2.3'
+
+  s.add_development_dependency 'rake'
+  s.add_development_dependency 'rspec',     '~> 3.1'
+  s.add_development_dependency 'rspec-its'
+  s.add_development_dependency 'bundler',   '~> 1.6'
+  s.add_development_dependency 'rubocop',   '~> 0.26'
+  s.add_development_dependency 'simplecov', '~> 0.9'
+end

data/spec/fixtures/options_file/default.json

@@ -0,0 +1,4 @@
+{
+  "verbose": true,
+  "override_me": "I should be overriden"
+}

data/spec/fixtures/options_file/malformed.json

@@ -0,0 +1,4 @@
+{
+  "verbose": true,
+  "":,
+}

data/spec/fixtures/options_file/override.yml

@@ -0,0 +1 @@
+override_me: "Yeaa"

data/spec/fixtures/options_file/unsupported.ext

@@ -0,0 +1 @@
+Unsupported file format

data/spec/fixtures/r.txt

@@ -0,0 +1 @@
+This file is a chmod 400

data/spec/fixtures/rwx.txt

@@ -0,0 +1 @@
+This file is a chmod 777