functo 0.1.3 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 11f0d93203f4181a8d9783fefd67aba0ae43856d
-  data.tar.gz: d3c4fc5ced337e6cc26cbd5b664541037692f6e6
+  metadata.gz: 1aacfe82c8c6c9ae6d012f3d8e6fdf0a76e95624
+  data.tar.gz: b214a8b047a2e3dfcfa825f407a59c85f8815706
 SHA512:
-  metadata.gz: c3c28d9beeef0a14e599e2faaf53233a84a838858c250bbc1a7b8be5d1e085b5efcb0e572164cd3be227fa80a89999d985577fe1155b2417c486b074b220ca70
-  data.tar.gz: e1541a748c161c5d2eacf7dd093fcb83ed171bead03d7eea0318f21f250a11e54272fca809e3f35389e1d103c8a5518a6476c9cbd031726f4f7ac88768f9c9b3
+  metadata.gz: f913c2170fe113976ee62b1e3c4c3d89a6b9293db56c8612073b7e3f8d490bc859465ff11e8362e6380cd5ad14798ae06679211c6ffe65c5f418600cb85bd611
+  data.tar.gz: 6ef2cb2b623d76ce701fdbaeff494fb0966aced469551f4cd5bf0c4bd98c08fa4a12efb4c3c0085bdaefd5b6209f264a909206fdd7088dda76c16af92b1fa2bb

data/.gitignore

@@ -7,3 +7,4 @@
 /pkg/
 /spec/reports/
 /tmp/
+/README.html

data/README.md

@@ -1,118 +1,53 @@
 # Functo
 
-Functo is a dynamic module for composable method objects in ruby.
+Composable method objects in ruby.
 
-It turns this:
-
-```ruby
-class AddsTwo
-  def self.call(*args)
-    new(*args).add
-  end
-
-  attr_reader :number
-  protected :number
-
-  def initialize(number)
-    @number = number
-  end
-
-  def add
-    number + 2
-  end
-end
-```
-
-in to this:
+## Usage
 
 ```ruby
-class AddsTwo
+class AddsOne
   include Functo.call :add, :number
 
   def add
-    number + 2
+    number + 1
   end
 end
-```
-
-## Installation
 
-Add this line to your application's Gemfile:
+AddsOne[1]
+# => 2
 
-```ruby
-gem 'functo'
-```
-
-And then execute:
-
-    $ bundle
-
-Or install it yourself as:
-
-    $ gem install functo
-
-## Usage
-
-Functo objects can take up to three arguments.
-
-```ruby
-class Multiply
-  include Functo.call :multiply, :first, :second, :third
+class Multiplies
+  include Functo.call :multiply, :foo, :bar
 
   def multiply
-    first * second * third
-  end
-end
-
-Multiply.call(10, 20, 30)
-# => 6000
-
-class Divide
-  include Functo.call :multiply, :first, :second, :third, :fourth
-
-  def divide
-    first / second / third / fourth
+    foo * bar
   end
 end
-# => ArgumentError: given 4 arguments when only 3 are allowed
-```
-
-If you find yourself needing more you should consider composing method objects or encapsulating some of your arguments in another object.
 
-You can use square brackets to call Functo objects:
-
-```ruby
-AddsTwo[3]
-# => 5
+Multiplies[2, 3]
+# => 6
 ```
 
-and they can be used in blocks:
+Functo objects can be used in place of a `Proc`.
 
 ```ruby
-[1, 2, 3].map(&AddsTwo)
-# => [3, 4, 5]
+[1, 2, 3].map(&AddsOne)
+# => [2, 3, 4]
 ```
 
 ### Composition
 
-Functo objects can be composed using `compose` or the turbo operator `>>`:
-
 ```ruby
-AddMulti = AddsTwo.compose(MultipliesThree)
+MultipliesAddsOne = Multiplies >> AddsOne
 
-AddMulti.call(3)
-# => 15
-
-MultiAdd = MultipliesThree >> AddsTwo
-
-MultiAdd[3]
-# => 11
+MultipliesAddsOne[2, 3]
+# => 7
 ```
 
-The difference between the two is that the turbo operator will splat arrays passed between the composed objects but `compose` will not.
+`>>` splats intermediate results. Use `>` to compose without splatting intermediate results.
 
 ```ruby
-class SplitDigits
+class SplitsDigits
   include Functo.call :split, :number
 
   def split
@@ -120,58 +55,51 @@ class SplitDigits
   end
 end
 
-class Sum
-  include Functo.call :sum, :first, :second, :third
+class Sums
+  include Functo.call :sum, :arr
 
   def sum
-    first + second + third
+    arr.reduce(:+)
   end
 end
 
-SumDigits = SplitDigits >> Sum
-
-SumDigits[123]
-# => 6
+SumsDigits = SplitsDigits >> Sums
+SumsDigits[1066]
+# => ArgumentError: wrong number of arguments (4 for 1)
 
-SumDigits2 = SplitDigits.compose(Sum)
-
-SumDigits2[123]
-# => ArgumentError: wrong number of arguments (given 1, expected 3)
+SumsDigits2 = SplitsDigits > Sums
+SumsDigits2[1066]
+# => 13
 ```
 
-### Filters
-
-Filters can be passed to the Functo constructor, for example to implement types or coercion. A filter can be anything which responds to `[]`.
+Any object that responds to `call` can be made composable.
 
 ```ruby
-class ValidatesNumeric
-  include Functo.call :validate, :number
-
-  ValidationError = Class.new(StandardError)
+SquareRoots = Functo.wrap ->(n) { Math.sqrt(n) }
 
-  def validate
-    raise ValidationError unless number.is_a?(Numeric)
+SquareRootsAddsOne = SquareRoots >> AddsOne
+SquareRootsAddsOne[16]
+# => 5.0
+```
 
-    number
-  end
-end
+### Filters
 
-class AddsThree
-  include Functo.call :add, number: ValidatesNumeric
+```ruby
+class DividesTwo
+  include Functo.call :divide, number: ->(n) { Float(n) }
 
-  def add
-    number + 2
+  def divide
+    2 / number
   end
 end
 
-AddsThree[10]
-# => 13
-
-AddsThree['10']
-# => ValidationError
+DividesTwo['4']
+# => 0.5
 ```
 
-You could use the `dry-types` gem for example.
+A filter can be any object that responds to `call` or `[]`.
+
+For example using [dry-types](https://github.com/dry-rb/dry-types).
 
 ```ruby
 require 'dry-types'
@@ -180,30 +108,28 @@ module Types
   include Dry::Types.module
 end
 
-class AddsFour
-  include Functo.call :add, number: Types::Strict::Int
+class Squares
+  include Functo.call :square, number: Types::Strict::Int
 
-  def add
-    number + 4
+  def square
+    number**2
   end
 end
 
-AddsFour[4]
-# => 4
-
-AddsFour['4']
-# => Dry::Types::ConstraintError
+Squares[4]
+# => 16
 
+Squares['4']
+# => Dry::Types::ConstraintError: "4" violates constraints
 ```
 
-If you have multiple arguments and only want one of them to have a filter, you can use `Functo.pass` for a filter that just returns its input.
-
 ## Acknowledgements
 
-Functo was inspired by these gems:
+Functo was inspired by:
 
 * [concord](https://github.com/mbj/concord) by mbj
 * [procto](https://github.com/snusnu/procto) by snusnu
+* [dry-pipeline](https://github.com/dry-rb/dry-pipeline)
 
 ## Contributing
 

data/lib/functo.rb

@@ -1,52 +1,66 @@
 require "functo/version"
+require "functo/compose"
 
 class Functo < Module
-  MAX_ARGUMENTS = 3
+  MAX_ATTRIBUTES = 3
   PASS = '__FUNCTO_PASS__'.freeze
 
-  private_class_method :new
+  class << self
+    private :new
 
-  def self.wrap(obj)
-    klass = Class.new
+    def define_method_object(&block)
+      Class.new.tap do |klass|
+        klass.define_singleton_method(:call, &block)
+        klass.extend(Functo::Compose)
+      end
+    end
 
-    klass.define_singleton_method :call do |*args|
-      obj.call(*args)
+    def wrap(obj)
+      define_method_object do |*args|
+        obj.call(*args)
+      end
     end
 
-    klass.extend(ClassMethods)
-    klass
-  end
+    def pass
+      PASS
+    end
 
-  def self.pass
-    PASS
-  end
+    def call(*args)
+      new(*parse_args(args))
+    end
 
-  def self.call(*names)
-    output = names.shift
+    private
 
-    if names.first.is_a?(Hash)
-      inputs = names.first
-      filters = inputs.values
-      names = inputs.keys
-    else
-      filters = [pass] * names.length
-    end
+    def parse_args(args)
+      function, *inputs = *args
 
-    if names.length > MAX_ARGUMENTS
-      raise ArgumentError.new("given #{names.length} arguments when only #{MAX_ARGUMENTS} are allowed")
-    end
+      if inputs.first.is_a?(Hash)
+        inputs = inputs.first
+
+        attributes = inputs.keys
+        filters = inputs.values
+      else
+        attributes = inputs
+        filters = [pass] * inputs.length
+      end
 
-    new(names, filters, output)
+      if attributes.length > MAX_ATTRIBUTES
+        raise ArgumentError.new("given #{attributes.length} attributes when only #{MAX_ATTRIBUTES} are allowed")
+      end
+
+      [attributes, function, filters]
+    end
   end
 
   private
 
-  def initialize(inputs, filters, output)
-    @inputs = inputs
+  def initialize(attributes, function, filters)
+    @attributes = attributes
+    @function = function
     @filters = filters
-    @output = output
-    @inputs_module = Module.new
-    @output_module = Module.new
+
+    @attributes_module = Module.new
+    @function_module = Module.new
 
     define_initialize
     define_readers
@@ -54,27 +68,30 @@ class Functo < Module
   end
 
   def included(host)
-    host.include(@inputs_module)
-    host.extend(@output_module)
+    host.include(@attributes_module)
+    host.extend(@function_module)
 
-    host.extend(ClassMethods)
+    host.extend(Functo::Compose)
   end
 
   def define_initialize
-    ivars = @inputs.map { |name| "@#{name}" }
-    filter_proc = method(:apply_filters).to_proc
-    size = @inputs.size
+    ivars = @attributes.map { |name| "@#{name}" }
+    size = @attributes.size
+    filter = method(:apply_filters).to_proc
 
-    @inputs_module.class_eval do
+    @attributes_module.class_eval do
       define_method :initialize do |*args|
         args_size = args.size
 
         if args_size != size
-          fail ArgumentError, "wrong number of arguments (#{args_size} for #{size})"
+          message = "wrong number of arguments (#{args_size} for #{size})"
+
+          raise ArgumentError.new(message)
         end
 
-        args = filter_proc.(args)
-        ivars.zip(args) { |ivar, arg| instance_variable_set(ivar, arg) }
+        ivars.zip(filter.call(args)) do |ivar, arg|
+          instance_variable_set(ivar, arg)
+        end
       end
 
       private :initialize
@@ -82,27 +99,27 @@ class Functo < Module
   end
 
   def define_readers
-    attribute_names = @inputs
+    attributes = @attributes
 
-    @inputs_module.class_eval do
-      attr_reader(*attribute_names)
-      protected(*attribute_names)
+    @attributes_module.class_eval do
+      attr_reader(*attributes)
+      protected(*attributes)
     end
   end
 
   def define_call
-    call_method = @output
+    function = @function
 
-    @output_module.class_eval do
+    @function_module.class_eval do
       define_method :call do |*args|
-        new(*args).public_send(call_method)
+        new(*args).public_send(function)
       end
     end
   end
 
   def apply_filters(args)
     args.zip(@filters).map do |arg, filter|
-      if filter === Functo.pass
+      if filter.equal?(Functo.pass)
         arg
       elsif filter.respond_to?(:[])
         filter[arg]
@@ -114,35 +131,4 @@ class Functo < Module
     end
   end
 
-  module ClassMethods
-    def [](*args)
-      call(*args)
-    end
-
-    def to_proc
-      public_method(:call).to_proc
-    end
-
-    def compose(outer, splat: false)
-      inner = self
-      klass = Class.new
-
-      klass.define_singleton_method :call do |*args|
-        if splat
-          outer.call(*inner.call(*args))
-        else
-          outer.call(inner.call(*args))
-        end
-      end
-
-      klass.extend(ClassMethods)
-      klass
-    end
-
-    def >>(outer)
-      compose(outer, splat: true)
-    end
-  end
-  private_constant(:ClassMethods)
-
 end

data/lib/functo/compose.rb

@@ -0,0 +1,29 @@
+module Functo::Compose
+  def [](*args)
+    call(*args)
+  end
+
+  def to_proc
+    public_method(:call).to_proc
+  end
+
+  def compose(outer, splat: false)
+    inner = self
+
+    Functo.define_method_object do |*args|
+      if splat
+        outer.call(*inner.call(*args))
+      else
+        outer.call(inner.call(*args))
+      end
+    end
+  end
+
+  def >(outer)
+    compose(outer, splat: false)
+  end
+
+  def >>(outer)
+    compose(outer, splat: true)
+  end
+end

data/lib/functo/version.rb

@@ -1,3 +1,3 @@
 class Functo < Module
-  VERSION = "0.1.3"
+  VERSION = "0.1.4"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: functo
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.1.4
 platform: ruby
 authors:
 - Samuel Scully
@@ -70,6 +70,7 @@ files:
 - bin/setup
 - functo.gemspec
 - lib/functo.rb
+- lib/functo/compose.rb
 - lib/functo/version.rb
 homepage: https://github.com/sbscully/functo
 licenses: