callable 0.0.3 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3c5b497c63676bf94da754c000b492a556129c05
-  data.tar.gz: 0134218e2d93a191fec3e99e487a62d2260006c8
+  metadata.gz: e768ec5b42620b5cddec4479ea0ce5018d32d462
+  data.tar.gz: 430ea16944fb5b4684b25b747edae15906f8f5c7
 SHA512:
-  metadata.gz: 5999f68db4942f65a3a306bdf1d761408380e6cb215d81ae5ea3fe54052c05cc987a84aa338211abafafaab6c6201130f476aaeb5e5aeb3cc10d161f3925e2b7
-  data.tar.gz: 017ef300b84cfa0a03f387266fae82eb8e8f99ee5d721ad832dd9922d32c6f87efec3bb0a64a75465750840a0b025c50ea7271ad7b6ae3c8c68b24f5cfe48090
+  metadata.gz: b4184989f5a317828f747c8638276c3997a95ac95f61bb208015b088d4b4fa70fbba75ab5921a371c15c37fbe2f857adad93ef2bd63451ad2edbacbd619a0552
+  data.tar.gz: 3ec6e7a740d65954e64bc9b8a40d1ad5c99586050c91356982a1e38e6acca4a919e18816a72476b6f66c228be1265d959d7e34b30a1a8b9e615161384c4e6aee

data/README.md

@@ -2,11 +2,11 @@
 
 Create callable objects on the fly.
 
-It's easy to create a calable object in Ruby (understandong callable
-as an object that supports the call method), you just wrap it in a
+It's easy to create a callable object in Ruby (understanding callable
+as an object that supports the `#call` method), you just wrap it in a
 lambda and that's it. 
 
-Although this approach is correct, it lucks some expresiveness. Wouldn't it
+Although this approach is correct, it lacks some expressiveness. Wouldn't it
 be better to just say:
 
 ```ruby
@@ -20,15 +20,18 @@ This gem allows you to do exactly that (see Usage)
 
 ## Usage
 
-If you need to return a callable object for some reason, you can do it
-in one of two ways (don't forget to install the gem first).
+To use this library, you first need to require it. That's all the setup you need.
 
-The first way is by invoking the callable method:
+```ruby
+  require "callable"
+```
+
+If you need to return a callable object for some reason, you can do it by invoking the callable method:
 
 ```ruby
   c = Callable( :ret_val )
   c.call
-  => ret_val
+  # => ret_val
 ```
 
 Take into account that if you pass a callable object (such as a
@@ -37,10 +40,12 @@ lambda), you'll get it back as the return value:
 ```ruby
   c = Callable( ->{ :ret_val } )
   c.call
-  => ret_val
+  # => ret_val
+  c
+  # => #<Proc:0x0000000261e138@-:6 (lambda)>
 ```
 
-The gem also ships with a #callable? method thar returns true if the
+The gem also ships with a #callable? method that returns true if the
 object is callable and false if it's not.
 
 ```ruby
@@ -57,7 +62,7 @@ This is the same as saying
   xxx.respond_to? :call
 ```
 
-But I felt it would be more illustrative of it's purpose.
+But I felt it would be more illustrative of its purpose.
 
 ## Where to use it?
 
@@ -107,90 +112,25 @@ And if we switch the policy value:
   # >> 
 ```
 
-This allows us to have a lot of flexibility. But we could provide the user a way to say the same with less code:
-
-
-
-
-
-*******************************
-Let me say where to use this gem with a very
-trivial example.
-
-Imagine we have some class that admits an informer object that
-responds to the get_info method and returns a some information on a
-String.
-
-```ruby
-  class SomeClass
-    attr_writer :informer
-    def info
-      @informer.get_info
-    end
-  end
-```
-
-If we want to use this "informer" object, we must define a new class
-or module that responds to the "get_info" method.
-
-When we have a case like this, is a common practice to name that
-method "call", instead of "get_info", because we now can toss a simple
-lambda to substitute it. We can rewrite the code above like this:
-
-```ruby
-  class SomeClass
-    attr_writer :informer
-    def info
-      @informer.call
-    end
-  end
-```
+This allows us to have a lot of flexibility. But we could provide the user a way to say the same with a little less code.
 
-And now we can define a class or module that responds to the call
-method. In that call method, we can get as fancy as we want:
+If we wrap the policy to call with the Callable method:
 
 ```ruby
-  module Informer
-    def call
-      # retrieve the information we need from wherever we want
-      # maybe a web service
-      # maybe a local file
-    end
+  def do_if(permission, policies=POLICIES)
+    yield if Callable(policies[permission]).call
   end
 ```
 
-So, when we do:
-
-```ruby
-  something = SomeClass.new
-  something.informer = Informer
-  something.info
-```
-
-We trigger some weird and complex logic.
-
-But when we test our code (or in some special case), we need that
-logic to be as simple (an decoupled) as it can get. 
-
-Say we now want info to return just a fixed string saying "No info
-available". With a lambda is fairly easy to do it
-
-```ruby
-  something = SomeClass.new
-  something.informer = ->{ "No info available" }
-  something.info
-```
-
-Here is where the Callable gem comes in handy, we could say the same
-thing like this:
+Now we can put the raw value we want to get back without the need of the lambda
 
 ```ruby
-  something = SomeClass.new
-  something.informer = Callable("No info available" )
-  something.info
+  POLICIES = {
+    development: true
+  }
 ```
 
-And now is much more expressive.
+Even though using a lambda adds just a few more characters, in my opinion, it clutters the code. By being able to leave it out, the code reads much better.
 
 ## Installation
 

data/Rakefile

@@ -1,3 +1,4 @@
 require "bundler/gem_tasks"
 
 require "matest/spec_tasks"
+

data/lib/callable.rb

@@ -1,7 +1,8 @@
 require "callable/version"
 
 module Callable
-  def Callable( callable_or_not )
+  def Callable( callable_or_not, default: nil )
+    return Callable(default) if callable_or_not.nil?
     if callable_or_not.respond_to?(:call)
       callable_or_not
     else

data/lib/callable/version.rb

@@ -1,3 +1,3 @@
 module Callable
-  VERSION = "0.0.3"
+  VERSION = "0.0.4"
 end

data/spec/callable_spec.rb

@@ -75,4 +75,11 @@ scope Callable do
       @c.call("Call", "me", "now") == "Call me now"
     end
   end
+  scope "default value" do
+    spec "returns the default value when passing nil" do
+      @c = Callable(nil, default: "DEFAULT VALUE")
+
+      @c.call == "DEFAULT VALUE"
+    end
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: callable
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
 platform: ruby
 authors:
 - Federico Iachetti
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-01-30 00:00:00.000000000 Z
+date: 2015-05-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -90,7 +90,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5
+rubygems_version: 2.4.6
 signing_key: 
 specification_version: 4
 summary: It allows you to define callable objects.