legal_entity 0.1.0.pre.beta0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 56e30bcc7f0afcd1b4c4a9f0b94edd5738ea506da9c0c16cb96988f11076ed5c
+  data.tar.gz: 454e46089d5147fa331c90bcb086f5d1d3483a9c82913f1ced73e473a441735c
+SHA512:
+  metadata.gz: 6246bbd815072b35a248cdc6bb5b1fb19178838e0e980659881cd12d2433d0b3f417120270e7576d47e981ea60ea345723d703e7672f9a4c325a0608072ee892
+  data.tar.gz: b97fe82f471b67f7c5d9ae19da3de5741c8bdb805e88e00728d3310cb6ff1e4c71ba5c12859126fa3d56acdfc28b3f75b7304c88b3c8d4da113e8714b45d27b8

data/.rubocop.yml

@@ -0,0 +1,18 @@
+require:
+  - rubocop-rake
+  - rubocop-minitest
+  - rubocop-sorbet
+
+AllCops:
+  TargetRubyVersion: 2.7
+
+Style/StringLiterals:
+  Enabled: true
+  EnforcedStyle: double_quotes
+
+Style/StringLiteralsInInterpolation:
+  Enabled: true
+  EnforcedStyle: double_quotes
+
+Layout/LineLength:
+  Max: 120

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## [Unreleased]
+
+## [0.1.0] - 2024-02-23
+
+- Initial release

data/MIT-LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2024- Yaw Boakye
+
+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 @@
+# LegalEntity

data/Rakefile

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "minitest/test_task"
+require "rubocop/rake_task"
+
+Minitest::TestTask.create
+RuboCop::RakeTask.new
+
+task default: %i[test rubocop]

data/legal_entity.gemspec

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require_relative "lib/legal_entity/version"
+
+Gem::Specification.new do |spec|
+  spec.name    = "legal_entity"
+  spec.version = LegalEntity::VERSION
+  spec.authors = ["Yaw Boakye"]
+  spec.email   = ["wheresyaw@gmail.com"]
+
+  spec.required_ruby_version = ">= 2.7.0"
+
+  spec.summary     = %(`legal_entity` represents, in your system, the legally recognized entity, according to some jurisdiction.)
+  spec.description = spec.summary
+  spec.homepage    = %(https://github.com/yawboakye/legal_entity)
+  spec.license     = "MIT"
+
+  spec.metadata["allowed_push_host"] = "https://rubygems.org"
+  spec.metadata["homepage_uri"]      = spec.homepage
+  spec.metadata["source_code_uri"]   = spec.homepage
+  spec.metadata["changelog_uri"]     = %(#{spec.homepage}/CHANGELOG.md)
+
+  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/ features/ .git .github Gemfile])
+    end
+  end
+
+  spec.require_paths = %w[lib]
+
+  spec.add_runtime_dependency     "sorbet-runtime",   "~> 0.5"
+
+  spec.add_development_dependency "minitest",         "~> 5.16"
+  spec.add_development_dependency "rake",             "~> 13.0"
+  spec.add_development_dependency "rubocop",          "~> 1.21"
+  spec.add_development_dependency "rubocop-minitest", "~> 0.34"
+  spec.add_development_dependency "rubocop-rake",     "~> 0.6"
+  spec.add_development_dependency "rubocop-sorbet",   "~> 0.7"
+  spec.add_development_dependency "sorbet",           "~> 0.5"
+  spec.add_development_dependency "spoom",            "~> 1.2"
+  spec.add_development_dependency "tapioca",          "~> 0.12"
+
+  spec.add_dependency "activerecord",                 "~> 7.0"
+end

data/lib/legal_entity/person.rb

@@ -0,0 +1,7 @@
+# typed: strict
+# frozen_string_literal: true
+
+module LegalEntity
+  class Person < ActiveRecord::Base
+  end
+end

data/lib/legal_entity/version.rb

@@ -0,0 +1,6 @@
+# typed: strict
+# frozen_string_literal: true
+
+module LegalEntity
+  VERSION = "0.1.0-beta0"
+end

data/lib/legal_entity.rb

@@ -0,0 +1,9 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "active_record"
+
+require_relative "legal_entity/version"
+require_relative "legal_entity/person"
+
+module LegalEntity; end

data/sorbet/config

@@ -0,0 +1,4 @@
+--dir
+.
+--ignore=tmp/
+--ignore=vendor/

data/sorbet/rbi/annotations/.gitattributes

@@ -0,0 +1 @@
+**/*.rbi linguist-vendored=true

data/sorbet/rbi/annotations/activemodel.rbi

@@ -0,0 +1,89 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This file was pulled from a central RBI files repository.
+# Please run `bin/tapioca annotations` to update it.
+
+class ActiveModel::Errors
+  Elem = type_member { { fixed: ActiveModel::Error } }
+
+  sig { params(attribute: T.any(Symbol, String)).returns(T::Array[String]) }
+  def [](attribute); end
+
+  sig { params(attribute: T.any(Symbol, String), type: T.untyped, options: T.untyped).returns(ActiveModel::Error) }
+  def add(attribute, type = :invalid, **options); end
+
+  sig { params(attribute: T.any(Symbol, String), type: T.untyped, options: T.untyped).returns(T::Boolean) }
+  def added?(attribute, type = :invalid, options = {}); end
+
+  sig { params(options: T.untyped).returns(T::Hash[T.untyped, T.untyped]) }
+  def as_json(options = nil); end
+
+  sig { returns(T::Array[Symbol]) }
+  def attribute_names; end
+
+  sig { params(attribute: T.any(Symbol, String), type: T.untyped, options: T.untyped).returns(T.nilable(T::Array[String])) }
+  def delete(attribute, type = nil, **options); end
+
+  sig { returns(T::Hash[Symbol, T::Array[T::Hash[Symbol, T.untyped]]]) }
+  def details; end
+
+  sig { returns(T::Array[Elem]) }
+  def errors; end
+
+  sig { params(attribute: T.any(Symbol, String), message: String).returns(String) }
+  def full_message(attribute, message); end
+
+  sig { returns(T::Array[String]) }
+  def full_messages; end
+
+  sig { params(attribute: T.any(Symbol, String)).returns(T::Array[String]) }
+  def full_messages_for(attribute); end
+
+  sig { params(attribute: T.any(Symbol, String), type: T.untyped, options: T.untyped).returns(String) }
+  def generate_message(attribute, type = :invalid, options = {}); end
+
+  sig { returns(T::Hash[Symbol, T::Array[ActiveModel::Error]]) }
+  def group_by_attribute; end
+
+  sig { params(attribute: T.any(Symbol, String)).returns(T::Boolean) }
+  def has_key?(attribute); end
+
+  sig { params(error: ActiveModel::Error, override_options: T.untyped).returns(T::Array[ActiveModel::Error]) }
+  def import(error, override_options = {}); end
+
+  sig { params(attribute: T.any(Symbol, String)).returns(T::Boolean) }
+  def include?(attribute); end
+
+  sig { params(attribute: T.any(Symbol, String)).returns(T::Boolean) }
+  def key?(attribute); end
+
+  sig { params(other: T.untyped).returns(T::Array[ActiveModel::Error]) }
+  def merge!(other); end
+
+  sig { returns(T::Hash[Symbol, T::Array[String]]) }
+  def messages; end
+
+  sig { params(attribute: T.any(Symbol, String)).returns(T::Array[String]) }
+  def messages_for(attribute); end
+
+  sig { returns(T::Array[Elem]) }
+  def objects; end
+
+  sig { params(attribute: T.any(Symbol, String), type: T.untyped).returns(T::Boolean) }
+  def of_kind?(attribute, type = :invalid); end
+
+  sig { returns(T::Array[String]) }
+  def to_a; end
+
+  sig { params(full_messages: T.untyped).returns(T::Hash[Symbol, T::Array[String]]) }
+  def to_hash(full_messages = false); end
+
+  sig { params(attribute: T.any(Symbol, String), type: T.untyped, options: T.untyped).returns(T::Array[ActiveModel::Error]) }
+  def where(attribute, type = nil, **options); end
+end
+
+module ActiveModel::Validations
+  sig { returns(ActiveModel::Errors) }
+  def errors; end
+end

data/sorbet/rbi/annotations/activerecord.rbi

@@ -0,0 +1,92 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This file was pulled from a central RBI files repository.
+# Please run `bin/tapioca annotations` to update it.
+
+class ActiveRecord::Schema
+  sig { params(info: T::Hash[T.untyped, T.untyped], blk: T.proc.bind(ActiveRecord::Schema).void).void }
+  def self.define(info = nil, &blk); end
+end
+
+class ActiveRecord::Migration
+  # @shim: Methods on migration are delegated to `SchemaStatements` using `method_missing`
+  include ActiveRecord::ConnectionAdapters::SchemaStatements
+
+  # @shim: Methods on migration are delegated to `DatabaseStatements` using `method_missing`
+  include ActiveRecord::ConnectionAdapters::DatabaseStatements
+end
+
+class ActiveRecord::Base
+  sig { returns(FalseClass) }
+  def blank?; end
+
+  # @shim: since `present?` is always true, `presence` always returns `self`
+  sig { returns(T.self_type) }
+  def presence; end
+
+  sig { returns(TrueClass) }
+  def present?; end
+
+  sig { params(args: T.untyped, options: T.untyped, block: T.nilable(T.proc.bind(T.attached_class).params(record: T.attached_class).void)).void }
+  def self.after_initialize(*args, **options, &block); end
+
+  sig { params(args: T.untyped, options: T.untyped, block: T.nilable(T.proc.bind(T.attached_class).params(record: T.attached_class).void)).void }
+  def self.after_find(*args, **options, &block); end
+
+  sig { params(args: T.untyped, options: T.untyped, block: T.nilable(T.proc.bind(T.attached_class).params(record: T.attached_class).void)).void }
+  def self.after_touch(*args, **options, &block); end
+
+  sig { params(args: T.untyped, options: T.untyped, block: T.nilable(T.proc.bind(T.attached_class).params(record: T.attached_class).void)).void }
+  def self.before_validation(*args, **options, &block); end
+
+  sig { params(args: T.untyped, options: T.untyped, block: T.nilable(T.proc.bind(T.attached_class).params(record: T.attached_class).void)).void }
+  def self.after_validation(*args, **options, &block); end
+
+  sig { params(args: T.untyped, options: T.untyped, block: T.nilable(T.proc.bind(T.attached_class).params(record: T.attached_class).void)).void }
+  def self.before_save(*args, **options, &block); end
+
+  sig { params(args: T.untyped, options: T.untyped, block: T.nilable(T.proc.bind(T.attached_class).params(record: T.attached_class).void)).void }
+  def self.around_save(*args, **options, &block); end
+
+  sig { params(args: T.untyped, options: T.untyped, block: T.nilable(T.proc.bind(T.attached_class).params(record: T.attached_class).void)).void }
+  def self.after_save(*args, **options, &block); end
+
+  sig { params(args: T.untyped, options: T.untyped, block: T.nilable(T.proc.bind(T.attached_class).params(record: T.attached_class).void)).void }
+  def self.before_create(*args, **options, &block); end
+
+  sig { params(args: T.untyped, options: T.untyped, block: T.nilable(T.proc.bind(T.attached_class).params(record: T.attached_class).void)).void }
+  def self.around_create(*args, **options, &block); end
+
+  sig { params(args: T.untyped, options: T.untyped, block: T.nilable(T.proc.bind(T.attached_class).params(record: T.attached_class).void)).void }
+  def self.after_create(*args, **options, &block); end
+
+  sig { params(args: T.untyped, options: T.untyped, block: T.nilable(T.proc.bind(T.attached_class).params(record: T.attached_class).void)).void }
+  def self.before_update(*args, **options, &block); end
+
+  sig { params(args: T.untyped, options: T.untyped, block: T.nilable(T.proc.bind(T.attached_class).params(record: T.attached_class).void)).void }
+  def self.around_update(*args, **options, &block); end
+
+  sig { params(args: T.untyped, options: T.untyped, block: T.nilable(T.proc.bind(T.attached_class).params(record: T.attached_class).void)).void }
+  def self.after_update(*args, **options, &block); end
+
+  sig { params(args: T.untyped, options: T.untyped, block: T.nilable(T.proc.bind(T.attached_class).params(record: T.attached_class).void)).void }
+  def self.before_destroy(*args, **options, &block); end
+
+  sig { params(args: T.untyped, options: T.untyped, block: T.nilable(T.proc.bind(T.attached_class).params(record: T.attached_class).void)).void }
+  def self.around_destroy(*args, **options, &block); end
+
+  sig { params(args: T.untyped, options: T.untyped, block: T.nilable(T.proc.bind(T.attached_class).params(record: T.attached_class).void)).void }
+  def self.after_destroy(*args, **options, &block); end
+
+  sig { params(args: T.untyped, options: T.untyped, block: T.nilable(T.proc.bind(T.attached_class).params(record: T.attached_class).void)).void }
+  def self.after_commit(*args, **options, &block); end
+
+  sig { params(args: T.untyped, options: T.untyped, block: T.nilable(T.proc.bind(T.attached_class).params(record: T.attached_class).void)).void }
+  def self.after_rollback(*args, **options, &block); end
+end
+
+class ActiveRecord::Relation
+  sig { returns(T::Boolean) }
+  def blank?; end
+end