model_fact 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 41b770abcc6205f56ea4913a107e0cae3f1be7a238341a1a017c54fc95619576
+  data.tar.gz: ba13febedc9c395b60b9f0c9045a0df0403cc64a96f5f0bda675575c2ffa8c61
+SHA512:
+  metadata.gz: 5fccf83a947103bce939c0af509218ffc6e8e5fc7c370d0905e933084dce1eeccb792dc21f9c123ff30195a85a4b12f067eb02b28d8aaa034f0475074f5eb041
+  data.tar.gz: c7d663479ee1982e3cdc0e1bb41522c72c751f5298f52e79fd35c431812e4a149266c53ffe4c05c09488d8ff356368939fe729b37b9577c5174b5ce16db1d4b5

data/.rspec

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

data/README.md

@@ -0,0 +1,31 @@
+# ModelFact
+
+TODO: Delete this and the text below, and describe your gem
+
+Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/model_fact`. To experiment with that code, run `bin/console` for an interactive prompt.
+
+## Installation
+
+TODO: Replace `UPDATE_WITH_YOUR_GEM_NAME_PRIOR_TO_RELEASE_TO_RUBYGEMS_ORG` with your gem name right after releasing it to RubyGems.org. Please do not do it earlier due to security reasons. Alternatively, replace this section with instructions to install your gem from git if you don't plan to release to RubyGems.org.
+
+Install the gem and add to the application's Gemfile by executing:
+
+    $ bundle add UPDATE_WITH_YOUR_GEM_NAME_PRIOR_TO_RELEASE_TO_RUBYGEMS_ORG
+
+If bundler is not being used to manage dependencies, install the gem by executing:
+
+    $ gem install UPDATE_WITH_YOUR_GEM_NAME_PRIOR_TO_RELEASE_TO_RUBYGEMS_ORG
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/model_fact.

data/Rakefile

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec
+require 'release/gem'

data/lib/model_fact/helpers/ar_helpers.rb

@@ -0,0 +1,392 @@
+
+# 
+# Helper for ActiveRecord
+#
+
+module ModelFact
+  module Helpers
+    module ActiveRecordHelper
+      include TR::CondUtils
+
+      class ReqMethodNotGiven < StandardError; end
+
+      module ClassMethods
+        include TR::CondUtils
+
+        def on_event(evt, opts = { }, &block)
+          
+          _listeners[evt] = [] if _listeners[evt].nil?
+
+          case evt
+          when :before_save
+            _listeners[evt] << block
+            self.class.class_eval <<-END
+            before_save :_mf_trigger_listener(:before_save)
+            END
+          end
+        end
+
+        def listeners
+          _listeners.freeze
+        end
+
+        ### Standardized search API
+        # 
+        # Issue : Record need to be part of the
+        # business object as Banis is controller
+        # driven. Whatever return from AR need
+        # to be converted to business model which
+        # difficult to be done generically
+        
+        def filter(opts = {}, &block)
+          
+          res = self.all
+
+          @goToPage = 0
+
+          if block
+
+            filter = FilterBuilder.new
+            flt = block.call(:cond, filter)
+
+            orArray = []
+            if not_empty?(flt.main_cond)
+              flt.main_cond.each do |val|
+                val.each do |k,v|
+                  case k
+                  when :and
+                    res = res.where(v)
+                  when :or
+                    val[:or].each do |r,vv|
+                      orArray << ["#{r} = #{vv}"]
+                    end
+                  end
+                end
+              end
+
+              res = res.where("(#{orArray.join(" or ")})") if not_empty?(orArray)
+
+            end
+
+            if not_empty?(flt.modifier)
+              flt.modifier.each do |mod|
+                mod.each do |k,v|
+                  case k
+                  when :sort
+                    res = res.order(v)
+                  when :first
+                    cnt = v || 1
+                    res = res.first(cnt)
+                  when :last
+                    cnt = v || 1
+                    res = res.last(cnt)
+                  when :page
+                    @goToPage = v
+                  end
+                end
+              end
+            end
+
+            ignorePaging = block.call(:ignore_paging?)
+            ignorePaging = false if is_empty?(ignorePaging)
+
+            if is_paginated? and not ignorePaging
+
+              ttl = res.count
+              block.call(:result, :total_record, ttl)
+
+              ttlPage = (ttl/per_page_count).to_i
+              ttlPage += 1 if (ttlPage*per_page_count) != ttl
+              block.call(:result, :total_page, ttlPage)
+
+              res = res.limit(per_page_count)
+
+              if @goToPage <= 0
+                block.call(:result, :first_page?, true) 
+              else
+                block.call(:result, :first_page?, false)
+              end
+
+              offset = @goToPage * per_page_count
+              res = res.offset(offset)
+
+              if (offset+per_page_count) >= ttl
+                block.call(:result, :last_page?, true) 
+              else
+                block.call(:result, :last_page?, false)
+              end
+
+            end
+
+            if flt.is_return_count?
+              res.count
+            else
+              translate(res)
+            end
+
+          else
+            translate(res)
+          end
+
+        end
+
+        def remove(rec)
+          self.delete(rec) 
+        end
+
+        def remove_all
+          self.delete_all
+        end
+
+        def first(row = 1)
+          res = self.filter do |ops, val|
+            case ops
+            when :cond
+              val.first(row)
+            end
+          end
+          res.first if row == 1
+        end
+
+        def last(row = 1)
+          res = self.filter do |ops, val|
+            case ops
+            when :cond
+              val.last(row)
+            end
+          end
+          res.first if row == 1
+        end
+
+        def find_record(opts = {}, &block)
+          self.filter do |ops, *val|
+            case ops
+            when :cond
+              val.first.filter(opts)
+            else
+              block.call(ops, *val) if block
+            end
+          end
+        end
+        alias_method :find_records, :find_record
+
+
+        #def find_record(opts = {}, &block)
+        #  opts = {} if opts.nil?
+        #  if not_empty?(opts) and not_empty?(opts[:fcond])
+        #    if not_empty?(opts[:fcond][:per_page_count])
+        #      paginate(per_page: opts[:fcond][:per_page_count].to_i)
+        #      opts[:fcond].delete(:per_page_count)
+        #    end
+        #    res = self.where(opts[:fcond])
+        #  else
+        #    res = self
+        #  end
+
+        #  apply_user_filter(res, opts) do |ops, val|
+        #    case ops
+        #    when :translate
+        #      if block
+        #        res = translate(block.call(:callback, val))
+        #        res
+        #      else
+        #        res = translate(val)
+        #        res
+        #      end
+        #      
+        #    else
+        #      if block
+        #        block.call(ops,val)
+        #      else
+        #        val 
+        #      end
+        #      
+        #    end
+        #  end
+        #end
+        #alias_method :find_records, :find_record
+
+        #def all_record(opts = {}, &block)
+
+        #  opts = {} if opts.nil?
+        #  noPaging = opts[:no_paging]
+        #  noPaging = false if is_empty?(noPaging)
+
+        #  res = self.all
+
+        #  if not opts[:no_paging]
+        #    apply_user_filter(res, opts) do |ops, val|
+        #      case ops
+        #      when :translate
+        #        translate(val)
+
+        #      else
+        #        if block
+        #          block.call(ops, val)  
+        #        else
+        #          val
+        #        end
+        #      end
+        #    end
+        #  else
+        #    translate(res)
+        #  end
+
+        #end
+        #alias_method :all_records, :all_record
+
+        #def first_record(count = 1)
+        #  translate(self.first(count).first)
+        #end
+
+        #def last_record(count = 1)
+        #  translate(self.last(count).first)
+        #end
+
+        def record_translator(&block)
+          @recTranslator = block
+        end
+
+        def translate(rec)
+          if @recTranslator
+            @recTranslator.call(rec)
+          else
+            rec
+          end
+        end
+
+        ### Paginate helpers
+        def paginate(opts = {})
+          @_per_page = opts[:per_page] || 10 
+          @_paginate = true
+        end
+
+        def per_page_count
+          @_per_page 
+        end
+
+        def per_page_count=(val)
+          @_per_page = val
+        end
+
+        def is_paginated?
+          not_empty?(@_paginate) and @_paginate
+        end
+        ## End paginate helpers
+
+        ### End standardize search API
+
+        private
+        def _listeners
+          if @_listeners.nil?
+            @_listeners = { }
+          end
+          @_listeners
+        end
+
+
+        #def apply_user_filter(mdl, opts = {}, &block)
+
+        #  raise Error, "Block is required" if not block
+
+        #  order = opts[:order] || { created_at: :asc }
+        #  res = mdl.send(:order, order) 
+
+        #  if is_paginated?
+
+        #    cnt = res.count
+
+        #    block.call(:total_record, cnt)
+
+        #    limit = per_page_count
+        #    res = res.limit(limit) if not_empty?(limit)
+
+        #    ttlPage = (cnt / limit).to_i + 1
+
+        #    block.call(:total_page, ttlPage)
+
+        #    page = (opts[:paginate].nil? ? 0 : opts[:paginate][:page]) || 0
+        #   
+        #    if page <= 0
+        #      block.call(:first_page?, true)
+        #    else
+        #      block.call(:first_page?, false)
+        #    end
+
+        #    offset = page * limit
+        #    res = res.offset(offset)
+
+        #    if (offset+limit) >= cnt
+        #      block.call(:last_page?, true)
+        #    else
+        #      block.call(:last_page?, false)
+        #    end
+
+        #  end
+
+        #  count = opts[:count]
+        #  if not_empty?(count)
+        #    res.count
+        #  else
+        #    block.call(:translate, res)
+        #  end
+
+        #end
+
+      end
+      def self.included(klass)
+        klass.extend(ClassMethods)
+      end
+
+      def _mf_trigger_listener(evt)
+        list = self.class.listeners[evt]
+        if not_empty?(list)
+          list.each do |l|
+            l.call(self)
+          end
+        end
+      end
+
+      ### Standardized search API
+      # 
+      # Issue : Record need to be part of the
+      # business object as Banis is controller
+      # driven. Whatever return from AR need
+      # to be converted to business model which
+      # difficult to be done generically
+      #
+      #def find_record(opts = {}, &block)
+      #  if not_empty?(opts)
+      #    res = self.class.where(opts)
+      #  else
+      #    res = self.class
+      #  end
+
+      #  if block
+      #    self.class.translate(block.call(res))
+      #  else
+      #    self.class.translate(res)
+      #  end
+      #end
+      #alias_method :find_records, :find_record
+
+      #def all_record
+      #  translate(self.all)
+      #end
+      #alias_method :all_records, :all_record
+
+      #def first_record(count = 1)
+      #  translate(self.first(count).first)
+      #end
+
+      #def last_record(count = 1)
+      #  translate(self.last(count).first)
+      #end
+
+      ### End standardize search API
+
+    end
+  end
+end
+
+

data/lib/model_fact/helpers/filter_builder.rb

@@ -0,0 +1,80 @@
+
+
+module ModelFact
+  module Helpers
+
+    # based on sql?
+    class FilterBuilder
+     
+      def initialize
+        @mainCond = []
+        @modifier = []
+        @_return_count = false
+      end
+
+      def and(condHash = {}, opts = {})
+        main_cond << { and: condHash }
+        self 
+      end
+      alias_method :filter, :and
+
+      def or(condHash = {}, opts = {})
+        main_cond << { or: condHash }
+        self 
+      end
+
+      def top(cnt = 1, opts = {})
+        modifier << { first: cnt }
+        self 
+      end
+      alias_method :first, :top
+
+      def bottom(cnt = 1, opts = {})
+        modifier << { last: cnt }
+        self 
+      end
+      alias_method :last, :bottom
+
+      #def sub_list_items(fromIndx, len, opts = {})
+      #  modifier << { sub_index: { from: fromIndx, length: len } }
+      #  self 
+      #end
+
+      def count
+        @_return_count = true
+        self
+      end
+      
+      def is_return_count?
+        @_return_count == true
+      end
+
+      def go_to_page(pageNo)
+        modifier << { page: pageNo } 
+        self
+      end
+
+      def sort(field, type = :asc)
+        modifier << { sort: { field => type } }
+        self
+      end
+      alias_method :order, :sort
+
+      def main_cond
+        if @_main_cond.nil?
+          @_main_cond = []
+        end
+        @_main_cond
+      end
+
+      def modifier
+        if @_modifier.nil?
+          @_modifier = []
+        end
+        @_modifier
+      end
+
+    end
+
+  end
+end

data/lib/model_fact/helpers/model_helper.rb

@@ -0,0 +1,84 @@
+
+
+module ModelFact
+  module ModelHelper
+    class ReqFieldNotAvail < StandardError; end
+
+   
+    module ClassMethods
+     
+      # 
+      # A way to document which fields are needed for
+      # the operational of this class
+      #
+      def req_accessor(*fields)
+        @reqFields = [] if @reqFields.nil?
+        @reqFields.concat(fields)
+        #@reqFields = fields 
+      end
+
+      def req_fields
+        (@reqFields || []).freeze
+      end
+
+      def set_model_key(key)
+        @modelKey = key 
+      end
+
+      def _model_key
+        @modelKey 
+      end
+
+      def method_missing(mtd, *args, &block)
+        ModelFact.instance(_model_key).send(mtd, *args, &block)
+      end
+
+      def respond_to_missing?(mtd, priv)
+        ModelFact.instance(_model_key).respond_to_missing?(mtd, priv)
+      end
+
+    end
+    def self.included(klass)
+      klass.extend(ClassMethods)
+    end
+
+    def ensure_attributes_defined
+      self.class.req_fields.each do |f|
+        raise ReqFieldNotAvail, "Requred field '#{f}' not available on #{self}" if not (self.respond_to?(f) and self.respond_to?("#{f}="))
+      end
+    end
+
+    def set_model_instance(mdlInst)
+      @_mdlInst = mdlInst
+    end
+
+    def _model_key
+      self.class._model_key
+    end
+    
+    def model
+      @_mdlInst
+    end
+
+    # comparing two model
+    def ==(val)
+      if val.is_a?(ModelFact)
+        model == val.model
+      else
+        false
+      end
+    end
+
+    private
+    def method_missing(mtd, *args, &block)
+      model.send(mtd, *args, &block)
+    end
+
+    def respond_to_missing?(mtd, priv)
+      res = model.respond_to?(mtd)
+      res
+    end
+
+
+  end
+end

data/lib/model_fact/helpers/poro_helpers.rb

@@ -0,0 +1,50 @@
+
+
+
+module ModelFact
+  module Helpers
+    # Plain Old Ruby Object (PORO) helpers
+    module POROHelpers
+     
+      module ClassMethods
+      
+        def on_event(evt, opts = { }, &block)
+          _listeners[evt] = [] if not _listeners.keys.include?(evt)
+          _listeners[evt] << block
+        end
+
+        def listeners
+          _listeners.freeze
+        end
+
+        private
+        def _listeners
+          if @_listeners.nil?
+            @_listeners = { }
+          end
+
+          @_listeners
+        end
+
+      end 
+
+      def self.included(klass)
+        klass.extend(ClassMethods)
+      end
+
+      ## instance methods
+
+      # triggering of this should be respective model's
+      # method
+      # E.g. before save(), model should manually check this
+      def trigger_listener(evt)
+        if self.class.listeners.keys.include?(evt)
+          self.class.listeners[evt].each do |l|
+            l.call(self)
+          end
+        end
+      end
+
+    end
+  end 
+end

data/lib/model_fact/helpers.rb

@@ -0,0 +1,11 @@
+
+
+require_relative 'helpers/poro_helpers'
+
+if defined?(ActiveRecord)
+require_relative 'helpers/ar_helpers'
+end
+
+require_relative 'helpers/model_helper'
+
+require_relative 'helpers/filter_builder'

data/lib/model_fact/registry.rb

@@ -0,0 +1,100 @@
+
+require 'singleton'
+
+module ModelFact
+  class Registry
+    include Singleton
+    include TR::CondUtils
+
+    # 
+    # To be called by application developer during
+    # startup to match which model to give to application
+    # This is configuration per se like on which 'database adapter' to go
+    #
+    def register(id, cls, opts = { })
+
+      opts = { } if opts.nil?
+
+      overwrite = opts[:overwrite]
+      overwrite = false if is_empty?(overwrite) or not_bool?(overwrite)
+
+      raise  InvalidParamValue, "Given ID is nil or empty" if is_empty?(id)
+      raise  InvalidParamValue, "Given class is nil or empty" if is_empty?(cls)
+
+      raise DuplicatedIDException, "Given ID '#{id}' already registered" if is_registered?(id)
+
+      idCls[id] = { target: cls }
+
+      als = opts[:alias]
+      if not_empty?(als)
+        if is_alias_registered?(als) and not overwrite
+          raise DuplicatedIDException, "Given alias '#{als}' already registered" 
+        else
+          aliases[als] = id 
+        end
+      end
+
+      cls
+    end
+
+    def is_registered?(id)
+      idCls.keys.include?(id)
+    end
+
+    def is_alias_registered?(als)
+      aliases.keys.include?(als)
+    end
+
+    def find(id)
+      if is_registered?(id)
+        idCls[id][:target]
+      elsif is_alias_registered?(id)
+        indx = aliases[id]
+        idCls[indx][:target]
+      else
+        nil
+      end
+    end
+
+    def on_event(id, event ,opts = {}, &block)
+      inst = find(id)
+      if not_empty?(inst) 
+        hasMethod = inst.respond_to?(:on_event)
+        if hasMethod
+          inst.on_event(event,opts,&block)
+          true
+        else
+          logger.warn "Instance '#{id}' does not have method on_event"
+          false
+        end
+
+      else
+        false
+      end
+    end
+
+    #
+    # Private Section
+    #
+    private
+    def idCls
+      if @idCls.nil? and not @idCls.is_a?(Hash)
+        @idCls = { }
+      end
+
+      @idCls
+    end
+
+    def aliases
+      if @aliases.nil?
+        @aliases = { }            
+      end
+      @aliases
+    end
+
+    def logger
+      ModelFact.logger(:mf_registry)
+    end
+
+  end
+end

data/lib/model_fact/version.rb

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

data/lib/model_fact.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+require 'toolrack'
+require 'teLogger'
+
+require_relative "model_fact/version"
+
+require_relative 'model_fact/registry'
+
+require_relative 'model_fact/helpers'
+
+require_relative 'model_fact/helpers/model_helper'
+
+module ModelFact
+  include TR::CondUtils
+
+  class Error < StandardError; end
+  # Your code goes here...
+
+  class InvalidParamValue < StandardError; end
+  class ModelNotFound < StandardError; end
+  class ModelNotAvailable < StandardError; end
+  class DuplicatedIDException < StandardError; end
+
+  def self.register(id, cls, opts = {})
+    Registry.instance.register(id, cls, opts)
+  end
+
+  # try_register will not throw exception if ID already registered
+  def self.try_register(id, cls, opts = { })
+    
+    opts = { } if opts.nil?
+    
+    if Registry.instance.is_registered?(id) or (not_empty?(opts[:alias]) and Registry.instance.is_alias_registered?(opts[:alias]))
+      false
+    else
+      register(id, cls, opts)
+      true
+    end
+  end
+
+  # To be used by buss app to get model object
+  # by given id
+  def self.instance(id, raise_if_not_found = true)
+    res = Registry.instance.find(id)
+    if res.nil? 
+      if raise_if_not_found
+        raise ModelNotFound, "Given ID '#{id}' is not registered"
+      else
+        nil
+      end
+    else
+
+      if defined?(ActiveRecord)
+        require_relative 'model_fact/helpers/ar_helpers'
+        logger.debug "ActiveRecord defined for class!"
+        if res.ancestors.include?(ActiveRecord::Base) 
+          logger.debug "Including ActiveRecordHelper into #{res}"
+          res.send(:include, ModelFact::Helpers::ActiveRecordHelper)
+        end
+      end
+
+      res
+
+    end
+  end
+
+  def self.new_instance(id, *args, &block)
+    cls = instance(id, true)
+    logger.debug "new_instance got #{cls}"
+    inst = cls.send(:new, *args, &block)
+    if defined?(ActiveRecord)
+      require_relative 'model_fact/helpers/ar_helpers'
+      logger.debug "ActiveRecord defined!"
+      if inst.is_a?(ActiveRecord::Base) #and inst.class.include?(ModelFact::Helpers::ActiveRecordHelper)
+        logger.debug "Including ActiveRecordHelper into #{cls}"
+        inst.class.send(:include, ModelFact::Helpers::ActiveRecordHelper)
+      end
+    end
+    inst
+  end
+
+  def self.on_event(id = nil, event = nil, opts = {}, &block)
+    Registry.instance.on_event(id, event, opts, &block)
+  end
+
+  def self.method_missing(mtd, *args, &block)
+    if Registry.instance.respond_to?(mtd)
+      Registry.instance.send(mtd, *args, &block)
+    else
+      super
+    end
+  end
+
+  def self.logger(tag = nil, &block)
+    if @_logger.nil?
+      @_logger = TeLogger::Tlogger.new(File.join(Dir.home,"test123.log"))
+    end
+
+    if block
+      if not_empty?(tag)
+        @_logger.with_tag(tag, &block)
+      else
+        @_logger.with_tag(@_logger.tag, &block)
+      end
+    else
+      if is_empty?(tag)
+        @_logger.tag = :model_fact
+        @_logger
+      else
+        # no block but tag is given? hmm
+        @_logger.tag = tag
+        @_logger
+      end
+    end
+
+  end
+
+end

data/sig/model_fact.rbs

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

metadata

@@ -0,0 +1,96 @@
+--- !ruby/object:Gem::Specification
+name: model_fact
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Chris
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2023-10-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: toolrack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: teLogger
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: release-gem
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: ''
+email:
+- chris@antrapol.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- README.md
+- Rakefile
+- lib/model_fact.rb
+- lib/model_fact/helpers.rb
+- lib/model_fact/helpers/ar_helpers.rb
+- lib/model_fact/helpers/filter_builder.rb
+- lib/model_fact/helpers/model_helper.rb
+- lib/model_fact/helpers/poro_helpers.rb
+- lib/model_fact/registry.rb
+- lib/model_fact/version.rb
+- sig/model_fact.rbs
+homepage: ''
+licenses: []
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.6.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.6
+signing_key:
+specification_version: 4
+summary: ''
+test_files: []