chef-gyoku 1.4.1 → 1.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 961beab424895dc794bc90010c758f6b6ce1423a8b2b1248c64796a7874cc76e
-  data.tar.gz: bef27d17bcc60cb5e2c10761230bcfa459243e2c71240229816fa036c82b40d1
+  metadata.gz: cda5eed97e4ffe761f4cbda700252dc6c2b5a93d26ab885e67b1dc75ccabed03
+  data.tar.gz: fecbfabb394e73ce3c57893ea727565e368079d1a28ca5ba931ed0d2a0bdb850
 SHA512:
-  metadata.gz: 0255cddf2cc2448f6f30840ac97f54c846d7e9a8728087318d67bb149d0efaf2208bfd2e87ca0c41050a2d5abfd84b4e01872c81739c55b9e8c88867be41a45f
-  data.tar.gz: fa9bf05243f96bda7ab2564c805c817e2cdab018112773660f9214ec8151084a7f3e1f932f804b8506d8977db0f460396084833143d39fb678b7cfc6216bc91e
+  metadata.gz: 609d24522f498586d62a31972d2c0045228716d43e26732d1e77708f37b5e9cf4b8970f8b53c0e2e292ddd650dc9067296d51d73c4b33e4fd46b3b5706a5d228
+  data.tar.gz: da04226ad912b1670fcf558acc2cb661658f41a85f4d387b84f63ad3b4b469275a99934a15edf1f3bbb1cfdd07ed352d394030d979b543d6a1d7397064915e02

data/.github/dependabot.yml

@@ -0,0 +1,12 @@
+# To get started with Dependabot version updates, you'll need to specify which
+# package ecosystems to update and where the package manifests are located.
+# Please see the documentation for more information:
+# https://docs.github.com/github/administering-a-repository/configuration-options-for-dependency-updates
+# https://containers.dev/guide/dependabot
+
+version: 2
+updates:
+ - package-ecosystem: "devcontainers"
+   directory: "/"
+   schedule:
+     interval: weekly

data/.github/workflows/ci.yml

@@ -16,10 +16,8 @@ jobs:
       fail-fast: true
       matrix:
         ruby:
-          - '3.2'
+          - '3.4'
           - '3.1'
-          - '3.0'
-          - 'jruby'
 
     runs-on: ubuntu-latest
 
@@ -47,7 +45,7 @@ jobs:
       - name: Set up Ruby
         uses: ruby/setup-ruby@v1
         with:
-          ruby-version: 3.2
+          ruby-version: 3.4
           bundler-cache: true
 
       - name: Install dependencies
@@ -59,4 +57,4 @@ jobs:
       - name: Report coverage
         uses: coverallsapp/github-action@v2
         with:
-          flag-name: ruby-3.2
+          flag-name: ruby-3.4

data/.github/workflows/lint.yml

@@ -0,0 +1,27 @@
+---
+name: lint
+
+on:
+  pull_request:
+  push:
+    branches:
+      - main
+
+concurrency:
+  group: lint-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  lint:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: 3.1
+          bundler-cache: false
+      - uses: r7kamura/rubocop-problem-matchers-action@v1  # this shows the failures in the PR
+      - run: |
+          gem install cookstyle
+          cookstyle --chefstyle -c .rubocop.yml
+  

data/.rubocop.yml

@@ -0,0 +1,12 @@
+AllCops:
+  TargetRubyVersion: 2.7
+  Exclude:
+    - "spec/data/**/*"
+    - "vendor/**/*"
+    - "pkg/**/*"
+
+# these have shellout examples that need to have the tabs that come with the shellout
+Layout/IndentationStyle:
+  Exclude:
+    - "lib/ohai/plugins/mono.rb"
+    - "lib/ohai/plugins/darwin/hardware.rb"

data/Rakefile

@@ -4,8 +4,30 @@ Bundler::GemHelper.install_tasks
 
 require "rspec/core/rake_task"
 
+desc "Check Linting and code style."
+task :style do
+  require "rubocop/rake_task"
+  require "cookstyle/chefstyle"
+
+  if RbConfig::CONFIG["host_os"] =~ /mswin|mingw|windows/
+    # Windows-specific command, rubocop erroneously reports the CRLF in each file which is removed when your PR is uploaeded to GitHub.
+    # This is a workaround to ignore the CRLF from the files before running cookstyle.
+    sh "cookstyle --chefstyle -c .rubocop.yml --except Layout/EndOfLine"
+  else
+    sh "cookstyle --chefstyle -c .rubocop.yml"
+  end
+rescue LoadError
+  puts "Rubocop or Cookstyle gems are not installed. bundle install first to make sure all dependencies are installed."
+end
+
+# Run the integration test suite
+RSpec::Core::RakeTask.new(:integration) do |task|
+  task.pattern = "spec/chef-gyoku/*_spec.rb"
+  task.rspec_opts = ["--color", "-f documentation"]
+end
+
 RSpec::Core::RakeTask.new do |t|
-  t.rspec_opts = %w[-c]
+  t.rspec_opts = %w{-c}
 end
 
 task default: :spec

data/{gyoku.gemspec → chef-gyoku.gemspec}

@@ -1,5 +1,5 @@
-$:.push File.expand_path("../lib", __FILE__)
-require "gyoku/version"
+$:.push File.expand_path("lib", __dir__)
+require "chef-gyoku/version"
 
 Gem::Specification.new do |s|
   s.name = "chef-gyoku"
@@ -10,16 +10,18 @@ Gem::Specification.new do |s|
   s.homepage = "https://github.com/savonrb/#{s.name}"
   s.summary = "Translates Ruby Hashes to XML"
   s.description = "Gyoku translates Ruby Hashes to XML"
-  s.required_ruby_version = ">= 3.0"
+  s.required_ruby_version = ">= 3.1"
 
   s.license = "MIT"
 
   s.add_dependency "builder", ">= 2.1.2"
-  s.add_dependency "rexml", "~> 3.3"
+  s.add_dependency "rexml", "~> 3.4"
 
   s.add_development_dependency "rake"
   s.add_development_dependency "rspec"
   s.add_development_dependency "standard"
+  s.add_development_dependency "fiddle"
+  s.add_development_dependency "cookstyle", ">= 8.0.0"
 
   s.files = `git ls-files`.split("\n")
 

data/lib/{gyoku → chef-gyoku}/array.rb

@@ -2,7 +2,7 @@ module Gyoku
   module Array
     module_function
 
-    NESTED_ELEMENT_NAME = "element"
+    NESTED_ELEMENT_NAME = "element".freeze
 
     # Builds XML and prettifies it if +pretty_print+ option is set to +true+
     def to_xml(array, key, escape_xml = true, attributes = {}, options = {})
@@ -64,13 +64,13 @@ module Gyoku
     def iterate_array(xml, array, attributes, &block)
       array.each_with_index do |item, index|
         attrs = if item.respond_to?(:keys)
-          item.each_with_object({}) do |v, st|
-            k = v[0].to_s
-            st[k[1..]] = v[1].to_s if Hash.explicit_attribute?(k)
-          end
-        else
-          {}
-        end
+                  item.each_with_object({}) do |v, st|
+                    k = v[0].to_s
+                    st[k[1..]] = v[1].to_s if Hash.explicit_attribute?(k)
+                  end
+                else
+                  {}
+                end
         yield xml, item, tag_attributes(attributes, index).merge(attrs), index
       end
     end

data/lib/{gyoku → chef-gyoku}/hash.rb

@@ -1,8 +1,8 @@
 require "builder"
-require "gyoku/prettifier"
-require "gyoku/array"
-require "gyoku/xml_key"
-require "gyoku/xml_value"
+require "chef-gyoku/prettifier"
+require "chef-gyoku/array"
+require "chef-gyoku/xml_key"
+require "chef-gyoku/xml_value"
 
 module Gyoku
   module Hash

data/lib/{gyoku → chef-gyoku}/prettifier.rb

@@ -1,4 +1,4 @@
-require "rexml/document"
+require "rexml/document" unless defined?(REXML::Document)
 
 module Gyoku
   class Prettifier

data/lib/chef-gyoku/version.rb

@@ -0,0 +1,3 @@
+module Gyoku
+  VERSION = "1.5.0".freeze
+end

data/lib/{gyoku → chef-gyoku}/xml_key.rb

@@ -1,22 +1,22 @@
 module Gyoku
   module XMLKey
     class << self
-      CAMELCASE = lambda { |key| key.gsub(/\/(.?)/) { |m| "::#{m[-1].upcase}" }.gsub(/(?:^|_)(.)/) { |m| m[-1].upcase } }
+      CAMELCASE = lambda { |key| key.gsub(%r{/(.?)}) { |m| "::#{m[-1].upcase}" }.gsub(/(?:^|_)(.)/) { |m| m[-1].upcase } }
       LOWER_CAMELCASE = lambda { |key| key[0].chr.downcase + CAMELCASE.call(key)[1..] }
-      UPCASE = lambda { |key| key.upcase }
+      UPCASE = lambda(&:upcase)
 
       FORMULAS = {
         lower_camelcase: lambda { |key| LOWER_CAMELCASE.call(key) },
         camelcase: lambda { |key| CAMELCASE.call(key) },
         upcase: lambda { |key| UPCASE.call(key) },
-        none: lambda { |key| key }
-      }
+        none: lambda { |key| key },
+      }.freeze
 
       # Converts a given +object+ with +options+ to an XML key.
       def create(key, options = {})
         xml_key = chop_special_characters key.to_s
 
-        if unqualified = unqualify?(xml_key)
+        if (unqualified = unqualify?(xml_key))
           xml_key = xml_key.split(":").last
         end
 
@@ -37,14 +37,14 @@ module Gyoku
 
         defined_key = options[:key_to_convert]
         key_converter = if !defined_key.nil? && (defined_key == xml_key)
-          options[:key_converter]
-        elsif !defined_key.nil?
-          :lower_camelcase
-        elsif options[:except] == xml_key
-          :lower_camelcase
-        else
-          options[:key_converter] || :lower_camelcase
-        end
+                          options[:key_converter]
+                        elsif !defined_key.nil?
+                          :lower_camelcase
+                        elsif options[:except] == xml_key
+                          :lower_camelcase
+                        else
+                          options[:key_converter] || :lower_camelcase
+                        end
         FORMULAS[key_converter]
       end
 

data/lib/{gyoku → chef-gyoku}/xml_value.rb

@@ -1,17 +1,17 @@
-require "cgi"
+require "cgi" unless defined?(CGI)
 require "date"
 
 module Gyoku
   module XMLValue
     class << self
       # xs:date format
-      XS_DATE_FORMAT = "%Y-%m-%d"
+      XS_DATE_FORMAT = "%Y-%m-%d".freeze
 
       # xs:time format
-      XS_TIME_FORMAT = "%H:%M:%S"
+      XS_TIME_FORMAT = "%H:%M:%S".freeze
 
       # xs:dateTime format
-      XS_DATETIME_FORMAT = "%Y-%m-%dT%H:%M:%S%Z"
+      XS_DATETIME_FORMAT = "%Y-%m-%dT%H:%M:%S%Z".freeze
 
       # Converts a given +object+ to an XML value.
       def create(object, escape_xml = true, options = {})

data/lib/{gyoku.rb → chef-gyoku.rb}

@@ -1,5 +1,5 @@
-require "gyoku/version"
-require "gyoku/hash"
+require "chef-gyoku/version"
+require "chef-gyoku/hash"
 
 module Gyoku
   # Converts a given Hash +key+ with +options+ into an XML tag.

data/spec/{gyoku → chef-gyoku}/array_spec.rb

@@ -3,14 +3,14 @@ require "spec_helper"
 describe Gyoku::Array do
   describe ".to_xml" do
     it "returns the XML for an Array of Hashes" do
-      array = [{name: "adam"}, {name: "eve"}]
+      array = [{ name: "adam" }, { name: "eve" }]
       result = "<user><name>adam</name></user><user><name>eve</name></user>"
 
       expect(to_xml(array, "user")).to eq(result)
     end
 
     it "returns the XML for an Array of Hashes unwrapped" do
-      array = [{name: "adam"}, {name: "eve"}]
+      array = [{ name: "adam" }, { name: "eve" }]
       result = "<user><name>adam</name><name>eve</name></user>"
 
       expect(to_xml(array, "user", true, {}, unwrap: true)).to eq(result)
@@ -38,39 +38,39 @@ describe Gyoku::Array do
     end
 
     it "adds attributes to a given tag" do
-      array = ["adam", "eve"]
+      array = %w{adam eve}
       result = '<value active="true">adam</value><value active="true">eve</value>'
 
       expect(to_xml(array, "value", :escape_xml, active: true)).to eq(result)
     end
 
     it "adds attributes to tags when :unwrap is true" do
-      array = [{item: "abc"}]
+      array = [{ item: "abc" }]
       key = "items"
       escape_xml = :escape_xml
-      attributes = {"amount" => "1"}
-      options = {unwrap: true}
+      attributes = { "amount" => "1" }
+      options = { unwrap: true }
       result = "<items amount=\"1\"><item>abc</item></items>"
 
       expect(to_xml(array, key, escape_xml, attributes, options)).to eq result
     end
 
     it "adds attributes to duplicate tags" do
-      array = ["adam", "eve"]
+      array = %w{adam eve}
       result = '<value id="1">adam</value><value id="2">eve</value>'
 
       expect(to_xml(array, "value", :escape_xml, id: [1, 2])).to eq(result)
     end
 
     it "skips attribute for element without attributes if there are fewer attributes than elements" do
-      array = ["adam", "eve", "serpent"]
+      array = %w{adam eve serpent}
       result = '<value id="1">adam</value><value id="2">eve</value><value>serpent</value>'
 
       expect(to_xml(array, "value", :escape_xml, id: [1, 2])).to eq(result)
     end
 
     it "handles nested Arrays" do
-      array = [["one", "two"]]
+      array = [%w{one two}]
       result = "<value><element>one</element><element>two</element></value>"
 
       expect(to_xml(array, "value")).to eq(result)
@@ -79,16 +79,16 @@ describe Gyoku::Array do
     context "when :pretty_print option is set to true" do
       context "when :unwrap option is set to true" do
         it "returns prettified xml" do
-          array = ["one", "two", {"three" => "four"}]
-          options = {pretty_print: true, unwrap: true}
+          array = ["one", "two", { "three" => "four" }]
+          options = { pretty_print: true, unwrap: true }
           result = "<test>\n  <test>one</test>\n  <test>two</test>\n  <three>four</three>\n</test>"
           expect(to_xml(array, "test", true, {}, options)).to eq(result)
         end
 
         context "when :indent option is specified" do
           it "returns prettified xml with specified indent" do
-            array = ["one", "two", {"three" => "four"}]
-            options = {pretty_print: true, indent: 3, unwrap: true}
+            array = ["one", "two", { "three" => "four" }]
+            options = { pretty_print: true, indent: 3, unwrap: true }
             result = "<test>\n   <test>one</test>\n   <test>two</test>\n   <three>four</three>\n</test>"
             expect(to_xml(array, "test", true, {}, options)).to eq(result)
           end
@@ -96,8 +96,8 @@ describe Gyoku::Array do
 
         context "when :compact option is specified" do
           it "returns prettified xml with specified compact mode" do
-            array = ["one", {"two" => "three"}]
-            options = {pretty_print: true, compact: false, unwrap: true}
+            array = ["one", { "two" => "three" }]
+            options = { pretty_print: true, compact: false, unwrap: true }
             result = "<test>\n  <test>\n    one\n  </test>\n  <two>\n     three \n  </two>\n</test>"
             expect(to_xml(array, "test", true, {}, options)).to eq(result)
           end
@@ -106,8 +106,8 @@ describe Gyoku::Array do
 
       context "when :unwrap option is not set" do
         it "returns non-prettified xml" do
-          array = ["one", "two", {"three" => "four"}]
-          options = {pretty_print: true}
+          array = ["one", "two", { "three" => "four" }]
+          options = { pretty_print: true }
           result = "<test>one</test><test>two</test><test><three>four</three></test>"
           expect(to_xml(array, "test", true, {}, options)).to eq(result)
         end

data/spec/{gyoku → chef-gyoku}/hash_spec.rb

@@ -8,29 +8,29 @@ describe Gyoku::Hash do
       end
 
       it "for a nested Hash" do
-        expect(to_xml(some: {new: "user"})).to eq("<some><new>user</new></some>")
+        expect(to_xml(some: { new: "user" })).to eq("<some><new>user</new></some>")
       end
 
       context "with key_converter" do
         it "expect all keys change" do
-          expect(to_xml({some: {new: "user"}}, {key_converter: :camelcase})).to eq("<Some><New>user</New></Some>")
+          expect(to_xml({ some: { new: "user" } }, { key_converter: :camelcase })).to eq("<Some><New>user</New></Some>")
         end
 
         it "and key_to_convert option should change only key" do
-          hash = {some: {new: "user", age: 20}}
-          options = {key_converter: :camelcase, key_to_convert: "some"}
+          hash = { some: { new: "user", age: 20 } }
+          options = { key_converter: :camelcase, key_to_convert: "some" }
           result = "<Some><new>user</new><age>20</age></Some>"
           expect(to_xml(hash, options)).to eq(result)
 
-          hash = {some: {new: "user", age: 20}}
-          options = {key_converter: :camelcase, key_to_convert: "new"}
+          hash = { some: { new: "user", age: 20 } }
+          options = { key_converter: :camelcase, key_to_convert: "new" }
           result = "<some><New>user</New><age>20</age></some>"
           expect(to_xml(hash, options)).to eq(result)
         end
 
         it "with except option, dont convert this key" do
-          hash = {some: {new: "user", age: 20}}
-          options = {key_converter: :camelcase, except: "some"}
+          hash = { some: { new: "user", age: 20 } }
+          options = { key_converter: :camelcase, except: "some" }
           result = "<some><New>user</New><Age>20</Age></some>"
           expect(to_xml(hash, options)).to eq(result)
         end
@@ -44,26 +44,26 @@ describe Gyoku::Hash do
       end
 
       it "for a Hash containing an Array" do
-        expect(to_xml(some: ["user", "gorilla"])).to eq("<some>user</some><some>gorilla</some>")
+        expect(to_xml(some: %w{user gorilla})).to eq("<some>user</some><some>gorilla</some>")
       end
 
       it "for a Hash containing an Array of Hashes" do
-        expect(to_xml(some: [{new: "user"}, {old: "gorilla"}]))
+        expect(to_xml(some: [{ new: "user" }, { old: "gorilla" }]))
           .to eq("<some><new>user</new></some><some><old>gorilla</old></some>")
       end
 
       context "when :pretty_print option is set to true" do
         it "returns prettified xml" do
-          hash = {some: {user: {name: "John", groups: ["admin", "editor"]}}}
-          options = {pretty_print: true}
+          hash = { some: { user: { name: "John", groups: %w{admin editor} } } }
+          options = { pretty_print: true }
           result = "<some>\n  <user>\n    <name>John</name>\n    <groups>admin</groups>\n    <groups>editor</groups>\n  </user>\n</some>"
           expect(to_xml(hash, options)).to eq(result)
         end
 
         context "when :indent option is specified" do
           it "returns prettified xml with specified indent" do
-            hash = {some: {user: {name: "John"}}}
-            options = {pretty_print: true, indent: 4}
+            hash = { some: { user: { name: "John" } } }
+            options = { pretty_print: true, indent: 4 }
             result = "<some>\n    <user>\n        <name>John</name>\n    </user>\n</some>"
             expect(to_xml(hash, options)).to eq(result)
           end
@@ -71,8 +71,8 @@ describe Gyoku::Hash do
 
         context "when :compact option is specified" do
           it "returns prettified xml with specified compact mode" do
-            hash = {some: {user: {name: "John"}}}
-            options = {pretty_print: true, compact: false}
+            hash = { some: { user: { name: "John" } } }
+            options = { pretty_print: true, compact: false }
             result = "<some>\n  <user>\n    <name>\n      John\n    </name>\n  </user>\n</some>"
             expect(to_xml(hash, options)).to eq(result)
           end
@@ -126,74 +126,74 @@ describe Gyoku::Hash do
     end
 
     it "defaults to escape special characters" do
-      result = to_xml(some: {nested: "<tag />"}, tag: "<tag />")
+      result = to_xml(some: { nested: "<tag />" }, tag: "<tag />")
       expect(result).to include("<tag>&lt;tag /&gt;</tag>")
       expect(result).to include("<some><nested>&lt;tag /&gt;</nested></some>")
     end
 
     it "does not escape special characters for keys marked with an exclamation mark" do
-      result = to_xml(some: {nested!: "<tag />"}, tag!: "<tag />")
+      result = to_xml(some: { nested!: "<tag />" }, tag!: "<tag />")
       expect(result).to include("<tag><tag /></tag>")
       expect(result).to include("<some><nested><tag /></nested></some>")
     end
 
     it "preserves the order of Hash keys and values specified through :order!" do
-      hash = {find_user: {name: "Lucy", id: 666, order!: [:id, :name]}}
+      hash = { find_user: { name: "Lucy", id: 666, order!: %i{id name} } }
       result = "<findUser><id>666</id><name>Lucy</name></findUser>"
       expect(to_xml(hash)).to eq(result)
 
-      hash = {find_user: {mname: "in the", lname: "Sky", fname: "Lucy", order!: [:fname, :mname, :lname]}}
+      hash = { find_user: { mname: "in the", lname: "Sky", fname: "Lucy", order!: %i{fname mname lname} } }
       result = "<findUser><fname>Lucy</fname><mname>in the</mname><lname>Sky</lname></findUser>"
       expect(to_xml(hash)).to eq(result)
     end
 
     it "preserves the order of Hash keys and values specified through 'order!' (as a string key)" do
-      hash = {find_user: {:name => "Lucy", :id => 666, "order!" => [:id, :name]}}
+      hash = { find_user: { :name => "Lucy", :id => 666, "order!" => %i{id name} } }
       result = "<findUser><id>666</id><name>Lucy</name></findUser>"
       expect(to_xml(hash)).to eq(result)
 
-      hash = {find_user: {:mname => "in the", :lname => "Sky", :fname => "Lucy", "order!" => [:fname, :mname, :lname]}}
+      hash = { find_user: { :mname => "in the", :lname => "Sky", :fname => "Lucy", "order!" => %i{fname mname lname} } }
       result = "<findUser><fname>Lucy</fname><mname>in the</mname><lname>Sky</lname></findUser>"
       expect(to_xml(hash)).to eq(result)
     end
 
     it "uses :order! symbol values for ordering but leaves the string key 'order!' if both are present" do
-      hash = {find_user: {:name => "Lucy", :id => 666, "order!" => "value", :order! => [:id, :name, "order!"]}}
+      hash = { find_user: { :name => "Lucy", :id => 666, "order!" => "value", :order! => [:id, :name, "order!"] } }
       result = "<findUser><id>666</id><name>Lucy</name><order>value</order></findUser>"
       expect(to_xml(hash)).to eq(result)
     end
 
     it "raises if the :order! Array is missing Hash keys" do
-      hash = {name: "Lucy", id: 666, order!: [:name]}
+      hash = { name: "Lucy", id: 666, order!: [:name] }
       expect { to_xml(hash) }.to raise_error(ArgumentError, "Missing elements in :order! [:id]")
     end
 
     it "raises if the :order! Array contains missing Hash keys" do
-      hash = {by_name: {first_name: "Lucy", last_name: "Sky", order!: [:first_name, :middle_name, :last_name]}}
+      hash = { by_name: { first_name: "Lucy", last_name: "Sky", order!: %i{first_name middle_name last_name} } }
       expect { to_xml(hash) }.to raise_error(ArgumentError, "Spurious elements in :order! [:middle_name]")
     end
 
     it "adds attributes to Hash keys specified through :attributes!" do
-      hash = {find_user: {person: "Lucy", attributes!: {person: {id: 666}}}}
+      hash = { find_user: { person: "Lucy", attributes!: { person: { id: 666 } } } }
       result = '<findUser><person id="666">Lucy</person></findUser>'
       expect(to_xml(hash)).to eq(result)
 
-      hash = {find_user: {person: "Lucy", attributes!: {person: {id: 666, city: "Hamburg"}}}}
+      hash = { find_user: { person: "Lucy", attributes!: { person: { id: 666, city: "Hamburg" } } } }
       expect(to_xml(hash)).to include('id="666"', 'city="Hamburg"')
     end
 
     it "adds attributes to duplicate Hash keys specified through :attributes!" do
-      hash = {find_user: {person: ["Lucy", "Anna"], attributes!: {person: {id: [1, 3]}}}}
+      hash = { find_user: { person: %w{Lucy Anna}, attributes!: { person: { id: [1, 3] } } } }
       result = '<findUser><person id="1">Lucy</person><person id="3">Anna</person></findUser>'
       expect(to_xml(hash)).to eq(result)
 
-      hash = {find_user: {person: ["Lucy", "Anna"], attributes!: {person: {active: "true"}}}}
+      hash = { find_user: { person: %w{Lucy Anna}, attributes!: { person: { active: "true" } } } }
       result = '<findUser><person active="true">Lucy</person><person active="true">Anna</person></findUser>'
       expect(to_xml(hash)).to eq(result)
     end
 
     it "skips attribute for element without attributes if there are fewer attributes than elements" do
-      hash = {find_user: {person: ["Lucy", "Anna", "Beth"], attributes!: {person: {id: [1, 3]}}}}
+      hash = { find_user: { person: %w{Lucy Anna Beth}, attributes!: { person: { id: [1, 3] } } } }
       result = '<findUser><person id="1">Lucy</person><person id="3">Anna</person><person>Beth</person></findUser>'
       expect(to_xml(hash)).to eq(result)
     end
@@ -201,7 +201,7 @@ describe Gyoku::Hash do
     it "adds attributes to self-closing tags" do
       hash = {
         "category/" => "",
-        :attributes! => {"category/" => {id: 1}}
+        :attributes! => { "category/" => { id: 1 } },
       }
 
       expect(to_xml(hash)).to eq('<category id="1"/>')
@@ -211,8 +211,8 @@ describe Gyoku::Hash do
       hash = {
         "category" => {
           :content! => "users",
-          :@id => 1
-        }
+          :@id => 1,
+        },
       }
       expect(to_xml(hash)).to eq('<category id="1">users</category>')
     end
@@ -220,8 +220,8 @@ describe Gyoku::Hash do
     it "recognizes @attribute => value along :attributes! in selfclosed tags" do
       hash = {
         "category/" => {
-          :@id => 1
-        }
+          :@id => 1,
+        },
       }
       expect(to_xml(hash)).to eq('<category id="1"/>')
     end
@@ -229,14 +229,14 @@ describe Gyoku::Hash do
     it ":@attribute => value takes over :attributes!" do
       hash = {
         "category/" => {
-          :@id => 1
+          :@id => 1,
         },
         :attributes! => {
           "category/" => {
             "id" => 2, # will be ignored
-            "type" => "admins"
-          }
-        }
+            "type" => "admins",
+          },
+        },
       }
       # attribute order is undefined
       expect(['<category id="1" type="admins"/>', '<category type="admins" id="1"/>']).to include to_xml(hash)
@@ -244,14 +244,14 @@ describe Gyoku::Hash do
       # with symbols
       hash = {
         "category/" => {
-          :@id => 1
+          :@id => 1,
         },
         :attributes! => {
           "category/" => {
             id: 2, # will be ignored
-            type: "admins"
-          }
-        }
+            type: "admins",
+          },
+        },
       }
       expect(['<category id="1" type="admins"/>', '<category type="admins" id="1"/>']).to include to_xml(hash)
     end
@@ -259,8 +259,8 @@ describe Gyoku::Hash do
     it "recognizes :content! => value as tag content" do
       hash = {
         "category" => {
-          content!: "users"
-        }
+          content!: "users",
+        },
       }
       expect(to_xml(hash)).to eq("<category>users</category>")
     end
@@ -268,8 +268,8 @@ describe Gyoku::Hash do
     it "recognizes :content! => value as tag content with value Fixnum" do
       hash = {
         "category" => {
-          content!: 666
-        }
+          content!: 666,
+        },
       }
       expect(to_xml(hash)).to eq("<category>666</category>")
     end
@@ -277,8 +277,8 @@ describe Gyoku::Hash do
     it "recognizes :content! => value as tag content with value true" do
       hash = {
         "category" => {
-          content!: true
-        }
+          content!: true,
+        },
       }
       expect(to_xml(hash)).to eq("<category>true</category>")
     end
@@ -286,8 +286,8 @@ describe Gyoku::Hash do
     it "recognizes :content! => value as tag content with value false" do
       hash = {
         "category" => {
-          content!: false
-        }
+          content!: false,
+        },
       }
       expect(to_xml(hash)).to eq("<category>false</category>")
     end
@@ -295,8 +295,8 @@ describe Gyoku::Hash do
     it "recognizes :content! => value as tag content with value DateTime" do
       hash = {
         "before" => {
-          content!: DateTime.new(2012, 0o3, 22, 16, 22, 33)
-        }
+          content!: DateTime.new(2012, 0o3, 22, 16, 22, 33),
+        },
       }
       expect(to_xml(hash)).to eq("<before>2012-03-22T16:22:33+00:00</before>")
     end
@@ -304,59 +304,59 @@ describe Gyoku::Hash do
     it "ignores :content! if self-closing mark present" do
       hash = {
         "category/" => {
-          content!: "users"
-        }
+          content!: "users",
+        },
       }
       expect(to_xml(hash)).to eq("<category/>")
     end
 
     it "recognizes array of attributes" do
       hash = {
-        "category" => [{:@name => "one"}, {:@name => "two"}]
+        "category" => [{ :@name => "one" }, { :@name => "two" }],
       }
       expect(to_xml(hash)).to eq('<category name="one"></category><category name="two"></category>')
 
       # issue #31.
       hash = {
-        :order! => ["foo", "bar"],
-        "foo" => {:@foo => "foo"},
-        "bar" => {:@bar => "bar", "baz" => {}}
+        :order! => %w{foo bar},
+        "foo" => { :@foo => "foo" },
+        "bar" => { :@bar => "bar", "baz" => {} },
       }
       expect(to_xml(hash)).to eq('<foo foo="foo"></foo><bar bar="bar"><baz></baz></bar>')
     end
 
     it "recognizes array of attributes with content in each" do
       hash = {
-        "foo" => [{:@name => "bar", :content! => "gyoku"}, {:@name => "baz", :@some => "attr", :content! => "rocks!"}]
+        "foo" => [{ :@name => "bar", :content! => "gyoku" }, { :@name => "baz", :@some => "attr", :content! => "rocks!" }],
       }
 
       expect([
         '<foo name="bar">gyoku</foo><foo name="baz" some="attr">rocks!</foo>',
-        '<foo name="bar">gyoku</foo><foo some="attr" name="baz">rocks!</foo>'
+        '<foo name="bar">gyoku</foo><foo some="attr" name="baz">rocks!</foo>',
       ]).to include to_xml(hash)
     end
 
     it "recognizes array of attributes but ignores content in each if selfclosing" do
       hash = {
-        "foo/" => [{:@name => "bar", :content! => "gyoku"}, {:@name => "baz", :@some => "attr", :content! => "rocks!"}]
+        "foo/" => [{ :@name => "bar", :content! => "gyoku" }, { :@name => "baz", :@some => "attr", :content! => "rocks!" }],
       }
 
       expect([
         '<foo name="bar"/><foo name="baz" some="attr"/>',
-        '<foo name="bar"/><foo some="attr" name="baz"/>'
+        '<foo name="bar"/><foo some="attr" name="baz"/>',
       ]).to include to_xml(hash)
     end
 
     it "recognizes array of attributes with selfclosing tag" do
       hash = {
-        "category/" => [{:@name => "one"}, {:@name => "two"}]
+        "category/" => [{ :@name => "one" }, { :@name => "two" }],
       }
       expect(to_xml(hash)).to eq('<category name="one"/><category name="two"/>')
     end
 
     context "with :element_form_default set to :qualified and a :namespace" do
       it "adds the given :namespace to every element" do
-        hash = {:first => {"first_name" => "Lucy"}, ":second" => {":first_name": "Anna"}, "v2:third" => {"v2:firstName" => "Danie"}}
+        hash = { :first => { "first_name" => "Lucy" }, ":second" => { ":first_name": "Anna" }, "v2:third" => { "v2:firstName" => "Danie" } }
         result = to_xml hash, element_form_default: :qualified, namespace: :v1
 
         expect(result).to include(
@@ -367,7 +367,7 @@ describe Gyoku::Hash do
       end
 
       it "adds given :namespace to every element in an array" do
-        hash = {array: [first: "Lucy", second: "Anna"]}
+        hash = { array: [first: "Lucy", second: "Anna"] }
         result = to_xml hash, element_form_default: :qualified, namespace: :v1
 
         expect(result).to include("<v1:array>", "<v1:first>Lucy</v1:first>", "<v1:second>Anna</v1:second>")
@@ -379,12 +379,12 @@ describe Gyoku::Hash do
         persons: {
           first: "Lucy",
           second: "Anna",
-          order!: [:second, :first],
-          attributes!: {first: {first: true}}
+          order!: %i{second first},
+          attributes!: { first: { first: true } },
         },
-        countries: [:de, :us],
-        order!: [:countries, :persons],
-        attributes!: {countries: {array: true}}
+        countries: %i{de us},
+        order!: %i{countries persons},
+        attributes!: { countries: { array: true } },
       }
 
       to_xml(hash)
@@ -393,20 +393,20 @@ describe Gyoku::Hash do
         persons: {
           first: "Lucy",
           second: "Anna",
-          order!: [:second, :first],
-          attributes!: {first: {first: true}}
+          order!: %i{second first},
+          attributes!: { first: { first: true } },
         },
-        countries: [:de, :us],
-        order!: [:countries, :persons],
-        attributes!: {countries: {array: true}}
+        countries: %i{de us},
+        order!: %i{countries persons},
+        attributes!: { countries: { array: true } },
       })
     end
   end
 
   it "doesn't modify original hash parameter by deleting its attribute keys" do
-    hash = {person: {name: "Johnny", surname: "Bravo", "@xsi:type": "People"}}
+    hash = { person: { name: "Johnny", surname: "Bravo", "@xsi:type": "People" } }
     to_xml(hash)
-    expect(hash).to eq({person: {name: "Johnny", surname: "Bravo", "@xsi:type": "People"}})
+    expect(hash).to eq({ person: { name: "Johnny", surname: "Bravo", "@xsi:type": "People" } })
   end
 
   describe ".explicit_attribute?" do

data/spec/{gyoku → chef-gyoku}/prettifier_spec.rb

@@ -3,7 +3,7 @@ require "spec_helper"
 describe Gyoku::Prettifier do
   describe "#prettify" do
     context "when xml is valid" do
-      let!(:xml) { Gyoku::Hash.build_xml(test: {pretty: "xml"}) }
+      let!(:xml) { Gyoku::Hash.build_xml(test: { pretty: "xml" }) }
 
       it "returns prettified xml" do
         expect(subject.prettify(xml)).to eql("<test>\n  <pretty>xml</pretty>\n</test>")
@@ -11,7 +11,7 @@ describe Gyoku::Prettifier do
 
       context "when indent option is specified" do
         it "returns prettified xml with indent" do
-          options = {indent: 3}
+          options = { indent: 3 }
           subject = Gyoku::Prettifier.new(options)
           expect(subject.prettify(xml)).to eql("<test>\n   <pretty>xml</pretty>\n</test>")
         end
@@ -19,7 +19,7 @@ describe Gyoku::Prettifier do
 
       context "when compact option is specified" do
         it "returns prettified xml with indent" do
-          options = {compact: false}
+          options = { compact: false }
           subject = Gyoku::Prettifier.new(options)
           expect(subject.prettify(xml)).to eql("<test>\n  <pretty>\n    xml\n  </pretty>\n</test>")
         end
@@ -28,7 +28,7 @@ describe Gyoku::Prettifier do
 
     context "when xml is not valid" do
       let!(:xml) do
-        Gyoku::Array.build_xml(["one", "two"], "test")
+        Gyoku::Array.build_xml(%w{one two}, "test")
       end
 
       it "raises an error" do

data/spec/{gyoku → chef-gyoku}/xml_key_spec.rb

@@ -23,31 +23,31 @@ describe Gyoku::XMLKey do
       it "should replace / with ::, and turn snake case into camel case" do
         input = :"hello_world_bob/how_are_you|there:foo^bar"
         expected_output = "HelloWorldBob::HowAreYou|there:foo^bar"
-        expect(create(input, {key_converter: :camelcase})).to eq(expected_output)
+        expect(create(input, { key_converter: :camelcase })).to eq(expected_output)
       end
     end
 
     context "with key_converter" do
       it "accepts lambda converters" do
-        expect(create(:some_text, {key_converter: lambda { |k| k.reverse }})).to eq("txet_emos")
+        expect(create(:some_text, { key_converter: lambda(&:reverse) })).to eq("txet_emos")
       end
 
       it "convert symbol to the specified type" do
-        expect(create(:some_text, {key_converter: :camelcase})).to eq("SomeText")
-        expect(create(:some_text, {key_converter: :upcase})).to eq("SOME_TEXT")
-        expect(create(:some_text, {key_converter: :none})).to eq("some_text")
+        expect(create(:some_text, { key_converter: :camelcase })).to eq("SomeText")
+        expect(create(:some_text, { key_converter: :upcase })).to eq("SOME_TEXT")
+        expect(create(:some_text, { key_converter: :none })).to eq("some_text")
       end
 
       it "when key_to_convert is defined, convert only this key" do
-        options = {key_converter: :camelcase, key_to_convert: "somekey"}
+        options = { key_converter: :camelcase, key_to_convert: "somekey" }
         expect(create(:some_key, options)).to eq("someKey")
 
-        options = {key_converter: :camelcase, key_to_convert: "some_key"}
+        options = { key_converter: :camelcase, key_to_convert: "some_key" }
         expect(create(:some_key, options)).to eq("SomeKey")
       end
 
       it "when except is defined, dont convert this key" do
-        options = {key_converter: :camelcase, except: "some_key"}
+        options = { key_converter: :camelcase, except: "some_key" }
         expect(create(:some_key, options)).to eq("someKey")
       end
     end

data/spec/{gyoku → chef-gyoku}/xml_value_spec.rb

@@ -46,7 +46,7 @@ describe Gyoku::XMLValue do
     end
 
     it "hash objects get converted to xml" do
-      object = {document!: {"@version" => "2.0", :content! => {key!: "value", other_key: {"@attribute" => "value", :content! => {key: "value"}}}}}
+      object = { document!: { "@version" => "2.0", :content! => { key!: "value", other_key: { "@attribute" => "value", :content! => { key: "value" } } } } }
       expect(create(object)).to eq("<document version=\"2.0\"><key>value</key><otherKey attribute=\"value\"><key>value</key></otherKey></document>")
     end
 

data/spec/{gyoku_spec.rb → chef-gyoku_spec.rb}

@@ -25,31 +25,31 @@ describe Gyoku do
 
   describe ".xml" do
     it "translates a given Hash to XML" do
-      hash = {id: 1}
+      hash = { id: 1 }
       xml = Gyoku.xml(hash, element_form_default: :qualified)
 
       expect(xml).to eq("<id>1</id>")
     end
 
     it "accepts a key_converter for the Hash keys" do
-      hash = {user_name: "finn", pass_word: "secret"}
-      xml = Gyoku.xml(hash, {key_converter: :upcase})
+      hash = { user_name: "finn", pass_word: "secret" }
+      xml = Gyoku.xml(hash, { key_converter: :upcase })
 
       expect(xml).to include("<USER_NAME>finn</USER_NAME>")
       expect(xml).to include("<PASS_WORD>secret</PASS_WORD>")
     end
 
     it "don't converts Strings keys" do
-      hash = {:user_name => "finn", "pass_word" => "secret"}
-      xml = Gyoku.xml(hash, {key_converter: :upcase})
+      hash = { :user_name => "finn", "pass_word" => "secret" }
+      xml = Gyoku.xml(hash, { key_converter: :upcase })
 
       expect(xml).to include("<USER_NAME>finn</USER_NAME>")
       expect(xml).to include("<pass_word>secret</pass_word>")
     end
 
     it "when defined key_to_convert only convert this key" do
-      hash = {user_name: "finn", pass_word: "secret"}
-      options = {key_converter: :upcase, key_to_convert: "user_name"}
+      hash = { user_name: "finn", pass_word: "secret" }
+      options = { key_converter: :upcase, key_to_convert: "user_name" }
       xml = Gyoku.xml(hash, options)
 
       expect(xml).to include("<USER_NAME>finn</USER_NAME>")
@@ -57,8 +57,8 @@ describe Gyoku do
     end
 
     it "accepts key_converter for nested hash" do
-      hash = {user: {user_name: "finn", pass_word: "secret"}}
-      xml = Gyoku.xml(hash, {key_converter: :upcase})
+      hash = { user: { user_name: "finn", pass_word: "secret" } }
+      xml = Gyoku.xml(hash, { key_converter: :upcase })
 
       expect(xml).to include("<USER><USER_NAME>finn</USER_NAME>")
       expect(xml).to include("<PASS_WORD>secret</PASS_WORD></USER>")
@@ -69,9 +69,9 @@ describe Gyoku do
         person: {
           first_name: "Lucy",
           last_name: "Sky",
-          order!: [:first_name, :last_name]
+          order!: %i{first_name last_name},
         },
-        attributes!: {person: {id: "666"}}
+        attributes!: { person: { id: "666" } },
       }
       original_hash = hash.dup
 

data/spec/spec_helper.rb

@@ -11,5 +11,5 @@ unless RUBY_PLATFORM.match?(/java/)
   end
 end
 
-require "gyoku"
+require "chef-gyoku"
 require "rspec"

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: chef-gyoku
 version: !ruby/object:Gem::Version
-  version: 1.4.1
+  version: 1.5.0
 platform: ruby
 authors:
 - Daniel Harrington
 bindir: bin
 cert_chain: []
-date: 2025-01-06 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: builder
@@ -29,14 +29,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.3'
+        version: '3.4'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.3'
+        version: '3.4'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -79,34 +79,65 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: fiddle
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: cookstyle
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 8.0.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 8.0.0
 description: Gyoku translates Ruby Hashes to XML
 email: me@rubiii.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/dependabot.yml"
 - ".github/workflows/ci.yml"
+- ".github/workflows/lint.yml"
 - ".gitignore"
 - ".rspec"
+- ".rubocop.yml"
 - CHANGELOG.md
 - Gemfile
 - MIT-LICENSE
 - README.md
 - Rakefile
-- gyoku.gemspec
-- lib/gyoku.rb
-- lib/gyoku/array.rb
-- lib/gyoku/hash.rb
-- lib/gyoku/prettifier.rb
-- lib/gyoku/version.rb
-- lib/gyoku/xml_key.rb
-- lib/gyoku/xml_value.rb
-- spec/gyoku/array_spec.rb
-- spec/gyoku/hash_spec.rb
-- spec/gyoku/prettifier_spec.rb
-- spec/gyoku/xml_key_spec.rb
-- spec/gyoku/xml_value_spec.rb
-- spec/gyoku_spec.rb
+- chef-gyoku.gemspec
+- lib/chef-gyoku.rb
+- lib/chef-gyoku/array.rb
+- lib/chef-gyoku/hash.rb
+- lib/chef-gyoku/prettifier.rb
+- lib/chef-gyoku/version.rb
+- lib/chef-gyoku/xml_key.rb
+- lib/chef-gyoku/xml_value.rb
+- spec/chef-gyoku/array_spec.rb
+- spec/chef-gyoku/hash_spec.rb
+- spec/chef-gyoku/prettifier_spec.rb
+- spec/chef-gyoku/xml_key_spec.rb
+- spec/chef-gyoku/xml_value_spec.rb
+- spec/chef-gyoku_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/savonrb/chef-gyoku
 licenses:
@@ -119,14 +150,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '3.0'
+      version: '3.1'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.2
+rubygems_version: 3.6.8
 specification_version: 4
 summary: Translates Ruby Hashes to XML
 test_files: []

data/lib/gyoku/version.rb

@@ -1,3 +0,0 @@
-module Gyoku
-  VERSION = "1.4.1"
-end