validy 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 9c0d9fbaa3151e0a5e75e19287e7a363cf75f3eec4066c9a28f8c866b9d966fa
+  data.tar.gz: 2c92ccdad681600fe8b781701b157c7fbd2f5512a19b8bdc4cb704fc7ef097df
+SHA512:
+  metadata.gz: 49e7c5f233d034b1ff5988500ce9163fe0994856720fb2159d09435f9538383b0c0ca2ca6408278288b8d3ed1af19842a585d6ca5728d51be4fcf05e5dacd8be
+  data.tar.gz: 6d296b8cf23575424c5015586ddc910dc2e4402f09f1439acc1f3433f5efe04d2b25a538a83d1d70b1245358c1aedf5d4bf1edcfeaa47ccf4ae0022aa8e35d3b

data/lib/validy.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+module Validy
+  Error = Class.new(StandardError)
+  NotImplementedError = Class.new(StandardError)
+  OverImplemented = Class.new(StandardError)
+
+  def self.included(base)
+    base.send(:extend, ClassMethods)
+    base.send(:include, InstanceMethods)
+    base.prepend(Initializer)
+  end
+
+  module Initializer
+    def initialize(*)
+      @errors = {}
+      @valid = true
+      @evaluating_attribute = nil
+
+      super
+
+      if method_presented?(method_without_bang)
+        send(method_without_bang)
+      elsif method_presented?(method_with_bang)
+        send(method_with_bang)
+      else
+        raise NotImplementedError, 'validy method given from validy_on method: argument, must be implemented!'
+      end
+    end
+  end
+
+  module ClassMethods
+    def validy_on(method:)
+      method_with_bang_name = (method[-1] == '!' ? method.to_s : "#{method}!")
+      method_without_bang_name = method_with_bang_name.gsub('!', '')
+
+      define_method :method_with_bang do
+        method_with_bang_name
+      end
+
+      define_method :method_without_bang do
+        method_without_bang_name
+      end
+
+      hooks = Module.new do
+        method_with_bang_name = (method[-1] == '!' ? method.to_s : "#{method}!")
+        method_without_bang_name = method_with_bang_name.gsub('!', '')
+        define_method method_with_bang_name do |*args, &block|
+          if method_presented?(method_without_bang_name)
+            send(method_without_bang_name, *args, &block)
+          else
+            super(*args, &block)
+          end
+          raise ::Validy::Error, stringified_error unless valid?
+        end
+      end
+      prepend hooks
+    end
+  end
+
+  module InstanceMethods
+    # "add_error" adds an error and set valid state to false
+    # @return [FalseClass]
+    def add_error(args = {})
+      @errors.merge!(args)
+      @valid = false
+    end
+
+    # "valid?" returns inner valid state
+    # @return [Boolean]
+    def valid?
+      @valid
+    end
+
+    # "errors" returns errors hash
+    # @return [Hash]
+    def errors
+      @errors
+    end
+
+    # "condition" evaluates either passed block or instance method represented in the instance
+    def condition(method, error = nil, &block)
+      return self unless valid?
+
+      condition = method.respond_to?(:call) ? method.call : send(method)
+      validate_condition(condition, error, &block)
+      self
+    end
+
+    # "required" checks presence of the variable
+    def required(attribute, error = nil, &block)
+      return self unless valid?
+
+      @evaluating_attribute = instance_variable_get("@#{attribute}")
+      validate_condition(@evaluating_attribute, error || "#{attribute} required!", &block)
+      self
+    end
+
+    # "optional" starts void validation for the given attribute
+    def optional(attribute)
+      return self unless valid?
+
+      @evaluating_attribute = instance_variable_get("@#{attribute}")
+      self
+    end
+
+    # "type" validates type of the instance variable
+    def type(clazz, error = nil, &block)
+      return self unless valid?
+
+      validate_condition(@evaluating_attribute&.is_a?(clazz),
+                         error || "#{@evaluating_attribute} is not a type #{clazz}", &block)
+      self
+    end
+
+    private
+
+    def method_presented?(method)
+      method_to_symed = method.to_sym
+      methods.any? { |m| m == method_to_symed }
+    end
+
+    def stringified_error
+      errors.inject(String.new) { |s, h| s << "#{h[0]}: #{h[1]}" }
+    end
+
+    def error_hash(error)
+      return error if error.is_a?(Hash)
+
+      { error: error }
+    end
+
+    def validate_condition(condition, error = nil, &block)
+      return if condition
+
+      error_hash = error_hash(error)
+      add_error(error_hash)
+
+      block.call if block_given?
+    end
+  end
+end

metadata

@@ -0,0 +1,44 @@
+--- !ruby/object:Gem::Specification
+name: validy
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Oleg Saltykov
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2022-01-09 00:00:00.000000000 Z
+dependencies: []
+description:
+email:
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/validy.rb
+homepage: https://github.com/nucleom42/validy
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- 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.3.7
+signing_key:
+specification_version: 4
+summary: Validy - simple way to turn ruby instance(object) into validateable object
+  with useful validity helpers
+test_files: []