rspec-openhab-scripting 0.0.18-java → 0.0.19-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6ea44768dd3bccdfc7276944f329030e21182d161126e433126970f096543f46
-  data.tar.gz: 81be4550cd3ab271f43e15616959709bb9e5d1cf14a999dd8565e0b148d3a8d7
+  metadata.gz: ea386c264164b6c12be46d5483fdd349c3e5fdadcba22bff4987a2db5c6a9803
+  data.tar.gz: 20c364d137e43d5de1a1ab5eda9341318132cbde7532cf9c84901badce83ed49
 SHA512:
-  metadata.gz: 4d70a68375f21fab304d05b620125cf79b5767f3522d5e22a0608301b56e4ed3b2f6baba7942bdfcdb9ffed742378452720b79b7bfc5d7523544087a0bcb15bc
-  data.tar.gz: d2ce66901858dc37eb7c76b5f37f82da6147f1b471b8fc70097037099d677eb01c6e4e25d77e12105847e28156a919e059d5420271f9ce5cfcb0c9af933b4383
+  metadata.gz: 13ae42f75b1bcaa898969e4077cefd1bbbc0979a7a081b7e904db9ff2c0b9550205bef2f4d20e3c502c2d12c449b64886819622101cb4425ee8ce4083cc02ea8
+  data.tar.gz: dd85b3c9249e88031ed3bf297dd09c1e7698cdb6d0958b04b0efbe35117dc6c71043b22f258b49fa0b52bb58a98ff3c3d5e6e492c6f551c393ce5a16187e9f75

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

@@ -13,6 +13,8 @@ module OpenHAB
         end
 
         def service(name)
+          name = name.java_class if name.is_a?(Class)
+          name = name.name if name.is_a?(java.lang.Class)
           @services&.[](name)
         end
 

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

@@ -452,6 +452,8 @@ module OpenHAB
 
           rs = org.openhab.core.internal.service.ReadyServiceImpl.new
           re = org.openhab.core.automation.internal.RuleEngineImpl.new(mtr, rr, ss, rs)
+          OpenHAB::Core::OSGI.register_service(re)
+
           # overwrite thCallbacks to one that will spy to remove threading
           field = re.class.java_class.declared_field("thCallbacks")
           field.accessible = true

data/lib/rspec/openhab/helpers.rb

@@ -1,8 +1,51 @@
 # frozen_string_literal: true
 
+module OpenHAB
+  module Transform
+    class << self
+      def add_script(modules, script)
+        full_name = modules.join("/")
+        name = modules.pop
+        (@scripts ||= {})[full_name] = engine_factory.script_engine.compile(script)
+
+        mod = modules.inject(self) { |m, n| m.const_get(n, false) }
+        mod.singleton_class.define_method(name) do |input, **kwargs|
+          Transform.send(:transform, full_name, input, kwargs)
+        end
+      end
+
+      private
+
+      def engine_factory
+        @engine_factory ||= org.jruby.embed.jsr223.JRubyEngineFactory.new
+      end
+
+      def transform(name, input, kwargs)
+        script = @scripts[name]
+        ctx = script.engine.context
+        ctx.set_attribute("input", input.to_s, javax.script.ScriptContext::ENGINE_SCOPE)
+        kwargs.each do |(k, v)|
+          ctx.set_attribute(k.to_s, v.to_s, javax.script.ScriptContext::ENGINE_SCOPE)
+        end
+        script.eval
+      end
+    end
+  end
+end
+
 module RSpec
   module OpenHAB
     module Helpers
+      module BindingHelper
+        def add_kwargs_to_current_binding(binding, kwargs)
+          kwargs.each { |(k, v)| binding.local_variable_set(k, v) }
+        end
+      end
+
+      private_constant :BindingHelper
+
+      singleton_class.include(Helpers)
+
       def autoupdate_all_items
         @autoupdated_items ||= {}
         $ir.for_each do |_provider, item|
@@ -31,8 +74,151 @@ module RSpec
         thing.handler.callback.channel_triggered(nil, channel, event)
       end
 
+      def populate_items_from_api
+        api = ::OpenHAB::DSL::Imports.api
+        all_items = api.items
+
+        item_factory = org.openhab.core.library.CoreItemFactory.new
+
+        all_items.each do |item_json|
+          full_type = item_json["type"]
+          name = item_json["name"]
+
+          type, _dimension = full_type.split(":")
+          if type == "Group"
+            base_item = item_factory.create_item(item_json["groupType"], name) if item_json["groupType"]
+            if item_json["function"]
+              dto = org.openhab.core.items.dto.GroupFunctionDTO.new
+              dto.name = item_json.dig("function", "name")
+              dto.params = item_json.dig("function", "params")
+              function = org.openhab.core.items.dto.ItemDTOMapper.map_function(base_item, dto)
+            end
+            item = GroupItem.new(name, base_item, function)
+          else
+            item = item_factory.create_item(full_type, name)
+          end
+
+          item.label = item_json["label"]
+          item_json["tags"].each do |tag|
+            item.add_tag(tag)
+          end
+          item_json["metadata"]&.each do |key, config|
+            item.meta[key] = config["value"], config["config"]
+          end
+          item.meta["stateDescription"] = item_json["stateDescription"] if item_json["stateDescription"]
+          item.category = item_json["category"] if item_json["category"]
+
+          $ir.add(item)
+
+          next unless item.meta["channel"]&.value
+
+          channel_uid = org.openhab.core.thing.ChannelUID.new(item.meta["channel"].value)
+          channel = $things.get_channel(channel_uid)
+          next unless channel
+
+          link = org.openhab.core.thing.link.ItemChannelLink.new(item.name, channel_uid)
+          Core::Mocks::ItemChannelLinkProvider.instance.add(link)
+        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
+      end
+
+      def populate_things_from_api
+        api = ::OpenHAB::DSL::Imports.api
+        populate_channel_types_from_api(api)
+        populate_thing_types_from_api(api)
+
+        thing_type_registry = ::OpenHAB::Core::OSGI.service("org.openhab.core.thing.type.ThingTypeRegistry")
+
+        api.things.each do |thing_json|
+          uid = org.openhab.core.thing.ThingUID.new(thing_json["UID"])
+          type_uid = org.openhab.core.thing.ThingTypeUID.new(thing_json["thingTypeUID"])
+          bridge_uid = org.openhab.core.thing.ThingUID.new(thing_json["bridgeUID"]) if thing_json["bridgeUID"]
+
+          type = thing_type_registry.get_thing_type(type_uid)
+          klass = if type.is_a?(org.openhab.core.thing.type.BridgeType)
+                    org.openhab.core.thing.binding.builder.BridgeBuilder
+                  else
+                    org.openhab.core.thing.binding.builder.ThingBuilder
+                  end
+          builder = klass.create(type_uid, uid)
+          builder.with_bridge(bridge_uid) if bridge_uid
+
+          thing_json.each do |(k, v)|
+            case k
+            when "UID", "thingTypeUID", "bridgeUID", "statusInfo", "editable"
+              nil
+            when "channels"
+              builder.with_channels(v.map { |c| build_channel(c) })
+            when "configuration"
+              builder.with_configuration(org.openhab.core.config.core.Configuration.new(v))
+            else
+              builder.send(:"with_#{k}", v)
+            end
+          end
+
+          $things.add(builder.build)
+        end
+      end
+
+      def load_rules
+        automation_path = "#{org.openhab.core.OpenHAB.config_folder}/automation/jsr223/ruby/personal"
+
+        RSpec::OpenHAB::SuspendRules.suspend_rules do
+          Dir["#{automation_path}/*.rb"].each do |f|
+            load f
+          rescue Exception => e
+            warn "Failed loading #{f}: #{e.inspect}"
+            warn e.backtrace
+          end
+        end
+      end
+
+      def load_transforms
+        transform_path = "#{org.openhab.core.OpenHAB.config_folder}/transform"
+        Dir["#{transform_path}/**/*.script"].each do |filename|
+          script = File.read(filename)
+          next unless ruby_file?(script)
+
+          filename.slice!(0..transform_path.length)
+          dir = File.dirname(filename)
+          modules = dir == "." ? [] : moduleize(dir)
+          basename = File.basename(filename)
+          method = basename[0...-7]
+          modules << method
+          ::OpenHAB::Transform.add_script(modules, script)
+        end
+      end
+
       private
 
+      EMACS_MODELINE_REGEXP = /# -\*-(.+)-\*-/.freeze
+
+      def parse_emacs_modeline(line)
+        line[EMACS_MODELINE_REGEXP, 1]
+            &.split(";")
+            &.map(&:strip)
+            &.map { |l| l.split(":", 2).map(&:strip).tap { |a| a[1] ||= nil } }
+            &.to_h
+      end
+
+      def ruby_file?(script)
+        # check the first 1KB for an emacs magic comment
+        script[0..1024].split("\n").any? { |line| parse_emacs_modeline(line)&.dig("mode") == "ruby" }
+      end
+
+      def moduleize(term)
+        term
+          .sub(/^[a-z\d]*/, &:capitalize)
+          .gsub(%r{(?:_|(/))([a-z\d]*)}) { "#{$1}#{$2.capitalize}" }
+          .split("/")
+      end
+
       def restore_autoupdate_items
         return unless instance_variable_defined?(:@autoupdated_items)
 
@@ -40,6 +226,124 @@ module RSpec
           item.meta["autoupdate"] = meta
         end
       end
+
+      def populate_channel_types_from_api(api)
+        api.channel_types.each do |ct_json|
+          uid = org.openhab.core.thing.type.ChannelTypeUID.new(ct_json["UID"])
+          builder = case ct_json["kind"]
+                    when "STATE"
+                      org.openhab.core.thing.type.ChannelTypeBuilder.state(uid, ct_json["label"], ct_json["itemType"])
+                    when "TRIGGER"
+                      org.openhab.core.thing.type.ChannelTypeBuilder.trigger(uid, ct_json["label"])
+                    else
+                      raise ArgumentError, "Unrecognized channel type kind #{ct_json["kind"]} for #{uid}"
+                    end
+
+          ct_json.each do |(k, v)|
+            case k
+            when "parameters", "parameterGroups", "label", "kind", "UID", "itemType"
+              nil
+            when "commandDescription"
+              builder.with_command_description(build_command_description(v))
+            when "stateDescription"
+              builder.with_state_description_fragment(build_state_description_fragment(v))
+            when "advanced"
+              builder.is_advanced(v)
+            else
+              builder.send(:"with_#{k}", v)
+            end
+          end
+
+          ct = builder.build
+          Core::Mocks::ChannelTypeProvider.instance.add(ct)
+        end
+      end
+
+      def build_command_description(json)
+        org.openhab.core.types.CommandDescriptionBuilder.create
+           .with_command_options(json["commandOptions"].map do |o|
+                                   org.openhab.core.types.CommandOption.new(o["command"], o["label"])
+                                 end)
+           .build
+      end
+
+      def build_state_description_fragment(json)
+        org.openhab.core.types.StateDescriptionFragmentBuilder.create
+           .with_minimum(json["minimum"]&.to_d)
+           .with_maximum(json["maximum"]&.to_d)
+           .with_step(json["step"&.to_d])
+           .with_pattern(json["pattern"])
+           .with_read_only(json["readOnly"])
+           .with_options(json["options"].map { |o| org.openhab.core.types.StateOption.new(o["value"], o["label"]) })
+           .build
+      end
+
+      def populate_thing_types_from_api(api)
+        api.thing_types.each do |tt_json|
+          uid = org.openhab.core.thing.ThingTypeUID.new(tt_json["UID"])
+          builder = org.openhab.core.thing.type.ThingTypeBuilder.instance(uid, tt_json["label"])
+          tt_json.each do |(k, v)|
+            case k
+            when "UID", "label", "bridge"
+              nil
+            when "listed"
+              builder.is_listed(v)
+            when "channels"
+              builder.with_channels(v.map { |c| build_channel_definition(c) })
+            when "channelGroups"
+              builder.with_channel_groups(v.map { |cg| build_channel_group_definition(cg) })
+            else
+              builder.send(:"with#{k[0].upcase}#{k[1..]}", v)
+            end
+          end
+
+          tt = tt_json["bridge"] ? builder.build_bridge : builder.build
+          Core::Mocks::ThingTypeProvider.instance.add(tt)
+        end
+      end
+
+      def build_channel_definition(json)
+        org.openhab.core.thing.type.ChannelDefinition.new(
+          json["uid"],
+          org.openhab.core.thing.type.ChannelTypeUID.new(json["typeUID"]),
+          json["description"],
+          json["properties"],
+          nil
+        )
+      end
+
+      def build_channel_group_definition(json)
+        org.openhab.core.thing.type.ChannelGroupDefinition.new(
+          json["uid"],
+          org.openhab.core.thing.type.ChannelGroupTypeUID.new(json["typeUID"]),
+          json["label"],
+          json["description"]
+        )
+      end
+
+      def build_channel(json)
+        uid = org.openhab.core.thing.ChannelUID.new(json["uid"])
+        builder = org.openhab.core.thing.binding.builder.ChannelBuilder.create(uid)
+
+        json.each do |(k, v)|
+          case k
+          when "uid", "id", "linkedItems", "itemType"
+            nil
+          when "channelTypeUID"
+            builder.with_type(org.openhab.core.thing.type.ChannelTypeUID.new((v)))
+          when "configuration"
+            builder.with_configuration(org.openhab.core.config.core.Configuration.new(v))
+          when "kind"
+            builder.with_kind(org.openhab.core.thing.type.ChannelKind.const_get(v, false))
+          when "defaultTags"
+            builder.with_default_tags(v.to_set)
+          else
+            builder.send("with_#{k}", v)
+          end
+        end
+
+        builder.build
+      end
     end
 
     RSpec.configure do |config|

data/lib/rspec/openhab/hooks.rb

@@ -1,20 +1,33 @@
 # frozen_string_literal: true
 
-RSpec.configure do |config|
-  config.before do
-    suspend_rules do
-      $ir.for_each do |_provider, item|
-        next if item.is_a?(GroupItem) # groups only have calculated states
+module RSpec
+  module OpenHAB
+    RSpec.configure do |config|
+      config.before(:suite) do
+        Helpers.populate_things_from_api if ::OpenHAB::DSL::Imports.api.authenticated?
+        Helpers.populate_items_from_api
+        Helpers.load_transforms
+        Helpers.suspend_rules do
+          Helpers.load_rules
+        end
+      end
+
+      config.before do
+        suspend_rules do
+          $ir.for_each do |_provider, item|
+            next if item.is_a?(GroupItem) # groups only have calculated states
 
-        item.state = NULL unless item.raw_state == NULL
+            item.state = NULL unless item.raw_state == NULL
+          end
+        end
       end
-    end
-  end
 
-  config.after do
-    OpenHAB::DSL::Timers.timer_manager.cancel_all
-    Timecop.return
-    restore_autoupdate_items
-    RSpec::OpenHAB::Core::Mocks::PersistenceService.instance.reset
+      config.after do
+        ::OpenHAB::DSL::Timers.timer_manager.cancel_all
+        Timecop.return
+        restore_autoupdate_items
+        Core::Mocks::PersistenceService.instance.reset
+      end
+    end
   end
 end

data/lib/rspec/openhab/version.rb

@@ -2,6 +2,6 @@
 
 module RSpec
   module OpenHAB
-    VERSION = "0.0.18"
+    VERSION = "0.0.19"
   end
 end

data/lib/rspec-openhab-scripting.rb

@@ -88,7 +88,6 @@ require_relative "rspec/openhab/dsl/rules/triggers/watch"
 
 # RSpec additions
 require "rspec/core"
-require "rspec/openhab/items"
 require "rspec/openhab/helpers"
 require "rspec/openhab/hooks"
 require "rspec/openhab/suspend_rules"
@@ -97,26 +96,9 @@ RSpec.configure do |config|
   config.include OpenHAB::Core::EntityLookup
 end
 
-RSpec::OpenHAB::SuspendRules.suspend_rules do
-  RSpec::OpenHAB::Items.populate_things_from_api(api) if api.authenticated?
-  RSpec::OpenHAB::Items.populate_items_from_api(api)
-end
-
 # make bundler/inline _not_ destroy the already existing load path
 module Bundler
   module SharedHelpers
     def clean_load_path; end
   end
 end
-
-# load rules files
-OPENHAB_AUTOMATION_PATH = "#{org.openhab.core.OpenHAB.config_folder}/automation/jsr223/ruby/personal"
-
-RSpec::OpenHAB::SuspendRules.suspend_rules do
-  Dir["#{OPENHAB_AUTOMATION_PATH}/*.rb"].each do |f|
-    load f
-  rescue Exception => e
-    warn "Failed loading #{f}: #{e.inspect}"
-    warn e.backtrace
-  end
-end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rspec-openhab-scripting
 version: !ruby/object:Gem::Version
-  version: 0.0.18
+  version: 0.0.19
 platform: java
 authors:
 - Cody Cutrer
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-07-20 00:00:00.000000000 Z
+date: 2022-08-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
@@ -205,7 +205,6 @@ files:
 - lib/rspec/openhab/dsl/timers/timer.rb
 - lib/rspec/openhab/helpers.rb
 - lib/rspec/openhab/hooks.rb
-- lib/rspec/openhab/items.rb
 - lib/rspec/openhab/suspend_rules.rb
 - lib/rspec/openhab/version.rb
 - vendor/gems/jar-dependencies-1.0.0/lib/jar-dependencies.rb

data/lib/rspec/openhab/items.rb

@@ -1,220 +0,0 @@
-# frozen_string_literal: true
-
-module RSpec
-  module OpenHAB
-    module Items
-      class << self
-        def populate_items_from_api(api)
-          all_items = api.items
-
-          gfh = org.openhab.core.internal.items.GroupFunctionHelper.new
-          item_factory = org.openhab.core.library.CoreItemFactory.new
-
-          all_items.each do |item_json|
-            full_type = item_json["type"]
-            name = item_json["name"]
-
-            type, _dimension = full_type.split(":")
-            if type == "Group"
-              base_item = item_factory.create_item(item_json["groupType"], name) if item_json["groupType"]
-              if item_json["function"]
-                dto = org.openhab.core.items.dto.GroupFunctionDTO.new
-                dto.name = item_json.dig("function", "name")
-                dto.params = item_json.dig("function", "params")
-                function = gfh.create_group_function(dto, base_item)
-              end
-              item = GroupItem.new(name, base_item, function)
-            else
-              item = item_factory.create_item(full_type, name)
-            end
-
-            item.label = item_json["label"]
-            item_json["tags"].each do |tag|
-              item.add_tag(tag)
-            end
-            item_json["metadata"]&.each do |key, config|
-              item.meta[key] = config["value"], config["config"]
-            end
-            item.meta["stateDescription"] = item_json["stateDescription"] if item_json["stateDescription"]
-            item.category = item_json["category"] if item_json["category"]
-
-            $ir.add(item)
-
-            next unless item.meta["channel"]&.value
-
-            channel_uid = org.openhab.core.thing.ChannelUID.new(item.meta["channel"].value)
-            channel = $things.get_channel(channel_uid)
-            next unless channel
-
-            link = org.openhab.core.thing.link.ItemChannelLink.new(item.name, channel_uid)
-            Core::Mocks::ItemChannelLinkProvider.instance.add(link)
-          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
-        end
-
-        def populate_things_from_api(api)
-          populate_channel_types_from_api(api)
-          populate_thing_types_from_api(api)
-
-          thing_type_registry = ::OpenHAB::Core::OSGI.service("org.openhab.core.thing.type.ThingTypeRegistry")
-
-          api.things.each do |thing_json|
-            uid = org.openhab.core.thing.ThingUID.new(thing_json["UID"])
-            type_uid = org.openhab.core.thing.ThingTypeUID.new(thing_json["thingTypeUID"])
-            bridge_uid = org.openhab.core.thing.ThingUID.new(thing_json["bridgeUID"]) if thing_json["bridgeUID"]
-
-            type = thing_type_registry.get_thing_type(type_uid)
-            klass = if type.is_a?(org.openhab.core.thing.type.BridgeType)
-                      org.openhab.core.thing.binding.builder.BridgeBuilder
-                    else
-                      org.openhab.core.thing.binding.builder.ThingBuilder
-                    end
-            builder = klass.create(type_uid, uid)
-            builder.with_bridge(bridge_uid) if bridge_uid
-
-            thing_json.each do |(k, v)|
-              case k
-              when "UID", "thingTypeUID", "bridgeUID", "statusInfo", "editable"
-                nil
-              when "channels"
-                builder.with_channels(v.map { |c| build_channel(c) })
-              when "configuration"
-                builder.with_configuration(org.openhab.core.config.core.Configuration.new(v))
-              else
-                builder.send(:"with_#{k}", v)
-              end
-            end
-
-            $things.add(builder.build)
-          end
-        end
-
-        private
-
-        def populate_channel_types_from_api(api)
-          api.channel_types.each do |ct_json|
-            uid = org.openhab.core.thing.type.ChannelTypeUID.new(ct_json["UID"])
-            builder = case ct_json["kind"]
-                      when "STATE"
-                        org.openhab.core.thing.type.ChannelTypeBuilder.state(uid, ct_json["label"], ct_json["itemType"])
-                      when "TRIGGER"
-                        org.openhab.core.thing.type.ChannelTypeBuilder.trigger(uid, ct_json["label"])
-                      else
-                        raise ArgumentError, "Unrecognized channel type kind #{ct_json["kind"]} for #{uid}"
-                      end
-
-            ct_json.each do |(k, v)|
-              case k
-              when "parameters", "parameterGroups", "label", "kind", "UID", "itemType"
-                nil
-              when "commandDescription"
-                builder.with_command_description(build_command_description(v))
-              when "stateDescription"
-                builder.with_state_description_fragment(build_state_description_fragment(v))
-              when "advanced"
-                builder.is_advanced(v)
-              else
-                builder.send(:"with_#{k}", v)
-              end
-            end
-
-            ct = builder.build
-            Core::Mocks::ChannelTypeProvider.instance.add(ct)
-          end
-        end
-
-        def build_command_description(json)
-          org.openhab.core.types.CommandDescriptionBuilder.create
-             .with_command_options(json["commandOptions"].map do |o|
-                                     org.openhab.core.types.CommandOption.new(o["command"], o["label"])
-                                   end)
-             .build
-        end
-
-        def build_state_description_fragment(json)
-          org.openhab.core.types.StateDescriptionFragmentBuilder.create
-             .with_minimum(json["minimum"]&.to_d)
-             .with_maximum(json["maximum"]&.to_d)
-             .with_step(json["step"&.to_d])
-             .with_pattern(json["pattern"])
-             .with_read_only(json["readOnly"])
-             .with_options(json["options"].map { |o| org.openhab.core.types.StateOption.new(o["value"], o["label"]) })
-             .build
-        end
-
-        def populate_thing_types_from_api(api)
-          api.thing_types.each do |tt_json|
-            uid = org.openhab.core.thing.ThingTypeUID.new(tt_json["UID"])
-            builder = org.openhab.core.thing.type.ThingTypeBuilder.instance(uid, tt_json["label"])
-            tt_json.each do |(k, v)|
-              case k
-              when "UID", "label", "bridge"
-                nil
-              when "listed"
-                builder.is_listed(v)
-              when "channels"
-                builder.with_channels(v.map { |c| build_channel_definition(c) })
-              when "channelGroups"
-                builder.with_channel_groups(v.map { |cg| build_channel_group_definition(cg) })
-              else
-                builder.send(:"with#{k[0].upcase}#{k[1..]}", v)
-              end
-            end
-
-            tt = tt_json["bridge"] ? builder.build_bridge : builder.build
-            Core::Mocks::ThingTypeProvider.instance.add(tt)
-          end
-        end
-
-        def build_channel_definition(json)
-          org.openhab.core.thing.type.ChannelDefinition.new(
-            json["uid"],
-            org.openhab.core.thing.type.ChannelTypeUID.new(json["typeUID"]),
-            json["description"],
-            json["properties"],
-            nil
-          )
-        end
-
-        def build_channel_group_definition(json)
-          org.openhab.core.thing.type.ChannelGroupDefinition.new(
-            json["uid"],
-            org.openhab.core.thing.type.ChannelGroupTypeUID.new(json["typeUID"]),
-            json["label"],
-            json["description"]
-          )
-        end
-
-        def build_channel(json)
-          uid = org.openhab.core.thing.ChannelUID.new(json["uid"])
-          builder = org.openhab.core.thing.binding.builder.ChannelBuilder.create(uid)
-
-          json.each do |(k, v)|
-            case k
-            when "uid", "id", "linkedItems", "itemType"
-              nil
-            when "channelTypeUID"
-              builder.with_type(org.openhab.core.thing.type.ChannelTypeUID.new((v)))
-            when "configuration"
-              builder.with_configuration(org.openhab.core.config.core.Configuration.new(v))
-            when "kind"
-              builder.with_kind(org.openhab.core.thing.type.ChannelKind.const_get(v, false))
-            when "defaultTags"
-              builder.with_default_tags(v.to_set)
-            else
-              builder.send("with_#{k}", v)
-            end
-          end
-
-          builder.build
-        end
-      end
-    end
-  end
-end