chef-attribute-validator 0.1.0 → 0.2.0

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    OGU5Y2Y2ZGFjYWIwNjBjMGVhODFiMTMxYWY0NzY1NzcyMWJlMjk0ZQ==
+    MThmOWZjYmNhMzI0ODZiODM4ZmNmMWYzOGVkYjNjZDIyMWMzZGU0OA==
   data.tar.gz: !binary |-
-    M2RmYmFjNTFlYTRjZGIyMTY4YTUwNjZmNmIwYTlhNTZkNzI3YTJlOQ==
+    ZWU3YmQzMGNkYmQ2Y2ExYTE1NWQ4MWY1MmUzNDVhMTljNjAzNDE0MA==
 SHA512:
   metadata.gz: !binary |-
-    NzM4NjBlNmY1MzdhNTBhNDAyNTc1YmVhMTdlMjExMTdkN2ZlZGNmMGIzZWJm
-    YmE0NmJkZjhhYzliOTY2ZTI3YzE1OTgyMWQ1NzA3N2NjYzYyNTdiNmRmYTZk
-    NDYwZmMzOGM5OWViNWVmYzJkNTZlMDM5MjZmZTE2MzQxYWExMTg=
+    ZDFiZjFiNmUyZDE2MTljOTI3ZWNiNDI5ZjVjN2ZmNTAyYTVhMDdiMzMwZmU1
+    MGZmODUxZDIyNjJhNjJhMmMzODYzMjMwZWFkMDIyNzg3YWU5YWZkYjQ1Mjg3
+    YzU5YTJiNjM3NDM0Y2EwM2FlYjdmMGZmNjEzMzU3M2FiYTU2OGI=
   data.tar.gz: !binary |-
-    ZWQ4NjdiM2Y3Nzk5NGU1NGZlMDdlODBhMTg5ZDAwOWJiMGE2ZTBhMjQ4MGUy
-    YzA1MGJjNzZiMDlhYzdiZTQ5MTljODRkMjNmMGFmZWE3ZDZlYWJhZjQ0NWQ5
-    YTc3ZTcyZTY0YTVkYzQ2Zjk4OWIzZjQwYmRmYjk3NWU2NjU5MDk=
+    MmVmZWQ1YzA2M2ZlOTkxMjE2ZDg5ZGE0MmI0NGRkZTcwNDQ3M2I5YWRhYTdk
+    OTY3N2E3ZjZhN2I4NTk5YTc2NjBlYjk5ZDViMWI5M2U3NDM4M2NjYjlmNTNi
+    NTdjNzJmMzI4MWM5NDNjYWQ0ZmU3MGZmYWU5NmRjY2ZlYmQ0YjU=

data/CHANGES

@@ -1,3 +1,7 @@
+2013-11-12 Clinton Wolfe 0.2.0
+   Support for wildcards - *, **, ?
+     Crude implementation using brute force and regexes
+
 2013-11-10 Clinton Wolfe 0.1.0
    Initial release
      Type, Regex, Min/Max Children, Required, and LooksLike checks

data/Gemfile

@@ -1,2 +1,4 @@
 source 'https://rubygems.org'
-gemspec
+
+gem "foodcritic"
+gem "rubocop"

data/README.md

@@ -68,13 +68,13 @@ Given:
 
 ## Bugs, Limitations and Roadmap
 
-#### Wildcard syntax not yet supported
+### How to Report Bugs
 
-I'd like to have at least this:
+Open a github issue at https://github.com/clintoncwolfe/chef-attribute-validator, ideally with a failing test case, a pull request that fixes the bug, and a unicorn.
 
-     /foo/* - Matches node['foo']['bar'], but not node['foo'] or node['foo']['bar']['baz']
-     /foo/c* - Matches node['foo']['car'], but not node['foo']['bar']
-     /foo/?ar - Matches node['foo']['bar'] and node['foo']['bar'] but not node['foo']['bleh']
+### Roadmap
+
+#### Some wildcard syntax not yet supported
 
 Possibly eventually support for **, [<charclass>], or {<alternatives>}.
 
@@ -82,18 +82,22 @@ Possibly eventually support for **, [<charclass>], or {<alternatives>}.
 
 Simple cookbook named 'attribute-validator' that loads the gem and provides recipes for compile-time and convergence-time violation checking.
 
-### Lame Exceptions
-
-No real exception class, just raising a bare string exception, which could certainly be improved upon.
-
-### Planned checks:
+#### Planned checks:
 
    looks_like/hostname
    looks_like/email
    name_regex - Regexp.  Applies given regex to the last element in the attribute path ('basename', if you will)   
    present - Boolean.  If true, fails if the path matches zero attributes.  If false, fails if the path matches nonzero attributes.  Does not consider nilness, only existence of attribute key(s).  See also required.
 
-#### Probably Slow
+### Bugs and Defects
+
+#### Lame Exceptions
+
+No real exception class, just raising a bare string exception, which could certainly be improved upon; hard to catch.
+
+#### Wildcard Expander implementation is simplistic and inefficient
+
+BrutalRegex is terrible.
 
 
 ## Author

data/Rakefile

@@ -11,13 +11,23 @@ task :test
 task :test => [:syntax]
 desc "Checks ruby files for syntax errors"
 task :syntax do |t|
+  puts "------------Syntax-----------"
   Dir.glob('**/*.rb').each do |f|
     system("/bin/echo -n '#{f}:  '; ruby -c #{f}")
   end
 end
 
-task :test => [:unit]
-desc "Runs unit tests"
+
+task :test => [:rubocop]
+desc "Runs rubocop against the code, to enforce style and standards."
+task :rubocop do |t|
+  puts "------------Rubocop-----------"
+  system("rubocop -c rubocop.yml")
+end
+
+
+#task :test => [:unit]
+#desc "Runs unit tests"
 #RSpec::Core::RakeTask.new(:unit) do |t|
 #  t.pattern = 'test/unit/**/*_spec.rb'
 #  t.rspec_opts = "-fd"

data/lib/chef-attribute-validator/attribute_set.rb

@@ -1,6 +1,8 @@
 
 require 'forwardable'
 
+require_relative './wildcard_expander'
+
 class Chef
   class Attribute
     class Validator
@@ -19,71 +21,15 @@ class Chef
           @path = a_path
           @node = a_node
 
-          embowel
-        end
-
-        private
-
-        def embowel
-          # Split on /
-          steps = path.split('/')
-
-          # Since we begin with /, the first element is ""
-          if steps[0] == "" then steps.shift end
-
-          # Promote integer strings to integers
-          steps.map! { |s| s.match(/^\d+$/) ? s.to_i : s }
-          
-          # TODO: some ckine of wildcard expansion
-          all_steps = [ steps ]
-
-          all_steps.each do |these_steps|
-            if path_exists_by_steps?(these_steps) then
-              guts['/' + these_steps.join('/')] = fetch_val_by_steps(these_steps)
-            end
-          end
-        end
-
-        def path_exists_by_steps? (the_steps)
-          nv = node
-          steps = the_steps.dup
-          while steps.size > 0 
-            step = steps.shift
-
-            # binding.pry
-            if nv.kind_of?(Chef::Node::ImmutableArray) then
-              # TODO: what if the step isn't an int?
+          expander = Chef::Attribute::Validator::WildcardExpander.choose(path, node)
 
-              if nv.size > step then
-                nv = nv[step]
-              else
-                # Array not long enough
-                return false
-              end
-
-            elsif nv.respond_to?(:has_key?) then
-              if nv.has_key?(step) then
-                nv = nv[step]
-              else
-                # No such key
-                return false
-              end
-            else
-              # Must be a scalar?
-              return false
-            end
+          # TODO: less dumb thing would be to have wildcard expander just be an enumerator
+          # and then call it on each access
+          expander.expand_all.each do | slashpath |
+            guts[slashpath] = expander.fetch_val_by_slashpath(slashpath)
           end
-          return true      
         end
 
-        def fetch_val_by_steps(the_steps)
-          nv = node
-          steps = the_steps.dup
-          while steps.size > 0 
-            nv = nv[steps.shift]
-          end
-          nv
-        end
       end
     end
   end

data/lib/chef-attribute-validator/version.rb

@@ -1,7 +1,7 @@
 class Chef
   class Attribute
     class Validator
-      VERSION = "0.1.0"
+      VERSION = "0.2.0"
     end
   end
 end

data/lib/chef-attribute-validator/wildcard_expander/brutal_regex.rb

@@ -0,0 +1,76 @@
+class Chef
+  class Attribute
+    class Validator
+      class WildcardExpander
+        class BrutalRegex < WildcardExpander
+
+          register(self)
+
+          def expand_all
+            # Create a massive list of all attribute paths, in slashpath format
+            all_slashpaths = find_all_slashpaths
+
+            # Convert the path_spec into a terrifying regex
+            regex_spec = convert_path_spec_to_regex
+
+            # Filter the list by grepping
+            all_slashpaths.grep(regex_spec)
+
+          end
+
+          def suitability
+            # I can do anything, but I'll do it badly
+            0.1
+          end
+
+
+          # TODO: maybe we could cache this on the node, or something?
+          def find_all_slashpaths (prefix='', node_cursor = nil)
+            node_cursor ||= node
+            child_paths = []
+
+            
+            if node_cursor.kind_of?(Array)
+              node_cursor.each_index do |idx|
+                child_paths.push prefix + '/' + idx.to_s
+                if node_cursor[idx].kind_of?(Mash) || node_cursor[idx].kind_of?(Array)
+                  child_paths += find_all_slashpaths(prefix + '/' + idx.to_s, node_cursor[idx])
+                end                
+              end
+            else
+              node_cursor.keys.each do |key|
+                child_paths.push prefix + '/' + key
+                if node_cursor[key].kind_of?(Mash) || node_cursor[key].kind_of?(Array)
+                  child_paths += find_all_slashpaths(prefix + '/' + key, node_cursor[key])
+                end
+              end
+            end
+            child_paths
+          end
+
+          def convert_path_spec_to_regex
+            re = path_spec.dup
+
+            # Anchor everything
+            re = '^' + re + '$'
+
+            # * => "anything but a slash"
+            re.gsub!(/([^*])\*(?!\*)/, '\1[^\/]*')
+            
+            # ? => "any single char other than a slash"
+            re.gsub!(/\?/, '[^\/]')
+
+            # ** => "anything"
+            re.gsub!(/\*\*/, '.*')
+
+            # {,} =>  alternatives # TODO
+
+            Regexp.new(re)
+
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/chef-attribute-validator/wildcard_expander/no_wildcards.rb

@@ -0,0 +1,29 @@
+class Chef
+  class Attribute
+    class Validator
+      class WildcardExpander
+        class NoWildcards < WildcardExpander
+
+          register(self)
+
+          def expand_all
+            if path_exists_by_slashpath?(path_spec)
+              [ path_spec ]
+            else
+              [ ]
+            end
+          end
+
+          def suitability
+            if path_contains_wildcards?(path_spec)
+              0.0
+            else
+              1.0
+            end
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/chef-attribute-validator/wildcard_expander.rb

@@ -0,0 +1,103 @@
+class Chef
+  class Attribute
+    class Validator
+      class WildcardExpander
+
+
+        attr_accessor :path_spec
+        attr_accessor :node
+
+        def initialize(a_path_spec, a_node)
+          @path_spec = a_path_spec
+          @node = a_node
+        end
+
+        def self.choose(path_spec, node)
+          # Ruby is an excellent language in which to write Perl
+          @@subclasses.map {|k| k.new(path_spec, node) }.map {|e| [e, e.suitability]}.sort { |a,b| b[1] <=> a[1] }.map {|e| e[0]}.first
+        end
+
+        def slashpath_to_steps(slashpath)
+          steps = slashpath.split('/')
+
+          # Since we begin with /, the first element is ""
+          if steps[0] == "" then steps.shift end
+
+          # Promote integer strings to integers
+          steps.map! { |s| s.match(/^\d+$/) ? s.to_i : s }
+
+          steps
+        end
+
+
+        # Note: does not handle missing values correctly!
+        def fetch_val_by_slashpath(slashpath)
+          nv = node
+          steps = slashpath_to_steps(slashpath)
+          while steps.size > 0 
+            nv = nv[steps.shift]
+          end
+          nv
+        end
+
+        def path_exists_by_slashpath? (slashpath)
+          nv = node
+          steps = slashpath_to_steps(slashpath)
+          while steps.size > 0 
+            step = steps.shift
+            
+            if nv.kind_of?(Chef::Node::ImmutableArray) then
+              # TODO: what if the step isn't an int?
+              
+              if nv.size > step then
+                nv = nv[step]
+              else
+                # Array not long enough
+                return false
+              end
+              
+            elsif nv.respond_to?(:has_key?) then
+              if nv.has_key?(step) then
+                nv = nv[step]
+              else
+                # No such key
+                return false
+              end
+            else
+              # Must be a scalar?
+              return false
+            end
+          end
+          return true      
+        end
+
+
+        def path_contains_wildcards?(path)
+          [
+           /\*/,
+           /\*\*/,
+           /\?/,
+           /\[\w+\]/,
+           /\{\w+(\s*,\s*\w+)?\}/, 
+          ].any? { |r| r.match(path) }
+        end
+
+        protected
+
+        def suitability
+          0.0
+        end
+
+        def self.register(klass)
+          @@subclasses ||= []
+          @@subclasses.push klass
+        end
+
+      end
+    end
+  end
+end
+
+Dir.glob(File.join(File.dirname(__FILE__), 'wildcard_expander', '*.rb')).each do |expander_implementation|
+  require expander_implementation
+end

data/test/fixtures/expander_brutal_deep_hash.rb

@@ -0,0 +1,5 @@
+default['childless'] = '1'
+default['parent']['child'] = '2'
+default['grandpappy']['parent']['child'] = '3'
+default['empty_hash'] = {}
+override['parent']['child'] = '4'

data/test/fixtures/expander_brutal_deep_mixed.rb

@@ -0,0 +1,5 @@
+default['childless'] = '1'
+default['parent'] = [ 'a', 'b' ]
+default['empty_array'] = [ ]
+default['aoh'] = [ { 'foo' => 'bar', 'yep' => 'nope' }, { 'baz' => 'whoomph' }  ]
+

data/test/fixtures/expander_brutal_flat.rb

@@ -0,0 +1,4 @@
+default['foo'] = '1'
+default['bar'] = '2'
+default['baz'] = '3'
+override['foo'] = '4'

data/test/unit/attr_set_spec.rb

@@ -52,4 +52,62 @@ describe Chef::Attribute::Validator::AttributeSet do
     end
   end
 
+  describe "basic star wildcard" do
+
+    context "when we are looking at the root element" do
+      it "should be able to run '/*'" do
+        expect { Chef::Attribute::Validator::AttributeSet.new(node, '/*') }.not_to raise_error
+      end
+      let(:ats) {  Chef::Attribute::Validator::AttributeSet.new(node, '/*') }
+      it "should be able to list all root elements" do
+        expect(ats.size).to eq 6
+      end
+    end
+
+    context "when we use a star at the beginning of a two-step path" do
+      it "should be able to run '/*/one'" do
+        expect { Chef::Attribute::Validator::AttributeSet.new(node, '/*/one') }.not_to raise_error
+      end
+      let(:ats) {  Chef::Attribute::Validator::AttributeSet.new(node, '/*/one') }
+      it "should be able to list all '/*/one'" do
+        expect(ats.size).to eq 1
+        expect(ats['/deeper/one']).to eq 1
+      end
+    end
+
+    context "when we use a star at the end of a two-step path" do
+      it "should be able to run '/deeper/*'" do
+        expect { Chef::Attribute::Validator::AttributeSet.new(node, '/deeper/*') }.not_to raise_error
+      end
+      let(:ats) {  Chef::Attribute::Validator::AttributeSet.new(node, '/deeper/*') }
+      it "should be able to list '/deeper/*'" do
+        expect(ats.size).to eq 2
+        expect(ats['/deeper/one']).to eq 1
+        expect(ats['/deeper/deeper_yet']).to be_a_kind_of(Mash)
+      end
+    end
+
+    context "when we use a star at the middle of a three-step path" do
+      it "should be able to run '/deeper/*/one'" do
+        expect { Chef::Attribute::Validator::AttributeSet.new(node, '/deeper/*/one') }.not_to raise_error
+      end
+      let(:ats) {  Chef::Attribute::Validator::AttributeSet.new(node, '/deeper/*/one') }
+      it "should be able to list '/deeper/*/one" do
+        expect(ats.size).to eq 1
+        expect(ats['/deeper/deeper_yet/one']).to eq 1
+      end
+    end
+      
+    context "when the wildcarded step does not exist" do
+      it "should be able to run '/nope/*'" do
+        expect { Chef::Attribute::Validator::AttributeSet.new(node, '/nope/*') }.not_to raise_error
+      end
+      let(:ats) {  Chef::Attribute::Validator::AttributeSet.new(node, '/nope/*') }
+      it "should not be able to find '/nope/*'" do
+        expect(ats.size).to eq 0
+      end
+
+    end
+  end
+
 end

data/test/unit/attr_set_spec_wildcard.rb

@@ -0,0 +1,114 @@
+require_relative './spec_helper'
+
+describe Chef::Attribute::Validator::AttributeSet do
+
+  let(:node) { CAVHelper.load_fixture_attributes('attr_set') }
+
+  describe "non-wildcard, non-array slashpath access" do
+    context "when the element exists" do
+      it "should be able to run /one" do
+        expect { Chef::Attribute::Validator::AttributeSet.new(node, '/one') }.not_to raise_error
+      end
+      let(:ats) { Chef::Attribute::Validator::AttributeSet.new(node, '/one') }
+      it "should be able to find /one" do
+        expect(ats.size).to eq 1
+        expect(ats.has_key?('/one')).to be_true
+        expect(ats['/one']).to eq 1
+      end
+    end
+
+    context "when the element does not exist" do
+      it "should be able to run /nope" do
+        expect { Chef::Attribute::Validator::AttributeSet.new(node, '/nope') }.not_to raise_error
+      end
+      let(:ats) { Chef::Attribute::Validator::AttributeSet.new(node, '/nope') }
+      it "should not be able to find /nope" do
+        expect(ats.size).to eq 0
+      end        
+    end
+  end
+
+  describe "non-wildcard, array slashpath access" do
+    context "when the element exists" do
+      it "should be able to run /cats/1" do
+        expect { Chef::Attribute::Validator::AttributeSet.new(node, '/cats/1') }.not_to raise_error
+      end
+      let(:ats) { Chef::Attribute::Validator::AttributeSet.new(node, '/cats/1') }
+      it "should be able to find /cats/1" do
+        expect(ats.size).to eq 1
+        expect(ats.has_key?('/cats/1')).to be_true
+        expect(ats['/cats/1']).to eq 'tabby'
+      end
+    end
+
+    context "when the element does not exist" do
+      it "should be able to run /cats/23" do
+        expect { Chef::Attribute::Validator::AttributeSet.new(node, '/cats/23') }.not_to raise_error
+      end
+      let(:ats) { Chef::Attribute::Validator::AttributeSet.new(node, '/cats/23') }
+      it "should not be able to find /cats/23" do
+        expect(ats.size).to eq 0
+      end        
+    end
+  end
+
+  describe "basic star wildcard" do
+
+    context "when we are looking at the root element" do
+      it "should be able to run '/*'" do
+        expect { Chef::Attribute::Validator::AttributeSet.new(node, '/*') }.not_to raise_error
+      end
+      let(:ats) {  Chef::Attribute::Validator::AttributeSet.new(node, '/*') }
+      it "should be able to list all root elements" do
+        expect(ats.size).to eq 7
+      end
+    end
+
+    context "when we use a star at the beginning of a two-step path" do
+      it "should be able to run '/*/one'" do
+        expect { Chef::Attribute::Validator::AttributeSet.new(node, '/*/one') }.not_to raise_error
+      end
+      let(:ats) {  Chef::Attribute::Validator::AttributeSet.new(node, '/*/one') }
+      it "should be able to list all '/*/one'" do
+        expect(ats.size).to eq 1
+        expect(ats['/deeper/one']).to eq 1
+      end
+    end
+
+    context "when we use a star at the end of a two-step path" do
+      it "should be able to run '/deeper/*'" do
+        expect { Chef::Attribute::Validator::AttributeSet.new(node, '/deeper/*') }.not_to raise_error
+      end
+      let(:ats) {  Chef::Attribute::Validator::AttributeSet.new(node, '/deeper/*') }
+      it "should be able to list '/deeper/*'" do
+        expect(ats.size).to eq 2
+        expect(ats['/deeper/one']).to eq 1
+        expect(ats['/deeper/deeper_yet']).to be_a_kind_of(Mash)
+      end
+    end
+
+    context "when we use a star at the middle of a three-step path" do
+      it "should be able to run '/deeper/*/one'" do
+        expect { Chef::Attribute::Validator::AttributeSet.new(node, '/deeper/*/one') }.not_to raise_error
+      end
+      let(:ats) {  Chef::Attribute::Validator::AttributeSet.new(node, '/deeper/*/one') }
+      it "should be able to list '/deeper/*/one" do
+        expect(ats.size).to eq 1
+        expect(ats['/deeper/deeper_yet/one']).to eq 1
+      end
+    end
+      
+    context "when the wildcarded step does not exist" do
+      it "should be able to run '/nope/*'" do
+        expect { Chef::Attribute::Validator::AttributeSet.new(node, '/nope/*') }.not_to raise_error
+      end
+      let(:ats) {  Chef::Attribute::Validator::AttributeSet.new(node, '/nope/*') }
+      it "should not be able to find '/nope/*'" do
+        expect(ats.size).to eq 0
+      end
+
+    end
+
+  end
+
+end

data/test/unit/expanders/brutal_regex_spec.rb

@@ -0,0 +1,132 @@
+require_relative '../spec_helper'
+
+describe Chef::Attribute::Validator::WildcardExpander::BrutalRegex do
+
+  context "prior to applying filter" do
+
+    context "when examining a shallow node" do
+      let(:node) { CAVHelper.load_fixture_attributes('expander_brutal_flat') }
+      let(:exp) { Chef::Attribute::Validator::WildcardExpander::BrutalRegex.new('/foo', node) }
+      let(:result) { exp.find_all_slashpaths }
+      
+      it "should prefix all entries with /" do
+        expect(result.all? { |sp| sp.match(/^\//) }).to be_true
+      end
+    
+      it "should find the right number of entries" do
+        expect(result.size).to eql 3
+      end
+
+      it "should find the /foo entry" do
+        expect(result).to include('/foo')
+      end
+
+    end
+
+    context "when examining a deeper node with no arrays" do
+      let(:node) { CAVHelper.load_fixture_attributes('expander_brutal_deep_hash') }
+      let(:exp) { Chef::Attribute::Validator::WildcardExpander::BrutalRegex.new('/foo', node) }
+      let(:result) { exp.find_all_slashpaths }
+
+   
+      it "should prefix all entries with /" do
+        expect(result.all? { |sp| sp.match(/^\//) }).to be_true
+      end
+
+      it "should find the right number of entries" do
+        expect(result.size).to eql 7
+      end
+
+      it "should find the /childless entry" do
+        expect(result).to include('/childless')
+      end
+      it "should find the /parent entry" do
+        expect(result).to include('/parent')
+      end
+      it "should find the /parent/child entry" do
+        expect(result).to include('/parent/child')
+      end
+      it "should find the /grandpappy entry" do
+        expect(result).to include('/grandpappy')
+      end
+      it "should find the /grandpappy/parent entry" do
+        expect(result).to include('/grandpappy/parent')
+      end
+      it "should find the /grandpappy/parent/child entry" do
+        expect(result).to include('/grandpappy/parent/child')
+      end
+      it "should find the /empty_hash entry" do
+        expect(result).to include('/empty_hash')
+      end
+
+      
+    end
+    
+    context "when examining a deeper node with mixed arrays" do
+      let(:node) { CAVHelper.load_fixture_attributes('expander_brutal_deep_mixed') }
+      let(:exp) { Chef::Attribute::Validator::WildcardExpander::BrutalRegex.new('/foo', node) }
+      let(:result) { exp.find_all_slashpaths }
+      
+   
+      it "should prefix all entries with /" do
+        expect(result.all? { |sp| sp.match(/^\//) }).to be_true
+      end
+
+      it "should find the right number of entries" do
+        expect(result.size).to eql 11
+      end
+
+      it "should find the /childless entry" do
+        expect(result).to include('/childless')
+      end
+      it "should find the /parent entry" do
+        expect(result).to include('/parent')
+      end
+      it "should find the /parent/0 entry" do
+        expect(result).to include('/parent/0')
+      end
+      it "should find the /parent/1 entry" do
+        expect(result).to include('/parent/1')
+      end
+      it "should find the /empty_array entry" do
+        expect(result).to include('/empty_array')
+      end
+
+      it "should find the /aoh entry" do
+        expect(result).to include('/aoh')
+      end
+
+      it "should find the /aoh/0 entry" do
+        expect(result).to include('/aoh/0')
+      end
+
+      it "should find the /aoh/0/foo entry" do
+        expect(result).to include('/aoh/0/foo')
+      end
+      
+    end
+  end
+
+  context "while converting a pathspec to a regex" do
+    let(:node) { CAVHelper.load_fixture_attributes('expander_brutal_flat') }
+
+    {
+      '/foo' => '^/foo$',
+      '/foo*' => '^/foo[^\/]*$',
+      '/foo*/*/bar' => '^/foo[^\/]*/[^\/]*/bar$',
+      '/?oo' => '^/[^\/]oo$',
+      '/**'  => '^/.*$',
+      '/foo/**/bar' => '^/foo/.*/bar$',
+    }.each do | spec, regex |
+      it "should convert '#{spec}' to '#{regex}'" do
+        exp = Chef::Attribute::Validator::WildcardExpander::BrutalRegex.new(spec, node)
+        expect(exp.convert_path_spec_to_regex).to eql Regexp.new(regex)
+      end
+    end
+    
+
+
+  end
+
+
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: chef-attribute-validator
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Clinton Wolfe
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-11-11 00:00:00.000000000 Z
+date: 2013-11-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -16,14 +16,16 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '1.3'
+        version: !binary |-
+          MS4z
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '1.3'
+        version: !binary |-
+          MS4z
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -81,6 +83,9 @@ files:
 - lib/chef-attribute-validator/rule.rb
 - lib/chef-attribute-validator/version.rb
 - lib/chef-attribute-validator/violation.rb
+- lib/chef-attribute-validator/wildcard_expander.rb
+- lib/chef-attribute-validator/wildcard_expander/brutal_regex.rb
+- lib/chef-attribute-validator/wildcard_expander/no_wildcards.rb
 - test/fixtures/attr_set.rb
 - test/fixtures/check_child_count.rb
 - test/fixtures/check_looks_like_arg_ip.rb
@@ -99,17 +104,22 @@ files:
 - test/fixtures/check_required_true.rb
 - test/fixtures/check_required_zero.rb
 - test/fixtures/check_type.rb
+- test/fixtures/expander_brutal_deep_hash.rb
+- test/fixtures/expander_brutal_deep_mixed.rb
+- test/fixtures/expander_brutal_flat.rb
 - test/fixtures/rules_empty.rb
 - test/fixtures/rules_missing_path.rb
 - test/fixtures/rules_no_check.rb
 - test/fixtures/rules_type_and_min_children.rb
 - test/fixtures/rules_type_check.rb
 - test/unit/attr_set_spec.rb
+- test/unit/attr_set_spec_wildcard.rb
 - test/unit/check_child_count_spec.rb
 - test/unit/check_looks_like_spec.rb
 - test/unit/check_regex_spec.rb
 - test/unit/check_required_spec.rb
 - test/unit/check_type_spec.rb
+- test/unit/expanders/brutal_regex_spec.rb
 - test/unit/rule_parse_spec.rb
 - test/unit/spec_helper.rb
 homepage: https://github.com/clintoncwolfe/chef-attribute-validator
@@ -155,16 +165,21 @@ test_files:
 - test/fixtures/check_required_true.rb
 - test/fixtures/check_required_zero.rb
 - test/fixtures/check_type.rb
+- test/fixtures/expander_brutal_deep_hash.rb
+- test/fixtures/expander_brutal_deep_mixed.rb
+- test/fixtures/expander_brutal_flat.rb
 - test/fixtures/rules_empty.rb
 - test/fixtures/rules_missing_path.rb
 - test/fixtures/rules_no_check.rb
 - test/fixtures/rules_type_and_min_children.rb
 - test/fixtures/rules_type_check.rb
 - test/unit/attr_set_spec.rb
+- test/unit/attr_set_spec_wildcard.rb
 - test/unit/check_child_count_spec.rb
 - test/unit/check_looks_like_spec.rb
 - test/unit/check_regex_spec.rb
 - test/unit/check_required_spec.rb
 - test/unit/check_type_spec.rb
+- test/unit/expanders/brutal_regex_spec.rb
 - test/unit/rule_parse_spec.rb
 - test/unit/spec_helper.rb