openhab-scripting 5.10.0 → 5.12.0

data/lib/openhab/dsl/sitemaps/builder.rb

@@ -36,12 +36,9 @@ module OpenHAB
       # Base class for all widgets
       # @see org.openhab.core.model.sitemap.sitemap.Widget
       class WidgetBuilder
-        # rubocop:disable Layout/LineLength, Lint/MixedRegexpCaptureTypes
-        # These are copied directly out of UIComponentSitemapProvider.java
-        VISIBILITY_PATTERN = /(?<item>[A-Za-z]\w*)\s*(?<condition>==|!=|<=|>=|<|>)\s*(?<sign>\+|-)?(?<state>\S+)/.freeze
-        COLOR_PATTERN = /((?<item>[A-Za-z]\w*)?\s*((?<condition>==|!=|<=|>=|<|>)\s*(?<sign>\+|-)?(?<state>\S+))?\s*=)?\s*(?<arg>\S+)/.freeze
-        # rubocop:enable Layout/LineLength, Lint/MixedRegexpCaptureTypes
-        private_constant :VISIBILITY_PATTERN, :COLOR_PATTERN
+        # This is copied directly out of UIComponentSitemapProvider.java
+        CONDITION_PATTERN = /(?<item>[A-Za-z]\w*)?\s*(?<condition>==|!=|<=|>=|<|>)?\s*(?<sign>\+|-)?(?<state>.+)/.freeze
+        private_constant :CONDITION_PATTERN
 
         # @return [String, nil]
         attr_accessor :label
@@ -52,15 +49,15 @@ module OpenHAB
         # @see https://www.openhab.org/docs/ui/sitemaps.html#icons
         attr_accessor :icon
         # Label color rules
-        # @return [Array<String>]
+        # @return [Hash<String, String>]
         # @see https://www.openhab.org/docs/ui/sitemaps.html#label-value-and-icon-colors
         attr_reader :label_colors
         # Value color rules
-        # @return [Array<String>]
+        # @return [Hash<String, String>]
         # @see https://www.openhab.org/docs/ui/sitemaps.html#label-value-and-icon-colors
         attr_reader :value_colors
         # Icon color rules
-        # @return [Array<String>]
+        # @return [Hash<String, String>]
         # @see https://www.openhab.org/docs/ui/sitemaps.html#label-value-and-icon-colors
         attr_reader :icon_colors
         # Visibility rules
@@ -94,32 +91,32 @@ module OpenHAB
           @label = label
           @icon = icon
           @visibilities = []
-          @label_colors = []
-          @value_colors = []
-          @icon_colors = []
+          @label_colors = {}
+          @value_colors = {}
+          @icon_colors = {}
 
-          self.label_color(*label_color) if label_color
-          self.value_color(*value_color) if value_color
-          self.icon_color(*icon_color) if icon_color
+          self.label_color(label_color) if label_color
+          self.value_color(value_color) if value_color
+          self.icon_color(icon_color) if icon_color
           self.visibility(*visibility) if visibility
         end
 
         # Adds one or more new rules for setting the label color
-        # @return [Array<String>] the current rules
-        def label_color(*rules)
-          @label_colors.concat(rules)
+        # @return [Hash<String, String>] the current rules
+        def label_color(rules)
+          @label_colors.merge!(rules)
         end
 
         # Adds one or more new rules for setting the value color
-        # @return [Array<String>] the current rules
-        def value_color(*rules)
-          @value_colors.concat(rules)
+        # @return [Hash<String, String>] the current rules
+        def value_color(rules)
+          @value_colors.merge!(rules)
         end
 
         # Adds one or more new rules for setting the icon color
-        # @return [Array<String>] the current rules
-        def icon_color(*rules)
-          @icon_colors.concat(rules)
+        # @return [Hash<String, String>] the current rules
+        def icon_color(rules)
+          @icon_colors.merge!(rules)
         end
 
         # Adds one or more new visibility rules
@@ -137,21 +134,28 @@ module OpenHAB
           widget.label = @label
           widget.icon = @icon
 
-          add_color(widget.label_color, label_colors) unless label_colors.empty?
-          add_color(widget.value_color, value_colors) unless value_colors.empty?
-          add_color(widget.icon_color, icon_colors) unless icon_colors.empty?
+          add_colors(widget, :label_color, label_colors)
+          add_colors(widget, :value_color, value_colors)
+          add_colors(widget, :icon_color, icon_colors)
 
-          visibilities.each do |v|
-            unless (match = VISIBILITY_PATTERN.match(v))
-              raise ArgumentError, "Syntax error in visibility rule #{v.inspect}"
+          # @deprecated OH 4.1
+          if SitemapBuilder.factory.respond_to?(:create_condition)
+            add_conditions(widget, :visibility, visibilities, :create_visibility_rule)
+          else
+            visibilities.each do |v|
+              raise ArgumentError, "AND conditions not supported prior to openHAB 4.1" if v.is_a?(Array)
+
+              unless (match = CONDITION_PATTERN.match(v))
+                raise ArgumentError, "Syntax error in visibility rule #{v.inspect}"
+              end
+
+              rule = SitemapBuilder.factory.create_visibility_rule
+              rule.item = match["item"]
+              rule.condition = match["condition"]
+              rule.sign = match["sign"]
+              rule.state = match["state"]
+              widget.visibility.add(rule)
             end
-
-            rule = SitemapBuilder.factory.create_visibility_rule
-            rule.item = match["item"]
-            rule.condition = match["condition"]
-            rule.sign = match["sign"]
-            rule.state = match["state"]
-            widget.visibility.add(rule)
           end
 
           widget
@@ -169,19 +173,51 @@ module OpenHAB
 
         private
 
-        def add_color(widget_color, colors)
-          colors.each do |c|
-            unless (match = COLOR_PATTERN.match(c))
-              raise ArgumentError, "Syntax error in color rule #{c.inspect}"
+        def add_colors(widget, method, conditions)
+          conditions.each do |condition, color|
+            condition = [condition] unless condition.is_a?(Array)
+            add_conditions(widget, method, condition, :create_color_array) do |color_array|
+              color_array.arg = color
+            end
+          end
+        end
+
+        def add_conditions(widget, method, conditions, container_method)
+          return if conditions.empty?
+
+          object = widget.send(method)
+          has_and_conditions = conditions.any?(Array)
+          # @deprecated OH 4.1
+          if !SitemapBuilder.factory.respond_to?(:create_condition) && has_and_conditions
+            raise ArgumentError, "AND conditions not supported prior to openHAB 4.1"
+          end
+
+          conditions = [conditions] unless has_and_conditions
+
+          conditions.each do |sub_conditions|
+            container = SitemapBuilder.factory.send(container_method)
+
+            add_conditions_to_container(container, sub_conditions)
+            yield container if block_given?
+            object.add(container)
+          end
+        end
+
+        def add_conditions_to_container(container, conditions)
+          # @deprecated OH 4.1
+          supports_and_conditions = SitemapBuilder.factory.respond_to?(:create_condition)
+
+          Array.wrap(conditions).each do |c|
+            unless (match = CONDITION_PATTERN.match(c))
+              raise ArgumentError, "Syntax error in condition #{c.inspect}"
             end
 
-            rule = SitemapBuilder.factory.create_color_array
-            rule.item = match["item"]
-            rule.condition = match["condition"]
-            rule.sign = match["sign"]
-            rule.state = match["state"]
-            rule.arg = match["arg"]
-            widget_color.add(color)
+            condition = supports_and_conditions ? SitemapBuilder.factory.create_condition : container
+            condition.item = match["item"]
+            condition.condition = match["condition"]
+            condition.sign = match["sign"]
+            condition.state = match["state"]
+            container.conditions.add(condition) if supports_and_conditions
           end
         end
       end
@@ -284,6 +320,7 @@ module OpenHAB
 
           @switch = switch
           @frequency = frequency
+          @switch_enabled = nil
         end
 
         # (see #switch=)

data/lib/openhab/dsl/things/builder.rb

@@ -210,7 +210,18 @@ module OpenHAB
               thing_type,
               self.class.config_description_registry
             )
+
+            predefined_channels = self.class.thing_factory_helper
+                                      .create_channels(thing_type, uid, self.class.config_description_registry)
+                                      .to_h { |channel| [channel.uid, channel] }
+            new_channels = channels.to_h { |channel| [channel.uid, channel] }
+            merged_channels = predefined_channels.merge(new_channels) do |_key, predefined_channel, new_channel|
+              predefined_channel.configuration.merge!(new_channel.configuration)
+              predefined_channel
+            end
+            @channels = merged_channels.values
           end
+
           builder = org.openhab.core.thing.binding.builder.ThingBuilder
                        .create(thing_type_uid, uid)
                        .with_label(label)
@@ -219,15 +230,7 @@ module OpenHAB
                        .with_bridge(bridge_uid)
                        .with_channels(channels)
 
-          if thing_type
-            # can't use with_channels, or it will wipe out custom channels from above
-            self.class.thing_factory_helper.create_channels(thing_type,
-                                                            uid,
-                                                            self.class.config_description_registry).each do |channel|
-              builder.with_channel(channel)
-            end
-            builder.with_properties(thing_type.properties)
-          end
+          builder.with_properties(thing_type.properties) if thing_type
 
           builder.build
         end
@@ -263,8 +266,14 @@ module OpenHAB
                     :default_tags,
                     :properties,
                     :description,
-                    :auto_update_policy,
-                    :accepted_item_type
+                    :auto_update_policy
+
+        class << self
+          # @!visibility private
+          def channel_type_registry
+            @channel_type_registry ||= OSGi.service("org.openhab.core.thing.type.ChannelTypeRegistry")
+          end
+        end
 
         #
         # Constructor for ChannelBuilder
@@ -284,7 +293,7 @@ module OpenHAB
         #   The default tags for this channel.
         # @param [:default, :recommend, :veto, org.openhab.core.thing.type.AutoUpdatePolicy] auto_update_policy
         #   The channel's auto update policy.
-        # @param [String] accepted_item_type The accepted item type.
+        # @param [String] accepted_item_type The accepted item type. If nil, infer the item type from the channel type.
         #
         def initialize(uid,
                        type,
@@ -343,6 +352,12 @@ module OpenHAB
              .build
         end
 
+        # @!attribute [r] accepted_item_type
+        # @return [String] The accepted item type.
+        def accepted_item_type
+          @accepted_item_type ||= self.class.channel_type_registry.get_channel_type(type)&.item_type
+        end
+
         private
 
         def kind

data/lib/openhab/dsl/version.rb

@@ -4,6 +4,6 @@ module OpenHAB
   module DSL
     # Version of openHAB helper libraries
     # @return [String]
-    VERSION = "5.10.0"
+    VERSION = "5.12.0"
   end
 end

data/lib/openhab/dsl.rb

@@ -77,7 +77,13 @@ module OpenHAB
     #
     # Defines a new profile that can be applied to item channel links.
     #
+    # To create a profile that can be used in the UI, provide a label and optionally a {config_description},
+    # otherwise the profile will not be visible in the UI.
+    #
     # @param [String, Symbol] id The id for the profile.
+    # @param [String, nil] label The label for the profile. When nil, the profile will not be visible in the UI.
+    # @param [org.openhab.core.config.core.ConfigDescription, nil] config_description
+    #   The configuration description for the profile so that it can be configured in the UI.
     # @yield [event, command: nil, state: nil, callback:, link:, item:, channel_uid:, configuration:, context:]
     #   All keyword params are optional. Any that aren't defined won't be passed.
     # @yieldparam [:command_from_item, :state_from_item, :command_from_handler, :state_from_handler] event
@@ -97,8 +103,8 @@ module OpenHAB
     # @yieldreturn [Boolean] Return true from the block in order to have default processing.
     # @return [void]
     #
-    # @see org.openhab.thing.Profile
-    # @see org.openhab.thing.StateProfile
+    # @see org.openhab.core.thing.profiles.Profile
+    # @see org.openhab.core.thing.profiles.StateProfile
     #
     # @example Vetoing a command
     #   profile(:veto_closing_shades) do |event, item:, command:|
@@ -142,17 +148,54 @@ module OpenHAB
     #   # can also be referenced from an `.items` file:
     #   # Number:Temperature MyTempWithNonUnitValueFromBinding "I prefer Celsius [%d °C]" { channel="something_that_returns_F"[profile="ruby:set_uom", unit="°F"] }
     #
-    def profile(id, &block)
+    # @example Create a profile that is usable in the UI
+    #   config_description = config_description do
+    #     parameter :min, :decimal, label: "Minimum", description: "Minimum value"
+    #     parameter :max, :decimal, label: "Maximum", description: "Maximum value"
+    #   end
+    #
+    #   profile(:range_filter, label: "Range Filter", config_description: config_description) do |event, state:, configuration:|
+    #     return true unless event == :state_from_handler
+    #
+    #     (configuration["min"]..configuration["max"]).cover?(state)
+    #   end
+    #
+    def profile(id, label: nil, config_description: nil, &block)
       raise ArgumentError, "Block is required" unless block
 
       id = id.to_s
-      uid = org.openhab.core.thing.profiles.ProfileTypeUID.new("ruby", id)
 
       ThreadLocal.thread_local(openhab_rule_type: "profile", openhab_rule_uid: id) do
-        Core::ProfileFactory.instance.register(uid, block)
+        Core::ProfileFactory.instance.register(id, block, label: label, config_description: config_description)
       end
     end
 
+    #
+    # Create a {org.openhab.core.config.core.ConfigDescription ConfigDescription} object.
+    #
+    # @param [String, java.net.URI] uri The URI for the ConfigDescription. When nil, a dummy URI is used which will
+    #   be replaced by the profile with the correct URI for that profile.
+    # @yield Block that consists of {ConfigDescription::Builder#parameter} and {ConfigDescription::Builder#group} calls.
+    #
+    # @return [org.openhab.core.config.core.ConfigDescription]
+    #   The created {org.openhab.core.config.core.ConfigDescription ConfigDescription} object
+    #
+    # @example
+    #  config_description = config_description do
+    #    parameter :ungrouped_parameter, :decimal, label: "Ungrouped Parameter", min: 1, max: 5
+    #
+    #    group "Config Group", label: "Grouped parameters", advanced: true do
+    #      parameter :my_parameter, :string, label: "My Parameter", description: "My Parameter Description"
+    #      parameter :other_parameter, :integer, label: "Other Parameter", description: "Other Parameter Description"
+    #    end
+    #  end
+    #
+    def config_description(uri = nil, &block)
+      raise ArgumentError, "Block is required" unless block
+
+      ConfigDescription::Builder.new.build(uri, &block)
+    end
+
     # rubocop:enable Layout/LineLength
 
     # @!group Object Access
@@ -557,10 +600,49 @@ module OpenHAB
     #   to reduce repetitions
     #
 
+    #
+    # Permanently enable conditional execution of commands and updates for the current thread.
+    #
+    # When conditional executions are enabled, commands and updates will only be sent if the
+    # item's current state is not the same as the command or updated state.
+    # This eliminates the need to chain the command and update calls through
+    # {DSL::Items::Ensure::Ensurable#ensure ensure}.
+    #
+    # When conditional executions are enabled either by this method or within a block of {ensure_states},
+    # commands and updates can still be forcefully executed using the corresponding bang methods, e.g.
+    # `Item1.on!`, `Item1.command!(50)`, or `Item1.update!(ON)`.
+    #
+    # @note This method is only intended for use at the top level of rule
+    #   scripts. If it's used within library methods, or hap-hazardly within
+    #   rules, things can get very confusing because the prior state won't be
+    #   properly restored.
+    #
+    # @param [Boolean] active Whether to enable or disable conditional executions.
+    # @return [Boolean] The previous ensure_states setting.
+    #
+    # @example Make ensure_states the default for the rest of the script
+    #   ensure_states!
+    #
+    #   # From now, all commands are "ensured", i.e. only sent when the current state is different
+    #   Item1.on
+    #   Item2.command(ON)
+    #
+    #   # While ensure_states! is active, we can still forcibly send a command
+    #   # regardless of the item's current state
+    #   Item2.on!
+    #
+    # @see ensure_states
+    #
+    def ensure_states!(active: true)
+      old = Thread.current[:openhab_ensure_states]
+      Thread.current[:openhab_ensure_states] = active
+      old
+    end
+
     #
     # Global method that takes a block and for the duration of the block
     # all commands sent will check if the item is in the command's state
-    # before sending the command.
+    # before sending the command. This also applies to updates.
     #
     # @yield
     # @return [Object] The result of the block.
@@ -603,11 +685,10 @@ module OpenHAB
     #   end
     #
     def ensure_states
-      old = Thread.current[:openhab_ensure_states]
-      Thread.current[:openhab_ensure_states] = true
+      old = ensure_states!
       yield
     ensure
-      Thread.current[:openhab_ensure_states] = old
+      ensure_states!(active: old)
     end
 
     #
@@ -841,7 +922,7 @@ module OpenHAB
     #     elements, the {Core::Items::Metadata::Hash} will be passed as an argument. Therefore it's
     #     recommended that you use a Proc, not a Lambda, for permissive argument matching.
     #
-    # @return [void]
+    # @return [Hash] the prior provider configuration.
     #
     # @see provider
     # @see OpenHAB::Core::Provider.current Provider.current for how the current provider is calculated

data/lib/openhab/rspec/shell.rb

@@ -5,26 +5,36 @@ module OpenHAB
     # based on https://stackoverflow.com/questions/1197224/source-shell-script-into-environment-within-a-ruby-script#19826329
     # @!visibility private
     module Shell
-      module_function
+      # @!visibility private
+      DEFAULT_PRINTENV_COMMAND = "printenv -0"
+      @printenv_command = DEFAULT_PRINTENV_COMMAND
+      @printenv_separator = "\0"
 
-      # Read in the bash environment, after an optional command.
-      #   Returns Array of key/value pairs.
-      def shell_env(cmd = nil)
-        cmd = "#{cmd} > /dev/null; " if cmd
-        env = `#{cmd}printenv -0`
-        env.split("\0").map { |l| l.split("=", 2) }
-      end
+      class << self
+        # Read in the bash environment, after an optional command.
+        #   Returns Array of key/value pairs.
+        def shell_env(cmd = nil)
+          cmd = "#{cmd} > #{IO::NULL}; " if cmd
+          env = `#{cmd}#{@printenv_command} 2> #{IO::NULL}`
+          if !$?.success? && @printenv_command.equal?(DEFAULT_PRINTENV_COMMAND)
+            @printenv_command = "printenv"
+            @printenv_separator = "\n"
+            env = `#{cmd}#{@printenv_command}`
+          end
+          env.split(@printenv_separator).map { |l| l.split("=", 2) }
+        end
 
-      # Source a given file, and compare environment before and after.
-      #   Returns Hash of any keys that have changed.
-      def shell_source(file)
-        (shell_env(". #{File.realpath(file)}") - shell_env).to_h
-      end
+        # Source a given file, and compare environment before and after.
+        #   Returns Hash of any keys that have changed.
+        def shell_source(file)
+          (shell_env(". #{File.realpath(file)}") - shell_env).to_h
+        end
 
-      # Find variables changed as a result of sourcing the given file,
-      #   and update in ENV.
-      def source_env_from(file)
-        shell_source(file).each { |k, v| ENV[k] = v }
+        # Find variables changed as a result of sourcing the given file,
+        #   and update in ENV.
+        def source_env_from(file)
+          shell_source(file).each { |k, v| ENV[k] = v }
+        end
       end
     end
   end

data/lib/openhab/yard/code_objects/java/base.rb

@@ -9,7 +9,9 @@ module YARD
       # Which might be a class, an enum, or an interface
       module Base
         module ClassMethods
-          def new(name)
+          def new(name, _suffix = nil)
+            # _suffix is given when it encounters a class with ::, e.g. org.openhab.core.OpenHAB::DEFAULT_CONFIG_FOLDER
+
             super(:root, name)
           end
         end

data/lib/openhab/yard/code_objects/java/method_object.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module YARD
+  module CodeObjects
+    module Java
+      class MethodObject < CodeObjects::MethodObject
+        include Base
+
+        def type
+          :method
+        end
+      end
+    end
+  end
+end

data/lib/openhab/yard/handlers/jruby/base.rb

@@ -5,27 +5,76 @@ module YARD
     module JRuby
       module Base
         class << self
+          #
+          # Creates an external link to java documentation for a java class.
+          #
+          # The supported classes are defined in the `javadocs` configuration option.
+          #
+          # Supported syntaxes:
+          #   Package:
+          #   - org.openhab.core => href_base/org/openhab/core/package-summary.html
+          #
+          #   Class:
+          #   - org.openhab.core.OpenHAB => href_base/org/openhab/core/OpenHAB.html
+          #   This doesn't get mistaken as a constant:
+          #   - java.net.URI => href_base/java/net/URI.html
+          #
+          #   Constant: (To specify a constant, use Ruby's `::` syntax)
+          #   - org.openhab.core.OpenHAB::DEFAULT_CONFIG_FOLDER =>
+          #       href_base/org/openhab/core/OpenHAB.html#DEFAULT_CONFIG_FOLDER
+          #
+          #   Method:
+          #   - org.openhab.core.OpenHAB#getVersion() => href_base/org/openhab/core/OpenHAB.html#getVersion()
+          #   But can also work with constants, albeit not a valid Ruby syntax:
+          #   - org.openhab.core.OpenHAB#version => href_base/org/openhab/core/OpenHAB.html#version
+          #   - org.openhab.core.OpenHAB#DEFAULT_CONFIG_FOLDER =>
+          #       href_base/org/openhab/core/OpenHAB.html#DEFAULT_CONFIG_FOLDER
+          #
+          #   Inner class:
+          #   - org.openhab.core.config.core.ConfigDescriptionParameter::Type =>
+          #       href_base/org/openhab/core/config/core/ConfigDescriptionParameter.Type.html
+          #   - org.openhab.core.config.core.ConfigDescriptionParameter.Type =>
+          #       href_base/org/openhab/core/config/core/ConfigDescriptionParameter.Type.html
+          #
+          #   Constant in inner class:
+          #   - org.openhab.core.config.core.ConfigDescriptionParameter::Type::TEXT =>
+          #       href_base/org/openhab/core/config/core/ConfigDescriptionParameter.Type.html#TEXT
+          #   - org.openhab.core.config.core.ConfigDescriptionParameter.Type::TEXT =>
+          #       href_base/org/openhab/core/config/core/ConfigDescriptionParameter.Type.html#TEXT
+          #
           def infer_java_class(klass, inferred_type = nil, comments = nil, statement = nil)
-            components = klass.split(".")
-            components.pop if components.last == "freeze"
-
-            class_first_char = components.last[0]
-            is_field = components.last == components.last.upcase
-            container_first_char = components[-2]&.[](0)
-            is_method = container_first_char &&
-                        class_first_char != class_first_char.upcase &&
-                        container_first_char == container_first_char.upcase
-            is_package = !is_method && !is_field && class_first_char != class_first_char.upcase
-
-            # methods aren't supported right now
-            return if is_method
-
             javadocs = YARD::Config.options.dig(:jruby, "javadocs") || {}
 
             href_base = javadocs.find { |package, _href| klass == package || klass.start_with?("#{package}.") }&.last
             return unless href_base
 
+            components = klass.split(/\.(?=[A-Z])/, 2)
+            components.unshift(*components.shift.split("."))
+            components.push(components.pop.delete_suffix(".freeze"))
+
+            class_first_char = components.last[0]
+            if /#|::/.match?(components.last)
+              parts = components.pop.rpartition(/#|::/)
+              is_field = parts.last == parts.last.upcase
+              # explicit method is fine, e.g. `org.openhab.core.OpenHAB#getVersion()`
+              is_method = !is_field
+              components.push(parts.first.gsub("::", "."), parts.last)
+            else
+              is_field = is_method = false
+              if components.last.include?(".")
+                parts = components.last.split(".")
+                if (is_method = parts.last[0] == parts.last[0].downcase)
+                  # implicit method is not supported, e.g. `org.openhab.core.OpenHAB.version`
+                  # because we're not sure whether it should be #version() or #getVersion()
+                  return
+                end
+              end
+            end
+
+            is_package = !is_method && !is_field && class_first_char != class_first_char.upcase
+
             inferred_type = CodeObjects::Java::FieldObject if is_field
+            inferred_type = CodeObjects::Java::MethodObject if is_method
             inferred_type = CodeObjects::Java::PackageObject if is_package
             if inferred_type.nil?
               docstring = Docstring.parser.parse(comments || statement&.comments).to_docstring
@@ -36,12 +85,18 @@ module YARD
                               end
             end
 
+            orig_klass = klass.dup
+
+            # purposely calling gsub! to modify the caller's string
+            # YARD doesn't handle java inner classes well, so we convert them to ruby
+            klass.gsub!("::", ".")
+
             inferred_type.new(klass) do |o|
               o.source = statement if statement
               suffix = "/package-summary" if is_package
-              field = "##{components.pop}" if is_field
+              field = "##{components.pop}" if is_field || is_method
               link = "#{href_base}#{components.join("/")}#{suffix}.html#{field}"
-              o.docstring.add_tag(Tags::Tag.new(:see, klass, nil, link)) unless o.docstring.has_tag?(:see)
+              o.docstring.add_tag(Tags::Tag.new(:see, orig_klass, nil, link)) unless o.docstring.has_tag?(:see)
             end
           end
         end