lex-rfp 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 8c6ee3402b33896e13c6d7dbae38acbb7fa05e61bac53bb39a8a7478c9ddbb47
+  data.tar.gz: 400220b847975bc491724d112e0c3fd96084437696938bd5e428c6f4a08becd6
+SHA512:
+  metadata.gz: fa341a874c0092ed018973520bb075dc1457decc4815fee304ef14fc8216f5e76473a00b454180e71f46387a33a99907d089408a1e3d712a577ba28d2d5e17c0
+  data.tar.gz: 380895e07cb7e8ff6fa2062a78dc24fcbeabffa0e5f9c6f437a8b2bcdb45645f38052c8302696b16cbba905110b3784228a92c58e8cdc0d80b6d7f24220b6b6d

data/.github/workflows/ci.yml

@@ -0,0 +1,16 @@
+name: CI
+on:
+  push:
+    branches: [main]
+  pull_request:
+
+jobs:
+  ci:
+    uses: LegionIO/.github/.github/workflows/ci.yml@main
+
+  release:
+    needs: ci
+    if: github.event_name == 'push' && github.ref == 'refs/heads/main'
+    uses: LegionIO/.github/.github/workflows/release.yml@main
+    secrets:
+      rubygems-api-key: ${{ secrets.RUBYGEMS_API_KEY }}

data/.gitignore

@@ -0,0 +1,12 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+Gemfile.lock
+
+# rspec failure tracking
+.rspec_status

data/.rspec

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

data/.rubocop.yml

@@ -0,0 +1,66 @@
+AllCops:
+  TargetRubyVersion: 3.4
+  NewCops: enable
+  SuggestExtensions: false
+
+Layout/LineLength:
+  Max: 160
+
+Layout/SpaceAroundEqualsInParameterDefault:
+  EnforcedStyle: space
+
+Layout/HashAlignment:
+  EnforcedHashRocketStyle: table
+  EnforcedColonStyle: table
+
+Metrics/MethodLength:
+  Max: 50
+
+Metrics/ClassLength:
+  Max: 1500
+
+Metrics/ModuleLength:
+  Max: 1500
+
+Metrics/BlockLength:
+  Max: 40
+  Exclude:
+    - 'spec/**/*'
+
+Metrics/AbcSize:
+  Max: 60
+
+Metrics/CyclomaticComplexity:
+  Max: 15
+
+Metrics/PerceivedComplexity:
+  Max: 17
+
+Metrics/ParameterLists:
+  Max: 10
+
+Style/Documentation:
+  Enabled: false
+
+Style/SymbolArray:
+  Enabled: true
+
+Style/FrozenStringLiteralComment:
+  Enabled: true
+  EnforcedStyle: always
+
+Naming/FileName:
+  Enabled: false
+
+Naming/PredicateMethod:
+  Enabled: false
+
+Naming/PredicatePrefix:
+  Enabled: false
+
+Gemspec/DevelopmentDependencies:
+  Enabled: false
+
+Lint/EmptyClass:
+  Exclude:
+    - 'spec/**/*'

data/CHANGELOG.md

@@ -0,0 +1,15 @@
+# Changelog
+
+## [Unreleased]
+
+## [0.1.0] - 2026-04-14
+
+### Added
+- Initial scaffold with monolith architecture (4 sub-modules)
+- Ingest sub-module: corpus loading for PDF, DOCX, Markdown, Excel, HTML documents
+- Generate sub-module: draft RFP response generation via LLM pipeline with RAG
+- Review sub-module: human-in-the-loop workflow with section-level status tracking
+- Analytics sub-module: win rate tracking, proposal metrics, and quality scoring
+- Standalone Client classes for each sub-module
+- Full RSpec test suite
+- GitHub Actions CI workflow

data/CLAUDE.md

@@ -0,0 +1,80 @@
+# lex-rfp: RFP and Proposal Automation for LegionIO
+
+**Repository Level 3 Documentation**
+- **Category**: `/Users/miverso2/rubymine/legion/extensions/CLAUDE.md`
+
+## Purpose
+
+Generative AI-powered RFP and proposal automation extension. Ingests past proposals and product documentation into Apollo, generates draft RFP responses via the LLM pipeline with RAG retrieval, provides human-in-the-loop review workflows, and tracks win rates with quality analytics.
+
+**GitHub**: https://github.com/LegionIO/lex-rfp
+**License**: MIT
+
+## Architecture
+
+Monolith-style extension with four self-contained sub-modules:
+
+```
+Legion::Extensions::Rfp
+├── Ingest/
+│   ├── Runners/
+│   │   ├── Documents       # Format detection, text extraction, chunking
+│   │   ├── Corpus          # Document ingest pipeline, directory scanning, Apollo push
+│   │   └── Parser          # RFP question extraction, requirement identification, section splitting
+│   ├── Helpers/Client      # Faraday connection helper
+│   └── Client              # Standalone client including all Ingest runners
+├── Generate/
+│   ├── Runners/
+│   │   ├── Drafts          # Full draft generation, single response, regeneration with feedback
+│   │   ├── Sections        # Section-specific responses, executive summary, compliance matrix
+│   │   └── Templates       # Template management (standard, government, healthcare), auto-suggest
+│   ├── Helpers/Client
+│   └── Client
+├── Review/
+│   ├── Runners/
+│   │   ├── Workflows       # Workflow lifecycle (create, submit, finalize), section status tracking
+│   │   ├── Comments        # Comment system, revision requests, resolution
+│   │   └── Approvals       # Section/proposal approval, rejection, readiness checks
+│   ├── Helpers/Client
+│   └── Client
+└── Analytics/
+    ├── Runners/
+    │   ├── Metrics          # Proposal recording, outcome tracking, summary stats, response times
+    │   ├── WinRates         # Overall/by-source/by-template win rates, trend analysis
+    │   └── Quality          # Response quality scoring (4 dimensions), proposal scoring, aggregate reports
+    ├── Helpers/Client
+    └── Client
+```
+
+## Supported Document Formats
+
+PDF, DOCX, Markdown, Excel (xlsx), HTML — PDF/DOCX/Excel extraction requires `legion-data` with Extract handlers.
+
+## Dependencies
+
+| Gem | Purpose |
+|-----|---------|
+| `faraday` (>= 2.0) | HTTP client for all sub-modules |
+| `legion-llm` (optional) | LLM pipeline for response generation |
+| `legion-apollo` (optional) | RAG retrieval from knowledge store |
+| `legion-data` (optional) | Document extraction (PDF, DOCX, Excel) |
+
+## Key Patterns
+
+- **Monolith style**: Top entry point uses `require_relative` to load sub-modules; sub-module entries use bare `require`
+- **Standalone Clients**: Each sub-module has its own `Client` class usable outside the framework
+- **`client(**)` passthrough**: Runner methods accept `**` and pass through to `client(**)`
+- **LLM integration**: Generate runners use `Legion::LLM.ask(message:)` with graceful fallback when LLM unavailable
+- **Apollo integration**: Ingest pushes to Apollo via `Legion::Apollo.ingest`; Generate retrieves via `Legion::Apollo.retrieve`
+
+## Testing
+
+```bash
+bundle install
+bundle exec rspec
+bundle exec rubocop
+```
+
+---
+
+**Maintained By**: Matthew Iverson (@Esity)

data/Dockerfile

@@ -0,0 +1,6 @@
+FROM legionio/legion
+
+COPY . /usr/src/app/lex-rfp
+
+WORKDIR /usr/src/app/lex-rfp
+RUN bundle install

data/Gemfile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+gemspec
+
+group :test do
+  gem 'rake'
+  gem 'rspec'
+  gem 'rspec_junit_formatter'
+  gem 'rubocop'
+  gem 'simplecov'
+end

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 Esity
+
+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,119 @@
+# lex-rfp
+
+Generative AI-powered RFP and proposal automation for [LegionIO](https://github.com/LegionIO/LegionIO). Ingests past proposals and product documentation into Apollo, generates draft RFP responses via the LLM pipeline with RAG retrieval, provides human-in-the-loop review workflows, and tracks win rates with quality analytics.
+
+## Architecture
+
+Monolith-style extension with four sub-modules:
+
+| Sub-Module | Purpose |
+|------------|---------|
+| **Ingest** | Document parsing (PDF, DOCX, Markdown, Excel, HTML), text chunking, corpus management, Apollo ingestion |
+| **Generate** | Draft response generation via LLM + RAG, section-by-section and full-document modes, template system |
+| **Review** | Human-in-the-loop workflows, section-level status tracking, comments, approvals |
+| **Analytics** | Win rate tracking, proposal metrics, response time stats, quality scoring |
+
+## Installation
+
+```bash
+gem install lex-rfp
+```
+
+Or add to your Gemfile:
+
+```ruby
+gem 'lex-rfp'
+```
+
+## Usage
+
+### Standalone Clients
+
+Each sub-module provides a standalone `Client` class:
+
+```ruby
+# Ingest documents
+ingest = Legion::Extensions::Rfp::Ingest::Client.new
+result = ingest.ingest_document(file_path: 'past_proposal.pdf', tags: ['healthcare'])
+chunks = result[:result]
+
+# Generate RFP responses
+gen = Legion::Extensions::Rfp::Generate::Client.new
+draft = gen.generate_response(question: 'Describe your network coverage')
+
+# Review workflow
+review = Legion::Extensions::Rfp::Review::Client.new
+wf = review.create_workflow(proposal_id: 'prop-123', sections: %w[summary approach pricing])
+review.submit_for_review(workflow_id: wf[:result][:id], reviewers: ['reviewer-1'])
+
+# Analytics
+analytics = Legion::Extensions::Rfp::Analytics::Client.new
+rate = analytics.overall_win_rate(proposals: proposal_data)
+```
+
+### Ingest Functions
+
+- `supported?(file_path:)` - Check if a file format is supported
+- `extract_text(file_path:)` - Extract text from a document
+- `chunk_text(text:, chunk_size:, overlap:)` - Split text into overlapping chunks
+- `ingest_document(file_path:, tags:, metadata:)` - Full document ingest pipeline
+- `ingest_directory(directory:, tags:, recursive:)` - Batch ingest all supported files
+- `ingest_to_apollo(chunks:, scope:)` - Push chunks to Apollo knowledge store
+- `parse_rfp_questions(text:)` - Extract numbered questions from RFP text
+- `extract_requirements(text:)` - Identify mandatory and preferred requirements
+- `extract_sections(text:)` - Split RFP into logical sections
+
+### Generate Functions
+
+- `generate_full_draft(rfp_text:, context:, model:)` - Generate complete RFP response
+- `generate_response(question:, context:, model:, scope:)` - Generate single question response with RAG
+- `regenerate(question:, previous_answer:, feedback:)` - Revise response based on feedback
+- `generate_section_response(question:, section:, context:)` - Section-specific response
+- `generate_executive_summary(rfp_text:, company_context:)` - Executive summary generation
+- `generate_compliance_matrix(requirements:, capabilities:)` - Compliance matrix
+- `list_templates` / `get_template(name:)` / `apply_template(name:, rfp_data:)` - Template management
+- `suggest_template(rfp_text:)` - Auto-suggest appropriate template
+
+### Review Functions
+
+- `create_workflow(proposal_id:, sections:, reviewers:)` - Create review workflow
+- `update_status(workflow_id:, status:)` / `update_section_status(...)` - Status management
+- `submit_for_review(workflow_id:, reviewers:)` - Submit for review
+- `finalize(workflow_id:)` - Finalize proposal
+- `add_comment(...)` / `resolve_comment(...)` / `request_revision(...)` - Comment system
+- `approve_section(...)` / `reject_section(...)` / `approve_proposal(...)` - Approvals
+- `check_readiness(sections:)` - Check if all sections are approved
+
+### Analytics Functions
+
+- `record_proposal(proposal_id:, rfp_source:, ...)` - Record proposal metadata
+- `record_outcome(proposal_id:, outcome:, revenue:)` - Record win/loss outcome
+- `summary(proposals:)` - Aggregate statistics
+- `response_time_stats(proposals:)` - Response time analysis
+- `overall_win_rate(proposals:)` - Overall win rate
+- `win_rate_by_source(proposals:)` / `win_rate_by_template(proposals:)` - Segmented rates
+- `trend(proposals:, period:)` - Win rate trends over time
+- `score_response(response_text:, question:, requirements:)` - Quality scoring
+- `score_proposal(sections:)` - Full proposal quality score
+- `quality_report(proposals:)` - Aggregate quality report
+
+## Supported Document Formats
+
+- PDF (via legion-data Extract)
+- DOCX (via legion-data Extract)
+- Markdown (.md, .markdown)
+- Excel (.xlsx, via legion-data Extract)
+- HTML (.html, .htm)
+
+## Requirements
+
+- Ruby >= 3.4
+- [LegionIO](https://github.com/LegionIO/LegionIO) framework
+- `faraday` (>= 2.0)
+- Optional: `legion-llm` for LLM-powered generation
+- Optional: `legion-apollo` for RAG retrieval
+- Optional: `legion-data` for PDF/DOCX/Excel extraction
+
+## License
+
+MIT

data/lex-rfp.gemspec

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative 'lib/legion/extensions/rfp/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'lex-rfp'
+  spec.version       = Legion::Extensions::Rfp::VERSION
+  spec.authors       = ['Esity']
+  spec.email         = ['matthewdiverson@gmail.com']
+
+  spec.summary       = 'LEX Rfp'
+  spec.description   = 'Generative AI-powered RFP and proposal automation for LegionIO. ' \
+                       'Ingests past proposals into Apollo, generates draft responses via LLM pipeline with RAG, ' \
+                       'and provides human-in-the-loop review workflows with analytics.'
+  spec.homepage      = 'https://github.com/LegionIO/lex-rfp'
+  spec.license       = 'MIT'
+  spec.required_ruby_version = '>= 3.4'
+
+  spec.metadata['homepage_uri'] = spec.homepage
+  spec.metadata['source_code_uri'] = 'https://github.com/LegionIO/lex-rfp'
+  spec.metadata['documentation_uri'] = 'https://github.com/LegionIO/lex-rfp'
+  spec.metadata['changelog_uri'] = 'https://github.com/LegionIO/lex-rfp/blob/main/CHANGELOG.md'
+  spec.metadata['bug_tracker_uri'] = 'https://github.com/LegionIO/lex-rfp/issues'
+  spec.metadata['rubygems_mfa_required'] = 'true'
+
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'faraday', '>= 2.0'
+end

data/lib/legion/extensions/rfp/analytics/client.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative 'helpers/client'
+require_relative 'runners/metrics'
+require_relative 'runners/win_rates'
+require_relative 'runners/quality'
+
+module Legion
+  module Extensions
+    module Rfp
+      module Analytics
+        class Client
+          include Helpers::Client
+          include Runners::Metrics
+          include Runners::WinRates
+          include Runners::Quality
+
+          attr_reader :opts
+
+          def initialize(base_url: nil, token: nil, **)
+            @opts = { base_url: base_url, token: token }.compact
+          end
+
+          def client(**override)
+            super(**@opts, **override)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/rfp/analytics/helpers/client.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'faraday'
+
+module Legion
+  module Extensions
+    module Rfp
+      module Analytics
+        module Helpers
+          module Client
+            def client(base_url: 'http://localhost:4567', token: nil, **)
+              Faraday.new(url: base_url) do |conn|
+                conn.request :json
+                conn.response :json, content_type: /\bjson$/
+                conn.headers['Content-Type'] = 'application/json'
+                conn.headers['Authorization'] = "Bearer #{token}" if token
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/rfp/analytics/runners/metrics.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Rfp
+      module Analytics
+        module Runners
+          module Metrics
+            extend Legion::Extensions::Rfp::Analytics::Helpers::Client
+
+            def record_proposal(proposal_id:, rfp_source:, submitted_at: nil, sections: 0, word_count: 0, **)
+              metric = {
+                proposal_id:  proposal_id,
+                rfp_source:   rfp_source,
+                submitted_at: submitted_at || Time.now.iso8601,
+                sections:     sections,
+                word_count:   word_count,
+                recorded_at:  Time.now.iso8601
+              }
+              { result: metric }
+            end
+
+            def record_outcome(proposal_id:, outcome:, revenue: nil, feedback: nil, **)
+              valid_outcomes = %i[won lost no_decision pending]
+              outcome_sym = outcome.to_sym
+              return { result: nil, error: "Invalid outcome: #{outcome}. Valid: #{valid_outcomes.join(', ')}" } unless valid_outcomes.include?(outcome_sym)
+
+              {
+                result: {
+                  proposal_id: proposal_id,
+                  outcome:     outcome_sym,
+                  revenue:     revenue,
+                  feedback:    feedback,
+                  recorded_at: Time.now.iso8601
+                }
+              }
+            end
+
+            def summary(proposals:, **)
+              total = proposals.length
+              won = proposals.count { |p| p[:outcome] == :won }
+              lost = proposals.count { |p| p[:outcome] == :lost }
+              pending = proposals.count { |p| p[:outcome] == :pending || p[:outcome].nil? }
+              total_revenue = proposals.select { |p| p[:outcome] == :won }.sum { |p| p[:revenue].to_f }
+
+              {
+                result: {
+                  total_proposals: total,
+                  won:             won,
+                  lost:            lost,
+                  pending:         pending,
+                  win_rate:        total.positive? ? (won.to_f / (won + lost)).round(4) : 0.0,
+                  total_revenue:   total_revenue
+                }
+              }
+            end
+
+            def response_time_stats(proposals:, **)
+              times = proposals.filter_map do |p|
+                next unless p[:created_at] && p[:submitted_at]
+
+                created = Time.parse(p[:created_at])
+                submitted = Time.parse(p[:submitted_at])
+                (submitted - created).to_f
+              end
+
+              return { result: { count: 0 } } if times.empty?
+
+              {
+                result: {
+                  count:  times.length,
+                  avg:    (times.sum / times.length).round(2),
+                  min:    times.min.round(2),
+                  max:    times.max.round(2),
+                  median: times.sort[times.length / 2].round(2)
+                }
+              }
+            end
+
+            include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
+                                                        Legion::Extensions::Helpers.const_defined?(:Lex)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/rfp/analytics/runners/quality.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Rfp
+      module Analytics
+        module Runners
+          module Quality
+            extend Legion::Extensions::Rfp::Analytics::Helpers::Client
+
+            QUALITY_DIMENSIONS = %i[completeness relevance clarity compliance].freeze
+
+            def score_response(response_text:, question: nil, requirements: [], **)
+              scores = {
+                completeness: score_completeness(response_text),
+                relevance:    score_relevance(response_text, question),
+                clarity:      score_clarity(response_text),
+                compliance:   score_compliance(response_text, requirements)
+              }
+
+              overall = scores.values.sum.to_f / scores.length
+              { result: { scores: scores, overall: overall.round(2) } }
+            end
+
+            def score_proposal(sections:, **)
+              section_scores = sections.map do |section|
+                scored = score_response(
+                  response_text: section[:content] || '',
+                  question:      section[:question],
+                  requirements:  section[:requirements] || []
+                )
+                { name: section[:name], scores: scored[:result] }
+              end
+
+              avg_overall = if section_scores.empty?
+                              0.0
+                            else
+                              section_scores.sum { |s| s[:scores][:overall] } / section_scores.length
+                            end
+
+              { result: { sections: section_scores, overall: avg_overall.round(2) } }
+            end
+
+            def quality_report(proposals:, **)
+              return { result: { count: 0 } } if proposals.empty?
+
+              avg_scores = QUALITY_DIMENSIONS.to_h do |dim|
+                scores = proposals.filter_map { |p| p.dig(:quality, :scores, dim) }
+                avg = scores.empty? ? 0.0 : (scores.sum.to_f / scores.length).round(2)
+                [dim, avg]
+              end
+
+              {
+                result: {
+                  count:          proposals.length,
+                  average_scores: avg_scores,
+                  overall:        avg_scores.values.sum / avg_scores.length
+                }
+              }
+            end
+
+            private
+
+            def score_completeness(text)
+              return 0.0 if text.nil? || text.strip.empty?
+
+              length_score = [text.length / 500.0, 1.0].min
+              paragraph_score = [text.split(/\n\n+/).length / 3.0, 1.0].min
+              ((length_score + paragraph_score) / 2.0 * 100).round(2)
+            end
+
+            def score_relevance(text, question)
+              return 50.0 if question.nil? || text.nil?
+
+              keywords = question.to_s.downcase.scan(/\b\w{4,}\b/).uniq
+              return 50.0 if keywords.empty?
+
+              text_lower = text.downcase
+              matched = keywords.count { |kw| text_lower.include?(kw) }
+              ((matched.to_f / keywords.length) * 100).round(2)
+            end
+
+            def score_clarity(text)
+              return 0.0 if text.nil? || text.strip.empty?
+
+              sentences = text.split(/[.!?]+/).reject(&:empty?)
+              return 50.0 if sentences.empty?
+
+              avg_length = sentences.sum { |s| s.split.length }.to_f / sentences.length
+              length_score = if avg_length.between?(10, 25)
+                               100.0
+                             elsif avg_length < 10
+                               avg_length * 10.0
+                             else
+                               [100.0 - ((avg_length - 25) * 2), 0.0].max
+                             end
+              length_score.round(2)
+            end
+
+            def score_compliance(text, requirements)
+              return 100.0 if requirements.empty?
+              return 0.0 if text.nil?
+
+              text_lower = text.downcase
+              matched = requirements.count do |req|
+                req_text = (req.is_a?(Hash) ? req[:text] : req).to_s.downcase
+                keywords = req_text.scan(/\b\w{4,}\b/).uniq
+                keywords.any? { |kw| text_lower.include?(kw) }
+              end
+
+              ((matched.to_f / requirements.length) * 100).round(2)
+            end
+
+            include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
+                                                        Legion::Extensions::Helpers.const_defined?(:Lex)
+          end
+        end
+      end
+    end
+  end
+end