hmibo 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 6c7f53b6038e3600d9f1190977b7bfbca6554297b260972230565dcc5eb2872a
+  data.tar.gz: 3477105cd41caa85e5a7eb33b4bfb9b4dbd7bf41e3dd8ff0670f256c266a7449
+SHA512:
+  metadata.gz: 5e7344a7a1a8b70a6b7446f9de4f7a3d437951207741ef0048c0b142cfd6e6e3a4284ebb34f5dcd946b7fd263e5b18c0869d8ce60f683e20027b3d0b260d0cf2
+  data.tar.gz: 0c932a2a11b444c6c05f766ee2d62555521aab46caeb573bc6646c6e949a56d3b08319974a68b8916dcb9fbc7b7edb14bddec004ae6d9cbd90a795af9eec3949

data/CHANGELOG.md

@@ -0,0 +1,27 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [0.1.0] - 2025-07-19
+
+### Added
+- Initial release of Hmibo gem
+- Base service class pattern for clean business logic organization
+- Structured error handling with automatic logging via LoggerHead
+- Result pattern with success/failure states and data
+- BulkCreation service for bulk record operations with individual error tracking
+- Test helpers for RSpec integration
+- Comprehensive test coverage
+- Documentation and examples
+
+### Features
+- Simple, lightweight service object pattern
+- Consistent error collection with flexible formats
+- Automatic exception logging with contextual information
+- Support for bulk operations with per-record error tracking
+- Rails-friendly with minimal dependencies
+- Clean API: `SomeService.call(params)`
+- Error interface: `result.errors?`, `result.errors`, `result.data`

data/CLAUDE.md

@@ -0,0 +1,64 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Project Overview
+
+Hmibo is a lightweight Ruby gem providing simple, dependency-free service object patterns inspired by DetectionTek conventions. The gem focuses on business logic encapsulation, error handling, and bulk operations for Rails applications.
+
+## Development Commands
+
+- **Run tests**: `rake spec` or `bundle exec rspec`
+- **Run linting**: `rake rubocop` or `bundle exec rubocop`
+- **Run all checks**: `rake` (runs both tests and rubocop)
+- **Build gem**: `rake build`
+- **Install gem locally**: `rake install`
+
+## Core Architecture
+
+### Service Object Pattern
+All services inherit from `Hmibo::Base` (lib/hmibo/base.rb), which provides:
+- Error collection and handling via `@errors` array
+- `call` class method for service execution
+- Exception handling with `handle_error`
+- Logging integration (Rails-aware)
+
+Services implement business logic in the private `perform` method and use:
+- `add_error(message, code:, id:)` for error tracking
+- `errors?` to check for validation failures
+
+### Result Objects
+`Hmibo::Result` (lib/hmibo/result.rb) provides consistent return values with:
+- `success?` / `failure?` status methods
+- `message`, `data`, and `errors` attributes
+- JSON serialization via `to_h` and `to_json`
+- Factory methods: `Result.success(message, data)` and `Result.failure(message, errors)`
+
+### Bulk Operations
+`Hmibo::BulkCreation` (lib/hmibo/bulk_creation.rb) handles batch record creation:
+- Processes arrays of parameters with `client_side_id` tracking
+- Individual error tracking per record
+- Validation for input parameters and target class
+
+### Test Integration
+`Hmibo::TestHelpers` (lib/hmibo/test_helpers.rb) provides RSpec matchers:
+- `expect_service_success(service)` - assert successful execution
+- `expect_service_failure(service, expected_error_count:)` - assert failure
+- `expect_service_error(service, message)` - assert specific error messages
+- `expect_service_error_with_attributes(service, attributes)` - assert error structure
+- `mock_service` and `stub_service` for test doubles
+
+## File Structure
+- `lib/hmibo.rb` - Main entry point and exception classes
+- `lib/hmibo/base.rb` - Core service class
+- `lib/hmibo/result.rb` - Result object implementation
+- `lib/hmibo/bulk_creation.rb` - Bulk operation service
+- `lib/hmibo/error.rb` - Custom exception definitions
+- `lib/hmibo/concerns/` - Reusable service modules
+- `spec/` - RSpec test suite with Rails integration tests
+
+## Testing Approach
+- Uses RSpec with custom matchers from TestHelpers
+- Rails integration specs in spec/integration/
+- Service-specific specs follow naming convention: `service_name_spec.rb`
+- Test helpers automatically included via spec_helper.rb configuration

data/Gemfile

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in hmibo.gemspec
+gemspec
+
+gem 'rake', '~> 13.0'
+gem 'rspec', '~> 3.0'
+gem 'rubocop', '~> 1.21'
+gem 'rubocop-rspec', '~> 2.0'
+
+# Development and testing dependencies
+group :development, :test do
+  gem 'logger_head', path: '../logger_head'
+  gem 'rails', '~> 7.1.0'
+  gem 'sprockets-rails'
+  gem 'sqlite3', '~> 1.4'
+end

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Daniel Brown
+
+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,190 @@
+# Hmibo
+
+**How May I Be Of service!** 
+
+Hmibo is a lightweight Ruby gem that provides simple, consistent patterns for service objects. Inspired by personal patterns, it offers structured error handling and logging for business logic in your Rails applications.
+
+## Features
+
+- **Simple Base Service Class**: Clean pattern following personal conventions
+- **Structured Error Logging**: Integrated with LoggerHead for contextual error logging
+- **Consistent Error Handling**: Structured error collection with flexible formats
+- **Bulk Operations**: Specialized service for bulk record creation with individual error tracking
+- **Rails Testing Helpers**: RSpec helpers for easy service testing
+- **Minimal Dependencies**: Uses LoggerHead for enhanced error logging (works great with Rails 7.1+)
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'hmibo'
+```
+
+And then execute:
+
+```bash
+$ bundle install
+```
+
+## Usage
+
+### Basic Service Object
+
+```ruby
+class CreateUserService < Hmibo::Base
+  def initialize(name:, email:, role: 'user')
+    @name = name
+    @email = email
+    @role = role
+    super()
+  end
+
+  private
+
+  attr_reader :name, :email, :role
+
+  def perform
+    add_error("Name is required") if name.blank?
+    add_error("Email is required") if email.blank?
+    add_error("Email format is invalid") unless valid_email?
+    
+    return self if errors?
+
+    user = User.create!(name: name, email: email, role: role)
+    @data = user
+    self
+  end
+
+  def valid_email?
+    email.match?(/\A[^@\s]+@[^@\s]+\z/)
+  end
+end
+
+# Usage
+result = CreateUserService.call(name: "John Doe", email: "john@example.com")
+
+if result.errors?
+  puts "Errors: #{result.errors.map { |e| e[:message] }.join(', ')}"
+else
+  puts "User created: #{result.data.name}"
+end
+```
+
+### Bulk Creation Service
+
+```ruby
+# Create multiple records with error handling
+params = [
+  { name: "John", email: "john@example.com", client_side_id: "temp-1" },
+  { name: "Jane", email: "invalid-email", client_side_id: "temp-2" },
+  { name: "Bob", email: "bob@example.com", client_side_id: "temp-3" }
+]
+
+result = Hmibo::BulkCreation.call(params, User)
+
+if result.errors?
+  result.errors.each do |error|
+    puts "Error for #{error[:id]}: #{error[:message]}"
+  end
+else
+  puts "All #{result.data.length} users created successfully"
+end
+```
+
+## Service Response
+
+Every service returns itself with the following interface:
+
+```ruby
+result = SomeService.call(params)
+
+result.errors?      # => true/false if there are errors
+result.data         # => Any data set by the service
+result.errors       # => Array of error hashes: [{message: "...", code: 422, id: nil}]
+```
+
+## Error Handling
+
+Services provide structured error handling with automatic logging:
+
+```ruby
+class ExampleService < Hmibo::Base
+  private
+
+  def perform
+    # Add individual errors
+    add_error("Something went wrong")
+    
+    # Errors are automatically logged with context using LoggerHead
+    return self if errors?
+
+    @data = { success: true }
+    self
+  end
+end
+```
+
+### Automatic Error Logging
+
+Hmibo integrates with [LoggerHead](https://github.com/lordofthedanse/logger_head) to provide structured error logging with context:
+
+```ruby
+class CreateUserService < Hmibo::Base
+  def perform
+    # Any unhandled exceptions are automatically logged with context
+    raise StandardError, "Database connection failed"
+  end
+end
+
+result = CreateUserService.call
+# Automatically logs:
+# ERROR -- : There was an error in CreateUserService execution: Database connection failed
+# ERROR -- : /path/to/backtrace...
+```
+
+### Custom Error Context
+
+You can provide custom context for error logging:
+
+```ruby
+class PaymentService < Hmibo::Base
+  private
+
+  def perform
+    process_payment
+  rescue => error
+    log_error(error, context: "processing payment for user #{user_id}")
+    add_error("Payment processing failed")
+    self
+  end
+end
+```
+
+## Exception Classes
+
+Hmibo provides custom exception classes:
+
+- `Hmibo::ServiceError` - Base service error
+
+## Dependencies
+
+Hmibo has one very lightweight dependency:
+
+- [LoggerHead](https://github.com/lordofthedanse/logger_head) - Structured error logging with context
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests.
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

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/examples/logger_head_integration.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+# Example demonstrating LoggerHead integration in Hmibo services
+# This example shows how LoggerHead provides structured error logging with context
+
+require_relative '../lib/hmibo'
+
+# Example service that demonstrates LoggerHead integration
+class ExampleService < Hmibo::Base
+  def initialize(data:)
+    @data_input = data
+    super()
+  end
+
+  private
+
+  attr_reader :data_input
+
+  def perform
+    # Validate input
+    if data_input.nil?
+      add_error('Data cannot be nil')
+      return self
+    end
+
+    # Simulate some processing that might fail
+    add_error('Name is required') if data_input[:name].nil? || data_input[:name].empty?
+
+    add_error('Age must be positive') if data_input[:age] && data_input[:age] < 0
+
+    return self if errors?
+
+    # Simulate a potential runtime error for demonstration
+    raise StandardError, 'Simulated processing error' if data_input[:name] == 'trigger_error'
+
+    @data = { processed: true, name: data_input[:name], age: data_input[:age] }
+    self
+  end
+end
+
+# Example usage with LoggerHead integration
+puts '=== LoggerHead Integration in Hmibo Example ==='
+puts
+
+# Example 1: Successful execution
+puts '1. Successful execution:'
+result = ExampleService.call(data: { name: 'John', age: 25 })
+puts "  Success: #{!result.errors?}"
+puts "  Data: #{result.data}"
+puts
+
+# Example 2: Validation errors (logged with context)
+puts '2. Validation errors:'
+result = ExampleService.call(data: { name: '', age: -5 })
+puts "  Success: #{!result.errors?}"
+puts "  Errors: #{result.errors}"
+puts
+
+# Example 3: Runtime exception (logged with LoggerHead)
+puts '3. Runtime exception (check logs for LoggerHead output):'
+result = ExampleService.call(data: { name: 'trigger_error', age: 30 })
+puts "  Success: #{!result.errors?}"
+puts "  Errors: #{result.errors}"
+puts
+
+puts '=== LoggerHead Features ==='
+puts '✓ Structured error logging with context'
+puts '✓ Automatic backtrace logging'
+puts '✓ Service class context included'
+puts '✓ Works in Rails and non-Rails environments'
+puts '✓ Consistent with DetectionTek logging patterns'

data/examples/using_hmibo_in_rails.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+# Example: Simple service object patterns using Hmibo
+# Inspired by DetectionTek patterns - clean, dependency-free Ruby classes
+
+# Example 1: Basic service pattern
+class CreateUser < Hmibo::Base
+  def initialize(user_params)
+    @user_params = user_params
+    super()
+  end
+
+  private
+
+  def perform
+    return add_error('Name is required') if @user_params[:name].nil?
+    return add_error('Email is required') if @user_params[:email].nil?
+
+    user = User.new(@user_params)
+
+    if user.save
+      @data = user
+    else
+      user.errors.full_messages.each { |msg| add_error(msg) }
+    end
+
+    self
+  end
+end
+
+# Example 2: Bulk creation with error tracking
+class BulkCreation < Hmibo::Base
+  def initialize(params, klass)
+    @params = params
+    @klass = klass
+    super()
+  end
+
+  private
+
+  def perform
+    return add_error('Params cannot be blank') if @params.nil? || @params.empty?
+    return add_error('Class cannot be blank') if @klass.nil?
+
+    created_records = []
+
+    @params.each do |param_set|
+      record = @klass.new(param_set.except(:client_side_id))
+
+      if record.save
+        created_records << record
+      else
+        message = record.errors.full_messages.join(', ')
+        add_error(message, id: param_set[:client_side_id])
+      end
+    end
+
+    @data = created_records
+    self
+  end
+end
+
+# Example 3: Simple email validation service (DetectionTek style)
+class EmailValidator < Hmibo::Base
+  def initialize(emails)
+    @emails = emails
+    super()
+  end
+
+  private
+
+  def perform
+    valid_emails = []
+
+    @emails.each do |email|
+      if valid_email?(email)
+        valid_emails << email
+      else
+        add_error("#{email} is not a valid email address")
+      end
+    end
+
+    @data = valid_emails
+    self
+  end
+
+  def valid_email?(email)
+    email.match?(/\A[\w+\-.]+@[a-z\d-]+(\.[a-z\d-]+)*\.[a-z]+\z/i)
+  end
+end
+
+# Usage examples:
+
+# Simple service call
+user_service = CreateUser.call(name: 'John', email: 'john@example.com')
+if user_service.errors?
+  puts "Errors: #{user_service.errors}"
+else
+  puts "Created user: #{user_service.data.name}"
+end
+
+# Bulk creation with error handling
+params = [
+  { name: 'John', email: 'john@example.com', client_side_id: 'temp-1' },
+  { name: 'Jane', email: 'invalid-email', client_side_id: 'temp-2' }
+]
+
+bulk_service = BulkCreation.call(params, User)
+if bulk_service.errors?
+  puts 'Some records failed:'
+  bulk_service.errors.each do |error|
+    puts "- #{error[:id] || 'N/A'}: #{error[:message] || error}"
+  end
+else
+  puts "All users created: #{bulk_service.data.map(&:name).join(', ')}"
+end
+
+# Email validation
+email_service = EmailValidator.call(['good@email.com', 'bad-email', 'another@good.com'])
+puts "Valid emails: #{email_service.data}"
+puts "Errors: #{email_service.errors}" if email_service.errors?

data/hmibo.gemspec

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require_relative 'lib/hmibo/version'
+
+Gem::Specification.new do |spec|
+  spec.name = 'hmibo'
+  spec.version = Hmibo::VERSION
+  spec.authors = ['Daniel Brown']
+  spec.email = ['daniel@wendcare.com']
+
+  spec.summary = 'Simple service object patterns for Ruby applications'
+  spec.description = 'Hmibo (How May I Be Of service) provides lightweight, dependency-free service object patterns inspired by DetectionTek conventions'
+  spec.homepage = 'https://github.com/lordofthedanse/hmibo'
+  spec.license = 'MIT'
+  spec.required_ruby_version = '>= 3.0.0'
+
+  spec.metadata['allowed_push_host'] = 'https://rubygems.org'
+  spec.metadata['source_code_uri'] = 'https://github.com/lordofthedanse/hmibo'
+  spec.metadata['changelog_uri'] = 'https://github.com/lordofthedanse/hmibo/blob/main/CHANGELOG.md'
+
+  # 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(__dir__) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (File.expand_path(f) == __FILE__) || f.start_with?(*%w[bin/ test/ spec/ features/ .git .circleci appveyor])
+    end
+  end
+  spec.bindir = 'exe'
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  # Dependencies
+  spec.add_dependency 'logger_head', '~> 0.1.0'
+
+  # Development dependencies
+  spec.add_development_dependency 'rspec', '~> 3.0'
+  spec.add_development_dependency 'rubocop', '~> 1.0'
+  spec.add_development_dependency 'rubocop-rspec', '~> 2.0'
+end

data/lib/hmibo/base.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Hmibo
+  # Base service class that provides common patterns for service objects
+  # Inspired by DetectionTek patterns - simple, dependency-free Ruby classes
+  class Base
+    attr_accessor :errors, :data
+
+    def initialize(*args)
+      @errors = []
+      @data = nil
+      setup(*args) if respond_to?(:setup, true)
+    end
+
+    # Main entry point for service execution
+    def call
+      perform
+    rescue StandardError => e
+      handle_error(e)
+      self
+    end
+
+    # Class method for convenient service execution
+    def self.call(*args, **kwargs)
+      new(*args, **kwargs).call
+    end
+
+    def errors?
+      !@errors.empty?
+    end
+
+    private
+
+    # Override this method in subclasses to implement business logic
+    def perform
+      raise NotImplementedError, 'Subclasses must implement #perform'
+    end
+
+    # Handle errors that occur during execution
+    def handle_error(error)
+      log_error(error, context: "#{self.class.name} execution")
+      @errors << error.message
+    end
+
+    # Add an error to the errors collection
+    def add_error(message, code: 422, id: nil)
+      error = if message.is_a?(Hash)
+                message
+              else
+                { message: message, code: code, id: id }
+              end
+      @errors << error
+      self
+    end
+
+    # Log error using LoggerHead for structured logging with context
+    def log_error(error, context: nil)
+      provided_context = context || "in #{self.class.name}"
+      LoggerHead.new(error, provided_context: provided_context).call
+    end
+  end
+end

data/lib/hmibo/bulk_creation.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Hmibo
+  # Service for bulk creation of records with error handling
+  # Follows DetectionTek patterns for simple, consistent service objects
+  class BulkCreation < Base
+    def initialize(params, klass)
+      @params = params
+      @klass = klass
+      super()
+    end
+
+    private
+
+    attr_reader :params, :klass
+
+    def perform
+      return add_validation_errors if invalid_inputs?
+
+      created_records = []
+
+      @params.each do |param_set|
+        record = @klass.new(param_set.except(:client_side_id))
+
+        if record.save
+          created_records << record
+        else
+          add_error_for_record(record, param_set[:client_side_id])
+        end
+      end
+
+      @data = created_records
+      self
+    end
+
+    def invalid_inputs?
+      return true if @params.nil? || (defined?(@params.blank?) && @params.blank?) || (@params.respond_to?(:empty?) && @params.empty?)
+      return true if @klass.nil?
+
+      false
+    end
+
+    def add_validation_errors
+      add_error('Params cannot be blank') if @params.nil? || (defined?(@params.blank?) && @params.blank?) || (@params.respond_to?(:empty?) && @params.empty?)
+      add_error('Class cannot be blank') if @klass.nil?
+    end
+
+    def add_error_for_record(record, client_side_id)
+      if record.errors.respond_to?(:full_messages)
+        record.errors.full_messages.each do |message|
+          add_error(message, code: 422, id: client_side_id)
+        end
+      else
+        add_error('Record validation failed', code: 422, id: client_side_id)
+      end
+    end
+  end
+end

data/lib/hmibo/error.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Hmibo
+  # Error class for structured error handling
+  class Error
+    attr_reader :id, :message, :code, :field
+
+    def initialize(message, code: 422, id: nil, field: nil)
+      @message = message
+      @code = code
+      @id = id
+      @field = field
+    end
+
+    def to_h
+      {
+        message: @message,
+        code: @code,
+        id: @id,
+        field: @field
+      }.compact
+    end
+
+    def to_json(*args)
+      to_h.to_json(*args)
+    end
+
+    def self.from_active_record(record, id: nil)
+      errors = []
+
+      record.errors.each do |error|
+        errors << new(
+          error.full_message,
+          code: 422,
+          id: id,
+          field: error.attribute
+        )
+      end
+
+      errors
+    end
+
+    def self.validation_error(message, field: nil)
+      new(message, code: 422, field: field)
+    end
+
+    def self.not_found(message = 'Record not found')
+      new(message, code: 404)
+    end
+
+    def self.unauthorized(message = 'Unauthorized')
+      new(message, code: 401)
+    end
+
+    def self.forbidden(message = 'Forbidden')
+      new(message, code: 403)
+    end
+
+    def self.server_error(message = 'Internal server error')
+      new(message, code: 500)
+    end
+  end
+end

data/lib/hmibo/result.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Hmibo
+  # Result object for service operations
+  class Result
+    attr_reader :success, :message, :data, :errors
+
+    def initialize(success, message, data = nil, errors = [])
+      @success = success
+      @message = message
+      @data = data
+      @errors = Array(errors)
+    end
+
+    def success?
+      @success
+    end
+
+    def failure?
+      !@success
+    end
+
+    def error?
+      failure?
+    end
+
+    def errors?
+      @errors.present?
+    end
+
+    def to_h
+      {
+        success: @success,
+        message: @message,
+        data: @data,
+        errors: @errors
+      }
+    end
+
+    def to_json(*args)
+      to_h.to_json(*args)
+    end
+
+    # Factory methods for creating results
+    def self.success(message = 'Success', data = nil)
+      new(true, message, data, [])
+    end
+
+    def self.failure(message, errors = [])
+      new(false, message, nil, Array(errors))
+    end
+
+    def self.error(message, errors = [])
+      failure(message, errors)
+    end
+  end
+end

data/lib/hmibo/test_helpers.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Hmibo
+  # Test helpers for RSpec testing of Hmibo services
+  module TestHelpers
+    # Assert that a service executed successfully
+    def expect_service_success(service)
+      expect(service.errors?).to be(false),
+                                 "Expected service to succeed, but got errors: #{service.errors}"
+      service
+    end
+
+    # Assert that a service failed with errors
+    def expect_service_failure(service, expected_error_count: nil)
+      expect(service.errors?).to be(true),
+                                 "Expected service to fail, but it succeeded with data: #{service.data}"
+
+      if expected_error_count
+        expect(service.errors.length).to eq(expected_error_count),
+                                         "Expected #{expected_error_count} errors, but got #{service.errors.length}: #{service.errors}"
+      end
+
+      service
+    end
+
+    # Assert that a service has a specific error message
+    def expect_service_error(service, message)
+      expect(service.errors?).to be(true),
+                                 'Expected service to have errors, but it succeeded'
+
+      error_messages = service.errors.map do |error|
+        error.is_a?(Hash) ? error[:message] : error.to_s
+      end
+
+      expect(error_messages).to include(message),
+                                "Expected error '#{message}' but got: #{error_messages}"
+
+      service
+    end
+
+    # Assert that a service has errors with specific attributes
+    def expect_service_error_with_attributes(service, attributes = {})
+      expect(service.errors?).to be(true),
+                                 'Expected service to have errors, but it succeeded'
+
+      matching_error = service.errors.find do |error|
+        next false unless error.is_a?(Hash)
+
+        attributes.all? { |key, value| error[key] == value }
+      end
+
+      expect(matching_error).to be_present,
+                                "Expected error with attributes #{attributes} but got: #{service.errors}"
+
+      service
+    end
+
+    # Create a mock service for testing
+    def mock_service(success: true, data: nil, errors: [])
+      service = instance_double('MockService')
+      allow(service).to receive(:errors?).and_return(!errors.empty?)
+      allow(service).to receive(:data).and_return(data)
+      allow(service).to receive(:errors).and_return(errors)
+      service
+    end
+
+    # Stub a service class to return a specific result
+    def stub_service(service_class, success: true, data: nil, errors: [])
+      mock = mock_service(success: success, data: data, errors: errors)
+      allow(service_class).to receive(:call).and_return(mock)
+      mock
+    end
+  end
+end

data/lib/hmibo/version.rb

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

data/lib/hmibo.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require 'logger_head'
+require_relative 'hmibo/version'
+require_relative 'hmibo/base'
+require_relative 'hmibo/result'
+require_relative 'hmibo/error'
+require_relative 'hmibo/bulk_creation'
+require_relative 'hmibo/test_helpers'
+
+module Hmibo
+  # Exception classes
+  class ServiceError < StandardError; end
+end

data/test_basic.rb

@@ -0,0 +1,67 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift(File.expand_path('lib', __dir__))
+
+require 'hmibo'
+
+# Test basic service
+class TestService < Hmibo::Base
+  def initialize(name: nil)
+    @name = name
+    super()
+  end
+
+  private
+
+  def perform
+    return add_error('Name is required') if @name.nil? || @name.empty?
+
+    @data = { name: @name }
+    self
+  end
+end
+
+puts 'Testing Hmibo gem...'
+
+# Test successful service
+service = TestService.call(name: 'John')
+puts "Success test: #{!service.errors?} (#{service.data})"
+
+# Test error case
+service = TestService.call(name: '')
+puts "Error test: #{service.errors?} (#{service.errors.first})"
+
+# Test BulkCreation
+class MockRecord
+  attr_reader :errors
+
+  def initialize(params)
+    @params = params
+    @errors = []
+  end
+
+  def save
+    if @params[:name] && !@params[:name].empty?
+      true
+    else
+      @errors << "Name can't be blank"
+      false
+    end
+  end
+
+  class << self
+    def full_messages
+      self
+    end
+
+    def join(_separator)
+      "Name can't be blank"
+    end
+  end
+end
+
+bulk = Hmibo::BulkCreation.call([{ name: 'John' }, { name: '' }], MockRecord)
+puts "Bulk creation test: #{bulk.errors?} (#{bulk.errors.length} errors)"
+
+puts 'All tests completed!'

metadata

@@ -0,0 +1,121 @@
+--- !ruby/object:Gem::Specification
+name: hmibo
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Daniel Brown
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2025-07-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: logger_head
+  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
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: rubocop-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+description: Hmibo (How May I Be Of service) provides lightweight, dependency-free
+  service object patterns inspired by DetectionTek conventions
+email:
+- daniel@wendcare.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- CLAUDE.md
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- examples/logger_head_integration.rb
+- examples/using_hmibo_in_rails.rb
+- hmibo.gemspec
+- lib/hmibo.rb
+- lib/hmibo/base.rb
+- lib/hmibo/bulk_creation.rb
+- lib/hmibo/error.rb
+- lib/hmibo/result.rb
+- lib/hmibo/test_helpers.rb
+- lib/hmibo/version.rb
+- log/test.log
+- test_basic.rb
+homepage: https://github.com/lordofthedanse/hmibo
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  source_code_uri: https://github.com/lordofthedanse/hmibo
+  changelog_uri: https://github.com/lordofthedanse/hmibo/blob/main/CHANGELOG.md
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.22
+signing_key:
+specification_version: 4
+summary: Simple service object patterns for Ruby applications
+test_files: []