string_length_conformable 0.1.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e9d964ace0305d966851b56fbe9cf38d88fb370f4b35b452705cf6609ad9dd37
-  data.tar.gz: 9017049d48b51d9db9ef431fc387caf21ad1a2f89dbe1b52daac4fd29d3f412c
+  metadata.gz: 43e42b3c80a5a1b3bcbc2e9aa67516f657eee4d5eb0bd1a5e429b78ef3604d63
+  data.tar.gz: 182aaa4a7586cb855e6ae431061827f2a77c52ddfbfa5b2e65ef86213851e094
 SHA512:
-  metadata.gz: a1871ac7599f6dc6da4b83f4e945a9af523f8a9fa44b6305ebe83e05e389f428b578d8eb52c6095cc6eee26574704e3acc4e19f9c17e5ccb037e7d3d38d1f445
-  data.tar.gz: cbf5e0eb93cb1ff22ea511425a71b6c3cff62cc2f2ced99a97e52074c6d499bb5fad3284ee039bfab92869960d5ffb29a5f740632f315d8cf0fbf6ebb16adf18
+  metadata.gz: 7d0e73b0541248586789d1c6a54f1c4478375348e25e85e3bcd7f7365a417671dae0575823551eddd300e6699bdccca5ff5c34dd9d39112c87fc65a1034fe715
+  data.tar.gz: 28a0a824dfae6b01cf3eb413407a6292c0bd5e5aa7c8974e03afe02590e1d5988e473aecb5c580df6ab1a479dd4c6f8ff4c441b51b02f1378bd20e97c52fc22c

data/README.md

@@ -1,13 +1,21 @@
 # StringLengthConformable
 
-# USE WITH MySQL
+[![Gem Version](https://badge.fury.io/rb/string_length_conformable.svg)](https://badge.fury.io/rb/string_length_conformable)
 
-If you have some attributes in your models with type string (varchar(255) by default).
-And you haven't validate length of it, you can face once with a problem when user will
-pass in form field more characters. Then, your database(MySQL), most probably will throw an error 500.
-To avoid such kind a problems I've createt this gem.
+# Description
 
-This gem will throw a human readable exception when there are not validations applied for string, and user tries to pass longer string, then is specified in DB.
+### This gem resolves basically two problems.
+---
+1. MySQL for strings(VARCHAR(255)) by default has limit 255 characters. And when developer left this attribute without any length validation, then it's possible to face with situation when user unintentionally or intentionally will pass in text field more characters. So, then, probably you will get 500...
+---
+2. PostgreSQL. The maximum number of characters for variable unlimited length types (text, varchar) is undefined. There is a limit of size in bytes for all string types: In any case, the longest possible character string that can be stored is about 1 GB.
+And when developer left this attribute without any length validation, then it's possible to face with situation when user unintentionally or intentionally will try to full up your database with lots of GB of 'important' info.
+---
+
+Both of this cases, I guess, are not very pleasant.
+
+This gem adds default length validation for all string attributes.
+Except those which are already vlidated in standart rails way.
 
 ## Installation
 
@@ -46,6 +54,39 @@ end
 
 ```
 
+## Example
+
+```ruby
+#schema.rb
+create_table "users", force: :cascade do |t|
+  t.string "name"
+  t.string "description"
+  t.datetime "created_at", null: false
+  t.datetime "updated_at", null: false
+end
+```
+
+```ruby
+# user.rb
+class User < ApplicationRecord
+  acts_as_string_length_conformable
+  validates :description, length: { maximum: 800 }
+end
+```
+`example for MySQL(VARCHAR(255))`
+```ruby
+john = User.new
+john.name = 'n'*500 # exception "is too long, 255 characters is the maximum allowed"
+john.description = 'd'*799 # ok
+```
+`example for PostgreSQL(1gb)`
+```ruby
+john = User.new
+john.name = 'n'*100.000.000.000 # exception "is too long, 1000 characters is the maximum allowed"
+john.description = 'd'*799 #
+```
+___
+
 ## License
 
 The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/lib/string_length_conformable.rb

@@ -1,35 +1,24 @@
-require "string_length_conformable/version"
+# frozen_string_literal: true
+
+require 'string_length_conformable/version'
+require 'string_length_conformable/mysql_length_of_string_validator'
+require 'string_length_conformable/postgresql_length_of_string_validator'
 
 ActiveSupport.on_load(:active_record) do
   class ActiveRecord::Base
-    class NotMysqlDb < StandardError; end
+    class NotImplementedForDb < StandardError; end
     def self.acts_as_string_length_conformable
-
-      unless ActiveRecord::Base.connection.adapter_name == 'MySQL'
-        raise NotMysqlDb, 'Please use this gem with mysql. But better use PostgreSQL and be happy!'
-      end
-
-      validates_with LengthOfStringValidator
-    end
-    class LengthOfStringValidator < ActiveModel::Validator
-      def validate(record)
-        record.attribute_names.each do |attr_name|
-
-          next if record.instance_eval(attr_name).nil?
-
-          next unless record.column_for_attribute(attr_name).type == :string
-
-          symbol_attr = attr_name.parameterize.underscore.to_sym
-
-          next if record.class.validators_on(symbol_attr).select { |v| v.class == ActiveRecord::Validations::LengthValidator}.any?
-
-          permited_length = record.class.columns_hash[attr_name].limit
-          new_length = record.instance_eval(attr_name).length
-
-          if new_length > permited_length.to_i
-            record.errors.add attr_name, "too long, #{permited_length.to_i} characters is the maximum allowed"
-          end
-        end
+      if ActiveRecord::Base.connection.adapter_name == 'MySQL'
+        validates_with MysqlLengthOfStringValidator
+      elsif ActiveRecord::Base.connection.adapter_name == 'PostgreSQL'
+        validates_with PostgresqlLengthOfStringValidator
+      else
+        text = <<-TEXT
+          Unfortunately #{ActiveRecord::Base.connection.adapter_name} is not supported yet,
+          please create an issue https://github.com/Yaponcik/string_length_conformable/issues,
+          or pull request!
+        TEXT
+        railse NotImplementedForDb, text
       end
     end
   end

data/lib/string_length_conformable/logging.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Logging
+  def log
+    text = <<-TEXT
+      \n
+      #{'*' * 100}
+      String is validated by gem string_length_conformable.
+      for more info visit https://github.com/Yaponcik/string_length_conformable
+      #{'*' * 100}
+    TEXT
+    Logger.new(STDOUT).info text
+  end
+end

data/lib/string_length_conformable/mysql_length_of_string_validator.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative 'logging'
+
+class MysqlLengthOfStringValidator < ActiveModel::Validator
+  include Logging
+
+  def validate(record)
+    record.attribute_names.each do |attr_name|
+      next if record.instance_eval(attr_name).nil?
+
+      next unless record.column_for_attribute(attr_name).type == :string
+
+      symbol_attr = attr_name.parameterize.underscore.to_sym
+
+      next if record.class.validators_on(symbol_attr).select { |v| v.is_a? ActiveRecord::Validations::LengthValidator }.any?
+
+      permited_length = record.class.columns_hash[attr_name].limit
+      new_length = record.instance_eval(attr_name).length
+
+      if new_length > permited_length.to_i
+        record.errors.add attr_name, "is too long, #{permited_length.to_i} characters is the maximum allowed"
+        log
+      end
+    end
+  end
+end

data/lib/string_length_conformable/postgresql_length_of_string_validator.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative 'logging'
+
+class PostgresqlLengthOfStringValidator < ActiveModel::Validator
+  include Logging
+  DEFAULT_STRING_LENGTH = 1000
+
+  def validate(record)
+    record.attribute_names.each do |attr_name|
+      next if record.instance_eval(attr_name).nil?
+
+      next unless record.column_for_attribute(attr_name).type == :string
+
+      symbol_attr = attr_name.parameterize.underscore.to_sym
+
+      next if record.class.validators_on(symbol_attr).select { |v| v.is_a? ActiveRecord::Validations::LengthValidator }.any?
+
+      permited_length = record.class.columns_hash[attr_name].limit || DEFAULT_STRING_LENGTH
+      new_length = record.instance_eval(attr_name).length
+
+      if new_length > permited_length.to_i
+        record.errors.add attr_name, "is too long, #{permited_length.to_i} characters is the maximum allowed"
+        log
+      end
+    end
+  end
+end

data/lib/string_length_conformable/version.rb

@@ -1,3 +1,3 @@
 module StringLengthConformable
-  VERSION = "0.1.0"
+  VERSION = '0.2.1'.freeze
 end

data/string_length_conformable.gemspec

@@ -1,35 +1,43 @@
-
-lib = File.expand_path("../lib", __FILE__)
+lib = File.expand_path('lib', __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require "string_length_conformable/version"
+require 'string_length_conformable/version'
 
 Gem::Specification.new do |spec|
-  spec.name          = "string_length_conformable"
+  spec.name          = 'string_length_conformable'
   spec.version       = StringLengthConformable::VERSION
-  spec.authors       = ["Vladimir"]
-  spec.email         = ["raileanv@gmail.com"]
+  spec.authors       = ['Vladimir']
+  spec.email         = ['raileanv@gmail.com']
 
-  spec.summary       = %q{Gem for validate string length}
+  spec.summary       = 'Gem for validate string length'
   spec.description   = <<-TEXT
-    If you have some attributes in your models with type string (varchar(255) by default).
-    And you haven't validate length of it, you can face once with a problem when user will
-    pass in form field more characters. Then, your database, most probably will throw an error 500.
-    To avoid such kind a problems I've createt this gem.
+  This gem resolves basically two problems.
+  ---
+  1. MySQL for strings(VARCHAR(255)) by default has limit 255 characters. And when developer left this attribute without any length validation, then it's possible to face with situation when user unintentionally or intentionally will pass in text field more characters. So, then, probably you will get 500...
+  ---
+  2. PostgreSQL. The maximum number of characters for variable unlimited length types (text, varchar) is undefined. There is a limit of size in bytes for all string types: In any case, the longest possible character string that can be stored is about 1 GB.
+  And when developer left this attribute without any length validation, then it's possible to face with situation when user unintentionally or intentionally will try to full up your database with lots of GB of 'important' info.
+  ---
+
+  Both of this cases, I guess, are not very pleasant.
+
+  This gem adds default length validation for all string attributes.
+  Except those which are already vlidated in standart rails way.
+
   TEXT
-  
-  spec.homepage      = "https://github.com/Yaponcik/string_length_conformable"
-  spec.license       = "MIT"
+
+  spec.homepage      = 'https://github.com/Yaponcik/string_length_conformable'
+  spec.license       = 'MIT'
 
   # 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('..', __FILE__)) do
+  spec.files         = Dir.chdir(File.expand_path(__dir__)) do
     `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
   end
-  spec.bindir        = "exe"
+  spec.bindir        = 'exe'
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
-  spec.require_paths = ["lib"]
+  spec.require_paths = ['lib']
 
-  spec.add_development_dependency "bundler", "~> 1.16"
-  spec.add_development_dependency "rake", "~> 10.0"
-  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency 'bundler', '~> 1.16'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rspec', '~> 3.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: string_length_conformable
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.1
 platform: ruby
 authors:
 - Vladimir
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-10-19 00:00:00.000000000 Z
+date: 2018-10-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -52,11 +52,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.0'
-description: |2
-      If you have some attributes in your models with type string (varchar(255) by default).
-      And you haven't validate length of it, you can face once with a problem when user will
-      pass in form field more characters. Then, your database, most probably will throw an error 500.
-      To avoid such kind a problems I've createt this gem.
+description: |2+
+    This gem resolves basically two problems.
+    ---
+    1. MySQL for strings(VARCHAR(255)) by default has limit 255 characters. And when developer left this attribute without any length validation, then it's possible to face with situation when user unintentionally or intentionally will pass in text field more characters. So, then, probably you will get 500...
+    ---
+    2. PostgreSQL. The maximum number of characters for variable unlimited length types (text, varchar) is undefined. There is a limit of size in bytes for all string types: In any case, the longest possible character string that can be stored is about 1 GB.
+    And when developer left this attribute without any length validation, then it's possible to face with situation when user unintentionally or intentionally will try to full up your database with lots of GB of 'important' info.
+    ---
+
+    Both of this cases, I guess, are not very pleasant.
+
+    This gem adds default length validation for all string attributes.
+    Except those which are already vlidated in standart rails way.
+
 email:
 - raileanv@gmail.com
 executables: []
@@ -71,6 +80,9 @@ files:
 - bin/console
 - bin/setup
 - lib/string_length_conformable.rb
+- lib/string_length_conformable/logging.rb
+- lib/string_length_conformable/mysql_length_of_string_validator.rb
+- lib/string_length_conformable/postgresql_length_of_string_validator.rb
 - lib/string_length_conformable/version.rb
 - string_length_conformable.gemspec
 homepage: https://github.com/Yaponcik/string_length_conformable