habdsl 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 39341817368937700b7cabf1d0e5770c836ac18134c318eaefcc0d955b2805fa
+  data.tar.gz: bc867e6cb1bd2a63d90a54b092deef24e66a29d6faa7e6e1b0cc7862db66d32d
+SHA512:
+  metadata.gz: 418da45b2da36110be735b467f27557d4f974dd205f4ba4652752b17829e1fda6333b5fc7b7b6d0d24d37b34407e79fd134abf2240edf01e19652127b67bbc4d
+  data.tar.gz: 0e9d6e110faabd54db923bbd65ace69c7bdcd8e0acda5751962d3a60bd6bf0fbe363aa010d3b34fe12372ae44d330f5c5d0fe3447b17bf131be9f00f8542e872

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,32 @@
+AllCops:
+  TargetRubyVersion: 3.3
+  NewCops: enable
+
+Layout/LineLength:
+  Max: 120
+
+Layout/MultilineMethodCallIndentation:
+  EnforcedStyle: indented_relative_to_receiver
+
+Layout/SpaceInsideBlockBraces:
+  SpaceBeforeBlockParameters: false
+
+Metrics/AbcSize:
+  Max: 25
+
+Metrics/ParameterLists:
+  CountKeywordArgs: false
+
+Style/Alias:
+  Enabled: true
+  EnforcedStyle: prefer_alias_method
+
+Style/FormatStringToken:
+  Enabled: false
+
+Style/ParallelAssignment:
+  Enabled: false
+
+Style/StringLiterals:
+  Enabled: true
+  EnforcedStyle: double_quotes

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## [Unreleased]
+
+## [0.1.0] - 2025-05-27
+
+- Initial release

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,132 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+We as members, contributors, and leaders pledge to make participation in our
+community a harassment-free experience for everyone, regardless of age, body
+size, visible or invisible disability, ethnicity, sex characteristics, gender
+identity and expression, level of experience, education, socio-economic status,
+nationality, personal appearance, race, caste, color, religion, or sexual
+identity and orientation.
+
+We pledge to act and interact in ways that contribute to an open, welcoming,
+diverse, inclusive, and healthy community.
+
+## Our Standards
+
+Examples of behavior that contributes to a positive environment for our
+community include:
+
+* Demonstrating empathy and kindness toward other people
+* Being respectful of differing opinions, viewpoints, and experiences
+* Giving and gracefully accepting constructive feedback
+* Accepting responsibility and apologizing to those affected by our mistakes,
+  and learning from the experience
+* Focusing on what is best not just for us as individuals, but for the overall
+  community
+
+Examples of unacceptable behavior include:
+
+* The use of sexualized language or imagery, and sexual attention or advances of
+  any kind
+* Trolling, insulting or derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or email address,
+  without their explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Enforcement Responsibilities
+
+Community leaders are responsible for clarifying and enforcing our standards of
+acceptable behavior and will take appropriate and fair corrective action in
+response to any behavior that they deem inappropriate, threatening, offensive,
+or harmful.
+
+Community leaders have the right and responsibility to remove, edit, or reject
+comments, commits, code, wiki edits, issues, and other contributions that are
+not aligned to this Code of Conduct, and will communicate reasons for moderation
+decisions when appropriate.
+
+## Scope
+
+This Code of Conduct applies within all community spaces, and also applies when
+an individual is officially representing the community in public spaces.
+Examples of representing our community include using an official email address,
+posting via an official social media account, or acting as an appointed
+representative at an online or offline event.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported to the community leaders responsible for enforcement at
+[INSERT CONTACT METHOD].
+All complaints will be reviewed and investigated promptly and fairly.
+
+All community leaders are obligated to respect the privacy and security of the
+reporter of any incident.
+
+## Enforcement Guidelines
+
+Community leaders will follow these Community Impact Guidelines in determining
+the consequences for any action they deem in violation of this Code of Conduct:
+
+### 1. Correction
+
+**Community Impact**: Use of inappropriate language or other behavior deemed
+unprofessional or unwelcome in the community.
+
+**Consequence**: A private, written warning from community leaders, providing
+clarity around the nature of the violation and an explanation of why the
+behavior was inappropriate. A public apology may be requested.
+
+### 2. Warning
+
+**Community Impact**: A violation through a single incident or series of
+actions.
+
+**Consequence**: A warning with consequences for continued behavior. No
+interaction with the people involved, including unsolicited interaction with
+those enforcing the Code of Conduct, for a specified period of time. This
+includes avoiding interactions in community spaces as well as external channels
+like social media. Violating these terms may lead to a temporary or permanent
+ban.
+
+### 3. Temporary Ban
+
+**Community Impact**: A serious violation of community standards, including
+sustained inappropriate behavior.
+
+**Consequence**: A temporary ban from any sort of interaction or public
+communication with the community for a specified period of time. No public or
+private interaction with the people involved, including unsolicited interaction
+with those enforcing the Code of Conduct, is allowed during this period.
+Violating these terms may lead to a permanent ban.
+
+### 4. Permanent Ban
+
+**Community Impact**: Demonstrating a pattern of violation of community
+standards, including sustained inappropriate behavior, harassment of an
+individual, or aggression toward or disparagement of classes of individuals.
+
+**Consequence**: A permanent ban from any sort of public interaction within the
+community.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage],
+version 2.1, available at
+[https://www.contributor-covenant.org/version/2/1/code_of_conduct.html][v2.1].
+
+Community Impact Guidelines were inspired by
+[Mozilla's code of conduct enforcement ladder][Mozilla CoC].
+
+For answers to common questions about this code of conduct, see the FAQ at
+[https://www.contributor-covenant.org/faq][FAQ]. Translations are available at
+[https://www.contributor-covenant.org/translations][translations].
+
+[homepage]: https://www.contributor-covenant.org
+[v2.1]: https://www.contributor-covenant.org/version/2/1/code_of_conduct.html
+[Mozilla CoC]: https://github.com/mozilla/diversity
+[FAQ]: https://www.contributor-covenant.org/faq
+[translations]: https://www.contributor-covenant.org/translations

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2025 SenoOh
+
+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.

data/README.md

@@ -0,0 +1,423 @@
+# Habdsl
+Habdsl implements a mechanism to generate openHAB Items configuration DSL from:
++ Ruby internal DSL syntax.
++ Ruby internal DSL syntax and JSON data.
++ Ruby internal DSL syntax and Spreadsheet data.
+
+It enables developers to define openHAB Items using familiar Ruby syntax, improving readability and maintainability.
+
+For example: 
+```bash
+$ vim habdsl.rb
+```
+
+```ruby
+require 'habdsl'
+
+input_code = <<~RUBY
+  location(name: "house", label: "House", icon: "house") do
+    location(name: "livingroom", label: "Living Room", icon: "bedroom") do
+      equipment(name: "sensor", label: "Sensor", icon: "siren") do
+        point(name: "temperature", label: "Temperature", type: "Number",
+              icon: "temperature", tags: ["Temperature"], channel: "mqtt:topic:mqttbroker:temperature")
+      end
+    end
+  end
+RUBY
+
+output = Habdsl::DslParser.parse(input_code: input_code)
+puts output.dsl
+```
+
+```bash
+$ ruby habdsl.rb
+
+Group house "House" <house> ["Location"]
+Group livingroom "Living Room" <bedroom> (house) ["Location"]
+Group sensor "Sensor" <siren> (livingroom) ["Equipment"]
+Number temperature "Temperature" <temperature> (sensor) ["Temperature"] {channel="mqtt:topic:mqttbroker:temperature"}
+```
+When you have the output.dsl from habdsl, paste it into a file with the .items extension and place it in the openHAB items file storage directory.
+
+As an example, assume that the name of the file to be pasted is `tempareture.items` and the openHAB items file storage directory is `/etc/openhab/items`.
+
+```bash
+$ ruby habdsl.rb >> /etc/openhab/items/temperature.items
+```
+
+When all is complete, the Items UI in openHAB will reflect the list of Items you have created.
+
+![Overview](./doc/tempareture_items.png)
+
+
+## Installation
+
+Install as a gem
+
+```ruby
+gem 'habdsl'
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install habdsl
+
+## Input formats
+
+Before using `habdsl`, make sure your **Spreadsheet** and **Ruby internal DSL code** follow the expected formats:
+
+### Ruby internal DSL format
+The Ruby DSL defines a hierarchical structure used to describe semantic models for `openHAB`.  
+Each DSL element corresponds to an object (`location`, `equipment`, or `point`) and is subject to strict structural validation.
+
+- `location` (e.g., a room or area)  
+  - `equipment` (e.g., a sensor or appliance)  
+    - `point` (e.g., a measurable property or control)
+
+Each DSL block maps to a structured entity that can be validated and transformed into openHAB items.  
+
+---
+
+#### Hierarchy Rules
+
+- `location` can contain:
+  - other `locations` (nested)
+  - `equipment`
+
+- `equipment` can contain:
+  - other `equipment'` (nested)
+  - `point`
+ 
+> - `location`**may contain nested** `location`, as well as `equipment`.
+> - `point` **must be defined inside an `equipment`**
+> - `point` **cannot contain any child elements**
+> - `equipment` **cannot contain** `location`
+
+❗ Violating this hierarchy will result in a validation error.
+
+---
+
+#### DSL Argument Validation Rules
+
+#### `location` block
+
+```ruby
+location(name:, label:, icon:, parent: nil) do
+  # ...
+end
+```
++ name
+  + Must not start with a number.
+  + Allowed characters: A-Z, a-z, 0-9, _ (underscores).
++ label
+  + Any free-form string.
++ icon
+  + Must be one of the icons listed in the openHAB Classic icon set: 
+  https://www.openhab.org/docs/configuration/iconsets/classic/
++ parent
+  + Optional.
+  + Must be the name of a parent `location`.
+  + If declared in a nested block, this is inferred automatically and does not need to be set explicitly.
++ type
+  + Automatically set to `Group`, no need to specify.
++ tags
+  + Automatically set to include `Location`, no need to specify.
+
+
+#### `equipment` block
+```ruby
+equipment(name:, label:, icon:, parent: nil) do
+  # ...
+end
+```
++ name
+  + Must not start with a number.
+  + Allowed characters: A-Z, a-z, 0-9, _ (underscores).
++ label
+  + Any free-form string.
++ icon
+  + Must be one of the icons listed in the openHAB Classic icon set: 
+  https://www.openhab.org/docs/configuration/iconsets/classic/
++ parent
+  + Optional.
+  + Must be the name of a parent `location` or `equipment`.
+  + If declared in a nested block, this is inferred automatically and does not need to be set explicitly.
++ type
+  + Automatically set to `Group`, no need to specify.
++ tags
+  + Automatically set to include `Equipment`, no need to specify.
+
+
+
+#### `point` block
+```ruby
+point(name:, label:, type:, icon:, tags:, parent: nil, channel: nil)
+```
++ name
+  + Must not start with a number.
+  + Allowed characters: A-Z, a-z, 0-9, _ (underscores).
++ label
+  + Any free-form string.
++ type
+  + Must be one of the valid openHAB item types listed here:
+  https://www.openhab.org/docs/concepts/items.html
++ icon
+  + Must be one of the icons listed in the openHAB Classic icon set: 
+  https://www.openhab.org/docs/configuration/iconsets/classic/
++ tags
+  + Must be one or more valid tags from the openHAB REST API endpoint: 
+```sh
+  $ curl -X GET "http://<openHAB_address>:<port>/rest/tags" -H "Accept: application/json"
+```
++ parent
+  + Optional.
+  + Must be the name of a parent `Equipment`.
+  + If declared in a nested block, this is inferred automatically.
++ channel
+  + Optional.
+  + Select the UID of the Things you want to link to this Items.
+
+
+**Valid Example:**
+```ruby
+location(name: "house", label: "House", icon: "house") do
+  table.each do |room|
+    location(name: "#{room[:name]}", label: "#{room[:label]}", icon: "bedroom") do
+      equipment(name: "#{room[:name]}_sensor", label: "#{room[:name]}_Sensor", icon: "siren") do
+        point(name: "#{room[:name]}_temperature", label: "#{room[:name]} Temperature", type: "Number",
+              icon: "temperature", tags: ["Temperature"], channel: "mqtt:topic:mqttbroker:temperature")
+      end
+    end
+  end
+end
+```
+
+---
+***Explanation***
++ This DSL structure defines a root location called "house", and iterates over each room from a dataset to dynamically generate nested location, equipment, and point blocks.
+
++ Each location represents a room, each equipment block represents a sensor in the room, and each point block defines a specific data point (e.g., temperature).
+
++ The DSL will be compiled into openHAB Items configuration DSL automatically.
+
+***About table***
++ The variable table is an array of hashes that is generated by parsing either a Spreadsheet (Excel) or JSON file.
++ It is produced by using the Habdsl::SheetParser.parse(...) or Habdsl::JsonParser.parse(...) methods.
++ Each hash in table corresponds to a row of data in the input file. For example:
+
+```json
+[
+  { "name": "livingroom", "label": "Living Room" },
+  { "name": "bedroom", "label": "Bed Room" },
+  { "name": "kitchen", "label": "Kitchen" }
+]
+```
++ Using table.each, the code dynamically creates DSL definitions based on that data.
+
+---
+
+
+
+### Spreadsheet
+The Spreadsheet serves as a data source that is combined with your Ruby internal DSL code to automatically generate openHAB Items configuration DSL.
+
+Each row (after the header) represents a unit of configuration, such as a room, a device, or a sensor, and contains fields like name and label. These fields are injected into the DSL using iteration (typically via table.each), allowing you to dynamically define multiple items based on spreadsheet contents.
+
+- The **first row** must contain the **headers** (column names).
+- Each **subsequent row** represents one configuration entry (e.g., an openHAB item).
+- The headers can be arbitrary, but must match the keys used in the Ruby DSL code (e.g., `:name`, `:label`, etc.).
+
+**Example:**
+
+| name  | label  |
+|-------|--------|
+| livingroom | Living Room  |
+| bedroom | Bed Room  |
+| kitchen | Kitchen  |
+
+### JSON
+The JSON file provides structured data that will be dynamically combined with your Ruby internal DSL code to generate openHAB Items configuration DSL.
+
+Each object in the JSON array corresponds to a unit of configuration — for example, a room or device — and the data it contains (such as name and label) is injected into the DSL using iteration (typically via table.each).
+
++ The JSON file must represent an array of objects (dictionaries/hashes).
+
++ Each object represents one configuration entry (e.g., an openHAB item).
+
++ The keys in each object should match the ones used in the Ruby DSL code (e.g., :name, :label, etc.).
+
+**Example:**
+
+```json
+[
+  { "name": "livingroom", "label": "Living Room" },
+  { "name": "bedroom",    "label": "Bed Room" },
+  { "name": "kitchen",    "label": "Kitchen" }
+]
+```
+
+
+## Usage
+### Examples
+The sample code is placed in example/.
+Try it out by executing it.
+
+```sh
+$ bundle exec ruby example/example_dslparser.rb
+$ bundle exec ruby example/example_jsonparser.rb
+$ bundle exec ruby example/example_sheetparser.rb
+```
+
+
+### Make openHAB's Items configuration DSL from SpreadSheet
+You can use the `Habdsl::SheetParser` class so habdsl automatically parses an Spreadsheet and Ruby internal DSL code, combining them to generate openHAB Items configuration DSL for item configuration.
+
+#### Example usage
+```ruby
+require 'habdsl'
+
+input_code = File.read("path/to/your_ruby_dsl_file")
+excel_path = "path/to/your_excel_file"
+output = Habdsl::SheetParser.parse(input_code: input_code, excel_path: excel_path)
+output.table
+# => Returns an array of hashes.
+# Each hash maps the spreadsheet’s headers (from the first row) to the corresponding values in each data row.
+# For example, if the headers are :name and :label:
+# [
+#   { "name": "livingroom", "label": "Living Room" },
+#   { "name": "bedroom",    "label": "Bed Room" },
+#   { "name": "kitchen",    "label": "Kitchen" }
+# ]
+
+output.dsl
+# => Returns a string containing the generated openHAB Items configuration DSL. 
+# For example, 
+
+# Group house "House" <house> ["Location"]
+# Group livingroom "Living Room" <bedroom> (house) ["Location"]
+# Group livingroom_sensor "livingroom_Sensor" <siren> (livingroom) ["Equipment"]
+# Number livingroom_temperature "livingroom Temperature" <temperature> (livingroom_sensor) ["Temperature"]
+# Group bedroom "Bed Room" <bedroom> (house) ["Location"]
+# Group bedroom_sensor "bedroom_Sensor" <siren> (bedroom) ["Equipment"]
+# Number bedroom_temperature "bedroom Temperature" <temperature> (bedroom_sensor) ["Temperature"]
+# Group kitchen "Kitchen" <bedroom> (house) ["Location"]
+# Group kitchen_sensor "kitchen_Sensor" <siren> (kitchen) ["Equipment"]
+# Number kitchen_temperature "kitchen Temperature" <temperature> (kitchen_sensor) ["Temperature"]
+```
+
+### Make openHAB's Items configuration DSL from JSON
+You can use the `Habdsl::JsonParser` class so habdsl automatically parses an JSON code and Ruby internal DSL code, combining them to generate openHAB Items configuration DSL for item configuration.
+
+#### Example usage
+```ruby
+require 'habdsl'
+
+input_code = File.read("path/to/your_ruby_dsl_file")
+json_code = File.read("path/to/your_json_file")
+output = Habdsl::JsonParser.parse(input_code: input_code, json_code: json_code)
+output.table
+# => Returns an array of hashes.
+# For example, 
+# [
+#   { "name": "livingroom", "label": "Living Room" },
+#   { "name": "bedroom",    "label": "Bed Room" },
+#   { "name": "kitchen",    "label": "Kitchen" }
+# ]
+
+output.dsl
+# => Returns a string containing the generated openHAB Items configuration DSL 
+# For example, 
+
+# Group house "House" <house> ["Location"]
+# Group livingroom "Living Room" <bedroom> (house) ["Location"]
+# Group livingroom_sensor "livingroom_Sensor" <siren> (livingroom) ["Equipment"]
+# Number livingroom_temperature "livingroom Temperature" <temperature> (livingroom_sensor) ["Temperature"]
+# Group bedroom "Bed Room" <bedroom> (house) ["Location"]
+# Group bedroom_sensor "bedroom_Sensor" <siren> (bedroom) ["Equipment"]
+# Number bedroom_temperature "bedroom Temperature" <temperature> (bedroom_sensor) ["Temperature"]
+# Group kitchen "Kitchen" <bedroom> (house) ["Location"]
+# Group kitchen_sensor "kitchen_Sensor" <siren> (kitchen) ["Equipment"]
+# Number kitchen_temperature "kitchen Temperature" <temperature> (kitchen_sensor) ["Temperature"]
+```
+
+### Make openHAB's Items configuration DSL from Only DSL
+You can use the `Habdsl::DslParser` class so habdsl automatically parses an Ruby internal DSL code and generate openHAB Items configuration DSL.
+
+#### Example usage
+```ruby
+require 'habdsl'
+
+input_code = <<~RUBY
+  location(name: "house", label: "House", icon: "house") do
+    location(name: "livingroom", label: "Living Room", icon: "bedroom") do
+      equipment(name: "sensor", label: "Sensor", icon: "siren") do
+        point(name: "temperature", label: "Temperature", type: "Number",
+              icon: "temperature", tags: ["Temperature"])
+      end
+    end
+  end
+RUBY
+
+output = Habdsl::DslParser.parse(input_code: input_code)
+output.table
+# => Returns nil.
+
+
+output.dsl
+# => Returns a string containing the generated openHAB Items configuration DSL 
+# For example, 
+
+# Group house "House" <house> ["Location"]
+# Group livingroom "Living Room" <bedroom> (house) ["Location"]
+# Group livingroom_sensor "livingroom_Sensor" <siren> (livingroom) ["Equipment"]
+# Number livingroom_temperature "livingroom Temperature" <temperature> (livingroom_sensor) ["Temperature"]
+```
+
+
+
+### Make openHAB's Items configuration DSL by using `bin/habdsl_cli.rb`
+
+You can use the `bin/habdsl_cli.rb` script to interactively select an Spreadsheet file, input Ruby internal DSL via the terminal, and automatically generate openHAB Items configuration DSL.
+
+This command-line tool performs the following steps:
+
+1. Prompts you to navigate directories and select a spreadsheet file (`.xls`, `.xlsx`, or `.xlsm`).
+2. Accepts Ruby internal DSL code via standard input (end with two consecutive empty lines or `Ctrl + D`).
+3. Combines the spreadsheet data and DSL to generate openHAB Items configuration DSL.
+4. Prompts you for an output filename and saves the generated DSL under the `output/` directory.
+
+#### Example usage
+
+```sh
+$ bundle exec ruby bin/habdsl_cli.rb
+```
+You'll then be prompted to:
+
+1. Select an Spreadsheet file
+2. Enter your Ruby DSL code
+3. Provide a name for the output file (e.g., my_items.items)
+4. After completion, the result will be saved in:
+`output/your_output_file.items`
+
+If any syntax errors or processing issues occur, they will be printed to the console with a detailed backtrace.
+
+
+## Development
+
+TODO
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/habdsl. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/[USERNAME]/habdsl/blob/main/CODE_OF_CONDUCT.md).
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+## Code of Conduct
+
+Everyone interacting in the JayFlavoredMarkdown project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/[USERNAME]/habdsl/blob/main/CODE_OF_CONDUCT.md).

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+task default: %i[spec rubocop]

data/example/example.json

@@ -0,0 +1,5 @@
+[
+    { "name": "livingroom", "label": "Living Room" },
+    { "name": "bedroom",    "label": "Bed Room" },
+    { "name": "kitchen",    "label": "Kitchen" }
+]

data/example/example_dsl.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+location(name: "house", label: "House", icon: "house") do
+  table.each do |room|
+    location(name: "#{room[:name]}", label: "#{room[:label]}", icon: "bedroom") do
+      equipment(name: "#{room[:name]}_sensor", label: "#{room[:name]}_Sensor", icon: "siren") do
+        point(name: "#{room[:name]}_temperature", label: "#{room[:name]} Temperature", type: "Number",
+              icon: "temperature", tags: ["Temperature"], channel: "mqtt:topic:mqtt_topic:temperature")
+      end
+    end
+  end
+end

data/example/example_dslparser.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require "#{Dir.pwd}/lib/habdsl"
+
+input_code = <<~RUBY
+  location(name: "house", label: "House", icon: "house") do
+    location(name: "livingroom", label: "Living Room", icon: "bedroom") do
+      equipment(name: "sensor", label: "Sensor", icon: "siren") do
+        point(name: "temperature", label: "Temperature", type: "Number",
+              icon: "temperature", tags: ["Temperature"], channel: "mqtt:topic:mqttbroker:temperature")
+      end
+    end
+  end
+RUBY
+
+begin
+  output = Habdsl::DslParser.parse(input_code: input_code)
+  puts "=== Generated table ==="
+  p output.table
+  puts ""
+  puts "=== Generated DSL ==="
+  puts output.dsl
+rescue StandardError => e
+  puts "エラー: #{e.message}"
+end

data/example/example_jsonparser.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require "#{Dir.pwd}/lib/habdsl"
+
+input_code = File.read("#{Dir.pwd}/example/example_dsl.rb")
+
+json_code = File.read("#{Dir.pwd}/example/example.json")
+
+begin
+  output = Habdsl::JsonParser.parse(input_code: input_code, json_code: json_code)
+  puts "=== Generated table ==="
+  p output.table
+  puts ""
+  puts "=== Generated DSL ==="
+  puts output.dsl
+rescue StandardError => e
+  puts "エラー: #{e.message}"
+end

data/example/example_sheetparser.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require "#{Dir.pwd}/lib/habdsl"
+
+input_code = File.read("#{Dir.pwd}/example/example_dsl.rb")
+
+excel_path = "#{Dir.pwd}/example/example.xlsx"
+
+begin
+  output = Habdsl::SheetParser.parse(input_code: input_code, excel_path: excel_path)
+  puts "=== Generated table ==="
+  p output.table
+  puts ""
+  puts "=== Generated DSL ==="
+  puts output.dsl
+rescue StandardError => e
+  puts "エラー: #{e.message}"
+end

data/lib/habdsl/base_parser.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require "ripper"
+require_relative "model/dsl"
+require_relative "result_parser"
+
+module Habdsl
+  # Class that parses DSL code and generates a result.
+  class BaseParser
+    class DSLValidationError < StandardError; end
+
+    def self.evaluate_dsl(input_code:, table:)
+      raise DSLValidationError, "Syntax error: DSL code contains a syntax error." if Ripper.sexp(input_code).nil?
+
+      if table.any? && !input_code.include?("table")
+        raise DSLValidationError, "'table' is not used in the DSL code but table data was provided."
+      end
+
+      dsl = Habdsl::Model::Dsl.new
+      defined_objects = []
+
+      eval_context = Object.new
+
+      eval_context.define_singleton_method(:location) do |**args, &block|
+        loc = dsl.location(**args, &block)
+        defined_objects << loc
+        loc
+      end
+
+      eval_context.define_singleton_method(:equipment) do |**args, &block|
+        eq = dsl.equipment(**args, &block)
+        defined_objects << eq
+        eq
+      end
+
+      eval_context.define_singleton_method(:point) do |**args|
+        dsl.point(**args)
+      end
+
+      eval_context.define_singleton_method(:table) { table }
+
+      begin
+        eval_context.instance_eval(input_code)
+      rescue StandardError => e
+        raise DSLValidationError, "Runtime error during DSL evaluation: #{e.class} - #{e.message}"
+      end
+
+      generated_output = defined_objects.map(&:to_s).join("\n")
+
+      if input_code.include?("table") && table.is_a?(Array) && !table.empty?
+        # Check if table keys were actually used in the generated output
+        unused_keys = table.first.keys.reject do |key|
+          table.any? {|row| generated_output.include?(row[key].to_s) }
+        end
+
+        if unused_keys.any?
+          raise DSLValidationError,
+                "Validation error: The following table keys are not used in the generated DSL output: #{unused_keys.join(', ')}"
+        end
+      end
+
+      ResultParser.new(table: table, dsl: generated_output)
+    end
+  end
+end

data/lib/habdsl/dsl_parser.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require "ripper"
+require_relative "model/dsl"
+require_relative "result_parser"
+
+module Habdsl
+  # DSLのみを評価してopenHAB設定DSLを生成するパーサ
+  class DslParser
+    class DSLValidationError < StandardError; end
+
+    def self.parse(input_code:)
+      raise DSLValidationError, "Syntax error: DSL code contains a syntax error." if Ripper.sexp(input_code).nil?
+
+      dsl = Habdsl::Model::Dsl.new
+      defined_objects = []
+
+      eval_context = Object.new
+
+      eval_context.define_singleton_method(:location) do |**args, &block|
+        loc = dsl.location(**args, &block)
+        defined_objects << loc
+        loc
+      end
+
+      eval_context.define_singleton_method(:equipment) do |**args, &block|
+        eq = dsl.equipment(**args, &block)
+        defined_objects << eq
+        eq
+      end
+
+      eval_context.define_singleton_method(:point) do |**args|
+        dsl.point(**args)
+      end
+
+      eval_context.instance_eval(input_code)
+
+      generated_output = defined_objects.map(&:to_s).join("\n")
+
+      ResultParser.new(dsl: generated_output, table: nil)
+    end
+  end
+end

data/lib/habdsl/json_parser.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "json"
+require_relative "base_parser"
+
+module Habdsl
+  # Parser for JSON input
+  class JsonParser
+    def self.parse(input_code:, json_code:)
+      table = JSON.parse(json_code, symbolize_names: true)
+
+      raise ArgumentError, "Parsed JSON must be an Array of hashes" unless table.is_a?(Array)
+
+      raise ArgumentError, "JSON data array is empty" if table.empty?
+
+      BaseParser.evaluate_dsl(input_code: input_code, table: table)
+    end
+  end
+end

data/lib/habdsl/model/dsl.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative "location"
+require_relative "equipment"
+require_relative "point"
+
+module Habdsl
+  module Model
+    # DSL for defining locations, equipment, and points
+    class Dsl
+      def location(name:, label:, icon:, parent: nil, &)
+        loc = Habdsl::Model::Location.new(name: name, label: label, icon: icon, parent: parent)
+        loc.instance_eval(&) if block_given?
+        loc
+      end
+
+      def equipment(name:, label:, icon:, parent: nil, &)
+        eq = Habdsl::Model::Equipment.new(name: name, label: label, icon: icon, parent: parent)
+        eq.instance_eval(&) if block_given?
+        eq
+      end
+
+      def point(name:, label:, type:, icon:, tags:, parent: nil, channel: nil)
+        Habdsl::Model::Point.new(name: name, label: label, type: type, icon: icon, tags: tags, parent: parent,
+                                 channel: channel)
+      end
+    end
+  end
+end

data/lib/habdsl/model/equipment.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Habdsl
+  module Model
+    # Represents a piece of equipment in the DSL.
+    class Equipment
+      attr_reader :name, :label, :icon, :parent, :points, :sub_equipments
+
+      def initialize(name:, label:, icon:, parent: nil)
+        validate!(name, "name")
+        validate!(icon, "icon")
+
+        @name = name
+        @label = label
+        @icon = icon
+        @parent = parent
+        @points = []
+        @sub_equipments = []
+      end
+
+      def equipment(name:, label:, icon:, parent: nil, &)
+        eq = Equipment.new(name: name, label: label, icon: icon, parent: parent)
+        eq.instance_eval(&) if block_given?
+        @sub_equipments << eq
+      end
+
+      def point(name:, label:, type:, icon:, tags:, parent: nil, channel: nil)
+        @points << Point.new(name: name, label: label, type: type, icon: icon, tags: tags, parent: parent,
+                             channel: channel)
+      end
+
+      def location(*)
+        raise "Error: location cannot be nested inside equipment"
+      end
+
+      def to_s(parent_name = nil)
+        result = "Group #{@name} \"#{@label}\" <#{@icon}>"
+        result += format_parent(parent_name, @parent)
+        result += " [\"Equipment\"]\n"
+
+        @sub_equipments.each {|sub_eq| result += sub_eq.to_s(@name) }
+        @points.each {|pt| result += pt.to_s(@name) }
+
+        result
+      end
+
+      private
+
+      def validate!(value, field)
+        return if value.nil?
+        return if value.match?(/\A[a-zA-Z_][a-zA-Z0-9_]*\z/)
+
+        raise ArgumentError, "#{field} is invalid: '#{value}'"
+      end
+
+      def format_parent(structure_parent, explicit_parent)
+        return "" if structure_parent.nil? && explicit_parent.nil?
+
+        values = [structure_parent, explicit_parent].compact
+        " (#{values.join(', ')})"
+      end
+    end
+  end
+end

data/lib/habdsl/model/location.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Habdsl
+  module Model
+    # Represents a location in the structure.
+    class Location
+      attr_reader :name, :label, :icon, :parent, :sub_locations, :equipments
+
+      def initialize(name:, label:, icon:, parent: nil)
+        validate!(name, "name")
+        validate!(icon, "icon")
+
+        @name = name
+        @label = label
+        @icon = icon
+        @parent = parent
+        @sub_locations = []
+        @equipments = []
+      end
+
+      def location(name:, label:, icon:, parent: nil, &)
+        loc = Location.new(name: name, label: label, icon: icon, parent: parent)
+        loc.instance_eval(&) if block_given?
+        @sub_locations << loc
+      end
+
+      def equipment(name:, label:, icon:, parent: nil, &)
+        eq = Equipment.new(name: name, label: label, icon: icon, parent: parent)
+        eq.instance_eval(&) if block_given?
+        @equipments << eq
+      end
+
+      def point(*)
+        raise "Error: point cannot be directly under location. Use equipment to wrap it."
+      end
+
+      def to_s(parent_name = nil)
+        result = "Group #{@name} \"#{@label}\" <#{@icon}>"
+        result += format_parent(parent_name, @parent)
+        result += " [\"Location\"]\n"
+
+        @sub_locations.each {|sub_loc| result += sub_loc.to_s(@name) }
+        @equipments.each {|eq| result += eq.to_s(@name) }
+
+        result
+      end
+
+      private
+
+      def validate!(value, field)
+        return if value.nil?
+        return if value.match?(/\A[a-zA-Z_][a-zA-Z0-9_]*\z/)
+
+        raise ArgumentError, "#{field} is invalid: '#{value}'"
+      end
+
+      def format_parent(structure_parent, explicit_parent)
+        return "" if structure_parent.nil? && explicit_parent.nil?
+
+        values = [structure_parent, explicit_parent].compact
+        " (#{values.join(', ')})"
+      end
+    end
+  end
+end

data/lib/habdsl/model/point.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Habdsl
+  module Model
+    # Represents a point in the model.
+    class Point
+      attr_reader :name, :label, :type, :icon, :parent, :tags
+
+      def initialize(name:, label:, type:, icon:, tags:, parent: nil, channel: nil)
+        validate!(name, "name")
+        validate!(type, "type")
+        validate!(icon, "icon")
+
+        @name = name
+        @label = label
+        @type = type
+        @icon = icon
+        @tags = tags
+        @parent = parent
+        @channel = channel
+      end
+
+      def location(*)
+        raise "Error: location cannot be nested inside point"
+      end
+
+      def equipment(*)
+        raise "Error: equipment cannot be nested inside point"
+      end
+
+      def to_s(parent_name = nil)
+        result = "#{@type} #{@name} \"#{@label}\" <#{@icon}>"
+        result += format_parent(parent_name, @parent)
+        result += " [#{@tags.map {|t| "\"#{t}\"" }.join(', ')}]"
+        result += " {channel=\"#{@channel}\"}" if @channel
+        result += "\n"
+        result
+      end
+
+      private
+
+      def validate!(value, field)
+        return if value.nil?
+        return if value.match?(/\A[a-zA-Z_][a-zA-Z0-9_]*\z/)
+
+        raise ArgumentError, "#{field} is invalid: '#{value}'"
+      end
+
+      def format_parent(structure_parent, explicit_parent)
+        return "" if structure_parent.nil? && explicit_parent.nil?
+
+        values = [structure_parent, explicit_parent].compact
+        " (#{values.join(', ')})"
+      end
+    end
+  end
+end

data/lib/habdsl/result_parser.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Habdsl
+  # The result of parsing a DSL file.
+  class ResultParser
+    attr_reader :table, :dsl
+
+    def initialize(dsl:, table: nil)
+      @table = table
+      @dsl = dsl
+    end
+  end
+end

data/lib/habdsl/sheet_parser.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "roo"
+require_relative "base_parser"
+
+module Habdsl
+  # Parser for Spreadsheet input
+  class SheetParser
+    def self.parse(input_code:, excel_path:)
+      raise ArgumentError, "Excel file does not exist: #{excel_path}" unless File.exist?(excel_path)
+
+      xlsx = Roo::Spreadsheet.open(excel_path.to_s)
+      sheet = xlsx.sheet(0)
+      headers = sheet.row(1).map(&:to_sym)
+
+      table = []
+      (2..sheet.last_row).each do |row_num|
+        row = sheet.row(row_num)
+        data = Hash[headers.zip(row)]
+        table << data
+      end
+
+      raise ArgumentError, "No data rows found in sheet" if table.empty?
+
+      BaseParser.evaluate_dsl(input_code: input_code, table: table)
+    end
+  end
+end

data/lib/habdsl/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Habdsl
+  VERSION = "0.1.0"
+end

data/lib/habdsl.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require_relative "habdsl/version"
+require_relative "habdsl/model/dsl"
+require_relative "habdsl/base_parser"
+require_relative "habdsl/dsl_parser"
+require_relative "habdsl/json_parser"
+require_relative "habdsl/result_parser"
+require_relative "habdsl/sheet_parser"
+
+# Habdsl is a DSL (Domain-Specific Language) for defining and parsing
+# structured data in a human-readable format. It provides a way to create
+# and manipulate data structures using a simple and intuitive syntax.
+#
+# The library includes parsers for converting DSL code into JSON format,
+# as well as for parsing JSON data into structured objects.
+#
+# @example Basic Usage
+#   require "habdsl"
+#
+#   dsl_code = <<~DSL
+#     # Your DSL code here
+#   DSL
+#
+#   json_code = <<~JSON
+#     # Your JSON code here
+#   JSON
+#
+#   parser = Habdsl::JsonParser.new
+#   result = parser.parse(input_code: dsl_code, json_code: json_code)
+#
+#   puts result.table
+#   puts result.dsl
+module Habdsl
+  class Error < StandardError; end
+  # Your code goes here...
+  # You can define additional convenience methods or constants here if needed.
+end

data/sig/habdsl.rbs

@@ -0,0 +1,4 @@
+module Habdsl
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -0,0 +1,100 @@
+--- !ruby/object:Gem::Specification
+name: habdsl
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Nomura Laboratory
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2025-05-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.6.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.6.3
+- !ruby/object:Gem::Dependency
+  name: roo
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.10.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.10.1
+description: HABDSL is a DSL tool that reads Excel files and outputs openHAB-compatible
+  DSL configuration.
+email:
+- ''
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- ".rubocop.yml"
+- CHANGELOG.md
+- CODE_OF_CONDUCT.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- doc/tempareture_items.png
+- example/example.json
+- example/example.xlsx
+- example/example_dsl.rb
+- example/example_dslparser.rb
+- example/example_jsonparser.rb
+- example/example_sheetparser.rb
+- lib/habdsl.rb
+- lib/habdsl/base_parser.rb
+- lib/habdsl/dsl_parser.rb
+- lib/habdsl/json_parser.rb
+- lib/habdsl/model/dsl.rb
+- lib/habdsl/model/equipment.rb
+- lib/habdsl/model/location.rb
+- lib/habdsl/model/point.rb
+- lib/habdsl/result_parser.rb
+- lib/habdsl/sheet_parser.rb
+- lib/habdsl/version.rb
+- output/.keep
+- sig/habdsl.rbs
+homepage: https://github.com/nomlab/habdsl
+licenses:
+- MIT
+metadata:
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.3
+signing_key:
+specification_version: 4
+summary: A DSL for generating openHAB-compatible config from Excel.
+test_files: []