jev-feels 0.1.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cb1c944edfc8044a07d64239c6452cf8717eee7a2878777b010ce06c7e328794
-  data.tar.gz: 4c4092c5de15890bb9897934dffe82c515a236e441444caf016e282d20046060
+  metadata.gz: e06314aa51799f9434268858022138a8a871b4f58332907b4be0f5d187885073
+  data.tar.gz: 8e5e28527de0e411f38ca91b660cb6a43c77a955af2a0780227c9401d4fdfe35
 SHA512:
-  metadata.gz: c01170a2578338e6d8359399873593357c7896a2fa536eca538edd82830925d597e0bf6a6b5ffddb2fce804e9c974be6fe9a7eb7b62109d4078987f53743de75
-  data.tar.gz: 41919c36db8eb4497f57acac8ee0c02bcca2f8cb5e7a5bf7b347dadda62253e80a7b5a20274f5db199ea5642e5eb98c82909ac8b9546920a336bc9e5c54d2e8e
+  metadata.gz: 11ff5c82f81642c4e60c1c39f4567de4b3d4e4a7c0ab6bd31a4a19be9cca47b5e2642f1b1388b2cc507ab45b563d02e7ea09767f489954ef1b3bb3d57659a798
+  data.tar.gz: 184c045587028d305a7fa8310c298687998981b655ded9e71e8c7990cb30bfeeaecac59bed11940ef3903bde5dfd49eb99a78c37e0c7e3a83f5a8274e8692589

data/README.md

@@ -25,6 +25,37 @@ if Jev.feels?(email, :urgent)
 end
 ```
 
+## Ruby on Rails
+
+Configure once, declare predicates on the model, ask the record:
+
+```ruby
+# Gemfile
+gem "jev-feels"
+```
+
+```ruby
+# config/initializers/jev.rb
+Jev.configure do |config|
+  config.api_key = ENV.fetch("JEV_API_KEY")
+end
+```
+
+```ruby
+class SupportEmail < ApplicationRecord
+  include Jev::Model
+
+  feels :body, :urgent, "Outage, customers cannot sign in"
+end
+
+email.feels?(:urgent)
+email.feels(:urgent)
+```
+
+The class is the scope, the first argument is the field. No model name, no `email.body.feels?`.
+
+String sugar is still opt-in (`using Jev::Feels` or `require "jev-feels/string"`) if you want `body.feels?(:urgent)` on a raw string.
+
 ## String sugar
 
 `require "feels"` does not change `String`. Opt in with a refinement:
@@ -39,6 +70,7 @@ Or, if you really want a global patch:
 
 ```ruby
 require "feels/string"
+# or: require "jev-feels/string"
 
 email.feels?(:urgent)
 ```
@@ -77,11 +109,16 @@ Jev.define :urgent, "Requires immediate attention or action"
 Jev.define :spam, "Unsolicited or unwanted promotional content"
 Jev.define :angry, "Expresses anger or hostility"
 
+Jev.define Email, :urgent, "Outage, customers cannot sign in"
+Jev.define Comment, :urgent, "Legal takedown or self-harm"
+
 Jev.definition(:urgent)
+Jev.definition(Email, :urgent)
 Jev.definitions
+Jev.definitions(Comment)
 ```
 
-`define` replaces an existing name. `definitions` returns a frozen copy of the registry.
+`define` replaces an existing name in that scope. Scopes are stored by class name, so `Email`, `"Email"` and `:Email` are the same key. `include Jev::Model` plus `feels :body, :urgent, "..."` does the same define and remembers the field. `Jev.feels?(text, Email, :urgent)` uses Email's definition, then a superclass, then the global `:urgent`. `definitions` returns a frozen copy.
 
 ## Configuration
 

data/context7.json

@@ -1,6 +1,6 @@
 {
   "$schema": "https://context7.com/schema/context7.json",
   "projectTitle": "jev-feels",
-  "description": "Ruby-like semantic text predicates via Jev. Jev.feels?(:urgent) is an ordinary condition, not an SDK session.",
+  "description": "Ruby-like semantic text predicates via Jev. Jev.feels?(:urgent) and model#feels?(:urgent) are ordinary conditions, not an SDK session.",
   "excludeFolders": ["spec"]
 }

data/lib/jev/model.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Jev
+  module Model
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      def inherited(subclass)
+        super
+        subclass.extend ClassMethods
+      end
+
+      def feels(attribute, name, description)
+        raise ArgumentError, "attribute must be a Symbol" unless attribute.is_a?(Symbol)
+
+        Jev.define(self, name, description)
+        (@jev_feels_attributes ||= {})[name.to_sym] = attribute
+      end
+
+      def jev_feels_attribute(name)
+        current = self
+        while current && current != Object
+          found = current.instance_variable_get(:@jev_feels_attributes)&.[](name)
+          return found if found
+
+          current = current.superclass
+        end
+      end
+    end
+
+    def feels(predicate)
+      Jev.feels(jev_text_for(predicate), self.class, predicate)
+    end
+
+    def feels?(predicate, threshold: Jev.configuration.threshold)
+      Jev.feels?(jev_text_for(predicate), self.class, predicate, threshold: threshold)
+    end
+
+    private
+
+    def jev_text_for(predicate)
+      attribute = self.class.jev_feels_attribute(predicate.to_sym) || raise(
+        UndefinedDefinition, "Undefined Jev definition: #{predicate.inspect} for #{self.class}"
+      )
+
+      public_send(attribute).to_s
+    end
+  end
+end

data/lib/jev/registry.rb

@@ -7,23 +7,77 @@ module Jev
       @definitions = {}
     end
 
-    def define(name, description)
+    def define(scope, name, description)
       key = name.to_sym
       value = description.to_s.dup.freeze
-      @mutex.synchronize { @definitions[key] = value }
+      scope_key = storage_key(scope)
+      @mutex.synchronize do
+        (@definitions[scope_key] ||= {})[key] = value
+      end
       value
     end
 
-    def fetch(name)
-      @mutex.synchronize { @definitions[name.to_sym] }
+    def fetch(name, scope: nil, fallback: true, inherit: true)
+      key = name.to_sym
+      @mutex.synchronize do
+        return @definitions.dig(nil, key) if scope.nil?
+
+        lookup_keys(scope, inherit: inherit).each do |scope_key|
+          found = @definitions.dig(scope_key, key)
+          return found if found
+        end
+        return @definitions.dig(nil, key) if fallback
+
+        nil
+      end
     end
 
-    def all
-      @mutex.synchronize { @definitions.dup.freeze }
+    def all(scope = nil)
+      @mutex.synchronize { (@definitions[storage_key(scope)] || {}).dup.freeze }
     end
 
     def reset!
       @mutex.synchronize { @definitions.clear }
     end
+
+    private
+
+    def storage_key(scope)
+      return if scope.nil?
+
+      key =
+        case scope
+        when String, Symbol then scope.to_s
+        when Module then scope.name || scope
+        else raise ArgumentError, "scope must be a Module, String, or Symbol"
+        end
+      raise ArgumentError, "scope must be a non-empty String" if key.is_a?(String) && key.empty?
+
+      key
+    end
+
+    def lookup_keys(scope, inherit:)
+      keys = [storage_key(scope)]
+      return keys unless inherit
+
+      klass = scope.is_a?(Class) ? scope : constantize(scope)
+      return keys unless klass.is_a?(Class)
+
+      current = klass.superclass
+      while current && current != Object
+        keys << (current.name || current)
+        current = current.superclass
+      end
+      keys.uniq
+    end
+
+    def constantize(name)
+      name = name.to_s if name.is_a?(Symbol)
+      return unless name.is_a?(String)
+
+      name.split("::").reduce(Object) { |mod, part| mod.const_get(part, false) }
+    rescue NameError
+      nil
+    end
   end
 end

data/lib/jev/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Jev
-  VERSION = "0.1.0"
+  VERSION = "1.0.0"
 end

data/lib/jev-feels/string.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require "feels/string"

data/lib/jev.rb

@@ -7,6 +7,7 @@ require_relative "jev/registry"
 require_relative "jev/transport"
 require_relative "jev/client"
 require_relative "jev/feels"
+require_relative "jev/model"
 
 module Jev
   class << self
@@ -21,28 +22,41 @@ module Jev
       @configuration = Configuration.new
     end
 
-    def define(name, description)
-      registry.define(name, description)
+    def define(scope_or_name, name_or_description, description = nil)
+      if description.nil?
+        if scope_or_name.is_a?(Module) || name_or_description.is_a?(Symbol)
+          raise ArgumentError, "description is required"
+        end
+
+        registry.define(nil, scope_or_name, name_or_description)
+      else
+        registry.define(scope_or_name, name_or_description, description)
+      end
     end
 
-    def definition(name)
-      registry.fetch(name)
+    def definition(scope_or_name, name = nil)
+      if name.nil?
+        registry.fetch(scope_or_name, scope: nil, fallback: false, inherit: false)
+      else
+        registry.fetch(name, scope: scope_or_name, fallback: false, inherit: false)
+      end
     end
 
-    def definitions
-      registry.all
+    def definitions(scope = nil)
+      registry.all(scope)
     end
 
     def reset_definitions!
       registry.reset!
     end
 
-    def feels(text, predicate)
-      Client.new(configuration).probability(coerce_text(text), resolve(predicate))
+    def feels(text, scope_or_predicate, predicate = nil)
+      scope, predicate = unpack_predicate(scope_or_predicate, predicate)
+      Client.new(configuration).probability(coerce_text(text), resolve(predicate, scope: scope))
     end
 
-    def feels?(text, predicate, threshold: configuration.threshold)
-      feels(text, predicate) >= normalize_threshold(threshold)
+    def feels?(text, scope_or_predicate, predicate = nil, threshold: configuration.threshold)
+      feels(text, scope_or_predicate, predicate) >= normalize_threshold(threshold)
     end
 
     def normalize_threshold(value)
@@ -67,17 +81,36 @@ module Jev
       text
     end
 
-    def resolve(predicate)
+    def unpack_predicate(scope_or_predicate, predicate)
+      return [nil, scope_or_predicate] if predicate.nil?
+      raise ArgumentError, "scope must be a Module, String, or Symbol" unless scoped?(scope_or_predicate)
+
+      [scope_or_predicate, predicate]
+    end
+
+    def scoped?(value)
+      value.is_a?(Module) || value.is_a?(String) || value.is_a?(Symbol)
+    end
+
+    def resolve(predicate, scope: nil)
       case predicate
       when Symbol
-        definition(predicate) ||
-          raise(UndefinedDefinition, "Undefined Jev definition: #{predicate.inspect}")
+        registry.fetch(predicate, scope: scope) ||
+          raise(UndefinedDefinition, undefined_message(predicate, scope))
       when String
         predicate
       else
         raise ArgumentError, "predicate must be a Symbol or String"
       end
     end
+
+    def undefined_message(predicate, scope)
+      if scope
+        "Undefined Jev definition: #{predicate.inspect} for #{scope}"
+      else
+        "Undefined Jev definition: #{predicate.inspect}"
+      end
+    end
   end
 
   reset_configuration!

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: jev-feels
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 1.0.0
 platform: ruby
 authors:
 - Maxim Veysgeym
@@ -25,11 +25,13 @@ files:
 - lib/feels.rb
 - lib/feels/string.rb
 - lib/jev-feels.rb
+- lib/jev-feels/string.rb
 - lib/jev.rb
 - lib/jev/client.rb
 - lib/jev/configuration.rb
 - lib/jev/errors.rb
 - lib/jev/feels.rb
+- lib/jev/model.rb
 - lib/jev/registry.rb
 - lib/jev/transport.rb
 - lib/jev/version.rb
@@ -39,7 +41,7 @@ licenses:
 metadata:
   homepage_uri: https://github.com/Qew7/jev-feels
   source_code_uri: https://github.com/Qew7/jev-feels
-  changelog_uri: https://github.com/Qew7/jev-feels/blob/main/README.md
+  changelog_uri: https://github.com/Qew7/jev-feels/blob/master/README.md
   allowed_push_host: https://rubygems.org
 post_install_message:
 rdoc_options: []