verifly 0.1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 4f523cb22087d0d7c74367fd62024dcdfb54304e
+  data.tar.gz: 3d6c1a22923b9e3c2878cbed2dd6df65295a0405
+SHA512:
+  metadata.gz: eb92359f062778ff644ccd41576b4023fcfcfe0af935b0c6edcf549ec4f9e5ea439bb24f617a0003935431313762925620f2e10366bffcad860d48873862ebf7
+  data.tar.gz: 033ac456b04c5cfec227311a83ba3f16f32790632ee9966e103c8ea2d2d09fb36ce83642ec7ccefd9316e32ce65166188014cd613c7997b230d900b924be1ab6

data/lib/verifly.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+# Verifly provides several usefull classes, but most important
+# is Verifier. Other provided classes are it's dependency.
+# See README.md or their own documentation for more info about usage
+module Verifly
+  autoload :VERSION, 'verifly/version'
+
+  autoload :Applicator, 'verifly/applicator'
+  autoload :ApplicatorWithOptions, 'verifly/applicator_with_options'
+  autoload :ClassBuilder, 'verifly/class_builder'
+  autoload :Verifier, 'verifly/verifier'
+end

data/lib/verifly/applicator.rb

@@ -0,0 +1,205 @@
+# frozen_string_literal: true
+
+module Verifly
+  # @abstract implement `#call`
+  # Applies "applicable" objects to given bindings
+  # (applicable objects are named based on their use,
+  # currently any object is applicable).
+  #
+  # This class uses ClassBuilder system.
+  # When reading the code, we suggest starting from '.call' method
+  # @see ClassBuilder
+  # @attr applicable [applicable] wrapped applicable object
+  class Applicator
+    # Proxy is used when applicable itself is an instance of Applicator.
+    # It just delegates #call method to applicable
+    # @example
+    #   Applicator.call(Applicator.build(:foo), binding_, context)
+    #   # => Applicator.call(:foo, binding_, context)
+    class Proxy < self
+      # @param applicable [Applicator]
+      # @return Proxy if applicable is an instance of Applicator
+      # @return [nil] otherwise
+      def self.build_class(applicable)
+        self if applicable.is_a?(Applicator)
+      end
+
+      # @param binding_ [#instance_exec] target to apply applicable
+      # @param context additional info to send it to applicable
+      # @return application result
+      def call(binding_, context)
+        applicable.call(binding_, context)
+      end
+    end
+
+    # MethodExtractor is used when applicable is a symbol.
+    # It extracts extracts method from binding_ and executes it on binding_
+    # (so it works just like send except it sends nothing
+    # when method arity is zero).
+    # @example
+    #   Applicator.call(Applicator.build(:foo), User.new, context)
+    #   # => User.new.foo(context)
+    #   # or => User.new.foo, if it does not accept context
+    class MethodExtractor < self
+      # @param applicable [Symbol]
+      # @return MethodExtractor if applicable is Symbol
+      # @return [nil] otherwise
+      def self.build_class(applicable)
+        self if applicable.is_a?(Symbol)
+      end
+
+      # @param binding_ [#instance_exec] target to apply applicable
+      # @param context additional info to send it to applicable
+      # @return application result
+      def call(binding_, context)
+        if binding_.is_a?(Binding)
+          call_on_binding(binding_, context)
+        else
+          invoke_lambda(binding_.method(applicable), binding_, context)
+        end
+      end
+
+      private
+
+      # When Binding is target, we have to respect both methods and variables
+      # @param binding_ [Binding] target to apply applicable
+      # @param context additional info to send it to applicable
+      # @return application result
+      def call_on_binding(binding_, context)
+        if binding_.receiver.respond_to?(applicable)
+          invoke_lambda(binding_.receiver.method(applicable), binding_, context)
+        else
+          binding_.local_variable_get(applicable)
+        end
+      end
+    end
+
+    # InstanceEvaluator is used for string. It works like instance_eval or
+    # Binding#eval depending on binding_ class
+    # @example
+    #   Applicator.call('foo if context[:foo]', binding_, context)
+    #   # => foo if context[:foo]
+    class InstanceEvaluator < self
+      # @param applicable [String]
+      # @return InstanceEvaluator if applicable is String
+      # @return [nil] otherwise
+      def self.build_class(applicable)
+        self if applicable.is_a?(String)
+      end
+
+      # @param binding_ [#instance_exec] target to apply applicable
+      # @param context additional info to send it to applicable
+      # @return application result
+      def call(binding_, context)
+        if binding_.is_a?(Binding)
+          binding_ = binding_.dup
+          binding_.local_variable_set(:context, context)
+          binding_.eval(applicable, *caller_line)
+        else
+          binding_.instance_eval(applicable, *caller_line)
+        end
+      end
+
+      # @return [String, Integer]
+      #   file and line where `Applicator.call` was called
+      def caller_line
+        offset = 2
+        backtace_line = caller(offset..offset)[0]
+        _, file, line = backtace_line.match(/\A(.+):(\d+):[^:]+\z/).to_a
+        [file, Integer(line)]
+      end
+    end
+
+    # ProcApplicatior is used when #to_proc is available.
+    # It works not just with procs, but also with hashes etc
+    # @example with proc
+    #   Applicator.call(-> { foo }, binding_, context) # => foo
+    # @example with hash
+    #   Applicator.call(Hash[foo: true], binding_, :foo) # => true
+    #   Applicator.call(Hash[foo: true], binding_, :bar) # => nil
+    class ProcApplicatior < self
+      # @param applicable [#to_proc]
+      # @return ProcApplicatior if applicable accepts #to_proc
+      # @return [nil] otherwise
+      def self.build_class(applicable)
+        self if applicable.respond_to?(:to_proc)
+      end
+
+      # @param binding_ [#instance_exec] target to apply applicable
+      # @param context additional info to send it to applicable
+      # @return application result
+      def call(binding_, context)
+        invoke_lambda(applicable.to_proc, binding_, context)
+      end
+    end
+
+    # Quoter is used when there is no other way to apply applicatable.
+    # @example
+    #   Applicator.call(true, binding_, context) # => true
+    class Quoter < self
+      # @return applicable without changes
+      def call(*)
+        applicable
+      end
+    end
+
+    extend ClassBuilder::Mixin
+
+    self.buildable_classes =
+      [Proxy, MethodExtractor, InstanceEvaluator, ProcApplicatior, Quoter]
+
+    attr_accessor :applicable
+
+    # Applies applicable on binding_ with context
+    # @todo add @see #initialize when it's todo done
+    # @param applicable [applicable]
+    #   see examples in defenitions of sublcasses
+    # @param binding_ [#instance_exec]
+    #   where should applicable be applied. It could be either a generic object,
+    #   where it would be `instance_exec`uted, or a binding_
+    # @param context
+    #   geneneric data you want to pass to applicable function.
+    #   If applicable cannot accept params, context will not be sent
+    # @return application result
+    def self.call(applicable, binding_, context)
+      build(applicable).call(binding_, context)
+    end
+
+    # Always use build instead of new
+    # @todo add more examples right here
+    # @param applicable [applicable]
+    #   see examples in sublcasses defenitions
+    # @api private
+    def initialize(applicable)
+      self.applicable = applicable
+    end
+
+    # @param [Applicator] other
+    # @return [Boolean] true if applicable matches, false otherwise
+    def ==(other)
+      applicable == other.applicable
+    end
+
+    # @!method call(binding_, context)
+    #   @abstract
+    #   Applies applicable on binding_ with context
+    #   @param binding_ [#instance_exec] binding to be used for applying
+    #   @param context param that will be passed if requested
+    #   @return application result
+
+    private
+
+    # invokes lambda respecting it's arity
+    # @param [Proc] lambda
+    # @param binding_ [#instance_exec] binding_ would be used in application
+    # @param context param would be passed if lambda arity > 0
+    # @return invocation result
+    def invoke_lambda(lambda, binding_, context)
+      if lambda.arity.zero?
+        binding_.instance_exec(&lambda)
+      else
+        binding_.instance_exec(context, &lambda)
+      end
+    end
+  end
+end

data/lib/verifly/applicator_with_options.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Verifly
+  # An applicator with useful options
+  # @example if
+  #   ApplicatorWithOptions.new(action, if: true)
+  # @example unless
+  #   ApplicatorWithOptions.new(action, unless: false)
+  # @attr action [Applicator]
+  #   main action to apply on call
+  # @attr if_condition [Applicator]
+  #   main action only apply if this applies to truthy value
+  # @attr unless_condition [Applicator]
+  #   main action only apply if this applies to falsey value
+  class ApplicatorWithOptions
+    attr_accessor :action, :if_condition, :unless_condition
+
+    # @param action [applicable] main action
+    # @option options [applicable] :if
+    #   main action only apply if this applies to truthy value
+    # @option options [applicable] :unless
+    #   main action only apply if this applies to falsey value
+    def initialize(action, **options)
+      self.action = Applicator.build(action)
+      self.if_condition = Applicator.build(options.fetch(:if, true))
+      self.unless_condition = Applicator.build(options.fetch(:unless, false))
+    end
+
+    # Applies main action if if_condition applyd to truthy value
+    # and unless_condition applyd to falsey value
+    # @param binding_ [#instance_exec]
+    #   binding to apply (see Applicator)
+    # @param context
+    #   generic context to apply (see Applicator)
+    # @return main action application result
+    # @return [nil] if condition checks failed
+    def call(binding_, context)
+      return unless if_condition.call(binding_, context)
+      return if unless_condition.call(binding_, context)
+      action.call(binding_, context)
+    end
+  end
+end

data/lib/verifly/class_builder.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Verifly
+  # ClassBuilder is something like Uber::Builder, but it
+  # allows the child classes to decide whether they will be used.
+  # I find it much more OOPish
+  # @attr klasses [Array(Class)]
+  #   classes to iterate during search of most suitable
+  class ClassBuilder
+    # Mixin provides useful methods to integrate builder subsystem.
+    # Feel free to override or just never include it.
+    # @attr_writer [Array(Class)] buildable_classes
+    #   Array of classes which will be checked if they
+    #   suite constructor arguments. Order matters
+    module Mixin
+      # Array of classes which would be checked if they
+      # suite constructor arguments. Order matters
+      # @param klasses [Array(Class)]
+      def buildable_classes=(klasses)
+        @class_builder = ClassBuilder.new(klasses).freeze
+      end
+
+      # Default implementation of build_class. Feel free to change
+      # You also have to override it in buildable_classes
+      def build_class(*args, &block)
+        if @class_builder
+          @class_builder.call(*args, &block)
+        else
+          self
+        end
+      end
+
+      # Default implementation.
+      # This method should be used instead of new in all cases
+      def build(*arguments, &block)
+        build_class(*arguments, &block).new(*arguments, &block)
+      end
+    end
+
+    attr_accessor :klasses
+
+    # @param klasses [Array(Classes)]
+    def initialize(klasses)
+      self.klasses = klasses
+    end
+
+    # @return [Class] first nonzero class returned by .build_class
+    def call(*arguments, &block)
+      klasses.each do |klass|
+        result = klass.build_class(*arguments, &block)
+        return result if result
+      end
+    end
+  end
+end

data/lib/verifly/verifier.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module Verifly
+  # Verifier is a proto-validator class, which allows to
+  # use generic messages formats (instead of errors, which are raw text)
+  # @abstract
+  #   implement `#message!` method in terms of super
+  # @attr model
+  #   Generic object to be verified
+  # @attr messages [Array]
+  #   Array with all messages yielded by the verifier
+  class Verifier
+    autoload :ApplicatorWithOptionsBuilder,
+             'verifly/verifier/applicator_with_options_builder'
+
+    attr_accessor :model, :messages
+
+    # @example with block
+    #   verify { |context| message!() if context[:foo] }
+    # @example with proc
+    #   verify -> (context) { message!() if context[:foo] }
+    # @example with hash
+    #  verify -> { message!() } if: { foo: true }
+    # @example cotnext could be ommited from lambda params
+    #   verify -> { message!() }, if: -> (context) { context[:foo] }
+    # @example with symbol
+    #   verify :foo, if: :bar
+    #   # calls #foo if #bar is true
+    #   # bar could either accept context or not
+    # @example with string
+    #  verify 'message!() if context[:foo]'
+    #  verify 'message!()', if: 'context[:foo]'
+    # @example with descedant
+    #   verify DescendantClass
+    #   # calls DescendantClass.call(model, context) and merges it's messages
+    # @param verifier [#to_proc|Symbol|String|Class|nil]
+    #   verifier defenition, see examples
+    # @option options [#to_proc|Symbol|String|nil] if (true)
+    #   call verifier if only block invocation result is truthy
+    # @option options [#to_proc|Symbol|String|nil] unless (false)
+    #   call verifier if only block invocation result is falsey
+    # @yield context on `#verfify!` calls
+    # @return [Array] list of all verifiers already defined
+    def self.verify(*args, &block)
+      bound_applicators <<
+        ApplicatorWithOptionsBuilder.call(self, *args, &block)
+    end
+
+    # @return [Array(ApplicatorWithOptions)]
+    #   List of applicators, bound by .verify
+    def self.bound_applicators
+      @bound_applicators ||= []
+    end
+
+    # @param model generic model to validate
+    # @param context context in which it would be valdiated
+    # @return [Array] list of messages yielded by verifier
+    def self.call(model, context = {})
+      new(model).verify!(context)
+    end
+
+    # @param model generic model to validate
+    def initialize(model)
+      self.model = model
+      self.messages = []
+    end
+
+    # @param context context in which model would be valdiated
+    # @return [Array] list of messages yielded by verifier
+    def verify!(context = {})
+      self.messages = []
+
+      self.class.bound_applicators.each do |bound_applicator|
+        bound_applicator.call(self, context)
+      end
+
+      messages
+    end
+
+    private
+
+    # @abstract
+    #   implement it like `super { Message.new(status, text, description) }`
+    # @return new message (yield result)
+    def message!(*)
+      new_message = yield
+      @messages << new_message
+      new_message
+    end
+  end
+end

data/lib/verifly/verifier/applicator_with_options_builder.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Verifly
+  class Verifier
+    # Builds ApplicatorWithOptions from different invocation styles.
+    # @api private
+    # @attr base [Class]
+    #   class for which applicator_with_options should be built
+    # @attr args [Array]
+    #   array of arguments Verifier.verify invoked with
+    # @attr block [Proc]
+    #   block Verifier.verify invoked with
+    ApplicatorWithOptionsBuilder = Struct.new(:base, :args, :block)
+    class ApplicatorWithOptionsBuilder
+      # @!method self.call(base)
+      # transforms `verify` arguments to class attributes
+      # and invokes calculation
+      # @raise [ArgumentError]
+      # @return [ApplicatorWithOptions] resulting applicator_with_options
+      def self.call(base, *args, &block)
+        new(base, args, block).call
+      end
+
+      # Tries different invocation styles until one matches
+      # @see #try_block
+      # @see #try_nesting
+      # @see #default
+      # @raise [ArgumentError]
+      # @return [ApplicatorWithOptions] resulting applicator_with_options
+      def call
+        try_block || try_nesting || default
+      end
+
+      private
+
+      # @example with options
+      #   verify(if: true) { ... }
+      # @example without options
+      #   verify { ... }
+      # @return [ApplicatorWithOptions]
+      def try_block
+        ApplicatorWithOptions.new(block, *args) if block
+      end
+
+      # @example correct
+      #   verify SubVerifier
+      # @example incorrect
+      #   verify Class
+      # @raise [ArgumentError]
+      # @return [ApplicatorWithOptions]
+      def try_nesting
+        verifier, *rest = args
+        return unless verifier.is_a?(Class)
+        raise ArgumentError, <<~ERROR unless verifier < base
+          Nested verifiers should be inherited from verifier they nested are in
+        ERROR
+
+        applicable = lambda do |context|
+          messages.concat(verifier.call(model, context))
+        end
+
+        ApplicatorWithOptions.new(applicable, *rest)
+      end
+
+      # Simply passes args to ApplicatorWithOptions
+      # @example
+      #   verify(:foo, unless: false)
+      # @return [ApplicatorWithOptions]
+      def default
+        ApplicatorWithOptions.new(*args)
+      end
+    end
+  end
+end

data/lib/verifly/version.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Verifly
+  # Specifies Verifly version
+  #
+  # Semantical naming: 0.a.b.c where
+  # * 0 is for unreleased
+  # * a is for public api changes
+  # * b is for private api changes
+  # * c is for changes, not changing private api
+  VERSION = '0.1.0.0'
+end

metadata

@@ -0,0 +1,190 @@
+--- !ruby/object:Gem::Specification
+name: verifly
+version: !ruby/object:Gem::Version
+  version: 0.1.0.0
+platform: ruby
+authors:
+- Alexander Smirnov
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-04-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  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'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.5'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.5'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.48'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.48'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.8
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.8
+- !ruby/object:Gem::Dependency
+  name: launchy
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.4'
+- !ruby/object:Gem::Dependency
+  name: coveralls
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.8.19
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.8.19
+- !ruby/object:Gem::Dependency
+  name: rubocop-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+- !ruby/object:Gem::Dependency
+  name: rspec-its
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+description: ''
+email:
+- begdory4@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/verifly.rb
+- lib/verifly/applicator.rb
+- lib/verifly/applicator_with_options.rb
+- lib/verifly/class_builder.rb
+- lib/verifly/verifier.rb
+- lib/verifly/verifier/applicator_with_options_builder.rb
+- lib/verifly/version.rb
+homepage: http://example.com
+licenses: []
+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: []
+rubyforge_project: 
+rubygems_version: 2.5.2
+signing_key: 
+specification_version: 4
+summary: ''
+test_files: []