rlet 0.5.1 → 0.6.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 8109f3f222f16dbf36e7da3292ed7987f00a5932
+  data.tar.gz: 17310f476fb99e9f82a8ce6147b63c2663908f80
+SHA512:
+  metadata.gz: 9c15981e58772ccf331396163b264b1a1b6f1506ccc5f9c1d45a21a3c0e36636200879f519b12e2a81df18c9032a4fc080e01ad40fecc1164a4620680e3ce1e7
+  data.tar.gz: 91b670103ba95aad945548791632b239df8287cf2e4ecc24d155cc8f3561392188022bc3f526fdcb84e5524608b5ae2207465fabc5d9c6dc1222c69d42b0ccda

data/README.md

@@ -1,54 +1,212 @@
-rlet
-====
+# rlet
 
-Ruby let(), class-based lexical scoping
+This library contains a library for RSpec-style let() declartions for lazy evaluation,
+concerns, and a few functional operators.
 
-Unlike ruby-let, or what is proposed here http://www.opensourcery.com/blog/zack-hobson/objectlet-ruby-0 
-this does not actually mimic the let of functional programming. Instead, it controls scope idiomatic
-to Ruby -- "everything is an object".
+Unlike ruby-let, or what is proposed here http://www.opensourcery.com/blog/zack-hobson/objectlet-ruby-0
+this does not actually mimic the let of functional programming.
 
-Here, let() defines a method in the class. The values are memoized. This allows for both
+Here, `let()` defines a method in the class. The values are memoized. This allows for both
 lazy-evaluation and class-based scoping.
 
-This is based on RSpec let(). Tutorials and documentation are forthcoming.
+By defining methods for lazy evaluation and grouping them into concerns, you can create
+mixins that can be shared across multiple objects. Lazy-eval lends itself to functional
+programming, so a small refinment is made available for use.
 
-INSTALLING
-====
+## INSTALLING
 
-  gem install rlet
+    gem install rlet
 
 Or from bundler
 
-  gem 'rlet'
+    gem 'rlet'
 
 
-USAGE
-====
+## USAGE
 
-The gems contain two modules, Let and Concern. You can use them like so:
+### Let and Concern
 
-  require 'rlet'
+The gems contain two modules, Let and Concern. You can use them like so:
 
-  class ContactsController
-    include Let
-    include RestfulResource
-  
-    let(:model) { Contact }
-  
-    def show
-      respond_with resource
+    require 'rlet'
+    
+    class ContactsController
+      include Let
+      include RestfulResource
+    
+      let(:model) { Contact }
+    
+      def show
+        respond_with resource
+      end
     end
-  end
-  
-  module RestfulResource
-    extend Concern
-  
-    included do
-      let(:resource) { model.find(id) }
-      let(:id) { params[:id]
+    
+    module RestfulResource
+      extend Concern
+    
+      included do
+        let(:resource) { model.find(id) }
+        let(:id) { params[:id] }
+      end
     end
-  end
-
 
 Concern is embedded from ActiveSupport. If ActiveSupport::Concern is loaded, it will use that. This
 allows one to use concerns without having ActiveSupport as a dependency.
+
+### LazyOptions
+
+One pattern that comes up is creating a class which takes an option as an initializer, and then
+using `let()` to define values based on those options.
+
+For example:
+
+    module Intentions
+      class Promise
+        include Let
+        extend Intentions::Concerns::Register
+    
+        attr_reader :identifier, :promiser, :promisee, :body, :metadata
+    
+        let(:identifier) { Digest::SHA2.new.update(to_digest.inspect).to_s }
+        let(:sign)       { metadata[:sign] }
+        let(:scope)      { metadata[:scope] }
+        let(:timestamp)  { Time.now.utc }
+        let(:salt)       { rand(100000) }
+    
+        def initialize(_promiser, _promisee, _body, _metadata = {})
+          @promiser = _promiser.freeze
+          @promisee = _promisee.freeze
+          @body     = _body.freeze
+          @metadata = _metadata.freeze
+          self
+        end
+    
+        def to_h
+          to_digest.merge(identifier: identifier)
+        end
+    
+        def to_digest
+          {
+            promiser:  promiser,
+            promisee:  promisee,
+            body:      body,
+            metadata:  metadata,
+            timestamp: timestamp,
+            salt:      salt
+          }
+        end
+    
+      end
+    end
+
+We can refactor into:
+
+    module Intentions
+      class Promise
+        include Let
+        extend Intentions::Concerns::Register
+    
+        attr_reader :options
+    
+        let(:promiser)   { options[:promiser] }
+        let(:promisee)   { options[:promisee] }
+        let(:body)       { options[:body] }
+        let(:metadata)   { options[:metadata] }
+    
+        let(:identifier) { Digest::SHA2.new.update(to_digest.inspect).to_s }
+        let(:sign)       { metadata[:sign] }
+        let(:scope)      { metadata[:scope] }
+        let(:timestamp)  { Time.now.utc }
+        let(:salt)       { rand(100000) }
+    
+        def initialize(_options = {})
+          @options = _options
+        end
+    
+        def to_h
+          to_digest.merge(identifier: identifier)
+        end
+    
+        def to_digest
+          {
+            promiser:  promiser,
+            promisee:  promisee,
+            body:      body,
+            metadata:  metadata,
+            timestamp: timestamp,
+            salt:      salt
+          }
+        end
+    
+      end
+    end
+
+This pattern occurs so frequently that `rlet` not includes a `LazyOptions` concern.
+
+    require 'rlet/lazy_options'
+    module Intentions
+      class Promise
+        include Let
+        include LazyOptions
+        extend Intentions::Concerns::Register
+    
+        let(:promiser)   { options[:promiser] }
+        let(:promisee)   { options[:promisee] }
+        let(:body)       { options[:body] }
+        let(:metadata)   { options[:metadata] }
+    
+        let(:identifier) { Digest::SHA2.new.update(to_digest.inspect).to_s }
+        let(:sign)       { metadata[:sign] }
+        let(:scope)      { metadata[:scope] }
+        let(:timestamp)  { Time.now.utc }
+        let(:salt)       { rand(100000) }
+    
+        def to_h
+          to_digest.merge(identifier: identifier)
+        end
+    
+        def to_digest
+          {
+            promiser:  promiser,
+            promisee:  promisee,
+            body:      body,
+            metadata:  metadata,
+            timestamp: timestamp,
+            salt:      salt
+          }
+        end
+    
+      end
+    end
+
+### Functional Operators
+
+Lazy-eval lends itself well to functional patterns. However, Ruby doesn't include many
+built-in operators for working with higher order functions. `rlet` includes a refinment (Ruby 2.0+)
+that adds in some operators.
+
+Currently, only two are supported: `|` which composes right, and `*` which composes left.
+
+The best example is when working with Intermodal presenters:
+
+    require 'rlet/functional'
+    
+    module SomeApi
+      module API
+        class V1_0 < Intermodal::API
+          using RLet::Functional
+     
+          self.default_per_page = 25
+     
+          map_data do
+            attribute = ->(field) { ->(r) { r.send(field) } }
+            helper    = ->(_method) { ActionController::Base.helpers.method(_method) }
+     
+            presentation_for :book do
+              presents :id
+              presents :price,    with: attribute.(:price) | helper.(:number_to_currency)
+            end
+          end
+        end
+      end
+    end

data/lib/rlet/functional.rb

@@ -0,0 +1,33 @@
+# This module requires refinements (Ruby 2.1+)
+#
+# To use this module, specify it with the using keyword:
+#
+# class StreamProcessor
+#   include Let
+#   using RLet::Functional
+#
+#   let(:user)      { User.create (minimum | with_photos).() }
+#   let(:minimum)   { { username: 'user', password: 'password' } }
+#   let(:with_nick) { ->(x) { x.merge(nick: 'Breaker') } }
+# end
+
+module RLet
+  module Functional
+    module Compose
+      def *(other)
+        Proc.new { |x| call(other.call(x)) }
+      end
+      def |(other)
+        Proc.new { |x| other.call(call(x)) }
+      end
+    end
+
+    refine Proc do
+      include Compose
+    end
+
+    refine Method do
+      include Compose
+    end
+  end
+end

data/lib/rlet/lazy_options.rb

@@ -0,0 +1,31 @@
+# Include this module when you want to have a hash initializer. This
+# allows you to build let() definitions derived from what gets passed
+# into the initializer
+#
+# For example:
+#
+# class Task
+#   include Let
+#   include RLet::LazyOptions
+#
+#   let(:name) { options[:name] }
+# end
+#
+# t = Task.new name: 'MyTask'
+# t.name
+# => 'MyTask'
+
+module RLet
+  module LazyOptions
+    extend Concern
+
+    included do
+      attr_reader :options
+
+      def initialize(opts = {})
+        @options = opts
+      end
+    end
+
+  end
+end

metadata

@@ -1,50 +1,50 @@
 --- !ruby/object:Gem::Specification
 name: rlet
 version: !ruby/object:Gem::Version
-  version: 0.5.1
-  prerelease: 
+  version: 0.6.1
 platform: ruby
 authors:
 - Ho-Sheng Hsiao
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-08-09 00:00:00.000000000Z
+date: 2015-02-27 00:00:00.000000000 Z
 dependencies: []
-description: Class-based scoping with let(). Use rspec's let() outside of rspec
+description: Use rspec's let() outside of rspec with concerns and functional operators
 email:
-- hosh@opscode.com
+- talktohosh@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- lib/rlet/concern.rb
-- lib/rlet/let.rb
-- lib/rlet.rb
 - LICENSE.txt
 - README.md
+- lib/rlet.rb
+- lib/rlet/concern.rb
+- lib/rlet/functional.rb
+- lib/rlet/lazy_options.rb
+- lib/rlet/let.rb
 homepage: http://github.com/hosh/rlet
 licenses: []
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: 1.3.6
 requirements: []
 rubyforge_project: rlet
-rubygems_version: 1.8.10
+rubygems_version: 2.2.2
 signing_key: 
-specification_version: 3
-summary: Class-based scoping with let()
+specification_version: 4
+summary: Lazy-eval and functional helpers
 test_files: []