dvla-kaping 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: '09c60001616143c58b1a1023bea7cdcf653c495ea1410222d767dc8718f4507b'
+  data.tar.gz: 713da1c1de593ffc1e516aa4a0727eae53174fb6832f82a0b8c988b7bba85ff7
+SHA512:
+  metadata.gz: f182de8966f9e515888ccfc137322df7a1fb8a84e7949ae2a9d8d439ff2ecc3f9f464766d864de3d7ec2480d3f965541be74e80af92e9eb8fc7b4d26ded224c0
+  data.tar.gz: 25a74e3a85a3719952e7239919b53aa1e6a9294713ece79c60ee42cce20ac862fb9b4487e65ceed33661f731dad97f1fdaaacd5256b968aab9fe69fb6f3a63cf

data/.drone.yml

@@ -0,0 +1,122 @@
+---
+kind: pipeline
+name: audit, lint & test
+
+platform:
+  os: linux
+  arch: amd64
+
+trigger:
+  event:
+    - push
+
+drone_cache_image: &drone_cache_image
+  image: 448934085854.dkr.ecr.eu-west-2.amazonaws.com/ce/drone-cache
+  pull: if-not-exists
+
+drone_cache_settings: &drone_cache_settings
+  bucket: dvla-drone1-cache-448934085854
+  region: eu-west-2
+  encryption: AES256
+  endpoint: https://s3.eu-west-2.amazonaws.com
+
+gem_cache_mount: &gem_cache_mount
+  mount:
+    - vendor/bundle
+
+ruby_image: &ruby_image
+  image: 448934085854.dkr.ecr.eu-west-2.amazonaws.com/base-images/qe-ruby:3
+
+sonar_image: &sonar_image
+  image: 448934085854.dkr.ecr.eu-west-2.amazonaws.com/utilities-ci-tools/ci-drone-sonar-scanner
+  pull: if-not-exists
+
+steps:
+  - name: Restore gems from cache
+    <<: *drone_cache_image
+    settings:
+      <<: *drone_cache_settings
+      <<: *gem_cache_mount
+      restore: true
+      cache_key: '{{ checksum "./README.md" }}' # Override the README to force a rebuild
+
+  - name: Unit tests
+    <<: *ruby_image
+    depends_on:
+      - Restore gems from cache
+    commands:
+      - bundle install
+      - bundle exec rspec
+    environment:
+      BUNDLE_PATH: vendor/bundle
+
+  - name: Gem audit
+    <<: *ruby_image
+    depends_on:
+      - Restore gems from cache
+    commands:
+      - bundle install
+      - bundle exec bundle-audit
+    environment:
+      BUNDLE_PATH: vendor/bundle
+
+  - name: Lint
+    <<: *ruby_image
+    depends_on:
+      - Restore gems from cache
+    commands:
+      - bundle install
+      - bundle exec rubocop
+    environment:
+      BUNDLE_PATH: vendor/bundle
+
+  - name: SonarQube
+    <<: *sonar_image
+    depends_on:
+      - Unit tests
+
+  - name: Build and deploy (dry-run)
+    image: 448934085854.dkr.ecr.eu-west-2.amazonaws.com/utilities-ci-tools/ci-qe-deploy-gem:latest
+    commands:
+      - git fetch origin main
+      - app
+    environment:
+      DRYRUN: true
+      VERBOSE: false
+
+  - name: Rebuild gem cache
+    <<: *drone_cache_image
+    depends_on:
+      - Gem audit
+    settings:
+      <<: *drone_cache_settings
+      <<: *gem_cache_mount
+      rebuild: true
+      cache_key: '{{ checksum "./README.md" }}'
+
+---
+kind: pipeline
+name: deploy
+depends_on:
+  - audit, lint & test
+
+platform:
+  os: linux
+  arch: amd64
+
+trigger:
+  event:
+    - push
+  branch:
+    - main
+
+steps:
+  - name: Build and deploy
+    image: 448934085854.dkr.ecr.eu-west-2.amazonaws.com/utilities-ci-tools/ci-qe-deploy-gem:latest
+    commands:
+      - git fetch origin main
+      - app
+    environment:
+      DRYRUN: false
+      VERBOSE: false
+

data/.rspec

@@ -0,0 +1,6 @@
+--format documentation
+--color
+--require spec_helper
+--format RspecSonarqubeFormatter
+--out out/test-report.xml
+

data/.rubocop.yml

@@ -0,0 +1,11 @@
+inherit_gem:
+  dvla-lint: ".rubocop.yml"
+
+AllCops:
+  TargetRubyVersion: 3.0
+
+Style/StringLiterals:
+  EnforcedStyle: single_quotes
+
+Style/StringLiteralsInInterpolation:
+  EnforcedStyle: single_quotes

data/.ruby-version

@@ -0,0 +1 @@
+3.4.2

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## [Unreleased]
+
+## [0.1.0] - 2024-11-07
+
+- 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/LICENCE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 HM Government (Driver and Vehicle Licensing Agency)
+
+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,145 @@
+# Dvla::Kaping
+
+The Kaping! gem - an idiomatic way to create DSL openSearch definitions
+
+## OpenSearch Query DSL
+https://opensearch.org/docs/latest/query-dsl/
+
+OpenSearch provides a search language called Query domain-specific language (Query DSL) that you can use to search for data. 
+Query DSL is a flexible language with a JSON interface.
+
+With query DSL, you need to specify a query in the query parameter of the search. One of the simplest searches in OpenSearch 
+uses the match_all query, which matches all documents in an index:
+
+```ruby
+{"query":{"match_all":{}}}
+```
+Or you can search on a specific field for a specif value
+
+```ruby
+{
+  "query": {
+     "match_phrase": { "foo":"BAR"} }
+  }
+```
+
+The real power of OpenSearch is you can combine multiple queries clauses to build complex search queries, the problem is they can be 
+complex to construct so this gem looks to simplify the process.
+
+## Query and filter context
+
+A filter context asks - “Does the document match the query clause?” and returns matching documents 
+i.e it's a binary answer
+
+A query context asks - “How well does the document match the query clause?”, - also returns a relevance score
+good for full-text searches
+
+# How to use
+Before you can use this Gem please ensure you can access your Opensearch instance. You may 
+also need to configure and assume an AWS role depending on your environment
+
+The **query builder** is the main feature of this gem, but there is also the additional facility to
+set up a **client** to send the queries to OpeSearch. The client is also extended to enable a **search**,
+so this will spin up a client, connect and post the query. Each of these features can be used independently
+or as a package.
+
+## Configuration
+
+The gem makes use of the config settings to target the different environments, tables and aws settings.
+
+The setting can be over-written by adding this line in your code
+
+```ruby
+DVLA::Kaping.configure { |attr| attr.yaml_override_path = './config/kaping.yml' }
+
+```
+The 'index' setting will control what environment to target
+
+The 'result_size' setting determines how many records to be returned from the query, if you are doing a post query filtering 
+code side then you should pump this value up.
+
+```yml
+kaping:
+  host: <%= ENV['HOST'] || 'https://[path-to-service]' %>
+  index: <%= ENV['INDEX'] || 'index-name'  %>
+  result_size: 50
+  log_level: <%= ENV['LOG_LEVEL'] || :debug %>
+
+```
+If you want to use the built-in client, and your OpenSearch instance is hosted in a Amazon VPC you will need to assume AWS permissions for access to run the queries.
+there are two options, you can either use profile or environment
+
+Profile will just pick up the credentials save in your specified shared credentials ini file at ~/.aws/credentials, 
+
+```yml
+  aws:
+    #  to use a AWS profile config file then set to profile, otherwise environment settings will be used
+    credential_type: profile
+    account_id: ##########
+    region: aws-region
+    profile: PROFILE
+    role: ROLE  
+```
+
+## Client
+
+client.connect will get you a new connection to use for a search query. The client is fully configurable from the config settings.
+
+```ruby
+ client = DVLA::Kaping::AWSClient.new
+ con = client.connect
+  ```
+
+  The client will need credentials which can be configured in the kaping.yml file or set as environment variables 
+
+## Search
+You can use the shortcut search facility, this will connect to a new client, all you need to do is supply the query to run
+
+```ruby
+body = DVLA::Kaping::Query.new('bool')
+  body.filter.term('foo.bar', 'Valid').
+    between('foo.dateOfBirth', '1958-08-21', '1970-08-21')
+
+ response = DVLA::Kaping.search(body)
+  ```
+
+## Query building
+A query can be built up with dot notation, but there are a few rules to follow. 
+
+First get a new Kaping Query instance. If we want a new Boolean query then we set the type as bool. 
+```ruby
+my_query = DVLA::Kaping::Query.new('bool')
+my_query.filter.term('foo.bar', 'Valid').
+  between('foo.bar', '1958-08-21', '1970-08-21')
+
+#  my_query.to_json will produce
+'{"query":{"bool":{"filter":[{"term":{"foo":"Valid"}},{"range":{"foo.bar":{"gte":"1958-08-21","lte":"1970-08-21"}}}]}}}'
+
+# we don't have to set the type for simple queries, the second parameter takes in key word arguments
+
+my_query = DVLA::Kaping::Query.new('match_phrase', foo: 'bar')
+
+#  my_query.to_json will produce
+'{"query":{"match_phrase":{"foo":"bar"}}}'
+```
+
+We then set the context of the query, this can be in the form of a filter context or a query context parameter.
+
+```ruby
+my_query.filter
+# or
+my_query.match
+```
+
+Then you can start building up complex queries as required with the dot notation
+
+Once you have your query defined you will then need to call to_json to build out the full
+structure of the query from the ruby objects.
+
+```ruby
+my_json_query = my_query.to_json
+```
+
+## Code of Conduct
+
+Everyone interacting in the Dvla::Kaping project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](./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/config/kaping.yml

@@ -0,0 +1,4 @@
+kaping_host: <%= ENV['KAPING_HOST'] || 'nil' %>
+kaping_index: <%= ENV['KAPING_INDEX'] || 'nil'  %>
+kaping_result_size: <%= ENV['KAPING_RESULT_SIZE'] || '50'  %>
+kaping_log_level: <%= ENV['KAPING_LOG_LEVEL'] || :debug %>

data/lib/dvla/kaping/aws_client.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require 'aws-sdk-core'
+require 'opensearch-aws-sigv4'
+require 'aws-sigv4'
+
+module DVLA
+  module Kaping
+    class AWSClient
+      def initialize
+        @base_url = Kaping.yaml[:kaping_host]
+        @aws_account_id = Kaping.yaml.dig(:aws, :account_id)
+        @role = Kaping.yaml.dig(:aws, :role)
+        @region = Kaping.yaml.dig(:aws, :region)
+        Kaping.logger.info { "Kaping Client | base_url: '#{@base_url}'" }
+      end
+
+      def connect
+        credentials = if Kaping.yaml.dig(:aws, :credential_type) == 'profile'
+                        assume_role_profile(@aws_account_id, @role)
+                      else
+                        assume_role_env(@aws_account_id, @role)
+                      end
+
+        signer = Aws::Sigv4::Signer.new(service: 'es',
+                                        region: @region,
+                                        credentials_provider: credentials)
+
+        OpenSearch::Aws::Sigv4Client.new({
+                                      host: @base_url,
+                                      log: false,
+                                    }, signer)
+      end
+
+    private
+
+      # @returns aws credentials using a profile
+      def assume_role_profile(aws_account_id, role)
+        role_arn = "arn:aws:iam::#{aws_account_id}:role/#{role}"
+        sts = Aws::STS::Client.new(region: @region, profile: Kaping.yaml.dig(:aws, :profile))
+        sts.assume_role(role_arn: role_arn, role_session_name: 'kaping')
+      rescue Aws::STS::Errors::ServiceError => e
+        raise "#{__method__}: AWS Profile Credentials Issue: #{e.message}  #{e.class.name}"
+      end
+
+      # via ENV settings - these are pick up directly
+      def assume_role_env(aws_account_id, role)
+        role_arn = "arn:aws:iam::#{aws_account_id}:role/#{role}"
+        sts = Aws::STS::Client.new(region: @region)
+        sts.assume_role(role_arn: role_arn, role_session_name: 'kaping')
+      rescue Aws::STS::Errors::ServiceError => e
+        raise "#{__method__}: AWS ENV Credentials Issue: #{e.message}  #{e.class.name}"
+      end
+    end
+  end
+end

data/lib/dvla/kaping/config.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require 'yaml'
+require 'active_support/core_ext/hash/deep_merge'
+
+
+module DVLA
+  module Kaping
+    class Config
+      attr_accessor :yaml
+      attr_reader :logger, :yaml_override_path
+
+      ATTRIBUTES = %w[host index result_size log_level].freeze
+      attr_accessor(*ATTRIBUTES)
+
+      def initialize
+        @yaml = load_yaml(Dir["#{Dir.pwd}/**/kaping.yml"].first)
+
+        ATTRIBUTES.each do |attr|
+          instance_variable_set(:"@#{attr}", ENV.fetch(attr.to_s.upcase, nil))
+        end
+
+        @logger = Logger.new($stdout)
+        @log_level ||= 'INFO'
+        @result_size ||= 100
+      end
+
+      #   step 1 - find kaping.yml
+      def load_yaml(path)
+        path = "#{path}.yml" unless %w[.yaml .yml].include?(File.extname(path))
+
+        if File.exist?(path)
+          YAML.safe_load(ERB.new(File.read(path)).result, symbolize_names: true, aliases: true)
+        else
+          warn("[WARN] YAML file not found at: '#{path}'")
+          nil
+        end
+      end
+
+      def yaml_override_path=(path)
+        unless path == @yaml_override_path
+          @yaml_override_path = path
+
+          merge_yaml(@yaml_override_path)
+        end
+      end
+
+      def merge_yaml(path)
+        config = load_yaml(path)
+
+        @yaml = @yaml.deep_merge(config) unless config.nil?
+      end
+
+      def logger=(new_logger)
+        if new_logger.is_a?(Logger)
+          @logger = new_logger
+          @logger.level = @yaml[kaping_log_level]
+        else
+          warn("[WARN] Custom logger is not an instance of Logger: '#{new_logger.class}'")
+        end
+      end
+
+      def log_level(_log_level = @yaml.dig(:kaping, :log_level))
+        @log
+      end
+    end
+  end
+end

data/lib/dvla/kaping/query.rb

@@ -0,0 +1,41 @@
+require_relative 'query_term'
+
+module DVLA
+  module Kaping
+    class Query
+      include QueryTerm
+
+      BOOL = 'bool'.freeze
+      MATCH = 'match'.freeze
+
+      attr_reader :query_type, :kwargs
+      protected attr_reader :operations, :parameters
+      protected attr_accessor :last_operation
+
+      def initialize(type, **kwargs)
+        super()
+        @last_operation = nil
+        @query_type = type
+        @operations ||= {}
+        @kwargs = kwargs
+      end
+
+      #  associated with Boolean query
+      %i[must must_not should filter].each do |op|
+        define_method(op) do
+          @last_operation = op
+          operations[op] ||= []
+          self
+        end
+      end
+
+      def to_json(*_args)
+        if kwargs.empty?
+          { query: { "#{query_type}": operations } }.to_json
+        else
+          { query: { "#{query_type}": kwargs } }.to_json
+        end
+      end
+    end
+  end
+end

data/lib/dvla/kaping/query_term.rb

@@ -0,0 +1,89 @@
+# assumes @operation exists
+# assumes @last_operation exists
+
+module DVLA
+  module Kaping
+    module Constants
+      ALLOWED_PARAMS = :minimum_should_match
+    end
+
+    module QueryTerm
+      def match_phrase(field, value, **kwargs)
+        current_operation << {
+          match_phrase: { "#{field}": value },
+        }
+        current_params(kwargs)
+        self
+      end
+
+      def match(field, value)
+        current_operation << {
+          match: { "#{field}": value },
+        }
+        self
+      end
+
+      def exists(field, value)
+        current_operation << {
+          exists: { "#{field}": value },
+        }
+        self
+      end
+
+      def wildcard(field, value)
+        current_operation << {
+          wildcard: { "#{field}": value },
+        }
+        self
+      end
+
+      def term(field, value)
+        current_operation << {
+          term: { "#{field}": value },
+        }
+        self
+      end
+
+      def prefix(field, value)
+        current_operation << {
+          prefix: { "#{field}": value },
+        }
+        self
+      end
+
+      def regex(field, value)
+        current_operation << {
+          regex: { "#{field}": value },
+        }
+        self
+      end
+
+      def between(field, *args)
+        fragment = case args
+                   in [Range]
+                     { gte: args.first.first, lte: args.first.last }
+                   in [String, String]
+                     { gte: args.first, lte: args.last }
+                   in [Hash]
+                     args.first
+                   else
+                     raise ArgumentError, "Expected either a range or a upper and lower bounds, got #{args}"
+                   end
+        current_operation << {
+          range: { "#{field}": fragment },
+        }
+        self
+      end
+
+      def current_operation
+        operations[last_operation]
+      end
+
+      def current_params(value)
+        if value.key?(Constants::ALLOWED_PARAMS)
+          operations.merge!(value)
+        end
+      end
+    end
+  end
+end

data/lib/dvla/kaping/search.rb

@@ -0,0 +1,16 @@
+module DVLA
+  module Kaping
+    module Search
+      #  could pass in a home rolled client
+      def search(body)
+        client = DVLA::Kaping::AWSClient.new
+        con = client.connect
+        con.search(
+          index: Kaping.yaml[:kaping_index],
+          body: body,
+          size: Kaping.yaml[:kaping_result_size],
+        )
+      end
+    end
+  end
+end

data/lib/dvla/kaping/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module DVLA
+  module Kaping
+    VERSION = '1.0.0'
+  end
+end

data/lib/dvla/kaping.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'json'
+require_relative 'kaping/version'
+require_relative 'kaping/config'
+require_relative 'kaping/aws_client'
+require_relative 'kaping/query'
+require_relative 'kaping/query_term'
+require_relative 'kaping/search'
+
+module DVLA
+  module Kaping
+    extend DVLA::Kaping::Search
+
+    CONFIG = "#{Gem::Specification.find_by_name('dvla-kaping').gem_dir.freeze}/config".freeze
+
+    def self.config
+      @config ||= DVLA::Kaping::Config.new
+    end
+
+    def self.configure
+      yield config
+    end
+
+    def self.logger
+      config.logger
+    end
+
+    def self.yaml
+      logger.warn { 'Environment not set!'.red } unless config.yaml
+      config.yaml || {}
+    end
+  end
+end

data/sig/dvla/kaping.rbs

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

data/sonar-project.properties

@@ -0,0 +1,5 @@
+# sonar-project.properties
+sonar.sources=lib
+sonar.tests=spec
+sonar.ruby.coverage.reportPaths=coverage/coverage.json
+sonar.testExecutionReportPaths=out/test-report.xml

metadata

@@ -0,0 +1,83 @@
+--- !ruby/object:Gem::Specification
+name: dvla-kaping
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Driver and Vehicle Licensing Agency (DVLA)
+- Kevin Upstill
+bindir: exe
+cert_chain: []
+date: 2025-04-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.16.7
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.16.7
+description: Wrapper for the AWS elastic search API to create an idiomatic way to
+  build complex search queries
+email:
+- Kevin.Upstill@dvla.gov.uk
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".drone.yml"
+- ".rspec"
+- ".rubocop.yml"
+- ".ruby-version"
+- CHANGELOG.md
+- CODE_OF_CONDUCT.md
+- LICENCE
+- README.md
+- Rakefile
+- config/kaping.yml
+- lib/dvla/kaping.rb
+- lib/dvla/kaping/aws_client.rb
+- lib/dvla/kaping/config.rb
+- lib/dvla/kaping/query.rb
+- lib/dvla/kaping/query_term.rb
+- lib/dvla/kaping/search.rb
+- lib/dvla/kaping/version.rb
+- sig/dvla/kaping.rbs
+- sonar-project.properties
+homepage: https://github.com/dvla/kaping
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/dvla/kaping
+  source_code_uri: https://github.com/dvla/kaping
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.2
+specification_version: 4
+summary: Idiomatic way to create DSL openSearch definitions
+test_files: []