test: add Ruby version matrix testing for PropertyStruct

Add comprehensive Ruby testing infrastructure to verify PropertyStruct
compatibility across Ruby versions 2.6 through head.

Following the pattern from PR cloudfoundry#707, this adds:
- GitHub Actions workflow testing across Ruby 2.6-3.4 and head
- RSpec test suite for PropertyStruct
- Tests for dynamic attribute access, nested structures, and arrays
- Tests for Ruby standard library method pass-through
- Tests for OpenStruct API compatibility

The Ruby matrix ensures PropertyStruct works correctly across all
supported Ruby versions, particularly validating Ruby 3.5+ compatibility
where ostruct is being removed.

Related to cloudfoundry#708

Author: rubionic

.github/workflows/ruby.yml

@@ -0,0 +1,21 @@
+name: ERB Renderer Ruby Tests
+
+on: [push, pull_request]
+
+jobs:
+  test_property_struct:
+    strategy:
+      matrix:
+        os: [ubuntu-latest, macos-latest]
+        ruby: ['2.6', '2.7', '3.0', '3.1', '3.2', '3.3', '3.4', head]
+    runs-on: ${{ matrix.os }}
+    steps:
+      - uses: actions/checkout@v6
+      - uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: ${{ matrix.ruby }}
+      - run: bundle install
+        working-directory: templatescompiler/erbrenderer/
+      - run: bundle exec rake
+        working-directory: templatescompiler/erbrenderer/
+        continue-on-error: ${{ matrix.ruby == 'head' }}

templatescompiler/erbrenderer/.gitignore

@@ -0,0 +1,3 @@
+.bundle/
+vendor/bundle/
+Gemfile.lock

templatescompiler/erbrenderer/Gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+group :test do
+  gem "rake"
+  gem "rspec"
+end

templatescompiler/erbrenderer/Rakefile

@@ -0,0 +1,5 @@
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: [:spec]

templatescompiler/erbrenderer/spec/property_struct_spec.rb

@@ -0,0 +1,86 @@
+require "spec_helper"
+require "erb_renderer"
+
+RSpec.describe "PropertyStruct" do
+  describe "initialization and attribute access" do
+    it "provides dynamic attribute access for hash keys" do
+      ps = PropertyStruct.new(name: "test", value: 42)
+      expect(ps.name).to eq("test")
+      expect(ps.value).to eq(42)
+    end
+
+    it "converts string keys to symbols" do
+      ps = PropertyStruct.new("name" => "test", "value" => 42)
+      expect(ps.name).to eq("test")
+      expect(ps.value).to eq(42)
+    end
+
+    it "supports nested attribute access" do
+      ps = PropertyStruct.new(config: {database: {host: "localhost", port: 5432}})
+      nested = ps.config
+      expect(nested).to be_a(PropertyStruct)
+      expect(nested.database).to be_a(PropertyStruct)
+      expect(nested.database.host).to eq("localhost")
+      expect(nested.database.port).to eq(5432)
+    end
+
+    it "handles arrays of hashes" do
+      ps = PropertyStruct.new(servers: [{name: "web1", ip: "10.0.0.1"}, {name: "web2", ip: "10.0.0.2"}])
+      servers = ps.servers
+      expect(servers).to be_an(Array)
+      expect(servers.length).to eq(2)
+      expect(servers.first.name).to eq("web1")
+      expect(servers.last.ip).to eq("10.0.0.2")
+    end
+
+    it "responds to method queries correctly" do
+      ps = PropertyStruct.new(existing_key: "value")
+      expect(ps.respond_to?(:existing_key)).to be true
+      expect(ps.respond_to?(:nonexistent_key)).to be false
+    end
+  end
+
+  describe "Ruby standard library method pass-through" do
+    it "supports array operations like map" do
+      ps = PropertyStruct.new(ports: [8080, 8081, 8082])
+      expect(ps.ports.map(&:to_s)).to eq(["8080", "8081", "8082"])
+    end
+
+    it "supports string operations" do
+      ps = PropertyStruct.new(url: "https://example.com")
+      expect(ps.url.start_with?("https")).to be true
+      expect(ps.url.split("://")).to eq(["https", "example.com"])
+    end
+
+    it "supports hash operations" do
+      ps = PropertyStruct.new(config: {a: 1, b: 2, c: 3})
+      expect(ps.config.keys.sort).to eq([:a, :b, :c])
+      expect(ps.config.values.sum).to eq(6)
+    end
+
+    it "supports nil and empty checks" do
+      ps = PropertyStruct.new(empty_string: "", nil_value: nil, filled: "data")
+      expect(ps.empty_string.empty?).to be true
+      expect(ps.nil_value.nil?).to be true
+      expect(ps.filled.nil?).to be false
+    end
+  end
+
+  describe "compatibility across Ruby versions" do
+    it "works with ERB rendering" do
+      template = ERB.new("<%= obj.name.upcase %>: <%= obj.ports.join(',') %>")
+      ps = PropertyStruct.new(name: "service", ports: [80, 443, 8080])
+      result = template.result(binding)
+      expect(result).to eq("SERVICE: 80,443,8080")
+    end
+
+    it "maintains OpenStruct API compatibility" do
+      # Test that PropertyStruct can be used as a drop-in replacement for OpenStruct
+      ps = PropertyStruct.new(field1: "value1", field2: "value2")
+      expect(ps).to respond_to(:field1)
+      expect(ps).to respond_to(:field2)
+      expect(ps.field1).to eq("value1")
+      expect(ps.field2).to eq("value2")
+    end
+  end
+end

templatescompiler/erbrenderer/spec/spec_helper.rb

@@ -0,0 +1,8 @@
+require "rspec"
+require "json"
+require "tmpdir"
+require "erb"
+
+ERB_RENDERER_ROOT = File.expand_path("..", File.dirname(__FILE__))
+
+$LOAD_PATH.unshift(ERB_RENDERER_ROOT)