ruby2d 0.12.1 → 1.0.0

data/lib/ruby2d/gamepad.rb

@@ -0,0 +1,323 @@
+# Ruby2D::Gamepad
+
+module Ruby2D
+  # A connected gamepad. Lives from connect to disconnect; reconnects produce
+  # a new object. Identity-based equality (default Ruby behavior) makes
+  # `Gamepad` instances stable hash keys for per-pad state.
+  #
+  # Disconnected pads remain safe to poll: `held?` etc. return `false`,
+  # `axis` returns `0.0`, and feedback methods return `false` silently.
+  class Gamepad
+    # SDL3 enum values for symbol → integer translation. These mirror the
+    # `R2D_BUTTON_*` and `R2D_AXIS_*` constants in `ruby2d.h`. The C side
+    # already speaks symbols for events; these are only needed for capability
+    # queries that go from Ruby through to SDL.
+    BUTTON_ENUM = {
+      south:           0,
+      east:            1,
+      west:            2,
+      north:           3,
+      back:            4,
+      guide:           5,
+      start:           6,
+      left_stick:      7,
+      right_stick:     8,
+      left_shoulder:   9,
+      right_shoulder:  10,
+      dpad_up:         11,
+      dpad_down:       12,
+      dpad_left:       13,
+      dpad_right:      14,
+      misc1:           15,
+      paddle1:         16,
+      paddle2:         17,
+      paddle3:         18,
+      paddle4:         19,
+      touchpad:        20,
+      misc2:           21,
+      misc3:           22,
+      misc4:           23,
+      misc5:           24,
+      misc6:           25
+    }.freeze
+
+    AXIS_ENUM = {
+      left_x:        0,
+      left_y:        1,
+      right_x:       2,
+      right_y:       3,
+      left_trigger:  4,
+      right_trigger: 5
+    }.freeze
+
+    # Sticks only — triggers (0.0..1.0) are exempt because they rest at zero
+    # and rarely drift. 0.05 should cover typical worst-case stick drift.
+    DEFAULT_DEAD_ZONE = 0.05
+
+    TRIGGER_AXES = %i[left_trigger right_trigger].freeze
+
+    # Ordered list of axis names. `axes` always returns the full hash so the
+    # shape is stable.
+    AXIS_NAMES = AXIS_ENUM.keys.freeze
+
+    attr_reader :id, :name, :type
+    attr_accessor :dead_zone
+
+    def initialize(window, id, name)
+      @window = window
+      @id = id
+      @name = name || ''
+      @connected = true
+      @dead_zone = DEFAULT_DEAD_ZONE
+
+      # Cached per-connection metadata. `type` and capabilities don't change
+      # while the pad is connected, so we read them once and avoid the SDL
+      # round-trip on every call.
+      @type = Ext.window_gamepad_type(window, id)
+      caps = Ext.window_gamepad_caps(window, id)
+      @cap_rumble          = caps & 0x1 != 0
+      @cap_rumble_triggers = caps & 0x2 != 0
+      @cap_led             = caps & 0x4 != 0
+
+      # Per-button and per-axis presence is also cached at connect — one SDL
+      # call per known enum, then `has?(:button, name)` / `has?(:axis, name)`
+      # are pure hash reads. Cheap (~27 calls total) and matches the
+      # "capability checks are cached at connect time" rule in USAGE.md.
+      @btn_present  = BUTTON_ENUM.each_with_object({}) do |(sym, enum), h|
+        h[sym] = Ext.window_gamepad_has_button(window, id, enum)
+      end
+      @axis_present = AXIS_ENUM.each_with_object({}) do |(sym, enum), h|
+        h[sym] = Ext.window_gamepad_has_axis(window, id, enum)
+      end
+
+      # Frame-scoped event sets. Pressed/released/axes_moved are cleared by
+      # `_clear_frame_state`; held is also cleared and refilled each frame
+      # from the C-side held loop.
+      @buttons_down  = []
+      @buttons_up    = []
+      @buttons_held  = []
+      @axes_moved    = []
+
+      # Sticky axis values populated by motion events.
+      @axis_values = {}
+      AXIS_NAMES.each { |a| @axis_values[a] = 0.0 }
+      @raw_axis_values = @axis_values.dup
+    end
+
+    def connected? = @connected
+
+    # Capability check. Forms:
+    #   pad.has?(:rumble)
+    #   pad.has?(:rumble_triggers)
+    #   pad.has?(:led)
+    #   pad.has?(:button, :paddle1)
+    #   pad.has?(:axis, :left_trigger)
+    def has?(capability, name = nil)
+      return false unless @connected
+
+      case capability
+      when :rumble           then @cap_rumble
+      when :rumble_triggers  then @cap_rumble_triggers
+      when :led              then @cap_led
+      when :button           then @btn_present[name]  || false
+      when :axis             then @axis_present[name] || false
+      else                        false
+      end
+    end
+
+    # Battery — live query, since charge level changes during play. Returns
+    # one of `:wired`, `:full`, `:medium`, `:low`, `:empty`, or `nil` when
+    # SDL can't determine the state.
+    def battery
+      return nil unless @connected
+
+      state, percent = Ext.window_gamepad_battery(@window, @id)
+      case state
+      when :wired then :wired
+      when :on_battery
+        case percent
+        when -1 then :medium  # plugged into a battery slot but no level reported
+        when 0..9 then :empty
+        when 10..29 then :low
+        when 30..74 then :medium
+        else :full
+        end
+      end
+    end
+
+    # Polling — currently held / current axis position.
+    def held?(button) = @buttons_held.include?(button)
+
+    def axis(name, raw: false)
+      return 0.0 unless AXIS_ENUM.key?(name)
+
+      v = (raw ? @raw_axis_values : @axis_values)[name]
+      v || 0.0
+    end
+
+    def buttons_held = @buttons_held.dup
+
+    def axes
+      AXIS_NAMES.each_with_object({}) { |a, h| h[a] = @axis_values[a] || 0.0 }
+    end
+
+    # Polling — frame-scoped transitions. Cleared each frame by
+    # `_clear_frame_state`.
+    def pressed?(button)  = @buttons_down.include?(button)
+    def released?(button) = @buttons_up.include?(button)
+    def axis_moved?(axis) = @axes_moved.include?(axis)
+    def axes_moved        = @axes_moved.dup
+
+    # Feedback. `rumble`, `rumble_triggers`, and `set_led` return `false` when
+    # the pad is disconnected or the SDL call fails — never raise. `led=` is a
+    # convenience alias of `set_led`; being a Ruby assignment it evaluates to the
+    # assigned value, not the success Boolean, so use `set_led` when you need it.
+    #
+    # `rumble(strength:, duration:)` is the simple form; the low/high form
+    # exposes the dual-motor pattern most pads expose.
+    def rumble(strength: nil, low: nil, high: nil, duration: 0.2)
+      return false unless @connected
+
+      if strength
+        low ||= strength
+        high ||= strength
+      end
+      low  ||= 0.0
+      high ||= 0.0
+      Ext.window_gamepad_rumble(@window, @id, low.to_f, high.to_f, duration.to_f)
+    end
+
+    def rumble_triggers(left: 0.0, right: 0.0, duration: 0.2)
+      return false unless @connected
+
+      Ext.window_gamepad_rumble_triggers(@window, @id,
+                   left.to_f, right.to_f, duration.to_f)
+    end
+
+    # Set the LED color from an `[r, g, b]` triple. Returns `false` on failure.
+    def set_led(rgb)
+      return false unless @connected
+      r, g, b = rgb
+      Ext.window_gamepad_set_led(@window, @id, r.to_i, g.to_i, b.to_i)
+    end
+
+    # Convenience setter form of `set_led`. As a Ruby assignment it returns the
+    # assigned value, not the success Boolean — call `set_led` if you need that.
+    def led=(rgb)
+      set_led(rgb)
+    end
+
+    # Snapshot of the underlying joystick's raw input state — buttons,
+    # axes (raw -32768..32767), and hats (SDL hat bitmask). Bypasses any
+    # gamepad mapping. Intended for mapping-generation tools that need to
+    # observe the physical hardware before SDL remaps it. Returns `nil`
+    # when the pad is disconnected.
+    def joystick_state
+      return nil unless @connected
+
+      arr = Ext.window_gamepad_joystick_state(@window, @id) or return nil
+      { buttons: arr[0], axes: arr[1], hats: arr[2] }
+    end
+
+    # Read-only snapshot of low-level metadata SDL exposes about the pad —
+    # useful when adding a custom mapping for an unrecognized device, or
+    # diagnosing why a connected device behaves oddly. Returns `nil` when
+    # the pad is disconnected.
+    #
+    # Keys:
+    #   :guid           — 32-char SDL GUID hex string (the same string used
+    #                     in `gamepads.txt` mapping entries)
+    #   :vendor_id      — USB-style vendor ID (Integer; format as `%04x`)
+    #   :product_id     — USB-style product ID (Integer; format as `%04x`)
+    #   :version        — product version (Integer; format as `%04x`)
+    #   :serial         — String, or nil if SDL has no serial for this pad
+    #   :connection     — :wired, :wireless, or :unknown
+    #   :real_type      — the underlying gamepad type before any user mapping
+    #                     remaps it (:xbox / :playstation / :nintendo /
+    #                     :generic / :unknown)
+    #   :num_touchpads  — count of touchpad surfaces (PS4/PS5 = 1, most = 0)
+    #   :mapping        — the resolved SDL gamepad mapping string, or nil
+    def debug_info
+      return nil unless @connected
+
+      arr = Ext.window_gamepad_debug_info(@window, @id) or return nil
+      {
+        guid:          arr[0],
+        vendor_id:     arr[1],
+        product_id:    arr[2],
+        version:       arr[3],
+        serial:        arr[4],
+        connection:    arr[5],
+        real_type:     arr[6],
+        num_touchpads: arr[7],
+        mapping:       arr[8]
+      }
+    end
+
+    # ----- Internal: dispatch hooks called from gamepad_callback -----
+
+    def _apply_button_down(button)
+      return unless @connected
+      @buttons_down << button unless @buttons_down.include?(button)
+      @buttons_held << button unless @buttons_held.include?(button)
+    end
+
+    def _apply_button_held(button)
+      return unless @connected
+      @buttons_held << button unless @buttons_held.include?(button)
+    end
+
+    def _apply_button_up(button)
+      return unless @connected
+      @buttons_up << button unless @buttons_up.include?(button)
+      @buttons_held.delete(button)
+    end
+
+    # Returns the dead-zoned value (which is what handlers receive), or `nil`
+    # if the value didn't move outside the dead-zoned region — letting the
+    # caller suppress event emission for motion entirely inside the dead zone.
+    def _apply_axis(axis, raw_value)
+      return nil unless @connected
+      return nil unless AXIS_ENUM.key?(axis)
+
+      previous = @axis_values[axis] || 0.0
+      dz = apply_dead_zone(axis, raw_value)
+
+      @raw_axis_values[axis] = raw_value
+      @axis_values[axis] = dz
+
+      if dz != previous
+        @axes_moved << axis unless @axes_moved.include?(axis)
+        dz
+      else
+        nil
+      end
+    end
+
+    def _clear_frame_state
+      @buttons_down.clear
+      @buttons_up.clear
+      @buttons_held.clear
+      @axes_moved.clear
+    end
+
+    def _disconnect
+      @connected = false
+      @buttons_down.clear
+      @buttons_up.clear
+      @buttons_held.clear
+      @axes_moved.clear
+      AXIS_NAMES.each do |a|
+        @axis_values[a] = 0.0
+        @raw_axis_values[a] = 0.0
+      end
+    end
+
+    private
+
+    def apply_dead_zone(axis, value)
+      return value if @dead_zone <= 0.0 || TRIGGER_AXES.include?(axis)
+      value.abs < @dead_zone ? 0.0 : value
+    end
+  end
+end

data/lib/ruby2d/gem_paths.rb

@@ -0,0 +1,19 @@
+# Extension-free path helpers. These live apart from the rest of `ruby2d` so the
+# tooling that must run *before* the native extension exists — the `ruby2d setup`
+# command that builds it, and the extconf that links it — can locate the gem's
+# files without loading the (possibly not-yet-built) `.so`.
+
+module Ruby2D
+  def self.gem_dir
+    # mruby doesn't define `Gem`
+    if RUBY_ENGINE == 'mruby'
+      `ruby -e "print Gem::Specification.find_by_name('ruby2d').gem_dir"`
+    else
+      Gem::Specification.find_by_name('ruby2d').gem_dir
+    end
+  end
+
+  def self.assets
+    "#{gem_dir}/assets"
+  end
+end

data/lib/ruby2d/image.rb

@@ -1,79 +1,182 @@
-# frozen_string_literal: true
-
 # Ruby2D::Image
 
 module Ruby2D
-  # Images in many popular formats can be drawn in the window.
-  # To draw an image in the window, use the following, providing the image file path:
-  # +Image.new('star.png')+
+  # An image drawn in the window
   class Image
     include Renderable
 
+    # Image uses `tint` instead of `color` — the image already has its own
+    # colors in the texture; tint modulates them.
+    undef_method :color, :color=, :colour, :colour=
+
     attr_reader :path
-    attr_accessor :x, :y, :width, :height, :rotate, :data
-
-    # Load an image +path+ and return a Texture, using a pixmap atlas if provided
-    # @param path [#to_s] The location of the file to load as an image.
-    # @param atlas [PixmapAtlas] Pixmap atlas to use to manage the image file
-    # @return [Texture] loaded
-    def self.load_image_as_texture(path, atlas:)
-      pixmap = if atlas
-                 atlas.load_and_keep_image(path, as: path)
-               else
-                 Pixmap.new path
-               end
-      pixmap.texture
+    attr_accessor :width, :height, :rotate
+
+    # Set the x position. Pass a symbol (`:left`, `:center`, `:right`) to
+    # set alignment intent — resolved at draw time against the window.
+    def x=(value)
+      return self.x_align = value if value.is_a?(Symbol)
+      @x_align = nil unless @_resolving_alignment
+      @x = value
     end
 
-    # Create an Image
-    # @param path [#to_s] The location of the file to load as an image.
-    # @param width [Numeric] The +width+ of image, or default is width from image file
-    # @param height [Numeric] The +height+ of image, or default is height from image file
-    # @param x [Numeric]
-    # @param y [Numeric]
-    # @param z [Numeric]
-    # @param rotate [Numeric] Angle, default is 0
-    # @param color [Numeric] (or +colour+) Tint the image when rendering
-    # @param opacity [Numeric] Opacity of the image when rendering
-    # @param show [Boolean] If +true+ the image is added to +Window+ automatically.
-    def initialize(path, atlas: nil,
-                   width: nil, height: nil, x: 0, y: 0, z: 0,
-                   rotate: 0, color: nil, colour: nil,
-                   opacity: nil, show: true)
-      @path = path.to_s
+    # Set the y position. Pass a symbol (`:top`, `:center`, `:bottom`) to
+    # set alignment intent — resolved at draw time against the window.
+    def y=(value)
+      return self.y_align = value if value.is_a?(Symbol)
+      @y_align = nil unless @_resolving_alignment
+      @y = value
+    end
+
+    # Get the rotation center x coordinate
+    def rx
+      @_user_rx.nil? ? @x + @width / 2.0 : @_user_rx
+    end
 
-      # Consider input pixmap atlas if supplied to load image file
-      @texture = Image.load_image_as_texture @path, atlas: atlas
-      @width = width || @texture.width
-      @height = height || @texture.height
+    # Get the rotation center y coordinate
+    def ry
+      @_user_ry.nil? ? @y + @height / 2.0 : @_user_ry
+    end
 
+    # Set the rotation center x coordinate
+    def rx=(val)
+      @_user_rx = val
+    end
+
+    # Set the rotation center y coordinate
+    def ry=(val)
+      @_user_ry = val
+    end
+
+    # Create an image
+    def initialize(path,
+                   width: nil, height: nil, x: 0, y: 0, z: 0,
+                   rotate: 0, rx: nil, ry: nil, tint: nil,
+                   opacity: nil, add: true, visible: true,
+                   padding: nil, padding_top: nil, padding_right: nil,
+                   padding_bottom: nil, padding_left: nil,
+                   _share_from: nil)
+      @width = width
+      @height = height
+
+      x, y = _extract_alignment(x, y)
+      _apply_padding(padding, padding_top, padding_right, padding_bottom, padding_left)
       @x = x
       @y = y
       @z = z
       @rotate = rotate
-      self.color = color || colour || 'white'
-      self.color.opacity = opacity unless opacity.nil?
+      @_user_rx = rx
+      @_user_ry = ry
+      self.tint = tint || 'white'
+      self.tint.opacity = opacity unless opacity.nil?
+
+      if _share_from
+        # SpriteSheet uses this to give every Sprite the same backing texture
+        # without re-decoding the file or re-uploading to the GPU.
+        @path        = _share_from.path
+        @ext_image   = _share_from.instance_variable_get(:@ext_image)
+        @orig_width  = _share_from.instance_variable_get(:@orig_width)
+        @orig_height = _share_from.instance_variable_get(:@orig_height)
+        @width     ||= @orig_width
+        @height    ||= @orig_height
+        @clipped     = false
+        @clip_x      = 0.0
+        @clip_y      = 0.0
+        @clip_width  = @orig_width
+        @clip_height = @orig_height
+      else
+        @path = path.to_s
+        raise Error, "Image file `#{@path}` not found" unless File.exist?(@path)
 
-      add if show
+        # Preserve user-provided values before image_create may overwrite them
+        provided_width = @width
+        provided_height = @height
+        provided_rotate = @rotate
+        Ext.image_create(self)
+
+        @width = provided_width || @width
+        @height = provided_height || @height
+        @rotate = provided_rotate
+      end
+
+      @visible = visible
+      self.add if add
+    end
+
+    # Re-rasterize the source at a new pixel size and update `width`/`height`.
+    # For SVGs this re-runs the vector rasterizer so the image stays crisp at
+    # the new size. For raster images it resamples the source to the new size
+    # — useful for trimming GPU memory when displaying a large source small.
+    # Called with no arguments, re-rasterizes at the current `width`/`height`
+    # — handy after assigning to `width=`/`height=` to commit a fresh raster.
+    def resize!(width = @width, height = @height)
+      unless width.is_a?(Numeric) && height.is_a?(Numeric) && width.positive? && height.positive?
+        raise Error, 'Image#resize! requires positive width and height'
+      end
+
+      Ext.image_resize(self, width, height)
+      @width = width
+      @height = height
+      self
+    end
+
+    # The image's tint color. The image's own texture colors are multiplied
+    # by this — `tint: 'red'` makes the image redder, not solid red.
+    def tint
+      @color
     end
 
-    def draw(x: 0, y: 0, width: nil, height: nil, rotate: 0, color: nil, colour: nil)
+    def tint=(c)
+      @color = Color.new(c)
+    end
+
+    # Render the image. Called with overrides for one-shot rendering inside a
+    # render block; with no arguments it draws the same frame the scene graph
+    # does (delegating to `_render_scene`).
+    def render(x: nil, y: nil, width: nil, height: nil, rotate: nil,
+               tint: nil, opacity: nil)
+      if x.nil? && y.nil? && width.nil? && height.nil? && rotate.nil? &&
+         tint.nil? && opacity.nil?
+        return _render_scene
+      end
+
       Window.render_ready_check
 
-      render(x: x, y: y, width:
-        width || @width, height: height || @height,
-             color: Color.new(color || colour || 'white'),
-             rotate: rotate || @rotate)
+      saved_x, saved_y = @x, @y
+      saved_width, saved_height = @width, @height
+      saved_rotate = @rotate
+      saved_color = @color
+
+      @x = x if x
+      @y = y if y
+      @width = width if width
+      @height = height if height
+      @rotate = rotate if rotate
+
+      if tint || opacity
+        @color = tint ? Color.new(tint) : Color.new(saved_color)
+        @color.opacity = opacity if opacity
+      end
+
+      begin
+        Ext.image_draw(self)
+      ensure
+        @x, @y = saved_x, saved_y
+        @width, @height = saved_width, saved_height
+        @rotate = saved_rotate
+        @color = saved_color
+      end
     end
 
     private
 
-    def render(x: @x, y: @y, width: @width, height: @height, color: @color, rotate: @rotate)
-      vertices = Vertices.new(x, y, width, height, rotate)
-
-      @texture.draw(
-        vertices.coordinates, vertices.texture_coordinates, color
-      )
+    # Scene-graph draw hook (see Renderable#_render_scene): `render` with no
+    # overrides, minus its keyword handling — a zero-arg call into the
+    # 7-keyword `render` still pays ~3.4µs of keyword setup on wasm mruby.
+    def _render_scene
+      _resolve_alignment
+      Ext.image_draw(self)
     end
+    public :_render_scene
   end
 end

data/lib/ruby2d/interactive.rb

@@ -0,0 +1,103 @@
+# Ruby2D::Interactive
+
+module Ruby2D
+  # Per-object event handling for objects that participate in Window's
+  # interactive registry. Provides `on` / `off` / `interactive?` and the
+  # `_fire_event` dispatch entry point. Mixed into `Renderable` and `Button`.
+  #
+  # Including objects must expose `x`, `y`, `z`, `width`, `height`, and
+  # `contains?(x, y)` so `Window::ObjectEventDispatch` can hit-test them.
+  module Interactive
+    # Per-object events that take a value matcher (button) in the kwarg form.
+    # `:hover`, `:hover_out`, and `:mouse_scroll` carry no matchable field.
+    OBJECT_EVENT_FILTER_PREDICATES = {
+      mouse_down: :button?, mouse_held: :button?, mouse_up: :button?,
+      click: :button?, drag: :button?
+    }.freeze
+
+    # The full per-object event vocabulary: the filterable events above plus the
+    # three that carry no matchable field. Derived from the predicates map so the
+    # two can't drift, and mirrors what Window::ObjectEventDispatch fires.
+    OBJECT_EVENTS = (OBJECT_EVENT_FILTER_PREDICATES.keys + %i[hover hover_out mouse_scroll]).freeze
+
+    # Register a per-object event handler. Two forms:
+    #
+    #   obj.on(:click) { |event| ... }
+    #   obj.on(click: :left) { ... }                   # filtered
+    #   obj.on(click: [:left, :right]) { ... }         # array → match any
+    #   obj.on(mouse_down: :left, click: :left) { ... }  # multi-event
+    def on(event = nil, **filters, &proc)
+      raise Error, '`on` requires a block' unless proc
+      if event.is_a?(Symbol) && filters.empty?
+        raise Error, "`#{event}` is not a valid object event" unless OBJECT_EVENTS.include?(event)
+        register_object_event_handler(event, proc)
+      elsif event.nil? && !filters.empty?
+        descriptors = filters.map do |type, matcher|
+          predicate = OBJECT_EVENT_FILTER_PREDICATES[type] or
+            raise Error, "`#{type}` does not support filtering with `on event: value`"
+          values = Array(matcher)
+          wrapped = ->(e) { proc.call(e) if values.any? { |v| e.send(predicate, v) } }
+          register_object_event_handler(type, wrapped)
+        end
+        descriptors.size == 1 ? descriptors.first : descriptors
+      else
+        raise Error, '`on` requires either an event symbol or event filters'
+      end
+    end
+
+    # Remove a per-object event handler (or several, given an array).
+    def off(descriptor)
+      return descriptor.each { |d| off(d) } if descriptor.is_a?(Array)
+
+      unless descriptor.is_a?(Window::ObjectEventDescriptor)
+        raise Error,
+              "Cannot remove event handler: expected a descriptor returned by `on`, got #{descriptor.inspect}"
+      end
+
+      return unless @_object_events
+
+      handlers = @_object_events[descriptor.type]
+      return unless handlers
+
+      handlers.delete(descriptor.id)
+      @_object_events.delete(descriptor.type) if handlers.empty?
+
+      Window.unregister_interactive(self) unless interactive?
+    end
+
+    # Check if this object has any event handlers
+    def interactive?(event = nil)
+      return false unless @_object_events
+
+      if event
+        @_object_events.key?(event) && !@_object_events[event].empty?
+      else
+        @_object_events.any? { |_type, handlers| !handlers.empty? }
+      end
+    end
+
+    # Dispatch an event to stored handlers (called by Window)
+    def _fire_event(type, event)
+      return unless @_object_events
+
+      handlers = @_object_events[type]
+      return unless handlers
+
+      # Snapshot the values: a handler may register another handler for the same
+      # event type mid-dispatch, which would otherwise mutate the hash we're
+      # iterating ("can't add a new key into hash during iteration").
+      handlers.values.each { |proc| proc.call(event) }
+    end
+
+    private
+
+    def register_object_event_handler(event, proc)
+      @_object_events ||= {}
+      @_object_events[event] ||= {}
+      id = (@_object_event_key = (@_object_event_key || 0) + 1)
+      @_object_events[event][id] = proc
+      Window.register_interactive(self)
+      Window::ObjectEventDescriptor.new(self, event, id)
+    end
+  end
+end