monadic 0.6.0 → 0.7.0

data/CHANGELOG.md

@@ -1,6 +1,26 @@
 # Changelog
 
-## v0.6 (unreleased)
+## v0.7
+**BREAKING CHANGES**
+
+Rename `Either#else` to `Either#or` to be consistent with `Maybe`
+Using `Either#else` will give you a deprecation warning for now, it will be removed in v1.0
+
+New `Validation#fill` method for validating filling Structs.
+
+    ExampleStruct = Struct.new(:a, :b)
+    module ExampleValidator
+      extend self
+      def a(params); Try { params[0] }.or 'a cannot be empty'; end
+      def b(params); Try { params[1] }.or 'b cannot be empty'; end
+    end
+
+    result = Validation.fill(ExampleStruct, [1, 2], ExampleValidator)         == Sucess
+    example = result.fetch
+    example.a  == 1
+    example.b  == 2
+
+## v0.6
 
 Extend `Try` to also support lambdas.
 

data/README.md

@@ -90,10 +90,12 @@ Maybe(1).to_s             == '1'
 ```
 
 `#or`
+```ruby
 Maybe(nil).or(1)          == Just(1)
 Maybe(1).or(2)            == Just(1)
 Maybe(nil).or(1)          == Just(1)
 Maybe(nil).or(nil)        == Nothing
+```
 
 Falsey values (kind-of) examples:
 
@@ -217,17 +219,17 @@ Success(params).
   bind ->(path)     { load_stuff(params)          }        #
 ```
 
-`Either#else` allows to provide alternate values in case of `Failure`:
+`Either#or` allows to provide alternate values in case of `Failure`:
 
 ```ruby
-Either(false == true).else('false was not true')          == Failure(false was not true)
-Success('truth needs no sugar coating').else('all lies')  == Success('truth needs no sugar coating')
+Either(false == true).or('false was not true')          == Failure(false was not true)
+Success('truth needs no sugar coating').or('all lies')  == Success('truth needs no sugar coating')
 ```
 
-`Either#else` supports also a block
+`Either#or` supports also a block
 
 ```ruby
-Failure(1).else {|other| 1 + 2 }                          == Failure(3)
+Failure(1).or {|other| 1 + 2 }                          == Failure(3)
 ```
 
 Storing intermediate results in instance variables is possible, although it is not very elegant:
@@ -251,16 +253,16 @@ Try { Date.parse('2012-02-30') }                                        == Failu
 Try { Date.parse('2012-02-28') }                                        == Success
 
 date_s = '2012-02-30'
-Try { Date.parse(date_s) }.else {|e| "#{e.message} #{date_s}" }        == Failure("invalid date 2012-02-30")
+Try { Date.parse(date_s) }.or {|e| "#{e.message} #{date_s}" }        == Failure("invalid date 2012-02-30")
 
 # with a predicate
 Try(true)                                                               == Success(true)
 Try(false) { "string" }                                                 == Failure("string")
-Try(false) { "success"}.else("fail")                                    == Failure("fail")
+Try(false) { "success"}.or("fail")                                    == Failure("fail")
 
 VALID_TITLES = %w[MR MRS]
 title = 'MS'
-Try(VALID_TITLES.inlude?(title)) { title }.else { "title must be on of '#{VALID_TITLES.join(', ')}'' but was '#{title}'"}
+Try(VALID_TITLES.inlude?(title)) { title }.or { "title must be on of '#{VALID_TITLES.join(', ')}'' but was '#{title}'"}
                                                                         == "title must be on of 'MR, MR' but was 'MS'"
 ```
 
@@ -306,6 +308,22 @@ The above example, returns either `Success([32, :sober, :male])` or `Failure(['A
 
 See also [examples/validation.rb](https://github.com/pzol/monadic/blob/master/examples/validation.rb) and [examples/validation_module](https://github.com/pzol/monadic/blob/master/examples/validation_module.rb)  
 
+`Validation#fill` method for validating filling Structs:
+
+```ruby
+ExampleStruct = Struct.new(:a, :b)
+module ExampleValidator
+  extend self
+  def a(params); Try { params[0] }.or 'a cannot be empty'; end
+  def b(params); Try { params[1] }.or 'b cannot be empty'; end
+end
+
+result = Validation.fill(ExampleStruct, [1, 2], ExampleValidator)         == Sucess
+example = result.fetch
+example.a  == 1
+example.b  == 2
+```
+
 ### Monad
 All Monads include this module. Standalone it is an Identity monad. Not useful on its own. It's methods are usable on all its descendants.
 

data/lib/monadic/either.rb

@@ -36,7 +36,15 @@ module Monadic
 
     # If it is a Failure it will return a new Failure with the provided value
     # @return [Success, Failure]
+    def or(value=nil, &block)
+      return Failure(block.call(@value)) if failure? && block_given?
+      return Failure(value) if failure?
+      return self
+    end
+
+    #@deprecated
     def else(value=nil, &block)
+      warn 'Either#else is deprecated and will be removed in a future version, use Either#or instead'
       return Failure(block.call(@value)) if failure? && block_given?
       return Failure(value) if failure?
       return self
@@ -83,6 +91,7 @@ module Monadic
     def bind(proc=nil, &block)
       @chain << (proc || block)
     end
+    alias :>= :bind
   end
 
   # @private instance and class methods for +Success+ and +Failure+

data/lib/monadic/validation.rb

@@ -29,5 +29,17 @@ module Monadic
       # @failure.fetch << result.fetch) if result.failure?
       @result << result
     end
+
+    # Useful to populate a data structure like a Struct, which takes values in its constructor
+    def self.fill(obj, params, validator)
+      properties = validator.methods - Module.methods
+      values = properties.collect {|property| validator.send(property, params) }
+
+      if values.all?(&:success?)
+        Success(obj.new(*values.collect(&:fetch)))
+      else
+        Failure(obj.new(*values))
+      end
+    end
   end
 end

data/lib/monadic/version.rb

@@ -1,3 +1,3 @@
 module Monadic
-  VERSION = "0.6.0"
+  VERSION = "0.7.0"
 end

data/spec/either_spec.rb

@@ -57,17 +57,17 @@ describe Monadic::Either do
     error.message.should == 'error'
   end
 
-  it '#else returns an alternative value considered Success if it is Nothing' do
-    Failure(false).else(true).should == Failure(true)
-    Either(nil).else(true).should == Failure(true)
-    Failure(1).else(nil).should == Failure(nil)
-    Success(true).else(false).should == Success(true)
-    Either(true).else(false).should == Success(true)
-    Success(false).else(true).should == Success(false)
+  it '#or returns an alternative value considered Success if it is Nothing' do
+    Failure(false).or(true).should == Failure(true)
+    Either(nil).or(true).should == Failure(true)
+    Failure(1).or(nil).should == Failure(nil)
+    Success(true).or(false).should == Success(true)
+    Either(true).or(false).should == Success(true)
+    Success(false).or(true).should == Success(false)
   end
 
-  it '#else with a block gets the original value passed' do
-    (Failure(1).else { |other| other + 1 }).should == Failure(2)
+  it '#or with a block gets the original value passed' do
+    (Failure(1).or { |other| other + 1 }).should == Failure(2)
   end
 
   class User

data/spec/examples/hotel_booking_spec.rb

@@ -1,62 +1,30 @@
 require 'spec_helper'
 require 'active_support/time'
 
-module Monadic
-  class Struct < ::Struct
-    def self.create(params, params_module)
-      properties = self.create_properties(params || {}, params_module)
-
-      if properties.values.all?(&:success?)
-        Success(properties)
-      else
-        Failure(properties)
-      end
-    end
-
-    def to_hash
-      Hash[*members.zip(values).flatten]
-    end
-
-    def unwrap
-      ::Struct.new(*members).new(*values.map(&:fetch))
-    end
-
-    private
-    def self.create_properties(params, params_module)
-      properties = params_module.methods - Module.methods
-      request_klas = self.new(*properties)
-      properties.reduce(request_klas.new) do |request, property|
-        request[property] = params_module.send(property, params)
-        request
-      end
-    end
-  end
-end
-
 describe 'Hotel Booking Example' do
   module HotelBookingRequestParams
     extend self
 
     def hotel_code(params)
       param = params['hotel_code']
-      Try(param =~ /^[A-Z]{3}[A-Z0-9]{4}$/) { param }.else "hotel_code must be of pattern XXX0001, got '#{param}'"
+      Try(param =~ /^[A-Z]{3}[A-Z0-9]{4}$/) { param }.or "hotel_code must be of pattern XXX0001, got '#{param}'"
     end
 
     def nights(params)
       value = params.fetch('nights', 0).to_i
-      Try(value > 0) { value }.else "nights must be a number greater than 0, got '#{params['nights']}'"
+      Try(value > 0) { value }.or "nights must be a number greater than 0, got '#{params['nights']}'"
     end
 
     ROOM_OCCUPANCIES = {'SR' => 1, 'DR' => 2, 'TR' => 3, 'QR' => 4 }
     VALID_ROOM_TYPES = ROOM_OCCUPANCIES.keys
     def room_type(params)
       param = params['room_type']
-      Try(VALID_ROOM_TYPES.include?(param)) { param }.else "room_type must be one of '#{VALID_ROOM_TYPES.join(', ')}', got '#{param}'"
+      Try(VALID_ROOM_TYPES.include?(param)) { param }.or "room_type must be one of '#{VALID_ROOM_TYPES.join(', ')}', got '#{param}'"
     end
 
     def check_in(params)
       param = params['check_in']
-      Try { Date.parse(param) }.else {|e| "check_in #{e.message}, got '#{param}'" }
+      Try { Date.parse(param) }.or {|e| "check_in #{e.message}, got '#{param}'" }
     end
 
     OCCUPANCIES = [1, 2, 3, 4]
@@ -64,7 +32,7 @@ describe 'Hotel Booking Example' do
       guests    = params.select {|p| p =~ /^guest/ }.values.compact
       rt        = params['room_type']
       occupancy = ROOM_OCCUPANCIES.fetch(rt, 99)
-      Try(guests.count == occupancy) { guests }.else "guests number must match the room_type '#{rt}':#{occupancy}, got #{guests.count}: '#{guests.join(', ')}'"
+      Try(guests.count == occupancy) { guests }.or "guests number must match the room_type '#{rt}':#{occupancy}, got #{guests.count}: '#{guests.join(', ')}'"
     end
 
   end
@@ -81,7 +49,7 @@ describe 'Hotel Booking Example' do
   it 'builds a valid request' do
     result = prepare params_proto
     result.should be_a Success
-    request = result.fetch.unwrap   # the valid object, ready to use
+    request = result.fetch   # the valid object, ready to use
     request.hotel_code.should == "STO0001"
     request.check_in.should   == Date.new(2012, 06, 15)
     request.nights.should     == 3
@@ -90,7 +58,9 @@ describe 'Hotel Booking Example' do
   end
 
   def prepare(params)
-    Monadic::Struct.create(params, HotelBookingRequestParams)
+    properties = HotelBookingRequestParams.methods - Module.methods
+    klas = Struct.new(*properties)
+    Monadic::Validation.fill(klas, params, HotelBookingRequestParams)
   end
 
   it 'reports too few guests' do
@@ -113,13 +83,14 @@ describe 'Hotel Booking Example' do
   end
 
   it 'builds a failure request with no params' do
-    result = prepare(nil)
+    result = prepare({})
     result.should be_a Failure
     request = result.fetch
     request.hotel_code.should == Failure("hotel_code must be of pattern XXX0001, got ''")
     request.nights.should     == Failure("nights must be a number greater than 0, got ''")
     request.room_type.should  == Failure("room_type must be one of 'SR, DR, TR, QR', got ''")
-    request.check_in.should   == Failure("check_in can't convert nil into String, got ''")
+    request.check_in.should be_a Failure
+    request.check_in.fetch.should =~ /check_in.*, got ''/
     request.guests.should     == Failure("guests number must match the room_type '':99, got 0: ''")
   end
 

data/spec/maybe_spec.rb

@@ -64,6 +64,7 @@ describe Monadic::Maybe do
       Nothing.or(Just(nil)).should == Just(nil)
       Nothing.something.or(1).should == Just(1)
       Nothing.something.or(Just(nil)).should == Just(nil)
+      Nothing.or('').should == Just('')
     end
   end
 

data/spec/try_spec.rb

@@ -23,7 +23,7 @@ describe 'Monadic::Try' do
   it 'with a param and with a block it returns the block result' do
     Try(true)  { 1 }.should == Success(1)
     Try(false) { 2 }.should == Failure(2)
-    Try(false) { 1 }.else { 2 }.should == Failure(2)
+    Try(false) { 1 }.or { 2 }.should == Failure(2)
   end
 
   it 'with a proc and no block it evaluates the proc' do
@@ -40,8 +40,8 @@ describe 'Monadic::Try' do
     Try { "string" }.should == Success("string")
   end
 
-  it 'combined with else and a block' do
-    Try { Date.parse('2012-02-30') }.else {|e| "Exception: #{e.message}" }.should == Failure("Exception: invalid date")
-    Try { Date.parse('2012-02-28') }.else {|e| "Exception: #{e.message}" }.should == Success(Date.parse('2012-02-28'))
+  it 'combined with or and a block' do
+    Try { Date.parse('2012-02-30') }.or {|e| "Exception: #{e.message}" }.should == Failure("Exception: invalid date")
+    Try { Date.parse('2012-02-28') }.or {|e| "Exception: #{e.message}" }.should == Success(Date.parse('2012-02-28'))
   end
 end

data/spec/validation_spec.rb

@@ -44,4 +44,32 @@ describe Monadic::Validation do
     success.should be_a Success
     success.should == Success([30, :sober, :male])
   end
+
+  describe '#fill' do
+    ExampleStruct = Struct.new(:a, :b)
+    module ExampleValidator
+      extend self
+      def a(params); Try { params[0] }.or 'a cannot be empty'; end
+      def b(params); Try { params[1] }.or 'b cannot be empty'; end
+    end
+
+    it 'works with a struct, returns the object wrapped in Success' do
+      params = [1, 2]
+      result = Validation.fill(ExampleStruct, params, ExampleValidator)
+      result.should be_a Success
+      example = result.fetch
+
+      example.a.should == 1
+      example.b.should == 2
+    end
+
+    it 'on Failure, each individual field contains a Success or Failure' do
+      params = [1]
+      result = Validation.fill(ExampleStruct, params, ExampleValidator)
+      result.should be_a Failure
+      example = result.fetch
+      example.a.should == Success(1)
+      example.b.should == Failure('b cannot be empty')
+    end
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: monadic
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.7.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-06-24 00:00:00.000000000 Z
+date: 2012-07-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -177,7 +177,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 2246458514498594220
+      hash: 494077126848857519
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -186,7 +186,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 2246458514498594220
+      hash: 494077126848857519
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.24