openhab-jrubyscripting 5.0.0.rc1

data/lib/openhab/rspec/openhab/core/actions.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module OpenHAB
+  module Core
+    module Actions
+      # rubocop:disable Lint/UnusedMethodArgument
+      # redefine these to do nothing so that rules won't fail
+
+      module_function
+
+      def notify(msg, email: nil)
+        logger.debug("notify: #{msg}")
+      end
+
+      def say(text, voice: nil, sink: nil, volume: nil)
+        logger.debug("say: #{text}")
+      end
+
+      def play_sound(filename, sink: nil, volume: nil)
+        logger.debug("play_sound: #{filename}")
+      end
+
+      # rubocop:enable Lint/UnusedMethodArgument
+    end
+  end
+end

data/lib/openhab/rspec/openhab/core/items/proxy.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module OpenHAB
+  module Core
+    module Items
+      class Proxy
+        @proxies = {}
+
+        class << self
+          # ensure each item only has a single proxy, so that
+          # expect(item).to receive(:method) works
+          def new(item)
+            return super unless defined?(::RSpec) && ::RSpec.current_example&.example_group&.consistent_proxies?
+
+            @proxies.fetch(item.name) do
+              @proxies[item.name] = super
+            end
+          end
+
+          def reset_cache
+            @proxies = {}
+          end
+        end
+      end
+    end
+  end
+end

data/lib/openhab/rspec/openhab/core/things/proxy.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module OpenHAB
+  module Core
+    module Things
+      class Proxy
+        @proxies = {}
+
+        class << self
+          # ensure each item only has a single proxy, so that
+          # expect(item).to receive(:method) works
+          def new(thing)
+            return super unless defined?(::RSpec) && ::RSpec.current_example&.example_group&.consistent_proxies?
+
+            @proxies.fetch(thing.uid.to_s) do
+              @proxies[thing.uid.to_s] = super
+            end
+          end
+
+          def reset_cache
+            @proxies = {}
+          end
+        end
+      end
+    end
+  end
+end

data/lib/openhab/rspec/shell.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module OpenHAB
+  module RSpec
+    # based on https://stackoverflow.com/questions/1197224/source-shell-script-into-environment-within-a-ruby-script#19826329
+    # @!visibility private
+    module Shell
+      module_function
+
+      # 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
+
+      # 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 }
+      end
+    end
+  end
+end

data/lib/openhab/rspec/suspend_rules.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module OpenHAB
+  module RSpec
+    # @!visibility private
+    module SuspendRules
+      # I'd prefer to prepend a module, but I can't because of
+      # https://github.com/jruby/jruby/issues/6966#issuecomment-1172983776
+      class ::OpenHAB::DSL::Rules::AutomationRule # rubocop:disable Style/ClassAndModuleChildren
+        def execute(mod = nil, inputs = nil)
+          if SuspendRules.suspended?
+            logger.trace("Skipping execution of #{uid} because rules are suspended.")
+            return
+          end
+
+          # super
+          ::OpenHAB::DSL::ThreadLocal.thread_local(**@thread_locals) do
+            logger.trace { "Execute called with mod (#{mod&.to_string}) and inputs (#{inputs.inspect})" }
+            logger.trace { "Event details #{inputs["event"].inspect}" } if inputs&.key?("event")
+            trigger_conditions(inputs).process(mod: mod, inputs: inputs) do
+              process_queue(create_queue(inputs), mod, inputs)
+            end
+          rescue Exception => e
+            @run_context.logger.log_exception(e)
+          end
+        end
+      end
+      # private_constant :AutomationRule
+      # DSL::Rules::AutomationRule.prepend(AutomationRule)
+
+      module DSL
+        def after(*)
+          return if SuspendRules.suspended?
+
+          super
+        end
+      end
+      private_constant :DSL
+      OpenHAB::DSL.prepend(DSL)
+
+      @suspended = false
+
+      class << self
+        # @!visibility private
+        def suspend_rules
+          old_suspended = @suspended
+          @suspended = true
+          yield
+        ensure
+          @suspended = old_suspended
+        end
+
+        # @!visibility private
+        def suspended?
+          @suspended
+        end
+      end
+    end
+  end
+end

data/lib/openhab/rspec.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+unless RUBY_ENGINE == "jruby" &&
+       Gem::Version.new(RUBY_ENGINE_VERSION) >= Gem::Version.new("9.3.8.0")
+  raise Gem::RubyVersionMismatch, "openhab-jrubyscripting requires JRuby 9.3.8.0 or newer"
+end
+
+require "jruby"
+
+require "diff/lcs"
+
+require "openhab/log"
+
+require_relative "rspec/configuration"
+require_relative "rspec/helpers"
+require_relative "rspec/karaf"
+require_relative "rspec/hooks"

data/lib/openhab/yard/cli/stats.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module OpenHAB
+  module YARD
+    module CLI
+      module Stats
+        ::YARD::CLI::Stats.prepend(self)
+
+        def stats_for_constants
+          objs = all_objects.select { |m| m.type == :constant }
+          undoc = objs.find_all do |m|
+            # allow constants that are simple aliases
+            # to not have additional documentation
+            m.docstring.blank? && m.target.nil?
+          end
+          @undoc_list |= undoc if @undoc_list
+
+          output "Constants", objs.size, undoc.size
+        end
+      end
+    end
+  end
+end

data/lib/openhab/yard/code_objects/group_object.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module OpenHAB
+  module YARD
+    module CodeObjects
+      class GroupObject < ::YARD::CodeObjects::Base
+        def path
+          "group#{sep}#{super}"
+        end
+
+        def to_s
+          name
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module YARD
+  module CodeObjects
+    module Java
+      #
+      # Represents a java.lang.Class
+      #
+      # Which might be a class, an enum, or an interface
+      module Base
+        module ClassMethods
+          def new(name)
+            super(:root, name)
+          end
+        end
+
+        def self.included(klass)
+          klass.singleton_class.include(ClassMethods)
+        end
+
+        def visibility
+          :private
+        end
+
+        def simple_name
+          name.to_s.split(".").last
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module YARD
+  module CodeObjects
+    module Java
+      class ClassObject < CodeObjects::ClassObject
+        include Base
+      end
+    end
+  end
+end

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

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

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

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

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

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module YARD
+  module CodeObjects
+    module Java
+      class PackageObject < CodeObjects::ClassObject
+        include Base
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module YARD
+  module CodeObjects
+    module Java
+      module Proxy
+        CodeObjects::Proxy.prepend(self)
+
+        def initialize(namespace, name, type = nil)
+          if name.match?(/^([a-zA-Z_$][a-zA-Z\d_$]*\.)+/)
+            @namespace = Registry.root
+            @name = name.to_sym
+            @obj = nil
+            @imethod = nil
+            self.type = type
+            return
+          end
+          super
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module YARD
+  module Handlers
+    module JRuby
+      module Base
+        class << self
+          def infer_java_class(klass, inferred_type = nil, comments = nil, statement = nil)
+            components = klass.split(".")
+            class_first_char = components.last[0]
+            is_field = components.last == components.last.upcase
+            is_package = !is_field && class_first_char != class_first_char.upcase
+
+            javadocs = YARD::Config.options.dig(:jruby, "javadocs") || {}
+
+            href_base = javadocs.find { |package, _href| klass == package || klass.start_with?("#{package}.") }&.last
+            return unless href_base
+
+            inferred_type = CodeObjects::Java::FieldObject if is_field
+            inferred_type = CodeObjects::Java::PackageObject if is_package
+            if inferred_type.nil?
+              docstring = Docstring.parser.parse(comments || statement&.comments).to_docstring
+              inferred_type = if docstring.has_tag?(:interface)
+                                CodeObjects::Java::InterfaceObject
+                              else
+                                CodeObjects::Java::ClassObject
+                              end
+            end
+
+            inferred_type.new(klass) do |o|
+              o.source = statement if statement
+              suffix = "/package-summary" if is_package
+              field = "##{components.pop}" if is_field
+              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)
+            end
+          end
+        end
+
+        def infer_java_class(statement, inferred_type = nil, comments = nil)
+          return unless statement.is_a?(Parser::Ruby::AstNode)
+          return unless statement.type == :call
+
+          Base.infer_java_class(statement.source, inferred_type, comments, statement)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module YARD
+  module Handlers
+    module JRuby
+      module ClassHandler
+        include Base
+
+        Ruby::ClassHandler.prepend(self)
+
+        def parse_superclass(superclass)
+          infer_java_class(superclass, CodeObjects::Java::ClassObject)&.then { |k| return k }
+          super
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module YARD
+  module Handlers
+    module JRuby
+      module ConstantHandler
+        include Base
+
+        Ruby::ConstantHandler.prepend(self)
+
+        def process_constant(statement)
+          infer_java_class(statement[1], nil, statement.comments)
+          super
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module YARD
+  module Handlers
+    module JRuby
+      class JavaImportHandler < Ruby::Base
+        include Base
+
+        handles method_call(:java_import)
+
+        process do
+          statement.parameters(false).each do |klass|
+            # first we auto-create the CodeObject for the class
+            obj = infer_java_class(klass)
+            next unless obj
+
+            # then we create a new constant in the current namespace
+            register CodeObjects::ConstantObject.new(namespace, obj.simple_name) { |o|
+                       o.source = statement
+                       o.value = klass.source
+                     }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module YARD
+  module Handlers
+    module JRuby
+      module MixinHandler
+        include Base
+
+        Ruby::MixinHandler.prepend(self)
+
+        def process_mixin(mixin)
+          if infer_java_class(mixin, CodeObjects::Java::InterfaceObject)
+            # make the Ruby::MixinHandler accept that this is a ref
+            def mixin.ref?
+              true
+            end
+          end
+          super
+        end
+      end
+    end
+  end
+end

data/lib/openhab/yard/html_helper.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module OpenHAB
+  module YARD
+    # @!visibility private
+    module HtmlHelper
+      def html_markup_markdown(text)
+        result = super
+
+        # re-link files in docs/*.md. They're written so they work on github without any
+        # processing
+        result.gsub!(%r{<a href="(?:[A-Za-z0-9_/-]+/)*([A-Za-z0-9_-]+).md(#[A-Za-z0-9_/-]+)?"},
+                     "<a href=\"file.\\1.html\\2\"")
+        result
+      end
+
+      # have to completely replace this method. only change is the regex splitting
+      # into parts now allows `.` as part of the identifier
+      # rubocop:disable Style
+      def format_types(typelist, brackets = true)
+        return unless typelist.is_a?(Array)
+
+        list = typelist.map do |type|
+          type = type.gsub(/([<>])/) { h($1) }
+          type = type.gsub(/([\w:.]+)/) { $1 == "lt" || $1 == "gt" ? $1 : linkify($1, $1) }
+          "<tt>" + type + "</tt>"
+        end
+        list.empty? ? "" : (brackets ? "(#{list.join(", ")})" : list.join(", "))
+      end
+      # rubocop:enable Style
+
+      def link_object(obj, title = nil, *)
+        ::YARD::Handlers::JRuby::Base.infer_java_class(obj) if obj.is_a?(String)
+        obj = ::YARD::Registry.resolve(object, obj, true, true) if obj.is_a?(String)
+        if obj.is_a?(::YARD::CodeObjects::Java::Base) && (see = obj.docstring.tag(:see))
+          # link to the first see tag
+          return linkify(see.name, title&.to_s || see.text)
+        end
+
+        super
+      end
+    end
+  end
+end

data/lib/openhab/yard/tags/constant_directive.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module OpenHAB
+  module YARD
+    module Tags
+      class ConstantDirective < ::YARD::Tags::Directive
+        def call
+          return unless handler
+
+          ::YARD::CodeObjects::ConstantObject.new(handler.namespace, tag.name.to_sym) do |obj|
+            obj.value = ""
+            obj.docstring = tag.text
+          end
+        end
+
+        ::YARD::Tags::Library.define_directive :constant, :with_title_and_text, self
+      end
+    end
+  end
+end

data/lib/openhab/yard/tags/group_directive.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module OpenHAB
+  module YARD
+    module Tags
+      module GroupDirective
+        ::YARD::Tags::GroupDirective.prepend(self)
+
+        def after_parse
+          return if tag.name.empty?
+          return unless handler
+
+          object = CodeObjects::GroupObject.new(handler.namespace, tag.name)
+          handler.extra_state.group = object
+          self.parser = parser.class.new(parser.library)
+          parser.state.inside_directive = true
+          parser.parse(tag.text, object, handler)
+          parser.state.inside_directive = false
+          object.docstring = parser.to_docstring # rubocop:disable Lint/UselessSetterCall
+        end
+      end
+    end
+  end
+end

data/lib/openhab/yard/tags/library.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+YARD::Tags::Library.define_directive :group, :with_title_and_text, ::YARD::Tags::GroupDirective

data/lib/openhab/yard.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require "byebug"
+
+Dir[File.expand_path("yard/**/*.rb", __dir__)].sort.each do |f|
+  require f
+end
+
+YARD::Templates::Template.extra_includes << ->(opts) { OpenHAB::YARD::HtmlHelper if opts.format == :html }
+YARD::Templates::Engine.register_template_path File.expand_path("../../templates", __dir__)
+YARD::Tags::Library.define_tag "Java Interface", :interface
+
+#
+# @!parse
+#   # @!visibility private
+#   module Comparable; end
+#
+#   # @!visibility private
+#   module Forwardable; end
+#
+#   # @!visibility private
+#   module Singleton; end
+#
+#   # Extensions to Ruby Numeric
+#   class Numeric; end
+#
+#   # @!visibility private
+#   class Object; end
+#
+#   # Extensions to Ruby Range
+#   class Range; end
+#