input_attributes_from_validators 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: ea33dbf007b19181f857847dc0cb7e9c9d505b84b8c421e6949f1f01c25e79b2
+  data.tar.gz: 390cd060a49ffb1e89c4ac164d1a8286ae786b2ae6e8a736f9fae6a57e4984d2
+SHA512:
+  metadata.gz: bca3ae056bf69d856efd25590436b2ab4c04743bf55e00f86513d830c7f6c827f9d1aeb928ad33826fda693ae144c2a938432110ad3abcfb3d585cb3384e3a54
+  data.tar.gz: 1495b8ab30226d5ac3f614aae92448c59ddbd84b2dac9a1ea4c2983fa86b20aa8b5372a2a2670b2b2c7681ce6b91cf3ff0cab7eda10e1c1bfb265b7be19bcd5b

data/Gemfile

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,90 @@
+PATH
+  remote: .
+  specs:
+    input_attributes_from_validators (0.0.1)
+      railties (>= 4)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    actionpack (7.0.3)
+      actionview (= 7.0.3)
+      activesupport (= 7.0.3)
+      rack (~> 2.0, >= 2.2.0)
+      rack-test (>= 0.6.3)
+      rails-dom-testing (~> 2.0)
+      rails-html-sanitizer (~> 1.0, >= 1.2.0)
+    actionview (7.0.3)
+      activesupport (= 7.0.3)
+      builder (~> 3.1)
+      erubi (~> 1.4)
+      rails-dom-testing (~> 2.0)
+      rails-html-sanitizer (~> 1.1, >= 1.2.0)
+    activesupport (7.0.3)
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      i18n (>= 1.6, < 2)
+      minitest (>= 5.1)
+      tzinfo (~> 2.0)
+    builder (3.2.4)
+    concurrent-ruby (1.1.10)
+    crass (1.0.6)
+    diff-lcs (1.5.0)
+    erubi (1.10.0)
+    i18n (1.10.0)
+      concurrent-ruby (~> 1.0)
+    loofah (2.18.0)
+      crass (~> 1.0.2)
+      nokogiri (>= 1.5.9)
+    method_source (1.0.0)
+    minitest (5.15.0)
+    nokogiri (1.13.6-arm64-darwin)
+      racc (~> 1.4)
+    racc (1.6.0)
+    rack (2.2.3.1)
+    rack-test (1.1.0)
+      rack (>= 1.0, < 3)
+    rails-dom-testing (2.0.3)
+      activesupport (>= 4.2.0)
+      nokogiri (>= 1.6)
+    rails-html-sanitizer (1.4.3)
+      loofah (~> 2.3)
+    railties (7.0.3)
+      actionpack (= 7.0.3)
+      activesupport (= 7.0.3)
+      method_source
+      rake (>= 12.2)
+      thor (~> 1.0)
+      zeitwerk (~> 2.5)
+    rake (13.0.6)
+    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)
+    thor (1.2.1)
+    tzinfo (2.0.4)
+      concurrent-ruby (~> 1.0)
+    webrick (1.7.0)
+    yard (0.9.28)
+      webrick (~> 1.7.0)
+    zeitwerk (2.5.4)
+
+PLATFORMS
+  arm64-darwin-21
+
+DEPENDENCIES
+  input_attributes_from_validators!
+  rake (~> 13)
+  rspec (~> 3)
+  yard (>= 0.9.20, < 1)
+
+BUNDLED WITH
+   2.3.15

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2022 Sergey Pedan
+
+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,113 @@
+# HTML input attributes helper
+
+[![Gem Version](https://badge.fury.io/rb/input_attributes_from_validators.svg)](https://badge.fury.io/rb/input_attributes_from_validators)
+
+## Installation
+
+```ruby
+gem "input_attributes_from_validators"
+```
+
+## The main idea
+
+HTML inputs have powerful controls over browser via attributes:
+
+- validations ([`min`](https://developer.mozilla.org/en-US/docs/Web/HTML/Attributes/min), [`max`](https://developer.mozilla.org/en-US/docs/Web/HTML/Attributes/max), [`minlength`](https://developer.mozilla.org/en-US/docs/Web/HTML/Attributes/minlength), [`maxlength`](https://developer.mozilla.org/en-US/docs/Web/HTML/Attributes/maxlength), [`required`](https://developer.mozilla.org/en-US/docs/Web/HTML/Attributes/required)) and
+- keyboards variations ([`inputmode`](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/inputmode), [`step`](https://developer.mozilla.org/en-US/docs/Web/HTML/Attributes/step)).
+
+Normally you write those HTML attributes manually or forget about them, but most of them can be inferred from model validations and the DB column name.
+
+## How to use
+
+Provided that you have validators on your model:
+
+```ruby
+class Review < ActiveRecord::Base
+
+  validates :comment, presence: true, length: { min: 3, max: 1_000 }
+  validates :score, numericality: { only_integer: true, in: 1..5 }
+end
+```
+
+### Individual helper methods
+
+This gem exposes a set of helper methods, one for the corresponding HTML attribute:
+
+```ruby
+validated_inputmode @rating, :comment #=> "text"
+validated_minlength @review, :comment #=> 3
+validated_maxlength @review, :comment #=> 1_000
+validated_required  @review, :comment #=> true
+```
+
+```ruby
+validated_inputmode @rating, :score   #=> "numeric"
+validated_min       @rating, :score   #=> 1
+validated_max       @rating, :score   #=> 5
+validated_step      @rating, :score   #=> 1
+```
+
+### Aggregate method
+
+There is also a method that returns a hash with all the values:
+
+```ruby
+resolved_input_attributes(record, attribute_name) #=>
+{
+  inputmode:  <String || NilClass>,,
+  max:       <Integer || NilClass>,
+  maxlength: <Integer || NilClass>,
+  min:       <Integer || NilClass>,
+  minlength: <Integer || NilClass>,
+  required: <Boolean>,
+  step:      <Integer || Decimal>,
+}
+```
+
+so you don’t have to repeadedly pass the record and the attribute name:
+
+```ruby
+= form_for model: @review do |f|
+  - attrs = resolved_input_attributes(@review, :score)
+
+  = f.number_field :size \
+                    inputmode: attrs[:inputmode], \
+                    max:       attrs[:max], \
+                    min:       attrs[:min], \
+                    required:  attrs[:required], \
+                    step:      attrs[:step]
+
+  = f.text_field :description \
+                    inputmode: attrs[:inputmode], \
+                    maxlength: attrs[:maxlength], \
+                    minlength: attrs[:minlength], \
+                    required:  attrs[:required]
+```
+
+## Less useful methods
+
+Search for validators with certain conditions:
+
+```ruby
+validators_for(record: @review, attr: :comment, type: :length, options: [:maximm])
+#=> 255
+
+validators_for(record: @review, attr: :score, type: :numericality, options: [:less_than, :less_than_or_equal_to])
+#=> 5
+```
+
+Also
+
+```ruby
+validated_value(record: @review, attr: :comment, type: :length, options: [:maximm])
+#=> 255
+```
+
+```ruby
+validator_type_to_class :presence     #=> ActiveRecord::Validations::PresenceValidator
+validator_type_to_class :numericality #=> ActiveRecord::Validations::NumericalityValidator
+```
+
+## Todo
+
+- [ ] pattern attribute

data/Rakefile

@@ -0,0 +1,79 @@
+# encoding: utf-8
+
+require "bundler/setup"
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+# require "term/ansicolor"
+require "yard"
+
+require "./lib/input_attributes_from_validators"
+
+Bundler::GemHelper.install_tasks
+RSpec::Core::RakeTask.new(:spec)
+
+desc "Generate documentation"
+YARD::Rake::YardocTask.new(:yard) do |t|
+end
+task doc: :yard
+
+# APP_RAKEFILE = File.expand_path("test/dummy/Rakefile", __dir__)
+# load "rails/tasks/engine.rake"
+load "rails/tasks/statistics.rake"
+
+task default: :spec
+
+# desc "Publish"
+# task :publish do
+# 	puts `gem push pkg/input_attributes_from_validators-#{InputAttributesFromValidators::VERSION}.gem`
+# end
+
+# require 'rake/testtask'
+# Rake::TestTask.new do |t|
+#   t.libs << 'test'
+#   t.test_files = FileList['test/**/*_test.rb']
+#   t.verbose = false
+#   t.warning = false
+# end
+
+# desc 'Test all Gemfiles from test/*.gemfile'
+# task :test_all_gemfiles do
+#   require 'term/ansicolor'
+#   require 'pty'
+#   require 'shellwords'
+#   cmd      = 'bundle install --quiet && bundle exec rake --trace'
+#   statuses = Dir.glob('./test/gemfiles/*{[!.lock]}').map do |gemfile|
+#     env = {'BUNDLE_GEMFILE' => gemfile}
+#     cmd_with_env = "  (#{env.map { |k, v| "export #{k}=#{Shellwords.escape v}" } * ' '}; #{cmd})"
+#     $stderr.puts Term::ANSIColor.cyan("Testing\n#{cmd_with_env}")
+#     Bundler.with_clean_env do
+#       PTY.spawn(env, cmd) do |r, _w, pid|
+#         begin
+#           r.each_line { |l| puts l }
+#         rescue Errno::EIO
+#           # Errno:EIO error means that the process has finished giving output.
+#         ensure
+#           ::Process.wait pid
+#         end
+#       end
+#     end
+#     [$? && $?.exitstatus == 0, cmd_with_env]
+#   end
+#   failed_cmds = statuses.reject(&:first).map { |(_status, cmd_with_env)| cmd_with_env }
+#   if failed_cmds.empty?
+#     $stderr.puts Term::ANSIColor.green('Tests pass with all gemfiles')
+#   else
+#     $stderr.puts Term::ANSIColor.red("Failing (#{failed_cmds.size} / #{statuses.size})\n#{failed_cmds * "\n"}")
+#     exit 1
+#   end
+# end
+
+# desc 'Start a dummy Rails app server'
+# task :rails_server do
+#   require 'rack'
+#   require 'term/ansicolor'
+#   port = ENV['PORT'] || 9292
+#   puts %Q(Starting on #{Term::ANSIColor.cyan "http://localhost:#{port}"})
+#   Rack::Server.start(
+#     config: 'test/dummy_rails/config.ru',
+#     Port: port)
+# end

data/app/helpers/attributes_helper.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module AttributesHelper
+
+	# @param [ActiveRecord::Base] record
+	# @param [String, Symbol] attr
+	# @return [Hash]
+	#
+	def resolved_input_attributes(record, attr)
+		{
+			inputmode: validated_inputmode(record, attr),
+			max:       validated_max(record, attr),
+			maxlength: validated_maxlength(record, attr),
+			min:       validated_min(record, attr),
+			minlength: validated_minlength(record, attr),
+			required:  validated_required(record, attr),
+		}.compact
+	end
+
+end

data/app/helpers/input_mode_helper.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module InputModeHelper
+
+	# @param [ActiveRecord::Base] record
+	# @param [String, Symbol] attr
+	# @return [String, NilClass]
+	# @example
+	#   validated_inputmode @user,   :email   #=> "email"
+	#   validated_inputmode @rating, :comment #=> "text"
+	#   validated_inputmode @rating, :score   #=> "numeric"
+	#
+	def validated_inputmode(record, attr)
+		v_types = validators_for_attr(record, attr).map(&:kind)
+
+		# TODO: try using pattern matching instead
+		if v_types.include?("numericality")
+			needs_integer?(record, attr) ? "numeric" : "decimal"
+		elsif v_types.include?("email")
+			"email"
+		elsif v_types.include?("url")
+			"url"
+		elsif ["tel", "phone"].any? { |i| v_types.include?(i) }
+			"tel"
+		elsif ["search"].any? { |i| v_types.include?(i) } || attr.to_s.include?("search")
+			"search"
+		else
+			"text"
+		end
+	end
+
+	# @param [ActiveRecord::Base] record
+	# @param [String, Symbol] attr
+	# @return [Numeric, NilClass]
+	# @example
+	#   validated_step @rating,   :score  #=> 1
+	#   validated_step @dumbbell, :weight #=> 0.25
+	#
+	def validated_step(record, attr)
+		case validated_inputmode(record, attr)
+		when "numeric" then   1
+		when "decimal" then 0.1
+		end
+	end
+
+
+	# https://developer.mozilla.org/en-US/docs/Web/HTML/Attributes/pattern
+	# def validated_pattern(record, attr)
+	# end
+
+	private def needs_integer?(record, attr)
+		validated_value(record: record, attr: attr, type: :numericality, options: [:only_integer])
+	end
+
+end

data/app/helpers/input_type_helper.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module InputTypeHelper
+
+	# @param [ActiveRecord::Base] record
+	# @param [String, Symbol] attr
+	# @return [String, NilClass]
+	# @example
+	#   resolved_input_type @user,   :email   #=> "email"
+	#   resolved_input_type @rating, :comment #=> "text"
+	#   resolved_input_type @rating, :score   #=> "numeric"
+	#
+	def resolved_input_type(record, attr)
+		v_types = validators_for_attr(record, attr).map(&:kind)
+		klass = record.class
+
+		# TODO: try using pattern matching instead
+		if v_types.include? "numericality" or [:integer, :bigint, :float, :decimal].include? klass.column_for_attribute(attr).type
+			"number"
+
+		elsif v_types.include? "email" or attr.to_s.include? "email"
+			"email"
+
+		elsif v_types.include? "url" or attr.to_s.include? "url"
+			"url"
+
+		elsif v_types.include? "tel" or attr.to_s.include? "tel"
+			"tel"
+
+		elsif v_types.include? "phone" or attr.to_s.include? "phone"
+			"tel"
+
+		elsif v_types.include? "color" or attr.to_s.include? "color"
+			"color"
+
+		elsif ["search"].any? { |i| v_types.include?(i) } or attr.to_s.include? "search"
+			"search"
+
+		elsif klass.column_for_attribute(attr).type == :text
+			validated_value(record: record, attr: attr, type: :length, options: [:maximm]).to_i > 256 ? "textarea" : "text"
+
+		elsif klass.column_for_attribute(attr).type == :date
+			"date"
+
+		elsif klass.column_for_attribute(attr).type == :datetime
+			"datetimelocal"
+
+		elsif klass.column_for_attribute(attr).type == :time
+			"time"
+
+		else
+			"text"
+		end
+	end
+
+end

data/app/helpers/limits_helper.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module LimitsHelper
+
+	# @example
+	#   validated_maxlength @review, :comment #=> 1_000
+	# @param [ActiveRecord::Base] record
+	# @param [String, Symbol] attr
+	# @return [Integer, NilClass]
+	# @see https://developer.mozilla.org/en-US/docs/Web/HTML/Attributes/maxlength
+	# @raise [TypeError]
+	#
+	def validated_maxlength(record, attr)
+		maximum = validated_value(record: record, attr: attr, type: :length, options: [:maximum])
+		range   = validated_value(record: record, attr: attr, type: :length, options: [:in])
+		range&.max || maximum
+	end
+
+	# @example
+	#   validated_minlength @review, :comment #=> 3
+	# @param [ActiveRecord::Base] record
+	# @param [String, Symbol] attr
+	# @return [Integer, NilClass]
+	# @see https://developer.mozilla.org/en-US/docs/Web/HTML/Attributes/minlength
+	# @raise [TypeError]
+	#
+	def validated_minlength(record, attr)
+		minimum = validated_value(record: record, attr: attr, type: :length, options: [:minimum])
+		range   = validated_value(record: record, attr: attr, type: :length, options: [:in])
+		range&.min || minimum
+	end
+
+	# @example
+	#   validated_required @rating, :score #=> 5
+	# @param [ActiveRecord::Base] record
+	# @param [String, Symbol] attr
+	# @return [Integer, NilClass]
+	# @see https://developer.mozilla.org/en-US/docs/Web/HTML/Attributes/max
+	# @raise [TypeError]
+	#
+	def validated_max(record, attr)
+		validated_value(record: record, attr: attr, type: :numericality, options: [:less_than, :less_than_or_equal_to])
+	end
+
+	# @example
+	#   validated_min @rating, :score #=> 1
+	# @param [ActiveRecord::Base] record
+	# @param [String, Symbol] attr
+	# @return [Integer, NilClass]
+	# @see https://developer.mozilla.org/en-US/docs/Web/HTML/Attributes/min
+	# @raise [TypeError]
+	#
+	def validated_min(record, attr)
+		validated_value(record: record, attr: attr, type: :numericality, options: [:greater_than, :greater_than_or_equal_to])
+	end
+
+	# @example
+	#   validated_required @user, :email #=> true
+	# @param [ActiveRecord::Base] record
+	# @param [String, Symbol] attr
+	# @return [Boolean]
+	# @see https://developer.mozilla.org/en-US/docs/Web/HTML/Attributes/required
+	# @raise [TypeError]
+	#
+	def validated_required(record, attr)
+		# validated_value(record: record, attr: attr, type: :presence, options: [:presece]) ?
+		validators_for(record: record, attr: attr, type: :presence).any?
+	end
+
+end

data/app/helpers/validators_reflection_helper.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module ValidatorsReflectionHelper
+
+	# @example
+	#   validators_for_attr(User.new, :email) #=>
+	#   [
+	#     <ActiveRecord::Validations::PresenceValidator:0x @attributes=[:email], @options={}>,
+	#     <EmailValidator:0x @attributes=[:email], @options={}>,
+	#     <ActiveRecord::Validations::UniquenessValidator:0x @attributes=[:email], @options={}>,
+	#     <ActiveRecord::Validations::PresenceValidator:0x @attributes=[:email], @options={:if=>:email_required?}>,
+	#     <ActiveRecord::Validations::UniquenessValidator:0x @attributes=[:email], @options={:allow_blank=>true, :case_sensitive=>true, :if=>:will_save_change_to_email?}>,
+	#     <ActiveModel::Validations::FormatValidator:0x @attributes=[:email], @options= {:allow_blank=>true, :if=>:will_save_change_to_email?}>
+	#   ]
+	# @param [ActiveRecord::Base] record
+	# @param [String, Symbol] attr
+	# @raise [TypeError]
+	#
+	def validators_for_attr(record, attr)
+		fail TypeError, "`attr` must be a Symbol or String, you pass a #{attr.class}" unless [Symbol, String].include? attr.class
+		# TODO: fail TypeError if record.class.ancestors.include?()
+
+		record.class.validators.select { _1.attributes.include? attr }
+	end
+
+	# @param [ActiveRecord::Base] record
+	# @param [String, Symbol] attr
+	# @param [Array<Symbol>] options
+	# @raise [TypeError]
+	#
+	def validators_for(record:, attr:, type: nil, options: [])
+		fail TypeError, "`options` must be an Array, you pass a #{options.class}" unless options.is_a? Array
+		result = validators_for_attr(record, attr).select { _1.options.keys & options }
+		result = result.select { _1.is_a? validator_type_to_class(type) } if type.present?
+		result
+	end
+
+	# @example
+	#   validated_value(record: @review, attr: :comment, type: :length, options: [:maximm]) #=> 255
+	# @param [ActiveRecord::Base] record
+	# @param [String, Symbol] attr
+	# @return [Integer, NilClass, Boolean]
+	# @raise [TypeError]
+	# @raise [TypeError]
+	#
+	def validated_value(record:, attr:, type: nil, options: [])
+		fail TypeError, "`options` must be an Array, you pass a #{options.class}" unless options.is_a? Array
+		validators_for(record: record, attr: attr, type: type, options: options).map { first_value(_1, options) }.compact.first
+	end
+
+	# @param [String, Symbol, NilClass] type
+	# @example
+	#   validator_type_to_class(:presence)     #=> ActiveRecord::Validations::PresenceValidator
+	#   validator_type_to_class(:numericality) #=> ActiveRecord::Validations::NumericalityValidator
+	#
+	def validator_type_to_class(type)
+		fail TypeError, "`type` must be a Symbol or String, you pass a #{type.class}" unless [Symbol, String, NilClass].include? type.class
+		["ActiveRecord::Validations::", type.to_s.capitalize, "Validator"].join.constantize if type.present?
+	end
+
+	private def first_value(validator, options)
+		options.map { |key| validator.options&.fetch(key, nil) }.compact.first
+	end
+
+end

data/input_attributes_from_validators.gemspec

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative "lib/input_attributes_from_validators/version"
+
+Gem::Specification.new do |spec|
+  spec.name             = "input_attributes_from_validators"
+  spec.version          = InputAttributesFromValidators::VERSION
+  spec.authors          = ["Sergey Pedan"]
+  spec.email            = ["sergey.pedan@gmail.com"]
+  spec.license          =  "MIT"
+
+  spec.summary          =  "A collection of helper methods for Rails to automate assigning HTML input attributes like maxlength, required, inputmode etc."
+  spec.description      = <<~HEREDOC
+                            #{spec.summary}.
+                          HEREDOC
+
+  spec.homepage         =  "https://github.com/sergeypedan/#{spec.name.gsub('_', '-')}"
+  spec.extra_rdoc_files = ["README.md", "CHANGELOG.md"]
+  spec.rdoc_options     = ["--charset=UTF-8"]
+  spec.metadata         = { "changelog_uri"     => "#{spec.homepage}/blob/master/CHANGELOG.md",
+                            "documentation_uri" => "https://www.rubydoc.info/gems/#{spec.name}",
+                            "homepage_uri"      => "https://sergeypedan.ru/open_source_projects/#{spec.name.gsub('_', '-')}",
+                            "source_code_uri"   => spec.homepage }
+
+  spec.require_paths    = ["app", "lib"]
+
+  spec.bindir           = "exe"
+  spec.executables      = []
+  spec.files            = Dir.chdir(File.expand_path(__dir__)) do
+                            `git ls-files`.split("\n")
+                              .reject { |f| %w[bin spec test].any? { |dir| f.start_with? dir } }
+                              .reject { |f| f.start_with? "." }
+                          end
+
+  spec.add_runtime_dependency "railties", ">= 4"
+
+  spec.add_development_dependency "rake", "~> 13"
+  spec.add_development_dependency "rspec", "~> 3"
+  spec.add_development_dependency "yard",  ">= 0.9.20", "< 1"
+end

data/lib/input_attributes_from_validators/engine.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module InputAttributesFromValidators
+
+  # This is standard Rails way to autoload gem’s contents dynamically as an “engine”
+  # @see https://guides.rubyonrails.org/engines.html Rails guide on engines
+  #
+  class Engine < ::Rails::Engine
+  end
+
+end

data/lib/input_attributes_from_validators/version.rb

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

data/lib/input_attributes_from_validators.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+# frozen_string_literal: true
+
+require_relative "input_attributes_from_validators/version"
+require_relative "input_attributes_from_validators/engine"
+
+require_relative "../app/helpers/attributes_helper"
+require_relative "../app/helpers/input_mode_helper"
+require_relative "../app/helpers/input_type_helper"
+require_relative "../app/helpers/limits_helper"
+require_relative "../app/helpers/validators_reflection_helper"
+
+
+module InputAttributesFromValidators
+end

metadata

@@ -0,0 +1,132 @@
+--- !ruby/object:Gem::Specification
+name: input_attributes_from_validators
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Sergey Pedan
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2022-06-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: railties
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.9.20
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.9.20
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '1'
+description: 'A collection of helper methods for Rails to automate assigning HTML
+  input attributes like maxlength, required, inputmode etc..
+
+'
+email:
+- sergey.pedan@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.md
+- CHANGELOG.md
+files:
+- CHANGELOG.md
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- app/helpers/attributes_helper.rb
+- app/helpers/input_mode_helper.rb
+- app/helpers/input_type_helper.rb
+- app/helpers/limits_helper.rb
+- app/helpers/validators_reflection_helper.rb
+- input_attributes_from_validators.gemspec
+- lib/input_attributes_from_validators.rb
+- lib/input_attributes_from_validators/engine.rb
+- lib/input_attributes_from_validators/version.rb
+homepage: https://github.com/sergeypedan/input-attributes-from-validators
+licenses:
+- MIT
+metadata:
+  changelog_uri: https://github.com/sergeypedan/input-attributes-from-validators/blob/master/CHANGELOG.md
+  documentation_uri: https://www.rubydoc.info/gems/input_attributes_from_validators
+  homepage_uri: https://sergeypedan.ru/open_source_projects/input-attributes-from-validators
+  source_code_uri: https://github.com/sergeypedan/input-attributes-from-validators
+post_install_message: 
+rdoc_options:
+- "--charset=UTF-8"
+require_paths:
+- app
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3.1
+signing_key: 
+specification_version: 4
+summary: A collection of helper methods for Rails to automate assigning HTML input
+  attributes like maxlength, required, inputmode etc.
+test_files: []