callable 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1ef39ede893ce0a86d29f34da19b77b7b2850090
-  data.tar.gz: d05ad76db5f5914b825e8c23f2a4b6453c598c33
+  metadata.gz: e85b170016fdbc135bebf0884c38e5637907d77a
+  data.tar.gz: 040b7e0d547142f84b52b547594171f3fcaa29f6
 SHA512:
-  metadata.gz: 00df6afe990ba3facb4d54ac73fb9ee4057086db2546afaba496eec83181ef7147e89b84a9691873357fab4f30adaa6a18ee3db371353618017879be35d0bde6
-  data.tar.gz: 7ed99cd5b51200dbce8bd34192272af15bf7c7b9c627eb661f6647f6d8145a48ba31a6516c11e89bc3d1fb475a230a1517faeae890df41bf875a3be455c4f139
+  metadata.gz: 6ff80b6c79dd75efe33e43c156ef738354470e1a2ad61c67b05cef612e9abeb339900dce8c2f193bf69ed772d28bdb7902150f6fc9c1a77ee1f4a7e3867b24ab
+  data.tar.gz: 72ecb0cf755932c829ceeefc659b5960770836ed2fcdb377910c0283abf555cd0ca776d96de7aaba410e5a533a7357733ad58bc6464d99d13d6216563dbb88ce

data/README.md

@@ -26,71 +26,108 @@ in one of two ways (don't forget to install the gem first).
 The first way is by invoking the callable method:
 
 ```ruby
-c = Callable( :ret_val )
-c.call
-=> ret_val
+  c = Callable( :ret_val )
+  c.call
+  => ret_val
 ```
 
 Take into account that if you pass a callable object (such as a
 lambda), you'll get it back as the return value:
 
 ```ruby
-c = Callable( ->{ :ret_val } )
-c.call
-=> ret_val
+  c = Callable( ->{ :ret_val } )
+  c.call
+  => ret_val
 ```
 
-The second way to use it is invoking the #callable directly on the object you
-want to be callable:
+The gem also ships with a #callable? method thar returns true if the
+object is callable and false if it's not.
 
 ```ruby
-c = :ret_val.callable
-c.call
-=> ret_val
+  :not_callable.callable?
+  => false
+  
+  ->{ :not_callable }.callable?
+  => true
 ```
 
-Like the example before, lambda, you'll get it back as the return value:
+This is the same as saying
 
 ```ruby
-c = ->{ :ret_val }.callable
-c.call
-=> ret_val
+  xxx.respond_to? :call
 ```
 
-The gem also ships with a #callable? method thar returns true if the
-object is callable and false if it's not.
+But I felt it would be more illustrative of it's purpose.
+
+## Where to use it?
+
+I think the main use for this library is handling actions as options.
+
+For example, imagine we have a very reduced authorization library that provides a method called `do_if`.
+This method receives:
+  - a symbol representing a permission name
+  - a Hash that represents the available authorization policies
+  - a block with the actions to perform
+
+The premise is that the method will execute the block if the selected policy returns true when we send the `call` message.
+
+Our first approach is:
 
 ```ruby
-:not_callable.callable?
-=> false
-->{ :not_callable }.callable?
-=> true
+  def do_if(permission, policies=POLICIES)
+    yield if policies[permission].call
+  end
 ```
 
-This is the same as saying
+So, if our POLICIES hash is:
 
 ```ruby
-xxx.respond_to? :call
+  POLICIES = {
+    development: -> { true }
+  }
+  
+  do_if(:development) do
+    puts "Debugging"
+  end
+  
+  # >> Debugging
 ```
 
-But I felt it would be more illustrative of it's purpose.
+And if we switch the policy value:
+
+```ruby
+  POLICIES = {
+    development: -> { false }
+  }
+  
+  do_if(:development) do
+    puts "Debugging"
+  end
+  
+  # >> 
+```
+
+This allows us to have a lot of flexibility. But we could provide the user a way to say the same with less code:
+
+
+
 
-## Where to use it?
 
-Let me say where to use this gem (with a very
-trivial example).
+*******************************
+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
+  class SomeClass
+    attr_writer :informer
+    def info
+      @informer.get_info
+    end
   end
-end
 ```
 
 If we want to use this "informer" object, we must define a new class
@@ -101,25 +138,25 @@ 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
+  class SomeClass
+    attr_writer :informer
+    def info
+      @informer.call
+    end
   end
-end
 ```
 
 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:
 
 ```ruby
-module Informer
-  def call
-    # retrieve the information we need from wherever we want
-    # maybe a web service
-    # maybe a local file
+  module Informer
+    def call
+      # retrieve the information we need from wherever we want
+      # maybe a web service
+      # maybe a local file
+    end
   end
-end
 ```
 
 So, when we do:
@@ -149,7 +186,7 @@ thing like this:
 
 ```ruby
   something = SomeClass.new
-  something.informer = Callable "No info available" 
+  something.informer = Callable("No info available" )
   something.info
 ```
 

data/callable.gemspec

@@ -1,4 +1,3 @@
-# coding: utf-8
 lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'callable/version'
@@ -22,3 +21,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "matest", "~> 1.5"
 end
+
+

data/lib/callable.rb

@@ -1,5 +1,23 @@
 require "callable/version"
 
 module Callable
-  # Your code goes here...
+  def Callable( callable_or_not )
+    if callable_or_not.respond_to?(:call)
+      callable_or_not
+    else
+      proc { |*args| callable_or_not }
+    end
+  end
+
+  def callable
+    Callable(self)
+  end
+
+  def callable?
+    self.respond_to?(:call)
+  end
 end
+
+::Object.include(Callable)
+
+puts "X" * 100

data/lib/callable/version.rb

@@ -1,3 +1,3 @@
 module Callable
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/spec/callable_spec.rb

@@ -0,0 +1,78 @@
+require "spec_helper"
+
+scope Callable do
+  spec "creates a callable object" do
+    @obj = :not_callable
+    @c = Callable(@obj)
+
+    @c.call == @obj
+  end
+
+  spec "leaves a callable object intact" do
+    @obj = -> { :callable }
+    @c = Callable(@obj)
+
+    @c == @obj
+  end
+
+  scope "#callable" do
+    spec "creates a callable object" do
+      @obj = :not_callable
+      @c = @obj.callable
+
+      @c.call == @obj
+    end
+
+    spec "leaves a callable object intact" do
+      @obj = -> { :callable }
+      @c = @obj.callable
+
+      @c == @obj
+    end
+
+  end
+
+  scope "#callable?" do
+    spec "returns true if the object responds to #call" do
+      @obj = -> { :callable }
+
+      @obj.callable?
+    end
+
+    spec "returns false if the object doesn't respond to #call" do
+      @obj = :not_callable
+
+      ! @obj.callable?
+    end
+  end
+
+  scope "arguments" do
+    spec "accepts arguments arguments" do
+      @obj = :not_callable
+      @c = Callable(@obj)
+
+      @c.call(1, 2, 3) == @obj
+    end
+
+    spec "passes the arguments on" do
+      @obj = -> (a, b) { a + " " + b }
+      @c = Callable(@obj)
+
+      @c.call("Call", "me") == "Call me"
+    end
+
+    spec "can pass any number of arguments to a proc" do
+      @obj = proc { |a, b| a + " " + b }
+      @c = Callable(@obj)
+
+      @c.call("Call", "me", "now") == "Call me"
+    end
+
+    spec "passes the arguments on" do
+      @obj = -> (*args) { args.join(" ") }
+      @c = Callable(@obj)
+
+      @c.call("Call", "me", "now") == "Call me now"
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,5 @@
+require "callable"
+
+Matest.configure do |config|
+  config.use_color
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: callable
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Federico Iachetti
@@ -68,6 +68,8 @@ files:
 - callable.gemspec
 - lib/callable.rb
 - lib/callable/version.rb
+- spec/callable_spec.rb
+- spec/spec_helper.rb
 homepage: ''
 licenses:
 - MIT
@@ -92,4 +94,6 @@ rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
 summary: It allows you to define callable objects.
-test_files: []
+test_files:
+- spec/callable_spec.rb
+- spec/spec_helper.rb