kdict 0.1.1

data/kdict.gemspec

@@ -0,0 +1,39 @@
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "kdict/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "kdict"
+  spec.version       = Kdict::VERSION
+  spec.authors       = ["Steven K Terry"]
+  spec.email         = ["stkterry@gmail.com"]
+
+  spec.summary       = %q{KDict allows you to quickly create powerful Keyword-Argument Dictionaries to automate input validation.}
+  spec.description   = %q{KDict allows you to quickly create powerful Keyword-Argument Dictionaries.  Each
+                          entry can be used to validate a user's input against it, and is built from a
+                          generic type defintion (*typedef*) and a unique structure (*struct*).
+
+                          With the included *typedefs* users can create simple to complex validaters in
+                          just a single line of code.
+
+                          Examples avaible here in the README don't offer up the full scope of usefulness,
+                          so take the time to look at the example documentation and perhaps run a few of
+                          them yourself.}
+  #spec.homepage      = "https://github.com/stkterry/KDict"
+
+  spec.license       = "MIT"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 2.0"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+end

data/lib/kdict/kwargdict/kwargtypes/bool.rb

@@ -0,0 +1,9 @@
+# A useful collection of monkey-wrenching that makes creating KwargTypes and
+# KwargModels a little simpler.
+
+# Empty module that's assigned to both {TrueClass} and {FalseClass}.
+module Bool; end
+# Adds the {Bool} module to {TrueClass}.
+class TrueClass; include Bool; end
+# Adds the {Bool} module to {FalseClass}.
+class FalseClass; include Bool; end

data/lib/kdict/kwargdict/kwargtypes.rb

@@ -0,0 +1,196 @@
+# KwargTypes is a collection of generic definitions that are called as parameters
+# from {KwargDict}.  Each definition or *typedef* validates a user's input against
+# models built in the dictionary. Every *typedef* receives a user's argument and
+# an associated *struct*, and checks to see if that argument passes the *struct*'s
+# unique conditions. All *typedefs* return Boolean.  Some *typedefs* can receive
+# a Proc that further modifies the *struct*'s behavior by adding to (but never overridding)
+# its conditions for truthiness.
+#
+module KwargTypes
+
+  # Used internally.  Gives *typedefs* access to a modified list of generic datatypes.
+  @@types = [Numeric, Float, Integer, Hash, Array, Bool, String, Symbol]
+
+  # Used by KwargDict to check against listed definitions before accepting
+  # a new KwargModel.
+  @@typedefs = [:typeof, :arrayof, :anyof, :anyNof, :formof, :kwargsof,
+    :adv_formof, :and_kwargsof]
+
+  #  ====Your *struct* contains a singular value of exactly one datatype.
+  #
+  # * *structs* - Some of Ruby's built-in types plus *Bool*, an added datatype for 
+  #   true/false collectively.  Acceptable *struct* arguments then, are: *Numeric*, *Float*, *Integer*, *Bool*, *String*, *Symbol*
+  # * Can accept a Proc that must also return true for successful validation
+  # @return [Boolean]
+  # @example (Called From a KwargDict instance)
+  #  my_dict[:example] = :typeof, Bool
+  #  my_dict[:proc_example] = :typeof, Float, Proc.new { |n| n > 5.3 }
+  #  my_dict.check(:example, false) # => true
+  #  my_dict.check(:proc_example, 2.1) # => false
+  def typeof(arg, struct, prc=nil)
+    return false if [Hash, Array].any? { |type| arg.is_a?(type) }
+    prc ||= Proc.new{true}
+    arg.is_a?(struct) && prc.call(arg)
+  end
+
+  #  ====Your *struct* contains an array of any length but contain only one datatype.
+  #
+  # * *structs* - Again some of Ruby's built-in types plus Bool: *Numeric*, *Float*, *Integer*, *Bool*, *String*, *Symbol*
+  # * Multi-dimensional arrays will be treated as flattened and all values will still
+  #   be checked against the given *struct*
+  # * Can accept a Proc that must return true for ALL values in the array.
+  # @return [Boolean]
+  # @example (Called From a KwargDict instance)
+  #   my_dict[:example] = :arrayof, Strings
+  #   my_dict[:proc_example] = :arrayof, Strings, Proc.new { |s| s.length > 2 }
+  #   my_dict.check(:example, ['This', 'will', 'return', 'true']) # => true
+  #   my_dict.check(:proc_example, ['This', 'is', 'still', 'false']) # => false
+  def arrayof(arg, struct, prc=nil)
+    return false if !arg.is_a?(Array)
+    prc ||= Proc.new{true}
+    arg.flatten.all? { |ele| ele.is_a?(struct) && prc.call(ele) }
+  end
+
+  # ====Your *struct* contains a singular element that can be found in an array.
+  #
+  # * *structs* - An array of any mix of things you'd like, EXCEPT other instances of KwargModels or KwargDicts.
+  # * Will not accept a Proc and must not contain generic datatype symbols.
+  # @return [Boolean]
+  # @example (Called From a KwargDict instance)
+  #  my_dict[:example] = :anyof, ['xx-small', 'x-small', 'large', 3.2]
+  #  my_dict.check(:example, 3.2) # => true
+  #  my_dict.check(:example, 'xx-large') # => false
+  def anyof(arg, struct)
+    struct.include?(arg)
+  end
+
+  # ====Your *struct* contains an element OR specific datatype in an array.
+  #
+  # * *structs* - An array of any mixed things you'd like plus generic datatype 
+  #   keywords *Numeric*, *Float*, *Integer*, *Bool*, *String*, *Symbol*
+  # * Can accept a Proc that will only operate on a given value if it's identified 
+  #   by a generic datatype in *struct* after a check for explicit existence in the array
+  # @example (Called From a KwargDict instance)
+  #   my_dict[:example] = :anyNof, [Integer, 'red', 'blue', 'magenta']
+  #   my_dict[:proc_example] = :anyNof, [Float, 'green', 3.1], Proc.new { |n| n > 5 }
+  #   my_dict.check(:example, 'red') # => true
+  #   my_dict.check(:example, 34) # => true
+  #   my_dict.check(:proc_example, 'green') # => true
+  #   my_dict.check(:proc_example, 6.1) # => true
+  #   my_dict.check(:proc_example, 3.1) # => true
+  def anyNof(arg, struct, prc=nil)
+    prc ||= Proc.new {true}
+    return true if anyof(arg, struct)
+    if struct.select { |ele| @@types.include?(ele) }.any? { |type| arg.is_a?(type) && prc.call(arg) }
+      return true
+    end
+    false
+  end
+
+  # ====Your *struct* contains an array of exact length, you expect each element to be contained in a specific order and be a generic datatype
+  #
+  # * *structs* - An array of set length containing generic datatype keywords *Numeric*, 
+  #   *Float*, *Integer*, *Bool*, *String*, *Symbol*, in a specific order.  Will 
+  #   return false if user input appears out of order with respect to the *struct*.
+  # * Can accept a Proc that must return true for ALL values in the array.
+  # @example (Called From a KwargDict instance)
+  #   my_dict[:example] = :formof, [Bool, Float, String]
+  #   my_dict[:proc_example] = :formof, [Integer, Float, Float], Proc.new { |n| n.between?(1, 3) }
+  #   my_dict.check(:example, [false, 3.1, "Holly Dolly"]) # => true
+  #   my_dict.check(:example, [false, 3.1]) # => false
+  #   my_dict.check(:example, ["Holly Dolly", 3.1, false]) # => false
+  #   my_dict.check(:proc_example, [2, 1.1, 1.2]) # => true
+  #   my_dict.check(:proc_example, [1.1, 2, 1.4]) # => false
+  def formof(arg, struct, prc=nil)
+    prc ||= Proc.new {true}
+    return false if !arg.is_a?(Array)
+    arg.zip(struct).all? { |a,s| a.is_a?(s) && prc.call(a) } ? (return true) : (return false)
+  end
+
+  # ====Your *struct* contains a hash that corresponds to another KwargDict
+  #
+  # * ***structs*** - Can only be another KwargDict instance.
+  # * Will not accept a Proc
+  # * Input hash need not contain every *kword* from the nested KwargDict to return true
+  # * Will return true only if every key-arg pair in input hash is valid in nested KwargDict
+  # @example (Called From a KwargDict instance)
+  #   another_dict.add([:one, :typeof, Float], [:two, :arrayof, String], [:three, :typeof, Bool],
+  #     [:and, :anyof, ['partridge', 'in', 'a', 'pear', 'tree']])
+  #   my_dict[:example] = :kwargsof, another_dict
+  #   my_dict.check(:example, {one:3.1, three:false, and:'in'}) # => true
+  #   my_dict.check(:example, {two:['this', 'works'], four:'without this'}) # => false
+  #   my_dict.check(:example, {two:['see?']}) # => true
+  def kwargsof(arg, struct)
+    return false if !arg.keys.all? { |sub_kword| struct.has_key?(sub_kword) }
+    arg.all? { |sub_word, sub_arg| valid?(sub_arg, *struct[sub_word].splay) }
+  end
+
+# ====Your *struct* contains an array of exact length, each of whom's elements has its own subset of *typedef*, *struct*, and possibly *prc*
+#
+# * *structs* - Must be an array of exact length, each element of which is a sub array
+#   containing *typedef*, *struct*, and an optional *prc*, in that order.  Can accept
+#   *:typeof*, *:arrayof*, *:anyof*, *:anyNof*, *:formof*, and *:adv_formof*.
+# * Will NOT accept *:kwargsof* or *:and_kwargsof*.
+# * Will return false if user input appears out of order with respect to the *struct*.
+# * Will not accept a Proc outside of a sub *typedef*.  Each element in *struct* may
+#   have its own unique Proc, however, if allowed for that *typedef*.
+# @example (Called From a KwargDict instance)
+#   my_dict[:example] = :adv_formof, [[:typeof, Float], [:arrayof, Integer]]
+#   my_dict[:proc_example] = :adv_formof, [[:typeof, String, Proc.new { |s| s.length > 5 }],
+#     [:formof, [Float]*3 , Proc.new { |n| n.ibetween?(0,1) }]]
+#   my_dict.check(:example, [3.1, [1, 2, 3, 4, 5]]) # => true
+#   my_dict.check(:example, [3.1, ['1', '2', '3']]) # => false
+#   my_dict.check(:proc_example, ["Longer", [0.25, 0.5, 1.0]]) # => true
+#   my_dict.check(:proc_example, ["Longer", [-0.25, 0.5, -1.0]]) # => false
+#   my_dict.check(:proc_example, ["Short", [0.25, 0.5, 1.0]]) # => false
+  def adv_formof(arg, struct)
+    return false if !arg.is_a?(Array) || arg.length != struct.length
+    arg.zip(struct).all? { |a, s| valid?(a, *s) }
+  end
+
+# ====Your *struct* is structured like *:adv_formof* but the last element MUST be a *:kwargsof* *typedef*
+#
+# * *structs* - MUST be an array in the form of *:adv_formof*, but the last sub 
+#   *typedef* MUST be a *kwargsof*
+# * Will return true if given a single value that returns true from the first sub *typedef* in the array.
+# * Will return true if given an array of values in the order they appear in *struct*, 
+#   without skipping one, and each returns true from its respective sub *typedef*
+# * Will return true if the previous statement is true but the given array also
+#   includes a hash that corresponds to the last sub *typedef* in the *struct*, 
+#   which again must always be *:kwargsof*.
+# * Will return false if only a hash is present, even if hash elements are
+#   all valid to its nested KwargDict
+# * Each sub *typedef* may receive a Proc if allowed for that *typedef*
+# @example (Called From a KwargDict instance)
+#   another_dict.add([:one, :typeof, Float], [:two, :arrayof, String])
+#   my_dict[:example] = :and_kwargsof, [[:typeof, String], [:typeof, Bool], [:kwargsof, another_dict]]
+#   my_dict.check(:example, 'It works!') # => true
+#   my_dict.check(:example, ['And this.']) # => true
+#   my_dict.check(:example, ['This too.', true]) # => true
+#   my_dict.check(:example, ['As does this.', false, {two:['Super!']}]) # => true
+#   my_dict.check(:example, ['Even this works.', {two:['Yep.'], one:3.1}]) # => true
+#   my_dict.check(:example, true) # => false | Skips the first element of :example
+#   my_dict.check(:example, [true, 'It broke!']) # => false | Elements appear out of order
+#   my_dict.check(:example, {one:'Nope'}) # => false 
+  def and_kwargsof(arg, struct)
+    return false if arg.is_a?(Hash)
+    
+    # If only one arg of several are present and it's the first...
+    if !arg.is_a?(Array)
+      return valid?(arg, *struct[0])
+    end 
+
+    if !arg[-1].is_a?(Hash)
+      return adv_formof(arg, struct[0...arg.length])
+    else
+      return false if !adv_formof(arg[0...-1], struct[0...arg.length-1])
+      return valid?(arg[-1], *struct[-1])
+    end
+
+  end
+  
+  private def valid?(arg, type, struct, prc=nil)
+    prc ? (self.send type, arg, struct, prc) : (self.send type, arg, struct)
+  end
+
+end

data/lib/kdict/kwargdict.rb

@@ -0,0 +1,75 @@
+# Creates a dictionary of generic, keyword-argument models.  Allows user to 
+# validate a keyword and value against the models added to the dictionary.
+#
+# Be sure to check out {KwargTypes} for a better understanding of what kind of
+# models can be built and added to the dictionary.
+
+class KwargDict < Hash
+
+   include KwargTypes
+
+  # @example Instantiating
+  #   my_dict = KwargDict.new
+  def initialize
+    super
+  end
+
+  # @see KwargModel
+  # Adds a new keyword-KwargModel to self.
+  # @param kword The name of the kword.
+  # @param type_struct_prc Collectively the *typedef*, *struct*, and optional *prc*.
+  # @param type AKA the *typedef*, a symbolic form of anyone of the included methods from {KwargTypes}
+  # @param struct The *typedef* format is dependent upon the model's *typedef*.  Be sure to refer to those {KwargTypes} to set *structs* appropriately.
+  # @param prc Optional.  A Proc that's meant to add to the specificity of *struct*.  Not all *typedefs* accept Procs.
+  # @return {KwargModel.new(type, struct, prc)}
+  # @example Adding a KwargModel to the KwargDict instance:
+  #   my_dict[:example] = :arrayof, Integer
+  #   my_dict[:proc_example] = :formof, [Float, Float], Proc.new { |n| n > 2.5 }
+  #   p my_dict[:example].splay #=> [:arrayof, Integer]
+  #   p my_dict[:proc_example].splay #=> [:formof, [Float, Float], <Proc:0x000055b98848a6d8@kwargdict.rb:20>] 
+  def []=(kword, type_struct_prc)
+    type, struct, prc = type_struct_prc
+    typedef?(type)
+    super(kword, KwargModel.new(type, struct, prc))
+  end
+
+  # Can add multiple KwargModels in the form of arrays. Remember that *prc* is optional.
+  # @param kwargmodel_list A collection of arrays each in the form [*kword*, *typedef*, *struct*, *prc*].
+  # @return {KwargModel.new(type, struct, prc)}
+  # @see #[]=
+  # @example Adding a KwargModel:
+  #   my_dict.add([:one, :typeof, String], [:two, :anyof, ['this', 'that']])
+  #   p my_dict[:one].splay #=> [:typeof, String]
+  #   p my_dict[:two].splay #=> [:anyof, ['this', 'that']] 
+  def add(*kwargmodel_list)
+    kwargmodel_list.each do |kword, type, struct, prc|
+      self[kword] = type, struct, prc
+    end
+  end
+
+  # Checks a kword and arg passed to it against the list of KwargModels added to
+  # self.  Returns false if the kword doesn't exist or if the arg passed in fails
+  # validation.  If the KwargModel has a Proc, the proc call will also have to 
+  # evaluate to true and does not replace or override the *struct*.
+  # @param kword The keyword whose *struct* you wish to check arg against.
+  # @param arg The argument, expression, etc., that you wish check against the  *struct*.
+  # @return [Boolean]
+  # @example Adding a KwargModel and Checking User Input Against It:
+  #   my_dict[:label] = :typeof, String
+  #   my_dict[:rgba] = :formof, [Numeric]*4, Proc.new { |n| n.ibetween(0, 1) }
+  #   my_dict.check(:label, 'Labels Are Fun!') #=> true
+  #   my_dict.check(:label, 45) #=> false
+  #   my_dict.check(:rgba, [0.5, 1, 0.25, 1]) #=> true
+  #   my_dict.check(:rgba, [0.5, 1, 0.25, 11.5]) #=> false
+  def check(kword, arg)
+    return false if !self.has_key?(kword)
+    valid?(arg, *self[kword].splay)
+  end
+
+  private def typedef?(type)
+    if !@@typedefs.include?(type)
+      raise "type must be a type in KwargTypes"
+    end
+  end
+
+end

data/lib/kdict/kwargmodel.rb

@@ -0,0 +1,40 @@
+# A convenient class for storing a unique Keyword-Argument Model
+
+class KwargModel
+
+  attr_reader :type, :struct, :prc 
+  
+  #@!attribute [r] type
+  # @return [typedef]
+  # Returns the typdef of the Model.
+
+  #@!attribute [r] struct
+  # Returns the structure of the typedef.
+
+  #@!attribute [r] prc
+  # @return [Proc]
+  # Returns a unique Proc if it exists, otherwise nil.
+  
+  # @param type [Symbol] the typedef of the instance. It can be any one of the {KwargTypes typedefs}
+  # @param struct the structure of the typedef.
+  # @param prc an optional Proc that modifies the 'specificity' of struct
+  def initialize(type, struct, prc=nil)
+    @type = type
+    @struct = struct
+    @prc = prc if prc
+  end
+
+  # Returns the attributes of the instance as an array.
+  # @return [[type, struct, prc]] if prc exists.
+  # @return [[type, struct]] if prc is nil.
+  #
+  #@example
+  #  km1 = KwargModel.new(:typeof, Float)
+  #  km2 = KwargModel.new(:typeof, Float, Proc.new{true})
+  #  km1.splay #=> [:typeof, Float]
+  #  km2.splay #=> [:typeof, Float, @prc=#<Proc:0x000055c85d7671b0@kwargmodel.rb:20>]
+  def splay
+    @prc ? [@type, @struct, @prc] : [@type, @struct]
+  end
+
+end

data/lib/kdict/version.rb

@@ -0,0 +1,5 @@
+#Version module.
+module Kdict
+  # Version number
+  VERSION = "0.1.1"
+end

data/lib/kdict.rb

@@ -0,0 +1,19 @@
+require "kdict/version"
+
+# KDict allows you to quickly create powerful Keyword-Argument Dictionaries.  Each
+# entry (a KwargModel) can be used to validate a user's input against it,
+# and is built from a generic type defintion (*typedef*) and a unique structure
+# (*struct*).
+#
+# With the included *typedefs* users can create simple to complex validaters in
+# just a single line of code.  Be sure to check out {KwargDict} and {KwargTypes}
+# for a detailed look at the underlying code and how it might be used.
+# Especially be sure to check out the {file:README.md} more than anything else!
+module KDict
+  # Inheriting SandardError.
+  class Error < StandardError; end
+  require 'kdict/kwargdict/kwargtypes/bool.rb'
+  require 'kdict/kwargdict/kwargtypes.rb'
+  require 'kdict/kwargdict.rb'
+  require 'kdict/kwargmodel.rb'
+end

data/ndoc/checksums

@@ -0,0 +1,6 @@
+lib/kdict.rb 1c241de8a71a827bcf892d1f636e7d953e89eaee
+lib/kdict/version.rb 0d5a275d2281605bbdebbe20851a80f17a145758
+lib/kdict/kwargdict.rb e3c64767b5243437a06d778c9ce336873847f8eb
+lib/kdict/kwargmodel.rb 4896ba2ba6ecf259e293a782ffb809f8d54fc747
+lib/kdict/kwargdict/kwargtypes.rb 22ed645961099b24d2e943361e2fb2a321706713
+lib/kdict/kwargdict/kwargtypes/bool.rb 94eb3a80af453e3b07e23d66afb55cc872009657

metadata

@@ -0,0 +1,150 @@
+--- !ruby/object:Gem::Specification
+name: kdict
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Steven K Terry
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2019-04-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: |-
+  KDict allows you to quickly create powerful Keyword-Argument Dictionaries.  Each
+                            entry can be used to validate a user's input against it, and is built from a
+                            generic type defintion (*typedef*) and a unique structure (*struct*).
+
+                            With the included *typedefs* users can create simple to complex validaters in
+                            just a single line of code.
+
+                            Examples avaible here in the README don't offer up the full scope of usefulness,
+                            so take the time to look at the example documentation and perhaps run a few of
+                            them yourself.
+email:
+- stkterry@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- ".yardopts"
+- CODE_OF_CONDUCT.md
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- docs/Between.html
+- docs/Bool.html
+- docs/Example1.md
+- docs/FalseClass.html
+- docs/KDict.html
+- docs/KDict/Error.html
+- docs/Kdict.html
+- docs/Kdict/Error.html
+- docs/Kdict_.html
+- docs/KwargDict.html
+- docs/KwargModel.html
+- docs/KwargTypes.html
+- docs/Numeric.html
+- docs/TrueClass.html
+- docs/_index.html
+- docs/class_list.html
+- docs/css/common.css
+- docs/css/full_list.css
+- docs/css/style.css
+- docs/file.Example1.html
+- docs/file.README.html
+- docs/file_list.html
+- docs/frames.html
+- docs/index.html
+- docs/js/app.js
+- docs/js/full_list.js
+- docs/js/jquery.js
+- docs/method_list.html
+- docs/top-level-namespace.html
+- examples/example1.rb
+- kdict.gemspec
+- lib/kdict.rb
+- lib/kdict/kwargdict.rb
+- lib/kdict/kwargdict/kwargtypes.rb
+- lib/kdict/kwargdict/kwargtypes/bool.rb
+- lib/kdict/kwargmodel.rb
+- lib/kdict/version.rb
+- ndoc/checksums
+- ndoc/complete
+- ndoc/object_types
+- ndoc/objects/root.dat
+- ndoc/proxy_types
+homepage: 
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: KDict allows you to quickly create powerful Keyword-Argument Dictionaries
+  to automate input validation.
+test_files: []