en14960 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: e392aeaeca04d9c6c7648b5517675cecdd55470c983aa834e7f09cd083cedc6c
+  data.tar.gz: 0a60d6ac76ca2bee3463215f0ec2e94c9947b1d881be4d2abdc83f70d07a1784
+SHA512:
+  metadata.gz: '0953db3f8d5c86091ff07ac92f9597299cef1ef4482d67fb877b1d3dfc08bd60e92c4fc7396827ad0946f7e4c4bcee4a28bb663d669f403af1b917c1e01b5725'
+  data.tar.gz: 023212ec36c17575cc234413fb42812d041dc1df8a393b0e747570e0a890d352876f178a12a6b48b7e7676222eb9b0d382748605c451d3f54fe30eef6d0c24b9

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.rspec_status

@@ -0,0 +1,31 @@
+example_id                                            | status | run_time        |
+----------------------------------------------------- | ------ | --------------- |
+./spec/calculators/anchor_calculator_spec.rb[1:1:1:1] | passed | 0.00004 seconds |
+./spec/calculators/anchor_calculator_spec.rb[1:1:1:2] | passed | 0.00006 seconds |
+./spec/calculators/anchor_calculator_spec.rb[1:1:1:3] | passed | 0.00005 seconds |
+./spec/calculators/anchor_calculator_spec.rb[1:1:2:1] | passed | 0.00005 seconds |
+./spec/calculators/anchor_calculator_spec.rb[1:1:2:2] | passed | 0.00004 seconds |
+./spec/calculators/anchor_calculator_spec.rb[1:1:3:1] | passed | 0.001 seconds   |
+./spec/calculators/anchor_calculator_spec.rb[1:1:3:2] | passed | 0.00043 seconds |
+./spec/calculators/anchor_calculator_spec.rb[1:1:4:1] | passed | 0.00028 seconds |
+./spec/calculators/anchor_calculator_spec.rb[1:1:4:2] | passed | 0.00003 seconds |
+./spec/calculators/anchor_calculator_spec.rb[1:1:4:3] | passed | 0.00002 seconds |
+./spec/calculators/anchor_calculator_spec.rb[1:1:5:1] | passed | 0.00005 seconds |
+./spec/calculators/anchor_calculator_spec.rb[1:1:5:2] | passed | 0.00007 seconds |
+./spec/calculators/anchor_calculator_spec.rb[1:2:1:1] | passed | 0.00002 seconds |
+./spec/calculators/anchor_calculator_spec.rb[1:2:1:2] | passed | 0.00003 seconds |
+./spec/calculators/anchor_calculator_spec.rb[1:2:1:3] | passed | 0.00003 seconds |
+./spec/calculators/anchor_calculator_spec.rb[1:2:1:4] | passed | 0.00003 seconds |
+./spec/calculators/anchor_calculator_spec.rb[1:2:1:5] | passed | 0.00005 seconds |
+./spec/calculators/anchor_calculator_spec.rb[1:3:1]   | passed | 0.00003 seconds |
+./spec/calculators/anchor_calculator_spec.rb[1:4:1]   | passed | 0.00044 seconds |
+./spec/en14960_spec.rb[1:1]                           | passed | 0.00027 seconds |
+./spec/en14960_spec.rb[1:2:1:1]                       | passed | 0.00004 seconds |
+./spec/en14960_spec.rb[1:2:2:1]                       | passed | 0.00022 seconds |
+./spec/en14960_spec.rb[1:2:2:2]                       | passed | 0.00004 seconds |
+./spec/en14960_spec.rb[1:2:3:1]                       | passed | 0.00006 seconds |
+./spec/en14960_spec.rb[1:2:4:1]                       | passed | 0.00008 seconds |
+./spec/en14960_spec.rb[1:2:4:2]                       | passed | 0.00005 seconds |
+./spec/en14960_spec.rb[1:2:5:1]                       | passed | 0.00005 seconds |
+./spec/en14960_spec.rb[1:2:6:1]                       | passed | 0.00004 seconds |
+./spec/en14960_spec.rb[1:2:7:1]                       | passed | 0.00003 seconds |

data/CHANGELOG.md

@@ -0,0 +1,25 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [0.1.0] - 2025-01-28
+
+### Added
+- Initial release of EN14960 gem
+- Anchor calculator for wind load calculations per EN 14960:2019 Annex A
+- Slide calculator for runout distances and wall height requirements
+- User capacity calculator based on age-appropriate space allocation
+- Material validator for rope, fabric, thread, and netting specifications
+- Comprehensive constants from EN 14960:2019 standard
+- Full test suite with RSpec
+- Detailed documentation and usage examples
+
+### Features
+- Framework-agnostic implementation (no Rails dependency)
+- Clean public API with intuitive method names
+- Detailed calculation breakdowns for transparency
+- Support for all height categories defined in EN 14960:2019
+- Configurable parameters for various scenarios

data/LICENSE

@@ -0,0 +1,14 @@
+Copyright (C) 2025 Chobble.com
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU Affero General Public License as published
+by the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU Affero General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with this program.  If not, see <https://www.gnu.org/licenses/>.

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2025 [Your Name]
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,195 @@
+# EN14960
+
+A Ruby gem providing calculators and validators for BS EN 14960:2019 - the British/European safety standard for inflatable play equipment.
+
+## Features
+
+- **Anchor Calculations**: Calculate required ground anchors based on dimensions and wind loads
+- **Slide Safety**: Calculate runout distances and wall height requirements
+- **User Capacity**: Calculate safe user capacity based on play area and user heights
+- **Material Validation**: Validate material specifications against EN 14960 requirements
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'en14960'
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install en14960
+
+## Usage
+
+### Anchor Calculations
+
+Calculate required anchors for inflatable play equipment:
+
+```ruby
+result = EN14960.calculate_anchors(length: 5, width: 4, height: 3)
+puts result.value  # => 8
+puts result.breakdown
+# => [
+#   ["Front/back area", "4m (W) × 3m (H) = 12m²"],
+#   ["Sides area", "5m (L) × 3m (H) = 15m²"],
+#   ["Front & back anchor counts", "((12.0 × 114.0 * 1.5) ÷ 1600.0 = 2"],
+#   ["Left & right anchor counts", "((15.0 × 114.0 * 1.5) ÷ 1600.0 = 2"],
+#   ["Required anchors", "(2 + 2) × 2 = 8"]
+# ]
+```
+
+### Slide Runout Calculations
+
+Calculate minimum runout distance for slides:
+
+```ruby
+# Basic runout calculation
+result = EN14960.calculate_slide_runout(2.5)
+puts result.value  # => 1.25 (meters)
+
+# With stop wall
+result = EN14960.calculate_slide_runout(2.5, has_stop_wall: true)
+puts result.value  # => 1.75 (meters)
+```
+
+### Wall Height Requirements
+
+Calculate containing wall requirements for different platform heights:
+
+```ruby
+result = EN14960.calculate_wall_height(2.0, 1.5)
+puts result.value  # => 1.5 (meters)
+puts result.breakdown
+# => [
+#   ["Height range", "0.6m - 3.0m"],
+#   ["Calculation", "1.5m (user height)"]
+# ]
+```
+
+### User Capacity Calculations
+
+Calculate safe user capacity based on play area:
+
+```ruby
+result = EN14960.calculate_user_capacity(10, 8)
+puts result.value
+# => {
+#   users_1000mm: 80,  # 1.0m tall users
+#   users_1200mm: 60,  # 1.2m tall users
+#   users_1500mm: 48,  # 1.5m tall users
+#   users_1800mm: 40   # 1.8m tall users
+# }
+
+# With maximum user height restriction
+result = EN14960.calculate_user_capacity(10, 8, 1.5, 0)
+puts result.value[:users_1800mm]  # => 0 (not allowed)
+
+# With obstacles/negative play space
+result = EN14960.calculate_user_capacity(10, 8, nil, 15)
+# Reduces usable area by 15m²
+```
+
+### Material Validation
+
+Validate materials against EN 14960 requirements:
+
+```ruby
+# Rope diameter validation
+EN14960.valid_rope_diameter?(20)  # => true (within 18-45mm range)
+EN14960.valid_rope_diameter?(10)  # => false (too thin)
+
+# Access material standards
+standards = EN14960.material_standards
+puts standards[:fabric][:min_tensile_strength]  # => 1850 (Newtons)
+puts standards[:rope][:min_diameter]  # => 18 (mm)
+```
+
+### Direct Module Access
+
+You can also use the calculator modules directly:
+
+```ruby
+# Using AnchorCalculator directly
+result = EN14960::Calculators::AnchorCalculator.calculate(
+  length: 10, 
+  width: 8, 
+  height: 4
+)
+
+# Using MaterialValidator directly
+EN14960::Validators::MaterialValidator.valid_fabric_tensile_strength?(2000)
+# => true
+```
+
+## Constants
+
+The gem provides access to all EN 14960:2019 constants:
+
+```ruby
+# Height categories
+EN14960.height_categories
+# => {
+#   1000 => {label: "1.0m (Young children)", max_users: :calculate_by_area},
+#   1200 => {label: "1.2m (Children)", max_users: :calculate_by_area},
+#   1500 => {label: "1.5m (Adolescents)", max_users: :calculate_by_area},
+#   1800 => {label: "1.8m (Adults)", max_users: :calculate_by_area}
+# }
+
+# Access all constants
+EN14960::Constants::SLIDE_HEIGHT_THRESHOLDS
+EN14960::Constants::MATERIAL_STANDARDS
+EN14960::Constants::ANCHOR_CALCULATION_CONSTANTS
+```
+
+## EN 14960:2019 Compliance
+
+This gem implements calculations based on BS EN 14960:2019, including:
+
+- **Section 4.2.9**: Containment requirements (wall heights)
+- **Section 4.2.11**: Slide runout requirements
+- **Section 4.3**: Number of users calculations
+- **Annex A**: Wind load and anchor calculations
+- **Material specifications**: Fabric, thread, rope, and netting requirements
+
+## Development
+
+After checking out the repo, run `bundle install` to install dependencies. Then, run `bundle exec rspec` to run the tests.
+
+To install this gem onto your local machine, run `bundle exec rake install`.
+
+## Releasing
+
+This gem uses GitHub Actions for automated releases to RubyGems.
+
+To release a new version:
+
+1. Update the version number in `lib/en14960/version.rb`
+2. Commit the change: `git commit -am "Bump version to x.y.z"`
+3. Create a tag: `git tag -a vx.y.z -m "Release version x.y.z"`
+4. Push the tag: `git push origin vx.y.z`
+
+The GitHub Action will automatically:
+- Build the gem
+- Publish it to RubyGems
+- Create a GitHub release with the gem file attached
+
+**Note**: You need to set up RubyGems authentication in your GitHub repository settings. Add a repository secret named `GEM_HOST_API_KEY` with your RubyGems API key.
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/chobbledotcom/en14960.
+
+## License
+
+The gem is available as open source under the terms of the [GNU Affero General Public License v3.0](https://www.gnu.org/licenses/agpl-3.0.html).
+
+## References
+
+- BS EN 14960:2019 - Inflatable play equipment - Safety requirements and test methods
+- EN 71-3 - Safety of toys - Migration of certain elements

data/Rakefile

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+require "standard/rake"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: %i[spec standard]
+
+desc "Run tests with coverage"
+task :coverage do
+  ENV["COVERAGE"] = "true"
+  Rake::Task["spec"].invoke
+end

data/en14960.gemspec

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require_relative "lib/en14960/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "en14960"
+  spec.version = EN14960::VERSION
+  spec.authors = ["Chobble.com"]
+  spec.email = ["hello@chobble.com"]
+
+  spec.summary = "BS EN 14960:2019 safety standard calculators for inflatable play equipment"
+  spec.description = "A Ruby gem providing calculators and validators for BS EN 14960:2019 - the safety standard for inflatable play equipment. Includes calculations for anchoring requirements, slide safety, user capacity, and material specifications."
+  spec.homepage = "https://github.com/chobbledotcom/en14960"
+  spec.license = "AGPL-3.0-or-later"
+  spec.required_ruby_version = ">= 3.0.0"
+
+  spec.metadata["allowed_push_host"] = "https://rubygems.org"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = spec.homepage
+  spec.metadata["changelog_uri"] = "#{spec.homepage}/blob/main/CHANGELOG.md"
+
+  # 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(__dir__) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (File.expand_path(f) == __FILE__) ||
+        f.start_with?(*%w[bin/ test/ spec/ features/ .git .github appveyor Gemfile]) ||
+        f.end_with?(".gem")
+    end
+  end
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  # No runtime dependencies - this gem is standalone
+
+  # Development dependencies
+  spec.add_development_dependency "bundler", "~> 2.0"
+  spec.add_development_dependency "rake", "~> 13.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "standard", "~> 1.0"
+  spec.add_development_dependency "simplecov", "~> 0.21"
+
+  # For more information and examples about making a new gem, check out our
+  # guide at: https://bundler.io/guides/creating_gem.html
+end

data/lib/en14960/calculators/anchor_calculator.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require_relative "../constants"
+require_relative "../models/calculator_response"
+
+module EN14960
+  module Calculators
+    module AnchorCalculator
+      extend self
+
+      def calculate_required_anchors(area_m2)
+        # EN 14960-1:2019 Annex A (Lines 1175-1210) - Anchor calculation formula
+        # Force = 0.5 × Cw × ρ × V² × A
+        # Where: Cw = 1.5, ρ = 1.24 kg/m³, V = 11.1 m/s (Lines 1194-1199)
+        # Number of anchors = Force / 1600N (Line 450 - each anchor withstands 1600N)
+        return 0 if area_m2.nil? || area_m2 <= 0
+
+        # Pre-calculated: 0.5 × 1.5 × 1.24 × 11.1² ≈ 114
+        area_coeff = Constants::ANCHOR_CALCULATION_CONSTANTS[:area_coefficient]
+        base_div = Constants::ANCHOR_CALCULATION_CONSTANTS[:base_divisor]
+        safety_mult = Constants::ANCHOR_CALCULATION_CONSTANTS[:safety_factor]
+
+        ((area_m2.to_f * area_coeff * safety_mult) / base_div).ceil
+      end
+
+      def calculate(length:, width:, height:)
+        # EN 14960-1:2019 Lines 1175-1210 (Annex A) - Calculate exposed surface areas
+        front_area = (width * height).round(1)
+        sides_area = (length * height).round(1)
+
+        required_front = calculate_required_anchors(front_area)
+        required_sides = calculate_required_anchors(sides_area)
+
+        # EN 14960-1:2019 Line 1204 - Calculate for each side
+        total_required = (required_front + required_sides) * 2
+
+        # EN 14960-1:2019 Lines 441-442 - "Each inflatable shall have at least six anchorage points"
+        minimum = Constants::ANCHOR_CALCULATION_CONSTANTS[:minimum_anchors]
+        total_required = [total_required, minimum].max
+
+        area_coeff = Constants::ANCHOR_CALCULATION_CONSTANTS[:area_coefficient]
+        base_div = Constants::ANCHOR_CALCULATION_CONSTANTS[:base_divisor]
+        safety_mult = Constants::ANCHOR_CALCULATION_CONSTANTS[:safety_factor]
+
+        formula_front = "((#{front_area} × #{area_coeff} * #{safety_mult}) ÷ #{base_div} = #{required_front}"
+        formula_sides = "((#{sides_area} × #{area_coeff} * #{safety_mult}) ÷ #{base_div} = #{required_sides}"
+
+        calculated_total = (required_front + required_sides) * 2
+
+        breakdown = [
+          ["Front/back area", "#{width}m (W) × #{height}m (H) = #{front_area}m²"],
+          ["Sides area", "#{length}m (L) × #{height}m (H) = #{sides_area}m²"],
+          ["Front & back anchor counts", formula_front],
+          ["Left & right anchor counts", formula_sides],
+          ["Required anchors", "(#{required_front} + #{required_sides}) × 2 = #{calculated_total}"]
+        ]
+
+        # Add minimum requirement note if applicable
+        if calculated_total < minimum
+          breakdown << ["EN 14960 minimum", "Minimum #{minimum} anchors required, using #{minimum}"]
+        end
+
+        CalculatorResponse.new(
+          value: total_required,
+          value_suffix: "",
+          breakdown: breakdown
+        )
+      end
+
+      def anchor_formula_text
+        area_coeff = Constants::ANCHOR_CALCULATION_CONSTANTS[:area_coefficient]
+        base_div = Constants::ANCHOR_CALCULATION_CONSTANTS[:base_divisor]
+        safety_fact = Constants::ANCHOR_CALCULATION_CONSTANTS[:safety_factor]
+        "((Area × #{area_coeff} × #{safety_fact}) ÷ #{base_div})"
+      end
+
+      def anchor_calculation_description
+        "Anchors must be calculated based on the play area to ensure adequate ground restraint for wind loads."
+      end
+    end
+  end
+end

data/lib/en14960/calculators/slide_calculator.rb

@@ -0,0 +1,254 @@
+# frozen_string_literal: true
+
+require_relative "../constants"
+require_relative "../models/calculator_response"
+
+module EN14960
+  module Calculators
+    module SlideCalculator
+      extend self
+
+      # Simple calculation method that returns just the numeric value
+      def calculate_runout_value(platform_height, has_stop_wall: false)
+        return 0 if platform_height.nil? || platform_height <= 0
+
+        height_ratio = Constants::RUNOUT_CALCULATION_CONSTANTS[:platform_height_ratio]
+        minimum_runout = Constants::RUNOUT_CALCULATION_CONSTANTS[:minimum_runout_meters]
+        stop_wall_add = Constants::RUNOUT_CALCULATION_CONSTANTS[:stop_wall_addition]
+
+        calculated_runout = platform_height * height_ratio
+        base_runout = [calculated_runout, minimum_runout].max
+
+        has_stop_wall ? base_runout + stop_wall_add : base_runout
+      end
+
+      def calculate_required_runout(platform_height, has_stop_wall: false)
+        # EN 14960-1:2019 Section 4.2.11 (Lines 930-939) - Runout requirements
+        # Line 934-935: The runout distance must be at least half the height of the slide's
+        # highest platform (measured from ground level), with an absolute minimum of 300mm
+        # Line 936: If a stop-wall is installed at the runout's end, an additional
+        # 50cm must be added to the total runout length
+        return CalculatorResponse.new(value: 0, value_suffix: "m", breakdown: []) if platform_height.nil? || platform_height <= 0
+
+        # Get constants
+        height_ratio = Constants::RUNOUT_CALCULATION_CONSTANTS[:platform_height_ratio]
+        minimum_runout = Constants::RUNOUT_CALCULATION_CONSTANTS[:minimum_runout_meters]
+        stop_wall_add = Constants::RUNOUT_CALCULATION_CONSTANTS[:stop_wall_addition]
+
+        # Calculate values using the shared method
+        calculated_runout = platform_height * height_ratio
+        base_runout = calculate_runout_value(platform_height, has_stop_wall: false)
+        final_runout = calculate_runout_value(platform_height, has_stop_wall: has_stop_wall)
+
+        # Build breakdown
+        breakdown = [
+          ["50% calculation", "#{platform_height}m × 0.5 = #{calculated_runout}m"],
+          ["Minimum requirement", "#{minimum_runout}m (300mm)"],
+          ["Base runout", "Maximum of #{calculated_runout}m and #{minimum_runout}m = #{base_runout}m"]
+        ]
+
+        # Add stop-wall if applicable
+        if has_stop_wall
+          breakdown << ["Stop-wall addition", "#{base_runout}m + #{stop_wall_add}m = #{final_runout}m"]
+        end
+
+        CalculatorResponse.new(
+          value: final_runout,
+          value_suffix: "m",
+          breakdown: breakdown
+        )
+      end
+
+      def meets_height_requirements?(platform_height, user_height, containing_wall_height, has_permanent_roof)
+        # EN 14960-1:2019 Section 4.2.9 (Lines 854-887) - Containment requirements
+        # Lines 859-860: Containing walls become mandatory for platforms exceeding 0.6m in height
+        # Lines 861-862: Platforms between 0.6m and 3.0m need walls at least as tall as the maximum user height
+        # Lines 863-864: Platforms between 3.0m and 6.0m require walls at least 1.25 times the maximum user height OR a permanent roof
+        # Lines 865-866: Platforms over 6.0m must have both containing walls and a permanent roof structure
+        return false if platform_height.nil? || user_height.nil? || containing_wall_height.nil? || has_permanent_roof.nil?
+
+        enhanced_multiplier = Constants::WALL_HEIGHT_CONSTANTS[:enhanced_height_multiplier]
+        thresholds = Constants::SLIDE_HEIGHT_THRESHOLDS
+
+        case platform_height
+        when 0..thresholds[:no_walls_required]
+          true # No containing walls required
+        when (thresholds[:no_walls_required]..thresholds[:basic_walls])
+          containing_wall_height >= user_height
+        when (thresholds[:basic_walls]..thresholds[:enhanced_walls])
+          # EITHER walls at 1.25x user height OR permanent roof
+          has_permanent_roof || containing_wall_height >= (user_height * enhanced_multiplier)
+        when (thresholds[:enhanced_walls]..thresholds[:max_safe_height])
+          # BOTH containing walls AND permanent roof required
+          has_permanent_roof && containing_wall_height >= (user_height * enhanced_multiplier)
+        else
+          false # Exceeds safe height limits
+        end
+      end
+
+      def meets_runout_requirements?(runout_length, platform_height, has_stop_wall: false)
+        # EN 14960-1:2019 Section 4.2.11 (Lines 930-939) - Runout requirements
+        # Lines 934-935: The runout area must extend at least half the platform's height
+        # or 300mm (whichever is greater) to allow users to decelerate safely
+        return false if runout_length.nil? || platform_height.nil?
+
+        required_runout = calculate_runout_value(platform_height, has_stop_wall: has_stop_wall)
+        runout_length >= required_runout
+      end
+
+      def slide_runout_formula_text
+        ratio_constant = Constants::RUNOUT_CALCULATION_CONSTANTS[:platform_height_ratio]
+        height_ratio = (ratio_constant * 100).to_i
+        min_constant = Constants::RUNOUT_CALCULATION_CONSTANTS[:minimum_runout_meters]
+        min_runout = (min_constant * 1000).to_i
+        "#{height_ratio}% of platform height, minimum #{min_runout}mm"
+      end
+
+      def calculate_wall_height_requirements(platform_height, user_height, has_permanent_roof = nil)
+        # EN 14960-1:2019 Section 4.2.9 (Lines 854-887) - Containment requirements
+        return CalculatorResponse.new(value: 0, value_suffix: "m", breakdown: []) if platform_height.nil? || user_height.nil? || platform_height <= 0 || user_height <= 0
+
+        # Get requirement details and breakdown
+        requirement_details = get_wall_height_requirement_details(platform_height, user_height, has_permanent_roof)
+
+        # Extract the required wall height from the details
+        required_height = extract_required_wall_height(platform_height, user_height)
+
+        CalculatorResponse.new(
+          value: required_height,
+          value_suffix: "m",
+          breakdown: requirement_details[:breakdown]
+        )
+      end
+
+      def get_wall_height_requirement_details(platform_height, user_height, has_permanent_roof)
+        thresholds = Constants::SLIDE_HEIGHT_THRESHOLDS
+        enhanced_multiplier = Constants::WALL_HEIGHT_CONSTANTS[:enhanced_height_multiplier]
+
+        case platform_height
+        when 0..thresholds[:no_walls_required]
+          {
+            text: "No containing walls required",
+            breakdown: [
+              ["Height range", "Under 0.6m"],
+              ["Requirement", "No containing walls required"]
+            ]
+          }
+        when (thresholds[:no_walls_required]..thresholds[:basic_walls])
+          {
+            text: "Walls must be at least #{user_height}m (equal to user height)",
+            breakdown: [
+              ["Height range", "0.6m - 3.0m"],
+              ["Calculation", "#{user_height}m (user height)"]
+            ]
+          }
+        when (thresholds[:basic_walls]..thresholds[:enhanced_walls])
+          required_height = (user_height * enhanced_multiplier).round(2)
+          breakdown = [
+            ["Height range", "3.0m - 6.0m"],
+            ["Calculation", "#{user_height}m × #{enhanced_multiplier} = #{required_height}m"],
+            ["Alternative requirement", "Permanent roof (can replace heightened walls)"]
+          ]
+
+          # Add roof status if known
+          if !has_permanent_roof.nil?
+            breakdown << if has_permanent_roof
+              ["Permanent roof", "Fitted ✓"]
+            else
+              ["Permanent roof", "Not fitted ✗"]
+            end
+          end
+
+          {
+            text: "Walls must be at least #{required_height}m (1.25× user height)",
+            breakdown: breakdown
+          }
+        when (thresholds[:enhanced_walls]..thresholds[:max_safe_height])
+          required_height = (user_height * enhanced_multiplier).round(2)
+          breakdown = [
+            ["Height range", "Over 6.0m"],
+            ["Calculation", "#{user_height}m × #{enhanced_multiplier} = #{required_height}m"],
+            ["Additional requirement", "Permanent roof required"]
+          ]
+
+          # Add roof status if known
+          if !has_permanent_roof.nil?
+            breakdown << if has_permanent_roof
+              ["Permanent roof", "Required and fitted ✓"]
+            else
+              ["Permanent roof", "Required but not fitted ✗"]
+            end
+          end
+
+          {
+            text: "Walls must be at least #{required_height}m + permanent roof required",
+            breakdown: breakdown
+          }
+        else
+          {
+            text: "Platform height exceeds safe limits",
+            breakdown: [
+              ["Status", "Platform height exceeds safe limits"]
+            ]
+          }
+        end
+      end
+
+      def requires_permanent_roof?(platform_height)
+        # EN 14960-1:2019 Section 4.2.9 (Lines 865-866)
+        # Inflatable structures with platforms higher than 6.0m must be equipped
+        # with both containing walls and a permanent roof
+        threshold = Constants::SLIDE_HEIGHT_THRESHOLDS[:enhanced_walls]
+        !platform_height.nil? && platform_height > threshold
+      end
+
+      def wall_height_requirement
+        multiplier = Constants::WALL_HEIGHT_CONSTANTS[:enhanced_height_multiplier]
+        "Containing walls required #{multiplier} times user height"
+      end
+
+      def slide_calculations
+        # EN 14960:2019 - Comprehensive slide safety requirements
+        {
+          containing_wall_heights: {
+            under_600mm: "No containing walls required",
+            between_600_3000mm: "Containing walls required of user height",
+            between_3000_6000mm: wall_height_requirement,
+            over_6000mm: "Both containing walls AND permanent roof required"
+          },
+          runout_requirements: {
+            minimum_length: "50% of highest platform height",
+            absolute_minimum: "300mm in any case",
+            maximum_inclination: "Not more than 10°",
+            stop_wall_addition: "If fitted, adds 50cm to required run-out length",
+            wall_height_requirement: "50% of user height on run-out sides"
+          },
+          safety_factors: {
+            first_metre_gradient: "Special requirements for first metre of slope",
+            surface_requirements: "Non-slip surface material required",
+            edge_protection: "Rounded edges and smooth transitions"
+          }
+        }
+      end
+
+      private
+
+      def extract_required_wall_height(platform_height, user_height)
+        thresholds = Constants::SLIDE_HEIGHT_THRESHOLDS
+        enhanced_multiplier = Constants::WALL_HEIGHT_CONSTANTS[:enhanced_height_multiplier]
+
+        case platform_height
+        when 0..thresholds[:no_walls_required]
+          0 # No walls required
+        when (thresholds[:no_walls_required]..thresholds[:basic_walls])
+          user_height # Equal to user height
+        when (thresholds[:basic_walls]..thresholds[:enhanced_walls]),
+             (thresholds[:enhanced_walls]..thresholds[:max_safe_height])
+          (user_height * enhanced_multiplier).round(2) # 1.25× user height
+        else
+          0 # Exceeds safe limits
+        end
+      end
+    end
+  end
+end

data/lib/en14960/calculators/user_capacity_calculator.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require_relative "../constants"
+require_relative "../models/calculator_response"
+
+module EN14960
+  module Calculators
+    module UserCapacityCalculator
+      extend self
+
+      def calculate(length, width, max_user_height = nil, negative_adjustment_area = 0)
+        return default_result if length.nil? || width.nil?
+
+        total_area = (length * width).round(2)
+        negative_adjustment_area = negative_adjustment_area.to_f.abs
+        usable_area = [total_area - negative_adjustment_area, 0].max.round(2)
+
+        breakdown = build_breakdown(length, width, total_area, negative_adjustment_area, usable_area)
+        capacities = calculate_capacities(usable_area, max_user_height, breakdown)
+
+        CalculatorResponse.new(
+          value: capacities,
+          value_suffix: "",
+          breakdown: breakdown
+        )
+      end
+
+      private
+
+      def build_breakdown(length, width, total_area, negative_adjustment_area, usable_area)
+        breakdown = []
+        formatted_length = format_number(length)
+        formatted_width = format_number(width)
+        formatted_total = format_number(total_area)
+        formatted_usable = format_number(usable_area)
+
+        breakdown << ["Total area", "#{formatted_length}m × #{formatted_width}m = #{formatted_total}m²"]
+
+        if negative_adjustment_area > 0
+          formatted_adjustment = format_number(negative_adjustment_area)
+          breakdown << ["Obstacles/adjustments", "- #{formatted_adjustment}m²"]
+        end
+
+        breakdown << ["Usable area", "#{formatted_usable}m²"]
+        breakdown << ["Capacity calculations", "Based on usable area"]
+
+        breakdown
+      end
+
+      def calculate_capacities(usable_area, max_user_height, breakdown)
+        capacities = {}
+
+        Constants::AREA_DIVISOR.each do |height_mm, divisor|
+          height_m = height_mm / 1000.0
+          key = :"users_#{height_mm}mm"
+
+          if max_user_height.nil? || height_m <= max_user_height
+            capacity = (usable_area / divisor).floor
+            capacities[key] = capacity
+            formatted_area = format_number(usable_area)
+            formatted_divisor = format_number(divisor)
+            calculation = "#{formatted_area} ÷ #{formatted_divisor} = #{capacity} "
+            calculation += (capacity == 1) ? "user" : "users"
+            breakdown << ["#{format_number(height_m)}m users", calculation]
+          else
+            capacities[key] = 0
+            breakdown << ["#{format_number(height_m)}m users", "Not allowed (exceeds height limit)"]
+          end
+        end
+
+        capacities
+      end
+
+      def default_result
+        CalculatorResponse.new(
+          value: default_capacity,
+          value_suffix: "",
+          breakdown: [["Invalid dimensions", ""]]
+        )
+      end
+
+      def default_capacity
+        {
+          users_1000mm: 0,
+          users_1200mm: 0,
+          users_1500mm: 0,
+          users_1800mm: 0
+        }
+      end
+
+      def format_number(number)
+        # Remove trailing zeros after decimal point
+        formatted = sprintf("%.1f", number)
+        formatted.sub(/\.0$/, "")
+      end
+    end
+  end
+end

data/lib/en14960/constants.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module EN14960
+  module Constants
+    # Height category constants based on EN 14960:2019
+    HEIGHT_CATEGORIES = {
+      1000 => {label: "1.0m (Young children)", max_users: :calculate_by_area},
+      1200 => {label: "1.2m (Children)", max_users: :calculate_by_area},
+      1500 => {label: "1.5m (Adolescents)", max_users: :calculate_by_area},
+      1800 => {label: "1.8m (Adults)", max_users: :calculate_by_area}
+    }.freeze
+
+    # Grounding test weights by user height (EN 14960:2019)
+    GROUNDING_TEST_WEIGHTS = {
+      height_1000mm: 25,               # kg test weight for 1.0m users
+      height_1200mm: 35,               # kg test weight for 1.2m users
+      height_1500mm: 65,               # kg test weight for 1.5m users
+      height_1800mm: 85                # kg test weight for 1.8m users
+    }.freeze
+
+    # Reinspection interval
+    REINSPECTION_INTERVAL_DAYS = 365  # days
+
+    # Anchor calculation constants from EN 14960-1:2019
+    # Line 450: Each anchor must withstand 1600N force
+    # Lines 441-442: Minimum 6 anchorage points required
+    # Lines 1194-1199: Cw=1.5, ρ=1.24 kg/m³, V=11.1 m/s
+    # Pre-calculated: 0.5 × 1.5 × 1.24 × 11.1² ≈ 114
+    ANCHOR_CALCULATION_CONSTANTS = {
+      area_coefficient: 114.0,     # Pre-calculated wind force coefficient
+      base_divisor: 1600.0,        # Force per anchor in Newtons (Line 450)
+      safety_factor: 1.5,          # Safety factor multiplier
+      minimum_anchors: 6           # Minimum required anchors (Lines 441-442)
+    }.freeze
+
+    # Slide safety thresholds
+    SLIDE_HEIGHT_THRESHOLDS = {
+      no_walls_required: 0.6,      # Under 600mm
+      basic_walls: 3.0,            # 600mm - 3000mm
+      enhanced_walls: 6.0,         # 3000mm - 6000mm
+      max_safe_height: 8.0         # Maximum recommended height
+    }.freeze
+
+    # Slide runout calculation constants (EN 14960:2019)
+    RUNOUT_CALCULATION_CONSTANTS = {
+      platform_height_ratio: 0.5, # 50% of platform height
+      minimum_runout_meters: 0.3,  # Absolute minimum 300mm (0.3m)
+      stop_wall_addition: 0.5      # 50cm addition when stop-wall fitted (Line 936)
+    }.freeze
+
+    # Wall height calculation constants (EN 14960:2019)
+    WALL_HEIGHT_CONSTANTS = {
+      enhanced_height_multiplier: 1.25  # 1.25× multiplier for enhanced walls
+    }.freeze
+
+    # EN 14960-1:2019 Section 4.3 (Lines 940-961) - Number of users
+    # Note: EN 14960 doesn't specify exact calculation formulas, only factors to consider:
+    # - Height of user (Line 946)
+    # - Size of playing area (Line 954)
+    # - Type of activity (Line 956)
+    # The calculation below is industry standard practice, not from EN 14960
+    AREA_DIVISOR = {
+      1000 => 1.0,   # 1 user per m² for 1.0m height
+      1200 => 1.33,  # 0.75 users per m² for 1.2m height
+      1500 => 1.66,  # 0.60 users per m² for 1.5m height
+      1800 => 2.0    # 0.5 users per m² for 1.8m height
+    }.freeze
+
+    # Material safety standards (EN 14960:2019 & EN 71-3)
+    MATERIAL_STANDARDS = {
+      fabric: {
+        min_tensile_strength: 1850,    # Newtons minimum
+        min_tear_strength: 350,        # Newtons minimum
+        fire_standard: "EN 71-3"       # Fire retardancy standard
+      },
+      thread: {
+        min_tensile_strength: 88      # Newtons minimum
+      },
+      rope: {
+        min_diameter: 18,              # mm minimum
+        max_diameter: 45,              # mm maximum
+        max_swing_percentage: 20       # % maximum swing
+      },
+      netting: {
+        max_vertical_mesh: 30,         # mm maximum for >1m height
+        max_roof_mesh: 8               # mm maximum
+      }
+    }.freeze
+  end
+end

data/lib/en14960/models/calculator_response.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module EN14960
+  # Data class for calculator responses
+  # Provides a consistent structure for all calculator results
+  class CalculatorResponse < Struct.new(:value, :value_suffix, :breakdown, keyword_init: true)
+    def initialize(value:, value_suffix: "", breakdown: [])
+      super
+    end
+
+    def to_h
+      {
+        value: value,
+        value_suffix: value_suffix,
+        breakdown: breakdown
+      }
+    end
+
+    alias_method :as_json, :to_h
+  end
+end

data/lib/en14960/validators/material_validator.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require_relative "../constants"
+
+module EN14960
+  module Validators
+    module MaterialValidator
+      extend self
+
+      def valid_rope_diameter?(diameter_mm)
+        # EN 14960:2019 - Rope diameter range prevents finger entrapment while
+        # ensuring adequate grip and structural strength
+        return false if diameter_mm.nil?
+
+        min_diameter = Constants::MATERIAL_STANDARDS[:rope][:min_diameter]
+        max_diameter = Constants::MATERIAL_STANDARDS[:rope][:max_diameter]
+        diameter_mm.between?(min_diameter, max_diameter)
+      end
+
+      def fabric_tensile_requirement
+        fabric_standards = Constants::MATERIAL_STANDARDS[:fabric]
+        "#{fabric_standards[:min_tensile_strength]} Newtons minimum"
+      end
+
+      def fabric_tear_requirement
+        fabric_standards = Constants::MATERIAL_STANDARDS[:fabric]
+        "#{fabric_standards[:min_tear_strength]} Newtons minimum"
+      end
+
+      # Additional validation methods
+      def valid_fabric_tensile_strength?(strength_n)
+        return false if strength_n.nil?
+        strength_n >= Constants::MATERIAL_STANDARDS[:fabric][:min_tensile_strength]
+      end
+
+      def valid_fabric_tear_strength?(strength_n)
+        return false if strength_n.nil?
+        strength_n >= Constants::MATERIAL_STANDARDS[:fabric][:min_tear_strength]
+      end
+
+      def valid_thread_tensile_strength?(strength_n)
+        return false if strength_n.nil?
+        strength_n >= Constants::MATERIAL_STANDARDS[:thread][:min_tensile_strength]
+      end
+
+      def valid_netting_mesh?(mesh_mm, is_roof: false)
+        return false if mesh_mm.nil?
+
+        max_mesh = is_roof ?
+          Constants::MATERIAL_STANDARDS[:netting][:max_roof_mesh] :
+          Constants::MATERIAL_STANDARDS[:netting][:max_vertical_mesh]
+
+        mesh_mm <= max_mesh
+      end
+    end
+  end
+end

data/lib/en14960/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module EN14960
+  VERSION = "0.1.0"
+end

data/lib/en14960.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require_relative "en14960/version"
+require_relative "en14960/models/calculator_response"
+require_relative "en14960/constants"
+require_relative "en14960/calculators/anchor_calculator"
+require_relative "en14960/calculators/slide_calculator"
+require_relative "en14960/calculators/user_capacity_calculator"
+require_relative "en14960/validators/material_validator"
+
+# EN14960 provides calculators and validators for BS EN 14960:2019
+# the safety standard for inflatable play equipment
+module EN14960
+  class Error < StandardError; end
+
+  # Public API methods for easy access to calculators
+  class << self
+    # Calculate required anchors for inflatable play equipment
+    # @param length [Float] Length in meters
+    # @param width [Float] Width in meters
+    # @param height [Float] Height in meters
+    # @return [CalculatorResponse] Response with anchor count and breakdown
+    def calculate_anchors(length:, width:, height:)
+      Calculators::AnchorCalculator.calculate(length: length, width: width, height: height)
+    end
+
+    # Calculate required slide runout distance
+    # @param platform_height [Float] Platform height in meters
+    # @param has_stop_wall [Boolean] Whether a stop wall is fitted
+    # @return [CalculatorResponse] Response with runout distance and breakdown
+    def calculate_slide_runout(platform_height, has_stop_wall: false)
+      Calculators::SlideCalculator.calculate_required_runout(platform_height, has_stop_wall: has_stop_wall)
+    end
+
+    # Calculate wall height requirements for slides
+    # @param platform_height [Float] Platform height in meters
+    # @param user_height [Float] Maximum user height in meters
+    # @param has_permanent_roof [Boolean] Whether unit has permanent roof
+    # @return [CalculatorResponse] Response with wall height requirements
+    def calculate_wall_height(platform_height, user_height, has_permanent_roof = nil)
+      Calculators::SlideCalculator.calculate_wall_height_requirements(
+        platform_height,
+        user_height,
+        has_permanent_roof
+      )
+    end
+
+    # Calculate user capacity based on play area
+    # @param length [Float] Length in meters
+    # @param width [Float] Width in meters
+    # @param max_user_height [Float, nil] Maximum allowed user height
+    # @param negative_adjustment_area [Float] Area to subtract for obstacles
+    # @return [CalculatorResponse] Response with capacity by user height
+    def calculate_user_capacity(length, width, max_user_height = nil, negative_adjustment_area = 0)
+      Calculators::UserCapacityCalculator.calculate(
+        length,
+        width,
+        max_user_height,
+        negative_adjustment_area
+      )
+    end
+
+    # Check if rope diameter meets safety requirements
+    # @param diameter_mm [Float] Rope diameter in millimeters
+    # @return [Boolean] Whether diameter is within safe range
+    def valid_rope_diameter?(diameter_mm)
+      Validators::MaterialValidator.valid_rope_diameter?(diameter_mm)
+    end
+
+    # Get height categories defined by EN 14960:2019
+    # @return [Hash] Height categories with labels and requirements
+    def height_categories
+      Constants::HEIGHT_CATEGORIES
+    end
+
+    # Get material standards defined by EN 14960:2019
+    # @return [Hash] Material requirements for fabrics, threads, ropes, and netting
+    def material_standards
+      Constants::MATERIAL_STANDARDS
+    end
+  end
+end

metadata

@@ -0,0 +1,135 @@
+--- !ruby/object:Gem::Specification
+name: en14960
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Chobble.com
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2025-07-28 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: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.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'
+- !ruby/object:Gem::Dependency
+  name: standard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.21'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.21'
+description: A Ruby gem providing calculators and validators for BS EN 14960:2019
+  - the safety standard for inflatable play equipment. Includes calculations for anchoring
+  requirements, slide safety, user capacity, and material specifications.
+email:
+- hello@chobble.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- ".rspec_status"
+- CHANGELOG.md
+- LICENSE
+- LICENSE.txt
+- README.md
+- Rakefile
+- en14960.gemspec
+- lib/en14960.rb
+- lib/en14960/calculators/anchor_calculator.rb
+- lib/en14960/calculators/slide_calculator.rb
+- lib/en14960/calculators/user_capacity_calculator.rb
+- lib/en14960/constants.rb
+- lib/en14960/models/calculator_response.rb
+- lib/en14960/validators/material_validator.rb
+- lib/en14960/version.rb
+homepage: https://github.com/chobbledotcom/en14960
+licenses:
+- AGPL-3.0-or-later
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/chobbledotcom/en14960
+  source_code_uri: https://github.com/chobbledotcom/en14960
+  changelog_uri: https://github.com/chobbledotcom/en14960/blob/main/CHANGELOG.md
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.19
+signing_key:
+specification_version: 4
+summary: BS EN 14960:2019 safety standard calculators for inflatable play equipment
+test_files: []