infer_model 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: beae3b14bb858f6f8d597788daa62d18ab9246d4ccc81e8d862f08b5e6bcf99f
+  data.tar.gz: 9856dc12362b8f109260e272b2a392d61a3a54c22f02085ffe3146d35acd5ebf
+SHA512:
+  metadata.gz: 49929b9598e50253e0eff456bd7a73894d782d95fb82fe90f5dd5c73bcd13eb2a59b4cb86da983b735b236652d9944f10370c35d6dd60265e0183f007cb0a177
+  data.tar.gz: 61c7a94a1f691dad8f6e3999cfcb876472e92c0ca4bf566f1e33d9d567d5835531a97743425317900fa0067664deaeab5ea244e5f3101c13b46ab338b9e8ac3f

data/.rubocop.yml

@@ -0,0 +1,105 @@
+require:
+  - 'rubocop-performance'
+
+AllCops:
+  Exclude:
+    - bin/**/* # Let gems do their stuff
+    - vendor/bundle/**/* # Let gems do their stuff
+    - .pryrc # Do what you want here
+    - tmp/**/* # Do what you want here
+    - doc/**/*
+    - node_modules/**/*
+  NewCops: enable
+
+###
+
+# Disable or configure cops with reasons:
+
+Layout/LineLength:
+  Enabled: false # Disabled as it would require heavy refactoring in most codebases. Feel free to enable it for your project!
+
+# Alignment-cops. Settings aim to avoid deep indentations and diff noise.
+Layout/FirstArgumentIndentation:
+  EnforcedStyle: consistent
+Layout/FirstArrayElementIndentation:
+  EnforcedStyle: consistent
+Layout/FirstHashElementIndentation:
+  EnforcedStyle: consistent
+Layout/MultilineMethodCallIndentation:
+  EnforcedStyle: indented
+Layout/ArgumentAlignment:
+  EnforcedStyle: with_fixed_indentation
+Layout/CaseIndentation:
+  EnforcedStyle: end
+Layout/EndAlignment:
+  EnforcedStyleAlignWith: start_of_line
+
+Layout/EmptyLineAfterGuardClause:
+  Enabled: false # Methods should be short anyway, so that a guard clause will be visible enough without an empty line
+
+Style/ClassAndModuleChildren: # Each version has its own benefits depending on the situation
+  Enabled: false
+Style/Documentation: # We currently do not enforce documentation. Do it where you feel it is useful!
+  Enabled: false
+Style/EmptyMethod: # Do not allow `def foo; end` for empty methods as semicolons are discouraged in ruby
+  EnforcedStyle: expanded
+Style/FrozenStringLiteralComment: # Might be enabled in the future
+  Enabled: false
+Style/Lambda: # Always use `->` instead of `lambda`, as the latter does not work with `do ... end` and we do not want to use `{ ... }` for multiline-blocks (see https://github.com/rubocop-hq/rubocop/issues/1520)
+  EnforcedStyle: literal
+Style/NumericPredicate: # Sometimes "== 0" is easier to read than .zero?
+  Enabled: false
+Style/StringLiterals:
+  EnforcedStyle: double_quotes # Avoids having to change quotes when adding interpolation to a string.
+Style/StringLiteralsInInterpolation:
+  EnforcedStyle: double_quotes
+Style/TrailingCommaInArguments:
+  EnforcedStyleForMultiline: consistent_comma # Makes it easier to swap lines and avoids noise in diffs
+Style/TrailingCommaInArrayLiteral:
+  EnforcedStyleForMultiline: consistent_comma # Makes it easier to swap lines and avoids noise in diffs
+Style/TrailingCommaInHashLiteral:
+  EnforcedStyleForMultiline: consistent_comma # Makes it easier to swap lines and avoids noise in diffs
+
+###
+
+# Tune metrics cops
+
+# Background: metrics cops, although they are sometimes annoying, give you a stimulus to think about the complexity of the code.
+# So, while it is true that good code style is best ensured by peer review, pair programming or ensemble (mob) programming, it's
+# good that the metrics cops have your back and act as a last line of defense while you are wrapping your head around other
+# aspects. Therefore we soften the default limits, so that the cops are not too whiny and annoy the developers, but we keep them
+# enabled.
+# Recommendation: if you offend a metrics cop for good reason, disable that specific cop in the offending file only (see
+# https://docs.rubocop.org/rubocop/configuration.html#disabling-cops-within-source-code). See also the README next to this file.
+
+# Length metrics
+Metrics/ClassLength:
+  Max: 200 # 2 times of the default value of 100, above this you should really think about splitting up the class
+Metrics/ModuleLength:
+  Max: 200 # 2 times of the default value of 100, above this you should really think about splitting up the module
+Metrics/MethodLength:
+  Max: 30 # 3 times of the default value of 10, above this you should really think about splitting up the method
+  CountAsOne: ['array', 'heredoc', 'hash'] #  Do not incentivise against multi-line and in-method constants and declarative programming
+  Exclude:
+    - db/migrate/**/* # let migrations do what they need
+Metrics/BlockLength: # the default value of 25 is good
+  Exclude:
+    - config/**/* # There is no reason to artificially break up config blocks
+    - lib/tasks/**/*.rake
+    - spec/**/* # describe or context blocks may be large
+    - '*.gemspec'
+
+# Method signature complexity metrics
+Metrics/ParameterLists:
+  Max: 3 # more than 3 positional parameters get confusing, use keyword args or group input parameters in value objects instead
+  CountKeywordArgs: false # keyword args are OK, they are way more readable than positional args
+
+# Code complexity metrics
+Metrics/AbcSize:
+  Max: 43 # ~2.5 times of the default value of 17, above this your method is most likely too complex
+Metrics/CyclomaticComplexity:
+  Max: 14 # 2 times of the default value of 7, above this your method is most likely too complex
+Metrics/PerceivedComplexity:
+  Max: 12 # 1.5 times of the default value of 8, above this your method is most likely too complex
+
+###

data/.ruby-version

@@ -0,0 +1 @@
+3.1.2

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## [Unreleased]
+
+## [0.1.0] - 2022-09-04
+
+- Initial release

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,84 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+We as members, contributors, and leaders pledge to make participation in our community a harassment-free experience for everyone, regardless of age, body size, visible or invisible disability, ethnicity, sex characteristics, gender identity and expression, level of experience, education, socio-economic status, nationality, personal appearance, race, religion, or sexual identity and orientation.
+
+We pledge to act and interact in ways that contribute to an open, welcoming, diverse, inclusive, and healthy community.
+
+## Our Standards
+
+Examples of behavior that contributes to a positive environment for our community include:
+
+* Demonstrating empathy and kindness toward other people
+* Being respectful of differing opinions, viewpoints, and experiences
+* Giving and gracefully accepting constructive feedback
+* Accepting responsibility and apologizing to those affected by our mistakes, and learning from the experience
+* Focusing on what is best not just for us as individuals, but for the overall community
+
+Examples of unacceptable behavior include:
+
+* The use of sexualized language or imagery, and sexual attention or
+  advances of any kind
+* Trolling, insulting or derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or email
+  address, without their explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Enforcement Responsibilities
+
+Community leaders are responsible for clarifying and enforcing our standards of acceptable behavior and will take appropriate and fair corrective action in response to any behavior that they deem inappropriate, threatening, offensive, or harmful.
+
+Community leaders have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct, and will communicate reasons for moderation decisions when appropriate.
+
+## Scope
+
+This Code of Conduct applies within all community spaces, and also applies when an individual is officially representing the community in public spaces. Examples of representing our community include using an official e-mail address, posting via an official social media account, or acting as an appointed representative at an online or offline event.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be reported to the community leaders responsible for enforcement at jay.schneider@zweitag.de. All complaints will be reviewed and investigated promptly and fairly.
+
+All community leaders are obligated to respect the privacy and security of the reporter of any incident.
+
+## Enforcement Guidelines
+
+Community leaders will follow these Community Impact Guidelines in determining the consequences for any action they deem in violation of this Code of Conduct:
+
+### 1. Correction
+
+**Community Impact**: Use of inappropriate language or other behavior deemed unprofessional or unwelcome in the community.
+
+**Consequence**: A private, written warning from community leaders, providing clarity around the nature of the violation and an explanation of why the behavior was inappropriate. A public apology may be requested.
+
+### 2. Warning
+
+**Community Impact**: A violation through a single incident or series of actions.
+
+**Consequence**: A warning with consequences for continued behavior. No interaction with the people involved, including unsolicited interaction with those enforcing the Code of Conduct, for a specified period of time. This includes avoiding interactions in community spaces as well as external channels like social media. Violating these terms may lead to a temporary or permanent ban.
+
+### 3. Temporary Ban
+
+**Community Impact**: A serious violation of community standards, including sustained inappropriate behavior.
+
+**Consequence**: A temporary ban from any sort of interaction or public communication with the community for a specified period of time. No public or private interaction with the people involved, including unsolicited interaction with those enforcing the Code of Conduct, is allowed during this period. Violating these terms may lead to a permanent ban.
+
+### 4. Permanent Ban
+
+**Community Impact**: Demonstrating a pattern of violation of community standards, including sustained inappropriate behavior,  harassment of an individual, or aggression toward or disparagement of classes of individuals.
+
+**Consequence**: A permanent ban from any sort of public interaction within the community.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 2.0,
+available at https://www.contributor-covenant.org/version/2/0/code_of_conduct.html.
+
+Community Impact Guidelines were inspired by [Mozilla's code of conduct enforcement ladder](https://github.com/mozilla/diversity).
+
+[homepage]: https://www.contributor-covenant.org
+
+For answers to common questions about this code of conduct, see the FAQ at
+https://www.contributor-covenant.org/faq. Translations are available at https://www.contributor-covenant.org/translations.

data/Gemfile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in infer_model.gemspec
+gemspec
+
+gem "rake"

data/Gemfile.lock

@@ -0,0 +1,86 @@
+PATH
+  remote: .
+  specs:
+    infer_model (0.1.0)
+      activesupport (~> 7.0)
+      dry-initializer (~> 3.0)
+      zeitwerk (~> 2.6)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activesupport (7.0.3.1)
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      i18n (>= 1.6, < 2)
+      minitest (>= 5.1)
+      tzinfo (~> 2.0)
+    ast (2.4.2)
+    coderay (1.1.3)
+    concurrent-ruby (1.1.10)
+    diff-lcs (1.5.0)
+    dotenv (2.8.1)
+    dry-initializer (3.1.1)
+    i18n (1.12.0)
+      concurrent-ruby (~> 1.0)
+    json (2.6.2)
+    method_source (1.0.0)
+    minitest (5.16.3)
+    parallel (1.22.1)
+    parser (3.1.2.1)
+      ast (~> 2.4.1)
+    pry (0.14.1)
+      coderay (~> 1.1)
+      method_source (~> 1.0)
+    rainbow (3.1.1)
+    rake (13.0.6)
+    regexp_parser (2.5.0)
+    rexml (3.2.5)
+    rspec (3.11.0)
+      rspec-core (~> 3.11.0)
+      rspec-expectations (~> 3.11.0)
+      rspec-mocks (~> 3.11.0)
+    rspec-core (3.11.0)
+      rspec-support (~> 3.11.0)
+    rspec-expectations (3.11.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.11.0)
+    rspec-mocks (3.11.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.11.0)
+    rspec-support (3.11.0)
+    rubocop (1.36.0)
+      json (~> 2.3)
+      parallel (~> 1.10)
+      parser (>= 3.1.2.1)
+      rainbow (>= 2.2.2, < 4.0)
+      regexp_parser (>= 1.8, < 3.0)
+      rexml (>= 3.2.5, < 4.0)
+      rubocop-ast (>= 1.20.1, < 2.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (>= 1.4.0, < 3.0)
+    rubocop-ast (1.21.0)
+      parser (>= 3.1.1.0)
+    rubocop-performance (1.14.3)
+      rubocop (>= 1.7.0, < 2.0)
+      rubocop-ast (>= 0.4.0)
+    ruby-progressbar (1.11.0)
+    tzinfo (2.0.5)
+      concurrent-ruby (~> 1.0)
+    unicode-display_width (2.2.0)
+    zeitwerk (2.6.0)
+
+PLATFORMS
+  arm64-darwin-21
+  x86_64-linux
+
+DEPENDENCIES
+  dotenv (~> 2.8)
+  infer_model!
+  pry (~> 0.14)
+  rake
+  rspec (~> 3.11)
+  rubocop (~> 1.36)
+  rubocop-performance (~> 1.14)
+
+BUNDLED WITH
+   2.3.17

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2022 Jay Schneider
+
+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,89 @@
+[![Continuous Integration](https://github.com/Jay-Schneider/infer_model/actions/workflows/ci.yml/badge.svg)](https://github.com/Jay-Schneider/infer_model/actions/workflows/ci.yml)
+
+# InferModel
+
+Infer a model from data.
+
+This gem transforms data dumps into managable structures.
+
+You can use it to deduce certain properties from a given set of data to use it to build a database around this data.
+
+The main use case is:
+Given a csv file that was exported from some tool, you want to manage and process the contained data in a database, say in your rails application.
+It would be valid to create a string column for every CSV column and import the data as is but you lose a lot of information by doing so.
+
+Instead what this tool allows you to do is to guess which data type, like integer, decimal, boolean, etc, is the best fit for each column and allows you to create migrations or scripts to do so almost automatically.
+
+Additionally the values may be parsed to deduce further features of your data that may be useful when setting up a database, like uniqueness or non-null constraints.
+
+## Installation
+
+Install the gem and add to the application's Gemfile by executing:
+
+    $ bundle add infer_model
+
+If bundler is not being used to manage dependencies, install the gem by executing:
+
+    $ gem install infer_model
+
+## Usage
+
+A CLI is yet to be written. But you may run the tool from inside your code or an interactive session.
+
+### Inferring information from data
+
+Run code like the following:
+
+```ruby
+require "infer_model"
+
+# Just display the results in a human readable format
+InferModel.from(:csv, "path/to/file.csv").to(:text).call
+
+# Create a rails migration for me with the inferred information
+InferModel.from(:csv, "path/to/file.csv", csv_options: { col_sep: ";", encoding: "csp1252" }).to(:migration, rails_version: "6.0", table_name: "csv_contents").call
+```
+
+More "Adapters" that can be used as `from` source or `to` target may be added in the future. If you have ideas or needs please contribute by creating an issue or pr.
+
+### Importing data
+
+After generating a database table fitting to your data, you might want to fill them. You can use `InferModel`s parsers to do so. For example in your rails app, in an import service or seeds:
+
+```ruby
+now = Time.current
+column_types = MyModel.columns.to_h { |column| [column.name, column.type] }
+
+data = ::CSV.foreach("my_model_data.csv", col_sep: ";", encoding: "utf-8", headers: true, header_converters: :symbol).map do |row|
+    parsed_attributes = row.to_h.to_h do |column_name, value| # note the `to_h.to_h`: The first one turns the row into a hash, the second one allows building a new hash with the block. CSV::Row's #to_h method does not process the block properly.
+        column_type = column_types.fetch(column_name.to_s)
+        parser = InferModel::Parsers::BY_TYPE.fetch(column_type)
+        [column_name, parser.call(value)]
+    end
+    { created_at: now, updated_at: now }.merge(parsed_attributes)
+end
+
+MyModel.upsert_all(data) if data.present? # rubocop:disable Rails/SkipsModelValidations
+```
+
+That way you profit from the parsers logic that already generated your tables. For example the `Boolean` parser acknowledges `"Y"` as a _truthy_ value compared to `"N"` which is considered _falsey_. When you use a different parser or just attempt to insert the string value into your database, they will most likely all have `true` as value in the corresponding column just because `"N"` is considered truthy.
+
+For more information on how different parsers work, have a look inside their definition, e.g. the constants `InferModel::Parsers::Boolean::TRUTHY_VALUES_LOWERCASE` and `FALSEY_VALUES_LOWERCASE`. There might be the option to configure those values in the future.
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/Jay-Schneider/infer_model. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/Jay-Schneider/infer_model/blob/main/CODE_OF_CONDUCT.md).
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+## Code of Conduct
+
+Everyone interacting in the InferModel project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/Jay-Schneider/infer_model/blob/main/CODE_OF_CONDUCT.md).

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+task default: %i[spec rubocop]

data/infer_model.gemspec

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require_relative "lib/infer_model/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "infer_model"
+  spec.version = InferModel::VERSION
+  spec.authors = ["Jay Schneider"]
+  spec.email = ["jay.schneider@zweitag.de"]
+
+  spec.summary = "Infer data types from external sources to create a rails model for example"
+  spec.description = "This gem tries to detect the data type from given data like a csv file. You can then use this information to generate a rails migration to have a fitting model for the data."
+  spec.homepage = "https://github.com/Jay-Schneider/infer_model"
+  spec.license = "MIT"
+  spec.required_ruby_version = ">= 3.1.0"
+
+  spec.metadata = {
+    "bug_tracker_uri" => "https://github.com/Jay-Schneider/infer_model/issues",
+    "changelog_uri" => "https://github.com/Jay-Schneider/infer_model/CHANGELOG.md",
+    "homepage_uri" => spec.homepage,
+    "rubygems_mfa_required" => "true",
+    "source_code_uri" => "https://github.com/Jay-Schneider/infer_model",
+  }
+
+  # 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(__dir__) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (f == __FILE__) || f.match(%r{\A(?:(?:bin|test|spec|features)/|\.(?:git|travis|circleci)|appveyor)})
+    end
+  end
+  spec.bindir = "bin"
+  spec.executables = spec.files.grep(%r{\Abin/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "activesupport", "~> 7.0"
+  spec.add_dependency "dry-initializer", "~> 3.0"
+  spec.add_dependency "zeitwerk", "~> 2.6"
+  spec.add_development_dependency "dotenv", "~> 2.8"
+  spec.add_development_dependency "pry", "~> 0.14"
+  spec.add_development_dependency "rspec", "~> 3.11"
+  spec.add_development_dependency "rubocop", "~> 1.36"
+  spec.add_development_dependency "rubocop-performance", "~> 1.14"
+
+  # For more information and examples about making a new gem, check out our
+  # guide at: https://bundler.io/guides/creating_gem.html
+end

data/lib/infer_model/callable.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module InferModel::Callable
+  def call(...) = new(...).call
+  alias call! call
+end

data/lib/infer_model/common_type.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module InferModel
+  class CommonType
+    extend Dry::Initializer
+
+    param :possible_detected_types
+    option :unique_constraint_possible, default: -> { false }
+    option :non_null_constraint_possible, default: -> { false }
+
+    def detected_type
+      possible_detected_types.respond_to?(:first) ? possible_detected_types.first : possible_detected_types
+    end
+  end
+end

data/lib/infer_model/common_type_guesser.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module InferModel
+  class CommonTypeGuesser
+    extend Callable
+    extend Dry::Initializer
+
+    param :inputs
+    option :available_types, default: -> { ValueTypeGuesser::RESULT_TYPES }
+    option :multi, default: -> { false }
+    option :allow_blank, default: -> { true }
+    option :detect_uniqueness, default: -> { true }
+    option :detect_non_null, default: -> { true }
+
+    def call
+      inputs.each do |input|
+        @available_types = ValueTypeGuesser.call(input, allow_blank:, available_types:, multi: true)
+      end
+      possible_detected_types = multi ? available_types : available_types.first
+
+      @parsed_inputs = inputs.map { Parsers::BY_TYPE.fetch(available_types.first).call(_1) }
+
+      CommonType.new(
+        possible_detected_types,
+        unique_constraint_possible:,
+        non_null_constraint_possible:,
+      )
+    end
+
+    private
+
+    def unique_constraint_possible
+      return unless detect_uniqueness
+
+      @parsed_inputs.size == @parsed_inputs.uniq.size
+    end
+
+    def non_null_constraint_possible
+      return unless detect_non_null
+
+      @parsed_inputs.none?(&:nil?)
+    end
+  end
+end

data/lib/infer_model/from/csv.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/hash/reverse_merge"
+require "csv"
+
+module InferModel::From
+  class CSV
+    extend Dry::Initializer
+    extend InferModel::Callable
+
+    DEFAULT_CSV_OPTIONS = { col_sep: ",", encoding: "utf-8", headers: true, quote_char: "\x00" }.freeze
+
+    param :filename
+    option :available_types, default: -> { ::InferModel::ValueTypeGuesser::RESULT_TYPES }
+    option :multi, default: -> { false }
+    option :csv_options, default: -> { {} }
+
+    def call
+      ::InferModel::Model.new(source_name:, attributes:)
+    end
+
+    private
+
+    def source_name = File.basename(filename, File.extname(filename))
+
+    def attributes
+      csv.by_col!.to_h do |header, contents|
+        [
+          header.downcase.to_sym,
+          ::InferModel::CommonTypeGuesser.call(contents, available_types:),
+        ]
+      end
+    end
+
+    def csv = ::CSV.parse(file_content, **csv_options_with_defaults)
+
+    def file_content = File.read(filename)
+
+    def csv_options_with_defaults = csv_options.with_defaults(DEFAULT_CSV_OPTIONS)
+  end
+end

data/lib/infer_model/from.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+module InferModel::From
+end

data/lib/infer_model/model.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module InferModel
+  class Model
+    extend Dry::Initializer
+
+    option :source_name
+    option :attributes
+  end
+end

data/lib/infer_model/parsers/boolean.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module InferModel
+  class Parsers::Boolean
+    extend Callable
+    extend Dry::Initializer
+
+    param :value
+    option :allow_blank, default: -> { true }
+
+    TRUTHY_VALUES_LOWERCASE = %w[true t x y j + * 1].freeze
+    FALSEY_VALUES_LOWERCASE = %w[false f n - 0].freeze
+
+    def call
+      raise Parsers::Error, "value was blank which is not allowed" if value.nil? && !allow_blank
+      return if value.nil?
+      return false if value.empty?
+      return false if FALSEY_VALUES_LOWERCASE.any? { |lie| value.casecmp(lie).zero? }
+      return true if TRUTHY_VALUES_LOWERCASE.any? { |truth| value.casecmp(truth).zero? }
+
+      raise Parsers::Error, "'#{value}' is not a Boolean"
+    end
+  end
+end

data/lib/infer_model/parsers/date_time.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require "date"
+
+module InferModel
+  class Parsers::DateTime
+    extend Callable
+    extend Dry::Initializer
+
+    ACCEPTABLE_DATETIME_FORMATS = [
+      "%Y-%m-%dT%T%z",
+      "%Y-%m-%dT%T%Z",
+      "%Y-%m-%dT%TZ",
+      "%d.%m.%Y %T%z",
+      "%d.%m.%Y %T%Z",
+      "%d.%m.%Y %T",
+      "%d.%m.%Y %H:%M",
+      "%Y-%m-%dT",
+      "%Y-%m-%d",
+      "%d.%m.%Y",
+    ].freeze
+
+    param :value
+    option :allow_blank, default: -> { true }
+
+    def call
+      raise Parsers::Error, "value was blank which is not allowed" if value.nil? && !allow_blank
+      return if value.nil? || value.empty?
+
+      ACCEPTABLE_DATETIME_FORMATS.each do |format|
+        return DateTime.strptime(value, format)
+      rescue Date::Error
+        next
+      end
+
+      raise Parsers::Error, "'#{value}' is not a DateTime"
+    end
+  end
+end

data/lib/infer_model/parsers/decimal.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module InferModel
+  class Parsers::Decimal
+    extend Callable
+    extend Dry::Initializer
+
+    param :value
+    option :allow_blank, default: -> { true }
+
+    def call
+      raise Parsers::Error, "value was blank which is not allowed" if value.nil? && !allow_blank
+      return if value.nil? || value.empty?
+
+      Float(value)
+    rescue ArgumentError
+      raise Parsers::Error, "'#{value}' is not a Decimal"
+    end
+  end
+end

data/lib/infer_model/parsers/integer.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module InferModel
+  class Parsers::Integer
+    extend Callable
+    extend Dry::Initializer
+
+    param :value
+    option :allow_blank, default: -> { true }
+    option :base, default: -> { 10 }
+
+    def call
+      raise Parsers::Error, "value was blank which is not allowed" if value.nil? && !allow_blank
+      return if value.nil? || value.empty?
+
+      Integer(value, base)
+    rescue ArgumentError
+      raise Parsers::Error, "'#{value}' is not an Integer"
+    end
+  end
+end

data/lib/infer_model/parsers/json.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require "json"
+
+module InferModel
+  class Parsers::JSON
+    extend Callable
+    extend Dry::Initializer
+
+    param :value
+    option :allow_blank, default: -> { true }
+
+    def call
+      raise Parsers::Error, "value was blank which is not allowed" if value.nil? && !allow_blank
+      return if value.nil? || value.empty?
+
+      JSON.parse(value)
+    rescue JSON::ParserError
+      raise Parsers::Error, "'#{value}' is not a JSON"
+    end
+  end
+end

data/lib/infer_model/parsers/time.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "time"
+
+module InferModel
+  class Parsers::Time
+    extend Callable
+    extend Dry::Initializer
+
+    ACCEPTABLE_TIME_FORMATS = %w[%T %R].freeze
+
+    param :value
+    option :allow_blank, default: -> { true }
+
+    def call
+      raise Parsers::Error, "value was blank which is not allowed" if value.nil? && !allow_blank
+      return if value.nil? || value.empty?
+
+      ACCEPTABLE_TIME_FORMATS.each do |format|
+        return Time.strptime(value, format)
+      rescue ArgumentError
+        next
+      end
+
+      raise Parsers::Error, "'#{value}' is not a Time"
+    end
+  end
+end

data/lib/infer_model/parsers/uuid.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module InferModel
+  class Parsers::UUID
+    extend Callable
+    extend Dry::Initializer
+
+    UUID_REGEX = /\A[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\z/i
+
+    param :value
+    option :allow_blank, default: -> { true }
+
+    def call
+      raise Parsers::Error, "value was blank which is not allowed" if value.nil? && !allow_blank
+      return if value.nil? || value.empty?
+      return value if UUID_REGEX.match?(value)
+
+      raise Parsers::Error, "'#{value}' is not a UUID"
+    end
+  end
+end

data/lib/infer_model/parsers.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module InferModel
+  module Parsers
+    Error = Class.new(StandardError)
+
+    BY_TYPE = {
+      boolean: Boolean,
+      datetime: DateTime,
+      decimal: Decimal,
+      integer: Integer,
+      json: JSON,
+      time: Time,
+      uuid: UUID,
+      string: ->(*args, **_opts) { args[0] },
+    }.freeze
+  end
+end

data/lib/infer_model/task.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module InferModel
+  class Task
+    FROMS = { csv: ::InferModel::From::CSV }.freeze
+    TOS = {
+      migration: ::InferModel::To::Migration,
+      text: ::InferModel::To::Text,
+    }.freeze
+
+    attr_reader :from_object, :from_args, :from_opts, :to_object, :to_args, :to_opts
+
+    def from(from_object, *args, **opts)
+      @from_object = from_object
+      @from_object = FROMS.fetch(from_object) if FROMS.key?(from_object)
+      @from_args = args
+      @from_opts = opts
+      self
+    end
+
+    def to(to_object, *args, **opts)
+      @to_object = to_object
+      @to_object = TOS.fetch(to_object) if TOS.key?(to_object)
+      @to_args = args
+      @to_opts = opts
+      self
+    end
+
+    def call
+      to_object.call(from_object.call(*from_args, **from_opts), *to_args, **to_opts)
+    end
+
+    class << self
+      def from(...) = new.from(...)
+      def to(...) = new.to(...)
+    end
+  end
+end

data/lib/infer_model/to/migration.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/string/inflections"
+
+module InferModel::To
+  class Migration
+    extend Dry::Initializer
+    extend InferModel::Callable
+
+    TIMESTAMP_FORMAT = "%Y%m%d%H%M%S"
+
+    param :model
+    option :target_dir, default: -> { "db/migrate" }
+    option :table_name, optional: true
+    option :rails_version, default: -> { "7.0" }
+
+    def call
+      FileUtils.mkdir_p(target_dir)
+      File.write(migration_filename, migration_content)
+    end
+
+    private
+
+    def migration_filename
+      timestamp = Time.now.localtime.strftime(TIMESTAMP_FORMAT)
+      File.join(target_dir, "#{timestamp}_create_#{given_or_inferred_tablename}.rb")
+    end
+
+    def given_or_inferred_tablename
+      table_name || model.source_name.pluralize
+    end
+
+    def migration_content
+      <<~RUBY
+        # frozen_string_literal: true
+
+        class Create#{given_or_inferred_tablename.camelize} < ActiveRecord::Migration[#{rails_version}]
+          def change
+            create_table "#{given_or_inferred_tablename}" do |t|
+              #{column_ddl_lines}
+
+              t.timestamps
+            end
+          end
+        end
+      RUBY
+    end
+
+    COLUMN_DDL_LINES_WITH_INDENTATION_JOINER = "\n#{"  " * 3}".freeze
+
+    def column_ddl_lines
+      column_definitions = model.attributes.map do |key, common_type|
+        attribute_and_name = %(t.#{common_type.detected_type} "#{key}")
+        non_null_constraint = common_type.non_null_constraint_possible ? "null: false" : nil
+
+        [attribute_and_name, non_null_constraint].compact.join(", ")
+      end
+      index_definitions = model.attributes.filter_map do |key, common_type|
+        next unless common_type.unique_constraint_possible
+
+        %(t.index ["#{key}"], unique: true)
+      end
+
+      (column_definitions + index_definitions).join(COLUMN_DDL_LINES_WITH_INDENTATION_JOINER)
+    end
+  end
+end

data/lib/infer_model/to/text.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module InferModel::To
+  class Text
+    extend Dry::Initializer
+    extend InferModel::Callable
+
+    param :model
+    option :outstream, default: -> { $stdout }
+
+    def call
+      outstream << <<~TEXT
+        #{title}
+        #{formatted_attributes.join("\n\n")}
+      TEXT
+    end
+
+    private
+
+    def title
+      source_name_line = "Source Name: '#{model.source_name}'"
+      <<~TEXT
+        #{source_name_line}
+        #{"#" * source_name_line.size}
+
+        Attributes:
+        -----------
+      TEXT
+    end
+
+    def formatted_attributes
+      model.attributes.map do |attr_name, common_type|
+        formatted_attribute(attr_name, common_type)
+      end
+    end
+
+    def formatted_attribute(attr_name, common_type)
+      attr_____string = "#{attr_name}:"
+      type_____string = "  Type:     #{common_type.detected_type}"
+      unique___string = "  Unique:   contains only unique values" if common_type.unique_constraint_possible
+      non_null_string = "  Non null: does not contain empty values" if common_type.non_null_constraint_possible
+      [
+        attr_____string,
+        type_____string,
+        unique___string,
+        non_null_string,
+      ].compact.join("\n")
+    end
+  end
+end

data/lib/infer_model/to.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+module InferModel::To
+end

data/lib/infer_model/value_type_guesser.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module InferModel
+  class ValueTypeGuesser
+    extend Callable
+    extend Dry::Initializer
+
+    param :input
+    option :available_types, default: -> { RESULT_TYPES }
+    option :multi, default: -> { false }
+    option :allow_blank, default: -> { true }
+
+    INTEGER_RESULT = :integer # bigint included
+    DECIMAL_RESULT = :decimal # float included
+    DATETIME_RESULT = :datetime # date included
+    TIME_RESULT = :time
+    BOOLEAN_RESULT = :boolean
+    JSON_RESULT = :json
+    UUID_RESULT = :uuid
+    STRING_RESULT = :string # text included
+    RESULT_TYPES = [ # ordered by specifity (string should come last, integer before decimal etc.)
+      INTEGER_RESULT,
+      DECIMAL_RESULT,
+      BOOLEAN_RESULT,
+      TIME_RESULT,
+      DATETIME_RESULT,
+      JSON_RESULT,
+      UUID_RESULT,
+      STRING_RESULT,
+    ].freeze
+
+    def call
+      raise Error, "Provide strings only for guessing the type" unless input.is_a?(String) || input.nil?
+      if multi
+        ordered_available_known_types.filter { |type| may_be?(type) }
+      else
+        ordered_available_known_types.find { |type| may_be?(type) }
+      end
+    end
+
+    private
+
+    def ordered_available_known_types
+      RESULT_TYPES & available_types
+    end
+
+    def may_be?(type)
+      type = type.to_s.downcase.to_sym
+      raise ArgumentError, "unknown type '#{type}'" unless InferModel::Parsers::BY_TYPE.key?(type)
+
+      InferModel::Parsers::BY_TYPE.fetch(type).call(input, allow_blank:) || true # false is allowed for boolean
+    rescue Parsers::Error
+      false
+    end
+  end
+end

data/lib/infer_model/version.rb

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

data/lib/infer_model.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+# libraries
+require "dotenv/load"
+require "dry-initializer"
+require "pry"
+require "zeitwerk"
+
+loader = Zeitwerk::Loader.for_gem
+loader.inflector.inflect("csv" => "CSV", "json" => "JSON", "uuid" => "UUID")
+loader.setup
+
+module InferModel
+  class Error < StandardError; end
+
+  class << self
+    def from(...) = Task.from(...)
+    def to(...) = Task.to(...)
+  end
+end

data/sig/infer_model.rbs

@@ -0,0 +1,4 @@
+module InferModel
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -0,0 +1,194 @@
+--- !ruby/object:Gem::Specification
+name: infer_model
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Jay Schneider
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2022-09-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '7.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '7.0'
+- !ruby/object:Gem::Dependency
+  name: dry-initializer
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: zeitwerk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.6'
+- !ruby/object:Gem::Dependency
+  name: dotenv
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.8'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.14'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.14'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.11'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.36'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.36'
+- !ruby/object:Gem::Dependency
+  name: rubocop-performance
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.14'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.14'
+description: This gem tries to detect the data type from given data like a csv file.
+  You can then use this information to generate a rails migration to have a fitting
+  model for the data.
+email:
+- jay.schneider@zweitag.de
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rubocop.yml"
+- ".ruby-version"
+- CHANGELOG.md
+- CODE_OF_CONDUCT.md
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- infer_model.gemspec
+- lib/infer_model.rb
+- lib/infer_model/callable.rb
+- lib/infer_model/common_type.rb
+- lib/infer_model/common_type_guesser.rb
+- lib/infer_model/from.rb
+- lib/infer_model/from/csv.rb
+- lib/infer_model/model.rb
+- lib/infer_model/parsers.rb
+- lib/infer_model/parsers/boolean.rb
+- lib/infer_model/parsers/date_time.rb
+- lib/infer_model/parsers/decimal.rb
+- lib/infer_model/parsers/integer.rb
+- lib/infer_model/parsers/json.rb
+- lib/infer_model/parsers/time.rb
+- lib/infer_model/parsers/uuid.rb
+- lib/infer_model/task.rb
+- lib/infer_model/to.rb
+- lib/infer_model/to/migration.rb
+- lib/infer_model/to/text.rb
+- lib/infer_model/value_type_guesser.rb
+- lib/infer_model/version.rb
+- sig/infer_model.rbs
+homepage: https://github.com/Jay-Schneider/infer_model
+licenses:
+- MIT
+metadata:
+  bug_tracker_uri: https://github.com/Jay-Schneider/infer_model/issues
+  changelog_uri: https://github.com/Jay-Schneider/infer_model/CHANGELOG.md
+  homepage_uri: https://github.com/Jay-Schneider/infer_model
+  rubygems_mfa_required: 'true'
+  source_code_uri: https://github.com/Jay-Schneider/infer_model
+post_install_message:
+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.3.7
+signing_key:
+specification_version: 4
+summary: Infer data types from external sources to create a rails model for example
+test_files: []