verifly 0.2.0.0 → 0.2.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: bb480769ef6ceb801e8d09f52eb9eab8a31bd356
-  data.tar.gz: fb911427e5d26cb1f10ae5142af217aae51110fc
+  metadata.gz: 7171d204c82a0f84dd0b8780dda21a0c527687e1
+  data.tar.gz: cec080bcb1b9e2e38a3dd3434f8f18c498293f64
 SHA512:
-  metadata.gz: e22e09f78908ed3e451c3ce90d1e1c7d439cb1c69c8c356c4fd858ea2bbd3a071713c62666d6c74e364bc57faa61207cd3425e897b76fc834a1394f2bbe8bcb5
-  data.tar.gz: c5f4a1fd4a51b470cc12c5b4f57086a0e526919abbbbb949ef6781d3efb2e2b6645b879a14a4866ebeecb9ffaf4bb504ab2607e6f4258d0f61aa642ef1016c39
+  metadata.gz: 3f8f1bcaf78681238fd4935cc831e4b5716aa937fe92caafffb4aa1762837d0091da69a891d4b33ce25126a40d3193cacb930a23e7c9ec1adf33dbfb2b73b850
+  data.tar.gz: 2ede721d805ba64742b50743b16952609e6c82529d0a634f82bf32b7152660becd766c687147e9ae369aa8e02211cb12b80a4da7284d950abdd147ad8f6a2fea

data/README.md

@@ -0,0 +1,193 @@
+# Verifly v0.2
+[![Build Status](https://travis-ci.org/umbrellio/verifly.svg?branch=master)](https://travis-ci.org/umbrellio/verifly)
+
+This gem provides an api to run sequential checks like
+'ActiveModel::Validations' do, but with generic messages instead of errors.
+
+It also provides additional components to build it which could be used
+to imporve code readability. See [Applicator](#Applicator),
+[ApplicatorWithOptions](#ApplicatorWithOptions) and
+[ClassBuilder](#ClassBuilder) along with [Verifier](#Verifier)
+
+## Instalation
+
+```
+$ gem install verifly
+```
+
+and then in code
+
+```
+require 'verifly'
+```
+
+## ClassBuilder
+
+example:
+
+```lang=ruby
+Abstract = Struct.new(:data)
+  extend Verifly::ClassBuilder::Mixin
+
+  class WithString < self
+    def self.build_class(x)
+      self if x.is_a?(String)
+    end
+  end
+
+  Generic = Class.new(self)
+
+  self.buildable_classes = [WithString, Generic]
+  # or, vice versa
+  def self.buildable_classes
+    [WithString, Generic]
+  end
+end
+
+Abstract.build("foo") # => WithString.new("foo")
+Abstract.build(:foo) # => Generic.new("foo")
+```
+
+or see it at rubydoc.info
+
+Why don't just use Uber::Builder?
+([Uber](https://github.com/apotonick/uber) is cool, you should try it)
+There are two reasons: firstly, it is an unnecessary dependency.
+We dont want npm hell, do we? Uber::Builder realy does not do much work,
+it's just a pattern. Secondly, this implementation looks more clear to me,
+because children are deciding whether they will handle arguments, not parents.
+
+So to use it, you have to:
+
+1. Write some classes with duck type `.class_builder(*args)`
+
+2. Invoke `Verifly::ClassBuilder.new([<%= array_of_classes %>]).call(*args)`
+
+3. ????
+
+4. PROFIT
+
+It's simple and clear, but not very sugary. So, otherwise, you may do
+following:
+
+1. Write an abstract class
+
+2. Extend `Verifly::ClassBuilder::Mixin`
+
+3. Inherit from the abstract class in different implementations
+
+4. If some implementations have common ancestors
+(not including the abstract class), you can implement common ancestor's
+`.build_class` in terms of super (i.e.
+`def self.build_class(x); super if x.is_a?(String); end`)
+
+5. Change `.build_class` of other classes like `self if ...`.
+Don't change default implementation's `.build_class`
+
+6. Setup `.buildable_classes` on the abstract class, mentioning only direct
+children if you done step 4
+
+7. Optionally redefine `.build` in abstract class, if you want
+to separate `build_class` and constructor params
+
+8. Use `.build` instead of `new`
+
+## Applicator
+
+Applicator is designed to wrap applications of
+[applicable](https://en.wikipedia.org/wiki/Sepulka) objects
+around some binding in some context
+
+example:
+
+```lang=ruby
+object = OpenStruct.new(foo: :bar)
+Applicator.call(:foo, object, {}) # => :bar
+Applicator.call('foo', object, {}) # => :bar
+Applicator.call('context', object, {}) # => {}
+Applicator.call(-> { foo }, object, {}) # => :bar
+Applicator.call(->(context) { context[foo] }, object, bar: :baz) # => :baz
+Applicator.call(true, object, {}) # => true
+
+foo = :bar
+Applicator.call(:foo, binding, {}) # => :bar
+Applicator.call('object.foo', binding, {}) # => :bar
+```
+
+Applicator is good, but in most cases
+[ApplicatorWithOptions](#ApplicatorWithOptions) would be a better option.
+
+## ApplicatorWithOptions
+
+ApplicatorWithOptions is an applicator with options.
+The options are `if: ` and `unless: `. Same as in ActiveModel::Validations,
+they are applied to the same binding. Main action is executed
+only if `if: ` evaluates to truthy and `unless: ` evaluates to falsey.
+
+See examples:
+
+```lang=ruby
+ApplicatorWithOptions.new(:foo, if: -> { true }).call(binding, {}) # => foo
+
+ApplicatorWithOptions.new(:foo, if: -> (context) { context[:bar] })
+  .call(binding, { bar: true }) # => foo
+
+ApplicatorWithOptions.new(:foo, if: { bar: true }).call(binding, :bar) # => foo
+
+ApplicatorWithOptions.new(:foo, unless: -> { true })
+  .call(binding, {}) # => nil
+ApplicatorWithOptions.new(:foo, unless: -> (context) { context[:bar] })
+  .call(binding, { bar: true }) # => foo
+ApplicatorWithOptions.new(:foo, unless: { bar: true })
+  .call(binding, :bar) # => nil
+```
+
+## Verifier
+
+The last, but the most interesting component is Verifier.
+Verifiers use ApplciatorWithOptions to execute generic procedures.
+Procedures should call `message!` if they want to yield something.
+Note that you should implement `message!` by yourself (in terms of super)
+
+```lang=ruby
+class MyVerifier < Verifly::Verifier
+  Message = Struct.new(:text)
+  verify :foo, if: { foo: true }
+
+  private
+
+  def message!(text)
+    super { Message.new(text) }
+  end
+
+  def foo
+    message!('Something is wrong') if Fixnum != Bignum
+  end
+end
+```
+
+In addition to Applicator's power, you also can nest your verifiers
+to split the logic
+
+```lang=ruby
+class MyVerifier < Verifly::Verifier
+  Message = Struct.new(:text)
+  verify_with ChildVerifier, if: -> (context) { cotnext[:foo] }
+
+  private
+
+  def message!(text)
+    super { Message.new(text) }
+  end
+end
+
+class ChildVerifier < MyVerifier
+  verify %q(message!("it's alive!"))
+end
+```
+
+## Yard documentation
+
+This gem uses yard to generate documentation about its API.
+Visit http://www.rubydoc.info/github/umbrellio/verifly/master to see
+actual documentation for master.

data/lib/verifly/version.rb

@@ -8,5 +8,5 @@ module Verifly
   # * a stands for public api changes
   # * b stands for private api changes
   # * c stands for patch changes (not touching public or private api)
-  VERSION = '0.2.0.0'
+  VERSION = '0.2.0.1'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: verifly
 version: !ruby/object:Gem::Version
-  version: 0.2.0.0
+  version: 0.2.0.1
 platform: ruby
 authors:
 - Alexander Smirnov
@@ -150,13 +150,15 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.1'
-description: 'See more info at http://www.rubydoc.info/gems/verifly/0.2.0.0 '
+description: 'An api to run sequential checks like ''ActiveModel::Validations'' do,
+  but with generic messages instead of errors. See more info at [http://www.rubydoc.info/gems/verifly/0.2.0.1] '
 email:
 - begdory4@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- README.md
 - lib/verifly.rb
 - lib/verifly/applicator.rb
 - lib/verifly/applicator_with_options.rb
@@ -166,7 +168,8 @@ files:
 homepage: https://github.com/umbrellio/verifly
 licenses:
 - MIT
-metadata: {}
+metadata:
+  yard.run: yri
 post_install_message: 
 rdoc_options: []
 require_paths:
@@ -186,6 +189,5 @@ rubyforge_project:
 rubygems_version: 2.5.2
 signing_key: 
 specification_version: 4
-summary: An api to run sequential checks like 'ActiveModel::Validations' do, but with
-  generic messages instead of errors
+summary: See more info at [http://www.rubydoc.info/gems/verifly/0.2.0.1]
 test_files: []