memorium 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 1281323555096907a8699e5dd707122af3ae2b6bcea75d12f5699504cc1c6c1a
+  data.tar.gz: 2e3f29414d57e03aac316d5d2285622c840e52501bc83877d5239e3bbed36219
+SHA512:
+  metadata.gz: 632885b625b5e4d269b3e0c3b02172b51a5bd40a199c812fcb0bca04ecce1ae92b935aa488cfe8108a678c028a25f5703a7771ff97e31290d967588d982402fa
+  data.tar.gz: de3136ffc2b5b05ea232df2bf2bb07c2b23324e4b4fba07c4390023ad7a3fcf486bdcf8ab882779172f00f8ad4cdd2b8fb5e16eb7dea0f1f9030639871a4d8fd

data/README.md

@@ -0,0 +1,165 @@
+# Memorium
+
+Toolkit for creating convenient classes with lazy calculations. Provides method memoization, declarative attribute initialization, and attribute validation.
+
+## Installation
+
+Add to your Gemfile:
+
+```ruby
+gem "memorium"
+```
+
+Or install directly:
+
+```bash
+gem install memorium
+```
+
+## Usage
+
+### Method Memoization (`memo`)
+
+Cache the result of a method so it's computed only once:
+
+```ruby
+class Calculator
+  memo def heavy_computation
+    sleep 2
+    42
+  end
+end
+
+calc = Calculator.new
+calc.heavy_computation # => 42 (takes 2 seconds)
+calc.heavy_computation # => 42 (instant, cached)
+```
+
+#### Inline syntax
+
+```ruby
+memo def result
+  expensive_call
+end
+```
+
+#### Block syntax
+
+```ruby
+memo
+def result
+  expensive_call
+end
+```
+
+#### Access levels
+
+Control visibility of the memoized method:
+
+```ruby
+class Example
+  memo def private_writer
+    compute
+  end, writer: :private
+
+  memo writer: :private
+  def private_writer
+    compute
+  end
+end
+```
+
+#### Writer
+
+You can also generate a writer to reset the memoized value:
+
+```ruby
+class Example
+  memo def value
+    rand(100)
+  end, writer: :public
+end
+
+obj = Example.new
+obj.value # => 42
+obj.value = 999
+obj.value # => 999
+```
+
+### Attribute Initialization (`initialize_attr`)
+
+Declaratively define attributes with auto-generated `initialize`:
+
+```ruby
+class User
+  initialize_attr :name
+  initialize_attr :email, required: :not_nil?
+  initialize_attr :age,  required: :nil?
+end
+
+user = User.new(name: "Alice", email: "alice@example.com")
+user.name  # => "Alice"
+user.email # => "alice@example.com"
+user.age   # => nil
+```
+
+#### With validation
+
+```ruby
+class User
+  initialize_attr :name, required: :not_nil?
+  initialize_attr :email, required: :not_nil?
+  initialize_attr :role,  required: :nil?
+end
+
+User.new(name: "Bob", email: "bob@example.com")
+User.new(name: nil, email: "bob@example.com")
+# => raises Memorium::AttributeRequired: Attribute `name` must be not_nil: nil
+```
+
+### Attribute Validation (`require_attr`)
+
+Validate attribute values at runtime:
+
+```ruby
+class User
+  initialize_attr :name, required: :not_nil?
+
+  memo def name_caps = require_attr(:name).upcase
+end
+
+user = User.new(name: "alice")
+user.name_caps # => "ALICE"
+```
+
+Available predicates:
+- `:nil?` — value must be nil
+- `:not_nil?` — value must not be nil
+- `:not_empty?` — value must not be empty
+- Any method name as a predicate (e.g., `:zero?`, `:positive?`)
+- Custom Proc: `require_attr(:name, by: ->(v) { v.size > 2 })`
+
+### Configuration
+
+```ruby
+# By default, nil values are also memoized
+Memorium.memoize_nil_values = true
+
+# Disable nil memoization (nil will be recomputed each time)
+Memorium.memoize_nil_values = false
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then run `rake spec` to run the tests.
+
+```bash
+bin/setup
+rake spec
+```
+
+You can also run `bin/console` for an interactive prompt.
+
+## Contributing
+
+Bug reports and pull requests are welcome at https://github.com/gem-forge/memorium.

data/Rakefile

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

data/examples/order/order.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+#
+# A customer order containing line items, an optional discount, and computed totals.
+#
+# @example
+#   items = [
+#     OrderItem.new(name: "Coffee",    quantity: 2, unit_price: 150.0),
+#     OrderItem.new(name: "Croissant", quantity: 3, unit_price:  80.0),
+#   ]
+#
+#   order = Order.new(customer_name: "Alice", items: items, discount_percent: 10)
+#   order.subtotal        # => 540.0
+#   order.discount_amount # => 54.0
+#   order.total           # => 486.0
+#
+class Order
+  # Customer's full name.
+  # @return [String]
+  initialize_attr :customer_name, required: :not_nil?
+
+  # Line items included in the order.
+  # @return [Array<OrderItem>]
+  initialize_attr :items, required: :not_empty?
+
+  # Discount percentage to apply (0–100). +nil+ means no discount.
+  # @return [Integer, nil]
+  initialize_attr :discount_percent
+
+  # Sum of all line item totals before discount.
+  # @return [Float]
+  memo def subtotal = items.sum(&:total_price)
+
+  # Discount amount in currency units.
+  # Equals zero when {#discount_percent} is +nil+.
+  # @return [Float]
+  memo def discount_amount = subtotal * (discount_percent.to_f / 100)
+
+  # Final amount due after applying the discount.
+  # @return [Float]
+  memo def total = subtotal - discount_amount
+
+  # One-line order summary.
+  # @return [String]
+  memo def summary
+    "Order for #{customer_name}: #{items.size} item(s), total #{require_attr(:total)}"
+  end
+end

data/examples/order/order_item.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+#
+# A single line item in an order — a product with quantity and unit price.
+#
+# @example
+#   item = OrderItem.new(name: "Coffee", quantity: 2, unit_price: 150.0)
+#   item.total_price # => 300.0
+#
+class OrderItem
+
+  # Product name.
+  # @return [String]
+  initialize_attr :name, required: :not_nil?
+
+  # Number of units.
+  # @return [Integer]
+  initialize_attr :quantity, required: :not_nil?
+
+  # Price per unit in currency.
+  # @return [Float]
+  initialize_attr :unit_price, required: :not_nil?
+
+  # Total cost of this line item (quantity × unit price).
+  # @return [Float]
+  memo def total_price = quantity * unit_price
+
+  # Human-readable representation of the line item.
+  # @return [String]
+  memo def to_s = "#{name} x#{quantity} @ #{unit_price} = #{total_price}"
+end

data/examples/order.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require "memorium"
+require_relative "order/order_item"
+require_relative "order/order"
+
+items = [
+  OrderItem.new(name: "Coffee",    quantity: 2, unit_price: 150.0),
+  OrderItem.new(name: "Croissant", quantity: 3, unit_price:  80.0),
+]
+
+order = Order.new(customer_name: "Alice", items: items, discount_percent: 10)
+
+puts "Line items:"
+items.each { |item| puts "  #{item}" }
+puts
+puts "Subtotal        : #{order.subtotal}"         # => 540.0
+puts "Discount (10%)  : #{order.discount_amount}"  # => 54.0
+puts "Total           : #{order.total}"            # => 486.0
+puts order.summary
+puts
+

data/examples/save_logs/app.log

@@ -0,0 +1,8 @@
+2024-01-15 10:23:45 INFO  App started
+2024-01-15 10:24:01 DEBUG Loading config from /etc/app/config.yml
+2024-01-15 10:24:03 INFO  Connected to database
+2024-01-15 10:31:17 WARN  Memory usage above 80%
+2024-01-15 10:45:02 ERROR Disk full on /dev/sda1
+2024-01-15 10:45:03 ERROR Failed to write temp file: /tmp/upload_xyz
+2024-01-15 11:00:00 INFO  Scheduled cleanup started
+2024-01-15 11:00:04 INFO  Scheduled cleanup finished

data/examples/save_logs/database.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+#
+# Stub that simulates a database connection.
+# Stores inserted records in memory and prints each insert to stdout.
+#
+# @example
+#   db = Database.new
+#   db.insert(level: "ERROR", message: "Oops", date: "2024-01-15", time: "10:45:02")
+#
+class Database
+  # In-memory store of all inserted records.
+  # @return [Array<Hash>]
+  memo def records = []
+
+  # Simulates inserting a log record into the database.
+  # @param [Hash] attrs Column values to insert.
+  def insert(attrs)
+    records << attrs
+    puts "  [DB] INSERT log_entries #{attrs.inspect}"
+
+    nil
+  end
+end

data/examples/save_logs/log_entry.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+#
+# DTO that parses a single raw log line into structured fields.
+#
+# Expected format: +YYYY-MM-DD HH:MM:SS LEVEL message text+
+#
+# @example
+#   entry = LogEntry.new(raw: "2024-01-15 10:23:45 ERROR Disk full on /dev/sda1")
+#   entry.level   # => "ERROR"
+#   entry.message # => "Disk full on /dev/sda1"
+#   entry.error?  # => true
+#
+class LogEntry
+  # Raw log line to parse.
+  # @return [String]
+  initialize_attr :raw, required: :not_empty?
+
+  # Date portion of the timestamp (YYYY-MM-DD).
+  # @return [String]
+  memo def date = parts[0]
+
+  # Time portion of the timestamp (HH:MM:SS).
+  # @return [String]
+  memo def time = parts[1]
+
+  # Severity level (DEBUG / INFO / WARN / ERROR).
+  # @return [String]
+  memo def level = parts[2]
+
+  # Human-readable log message (everything after the level token).
+  # @return [String]
+  memo def message = parts[3..].join(" ")
+
+  # Returns +true+ when the entry has ERROR severity.
+  # @return [Boolean]
+  memo def error? = level == "ERROR"
+
+  # Returns +true+ when the entry has WARN severity.
+  # @return [Boolean]
+  memo def warn? = level == "WARN"
+
+  # One-line string representation of the entry.
+  # @return [String]
+  memo def to_s = "[#{date} #{time}] #{level.ljust(5)} #{message}"
+
+  private
+
+  # Raw line split into tokens.
+  # @return [Array<String>]
+  memo def parts = raw.split(" ")
+end

data/examples/save_logs/save_logs.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+# rubocop:disable Lint/MissingCopEnableDirective
+# rubocop:disable Layout/EndAlignment
+# rubocop:disable Style/TrailingBodyOnClass
+
+#
+# Reads raw log lines from a file, parses them into LogEntry,
+# and persists each entry into the database.
+#
+# @example
+#   SaveLogs.new(log_path: "examples/save_logs/app.log", db: Database.new).call
+#
+class SaveLogs
+  initialize_attr :log_path, required: :not_nil?
+  initialize_attr :db,       required: :not_nil?
+
+  #
+  # Parses the log file and saves every entry to the database.
+  #
+  def call
+    persist_entries
+
+    nil
+  end
+
+  #--------------------------------------- Attributes
+  private
+
+  #
+  # Parsed LogEntry objects built from raw file lines.
+  #
+  # @return [Array<LogEntry>]
+  #
+  memo def entries
+    raw_lines.map { |line| LogEntry.new(raw: line) }
+  end
+
+  #
+  # Raw non-empty lines read from the log file.
+  #
+  # @return [Array<String>]
+  #
+  memo def raw_lines
+    File.readlines(log_path, chomp: true).reject(&:empty?)
+  end
+
+  #--------------------------------------- Executors
+  private
+
+  #
+  # Inserts every parsed entry into the database.
+  #
+  def persist_entries
+    entries.each { |entry| persist_entry(entry) }
+
+    nil
+  end
+
+  #
+  # Inserts a single log entry into the database.
+  #
+  # @param [LogEntry] entry The entry to persist.
+  #
+  def persist_entry(entry)
+    db.insert(
+      date:    entry.date,
+      time:    entry.time,
+      level:   entry.level,
+      message: entry.message,
+    )
+
+    nil
+  end
+end

data/examples/save_logs.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require "memorium"
+require_relative "save_logs/log_entry"
+require_relative "save_logs/database"
+require_relative "save_logs/save_logs"
+
+db = Database.new
+
+SaveLogs.new(
+  log_path: File.join(__dir__, "save_logs/app.log"),
+  db:       db,
+).call
+
+puts
+puts "Saved #{db.records.size} entries total."
+puts "Errors: #{db.records.count { |r| r[:level] == "ERROR" }}"

data/lib/memorium/access_level.rb

@@ -0,0 +1,32 @@
+class Memorium::AccessLevel
+  PUBLIC = :public
+  PRIVATE = :private
+  PROTECTED = :protected
+
+  attr_reader :klass, :method_name, :access_level
+
+  def initialize(klass, method_name)
+    @klass = klass
+    @method_name = method_name
+
+    @access_level = define_access_level
+  end
+
+  def copy_to(target_method_name) = apply_level access_level, target_method_name
+  def apply_level(level, name) = klass.send(level, name)
+
+  def apply_or_copy(level, target_method_name)
+    level.nil? ? copy_to(target_method_name) : apply_level(level, target_method_name)
+  end
+
+  private
+
+
+  def define_access_level
+    if    klass.private_method_defined?(method_name)   then PRIVATE
+    elsif klass.protected_method_defined?(method_name) then PROTECTED
+    elsif klass.public_method_defined?(method_name)    then PUBLIC
+    else  raise "Method #{method_name.inspect} not defined"
+    end
+  end
+end

data/lib/memorium/config.rb

@@ -0,0 +1,9 @@
+module Memorium::Config
+  extend ActiveSupport::Concern
+
+  included do
+    include ActiveSupport::Configurable
+
+    config_accessor(:memoize_nil_values) { true }
+  end
+end

data/lib/memorium/core.rb

@@ -0,0 +1,13 @@
+class Memorium::Core
+
+  attr_reader :klass
+
+  def initialize(klass)
+    @klass = klass
+  end
+
+  def eager_memo   = @eager_memo   ||= Memorium::Memo::Eager.new(klass)
+  def pending_memo = @pending_memo ||= Memorium::Memo::Pending.new(klass)
+
+  def initializer  = @initializer  ||= Memorium::InitializeAttr::Interaction.new(klass)
+end

data/lib/memorium/extension.rb

@@ -0,0 +1,30 @@
+module Memorium::Extension
+  extend ActiveSupport::Concern
+
+  included do |klass|
+    Memorium::RequireAttr.create_method(klass)
+  end
+
+  class_methods do
+    def memorium = @memorium ||= Memorium::Core.new(self)
+
+    def memo(method_name = nil, reader: nil, writer: nil)
+      if method_name.nil?
+        memorium.pending_memo.setup(reader:, writer:)
+      else
+        memorium.eager_memo.apply(method_name, reader:, writer:)
+      end
+    end
+
+    def method_added(method_name)
+      super
+      return if @memorium.nil? || !memorium.pending_memo.ready?
+
+      memorium.pending_memo.apply(method_name)
+    end
+
+    def initialize_attr(attr_name, reader: nil, writer: nil, required: nil)
+      memorium.initializer.define(attr_name, reader:, writer:, required:)
+    end
+  end
+end

data/lib/memorium/initialize_attr/interaction.rb

@@ -0,0 +1,15 @@
+class Memorium::InitializeAttr::Interaction
+  attr_reader :klass, :initialized
+
+  def initialize(klass)
+    @klass = klass
+
+    @initialized = false
+  end
+
+  def define(name, reader:, writer:, required:)
+    Memorium::InitializeAttr.new(klass, name, reader:, writer:, required:, initialized:).define
+    @initialized ||= true
+  end
+
+end

data/lib/memorium/initialize_attr/template.rb

@@ -0,0 +1,50 @@
+class Memorium::InitializeAttr::Template
+  attr_reader :name
+
+  def initialize(name)
+    @name = name
+
+    @result = []
+  end
+
+  def result = @result.join("\n")
+
+  def initializer
+    @result << <<~RUBY
+      def initialize(attributes = nil, **kw_attributes)
+        #{Memorium::InitializeAttr::ACCESSOR} = attributes || kw_attributes
+      end
+    RUBY
+
+  end
+
+  def reader
+    @result << <<~RUBY
+      def #{name.original}
+        return #{name.attribute} if defined?(#{name.attribute})
+        #{name.attribute} = #{Memorium::InitializeAttr::ACCESSOR}[#{name.original.inspect}]
+      end
+    RUBY
+
+  end
+
+  def reader_with_require(check_type)
+    @result << <<~RUBY
+      def #{name.original}
+        return #{name.attribute} if defined?(#{name.attribute})
+        #{name.attribute} = #{Memorium::InitializeAttr::ACCESSOR}[#{name.original.inspect}]
+        require_attr(#{name.original.inspect}, by: #{check_type.inspect})
+      end
+    RUBY
+
+  end
+
+  def writer
+    @result << <<~RUBY
+      def #{name.setter}(value)
+        #{name.attribute} = value
+      end
+    RUBY
+
+  end
+end

data/lib/memorium/initialize_attr.rb

@@ -0,0 +1,49 @@
+class Memorium::InitializeAttr
+  ACCESSOR = '@__initialize_attributes'.freeze
+
+  attr_reader :klass, :attr_name, :reader_level, :writer_level, :required, :initialized
+
+  def initialize(klass, attr_name, reader: nil, writer: nil, required: nil, initialized: false)
+    @klass = klass
+    @attr_name = attr_name
+    @reader_level = reader || Memorium::AccessLevel::PUBLIC
+    @writer_level = writer || Memorium::AccessLevel::PUBLIC
+    @required = required
+
+    @initialized = initialized
+  end
+
+  def define
+    create_methods
+
+    apply_reader_access_level
+    apply_writer_access_level
+  end
+
+  private
+
+  def naming = @naming ||= Memorium::Naming.new(attr_name)
+  def access_level = @access_level ||= Memorium::AccessLevel.new(klass, attr_name)
+
+  def template
+    @template ||= begin
+      template = Template.new(naming)
+      template.initializer unless initialized
+
+      required.nil? ? template.reader : template.reader_with_require(required_type)
+
+      template.writer
+      template
+    end
+  end
+
+  def required_type = @required_type ||= required.to_s
+
+  def create_methods = klass.class_eval(template.result, caller_location.path, caller_location.lineno + 1)
+
+  def apply_reader_access_level = access_level.apply_level(reader_level, naming.original)
+  def apply_writer_access_level = access_level.apply_level(writer_level, naming.setter)
+
+  # OPTIMIZE: Хрупкий caller_location
+  def caller_location = @caller_location ||= caller_locations(5, 1).first
+end

data/lib/memorium/memo/eager.rb

@@ -0,0 +1,13 @@
+class Memorium::Memo::Eager
+
+  attr_accessor :klass
+
+  def initialize(klass)
+    @klass = klass
+  end
+
+  def apply(name, reader:, writer:)
+    Memorium::Memo.new(klass, name, reader:, writer:).apply
+  end
+
+end

data/lib/memorium/memo/pending.rb

@@ -0,0 +1,30 @@
+class Memorium::Memo::Pending
+
+  attr_accessor :reader, :writer, :klass, :is_ready
+
+  def initialize(klass)
+    @klass = klass
+    @is_ready = false
+  end
+
+  alias ready? is_ready
+
+  def setup(reader:, writer:)
+    self.is_ready = true
+    self.reader   = reader
+    self.writer   = writer
+  end
+
+  def discard
+    self.is_ready = false
+    self.reader   = nil
+    self.writer   = nil
+  end
+
+  def apply(name)
+    memo = Memorium::Memo.new(klass, name, reader:, writer:)
+    discard
+    memo.apply
+  end
+
+end

data/lib/memorium/memo/template.rb

@@ -0,0 +1,40 @@
+class Memorium::Memo::Template
+  attr_reader :name, :params
+
+  def initialize(name, params)
+    @name = name
+    @params = params
+
+    @result = []
+  end
+
+  def result = @result.join("\n")
+
+  def reader_plain
+    @result << <<~RUBY
+      def #{name.original}(#{params.signature})
+        #{name.pure_memoized} ||= #{name.memoized}(#{params.parametrize})
+      end
+    RUBY
+
+  end
+
+  def reader_memoize_nil
+    @result << <<~RUBY
+      def #{name.original}(#{params.signature})
+        return #{name.pure_memoized} if defined?(#{name.pure_memoized})
+        #{name.pure_memoized} = #{name.memoized}(#{params.parametrize})
+      end
+    RUBY
+
+  end
+
+  def writer
+    @result << <<~RUBY
+      def #{name.setter}(value)
+        #{name.pure_memoized} = value
+      end
+    RUBY
+
+  end
+end

data/lib/memorium/memo.rb

@@ -0,0 +1,42 @@
+class Memorium::Memo
+  attr_reader :klass, :method_name, :reader_level, :writer_level
+
+  def initialize(klass, method_name, reader: nil, writer: nil)
+    @klass = klass
+    @method_name = method_name
+    @reader_level = reader
+    @writer_level = writer
+  end
+
+  def apply
+    create_alias
+    create_methods
+
+    apply_reader_access_level
+    apply_writer_access_level
+    apply_alias_access_level
+  end
+
+  private
+
+  def naming = @naming ||= Memorium::Naming.new(method_name)
+  def parametrs = @parametrs ||= Memorium::Parametrs.new(method)
+  def access_level = @access_level ||= Memorium::AccessLevel.new(klass, naming.memoized)
+
+  def method = @method ||= klass.instance_method(method_name)
+
+  def template
+    @template ||= begin
+      template = Template.new(naming, parametrs)
+      Memorium.config.memoize_nil_values ? template.reader_memoize_nil : template.reader_plain
+      template.writer
+      template
+    end
+  end
+
+  def create_alias   = klass.alias_method naming.memoized, naming.original
+  def create_methods = klass.class_eval template.result, __FILE__, __LINE__ + 1
+  def apply_reader_access_level = access_level.apply_or_copy(reader_level, naming.original)
+  def apply_writer_access_level = access_level.apply_or_copy(writer_level, naming.setter)
+  def apply_alias_access_level  = access_level.apply_level(Memorium::AccessLevel::PRIVATE, naming.memoized)
+end

data/lib/memorium/naming.rb

@@ -0,0 +1,25 @@
+class Memorium::Naming
+
+  def initialize(method_name)
+    @method_name = method_name
+  end
+
+  def original      = @original      ||= @method_name
+  def pure          = @pure          ||= clear_name(original)
+  def memoized      = @memoized      ||= "__memo_original_#{original}"
+  def pure_memoized = @pure_memoized ||= "@__memo_#{pure}"
+  def attribute     = @attribute     ||= "@#{pure}"
+  def setter        = @setter        ||= "#{pure}="
+
+  private
+
+  def clear_name(name)
+    stripped = name.to_s.delete_suffix('?').delete_suffix('!')
+
+    case name[-1]
+    when '?' then "is_#{stripped}"
+    when '!' then "to_#{stripped}"
+    else stripped
+    end
+  end
+end

data/lib/memorium/parametrs.rb

@@ -0,0 +1,27 @@
+class Memorium::Parametrs
+  attr_reader :method
+
+  def initialize(method)
+    @method = method
+  end
+
+  def signature = @signature ||= parse_signature
+  def parametrize = @parametrize ||= signature.gsub(/=[^,]+/, '')
+
+  private
+
+  def parse_signature
+    method.parameters.map do |type, name|
+      case type
+      when :req then name.to_s
+      when :opt then "#{name}=nil"
+      when :keyreq then "#{name}:"
+      when :key then "#{name}: nil"
+      when :rest then "*#{name}"
+      when :keyrest then "**#{name}"
+      when :block then "&#{name}"
+      end
+    end.join(", ")
+  end
+
+end

data/lib/memorium/require_attr/template.rb

@@ -0,0 +1,14 @@
+class Memorium::RequireAttr::Template
+
+  def require_method
+    <<~RUBY
+      def require_attr(attr_name, by: :not_nil?)
+        attribute = send(attr_name)
+        require_attribute = Memorium::RequireAttr.new(attr_name, by:, value: attribute)
+        raise(Memorium::AttributeRequired, require_attribute.raise_text, caller) unless require_attribute.check_requirements
+        attribute
+      end
+    RUBY
+
+  end
+end

data/lib/memorium/require_attr.rb

@@ -0,0 +1,36 @@
+class Memorium::RequireAttr
+  attr_reader :attr_name, :by, :value
+
+  def self.create_method(klass) = klass.class_eval Template.new.require_method, caller_location.path, caller_location.lineno + 1
+  def self.caller_location = caller_locations(4, 1).first
+
+  def initialize(attr_name, by:, value:)
+    @attr_name = attr_name.to_s
+    @by = by.is_a?(Proc) ? by : by.to_s
+    @value = value
+  end
+
+  def check_requirements
+    return by.call(value) if by.is_a?(Proc)
+
+    inverse_type? ? inverse_check_by_type : check_by_type
+  end
+
+  def raise_text
+    @raise_text ||= begin
+      return  "Attribute `#{attr_name}` not pass the condition: #{value.inspect}" if by.is_a?(Proc)
+
+      "Attribute `#{attr_name}` #{raise_verb} be #{unpredicated_type}: #{value.inspect}"
+    end
+  end
+
+  private
+
+  def inverse_type?     = @is_inverse_type   ||= by.start_with?('not_')
+  def cleared_type      = @cleared_type      ||= by.delete_prefix('not_')
+  def unpredicated_type = @pure_type         ||= cleared_type.chomp('?')
+  def raise_verb        = @raise_verb        ||= inverse_type? ? 'must not' : 'must'
+
+  def check_by_type         = value.public_send(cleared_type)
+  def inverse_check_by_type = !value.public_send(cleared_type)
+end

data/lib/memorium/version.rb

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

data/lib/memorium.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "zeitwerk"
+require "active_support/concern"
+require "active_support/configurable"
+require_relative "memorium/version"
+
+loader = Zeitwerk::Loader.for_gem
+loader.setup
+
+module Memorium
+  include Config
+
+  class Error < StandardError; end
+  class AttributeRequired < Error; end
+
+end
+
+Object.include(Memorium::Extension)

metadata

@@ -0,0 +1,110 @@
+--- !ruby/object:Gem::Specification
+name: memorium
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Danila Fedorov
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  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: zeitwerk
+  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: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
+description: Toolkit for creating convenient classes with lazy calculations.
+email:
+- dan2065@mail.ru
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- Rakefile
+- examples/order.rb
+- examples/order/order.rb
+- examples/order/order_item.rb
+- examples/save_logs.rb
+- examples/save_logs/app.log
+- examples/save_logs/database.rb
+- examples/save_logs/log_entry.rb
+- examples/save_logs/save_logs.rb
+- lib/memorium.rb
+- lib/memorium/access_level.rb
+- lib/memorium/config.rb
+- lib/memorium/core.rb
+- lib/memorium/extension.rb
+- lib/memorium/initialize_attr.rb
+- lib/memorium/initialize_attr/interaction.rb
+- lib/memorium/initialize_attr/template.rb
+- lib/memorium/memo.rb
+- lib/memorium/memo/eager.rb
+- lib/memorium/memo/pending.rb
+- lib/memorium/memo/template.rb
+- lib/memorium/naming.rb
+- lib/memorium/parametrs.rb
+- lib/memorium/require_attr.rb
+- lib/memorium/require_attr/template.rb
+- lib/memorium/version.rb
+homepage: https://github.com/gem-forge/memorium
+licenses: []
+metadata:
+  homepage_uri: https://github.com/gem-forge/memorium
+  source_code_uri: https://github.com/gem-forge/memorium
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.8
+specification_version: 4
+summary: Toolkit for creating convenient classes with lazy calculations.
+test_files: []