kiroshi 0.0.1 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f215b5db38cfab5958a6d87cfbfffe94a6a4ca9f36b114d6539f064e918aaf3c
-  data.tar.gz: 11fd8327a643b27eab6feaa92eda2dd962ccbb573501a0dd06f0811ac840dbdc
+  metadata.gz: 3bbe023d89c78eca0371b05303b85c44da60ce794a1c39844b2ab719350cc665
+  data.tar.gz: aa64d92280278a488c7bb2c5385fc7fd5f28a04a5b7a22aa1cbd1681311bf316
 SHA512:
-  metadata.gz: 60fbd8f3a711432be3ecfdd1c565d535657b6424ee46eae72b85d345fed4dd160606eeb7e4c13c83de291b72cce32d6c63bbbc8c31949c1e5c0a3155ddb02821
-  data.tar.gz: e57185d0789ef027ac87be751cc5054cdf52169beb7a7f9836aaa7e750b9776b4ae86751560c91b20dc20b93775a9f63f58d91948d7d85ec23a5012b1a151fdd
+  metadata.gz: 588fb1ce51bb238a8536b08d123a6cd23b8393896eea4f66df436b8fb641e016f517e411a6936ea6277b76c9d34564d44e82b547517b27ec61762634dbaa1ca3
+  data.tar.gz: 7f90feb28c09bc3858110427fe2266ec16fcc699238689ceea3432ed56a6e839ad1d33d49818e7563998817b3d41fc839f175d5e64bbdb0d838f4375e0d5698a

data/.rubocop_todo.yml

@@ -1,21 +1,23 @@
 # This configuration was generated by
 # `rubocop --auto-gen-config`
-# on 2025-08-15 21:59:24 UTC using RuboCop version 1.79.2.
+# on 2025-08-17 15:11:59 UTC using RuboCop version 1.79.2.
 # The point is for the user to remove these configuration records
 # one by one as the offenses are removed from the code base.
 # Note that changes in the inspected code, or installation of new
 # versions of RuboCop, may require this file to be generated again.
 
-# Offense count: 1
-# Configuration parameters: AllowComments, AllowEmptyLambdas.
-Lint/EmptyBlock:
-  Exclude:
-    - 'spec/**/*_spec.rb'
-    - 'spec/dummy/config/routes.rb'
-
 # Offense count: 1
 # Configuration parameters: AllowedPatterns.
 # AllowedPatterns: ^expect_, ^assert_
 RSpec/NoExpectationExample:
   Exclude:
     - 'spec/lib/kiroshi_spec.rb'
+
+# Offense count: 2
+# Configuration parameters: AllowedConstants.
+Style/Documentation:
+  Exclude:
+    - 'spec/**/*'
+    - 'test/**/*'
+    - 'lib/kiroshi/filter.rb'
+    - 'lib/kiroshi/filters.rb'

data/Gemfile

@@ -6,6 +6,7 @@ gemspec
 
 gem 'actionpack',                '7.2.2.1'
 gem 'activerecord',              '7.2.2.1'
+gem 'activesupport',             '7.2.2.1'
 gem 'bundler',                   '~> 2.3'
 gem 'factory_bot',               '6.2.1'
 gem 'minitest',                  '5.25.4'

data/README.md

@@ -1,16 +1,24 @@
-Kiroshi
-====
+# Kiroshi
 [![Build Status](https://circleci.com/gh/darthjee/kiroshi.svg?style=shield)](https://circleci.com/gh/darthjee/kiroshi)
 [![Codacy Badge](https://app.codacy.com/project/badge/Grade/35480a5e82e74ff7a0186697b3f61a4b)](https://app.codacy.com/gh/darthjee/kiroshi/dashboard?utm_source=gh&utm_medium=referral&utm_content=&utm_campaign=Badge_grade)
 
 ![kiroshi](https://raw.githubusercontent.com/darthjee/kiroshi/master/kiroshi.jpg)
 
-Yard Documentation
--------------------
-[https://www.rubydoc.info/gems/kiroshi/0.0.1](https://www.rubydoc.info/gems/kiroshi/0.0.1)
 
-Installation
----------------
+## Yard Documentation
+
+[https://www.rubydoc.info/gems/kiroshi/0.1.0](https://www.rubydoc.info/gems/kiroshi/0.1.0)
+
+Kiroshi has been designed to make filtering ActiveRecord queries easier
+by providing a flexible and reusable filtering system. It allows you to
+define filter sets that can be applied to any ActiveRecord scope,
+supporting both exact matches and partial matching using SQL LIKE operations.
+
+Current Release: [0.1.0](https://github.com/darthjee/kiroshi/tree/0.1.0)
+
+[Next release](https://github.com/darthjee/kiroshi/compare/0.1.0...master)
+
+## Installation
 
 - Install it
 
@@ -27,3 +35,160 @@ Installation
 ```bash
   bundle install kiroshi
 ```
+
+## Usage
+
+### Kiroshi::Filters
+
+[Filters](https://www.rubydoc.info/gems/kiroshi/Kiroshi/Filters)
+is a base class for implementing filter sets on ActiveRecord scopes.
+It uses a class-level DSL to define filters and an instance-level interface to apply them.
+
+#### Basic Usage
+
+```ruby
+# Define a filter class
+class DocumentFilters < Kiroshi::Filters
+  filter_by :name, match: :like
+  filter_by :status
+  filter_by :category
+end
+
+# Apply filters to a scope
+filters = DocumentFilters.new(name: 'report', status: 'published')
+filtered_documents = filters.apply(Document.all)
+# Generates: WHERE name LIKE '%report%' AND status = 'published'
+```
+
+#### Filter Types
+
+Kiroshi supports two types of matching:
+
+- `:exact` - Exact match (default)
+- `:like` - Partial match using SQL LIKE
+
+```ruby
+class UserFilters < Kiroshi::Filters
+  filter_by :email, match: :like      # Partial matching
+  filter_by :role                     # Exact matching (default)
+  filter_by :active, match: :exact    # Explicit exact matching
+end
+
+filters = UserFilters.new(email: 'admin', role: 'moderator')
+filtered_users = filters.apply(User.all)
+# Generates: WHERE email LIKE '%admin%' AND role = 'moderator'
+```
+
+#### Advanced Examples
+
+##### Multiple Filter Types
+
+```ruby
+class ProductFilters < Kiroshi::Filters
+  filter_by :name, match: :like
+  filter_by :category
+  filter_by :price, match: :exact
+  filter_by :brand
+end
+
+# Apply only some filters
+filters = ProductFilters.new(name: 'laptop', category: 'electronics')
+products = filters.apply(Product.all)
+# Only name and category filters are applied, price and brand are ignored
+```
+
+##### Controller Integration
+
+```ruby
+class DocumentsController < ApplicationController
+  def index
+    @documents = document_filters.apply(Document.all)
+    render json: @documents
+  end
+
+  private
+
+  def document_filters
+    DocumentFilters.new(filter_params)
+  end
+
+  def filter_params
+    params.permit(:name, :status, :category, :author)
+  end
+end
+
+class DocumentFilters < Kiroshi::Filters
+  filter_by :name, match: :like
+  filter_by :status
+  filter_by :category
+  filter_by :author, match: :like
+end
+```
+
+##### Nested Resource Filtering
+
+```ruby
+class ArticleFilters < Kiroshi::Filters
+  filter_by :title, match: :like
+  filter_by :published
+  filter_by :tag, match: :like
+end
+
+# In your controller
+def articles
+  base_scope = current_user.articles
+  article_filters.apply(base_scope)
+end
+
+def article_filters
+  ArticleFilters.new(params.permit(:title, :published, :tag))
+end
+```
+
+### Kiroshi::Filter
+
+[Filter](https://www.rubydoc.info/gems/kiroshi/Kiroshi/Filter)
+is the individual filter class that applies filtering logic to ActiveRecord scopes.
+It's automatically used by `Kiroshi::Filters`, but can also be used standalone.
+
+#### Standalone Usage
+
+```ruby
+# Create individual filters
+name_filter = Kiroshi::Filter.new(:name, match: :like)
+status_filter = Kiroshi::Filter.new(:status, match: :exact)
+
+# Apply filters manually
+scope = Document.all
+scope = name_filter.apply(scope, { name: 'report' })
+scope = status_filter.apply(scope, { status: 'published' })
+```
+
+#### Filter Options
+
+- `match: :exact` - Performs exact matching (default)
+- `match: :like` - Performs partial matching using SQL LIKE
+
+```ruby
+# Exact match filter
+exact_filter = Kiroshi::Filter.new(:status)
+exact_filter.apply(Document.all, { status: 'published' })
+# Generates: WHERE status = 'published'
+
+# LIKE match filter
+like_filter = Kiroshi::Filter.new(:title, match: :like)
+like_filter.apply(Document.all, { title: 'Ruby' })
+# Generates: WHERE title LIKE '%Ruby%'
+```
+
+#### Empty Value Handling
+
+Filters automatically ignore empty or nil values:
+
+```ruby
+filter = Kiroshi::Filter.new(:name)
+filter.apply(Document.all, { name: nil })        # Returns original scope
+filter.apply(Document.all, { name: '' })         # Returns original scope  
+filter.apply(Document.all, {})                   # Returns original scope
+filter.apply(Document.all, { name: 'value' })    # Applies filter
+```

data/config/yardstick.yml

@@ -1,4 +1,4 @@
-threshold: 100
+threshold: 100.0
 require_exact_threshold: false
 rules:
   ApiTag::Presence:

data/lib/kiroshi/filter.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module Kiroshi
+  # @author darthjee
+  #
+  # A filter class that applies filtering logic to ActiveRecord scopes
+  #
+  # This class provides a flexible way to apply filters to database queries,
+  # supporting both exact matches and partial matches using SQL LIKE operations.
+  #
+  # @example Creating and applying an exact filter
+  #   filter = Kiroshi::Filter.new(:name)
+  #   filtered_scope = filter.apply(Document.all, { name: 'John' })
+  #
+  # @example Creating and applying a LIKE filter
+  #   filter = Kiroshi::Filter.new(:title, match: :like)
+  #   filtered_scope = filter.apply(Article.all, { title: 'Ruby' })
+  #
+  # @since 0.1.0
+  class Filter
+    # Creates a new Filter instance
+    #
+    # @param attribute [Symbol] the attribute name to filter by
+    # @param match [Symbol] the matching type, defaults to :exact
+    # @option match [Symbol] :exact performs exact matching (default)
+    # @option match [Symbol] :like performs partial matching using SQL LIKE
+    #
+    # @example Creating an exact match filter
+    #   filter = Kiroshi::Filter.new(:status)
+    #
+    # @example Creating a partial match filter
+    #   filter = Kiroshi::Filter.new(:name, match: :like)
+    #
+    # @since 0.1.0
+    def initialize(attribute, match: :exact)
+      @attribute = attribute
+      @match = match
+    end
+
+    # Applies the filter to the given scope
+    #
+    # This method examines the filters hash for a value corresponding to the
+    # filter's attribute and applies the appropriate WHERE clause to the scope.
+    # If no value is present or the value is blank, the original scope is returned unchanged.
+    #
+    # @param scope [ActiveRecord::Relation] the ActiveRecord scope to filter
+    # @param filters [Hash] a hash containing filter values
+    #
+    # @return [ActiveRecord::Relation] the filtered scope
+    #
+    # @example Applying an exact filter
+    #   filter = Kiroshi::Filter.new(:status)
+    #   filter.apply(Document.all, { status: 'published' })
+    #   # Generates: WHERE status = 'published'
+    #
+    # @example Applying a LIKE filter
+    #   filter = Kiroshi::Filter.new(:title, match: :like)
+    #   filter.apply(Article.all, { title: 'Ruby' })
+    #   # Generates: WHERE title LIKE '%Ruby%'
+    #
+    # @example With empty filter value
+    #   filter = Kiroshi::Filter.new(:name)
+    #   filter.apply(User.all, { name: nil })
+    #   # Returns the original scope unchanged
+    #
+    # @since 0.1.0
+    def apply(scope, filters)
+      filter_value = filters[attribute]
+      return scope unless filter_value.present?
+
+      case match
+      when :like
+        scope.where("#{attribute} LIKE ?", "%#{filter_value}%")
+      else # :exact (default)
+        scope.where(attribute => filter_value)
+      end
+    end
+
+    private
+
+    attr_reader :attribute, :match
+
+    # @!method attribute
+    #   @api private
+    #   @private
+    #
+    #   Returns the attribute name to filter by
+    #
+    #   @return [Symbol] the attribute name to filter by
+
+    # @!method match
+    #   @api private
+    #   @private
+    #
+    #   Returns the matching type (+:exact+ or +:like+)
+    #
+    #   @return [Symbol] the matching type (+:exact+ or +:like+)
+  end
+end

data/lib/kiroshi/filters.rb

@@ -0,0 +1,177 @@
+# frozen_string_literal: true
+
+module Kiroshi
+  # @api public
+  # Base class for implementing filter sets on ActiveRecord scopes
+  #
+  # This class provides a foundation for creating reusable filter collections
+  # that can be applied to ActiveRecord queries. It uses a class-level DSL
+  # to define filters and an instance-level interface to apply them.
+  #
+  # The class is designed to be inherited by specific filter implementations
+  # that define their own set of filters using the {.filter_by} method.
+  #
+  # @api public
+  # @author darthjee
+  #
+  # @example Basic usage with inheritance
+  #   class DocumentFilters < Kiroshi::Filters
+  #     filter_by :name, match: :like
+  #     filter_by :status
+  #     filter_by :created_at, match: :exact
+  #   end
+  #
+  #   filters = DocumentFilters.new(name: 'report', status: 'published')
+  #   filtered_documents = filters.apply(Document.all)
+  #
+  # @example Multiple filter types
+  #   class UserFilters < Kiroshi::Filters
+  #     filter_by :email, match: :like
+  #     filter_by :role
+  #     filter_by :active, match: :exact
+  #   end
+  #
+  #   filters = UserFilters.new(email: 'admin', role: 'moderator')
+  #   filtered_users = filters.apply(User.all)
+  #
+  # @since 0.1.0
+  class Filters
+    class << self
+      # Defines a filter for the current filter class
+      #
+      # This method is used at the class level to configure filters that will
+      # be applied when {#apply} is called. Each call creates a new {Filter}
+      # instance with the specified configuration.
+      #
+      # @param attribute [Symbol] the attribute name to filter by
+      # @param options [Hash] additional options passed to {Filter#initialize}
+      # @option options [Symbol] :match (:exact) the matching type
+      #   - +:exact+ for exact matching (default)
+      #   - +:like+ for partial matching using SQL LIKE
+      #
+      # @return [Filter] the new filter instance
+      #
+      # @example Defining exact match filters
+      #   class ProductFilters < Kiroshi::Filters
+      #     filter_by :category
+      #     filter_by :brand
+      #   end
+      #
+      # @example Defining partial match filters
+      #   class SearchFilters < Kiroshi::Filters
+      #     filter_by :title, match: :like
+      #     filter_by :description, match: :like
+      #   end
+      #
+      # @example Mixed filter types
+      #   class OrderFilters < Kiroshi::Filters
+      #     filter_by :customer_name, match: :like
+      #     filter_by :status, match: :exact
+      #     filter_by :payment_method
+      #   end
+      #
+      # @since 0.1.0
+      def filter_by(attribute, **)
+        Filter.new(attribute, **).tap do |filter|
+          filter_configs << filter
+        end
+      end
+
+      # Returns the list of configured filters for this class
+      #
+      # @return [Array<Filter>] array of {Filter} instances configured
+      #   for this filter class
+      #
+      # @example Accessing configured filters
+      #   class MyFilters < Kiroshi::Filters
+      #     filter_by :name
+      #     filter_by :status, match: :like
+      #   end
+      #
+      #   MyFilters.filter_configs.length # => 2
+      #   MyFilters.filter_configs.first.attribute # => :name
+      #
+      # @since 0.1.0
+      def filter_configs
+        @filter_configs ||= []
+      end
+    end
+
+    # Creates a new Filters instance
+    #
+    # @param filters [Hash] a hash containing the filter values to be applied.
+    #   Keys should correspond to attributes defined with {.filter_by}.
+    #   Values will be used for filtering. Nil or blank values are ignored.
+    #
+    # @example Creating filters with values
+    #   filters = DocumentFilters.new(
+    #     name: 'annual report',
+    #     status: 'published',
+    #     category: 'finance'
+    #   )
+    #
+    # @example Creating filters with partial values
+    #   filters = UserFilters.new(email: 'admin')  # Only email filter will be applied
+    #
+    # @example Creating empty filters
+    #   filters = ProductFilters.new({})  # No filters will be applied
+    #
+    # @since 0.1.0
+    def initialize(filters = {})
+      @filters = filters || {}
+    end
+
+    # Applies all configured filters to the given scope
+    #
+    # This method iterates through all filters defined via {.filter_by}
+    # and applies each one sequentially to the scope. Filters with no
+    # corresponding value in the filters hash or with blank values are
+    # automatically skipped.
+    #
+    # @param scope [ActiveRecord::Relation] the ActiveRecord scope to filter
+    #
+    # @return [ActiveRecord::Relation] the filtered scope with all
+    #   applicable filters applied
+    #
+    # @example Applying filters to a scope
+    #   class ArticleFilters < Kiroshi::Filters
+    #     filter_by :title, match: :like
+    #     filter_by :published, match: :exact
+    #   end
+    #
+    #   filters = ArticleFilters.new(title: 'Ruby', published: true)
+    #   filtered_articles = filters.apply(Article.all)
+    #   # Generates: WHERE title LIKE '%Ruby%' AND published = true
+    #
+    # @example With empty filters
+    #   filters = ArticleFilters.new({})
+    #   filtered_articles = filters.apply(Article.all)
+    #   # Returns the original scope unchanged
+    #
+    # @example With partial filters
+    #   filters = ArticleFilters.new(title: 'Ruby')  # published filter ignored
+    #   filtered_articles = filters.apply(Article.all)
+    #   # Generates: WHERE title LIKE '%Ruby%'
+    #
+    # @since 0.1.0
+    def apply(scope)
+      self.class.filter_configs.each do |filter|
+        scope = filter.apply(scope, filters)
+      end
+
+      scope
+    end
+
+    private
+
+    attr_reader :filters
+
+    # @!method filters
+    #   @api private
+    #   @private
+    #
+    #   Returns the hash of filter values to be applied
+    #
+    #   @return [Hash] the hash of filter values to be applied
+  end
+end

data/lib/kiroshi/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
-class Kiroshi
-  VERSION = '0.0.1'
+module Kiroshi
+  VERSION = '0.1.0'
 end

data/lib/kiroshi.rb

@@ -2,6 +2,8 @@
 
 # @api public
 # @author darthjee
-class Kiroshi
+module Kiroshi
   autoload :VERSION, 'kiroshi/version'
+  autoload :Filters, 'kiroshi/filters'
+  autoload :Filter,  'kiroshi/filter'
 end

data/spec/lib/kiroshi/filter_spec.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Kiroshi::Filter, type: :model do
+  describe '#apply' do
+    let(:scope)                  { Document.all }
+    let(:filter_value)           { 'test_value' }
+    let(:filters)                { { name: filter_value } }
+    let!(:matching_document)     { create(:document, name: filter_value) }
+    let!(:non_matching_document) { create(:document, name: 'other_value') }
+
+    context 'when match is :exact' do
+      subject(:filter) { described_class.new(:name, match: :exact) }
+
+      it 'returns exact matches' do
+        expect(filter.apply(scope, filters)).to include(matching_document)
+      end
+
+      it 'does not return non-matching records' do
+        expect(filter.apply(scope, filters)).not_to include(non_matching_document)
+      end
+    end
+
+    context 'when match is :like' do
+      subject(:filter) { described_class.new(:name, match: :like) }
+
+      let(:filter_value) { 'test' }
+      let!(:matching_document)     { create(:document, name: 'test_document') }
+      let!(:non_matching_document) { create(:document, name: 'other_value') }
+
+      it 'returns partial matches' do
+        expect(filter.apply(scope, filters)).to include(matching_document)
+      end
+
+      it 'does not return non-matching records' do
+        expect(filter.apply(scope, filters)).not_to include(non_matching_document)
+      end
+    end
+
+    context 'when match is not specified (default)' do
+      subject(:filter) { described_class.new(:name) }
+
+      it 'defaults to exact match returning only exact matches' do
+        expect(filter.apply(scope, filters)).to include(matching_document)
+      end
+
+      it 'defaults to exact match returning not returning when filtering by a non-matching value' do
+        expect(filter.apply(scope, filters)).not_to include(non_matching_document)
+      end
+    end
+
+    context 'when filter value is not present' do
+      subject(:filter) { described_class.new(:name) }
+
+      let(:filters) { { name: nil } }
+
+      it 'returns the original scope unchanged' do
+        expect(filter.apply(scope, filters)).to eq(scope)
+      end
+    end
+  end
+end

data/spec/lib/kiroshi/filters_spec.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Kiroshi::Filters, type: :model do
+  describe '#apply' do
+    subject(:filter_instance) { filters_class.new(filters) }
+
+    let(:scope)           { Document.all }
+    let(:filters)         { {} }
+    let!(:document)       { create(:document, name: 'test_name', status: 'finished') }
+    let!(:other_document) { create(:document, name: 'other_name', status: 'processing') }
+
+    let(:filters_class) { Class.new(described_class) }
+
+    context 'when no filters are configured' do
+      context 'when no filters are provided' do
+        it 'returns the original scope unchanged' do
+          expect(filter_instance.apply(scope)).to eq(scope)
+        end
+      end
+
+      context 'when filters are provided' do
+        let(:filters) { { name: 'test_name' } }
+
+        it 'returns the original scope unchanged' do
+          expect(filter_instance.apply(scope)).to eq(scope)
+        end
+      end
+    end
+
+    context 'when one exact filter is configured' do
+      let(:filters) { { name: 'test_name' } }
+
+      before do
+        filters_class.filter_by :name
+      end
+
+      it 'returns documents matching the exact filter' do
+        expect(filter_instance.apply(scope)).to include(document)
+      end
+
+      it 'does not return documents not matching the exact filter' do
+        expect(filter_instance.apply(scope)).not_to include(other_document)
+      end
+    end
+
+    context 'when one like filter is configured' do
+      let(:filters) { { name: 'test' } }
+
+      before do
+        filters_class.filter_by :name, match: :like
+      end
+
+      it 'returns documents matching the like filter' do
+        expect(filter_instance.apply(scope)).to include(document)
+      end
+
+      it 'does not return documents not matching the like filter' do
+        expect(filter_instance.apply(scope)).not_to include(other_document)
+      end
+    end
+
+    context 'when multiple filters are configured' do
+      let(:filters) { { name: 'test', status: 'finished' } }
+
+      before do
+        filters_class.filter_by :name, match: :like
+        filters_class.filter_by :status
+      end
+
+      it 'returns documents matching all filters' do
+        expect(filter_instance.apply(scope)).to include(document)
+      end
+
+      it 'does not return documents not matching all filters' do
+        expect(filter_instance.apply(scope)).not_to include(other_document)
+      end
+    end
+
+    context 'when filters hash is empty' do
+      before do
+        filters_class.filter_by :name
+        filters_class.filter_by :status
+      end
+
+      let(:filters) { {} }
+
+      it 'returns the original scope unchanged' do
+        expect(filter_instance.apply(scope)).to eq(scope)
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -10,6 +10,8 @@ SimpleCov.start 'gem'
 
 require 'kiroshi'
 require 'pry-nav'
+require 'active_support/all'
+require 'factory_bot'
 
 require 'active_record'
 ActiveRecord::Base.establish_connection(

data/spec/support/db/schema.rb

@@ -2,4 +2,9 @@
 
 ActiveRecord::Schema.define do
   self.verbose = false
+
+  create_table :documents, force: true do |t|
+    t.string   :name
+    t.string   :status
+  end
 end

data/spec/support/factories/document.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+FactoryBot.define do
+  factory :document, class: '::Document' do
+    sequence(:name) { |n| "Name-#{n}" }
+  end
+end

data/spec/support/factory_bot.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+RSpec.configure do |config|
+  config.include FactoryBot::Syntax::Methods
+end
+
+FactoryBot.find_definitions

data/spec/support/models/document.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class Document < ActiveRecord::Base
+  validates :name, presence: true
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kiroshi
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
 platform: ruby
 authors:
 - Darthjee
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2025-08-15 00:00:00.000000000 Z
+date: 2025-08-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -62,14 +62,22 @@ files:
 - config/yardstick.yml
 - docker-compose.yml
 - kiroshi.gemspec
+- kiroshi.jpg
 - lib/kiroshi.rb
+- lib/kiroshi/filter.rb
+- lib/kiroshi/filters.rb
 - lib/kiroshi/version.rb
 - spec/integration/readme/.keep
 - spec/integration/yard/.keep
+- spec/lib/kiroshi/filter_spec.rb
+- spec/lib/kiroshi/filters_spec.rb
 - spec/lib/kiroshi_spec.rb
 - spec/spec_helper.rb
 - spec/support/db/schema.rb
+- spec/support/factories/document.rb
+- spec/support/factory_bot.rb
 - spec/support/models/.keep
+- spec/support/models/document.rb
 - spec/support/shared_examples/.keep
 homepage: https://github.com/darthjee/kiroshi
 licenses: []