SYMBOL INDEX (773 symbols across 69 files)

FILE: lib/hanami/entity.rb
  type Hanami (line 5) | module Hanami
    class Entity (line 54) | class Entity
      type Types (line 60) | module Types
      type ClassMethods (line 68) | module ClassMethods
        function attributes (line 86) | def attributes(type = nil, &blk)
        function schema= (line 97) | def schema=(value)
      method inherited (line 110) | def self.inherited(klass)
      method initialize (line 126) | def initialize(attributes = nil)
      method id (line 136) | def id
      method method_missing (line 146) | def method_missing(method_name, *)
      method == (line 161) | def ==(other)
      method hash (line 171) | def hash
      method freeze (line 178) | def freeze
      method to_h (line 188) | def to_h
      method attribute? (line 201) | def attribute?(name)
      method respond_to_missing? (line 213) | def respond_to_missing?(name, _include_all)

FILE: lib/hanami/entity/schema.rb
  type Hanami (line 6) | module Hanami
    class Entity (line 7) | class Entity
      class Schema (line 56) | class Schema
        class Schemaless (line 61) | class Schemaless
          method initialize (line 64) | def initialize
          method call (line 74) | def call(attributes)
          method attribute? (line 84) | def attribute?(_name)
        class Definition (line 93) | class Definition
          class Dsl (line 97) | class Dsl
            method build (line 108) | def self.build(type, &blk)
            method initialize (line 118) | def initialize(&blk)
            method attribute (line 149) | def attribute(name, type)
            method to_h (line 155) | def to_h
          method initialize (line 168) | def initialize(type = nil, &blk)
          method call (line 185) | def call(attributes)
          method attribute? (line 201) | def attribute?(name)
        method initialize (line 224) | def initialize(type = nil, &blk)
        method call (line 240) | def call(attributes)
        method attribute? (line 258) | def attribute?(name)

FILE: lib/hanami/model.rb
  type Hanami (line 11) | module Hanami
    type Model (line 15) | module Model
      function configure (line 54) | def self.configure(&block)
      function configuration (line 62) | def self.configuration
      function repositories (line 68) | def self.repositories
      function container (line 74) | def self.container
      function load! (line 81) | def self.load!(&blk)
      function disconnect (line 107) | def self.disconnect

FILE: lib/hanami/model/association.rb
  type Hanami (line 9) | module Hanami
    type Model (line 10) | module Model
      class Association (line 15) | class Association
        method build (line 20) | def self.build(repository, target, subject)
        method lookup (line 29) | def self.lookup(association)

FILE: lib/hanami/model/associations/belongs_to.rb
  type Hanami (line 5) | module Hanami
    type Model (line 6) | module Model
      type Associations (line 7) | module Associations
        class BelongsTo (line 12) | class BelongsTo
          method schema_type (line 15) | def self.schema_type(entity)
          method initialize (line 41) | def initialize(repository, source, target, subject, scope = nil)
          method one (line 52) | def one
          method container (line 60) | def container
          method primary_key (line 66) | def primary_key
          method relation (line 72) | def relation(name)
          method foreign_key (line 78) | def foreign_key
          method association_keys (line 86) | def association_keys
          method association (line 95) | def association
          method _build_scope (line 101) | def _build_scope

FILE: lib/hanami/model/associations/dsl.rb
  type Hanami (line 3) | module Hanami
    type Model (line 4) | module Model
      type Associations (line 5) | module Associations
        class Dsl (line 11) | class Dsl
          method initialize (line 14) | def initialize(repository, &blk)
          method has_many (line 21) | def has_many(relation, **args)
          method has_one (line 28) | def has_one(relation, *)
          method belongs_to (line 34) | def belongs_to(relation, *)

FILE: lib/hanami/model/associations/has_many.rb
  type Hanami (line 5) | module Hanami
    type Model (line 6) | module Model
      type Associations (line 7) | module Associations
        class HasMany (line 12) | class HasMany
          method schema_type (line 15) | def self.schema_type(entity)
          method initialize (line 42) | def initialize(repository, source, target, subject, scope = nil)
          method create (line 53) | def create(data)
          method add (line 62) | def add(data)
          method remove (line 71) | def remove(id)
          method delete (line 79) | def delete
          method each (line 85) | def each(&blk)
          method map (line 91) | def map(&blk)
          method to_a (line 97) | def to_a
          method where (line 103) | def where(condition)
          method count (line 109) | def count
          method command (line 117) | def command(target, relation, options = {})
          method entity (line 123) | def entity
          method relation (line 129) | def relation(name)
          method aggregate (line 135) | def aggregate(name)
          method association (line 141) | def association(name)
          method associate (line 147) | def associate(data)
          method unassociate (line 155) | def unassociate
          method container (line 161) | def container
          method primary_key (line 167) | def primary_key
          method foreign_key (line 173) | def foreign_key
          method association_keys (line 181) | def association_keys
          method target_association (line 190) | def target_association
          method _build_scope (line 196) | def _build_scope
          method __new__ (line 204) | def __new__(new_scope)
          method serialize (line 208) | def serialize(data)

FILE: lib/hanami/model/associations/has_one.rb
  type Hanami (line 5) | module Hanami
    type Model (line 6) | module Model
      type Associations (line 7) | module Associations
        class HasOne (line 12) | class HasOne
          method schema_type (line 15) | def self.schema_type(entity)
          method initialize (line 41) | def initialize(repository, source, target, subject, scope = nil)
          method one (line 50) | def one
          method create (line 54) | def create(data)
          method add (line 62) | def add(data)
          method update (line 68) | def update(data)
          method delete (line 77) | def delete
          method replace (line 82) | def replace(data)
          method entity (line 93) | def entity
          method aggregate (line 99) | def aggregate(name)
          method command (line 105) | def command(target, relation, options = {})
          method relation (line 111) | def relation(name)
          method container (line 117) | def container
          method primary_key (line 123) | def primary_key
          method foreign_key (line 129) | def foreign_key
          method associate (line 135) | def associate(data)
          method association_keys (line 145) | def association_keys
          method _build_scope (line 153) | def _build_scope
          method serialize (line 161) | def serialize(data)

FILE: lib/hanami/model/associations/many_to_many.rb
  type Hanami (line 5) | module Hanami
    type Model (line 6) | module Model
      type Associations (line 7) | module Associations
        class ManyToMany (line 12) | class ManyToMany
          method schema_type (line 15) | def self.schema_type(entity)
          method initialize (line 44) | def initialize(repository, source, target, subject, scope = nil)
          method to_a (line 54) | def to_a
          method map (line 58) | def map(&blk)
          method each (line 62) | def each(&blk)
          method count (line 66) | def count
          method where (line 70) | def where(condition)
          method add (line 78) | def add(*data)
          method delete (line 87) | def delete
          method remove (line 93) | def remove(target_id)
          method container (line 108) | def container
          method relation (line 114) | def relation(name)
          method command (line 120) | def command(target, relation, options = {})
          method associate (line 126) | def associate(data)
          method source_primary_key (line 134) | def source_primary_key
          method source_foreign_key (line 140) | def source_foreign_key
          method association_keys (line 146) | def association_keys
          method target_foreign_key (line 154) | def target_foreign_key
          method target_primary_key (line 160) | def target_primary_key
          method association (line 168) | def association
          method _build_scope (line 175) | def _build_scope
          method __new__ (line 187) | def __new__(new_scope)
          method serialize (line 193) | def serialize(data)

FILE: lib/hanami/model/configuration.rb
  type Hanami (line 5) | module Hanami
    type Model (line 6) | module Model
      class Configuration (line 13) | class Configuration
        method initialize (line 32) | def initialize(configurator)
        method connection (line 57) | def connection
        method gateway (line 68) | def gateway
        method root (line 76) | def root
        method migrations (line 83) | def migrations
        method schema (line 90) | def schema
        method define_mappings (line 96) | def define_mappings(root, &blk)
        method register_entity (line 102) | def register_entity(plural, singular, klass)
        method define_entities_mappings (line 109) | def define_entities_mappings(container, repositories)
        method configure_gateway (line 122) | def configure_gateway
        method logger= (line 128) | def logger=(value)
        method rom (line 139) | def rom
        method load! (line 152) | def load!(repositories, &blk)
        method method_missing (line 168) | def method_missing(method_name, *args, &blk)
        method respond_to_missing? (line 178) | def respond_to_missing?(method_name, include_all)

FILE: lib/hanami/model/configurator.rb
  type Hanami (line 3) | module Hanami
    type Model (line 4) | module Model
      class Configurator (line 9) | class Configurator
        method build (line 40) | def self.build(&block)
        method migrations_logger (line 46) | def migrations_logger(stream = $stdout)
        method adapter (line 55) | def adapter(backend, url)
        method path (line 62) | def path(path)
        method migrations (line 68) | def migrations(path)
        method schema (line 74) | def schema(path)
        method logger (line 80) | def logger(stream, options = {})
        method gateway (line 89) | def gateway(&blk)

FILE: lib/hanami/model/entity_name.rb
  type Hanami (line 3) | module Hanami
    type Model (line 4) | module Model
      class EntityName (line 12) | class EntityName
        method initialize (line 22) | def initialize(name)
        method underscore (line 28) | def underscore
        method to_s (line 34) | def to_s

FILE: lib/hanami/model/error.rb
  type Hanami (line 5) | module Hanami
    type Model (line 6) | module Model
      class Error (line 10) | class Error < ::StandardError
        method for (line 17) | def self.for(exception)
        method register (line 23) | def self.register(external, internal)
        method mapping (line 29) | def self.mapping
      class DatabaseError (line 37) | class DatabaseError < Error
      class InvalidCommandError (line 43) | class InvalidCommandError < Error
        method initialize (line 46) | def initialize(message = "Invalid command")
      class ConstraintViolationError (line 54) | class ConstraintViolationError < Error
        method initialize (line 57) | def initialize(message = "Constraint has been violated")
      class UniqueConstraintViolationError (line 65) | class UniqueConstraintViolationError < ConstraintViolationError
        method initialize (line 68) | def initialize(message = "Unique constraint has been violated")
      class ForeignKeyConstraintViolationError (line 76) | class ForeignKeyConstraintViolationError < ConstraintViolationError
        method initialize (line 79) | def initialize(message = "Foreign key constraint has been violated")
      class NotNullConstraintViolationError (line 87) | class NotNullConstraintViolationError < ConstraintViolationError
        method initialize (line 90) | def initialize(message = "NOT NULL constraint has been violated")
      class CheckConstraintViolationError (line 98) | class CheckConstraintViolationError < ConstraintViolationError
        method initialize (line 101) | def initialize(message = "Check constraint has been violated")
      class UnknownDatabaseTypeError (line 109) | class UnknownDatabaseTypeError < Error
      class MissingPrimaryKeyError (line 115) | class MissingPrimaryKeyError < Error
      class UnknownAttributeError (line 121) | class UnknownAttributeError < Error
      class UnknownDatabaseAdapterError (line 127) | class UnknownDatabaseAdapterError < Error
        method initialize (line 128) | def initialize(url)

FILE: lib/hanami/model/mapped_relation.rb
  type Hanami (line 3) | module Hanami
    type Model (line 4) | module Model
      class MappedRelation (line 11) | class MappedRelation < SimpleDelegator
        method mapper_name (line 24) | def self.mapper_name
        method initialize (line 30) | def initialize(relation)
        method [] (line 54) | def [](attribute)

FILE: lib/hanami/model/mapping.rb
  type Hanami (line 5) | module Hanami
    type Model (line 6) | module Model
      class Mapping (line 11) | class Mapping
        method initialize (line 18) | def initialize(&blk)
        method t (line 26) | def t(name, *args)
        method model (line 31) | def model(entity)
        method register_as (line 35) | def register_as(name)
        method attribute (line 39) | def attribute(name, options)
        method process (line 47) | def process(input)
        method reverse? (line 52) | def reverse?
        method translate (line 57) | def translate(attribute)

FILE: lib/hanami/model/migration.rb
  type Hanami (line 3) | module Hanami
    type Model (line 4) | module Model
      class Migration (line 9) | class Migration
        method initialize (line 20) | def initialize(gateway, &block)
        method run (line 28) | def run(direction = :up)

FILE: lib/hanami/model/migrator.rb
  type Hanami (line 6) | module Hanami
    type Model (line 7) | module Model
      class MigrationError (line 11) | class MigrationError < Hanami::Model::Error
      class Migrator (line 17) | class Migrator
        method create (line 47) | def self.create
        method drop (line 77) | def self.drop
        method migrate (line 126) | def self.migrate(version: nil)
        method rollback (line 162) | def self.rollback(steps: 1)
        method apply (line 206) | def self.apply
        method prepare (line 248) | def self.prepare
        method version (line 267) | def self.version
        method initialize (line 279) | def initialize(configuration: self.class.configuration)
        method create (line 288) | def create
        method drop (line 296) | def drop
        method migrate (line 304) | def migrate(version: nil)
        method rollback (line 312) | def rollback(steps: 1)
        method apply (line 320) | def apply
        method prepare (line 330) | def prepare
        method version (line 343) | def version
        method configuration (line 351) | def self.configuration
        method migrations (line 373) | def migrations
        method migrations? (line 381) | def migrations?
        method delete_migrations (line 389) | def delete_migrations

FILE: lib/hanami/model/migrator/adapter.rb
  type Hanami (line 7) | module Hanami
    type Model (line 8) | module Model
      class Migrator (line 9) | class Migrator
        class Adapter (line 14) | class Adapter
          method for (line 31) | def self.for(configuration)
          method initialize (line 53) | def initialize(connection)
          method create (line 64) | def create
          method drop (line 75) | def drop
          method migrate (line 81) | def migrate(migrations, version)
          method rollback (line 91) | def rollback(migrations, steps)
          method load (line 107) | def load
          method version (line 115) | def version
          method version_to_rollback (line 133) | def version_to_rollback(table, steps)
          method migrations_table_dataset (line 142) | def migrations_table_dataset
          method schema (line 152) | def schema
          method new_connection (line 166) | def new_connection(global: false)
          method database (line 174) | def database
          method port (line 180) | def port
          method host (line 186) | def host
          method username (line 192) | def username
          method password (line 198) | def password
          method migrations_table (line 204) | def migrations_table
          method escape (line 210) | def escape(string)
          method execute (line 216) | def execute(command, env: {}, error: ->(err) { raise MigrationEr...

FILE: lib/hanami/model/migrator/connection.rb
  type Hanami (line 5) | module Hanami
    type Model (line 6) | module Model
      class Migrator (line 7) | class Migrator
        class Connection (line 14) | class Connection
          method initialize (line 17) | def initialize(configuration)
          method raw (line 23) | def raw
          method host (line 40) | def host
          method port (line 50) | def port
          method database (line 60) | def database
          method database_type (line 72) | def database_type
          method user (line 89) | def user
          method password (line 99) | def password
          method uri (line 107) | def uri
          method global_uri (line 115) | def global_uri
          method jdbc? (line 123) | def jdbc?
          method parsed_uri (line 131) | def parsed_uri
          method schema (line 136) | def schema
          method table (line 144) | def table(name)
          method parsed_opt (line 160) | def parsed_opt(option, query: parsed_uri.query)

FILE: lib/hanami/model/migrator/logger.rb
  type Hanami (line 5) | module Hanami
    type Model (line 6) | module Model
      class Migrator (line 7) | class Migrator
        class Logger (line 12) | class Logger < Hanami::Logger
          class Formatter (line 17) | class Formatter < Hanami::Logger::Formatter
            method _format (line 22) | def _format(hash)
          method initialize (line 29) | def initialize(stream)

FILE: lib/hanami/model/migrator/mysql_adapter.rb
  type Hanami (line 3) | module Hanami
    type Model (line 4) | module Model
      class Migrator (line 5) | class Migrator
        class MySQLAdapter (line 10) | class MySQLAdapter < Adapter
          method create (line 27) | def create
          method drop (line 41) | def drop
          method dump (line 55) | def dump
          method load (line 62) | def load
          method password (line 70) | def password
          method port (line 74) | def port
          method dump_structure (line 80) | def dump_structure
          method load_structure (line 86) | def load_structure
          method dump_migrations_data (line 92) | def dump_migrations_data

FILE: lib/hanami/model/migrator/postgres_adapter.rb
  type Hanami (line 5) | module Hanami
    type Model (line 6) | module Model
      class Migrator (line 7) | class Migrator
        class PostgresAdapter (line 12) | class PostgresAdapter < Adapter
          method create (line 37) | def create
          method drop (line 43) | def drop
          method dump (line 49) | def dump
          method load (line 56) | def load
          method environment_variables (line 64) | def environment_variables
          method dump_structure (line 75) | def dump_structure
          method load_structure (line 81) | def load_structure
          method dump_migrations_data (line 89) | def dump_migrations_data
          method call_db_command (line 96) | def call_db_command(command)
          method modified_message (line 110) | def modified_message(original_message)

FILE: lib/hanami/model/migrator/sqlite_adapter.rb
  type Hanami (line 7) | module Hanami
    type Model (line 8) | module Model
      class Migrator (line 9) | class Migrator
        class SQLiteAdapter (line 14) | class SQLiteAdapter < Adapter
          type Memory (line 19) | module Memory
            function create (line 22) | def create
            function drop (line 27) | def drop
          method initialize (line 35) | def initialize(configuration)
          method create (line 42) | def create
          method drop (line 51) | def drop
          method dump (line 59) | def dump
          method load (line 66) | def load
          method path (line 74) | def path
          method root (line 82) | def root
          method memory? (line 88) | def memory?
          method dump_structure (line 96) | def dump_structure
          method load_structure (line 102) | def load_structure
          method dump_migrations_data (line 109) | def dump_migrations_data

FILE: lib/hanami/model/plugins.rb
  type Hanami (line 3) | module Hanami
    type Model (line 4) | module Model
      type Plugins (line 9) | module Plugins
        class WrappingInput (line 14) | class WrappingInput
          method initialize (line 17) | def initialize(_relation, input)

FILE: lib/hanami/model/plugins/mapping.rb
  type Hanami (line 3) | module Hanami
    type Model (line 4) | module Model
      type Plugins (line 5) | module Plugins
        type Mapping (line 10) | module Mapping
          class InputWithMapping (line 15) | class InputWithMapping < WrappingInput
            method initialize (line 18) | def initialize(relation, input)
            method [] (line 27) | def [](value)
          type ClassMethods (line 36) | module ClassMethods
            function build (line 41) | def build(relation, options = {})
          function included (line 49) | def self.included(klass)

FILE: lib/hanami/model/plugins/schema.rb
  type Hanami (line 3) | module Hanami
    type Model (line 4) | module Model
      type Plugins (line 5) | module Plugins
        type Schema (line 10) | module Schema
          class InputWithSchema (line 15) | class InputWithSchema < WrappingInput
            method initialize (line 18) | def initialize(relation, input)
            method [] (line 27) | def [](value)
          type ClassMethods (line 36) | module ClassMethods
            function build (line 41) | def build(relation, options = {})
          function included (line 49) | def self.included(klass)

FILE: lib/hanami/model/plugins/timestamps.rb
  type Hanami (line 3) | module Hanami
    type Model (line 4) | module Model
      type Plugins (line 5) | module Plugins
        type Timestamps (line 10) | module Timestamps
          class InputWithTimestamp (line 17) | class InputWithTimestamp < WrappingInput
            method initialize (line 26) | def initialize(relation, input)
            method [] (line 35) | def [](value)
            method _touch (line 45) | def _touch(_value)
            method timestamps? (line 53) | def timestamps?
          class InputWithUpdateTimestamp (line 62) | class InputWithUpdateTimestamp < InputWithTimestamp
            method _touch (line 67) | def _touch(value, now)
          class InputWithCreateTimestamp (line 77) | class InputWithCreateTimestamp < InputWithUpdateTimestamp
            method _touch (line 82) | def _touch(value, now)
          type ClassMethods (line 93) | module ClassMethods
            function build (line 98) | def build(relation, options = {})
          function included (line 112) | def self.included(klass)

FILE: lib/hanami/model/relation_name.rb
  type Hanami (line 6) | module Hanami
    type Model (line 7) | module Model
      class RelationName (line 15) | class RelationName < EntityName
        method new (line 21) | def self.new(name)

FILE: lib/hanami/model/sql.rb
  type Hanami (line 6) | module Hanami
    type Model (line 8) | module Model
      function migration (line 50) | def self.migration(&blk)
      type Sql (line 57) | module Sql
        function function (line 85) | def self.function(name)
        function literal (line 119) | def self.literal(string)
        function asc (line 129) | def self.asc(column)
        function desc (line 139) | def self.desc(column)

FILE: lib/hanami/model/sql/console.rb
  type Hanami (line 5) | module Hanami
    type Model (line 6) | module Model
      type Sql (line 7) | module Sql
        class Console (line 12) | class Console
          method initialize (line 21) | def initialize(uri)
          method console (line 29) | def console

FILE: lib/hanami/model/sql/consoles/abstract.rb
  type Hanami (line 3) | module Hanami
    type Model (line 4) | module Model
      type Sql (line 5) | module Sql
        type Consoles (line 6) | module Consoles
          class Abstract (line 11) | class Abstract
            method initialize (line 14) | def initialize(uri)
            method database_name (line 22) | def database_name
            method concat (line 28) | def concat(*tokens)

FILE: lib/hanami/model/sql/consoles/mysql.rb
  type Hanami (line 5) | module Hanami
    type Model (line 6) | module Model
      type Sql (line 7) | module Sql
        type Consoles (line 8) | module Consoles
          class Mysql (line 13) | class Mysql < Abstract
            method connection_string (line 20) | def connection_string
            method command (line 28) | def command
            method host (line 34) | def host
            method database (line 40) | def database
            method port (line 46) | def port
            method username (line 52) | def username
            method password (line 58) | def password

FILE: lib/hanami/model/sql/consoles/postgresql.rb
  type Hanami (line 6) | module Hanami
    type Model (line 7) | module Model
      type Sql (line 8) | module Sql
        type Consoles (line 9) | module Consoles
          class Postgresql (line 14) | class Postgresql < Abstract
            method connection_string (line 25) | def connection_string
            method command (line 34) | def command
            method host (line 40) | def host
            method database (line 46) | def database
            method port (line 52) | def port
            method username (line 59) | def username
            method configure_password (line 66) | def configure_password
            method query (line 73) | def query

FILE: lib/hanami/model/sql/consoles/sqlite.rb
  type Hanami (line 6) | module Hanami
    type Model (line 7) | module Model
      type Sql (line 8) | module Sql
        type Consoles (line 9) | module Consoles
          class Sqlite (line 14) | class Sqlite < Abstract
            method connection_string (line 21) | def connection_string
            method command (line 29) | def command
            method host (line 35) | def host
            method database (line 41) | def database

FILE: lib/hanami/model/sql/entity/schema.rb
  type Hanami (line 7) | module Hanami
    type Model (line 8) | module Model
      type Sql (line 9) | module Sql
        type Entity (line 10) | module Entity
          class Schema (line 22) | class Schema < Hanami::Entity::Schema
            method initialize (line 36) | def initialize(registry, relation, mapping)
            method call (line 51) | def call(attributes)
            method attribute? (line 67) | def attribute?(name)
            method build (line 89) | def build(registry, relation, mapping)
            method build_attributes (line 106) | def build_attributes(relation, mapping)
            method build_associations (line 125) | def build_associations(registry, associations)
            method coercible (line 136) | def coercible(type)

FILE: lib/hanami/model/sql/types.rb
  type Hanami (line 6) | module Hanami
    type Model (line 7) | module Model
      type Sql (line 8) | module Sql
        type Types (line 12) | module Types
          type Schema (line 18) | module Schema
            function coercible (line 67) | def self.coercible(attribute)
            function pg_json_pristines (line 89) | def self.pg_json_pristines
            function pg_json? (line 97) | def self.pg_json?(pristine)
            class AssociationType (line 108) | class AssociationType < Hanami::Model::Types::Schema::Coercibl...
              method valid? (line 117) | def valid?(value)
              method success (line 123) | def success(*args)

FILE: lib/hanami/model/sql/types/schema/coercions.rb
  type Hanami (line 6) | module Hanami
    type Model (line 7) | module Model
      type Sql (line 8) | module Sql
        type Types (line 9) | module Types
          type Schema (line 10) | module Schema
            type Coercions (line 17) | module Coercions
              function int (line 28) | def self.int(arg)
              function float (line 49) | def self.float(arg)
              function decimal (line 70) | def self.decimal(arg)
              function date (line 93) | def self.date(arg)
              function datetime (line 116) | def self.datetime(arg)
              function time (line 139) | def self.time(arg)
              function array (line 164) | def self.array(arg)
              function hash (line 185) | def self.hash(arg)
              function pg_json (line 208) | def self.pg_json(arg)

FILE: lib/hanami/model/types.rb
  type Hanami (line 5) | module Hanami
    type Model (line 6) | module Model
      type Types (line 10) | module Types
        function included (line 15) | def self.included(mod)
        type ClassMethods (line 22) | module ClassMethods
          function Entity (line 46) | def Entity(type)
          function Collection (line 76) | def Collection(type)
        type Schema (line 85) | module Schema
          class CoercibleType (line 90) | class CoercibleType < Dry::Types::Definition
            method call (line 101) | def call(value)
            method valid? (line 122) | def valid?(value)
            method coerce (line 132) | def coerce(value)
            method object (line 143) | def object

FILE: lib/hanami/model/version.rb
  type Hanami (line 3) | module Hanami
    type Model (line 4) | module Model

FILE: lib/hanami/repository.rb
  type Hanami (line 13) | module Hanami
    class Repository (line 112) | class Repository < ROM::Repository::Root
      method configuration (line 125) | def self.configuration
      method container (line 133) | def self.container
      method command (line 157) | def command(*args, **opts, &block)
      method define_relation (line 171) | def self.define_relation
      method define_mapping (line 201) | def self.define_mapping
      method define_associations (line 224) | def self.define_associations
      method associations (line 241) | def self.associations(&blk)
      method schema (line 262) | def self.schema(&blk)
      method mapping (line 281) | def self.mapping(&blk)
      method load! (line 289) | def self.load!
      method inherited (line 298) | def self.inherited(klass)
      type Commands (line 330) | module Commands
        function create (line 348) | def create(*args)
        function update (line 377) | def update(*args)
        function delete (line 396) | def delete(*args)
      method initialize (line 408) | def initialize
      method find (line 426) | def find(id)
      method all (line 440) | def all
      method first (line 452) | def first
      method last (line 464) | def last
      method clear (line 474) | def clear
      method assoc (line 486) | def assoc(target, subject = nil)

FILE: spec/support/database.rb
  type Database (line 3) | module Database
    class Setup (line 4) | class Setup
      method initialize (line 7) | def initialize(adapter: ENV["DB"])
      method run (line 11) | def run
    type Strategies (line 16) | module Strategies
      function strategies (line 21) | def self.strategies
    class Strategy (line 28) | class Strategy
      method for (line 30) | def for(adapter)
      method strategies (line 38) | def strategies
    function engine (line 44) | def self.engine
    function engine? (line 48) | def self.engine?(name)

FILE: spec/support/database/strategies/abstract.rb
  type Database (line 3) | module Database
    type Strategies (line 4) | module Strategies
      class Abstract (line 5) | class Abstract
        method eligible? (line 6) | def self.eligible?(_adapter)
        method run (line 10) | def run
        method before (line 22) | def before
        method database_name (line 26) | def database_name
        method load_dependencies (line 30) | def load_dependencies
        method export_env (line 34) | def export_env
        method create_database (line 38) | def create_database
        method configure (line 42) | def configure
        method after (line 50) | def after
        method jruby? (line 56) | def jruby?
        method ci? (line 60) | def ci?

FILE: spec/support/database/strategies/mysql.rb
  type Database (line 5) | module Database
    type Strategies (line 6) | module Strategies
      class Mysql (line 7) | class Mysql < Sql
        type JrubyImplementation (line 8) | module JrubyImplementation
          function load_dependencies (line 11) | def load_dependencies
          function export_env (line 16) | def export_env
          function host (line 21) | def host
          function credentials (line 25) | def credentials
        type TravisCiImplementation (line 36) | module TravisCiImplementation
          function export_env (line 39) | def export_env
          function create_database (line 45) | def create_database
          function run_command (line 53) | def run_command(command)
        type CircleCiImplementation (line 59) | module CircleCiImplementation
          function export_env (line 62) | def export_env
          function create_database (line 68) | def create_database
          function run_command (line 75) | def run_command(command)
        method eligible? (line 81) | def self.eligible?(adapter)
        method initialize (line 85) | def initialize
        method load_dependencies (line 98) | def load_dependencies
        method export_env (line 103) | def export_env
        method create_database (line 111) | def create_database
        method run_command (line 119) | def run_command(command)

FILE: spec/support/database/strategies/postgresql.rb
  type Database (line 5) | module Database
    type Strategies (line 6) | module Strategies
      class Postgresql (line 7) | class Postgresql < Sql
        type JrubyImplementation (line 8) | module JrubyImplementation
          function load_dependencies (line 11) | def load_dependencies
          function export_env (line 18) | def export_env
        type TravisCiImplementation (line 24) | module TravisCiImplementation
          function export_env (line 27) | def export_env
        type CircleCiImplementation (line 33) | module CircleCiImplementation
          function create_database (line 36) | def create_database
        type GithubActionsImplementation (line 47) | module GithubActionsImplementation
          function export_env (line 50) | def export_env
          function create_database (line 56) | def create_database
        method eligible? (line 67) | def self.eligible?(adapter)
        method initialize (line 71) | def initialize
        method load_dependencies (line 85) | def load_dependencies
        method create_database (line 90) | def create_database
        method export_env (line 106) | def export_env
        method try (line 115) | def try(message)

FILE: spec/support/database/strategies/sql.rb
  type Database (line 8) | module Database
    type Strategies (line 9) | module Strategies
      class Sql (line 10) | class Sql < Abstract
        method eligible? (line 11) | def self.eligible?(_adapter)
        method before (line 17) | def before
        method export_env (line 23) | def export_env
        method configure (line 29) | def configure
        method after (line 44) | def after
        method migrate (line 50) | def migrate
        method credentials (line 57) | def credentials
        method host (line 63) | def host
        method host_and_credentials (line 67) | def host_and_credentials
        method logger (line 73) | def logger

FILE: spec/support/database/strategies/sqlite.rb
  type Database (line 6) | module Database
    type Strategies (line 7) | module Strategies
      class Sqlite (line 8) | class Sqlite < Sql
        type JrubyImplementation (line 9) | module JrubyImplementation
          function load_dependencies (line 12) | def load_dependencies
          function export_env (line 18) | def export_env
        type CiImplementation (line 24) | module CiImplementation
        method eligible? (line 27) | def self.eligible?(adapter)
        method initialize (line 31) | def initialize
        method database_name (line 38) | def database_name
        method load_dependencies (line 42) | def load_dependencies
        method create_database (line 47) | def create_database
        method export_env (line 54) | def export_env

FILE: spec/support/fixtures.rb
  class BaseParams (line 5) | class BaseParams < OpenStruct
    method to_hash (line 6) | def to_hash
  class User (line 11) | class User < Hanami::Entity
  class Avatar (line 14) | class Avatar < Hanami::Entity
  class Author (line 17) | class Author < Hanami::Entity
  class Book (line 20) | class Book < Hanami::Entity
  class Category (line 23) | class Category < Hanami::Entity
  class BookOntology (line 26) | class BookOntology < Hanami::Entity
  class Operator (line 29) | class Operator < Hanami::Entity
  class AccessToken (line 32) | class AccessToken < Hanami::Entity
  class SourceFile (line 35) | class SourceFile < Hanami::Entity
  class Post (line 38) | class Post < Hanami::Entity
  class Comment (line 41) | class Comment < Hanami::Entity
  class Warehouse (line 44) | class Warehouse < Hanami::Entity
  class Account (line 52) | class Account < Hanami::Entity
  class PageVisit (line 64) | class PageVisit < Hanami::Entity
  class Person (line 78) | class Person < Hanami::Entity
  class Product (line 85) | class Product < Hanami::Entity
  class Color (line 88) | class Color < Hanami::Entity
  class Label (line 91) | class Label < Hanami::Entity
  class PostRepository (line 94) | class PostRepository < Hanami::Repository
    method find_with_commenters (line 101) | def find_with_commenters(id)
    method commenters_for (line 105) | def commenters_for(post)
    method find_with_author (line 109) | def find_with_author(id)
    method feed_for (line 113) | def feed_for(id)
    method author_for (line 117) | def author_for(post)
  class CommentRepository (line 122) | class CommentRepository < Hanami::Repository
    method commenter_for (line 128) | def commenter_for(comment)
  class AvatarRepository (line 133) | class AvatarRepository < Hanami::Repository
    method by_user (line 138) | def by_user(id)
  class UserRepository (line 143) | class UserRepository < Hanami::Repository
    method find_with_threads (line 150) | def find_with_threads(id)
    method threads_for (line 154) | def threads_for(user)
    method find_with_avatar (line 158) | def find_with_avatar(id)
    method create_with_avatar (line 162) | def create_with_avatar(data)
    method remove_avatar (line 166) | def remove_avatar(user)
    method add_avatar (line 170) | def add_avatar(user, data)
    method update_avatar (line 174) | def update_avatar(user, data)
    method replace_avatar (line 178) | def replace_avatar(user, data)
    method avatar_for (line 182) | def avatar_for(user)
    method by_name (line 186) | def by_name(name)
    method by_matching_name (line 190) | def by_matching_name(name)
    method by_name_with_root (line 194) | def by_name_with_root(name)
    method find_all_by_manual_query (line 198) | def find_all_by_manual_query
    method ids (line 202) | def ids
    method select_id_and_name (line 206) | def select_id_and_name
  class AvatarRepository (line 211) | class AvatarRepository < Hanami::Repository
    method by_user (line 138) | def by_user(id)
  class AuthorRepository (line 214) | class AuthorRepository < Hanami::Repository
    method create_many (line 219) | def create_many(data, opts: {})
    method create_with_books (line 223) | def create_with_books(data)
    method find_with_books (line 227) | def find_with_books(id)
    method books_for (line 231) | def books_for(author)
    method add_book (line 235) | def add_book(author, data)
    method remove_book (line 239) | def remove_book(author, id)
    method delete_books (line 243) | def delete_books(author)
    method delete_on_sales_books (line 247) | def delete_on_sales_books(author)
    method books_count (line 251) | def books_count(author)
    method on_sales_books_count (line 255) | def on_sales_books_count(author)
    method find_book (line 259) | def find_book(author, id)
    method book_exists? (line 263) | def book_exists?(author, id)
    method book_for (line 269) | def book_for(author, id)
  class BookOntologyRepository (line 274) | class BookOntologyRepository < Hanami::Repository
  class CategoryRepository (line 281) | class CategoryRepository < Hanami::Repository
    method books_for (line 286) | def books_for(category)
    method on_sales_books_count (line 290) | def on_sales_books_count(category)
    method books_count (line 294) | def books_count(category)
    method find_with_books (line 298) | def find_with_books(id)
    method add_books (line 302) | def add_books(category, *books)
    method remove_book (line 306) | def remove_book(category, book_id)
  class BookRepository (line 311) | class BookRepository < Hanami::Repository
    method add_category (line 317) | def add_category(book, category)
    method clear_categories (line 321) | def clear_categories(book)
    method categories_for (line 325) | def categories_for(book)
    method find_with_categories (line 329) | def find_with_categories(id)
    method find_with_author (line 333) | def find_with_author(id)
    method author_for (line 337) | def author_for(book)
  class OperatorRepository (line 342) | class OperatorRepository < Hanami::Repository
  class AccessTokenRepository (line 351) | class AccessTokenRepository < Hanami::Repository
  class SourceFileRepository (line 355) | class SourceFileRepository < Hanami::Repository
  class WarehouseRepository (line 358) | class WarehouseRepository < Hanami::Repository
  class ProductRepository (line 361) | class ProductRepository < Hanami::Repository
  class ColorRepository (line 364) | class ColorRepository < Hanami::Repository
  class LabelRepository (line 373) | class LabelRepository < Hanami::Repository

FILE: spec/support/platform.rb
  type Platform (line 3) | module Platform
    function ci? (line 10) | def self.ci?
    function match (line 14) | def self.match(&blk)
    function match? (line 18) | def self.match?(**args)
  type PlatformHelpers (line 23) | module PlatformHelpers
    function with_platform (line 24) | def with_platform(**args)
    function unless_platform (line 28) | def unless_platform(**args)

FILE: spec/support/platform/ci.rb
  type Platform (line 3) | module Platform
    type Ci (line 4) | module Ci
      function ci? (line 5) | def self.ci?(name)
      function current (line 9) | def self.current
      function travis? (line 20) | def travis?
      function circle? (line 24) | def circle?
      function drone? (line 28) | def drone?
      function github? (line 32) | def github?

FILE: spec/support/platform/db.rb
  type Platform (line 3) | module Platform
    type Db (line 4) | module Db
      function db? (line 5) | def self.db?(name)
      function current (line 9) | def self.current

FILE: spec/support/platform/engine.rb
  type Platform (line 5) | module Platform
    type Engine (line 6) | module Engine
      function engine? (line 7) | def self.engine?(name)
      function current (line 11) | def self.current
      function ruby? (line 20) | def ruby?
      function jruby? (line 24) | def jruby?

FILE: spec/support/platform/matcher.rb
  type Platform (line 5) | module Platform
    class Matcher (line 6) | class Matcher
      class Nope (line 7) | class Nope < Hanami::Utils::BasicObject
        method or (line 8) | def or(other, &blk)
        method method_missing (line 14) | def method_missing(*)
      method match (line 21) | def self.match(&blk)
      method match? (line 27) | def self.match?(os: Os.current, ci: Ci.current, engine: Engine.curre...
      method initialize (line 33) | def initialize
      method os (line 37) | def os(name, &blk)
      method ci (line 43) | def ci(name, &blk)
      method engine (line 49) | def engine(name, &blk)
      method db (line 55) | def db(name, &blk)
      method default (line 61) | def default(&blk)
      method match (line 67) | def match(&blk)
      method nope (line 71) | def nope
      method yep (line 75) | def yep
      method resolve (line 79) | def resolve
      method os? (line 83) | def os?(name)
      method ci? (line 87) | def ci?(name)
      method engine? (line 91) | def engine?(name)
      method db? (line 95) | def db?(name)

FILE: spec/support/platform/os.rb
  type Platform (line 5) | module Platform
    type Os (line 6) | module Os
      function os? (line 7) | def self.os?(name)
      function current (line 11) | def self.current

FILE: spec/support/test_io.rb
  type TestIO (line 3) | module TestIO
    function with_stdout (line 4) | def self.with_stdout
    function stream (line 13) | def self.stream

FILE: spec/unit/hanami/entity/automatic_schema_spec.rb
  function to_hash (line 9) | def to_hash

FILE: spec/unit/hanami/entity/manual_schema/base_spec.rb
  function to_hash (line 9) | def to_hash

FILE: spec/unit/hanami/entity/manual_schema/strict_spec.rb
  function to_hash (line 9) | def to_hash

FILE: spec/unit/hanami/entity/schemaless_spec.rb
  function to_hash (line 11) | def to_hash

FILE: spec/unit/hanami/model/migrator/mysql.rb
  function prepare_migrations_directory (line 457) | def prepare_migrations_directory
  function clean_migrations (line 462) | def clean_migrations

FILE: spec/unit/hanami/model/migrator/postgresql.rb
  function prepare_migrations_directory (line 535) | def prepare_migrations_directory
  function clean_migrations (line 540) | def clean_migrations

FILE: spec/unit/hanami/model/migrator/sqlite.rb
  function prepare_migrations_directory (line 409) | def prepare_migrations_directory
  function clean_migrations (line 414) | def clean_migrations

FILE: spec/unit/hanami/model/sql/schema/array_spec.rb
  function to_ary (line 8) | def to_ary

FILE: spec/unit/hanami/model/sql/schema/date_spec.rb
  function to_date (line 8) | def to_date

FILE: spec/unit/hanami/model/sql/schema/date_time_spec.rb
  function to_datetime (line 8) | def to_datetime

FILE: spec/unit/hanami/model/sql/schema/decimal_spec.rb
  function to_d (line 8) | def to_d

FILE: spec/unit/hanami/model/sql/schema/float_spec.rb
  function to_f (line 8) | def to_f

FILE: spec/unit/hanami/model/sql/schema/hash_spec.rb
  function to_hash (line 8) | def to_hash

FILE: spec/unit/hanami/model/sql/schema/int_spec.rb
  function to_int (line 8) | def to_int

FILE: spec/unit/hanami/model/sql/schema/time_spec.rb
  function to_time (line 8) | def to_time