custom_form_generator 1.0.4

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 3ba23a1a93a21d8bff1af16e497f7f7e9536abc168098f342a71d65211f8f6f3
+  data.tar.gz: a42375d97414ff4c920a110cfdefe6da8e814dd455a4e045aece47e6cd9b3ca9
+SHA512:
+  metadata.gz: 147be430a8c714f7a779c44c4b2a9b2deb8fb0d79cf11c0486e25d5310b35f02629f9a1d727006c1462e72c9e1c6bbc2adc78d3581dda08c163535c86edf349e
+  data.tar.gz: db3c5dbfd7aee5b3e02c6340256642674f8ffcb90a5a19d90b5d39a11628166158f832f2eac46a63269ec10bede32861026cdcc7fc8652a1592ab7c6faacccb1

data/README.md

@@ -0,0 +1,125 @@
+# CustomFormGenerator
+
+## Overview
+
+CustomFormGenerator is a Ruby gem designed to dynamically generate HTML forms and tables based on JSON configurations. It leverages the Slim templating engine to render forms, filter, sort options, and tabular views.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'custom_form_generator', path: '/path/to/custom_form_generator'
+And then execute:
+
+    bundle install
+
+## Usage
+
+### Preparation
+
+To use CustomFormGenerator, you need to provide few JSON and YAML files that defines the structure of your form or table. Currently supporting use cases of 4 such files:
+- form.yml
+- data.json
+- config.json
+- table.yml
+
+#### form.yml
+```
+- type: textfield
+  label: Name
+  key: properties.name
+  id: name_input
+  class: form-control
+- type: dropdown
+  label: Language
+  key: language
+  id: language_select
+  class: form-select
+  disabled: true
+```
+
+#### data.json
+```
+[
+  {
+    "_id": { "$oid": "64df" },
+    "language": "jp",
+    "name": "Kishimoto S",
+    "properties": {
+      "name": "Kishimoto S",
+      "categories": ["/Yusuke/Urameshi"],
+      "sku": "B3743-B001"
+    }
+  }
+]
+
+```
+
+#### config.json
+```
+{
+  "sort": [
+    { "key": "name", "label": "Name" },
+    { "key": "created_at", "label": "Created At" }
+  ],
+  "filter": [
+    { "key": "language", "label": "Language" },
+    { "key": "published_at", "label": "Published At", "type": "radio", "options": ["all", "yes", "no"], "default": "all" }
+  ],
+  "order_by": [
+    { "key": "asc", "label": "Ascending" },
+    { "key": "desc", "label": "Descending" }
+  ]
+}
+
+```
+
+#### table.yml
+```
+- key: images_url
+  label: Image
+  id: image_column
+  class: table-column
+- key: properties.name
+  label: Name
+  id: name_column
+  class: table-column
+```
+
+### Usage Example
+
+```
+require 'custom_form_generator'
+
+generator = CustomFormGenerator::Generator.new(
+  'path/to/form.yml',
+  'path/to/data.json',
+  'path/to/config.json',
+  'path/to/table.yml'
+)
+
+# Generate form
+html_form = generator.generate_form
+
+# Generate filter and sort
+filter_html = generator.generate_filter_and_sort
+
+# Generate table view
+table_html = generator.generate_tabular_view(data)
+```
+
+## Development
+
+After checking out the repo, run bin/setup to install dependencies. Then, run rake spec to run the tests.
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/Manmohan-menon/SlimForms_gem. 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/Manmohan-menon/SlimForms_gem/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 CustomFormGenerator project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/Manmohan-menon/SlimForms_gem/CODE_OF_CONDUCT.md).

data/custom_form_generator.gemspec

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative "lib/custom_form_generator/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "custom_form_generator"
+  spec.version = CustomFormGenerator::VERSION
+  spec.authors = ["manmohan.menon"]
+  spec.email = ["manmohan.menon@gmail.com"]
+
+  spec.summary = "A custom form generator using Slim and JSON data."
+  spec.description = "This gem generates forms based on JSON data, using Slim for templating."
+  spec.homepage = "https://github.com/Manmohan-menon/SlimForms_gem"
+  spec.license = "MIT"
+  spec.required_ruby_version = ">= 2.6.0"
+
+  spec.metadata["allowed_push_host"] = "https://rubygems.org"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/Manmohan-menon/SlimForms_gem"
+  spec.metadata["changelog_uri"] = "https://github.com/Manmohan-menon/SlimForms_gem"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    Dir["lib/**/*.rb"] + %w[
+      README.md
+      custom_form_generator.gemspec
+    ].reject { |file| file == "custom_form_generator-0.1.4.gem" }
+  end
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  # Uncomment to register a new dependency of your gem
+  spec.add_dependency "json", "~> 2.6"
+  spec.add_dependency "slim", "~> 5.0.0"
+  spec.add_dependency "yaml", "~> 0.1.0"
+
+  # For more information and examples about making a new gem, check out our
+  # guide at: https://bundler.io/guides/creating_gem.html
+end

data/lib/custom_form_generator/generator.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require "json"
+require "slim"
+require "yaml"
+require_relative "helpers/yaml_loader"
+require_relative "helpers/json_loader"
+require_relative "helpers/template_render"
+require_relative "helpers/form_element_renderer"
+require_relative "helpers/field_renderers"
+require_relative "helpers/filter_sort"
+require_relative "helpers/table_renderer"
+
+module CustomFormGenerator
+  # The Generator class is responsible for orchestrating the loading and rendering
+  # of form configurations, data, and templates. It integrates various helper modules
+  # to process YAML and JSON files, and to render forms and UI components using Slim templates.
+  class Generator
+    include Helpers::YamlLoader
+    include Helpers::JsonLoader
+    include Helpers::TemplateRender
+    include Helpers::FieldRenderers
+    include Helpers::FilterSort
+    include Helpers::TableRenderer
+    include Helpers::FormElementRenderer
+
+    def initialize(form_yaml, data_json, config_json, table_yaml, debug: false)
+      load_files(form_yaml, data_json, config_json, table_yaml)
+      @debug = { debug: debug }
+    rescue StandardError => e
+      raise CustomFormGenerator::Error, "Failed to load generator files: #{e.message}"
+    end
+
+    private
+
+    def load_files(form_yaml, data_json, config_json, table_yaml)
+      @form_yaml = load_yaml(form_yaml)
+      @data_json = load_json(data_json)
+      @config_json = load_json(config_json)
+      @table_yaml = load_yaml(table_yaml)
+    rescue StandardError => e
+      raise CustomFormGenerator::Error, "Failed to load files: #{e.message}"
+    end
+
+    def generate_form
+      debug_output("Generating form") if @debug
+      Slim::Template.new { form_template }.render(self)
+    end
+
+    def generate_filter_and_sort
+      debug_output("Generating filter and sort") if @debug
+      updated_config = generate_updated_config(@config_json, @data_json)
+      Slim::Template.new { filter_and_sort_template(updated_config) }.render(self, updated_config: updated_config)
+    end
+
+    def generate_form_with_data(item)
+      debug_output("Generating form with data") if @debug
+      @data_json = item
+      Slim::Template.new { form_template }.render(self)
+    end
+
+    def debug_output(message)
+      puts "[DEBUG] #{message}" if @debug[:debug]
+    end
+  end
+end

data/lib/custom_form_generator/helpers/field_renderers.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require "cgi"
+
+module CustomFormGenerator
+  # Helpers module provides form generation and rendering functionality
+  # Contains core modules for field rendering, validation, and HTML generation
+  module Helpers
+    include FormElementRenderer
+
+    # FieldRenderers module handles HTML form field generation with various input types
+    # and proper escaping for security
+    module FieldRenderers
+      def render_field(field)
+        validate_field(field)
+        field_attributes = extract_field_attributes(field)
+        render_field_by_type(field, field_attributes)
+      rescue StandardError => e
+        raise CustomFormGenerator::Error, "Failed to render field '#{field["key"]}': #{e.message}"
+      end
+
+      private
+
+      def validate_field(field)
+        raise CustomFormGenerator::Error, "Invalid field structure" unless field.is_a?(Hash)
+      end
+
+      def extract_field_attributes(field)
+        {
+          label: CGI.escapeHTML(field["label"]),
+          id: CGI.escapeHTML(field["id"]),
+          key: CGI.escapeHTML(field["key"]),
+          css_class: CGI.escapeHTML(field["class"]),
+          value: fetch_nested_value(field["key"]).to_s,
+          type: field["type"]
+        }
+      end
+
+      def render_field_by_type(field, attrs)
+        case attrs[:type]
+        when "textfield" then render_textfield(attrs)
+        when "dropdown" then render_dropdown(field, attrs)
+        when "datetime-local" then render_datetime(field, attrs)
+        when "radio" then render_radio(field, attrs)
+        when "textbox" then render_textbox(attrs)
+        else ""
+        end
+      end
+
+      def fetch_dropdown_options(field, selected_value)
+        options = fetch_nested_value(field["key"])
+        return "" unless options.is_a?(Array)
+
+        options.map { |opt| generate_option(opt, opt == selected_value ? "selected" : "") }.join("\n")
+      rescue StandardError => e
+        raise CustomFormGenerator::Error, "Failed to generate dropdown options: #{e.message}"
+      end
+
+      def fetch_radio_options(field, selected_value)
+        return "" unless field.is_a?(Hash) && field.key?("options")
+
+        generate_radio_options(field, selected_value)
+      rescue StandardError => e
+        raise CustomFormGenerator::Error, "Failed to generate radio options: #{e.message}"
+      end
+
+      def generate_radio_options(field, selected_value)
+        field["options"].map do |opt|
+          generate_radio_option(opt, selected_value)
+        end.join("<br>")
+      end
+
+      def generate_radio_option(opt, selected_value)
+        opt_value = CGI.escapeHTML(opt["value"])
+        opt_label = CGI.escapeHTML(opt["label"])
+        checked = opt["value"] == selected_value ? "checked" : ""
+        <<~HTML
+          <input type='radio' id='#{id}_#{opt_value}' class='#{css_class}'#{" "}
+                 name='#{key}' value='#{opt_value}' #{checked}>
+          <label for='#{id}_#{opt_value}'>#{opt_label}</label>
+        HTML
+      end
+
+      def fetch_nested_value(key)
+        keys = key.split(".")
+        value = keys.reduce(@data_json) do |data, k|
+          return "" unless data.is_a?(Hash) && data.key?(k)
+
+          data[k]
+        end
+        puts "DEBUG: key = #{key}, value = #{value.inspect}" if @debug
+        value.is_a?(Array) ? value : value || ""
+      end
+
+      def generate_option(option, selected)
+        "<option value='#{CGI.escapeHTML(option)}' #{selected}>#{CGI.escapeHTML(option)}</option>"
+      end
+    end
+  end
+end

data/lib/custom_form_generator/helpers/filter_sort.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+require "cgi"
+require "slim"
+
+module CustomFormGenerator
+  module Helpers
+    # FilterSort module handles configuration updates and template generation for filtering and sorting
+    module FilterSort
+      def generate_updated_config(config, data)
+        validate_inputs(config, data)
+        parsed_data = parse_input_data(config, data)
+        update_filter_options(parsed_data)
+      end
+
+      def filter_and_sort_template(_updated_config)
+        <<-SLIM
+          div
+            button onclick='showFilterPanel()' Filter
+            select name='sort'
+              - updated_config['sort'].each do |sort_option|
+                option value=sort_option['key'] = sort_option['label']
+            select name='order_by'
+              - updated_config['order_by'].each do |order_option|
+                option value=order_option['key'] = order_option['label']
+            div id='filterPanel' style='display:none;'
+              - updated_config['filter'].each do |filter_option|
+                label = filter_option['label']
+                - if filter_option['type'] == 'radio'
+                  fieldset
+                    legend= filter_option['label']
+                    - filter_option['options'].each do |option|
+                      input type='radio' name=filter_option['key'] value=option['value']
+                      label= option['label']
+                    - if filter_option['default']
+                      input type='radio' name=filter_option['key'] value=filter_option['default'] checked
+                - else
+                  - filter_option['options'].each do |option|
+                    input type='checkbox' name=filter_option['key'] value=option['value']
+                    label= option['label']
+            button type='submit' Apply
+        SLIM
+      end
+
+      private
+
+      def validate_inputs(config, data)
+        raise CustomFormGenerator::Error, "Config is not a hash: #{config.class}" unless config.is_a?(Hash)
+        raise CustomFormGenerator::Error, "Data is not an array: #{data.class}" unless data.is_a?(Array)
+      end
+
+      def parse_input_data(config, data)
+        {
+          config: config.is_a?(String) ? load_json(config) : config,
+          data: data.is_a?(String) ? load_json(data) : data
+        }
+      end
+
+      def update_filter_options(parsed_data)
+        config = parsed_data[:config]
+        config["filter"].each do |filter|
+          next if filter["options"]&.any?
+
+          unique_values = extract_unique_values(parsed_data[:data], filter["key"])
+          update_filter_settings(filter, unique_values)
+        end
+        config
+      end
+
+      def extract_unique_values(data, key)
+        data.map { |entry| extract_value(entry, key) }
+            .flatten
+            .uniq
+            .compact
+      end
+
+      def extract_value(entry, key)
+        value = entry[key] || entry.dig(*key.split("."))
+        value.is_a?(Array) ? value : [value]
+      end
+
+      def update_filter_settings(filter, unique_values)
+        filter["default"] ||= unique_values.first if filter["type"] == "radio"
+        filter["options"] ||= generate_options(unique_values)
+      end
+
+      def generate_options(values)
+        values.map do |value|
+          formatted_value = format_name(value)
+          { "value" => formatted_value, "label" => formatted_value }
+        end
+      end
+
+      def format_name(name)
+        name.gsub("/", " ").strip.split.map(&:capitalize).join(" ")
+      end
+    end
+  end
+end

data/lib/custom_form_generator/helpers/form_element_renderer.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require "cgi"
+
+module CustomFormGenerator
+  module Helpers
+    # FormElementRenderer module handles HTML form element generation
+    module FormElementRenderer
+      def render_textfield(attrs)
+        <<~HTML
+          <label for='#{attrs[:id]}'>#{attrs[:label]}</label>
+          <input type='text' id='#{attrs[:id]}' class='#{attrs[:css_class]}'#{" "}
+                 name='#{attrs[:key]}' value='#{CGI.escapeHTML(attrs[:value])}'#{" "}
+                 placeholder='Enter your #{attrs[:label]}'/>
+        HTML
+      end
+
+      def render_dropdown(field, attrs)
+        options = fetch_dropdown_options(field, attrs[:value])
+        <<~HTML
+          <label for='#{attrs[:id]}'>#{attrs[:label]}</label>
+          <select id='#{attrs[:id]}' class='#{attrs[:css_class]}' name='#{attrs[:key]}'>
+            #{options}
+          </select>
+        HTML
+      end
+
+      def render_datetime(field, attrs)
+        disabled_attr = field["disabled"] ? "disabled" : ""
+        <<~HTML
+          <label for='#{attrs[:id]}'>#{attrs[:label]}</label>
+          <input type='datetime-local' id='#{attrs[:id]}' class='#{attrs[:css_class]}'#{" "}
+                 name='#{attrs[:key]}' value='#{CGI.escapeHTML(attrs[:value])}' #{disabled_attr} />
+        HTML
+      end
+
+      def render_radio(field, attrs)
+        options = fetch_radio_options(field, attrs[:value])
+        <<~HTML
+          <fieldset>
+            <legend>#{attrs[:label]}</legend>
+            #{options}
+          </fieldset>
+        HTML
+      end
+
+      def render_textbox(attrs)
+        <<~HTML
+          <label for='#{attrs[:id]}'>#{attrs[:label]}</label>
+          <textarea id='#{attrs[:id]}' class='#{attrs[:css_class]}' name='#{attrs[:key]}'#{" "}
+                    placeholder='Enter your #{attrs[:label]}'>#{CGI.escapeHTML(attrs[:value])}</textarea>
+        HTML
+      end
+    end
+  end
+end

data/lib/custom_form_generator/helpers/json_loader.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require "json"
+puts "JSON Version: #{JSON::VERSION}"
+
+module CustomFormGenerator
+  module Helpers
+    # JsonLoader module provides JSON file loading functionality with safety checks
+    # along with error handling for the CustomFormGenerator gem
+    module JsonLoader
+      def load_json(file_path)
+        raise CustomFormGenerator::Error, "JSON file not found: #{file_path}" unless File.exist?(file_path)
+
+        JSON.parse(File.read(file_path))
+      end
+    end
+  end
+end

data/lib/custom_form_generator/helpers/table_renderer.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "slim"
+module CustomFormGenerator
+  module Helpers
+    # Module CustomFormGenerator::Helpers::TableRenderer helps in gnerating table from yaml using slim template
+    module TableRenderer
+      def table_template
+        <<-SLIM
+          table
+            tr
+              - @table_yaml.each do |field|
+                th id=CGI.escapeHTML(field["id"]) class=CGI.escapeHTML(field["class"]) = field['label']
+              th Activities
+            - data.each do |entry|
+              tr
+                - @table_yaml.each do |field|
+                  td id=CGI.escapeHTML(field["id"]) class=CGI.escapeHTML(field["class"])
+                    - value = entry.dig(*field['key'].split('.'))
+                    - if field['key'] == 'properties.published_at' && value.nil?
+                      | false
+                    - elsif field['key'] == 'properties.image_url' && value.nil?
+                      img src='/path/to/default_image.jpg' alt='Default Thumbnail'
+                    - else
+                      = value
+                td
+                  button class='edit-button' data-id=entry['_id']['$oid'] Edit
+                  button class='delete-button' data-id=entry['_id']['$oid'] Delete
+        SLIM
+      end
+
+      def generate_tabular_view(data:, table_template:)
+        template = Slim::Template.new { table_template }
+        template.render(self, data: data)
+      end
+    end
+  end
+end

data/lib/custom_form_generator/helpers/template_render.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require "slim"
+require "cgi"
+
+module CustomFormGenerator
+  module Helpers
+    # TemplateRender module handles rendering of Slim templates.
+    # Provides methods to generate dynamic HTML content for form
+    # based on the provided configuration and data.
+    module TemplateRender
+      def form_template
+        <<-SLIM
+          form
+            - @form_yaml.each do |field|
+              - next if field['key'] == '_id'
+              == render_field(field)
+              br
+        SLIM
+      end
+
+      def filter_and_sort_template(_config)
+        <<-SLIM
+          div
+            button onclick='showFilterPanel()' Filter
+            select name='sort'
+              - config['sort'].each do |sort_option|
+                option value=sort_option['key'] = sort_option['label']
+            select name='order_by'
+              - config['order_by'].each do |order_option|
+                option value=order_option['key'] = order_option['label']
+            div id='filterPanel' style='display:none;'
+              - config['filter'].each do |filter_option|
+                label = filter_option['label']
+                - if filter_option['type'] == 'radio'
+                  fieldset
+                    legend= filter_option['label']
+                    - filter_option['options'].each do |option|
+                      input type='radio' name=filter_option['key'] value=option['value']
+                      label= option['label']
+                    - if filter_option['default']
+                      input type='radio' name=filter_option['key'] value=filter_option['default'] checked
+                - else
+                  - filter_option['options'].each do |option|
+                    input type='checkbox' name=filter_option['key'] value=option['value']
+                    label= option['label']
+            button type='submit' Apply
+        SLIM
+      end
+    end
+  end
+end

data/lib/custom_form_generator/helpers/yaml_loader.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require "yaml"
+module CustomFormGenerator
+  module Helpers
+    # YamlLoader module provides YAML file loading functionality with safety checks
+    # along with error handling for the CustomFormGenerator gem
+    module YamlLoader
+      def load_yaml(file_path)
+        raise CustomFormGenerator::Error, "YAML file not found: #{file_path}" unless File.exist?(file_path)
+
+        YAML.safe_load(File.read(file_path), permitted_classes: [Symbol])
+      end
+    end
+  end
+end

data/lib/custom_form_generator/version.rb

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

data/lib/custom_form_generator.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require_relative "custom_form_generator/version"
+require "json"
+require "slim"
+require "yaml"
+require_relative "custom_form_generator/generator"
+
+module CustomFormGenerator
+  class Error < StandardError; end
+end

metadata

@@ -0,0 +1,101 @@
+--- !ruby/object:Gem::Specification
+name: custom_form_generator
+version: !ruby/object:Gem::Version
+  version: 1.0.4
+platform: ruby
+authors:
+- manmohan.menon
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2024-10-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'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.6'
+- !ruby/object:Gem::Dependency
+  name: slim
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.0.0
+- !ruby/object:Gem::Dependency
+  name: yaml
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+description: This gem generates forms based on JSON data, using Slim for templating.
+email:
+- manmohan.menon@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- custom_form_generator.gemspec
+- lib/custom_form_generator.rb
+- lib/custom_form_generator/generator.rb
+- lib/custom_form_generator/helpers/field_renderers.rb
+- lib/custom_form_generator/helpers/filter_sort.rb
+- lib/custom_form_generator/helpers/form_element_renderer.rb
+- lib/custom_form_generator/helpers/json_loader.rb
+- lib/custom_form_generator/helpers/table_renderer.rb
+- lib/custom_form_generator/helpers/template_render.rb
+- lib/custom_form_generator/helpers/yaml_loader.rb
+- lib/custom_form_generator/version.rb
+homepage: https://github.com/Manmohan-menon/SlimForms_gem
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/Manmohan-menon/SlimForms_gem
+  source_code_uri: https://github.com/Manmohan-menon/SlimForms_gem
+  changelog_uri: https://github.com/Manmohan-menon/SlimForms_gem
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.6.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.1
+signing_key: 
+specification_version: 4
+summary: A custom form generator using Slim and JSON data.
+test_files: []