en14960 0.2.3 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fedeb5f36f6f2e3f2ac74b39a18ad7ead640a520917d4681abe23403a477de7f
-  data.tar.gz: 62b331bcad579a79b39039ba9a4fc8a3f8a15bef7bdf785e4e336434253e0112
+  metadata.gz: fda15828cb9885998e0aa06bb8cff2621e0dd3cbdd5ed5a717a102988f04ecb9
+  data.tar.gz: c9d0d2184b17fad322ca86a7ac19e978c7918ef1d2d412881072feb1ee995491
 SHA512:
-  metadata.gz: c0195422eb49e92201c750a030003620844f798426143b4ed8b58d80fd1ff277ae8e8d735bb2edea76ebf146b24669adf67a0750ebc1f81f7683e5de33cd782a
-  data.tar.gz: 8d0892f9d9c7522c43d4bfb8c7b16f80e947e8a36ea75b3126fcdf7e06470b3ecd6d6067a6515eec337fa739a2d98f9b218d3ad23b2ebae17a044494735ce223
+  metadata.gz: bf879fdb5e594c2078c14959a2d2c1040afcefe051edfa42156b623fc0d66583ee48c8baf2ca81f91894cacbfee840deb4c7f4863cceb9260c927305a9332ed8
+  data.tar.gz: 73699ce3ae6651564d4641b6746e8819b57c3a0c8938990bd11b4783156bfa5f0fd339281eb00518d3abe23f2284b56f1a61de11612b6692e0d2b32fea3ffa1c

data/CHANGELOG.md

@@ -5,6 +5,20 @@ 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).
 
+## [Unreleased]
+
+### Added
+- Full Sorbet type signatures for all public APIs
+- Runtime type checking with sorbet-runtime
+- Strongly typed CalculatorResponse using T::Struct
+- Type safety documentation in README
+- Test file demonstrating type-safe usage
+
+### Changed
+- CalculatorResponse now extends T::Struct instead of using Data.define
+- All modules and classes now include Sorbet type annotations
+- Improved type safety for method parameters and return values
+
 ## [0.1.0] - 2025-01-28
 
 ### Added

data/README.md

@@ -10,6 +10,7 @@ A Ruby gem providing calculators and validators for BS EN 14960:2019 - the Briti
 - **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
+- **Type Safety**: Full Sorbet type signatures for all public APIs ensuring type safety and better IDE support
 
 ## Installation
 
@@ -170,6 +171,35 @@ EN14960::Constants::MATERIAL_STANDARDS
 EN14960::Constants::ANCHOR_CALCULATION_CONSTANTS
 ```
 
+## Type Safety with Sorbet
+
+This gem includes full Sorbet type signatures for improved type safety and IDE support:
+
+```ruby
+# All public methods have type signatures
+sig { params(length: T.any(Float, Integer), width: T.any(Float, Integer), height: T.any(Float, Integer)).returns(CalculatorResponse) }
+def calculate_anchors(length:, width:, height:)
+  # ...
+end
+
+# Return types are strongly typed
+result = EN14960.calculate_anchors(length: 10, width: 8, height: 3)
+result.value        # Integer
+result.value_suffix # String
+result.breakdown    # Array[Array[String]]
+```
+
+The gem uses `T::Struct` for data classes providing runtime type checking:
+
+```ruby
+# CalculatorResponse is a typed struct
+class CalculatorResponse < T::Struct
+  const :value, T.any(Integer, Float, String, T::Array[T.untyped])
+  const :value_suffix, String, default: ""
+  const :breakdown, T::Array[T::Array[String]], default: []
+end
+```
+
 ## EN 14960:2019 Compliance
 
 This gem implements calculations based on BS EN 14960:2019, including:

data/lib/en14960/api.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+# typed: strict
+
+require "sorbet-runtime"
+
+module EN14960
+  module API
+    extend T::Sig
+
+    class << self
+      extend T::Sig
+
+      sig { params(length: Float, width: Float, height: Float).returns(CalculatorResponse) }
+      def calculate_anchors(length:, width:, height:)
+        Calculators::AnchorCalculator.calculate(length: length, width: width, height: height)
+      end
+
+      sig { params(platform_height: Float, has_stop_wall: T::Boolean).returns(CalculatorResponse) }
+      def calculate_slide_runout(platform_height, has_stop_wall: false)
+        Calculators::SlideCalculator.calculate_required_runout(platform_height, has_stop_wall: has_stop_wall)
+      end
+
+      sig { params(platform_height: Float, user_height: Float, has_permanent_roof: T.nilable(T::Boolean)).returns(CalculatorResponse) }
+      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
+
+      sig { params(length: Float, width: Float, max_user_height: T.nilable(Float), negative_adjustment_area: Float).returns(CalculatorResponse) }
+      def calculate_user_capacity(length, width, max_user_height = nil, negative_adjustment_area = 0.0)
+        Calculators::UserCapacityCalculator.calculate(
+          length,
+          width,
+          max_user_height,
+          negative_adjustment_area
+        )
+      end
+
+      sig { params(diameter_mm: Float).returns(T::Boolean) }
+      def valid_rope_diameter?(diameter_mm)
+        Validators::MaterialValidator.valid_rope_diameter?(diameter_mm)
+      end
+
+      sig { returns(T::Hash[Symbol, T.untyped]) }
+      def height_categories
+        Constants::HEIGHT_CATEGORIES
+      end
+
+      sig { returns(T::Hash[Symbol, T.untyped]) }
+      def material_standards
+        Constants::MATERIAL_STANDARDS
+      end
+
+      sig {
+        params(
+          unit_length: Float,
+          unit_width: Float,
+          play_area_length: Float,
+          play_area_width: Float,
+          negative_adjustment_area: Float
+        ).returns(T::Hash[Symbol, T.untyped])
+      }
+      def validate_play_area(
+        unit_length:,
+        unit_width:,
+        play_area_length:,
+        play_area_width:,
+        negative_adjustment_area:
+      )
+        Validators::PlayAreaValidator.validate(
+          unit_length: unit_length,
+          unit_width: unit_width,
+          play_area_length: play_area_length,
+          play_area_width: play_area_width,
+          negative_adjustment_area: negative_adjustment_area
+        )
+      end
+    end
+  end
+end

data/lib/en14960/calculators/anchor_calculator.rb

@@ -1,19 +1,23 @@
 # frozen_string_literal: true
+# typed: strict
 
+require "sorbet-runtime"
 require_relative "../constants"
 require_relative "../models/calculator_response"
 
 module EN14960
   module Calculators
     module AnchorCalculator
+      extend T::Sig
       extend self
 
+      sig { params(area_m2: Float).returns(Integer) }
       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
+        return 0 if area_m2 <= 0
 
         # Pre-calculated: 0.5 × 1.5 × 1.24 × 11.1² ≈ 114
         area_coeff = Constants::ANCHOR_CALCULATION_CONSTANTS[:area_coefficient]
@@ -23,6 +27,7 @@ module EN14960
         ((area_m2.to_f * area_coeff * safety_mult) / base_div).ceil
       end
 
+      sig { params(length: Float, width: Float, height: Float).returns(CalculatorResponse) }
       def calculate(length:, width:, height:)
         # EN 14960-1:2019 Lines 1175-1210 (Annex A) - Calculate exposed surface areas
         front_area = (width * height).round(1)
@@ -67,6 +72,7 @@ module EN14960
         )
       end
 
+      sig { returns(String) }
       def anchor_formula_text
         area_coeff = Constants::ANCHOR_CALCULATION_CONSTANTS[:area_coefficient]
         base_div = Constants::ANCHOR_CALCULATION_CONSTANTS[:base_divisor]
@@ -74,6 +80,7 @@ module EN14960
         "((Area × #{area_coeff} × #{safety_fact}) ÷ #{base_div})"
       end
 
+      sig { returns(String) }
       def anchor_calculation_description
         "Anchors must be calculated based on the play area to ensure adequate ground restraint for wind loads."
       end

data/lib/en14960/calculators/slide_calculator.rb

@@ -1,16 +1,20 @@
 # frozen_string_literal: true
+# typed: strict
 
+require "sorbet-runtime"
 require_relative "../constants"
 require_relative "../models/calculator_response"
 
 module EN14960
   module Calculators
     module SlideCalculator
+      extend T::Sig
       extend self
 
       # Simple calculation method that returns just the numeric value
+      sig { params(platform_height: Float, has_stop_wall: T::Boolean).returns(Float) }
       def calculate_runout_value(platform_height, has_stop_wall: false)
-        return 0 if platform_height.nil? || platform_height <= 0
+        return 0.0 if platform_height <= 0
 
         height_ratio = Constants::RUNOUT_CALCULATION_CONSTANTS[:platform_height_ratio]
         minimum_runout = Constants::RUNOUT_CALCULATION_CONSTANTS[:minimum_runout_meters]
@@ -22,13 +26,14 @@ module EN14960
         has_stop_wall ? base_runout + stop_wall_add : base_runout
       end
 
+      sig { params(platform_height: Float, has_stop_wall: T::Boolean).returns(CalculatorResponse) }
       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
+        return CalculatorResponse.new(value: 0, value_suffix: "m", breakdown: []) if platform_height <= 0
 
         # Get constants
         height_ratio = Constants::RUNOUT_CALCULATION_CONSTANTS[:platform_height_ratio]
@@ -59,13 +64,13 @@ module EN14960
         )
       end
 
+      sig { params(platform_height: Float, user_height: Float, containing_wall_height: Float, has_permanent_roof: T::Boolean).returns(T::Boolean) }
       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
@@ -86,16 +91,17 @@ module EN14960
         end
       end
 
+      sig { params(runout_length: Float, platform_height: Float, has_stop_wall: T::Boolean).returns(T::Boolean) }
       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
 
+      sig { returns(String) }
       def slide_runout_formula_text
         ratio_constant = Constants::RUNOUT_CALCULATION_CONSTANTS[:platform_height_ratio]
         height_ratio = (ratio_constant * 100).to_i
@@ -104,9 +110,10 @@ module EN14960
         "#{height_ratio}% of platform height, minimum #{min_runout}mm"
       end
 
+      sig { params(platform_height: Float, user_height: Float, has_permanent_roof: T.nilable(T::Boolean)).returns(CalculatorResponse) }
       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
+        return CalculatorResponse.new(value: 0, value_suffix: "m", breakdown: []) if 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)
@@ -121,6 +128,7 @@ module EN14960
         )
       end
 
+      sig { params(platform_height: Float, user_height: Float, has_permanent_roof: T.nilable(T::Boolean)).returns(T::Hash[Symbol, T.untyped]) }
       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]
@@ -204,19 +212,22 @@ module EN14960
         end
       end
 
+      sig { params(platform_height: Float).returns(T::Boolean) }
       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
+        platform_height > threshold
       end
 
+      sig { returns(String) }
       def wall_height_requirement
         multiplier = Constants::WALL_HEIGHT_CONSTANTS[:enhanced_height_multiplier]
         "Containing walls required #{multiplier} times user height"
       end
 
+      sig { returns(T::Hash[Symbol, T::Hash[Symbol, String]]) }
       def slide_calculations
         # EN 14960:2019 - Comprehensive slide safety requirements
         {
@@ -243,6 +254,7 @@ module EN14960
 
       private
 
+      sig { params(platform_height: Float, user_height: Float).returns(Float) }
       def extract_required_wall_height(platform_height, user_height)
         thresholds = Constants::SLIDE_HEIGHT_THRESHOLDS
         enhanced_multiplier = Constants::WALL_HEIGHT_CONSTANTS[:enhanced_height_multiplier]

data/lib/en14960/calculators/user_capacity_calculator.rb

@@ -1,19 +1,23 @@
 # frozen_string_literal: true
+# typed: strict
 
+require "sorbet-runtime"
 require_relative "../constants"
 require_relative "../models/calculator_response"
 
 module EN14960
   module Calculators
     module UserCapacityCalculator
+      extend T::Sig
       extend self
 
+      sig { params(length: Float, width: Float, max_user_height: T.nilable(Float), negative_adjustment_area: Float).returns(CalculatorResponse) }
       def calculate(length, width, max_user_height = nil, negative_adjustment_area = 0)
-        return default_result if length.nil? || width.nil?
+        return default_result if length <= 0 || width <= 0
 
         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)
+        usable_area = [total_area - negative_adjustment_area, 0.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)
@@ -27,6 +31,7 @@ module EN14960
 
       private
 
+      sig { params(length: Float, width: Float, total_area: Float, negative_adjustment_area: Float, usable_area: Float).returns(T::Array[T::Array[String]]) }
       def build_breakdown(length, width, total_area, negative_adjustment_area, usable_area)
         breakdown = []
         formatted_length = format_number(length)
@@ -47,6 +52,7 @@ module EN14960
         breakdown
       end
 
+      sig { params(usable_area: Float, max_user_height: T.nilable(Float), breakdown: T::Array[T::Array[String]]).returns(T::Hash[Symbol, Integer]) }
       def calculate_capacities(usable_area, max_user_height, breakdown)
         capacities = {}
 
@@ -71,6 +77,7 @@ module EN14960
         capacities
       end
 
+      sig { returns(CalculatorResponse) }
       def default_result
         CalculatorResponse.new(
           value: default_capacity,
@@ -79,6 +86,7 @@ module EN14960
         )
       end
 
+      sig { returns(T::Hash[Symbol, Integer]) }
       def default_capacity
         {
           users_1000mm: 0,
@@ -88,6 +96,7 @@ module EN14960
         }
       end
 
+      sig { params(number: Float).returns(String) }
       def format_number(number)
         # Remove trailing zeros after decimal point
         formatted = sprintf("%.1f", number)

data/lib/en14960/constants.rb

@@ -1,7 +1,11 @@
 # frozen_string_literal: true
+# typed: strict
+
+require "sorbet-runtime"
 
 module EN14960
   module Constants
+    extend T::Sig
     # Height category constants based on EN 14960:2019
     HEIGHT_CATEGORIES = {
       1000 => {label: "1.0m (Young children)", max_users: :calculate_by_area},

data/lib/en14960/models/calculator_response.rb

@@ -1,13 +1,19 @@
 # frozen_string_literal: true
+# typed: strict
+
+require "sorbet-runtime"
 
 module EN14960
   # Data class for calculator responses
   # Provides a consistent structure for all calculator results
-  CalculatorResponse = Data.define(:value, :value_suffix, :breakdown) do
-    def initialize(value:, value_suffix: "", breakdown: [])
-      super
-    end
+  class CalculatorResponse < T::Struct
+    extend T::Sig
 
+    const :value, T.any(Integer, Float, String, T::Hash[Symbol, Integer], T::Array[T.untyped])
+    const :value_suffix, String, default: ""
+    const :breakdown, T::Array[T::Array[String]], default: []
+
+    sig { returns(T::Hash[Symbol, T.untyped]) }
     def to_h
       {
         value: value,
@@ -16,6 +22,9 @@ module EN14960
       }
     end
 
-    alias_method :as_json, :to_h
+    sig { returns(T::Hash[Symbol, T.untyped]) }
+    def as_json
+      to_h
+    end
   end
 end

data/lib/en14960/source_code.rb

@@ -1,17 +1,29 @@
 # frozen_string_literal: true
+# typed: strict
+
+require "sorbet-runtime"
 
 module EN14960
   module SourceCode
+    extend T::Sig
+
+    sig { params(method_name: Symbol, module_name: Module, additional_methods: T::Array[Symbol]).returns(String) }
     def self.get_method_source(method_name, module_name, additional_methods = [])
-      method_obj = module_name.method(method_name)
-      source_location = method_obj.source_location
+      base_dir = File.expand_path("..", __FILE__)
+
+      ruby_files = Dir.glob(File.join(base_dir, "**", "*.rb"))
 
-      return "Source code not available" unless source_location
+      file_path, line_number = find_method_in_files(ruby_files, method_name)
 
-      file_path, line_number = source_location
-      return "Source file not found" unless File.exist?(file_path)
+      unless file_path
+        raise StandardError, "Source code not available for method: #{method_name}"
+      end
+
+      unless File.exist?(file_path)
+        raise StandardError, "Source file not found: #{file_path}"
+      end
 
-      lines = File.readlines(file_path)
+      lines = File.readlines(file_path, encoding: "UTF-8")
 
       constants_code = ""
       module_constants = get_module_constants(module_name, method_name)
@@ -27,10 +39,9 @@ module EN14960
 
       additional_methods.each do |additional_method|
         if module_name.respond_to?(additional_method)
-          additional_obj = module_name.method(additional_method)
-          additional_location = additional_obj.source_location
-          if additional_location && additional_location[0] == file_path
-            additional_lines = extract_method_lines(lines, additional_location[1] - 1, additional_method)
+          method_line_idx = lines.index { |line| line.strip =~ /^def\s+(self\.)?#{Regexp.escape(additional_method.to_s)}(\(|$|\s)/ }
+          if method_line_idx
+            additional_lines = extract_method_lines(lines, method_line_idx, additional_method)
             methods_code += strip_consistent_indentation(additional_lines.join("")) + "\n\n"
           end
         end
@@ -50,12 +61,31 @@ module EN14960
       output
     end
 
+    sig { params(files: T::Array[String], method_name: Symbol).returns(T.nilable([String, Integer])) }
+    private_class_method def self.find_method_in_files(files, method_name)
+      files.each do |path|
+        if File.exist?(path)
+          content = File.read(path, encoding: "UTF-8")
+          if content.match?(/def\s+(self\.)?#{Regexp.escape(method_name.to_s)}(\(|\s|$)/)
+            lines = File.readlines(path, encoding: "UTF-8")
+            line_idx = lines.index { |line| line.strip =~ /^def\s+(self\.)?#{Regexp.escape(method_name.to_s)}(\(|$|\s)/ }
+            if line_idx
+              return [path, line_idx + 1]
+            end
+          end
+        end
+      end
+      nil
+    end
+
+    sig { params(module_name: Module, method_name: Symbol).returns(T::Array[Symbol]) }
     private_class_method def self.get_module_constants(module_name, method_name)
       module_name.constants.select do |const_name|
         module_name.const_get(const_name).is_a?(Hash)
       end
     end
 
+    sig { params(lines: T::Array[String], constant_name: Symbol).returns(String) }
     private_class_method def self.extract_constant_definition(lines, constant_name)
       constant_lines = []
       in_constant = false
@@ -82,6 +112,7 @@ module EN14960
       constant_lines.join("")
     end
 
+    sig { params(lines: T::Array[String], start_line: Integer, method_name: Symbol).returns(T::Array[String]) }
     private_class_method def self.extract_method_lines(lines, start_line, method_name)
       method_lines = []
       current_line = start_line
@@ -89,7 +120,7 @@ module EN14960
 
       while current_line < lines.length
         line = lines[current_line]
-        if line.strip.start_with?("def #{method_name}")
+        if /^def\s+(self\.)?#{Regexp.escape(method_name.to_s)}(\(|$|\s)/.match?(line.strip)
           indent_level = line.index("def")
           method_lines << line
           current_line += 1
@@ -104,7 +135,7 @@ module EN14960
         line = lines[current_line]
         method_lines << line
 
-        if line.strip == "end" && (line.index(/\S/) || 0) <= indent_level
+        if line.strip == "end" && indent_level && (line.index(/\S/) || 0) <= indent_level
           break
         end
 
@@ -114,6 +145,7 @@ module EN14960
       method_lines
     end
 
+    sig { params(source_code: String).returns(String) }
     private_class_method def self.strip_consistent_indentation(source_code)
       lines = source_code.split("\n")
 

data/lib/en14960/validators/material_validator.rb

@@ -1,51 +1,55 @@
 # frozen_string_literal: true
+# typed: strict
 
+require "sorbet-runtime"
 require_relative "../constants"
 
 module EN14960
   module Validators
     module MaterialValidator
+      extend T::Sig
       extend self
 
+      sig { params(diameter_mm: Float).returns(T::Boolean) }
       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
 
+      sig { returns(String) }
       def fabric_tensile_requirement
         fabric_standards = Constants::MATERIAL_STANDARDS[:fabric]
         "#{fabric_standards[:min_tensile_strength]} Newtons minimum"
       end
 
+      sig { returns(String) }
       def fabric_tear_requirement
         fabric_standards = Constants::MATERIAL_STANDARDS[:fabric]
         "#{fabric_standards[:min_tear_strength]} Newtons minimum"
       end
 
       # Additional validation methods
+      sig { params(strength_n: Float).returns(T::Boolean) }
       def valid_fabric_tensile_strength?(strength_n)
-        return false if strength_n.nil?
         strength_n >= Constants::MATERIAL_STANDARDS[:fabric][:min_tensile_strength]
       end
 
+      sig { params(strength_n: Float).returns(T::Boolean) }
       def valid_fabric_tear_strength?(strength_n)
-        return false if strength_n.nil?
         strength_n >= Constants::MATERIAL_STANDARDS[:fabric][:min_tear_strength]
       end
 
+      sig { params(strength_n: Float).returns(T::Boolean) }
       def valid_thread_tensile_strength?(strength_n)
-        return false if strength_n.nil?
         strength_n >= Constants::MATERIAL_STANDARDS[:thread][:min_tensile_strength]
       end
 
+      sig { params(mesh_mm: Float, is_roof: T::Boolean).returns(T::Boolean) }
       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]

data/lib/en14960/validators/play_area_validator.rb

@@ -1,10 +1,23 @@
 # frozen_string_literal: true
+# typed: strict
+
+require "sorbet-runtime"
 
 module EN14960
   module Validators
     module PlayAreaValidator
+      extend T::Sig
       extend self
 
+      sig {
+        params(
+          unit_length: Float,
+          unit_width: Float,
+          play_area_length: Float,
+          play_area_width: Float,
+          negative_adjustment_area: Float
+        ).returns(T::Hash[Symbol, T.untyped])
+      }
       def validate(
         unit_length:,
         unit_width:,
@@ -14,17 +27,7 @@ module EN14960
       )
         errors = []
 
-        if [
-          unit_length,
-          unit_width,
-          play_area_length,
-          play_area_width,
-          negative_adjustment_area
-        ].any?(&:nil?)
-          errors << "All measurements must be provided"
-        end
-
-        return build_response(false, errors) unless errors.empty?
+        # All parameters are required, no nil checks needed
 
         unit_length = unit_length.to_f
         unit_width = unit_width.to_f
@@ -61,6 +64,7 @@ module EN14960
 
       private
 
+      sig { params(valid: T::Boolean, errors: T::Array[String], measurements: T::Hash[Symbol, Float]).returns(T::Hash[Symbol, T.untyped]) }
       def build_response(valid, errors, measurements = {})
         {
           valid: valid,

data/lib/en14960/version.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
+# typed: strict
 
 module EN14960
-  VERSION = "0.2.3"
+  VERSION = "0.4.0"
 end

data/lib/en14960.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
+# typed: strict
 
+require "sorbet-runtime"
 require_relative "en14960/version"
 require_relative "en14960/models/calculator_response"
 require_relative "en14960/constants"
@@ -13,15 +15,19 @@ require_relative "en14960/source_code"
 # EN14960 provides calculators and validators for BS EN 14960:2019
 # the safety standard for inflatable play equipment
 module EN14960
+  extend T::Sig
+
   class Error < StandardError; end
 
   # Public API methods for easy access to calculators
   class << self
+    extend T::Sig
     # 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
+    sig { params(length: Float, width: Float, height: Float).returns(CalculatorResponse) }
     def calculate_anchors(length:, width:, height:)
       Calculators::AnchorCalculator.calculate(length: length, width: width, height: height)
     end
@@ -30,6 +36,7 @@ module EN14960
     # @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
+    sig { params(platform_height: Float, has_stop_wall: T::Boolean).returns(CalculatorResponse) }
     def calculate_slide_runout(platform_height, has_stop_wall: false)
       Calculators::SlideCalculator.calculate_required_runout(platform_height, has_stop_wall: has_stop_wall)
     end
@@ -39,6 +46,7 @@ module EN14960
     # @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
+    sig { params(platform_height: Float, user_height: Float, has_permanent_roof: T.nilable(T::Boolean)).returns(CalculatorResponse) }
     def calculate_wall_height(platform_height, user_height, has_permanent_roof = nil)
       Calculators::SlideCalculator.calculate_wall_height_requirements(
         platform_height,
@@ -53,7 +61,8 @@ module EN14960
     # @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)
+    sig { params(length: Float, width: Float, max_user_height: T.nilable(Float), negative_adjustment_area: Float).returns(CalculatorResponse) }
+    def calculate_user_capacity(length, width, max_user_height = nil, negative_adjustment_area = 0.0)
       Calculators::UserCapacityCalculator.calculate(
         length,
         width,
@@ -65,18 +74,21 @@ module EN14960
     # Check if rope diameter meets safety requirements
     # @param diameter_mm [Float] Rope diameter in millimeters
     # @return [Boolean] Whether diameter is within safe range
+    sig { params(diameter_mm: Float).returns(T::Boolean) }
     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
+    sig { returns(T::Hash[Symbol, T.untyped]) }
     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
+    sig { returns(T::Hash[Symbol, T.untyped]) }
     def material_standards
       Constants::MATERIAL_STANDARDS
     end
@@ -88,6 +100,15 @@ module EN14960
     # @param play_area_width [Float] Play area width
     # @param negative_adjustment_area [Float] Negative adjustment area
     # @return [Hash] Validation result with errors and measurements
+    sig {
+      params(
+        unit_length: Float,
+        unit_width: Float,
+        play_area_length: Float,
+        play_area_width: Float,
+        negative_adjustment_area: Float
+      ).returns(T::Hash[Symbol, T.untyped])
+    }
     def validate_play_area(
       unit_length:,
       unit_width:,

data/sorbet/config

@@ -0,0 +1,6 @@
+--dir
+.
+--ignore
+vendor/
+--ignore
+spec/

data/terragon-setup.sh

@@ -0,0 +1,34 @@
+#\!/bin/bash
+set -euo pipefail
+
+# Terragon Labs Rails Setup Script
+# Optimized for Ubuntu 24.04 - runs on every sandbox start
+
+# Skip if already set up (optimization for repeated runs)
+if [ -f ".terragon-setup-complete" ] && [ -z "${FORCE_SETUP:-}" ]; then
+    echo "Setup already complete. Run with FORCE_SETUP=1 to re-run."
+    exit 0
+fi
+
+echo "Installing Ruby and dependencies..."
+sudo apt-get update -qq
+sudo apt-get install -y ruby-full ruby-bundler build-essential libsqlite3-dev libyaml-dev imagemagick
+
+echo "Installing bundler gem..."
+sudo gem install bundler
+
+# Setup ImageMagick symlinks if needed
+for cmd in identify mogrify convert; do
+    if \! command -v $cmd &> /dev/null; then
+        BINARY=$(ls /usr/bin/${cmd}-* 2>/dev/null | grep -E "${cmd}-im[0-9]" | head -1)
+        if [ -n "$BINARY" ]; then
+            sudo ln -sf "$BINARY" "/usr/local/bin/$cmd" 2>/dev/null || true
+        fi
+    fi
+done
+
+# Mark setup as complete
+touch .terragon-setup-complete
+
+echo "Rails setup complete\!"
+

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: en14960
 version: !ruby/object:Gem::Version
-  version: 0.2.3
+  version: 0.4.0
 platform: ruby
 authors:
 - Chobble.com
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-08-12 00:00:00.000000000 Z
+date: 2025-08-16 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: sorbet-runtime
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.5'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -80,6 +94,34 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.21'
+- !ruby/object:Gem::Dependency
+  name: sorbet
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.5'
+- !ruby/object:Gem::Dependency
+  name: tapioca
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.16'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.16'
 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.
@@ -91,6 +133,7 @@ extra_rdoc_files: []
 files:
 - ".envrc"
 - ".rspec"
+- ".terragon-setup-complete"
 - CHANGELOG.md
 - LICENSE
 - LICENSE.txt
@@ -99,6 +142,7 @@ files:
 - flake.lock
 - flake.nix
 - lib/en14960.rb
+- lib/en14960/api.rb
 - lib/en14960/calculators/anchor_calculator.rb
 - lib/en14960/calculators/slide_calculator.rb
 - lib/en14960/calculators/user_capacity_calculator.rb
@@ -108,6 +152,8 @@ files:
 - lib/en14960/validators/material_validator.rb
 - lib/en14960/validators/play_area_validator.rb
 - lib/en14960/version.rb
+- sorbet/config
+- terragon-setup.sh
 homepage: https://github.com/chobbledotcom/en14960
 licenses:
 - AGPL-3.0-or-later