rspec-openhab-scripting 0.0.1-java

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: b0469b486b84d65883d60fa79dbea29b5c5c86792a8f430d222c87bbb76b69d5
+  data.tar.gz: 188413ff354ddec32fdfb5c4fb0823efcde0a803b684acd3370070217f3d4f1c
+SHA512:
+  metadata.gz: fe7991e666341f3a035ea7bbb59d575affd17da44503eb90209b30a05df2f1802620696e8fc8701afe1f0abfcd64e5e8250415f463e5934a2e82ac15234cba83
+  data.tar.gz: 44d8592c747ac3d179b71a7bf05b35fa8e5b061969b7309f6b793df44135ff781d2d476a776e4f1431e214744188386e32aa875512f016589af62838f7709100

data/lib/rspec/bundler/inline.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Bundler
+  class DummyDsl
+    def source(*); end
+  end
+end
+
+def gemfile(*, &block)
+  # needs to be a no-op, since we're already running in the context of bundler
+  Bundler::DummyDsl.new.instance_eval(&block)
+end

data/lib/rspec/openhab/api.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require "faraday_middleware"
+
+module OpenHAB
+  class API
+    def initialize(url)
+      @faraday = Faraday.new(url) do |f|
+        f.request :retry
+        f.response :raise_error
+        f.response :json
+        f.adapter :net_http_persistent
+        f.path_prefix = "/rest/"
+      end
+    end
+
+    def version
+      body = @faraday.get.body
+      version = body.dig("runtimeInfo", "version")
+      version = "#{version}-SNAPSHOT" if body.dig("runtimeInfo", "buildString")&.start_with?("Build #")
+      version
+    end
+
+    def items
+      @faraday.get("items").body
+    end
+
+    def item(name)
+      @faraday.get("items/#{name}").body
+    rescue Faraday::ResourceNotFound
+      nil
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module OpenHAB
+  module Core
+    class CronScheduler
+      include Singleton
+
+      def schedule(*); end
+    end
+
+    OpenHAB::Core::OSGI.register_service("org.openhab.core.scheduler.CronScheduler", CronScheduler.instance)
+  end
+end

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

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module OpenHAB
+  module Core
+    OPENHAB_SHARE_PATH = "#{org.openhab.core.OpenHAB.config_folder}/automation/lib/ruby"
+
+    class << self
+      def add_rubylib_to_load_path
+        $LOAD_PATH.unshift(OPENHAB_SHARE_PATH) unless $LOAD_PATH.include?(OPENHAB_SHARE_PATH)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+def ch
+  Java::Ch
+end
+
+ch.qos.logback.classic.Level.class_eval do
+  alias_method :inspect, :to_s
+end
+
+module OpenHAB
+  module Core
+    class Logger
+      levels = %i[OFF ERROR WARN INFO DEBUG TRACE ALL]
+      levels.each { |level| const_set(level, ch.qos.logback.classic.Level.const_get(level)) }
+
+      extend Forwardable
+      delegate %i[level level=] => :@sl4fj_logger
+    end
+  end
+end
+
+root_logger = org.slf4j.LoggerFactory.get_logger(org.slf4j.Logger::ROOT_LOGGER_NAME)
+root_logger.level = OpenHAB::Core::Logger::INFO

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

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require "openhab/core/services"
+
+module OpenHAB
+  module Core
+    class << self
+      def wait_till_openhab_ready; end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module OpenHAB
+  module Core
+    class OSGI
+      class << self
+        def register_service(name, service)
+          (@services ||= {})[name] = service
+        end
+
+        def service(name)
+          @services&.[](name)
+        end
+
+        def services(name, filter: nil); end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module OpenHAB
+  module Core
+    module ScriptHandling
+      module_function
+
+      def script_loaded(&block); end
+      def script_unloaded(&block); end
+    end
+
+    module ScriptHandlingCallbacks
+    end
+  end
+
+  module DSL
+    module Core
+      ScriptHandling = OpenHAB::Core::ScriptHandling
+    end
+  end
+end

data/lib/rspec/openhab/dsl/imports.rb

@@ -0,0 +1,231 @@
+# frozen_string_literal: true
+
+require "openhab/core/osgi"
+
+module OpenHAB
+  module DSL
+    module Imports
+      class ScriptExtensionManagerWrapper
+        def initialize(manager)
+          @manager = manager
+        end
+
+        def get(type)
+          @manager.get("jruby", type)
+        end
+      end
+
+      class EventAdmin
+        include org.osgi.service.event.EventAdmin
+
+        def initialize(event_manager)
+          @event_manager = event_manager
+        end
+
+        def post_event(event)
+          send_event(event)
+        end
+
+        def send_event(event)
+          @event_manager.handle_event(event)
+        end
+      end
+
+      class BundleContext
+        include org.osgi.framework.BundleContext
+
+        def initialize(event_manager)
+          @event_manager = event_manager
+        end
+
+        def register_service(klass, service, _properties)
+          klass = klass.to_s
+          unless klass == "org.openhab.core.events.EventSubscriber"
+            raise NotImplementedError "Don't know how to process service #{service.inspect} of type #{klass.name}"
+          end
+
+          @event_manager.add_event_subscriber(service)
+        end
+      end
+
+      # don't depend on org.openhab.core.test
+      class VolatileStorageService
+        include org.openhab.core.storage.StorageService
+
+        def initialize
+          @storages = {}
+        end
+
+        def get_storage(name, *)
+          @storages[name] ||= VolatileStorage.new
+        end
+      end
+
+      class VolatileStorage < Hash
+        include org.openhab.core.storage.Storage
+
+        alias_method :get, :[]
+        alias_method :put, :[]=
+        alias_method :remove, :delete
+        alias_method :contains_key, :key?
+
+        alias_method :get_keys, :keys
+        alias_method :get_values, :values
+      end
+
+      class Bundle
+        include org.osgi.framework.Bundle
+        INSTALLED = 2
+
+        def initialize(*jar_args)
+          file = Jars.find_jar(*jar_args)
+          @jar = java.util.jar.JarFile.new(file)
+          @symbolic_name = jar_args[1]
+          @version = org.osgi.framework.Version.new(jar_args[2].tr("-", "."))
+        end
+
+        attr_reader :symbolic_name, :version
+
+        def state
+          INSTALLED
+        end
+
+        def find_entries(path, pattern, recurse)
+          pattern ||= recurse ? "**" : "*"
+          full_pattern = File.join(path, pattern)
+          entries = @jar.entries.select do |e|
+            File.fnmatch(full_pattern, e.name)
+          end
+          java.util.Collections.enumeration(entries.map { |e| java.net.URL.new("jar:file://#{@jar.name}!/#{e.name}") })
+        end
+      end
+
+      # subclass to expose private fields
+      class EventManager < org.openhab.core.internal.events.OSGiEventManager
+        field_reader :typedEventFactories, :typedEventSubscribers
+      end
+
+      @imported = false
+
+      class << self
+        def import_presets
+          return if @imported
+
+          @imported = true
+
+          # some background java threads get created; kill them at_exit
+          at_exit do
+            status = 0
+            status = $!.status if $!.is_a?(SystemExit)
+            exit!(status)
+          end
+
+          # OSGiEventManager will create a ThreadedEventHandler on OSGi activation;
+          # we're skipping that, and directly sending to a non-threaded event handler.
+          em = EventManager.new
+          eh = org.openhab.core.internal.events.EventHandler.new(em.typedEventSubscribers, em.typedEventFactories)
+          at_exit { eh.close }
+          ea = EventAdmin.new(eh)
+          ep = org.openhab.core.internal.events.OSGiEventPublisher.new(ea)
+
+          # the registries!
+          mr = org.openhab.core.internal.items.MetadataRegistryImpl.new
+          OpenHAB::Core::OSGI.register_service("org.openhab.core.items.MetadataRegistry", mr)
+          ir = org.openhab.core.internal.items.ItemRegistryImpl.new(mr)
+          ss = VolatileStorageService.new
+          ir.managed_provider = mip = org.openhab.core.items.ManagedItemProvider.new(ss, nil)
+          ir.add_provider(mip)
+          tr = org.openhab.core.thing.internal.ThingRegistryImpl.new
+          mtr = org.openhab.core.automation.internal.type.ModuleTypeRegistryImpl.new
+          rr = org.openhab.core.automation.internal.RuleRegistryImpl.new
+          rr.module_type_registry = mtr
+          rr.managed_provider = mrp = org.openhab.core.automation.ManagedRuleProvider.new(ss)
+          rr.add_provider(mrp)
+          iclr = org.openhab.core.thing.link.ItemChannelLinkRegistry.new(tr, ir)
+
+          # set up stuff accessed from rules
+          preset = org.openhab.core.automation.module.script.internal.defaultscope
+                      .DefaultScriptScopeProvider.new(ir, tr, rr, ep)
+          preset.default_presets.each do |preset_name|
+            preset.import_preset(nil, preset_name).each do |(name, value)|
+              next if name == "File"
+
+              if value.respond_to?(:ruby_class)
+                Object.const_set(name, value.ruby_class)
+              elsif /[[:upper:]]/.match?(name[0])
+                Object.const_set(name, value)
+              else
+                eval("$#{name} = value", binding, __FILE__, __LINE__) # $ir = value # rubocop:disable Security/Eval
+              end
+            end
+          end
+
+          # set up the rules engine part 1
+          mtrbp = org.openhab.core.automation.internal.provider.ModuleTypeResourceBundleProvider.new(nil)
+          mtgp = org.openhab.core.automation.internal.parser.gson.ModuleTypeGSONParser.new
+          mtrbp.add_parser(mtgp, {})
+          bundle = Bundle.new("org.openhab.core.bundles",
+                              "org.openhab.core.automation.module.script.rulesupport",
+                              OpenHAB::Core.openhab_version)
+          mtrbp.process_automation_provider(bundle)
+          bundle = Bundle.new("org.openhab.core.bundles",
+                              "org.openhab.core.automation",
+                              OpenHAB::Core.openhab_version)
+          mtrbp.process_automation_provider(bundle)
+          mtr.add_provider(mtrbp)
+
+          # set up script support stuff
+          srp = org.openhab.core.automation.module.script.rulesupport.shared.ScriptedRuleProvider.new
+          rr.add_provider(srp)
+          scmhf = org.openhab.core.automation.module.script.rulesupport.internal.ScriptedCustomModuleHandlerFactory.new
+          scmtp = org.openhab.core.automation.module.script.rulesupport.internal.ScriptedCustomModuleTypeProvider.new
+          mtr.add_provider(scmtp)
+          spmhf = org.openhab.core.automation.module.script.rulesupport.internal.ScriptedPrivateModuleHandlerFactory.new
+          se = org.openhab.core.automation.module.script.rulesupport.internal
+                  .RuleSupportScriptExtension.new(rr, srp, scmhf, scmtp, spmhf)
+          sew = ScriptExtensionManagerWrapper.new(se)
+          $se = $scriptExtension = sew # rubocop:disable Style/GlobalVars
+
+          # need to create some singletons referencing registries
+          org.openhab.core.model.script.ScriptServiceUtil.new(ir, tr, ep, nil, nil)
+          org.openhab.core.model.script.internal.engine.action.SemanticsActionService.new(ir)
+
+          # link up event bus infrastructure
+          iu = org.openhab.core.internal.items.ItemUpdater.new(ir)
+          ief = org.openhab.core.items.events.ItemEventFactory.new
+
+          sc = org.openhab.core.internal.common.SafeCallerImpl.new({})
+          aum = org.openhab.core.thing.internal.AutoUpdateManager.new({ "enabled" => "true" }, nil, ep, iclr, mr, tr)
+          cm = org.openhab.core.thing.internal.CommunicationManager.new(aum, nil, nil, iclr, ir, nil, ep, sc, tr)
+
+          em.add_event_subscriber(iu)
+          em.add_event_subscriber(cm)
+          em.add_event_factory(ief)
+
+          # set up the rules engine part 2
+          bc = BundleContext.new(em)
+          k = org.openhab.core.automation.internal.module.factory.CoreModuleHandlerFactory
+          # depending on OH version, this class is set up differently
+          cmhf = begin
+            cmhf = k.new
+            cmhf.item_registry = ir
+            cmhf.event_publisher = ep
+            cmhf.activate(bc)
+            cmhf
+          rescue ArgumentError
+            k.new(bc, ep, ir)
+          end
+
+          rs = org.openhab.core.internal.service.ReadyServiceImpl.new
+          re = org.openhab.core.automation.internal.RuleEngineImpl.new(mtr, rr, ss, rs)
+          re.add_module_handler_factory(cmhf)
+          re.add_module_handler_factory(scmhf)
+          re.add_module_handler_factory(spmhf)
+          re.onReadyMarkerAdded(nil)
+        end
+      end
+    end
+  end
+end
+
+OpenHAB::DSL.singleton_class.prepend(OpenHAB::DSL::Imports)

data/lib/rspec/openhab/dsl/timers/timer.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module OpenHAB
+  module DSL
+    class Timer
+      #
+      # Create a new Timer Object
+      #
+      # @param [Duration] duration Duration until timer should fire
+      # @param [Block] block Block to execute when timer fires
+      #
+      def initialize(duration:, thread_locals: {}, &block) # rubocop:disable Lint/UnusedMethodArgument
+        @duration = duration
+
+        Timers.timer_manager.add(self)
+      end
+
+      def reschedule(duration = nil)
+        duration ||= @duration
+
+        Timers.timer_manager.add(self)
+        reschedule(OpenHAB::DSL.to_zdt(duration))
+      end
+
+      #
+      # Cancel timer
+      #
+      # @return [Boolean] True if cancel was successful, false otherwise
+      #
+      def cancel
+        Timers.timer_manager.delete(self)
+      end
+
+      def terminated?; end
+      alias_method :has_terminated, :terminated?
+
+      private
+
+      def timer_block
+        proc do
+          Timers.timer_manager.delete(self)
+          yield(self)
+        end
+      end
+    end
+
+    #
+    # Convert TemporalAmount (Duration), seconds (float, integer), and Ruby Time to ZonedDateTime
+    # Note: TemporalAmount is added to now
+    #
+    # @param [Object] timestamp to convert
+    #
+    # @return [ZonedDateTime]
+    #
+    def self.to_zdt(timestamp)
+      logger.trace("Converting #{timestamp} (#{timestamp.class}) to ZonedDateTime")
+      return unless timestamp
+
+      case timestamp
+      when Java::JavaTimeTemporal::TemporalAmount then ZonedDateTime.now.plus(timestamp)
+      when ZonedDateTime then timestamp
+      when Time then timestamp.to_java(ZonedDateTime)
+      else
+        to_zdt(seconds_to_duration(timestamp)) ||
+          raise(ArgumentError, "Timestamp must be a ZonedDateTime, a Duration, a Numeric, or a Time object")
+      end
+    end
+
+    #
+    # Convert numeric seconds to a Duration object
+    #
+    # @param [Float, Integer] secs The number of seconds in integer or float
+    #
+    # @return [Duration]
+    #
+    def self.seconds_to_duration(secs)
+      return unless secs
+
+      if secs.respond_to?(:to_f)
+        secs.to_f.seconds
+      elsif secs.respond_to?(:to_i)
+        secs.to_i.seconds
+      end
+    end
+  end
+end

data/lib/rspec/openhab/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module RSpec
+  module OpenHAB
+    VERSION = "0.0.1"
+  end
+end

data/lib/rspec-openhab-scripting.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+# see https://github.com/jruby/jruby/issues/7262
+# in the meantime, I've "vendored" it, and just forcing it on the load path first
+$LOAD_PATH.unshift(File.expand_path("../vendor/gems/jar-dependencies-1.0.0/lib", __dir__))
+
+require "rspec/openhab/api"
+api = OpenHAB::API.new("http://#{ENV.fetch("OPENHAB_HOST", "localhost")}:#{ENV.fetch("OPENHAB_HTTP_PORT", "8080")}/")
+
+module OpenHAB
+  module Core
+    class << self
+      attr_accessor :openhab_version
+    end
+  end
+end
+
+oh_home = ENV.fetch("OPENHAB_HOME", "/usr/share/openhab")
+oh_runtime = ENV.fetch("OPENHAB_RUNTIME", "#{oh_home}/runtime")
+
+ENV["JARS_ADDITIONAL_MAVEN_REPOS"] = File.join(oh_runtime, "system")
+
+openhab_version = OpenHAB::Core.openhab_version = api.version
+
+require "rspec-openhab-scripting_jars"
+
+maven_require do
+  # upstream dependencies that I don't know how to infer from the openhab bundles alone
+  require "jar com.google.code.gson, gson, 2.8.9"
+  require "jar org.eclipse.xtext, org.eclipse.xtext, 2.26.0"
+  require "jar org.osgi, osgi.cmpn, 7.0.0"
+  require "jar org.osgi, org.osgi.framework, 1.8.0"
+  require "jar si.uom, si-units, 2.1"
+  require "jar tech.units, indriya, 2.1.3"
+
+  require "jar org.openhab.core.bundles, org.openhab.core, #{openhab_version}"
+  require "jar org.openhab.core.bundles, org.openhab.core.config.core, #{openhab_version}"
+  require "jar org.openhab.core.bundles, org.openhab.core.automation, #{openhab_version}"
+  require "jar org.openhab.core.bundles, org.openhab.core.automation.module.script, #{openhab_version}"
+  require "jar org.openhab.core.bundles, org.openhab.core.automation.module.script.rulesupport, #{openhab_version}"
+  require "jar org.openhab.core.bundles, org.openhab.core.model.core, #{openhab_version}"
+  require "jar org.openhab.core.bundles, org.openhab.core.model.script, #{openhab_version}"
+  require "jar org.openhab.core.bundles, org.openhab.core.semantics, #{openhab_version}"
+  require "jar org.openhab.core.bundles, org.openhab.core.thing, #{openhab_version}"
+end
+
+require "openhab/version"
+
+# we completely override some files from openhab-scripting
+$LOAD_PATH.unshift("#{__dir__}/rspec")
+
+oh = org.openhab.core.OpenHAB
+def oh.config_folder
+  ENV.fetch("OPENHAB_CONF", "/etc/openhab")
+end
+
+# global variables need to be set up before openhab-scripting loads
+require "openhab/log/logger"
+require "rspec/openhab/core/logger"
+require "openhab/dsl/imports"
+OpenHAB::DSL::Imports.import_presets
+
+require "openhab"
+
+require "rspec/openhab/core/cron_scheduler"
+
+# openhab-scripting uses a require_relative, so our override doesn't get used
+OpenHAB::DSL.send(:remove_const, :Timer)
+require_relative "rspec/openhab/dsl/timers/timer"
+
+# rubocop:disable Style/GlobalVars
+
+# populate item registry
+all_items = api.items
+all_items.each do |item_json|
+  type, _dimension = item_json["type"].split(":")
+  if type == "Group"
+    if item_json["groupType"]
+      type, _dimension = item_json["groupType"].split(":")
+      klass = OpenHAB::DSL::Items.const_get(:"#{type}Item")
+      base_item = klass.new(item_json["name"])
+    end
+    # TODO: create group function
+    item = GroupItem.new(item_json["name"], base_item)
+  else
+    klass = OpenHAB::DSL::Items.const_get(:"#{type}Item")
+    item = klass.new(item_json["name"])
+  end
+
+  item.label = item_json["label"]
+  item_json["tags"].each do |tag|
+    item.add_tag(tag)
+  end
+  $ir.add(item)
+end
+all_items.each do |item_json| # rubocop:disable Style/CombinableLoops
+  item_json["groupNames"].each do |group_name|
+    next unless (group = $ir.get(group_name))
+
+    group.add_member($ir.get(item_json["name"]))
+  end
+end
+
+# rubocop:enable Style/GlobalVars
+
+# load rules files
+OPENHAB_AUTOMATION_PATH = "#{org.openhab.core.OpenHAB.config_folder}/automation/jsr223/ruby/personal"
+
+# set up some environment the rules files expect
+Dir["#{OPENHAB_AUTOMATION_PATH}/*.rb"].each do |f|
+  load f
+rescue Exception => e # rubocop:disable Lint/RescueException
+  warn "Failed loading #{f}: #{e}"
+  warn e.backtrace
+end

data/lib/rspec-openhab-scripting_jars.rb

@@ -0,0 +1,14 @@
+# this is a generated file, to avoid over-writing it just delete this comment
+begin
+  require 'jar_dependencies'
+rescue LoadError
+  require 'ch/qos/logback/logback-classic/1.2.9/logback-classic-1.2.9.jar'
+  require 'org/slf4j/slf4j-api/1.7.32/slf4j-api-1.7.32.jar'
+  require 'ch/qos/logback/logback-core/1.2.9/logback-core-1.2.9.jar'
+end
+
+if defined? Jars
+  require_jar 'ch.qos.logback', 'logback-classic', '1.2.9'
+  require_jar 'org.slf4j', 'slf4j-api', '1.7.32'
+  require_jar 'ch.qos.logback', 'logback-core', '1.2.9'
+end

data/vendor/gems/jar-dependencies-1.0.0/lib/jar-dependencies.rb

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