researchable-freedcamp-api 0.1.0

data/researchable_freedcamp_api.gemspec

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require_relative 'lib/researchable/freedcamp_api/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'researchable-freedcamp-api'
+  spec.version       = Researchable::FreedcampApi::VERSION
+  spec.authors       = ['Frank Blaauw']
+  spec.email         = ['f.j.blaauw@researchable.nl']
+  spec.summary       = 'Freedcamp API gem'
+  spec.description   = 'Wrapper around the freedcamp api'
+  spec.homepage      = 'https://researchable.nl'
+  spec.license       = 'MIT'
+  spec.required_ruby_version = Gem::Requirement.new('>= 2.4.0')
+
+  spec.metadata['allowed_push_host'] = 'https://rubygems.org'
+
+  spec.metadata['homepage_uri'] = spec.homepage
+  spec.metadata['source_code_uri'] = 'https://gitlab.com/researchable/open-source/api-gems/freedcamp-api-gem'
+  spec.metadata['changelog_uri'] = 'https://gitlab.com/researchable/open-source/api-gems/freedcamp-api-gem'
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{\A(?:test|spec|features)/}) }
+  end
+  spec.bindir        = 'bin'
+  spec.executables   = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  # Uncomment to register a new dependency of your gem
+  # spec.add_dependency "example-gem", "~> 1.0"
+
+  # For more information and examples about making a new gem, checkout our
+  # guide at: https://bundler.io/guides/creating_gem.html
+  spec.add_dependency 'active_interaction', '>= 3.2'
+  spec.add_dependency 'httparty',           '>= 0.14'
+  spec.add_dependency 'sorbet-runtime' 
+
+  spec.add_development_dependency 'bundler', '>0'
+  spec.add_development_dependency 'rspec', '~> 3.0'
+  spec.add_development_dependency 'sorbet'
+  spec.add_development_dependency 'byebug'
+end

data/sorbet/config

@@ -0,0 +1,3 @@
+--dir
+.
+--ignore=/vendor/bundle

data/sorbet/rbi/gems/active_interaction.rbi

@@ -0,0 +1,304 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   srb rbi gems
+
+# typed: ignore
+#
+# If you would like to make changes to this file, great! Please create the gem's shim here:
+#
+#   https://github.com/sorbet/sorbet-typed/new/master?filename=lib/active_interaction/all/active_interaction.rbi
+#
+# active_interaction-4.1.0
+
+module ActiveInteraction
+end
+class ActiveInteraction::Error < StandardError
+end
+class ActiveInteraction::InvalidNameError < ActiveInteraction::Error
+end
+class ActiveInteraction::InvalidConverterError < ActiveInteraction::Error
+end
+class ActiveInteraction::InvalidDefaultError < ActiveInteraction::Error
+end
+class ActiveInteraction::InvalidFilterError < ActiveInteraction::Error
+end
+class ActiveInteraction::InvalidInteractionError < ActiveInteraction::Error
+  def interaction; end
+  def interaction=(arg0); end
+end
+class ActiveInteraction::InvalidValueError < ActiveInteraction::Error
+end
+class ActiveInteraction::MissingFilterError < ActiveInteraction::Error
+end
+class ActiveInteraction::MissingValueError < ActiveInteraction::Error
+end
+class ActiveInteraction::NoDefaultError < ActiveInteraction::Error
+end
+class ActiveInteraction::InvalidNestedValueError < ActiveInteraction::InvalidValueError
+  def filter_name; end
+  def initialize(filter_name, input_value); end
+  def input_value; end
+end
+class ActiveInteraction::Interrupt < ActiveInteraction::Error
+  def errors; end
+  def initialize(errors); end
+end
+class ActiveInteraction::Errors < ActiveModel::Errors
+  def attribute?(attribute); end
+  def backtrace; end
+  def backtrace=(arg0); end
+  def detailed_error?(detail); end
+  def merge!(other); end
+  def merge_detail!(attribute, detail, message); end
+  def merge_details!(other); end
+  def merge_message!(attribute, message); end
+end
+module ActiveInteraction::ActiveModelable
+  def i18n_scope; end
+  def model_name(*args, &block); end
+  def new_record?; end
+  def persisted?; end
+  extend ActiveModel::Naming
+  extend ActiveSupport::Concern
+  include ActiveModel::Conversion
+  include ActiveModel::Validations
+end
+module ActiveInteraction::ActiveModelable::ClassMethods
+  def i18n_scope; end
+end
+module ActiveInteraction::ActiveRecordable
+  def column_for_attribute(name); end
+  def has_attribute?(name); end
+end
+module ActiveInteraction::Hashable
+  def hash(*args, &block); end
+  extend ActiveSupport::Concern
+end
+module ActiveInteraction::Missable
+  def filter(slug); end
+  def method_missing(slug, *args); end
+  def respond_to_missing?(slug, *arg1); end
+  extend ActiveSupport::Concern
+end
+module ActiveInteraction::Runnable
+  def compose(other, *args); end
+  def errors; end
+  def execute; end
+  def result; end
+  def result=(result); end
+  def run!; end
+  def run; end
+  def valid?(*arg0); end
+  extend ActiveSupport::Concern
+  include ActiveModel::Validations
+end
+module ActiveInteraction::Runnable::ClassMethods
+  def new(*arg0); end
+  def run!(*args); end
+  def run(*args); end
+end
+class ActiveInteraction::GroupedInput < OpenStruct
+end
+class ActiveInteraction::Inputs < Anonymous_Delegator_1
+  def initialize(inputs = nil); end
+  def self.assign_to_grouped_input!(inputs, key, index, value); end
+  def self.keys_for_group?(keys, group_key); end
+  def self.normalize_inputs!(inputs); end
+  def self.process(inputs); end
+  def self.reserved?(name); end
+end
+module ActiveInteraction::Validation
+  def self.type(filter); end
+  def self.validate(context, filters, inputs); end
+end
+class ActiveInteraction::FilterColumn
+  def initialize(type); end
+  def limit; end
+  def number?; end
+  def self.intern(type); end
+  def self.new(*arg0); end
+  def text?; end
+  def type; end
+end
+class ActiveInteraction::Filter
+  def accepts_grouped_inputs?; end
+  def adjust_output(value, _context); end
+  def cast(value, context, convert: nil, reconstantize: nil); end
+  def clean(value, context); end
+  def convert(value); end
+  def database_column_type; end
+  def default(context = nil); end
+  def default?; end
+  def desc; end
+  def describe(value); end
+  def filters; end
+  def initialize(name, options = nil, &block); end
+  def klass; end
+  def matches?(_value); end
+  def name; end
+  def options; end
+  def raw_default(context); end
+  def self.factory(slug); end
+  def self.register(slug); end
+  def self.slug; end
+end
+class ActiveInteraction::Base
+  def __callbacks; end
+  def __callbacks?; end
+  def _execute_callbacks; end
+  def _run_execute_callbacks(&block); end
+  def _run_type_check_callbacks(&block); end
+  def _run_validate_callbacks(&block); end
+  def _type_check_callbacks; end
+  def _validate_callbacks; end
+  def _validators; end
+  def _validators?; end
+  def given?(input, *rest); end
+  def initialize(inputs = nil); end
+  def inputs; end
+  def model_name(*args, &block); end
+  def populate_filters_and_inputs(inputs); end
+  def run_validations!; end
+  def self.__callbacks; end
+  def self.__callbacks=(value); end
+  def self.__callbacks?; end
+  def self._execute_callbacks; end
+  def self._execute_callbacks=(value); end
+  def self._type_check_callbacks; end
+  def self._type_check_callbacks=(value); end
+  def self._validate_callbacks; end
+  def self._validate_callbacks=(value); end
+  def self._validators; end
+  def self._validators=(value); end
+  def self._validators?; end
+  def self.add_filter(klass, name, options, &block); end
+  def self.desc(desc = nil); end
+  def self.eagerly_evaluate_default(filter); end
+  def self.filters; end
+  def self.import_filters(klass, options = nil); end
+  def self.inherited(klass); end
+  def self.initialize_filter(filter); end
+  def self.method_missing(*args, &block); end
+  def type_check; end
+  def validation_context; end
+  def validation_context=(arg0); end
+  extend ActiveInteraction::ActiveModelable::ClassMethods
+  extend ActiveInteraction::Runnable::ClassMethods
+  extend ActiveModel::Callbacks
+  extend ActiveModel::Conversion::ClassMethods
+  extend ActiveModel::Naming
+  extend ActiveModel::Translation
+  extend ActiveModel::Validations::ClassMethods
+  extend ActiveModel::Validations::HelperMethods
+  extend ActiveSupport::Callbacks::ClassMethods
+  extend ActiveSupport::DescendantsTracker
+  include ActiveInteraction::ActiveModelable
+  include ActiveInteraction::ActiveRecordable
+  include ActiveInteraction::Runnable
+  include ActiveModel::Conversion
+  include ActiveModel::Validations
+  include ActiveModel::Validations
+  include ActiveModel::Validations::HelperMethods
+  include ActiveSupport::Callbacks
+end
+class ActiveInteraction::InterfaceFilter < ActiveInteraction::Filter
+  def checking_class_inheritance?(object, from); end
+  def class_inherits_from?(klass, inherits_from); end
+  def from; end
+  def initialize(name, options = nil, &block); end
+  def matches?(object); end
+  def matches_methods?(object); end
+  def singleton_ancestor?(object, from); end
+end
+class ActiveInteraction::AbstractDateTimeFilter < ActiveInteraction::Filter
+  def accepts_grouped_inputs?; end
+  def convert(value); end
+  def convert_grouped_input(value); end
+  def convert_string(value); end
+  def database_column_type; end
+  def format; end
+  def format?; end
+  def klasses; end
+  def matches?(value); end
+end
+class ActiveInteraction::AbstractNumericFilter < ActiveInteraction::Filter
+  def convert(value); end
+  def converter(value); end
+  def database_column_type; end
+  def matches?(value); end
+  def safe_converter(value); end
+end
+class ActiveInteraction::ArrayFilter < ActiveInteraction::Filter
+  def add_option_in_place_of_name(klass, options); end
+  def adjust_output(value, context); end
+  def convert(value); end
+  def klasses; end
+  def matches?(value); end
+  def method_missing(*arg0, &block); end
+  def validate!(names); end
+  include ActiveInteraction::Missable
+end
+class ActiveInteraction::BooleanFilter < ActiveInteraction::Filter
+  def convert(value); end
+  def database_column_type; end
+  def matches?(value); end
+end
+class ActiveInteraction::DateFilter < ActiveInteraction::AbstractDateTimeFilter
+end
+class ActiveInteraction::DateTimeFilter < ActiveInteraction::AbstractDateTimeFilter
+  def database_column_type; end
+end
+class ActiveInteraction::DecimalFilter < ActiveInteraction::AbstractNumericFilter
+  def converter(value); end
+  def digits; end
+  def klass; end
+end
+class ActiveInteraction::FileFilter < ActiveInteraction::Filter
+  def database_column_type; end
+  def matches?(object); end
+end
+class ActiveInteraction::FloatFilter < ActiveInteraction::AbstractNumericFilter
+end
+class ActiveInteraction::HashFilter < ActiveInteraction::Filter
+  def adjust_output(value, context); end
+  def clean_value(hash, name, filter, value, context); end
+  def convert(value); end
+  def matches?(value); end
+  def method_missing(*args, &block); end
+  def raw_default(*arg0); end
+  def strip?; end
+  include ActiveInteraction::Missable
+end
+class ActiveInteraction::IntegerFilter < ActiveInteraction::AbstractNumericFilter
+  def base; end
+  def converter(value); end
+end
+class ActiveInteraction::ObjectFilter < ActiveInteraction::Filter
+  def convert(value); end
+  def converter(value); end
+  def klass; end
+  def matches?(value); end
+end
+class ActiveInteraction::RecordFilter < ActiveInteraction::Filter
+  def convert(value); end
+  def find(klass, value, finder); end
+  def klass; end
+  def matches?(value); end
+end
+class ActiveInteraction::StringFilter < ActiveInteraction::Filter
+  def adjust_output(value, _context); end
+  def convert(value); end
+  def matches?(value); end
+  def strip?; end
+end
+class ActiveInteraction::SymbolFilter < ActiveInteraction::Filter
+  def convert(value); end
+  def matches?(value); end
+end
+class ActiveInteraction::TimeFilter < ActiveInteraction::AbstractDateTimeFilter
+  def convert(value); end
+  def database_column_type; end
+  def initialize(name, options = nil, &block); end
+  def klass; end
+  def klasses; end
+  def time_with_zone?; end
+end

data/sorbet/rbi/gems/activemodel.rbi

@@ -0,0 +1,342 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   srb rbi gems
+
+# typed: strict
+#
+# If you would like to make changes to this file, great! Please create the gem's shim here:
+#
+#   https://github.com/sorbet/sorbet-typed/new/master?filename=lib/activemodel/all/activemodel.rbi
+#
+# activemodel-6.1.4.4
+
+module ActiveModel
+  def self.eager_load!; end
+  def self.gem_version; end
+  def self.version; end
+  extend ActiveSupport::Autoload
+end
+module ActiveModel::VERSION
+end
+module ActiveModel::Serializers
+  extend ActiveSupport::Autoload
+end
+class ActiveModel::Error
+  def ==(other); end
+  def attribute; end
+  def attributes_for_hash; end
+  def base; end
+  def detail; end
+  def details; end
+  def eql?(other); end
+  def full_message; end
+  def hash; end
+  def i18n_customize_full_message; end
+  def i18n_customize_full_message=(arg0); end
+  def i18n_customize_full_message?; end
+  def initialize(base, attribute, type = nil, **options); end
+  def initialize_dup(other); end
+  def inspect; end
+  def match?(attribute, type = nil, **options); end
+  def message; end
+  def options; end
+  def raw_type; end
+  def self.full_message(attribute, message, base); end
+  def self.generate_message(attribute, type, base, options); end
+  def self.i18n_customize_full_message; end
+  def self.i18n_customize_full_message=(value); end
+  def self.i18n_customize_full_message?; end
+  def strict_match?(attribute, type, **options); end
+  def type; end
+end
+class ActiveModel::NestedError < ActiveModel::Error
+  def initialize(base, inner_error, override_options = nil); end
+  def inner_error; end
+  def message(*args, &block); end
+  extend Forwardable
+end
+class ActiveModel::Errors
+  def [](attribute); end
+  def add(attribute, type = nil, **options); end
+  def add_from_legacy_details_hash(details); end
+  def added?(attribute, type = nil, options = nil); end
+  def any?(*args, &block); end
+  def as_json(options = nil); end
+  def attribute_names; end
+  def blank?(*args, &block); end
+  def clear(*args, &block); end
+  def copy!(other); end
+  def count(*args, &block); end
+  def delete(attribute, type = nil, **options); end
+  def deprecation_removal_warning(method_name, alternative_message = nil); end
+  def deprecation_rename_warning(old_method_name, new_method_name); end
+  def details; end
+  def each(&block); end
+  def empty?(*args, &block); end
+  def errors; end
+  def full_message(attribute, message); end
+  def full_messages; end
+  def full_messages_for(attribute); end
+  def generate_message(attribute, type = nil, options = nil); end
+  def group_by_attribute; end
+  def has_key?(attribute); end
+  def import(error, override_options = nil); end
+  def include?(attribute); end
+  def init_with(coder); end
+  def initialize(base); end
+  def initialize_dup(other); end
+  def key?(attribute); end
+  def keys; end
+  def marshal_load(array); end
+  def merge!(other); end
+  def messages; end
+  def messages_for(attribute); end
+  def normalize_arguments(attribute, type, **options); end
+  def objects; end
+  def of_kind?(attribute, type = nil); end
+  def size(*args, &block); end
+  def slice!(*keys); end
+  def to_a; end
+  def to_h; end
+  def to_hash(full_messages = nil); end
+  def to_xml(options = nil); end
+  def uniq!(*args, &block); end
+  def values; end
+  def where(attribute, type = nil, **options); end
+  extend Forwardable
+  include Enumerable
+end
+class ActiveModel::DeprecationHandlingMessageHash < SimpleDelegator
+  def []=(attribute, value); end
+  def delete(attribute); end
+  def initialize(errors); end
+  def prepare_content; end
+end
+class ActiveModel::DeprecationHandlingMessageArray < SimpleDelegator
+  def <<(message); end
+  def clear; end
+  def initialize(content, errors, attribute); end
+end
+class ActiveModel::DeprecationHandlingDetailsHash < SimpleDelegator
+  def initialize(details); end
+end
+class ActiveModel::StrictValidationFailed < StandardError
+end
+class ActiveModel::RangeError < RangeError
+end
+class ActiveModel::UnknownAttributeError < NoMethodError
+  def attribute; end
+  def initialize(record, attribute); end
+  def record; end
+end
+module ActiveModel::Conversion
+  def to_key; end
+  def to_model; end
+  def to_param; end
+  def to_partial_path; end
+  extend ActiveSupport::Concern
+end
+module ActiveModel::Conversion::ClassMethods
+  def _to_partial_path; end
+end
+module ActiveModel::Validations
+  def errors; end
+  def initialize_dup(other); end
+  def invalid?(context = nil); end
+  def raise_validation_error; end
+  def read_attribute_for_validation(*arg0); end
+  def run_validations!; end
+  def valid?(context = nil); end
+  def validate!(context = nil); end
+  def validate(context = nil); end
+  def validates_with(*args, &block); end
+  extend ActiveSupport::Concern
+end
+module ActiveModel::Validations::Callbacks
+  def run_validations!; end
+  extend ActiveSupport::Concern
+end
+module ActiveModel::Validations::Callbacks::ClassMethods
+  def after_validation(*args, &block); end
+  def before_validation(*args, &block); end
+  def set_options_for_callback(options); end
+end
+class ActiveModel::Validator
+  def initialize(options = nil); end
+  def kind; end
+  def options; end
+  def self.kind; end
+  def validate(record); end
+end
+class ActiveModel::EachValidator < ActiveModel::Validator
+  def attributes; end
+  def check_validity!; end
+  def initialize(options); end
+  def prepare_value_for_validation(value, record, attr_name); end
+  def validate(record); end
+  def validate_each(record, attribute, value); end
+end
+class ActiveModel::BlockValidator < ActiveModel::EachValidator
+  def initialize(options, &block); end
+  def validate_each(record, attribute, value); end
+end
+class ActiveModel::Validations::ConfirmationValidator < ActiveModel::EachValidator
+  def confirmation_value_equal?(record, attribute, value, confirmed); end
+  def initialize(options); end
+  def setup!(klass); end
+  def validate_each(record, attribute, value); end
+end
+module ActiveModel::Validations::HelperMethods
+  def _merge_attributes(attr_names); end
+  def validates_absence_of(*attr_names); end
+  def validates_acceptance_of(*attr_names); end
+  def validates_confirmation_of(*attr_names); end
+  def validates_exclusion_of(*attr_names); end
+  def validates_format_of(*attr_names); end
+  def validates_inclusion_of(*attr_names); end
+  def validates_length_of(*attr_names); end
+  def validates_numericality_of(*attr_names); end
+  def validates_presence_of(*attr_names); end
+  def validates_size_of(*attr_names); end
+end
+module ActiveModel::Validations::Clusivity
+  def check_validity!; end
+  def delimiter; end
+  def include?(record, value); end
+  def inclusion_method(enumerable); end
+end
+class ActiveModel::Validations::ExclusionValidator < ActiveModel::EachValidator
+  def validate_each(record, attribute, value); end
+  include ActiveModel::Validations::Clusivity
+end
+class ActiveModel::Validations::FormatValidator < ActiveModel::EachValidator
+  def check_options_validity(name); end
+  def check_validity!; end
+  def option_call(record, name); end
+  def record_error(record, attribute, name, value); end
+  def regexp_using_multiline_anchors?(regexp); end
+  def validate_each(record, attribute, value); end
+end
+class ActiveModel::Validations::PresenceValidator < ActiveModel::EachValidator
+  def validate_each(record, attr_name, value); end
+end
+class ActiveModel::Validations::AcceptanceValidator < ActiveModel::EachValidator
+  def acceptable_option?(value); end
+  def initialize(options); end
+  def setup!(klass); end
+  def validate_each(record, attribute, value); end
+end
+class ActiveModel::Validations::AcceptanceValidator::LazilyDefineAttributes < Module
+  def ==(other); end
+  def attributes; end
+  def define_on(klass); end
+  def included(klass); end
+  def initialize(attributes); end
+  def matches?(method_name); end
+end
+class ActiveModel::Validations::WithValidator < ActiveModel::EachValidator
+  def validate_each(record, attr, val); end
+end
+module ActiveModel::Validations::ClassMethods
+  def _parse_validates_options(options); end
+  def _validates_default_keys; end
+  def attribute_method?(attribute); end
+  def clear_validators!; end
+  def inherited(base); end
+  def validate(*args, &block); end
+  def validates!(*attributes); end
+  def validates(*attributes); end
+  def validates_each(*attr_names, &block); end
+  def validates_with(*args, &block); end
+  def validators; end
+  def validators_on(*attributes); end
+end
+class ActiveModel::Validations::LengthValidator < ActiveModel::EachValidator
+  def check_validity!; end
+  def initialize(options); end
+  def skip_nil_check?(key); end
+  def validate_each(record, attribute, value); end
+end
+class ActiveModel::Validations::NumericalityValidator < ActiveModel::EachValidator
+  def allow_only_integer?(record); end
+  def check_validity!; end
+  def filtered_options(value); end
+  def is_hexadecimal_literal?(raw_value); end
+  def is_integer?(raw_value); end
+  def is_number?(raw_value, precision, scale); end
+  def parse_as_number(raw_value, precision, scale); end
+  def parse_float(raw_value, precision, scale); end
+  def prepare_value_for_validation(value, record, attr_name); end
+  def record_attribute_changed_in_place?(record, attr_name); end
+  def round(raw_value, scale); end
+  def validate_each(record, attr_name, value, precision: nil, scale: nil); end
+end
+class ActiveModel::Validations::AbsenceValidator < ActiveModel::EachValidator
+  def validate_each(record, attr_name, value); end
+end
+class ActiveModel::Validations::InclusionValidator < ActiveModel::EachValidator
+  def validate_each(record, attribute, value); end
+  include ActiveModel::Validations::Clusivity
+end
+class ActiveModel::ValidationError < StandardError
+  def initialize(model); end
+  def model; end
+end
+class ActiveModel::Name
+  def !~(*args, &block); end
+  def <=>(*args, &block); end
+  def ==(arg); end
+  def ===(arg); end
+  def =~(*args, &block); end
+  def _singularize(string); end
+  def as_json(*args, &block); end
+  def cache_key; end
+  def collection; end
+  def collection=(arg0); end
+  def element; end
+  def element=(arg0); end
+  def eql?(*args, &block); end
+  def human(options = nil); end
+  def i18n_key; end
+  def i18n_key=(arg0); end
+  def initialize(klass, namespace = nil, name = nil); end
+  def match?(*args, &block); end
+  def name; end
+  def name=(arg0); end
+  def param_key; end
+  def param_key=(arg0); end
+  def plural; end
+  def plural=(arg0); end
+  def route_key; end
+  def route_key=(arg0); end
+  def singular; end
+  def singular=(arg0); end
+  def singular_route_key; end
+  def singular_route_key=(arg0); end
+  def to_s(*args, &block); end
+  def to_str(*args, &block); end
+  include Comparable
+end
+module ActiveModel::Naming
+  def model_name; end
+  def self.extended(base); end
+  def self.model_name_from_record_or_class(record_or_class); end
+  def self.param_key(record_or_class); end
+  def self.plural(record_or_class); end
+  def self.route_key(record_or_class); end
+  def self.singular(record_or_class); end
+  def self.singular_route_key(record_or_class); end
+  def self.uncountable?(record_or_class); end
+end
+module ActiveModel::Callbacks
+  def _define_after_model_callback(klass, callback); end
+  def _define_around_model_callback(klass, callback); end
+  def _define_before_model_callback(klass, callback); end
+  def define_model_callbacks(*callbacks); end
+  def self.extended(base); end
+end
+module ActiveModel::Translation
+  def human_attribute_name(attribute, options = nil); end
+  def i18n_scope; end
+  def lookup_ancestors; end
+  include ActiveModel::Naming
+end