with_ease 0.0.0 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: eb2fe2e40c1ff0b1a90a49ac10de9b1ce58265af246dbf5827be968979cf9b7c
-  data.tar.gz: 2339362eba09d95578f6335e747e3afe5b018f919160e7282ca5431836bc0ba9
+  metadata.gz: 1acaa86f823eeec13d846b6af27f39e94ec5bffa9d19fa81ce78994680efbfa5
+  data.tar.gz: 2c23c88589ed075d3289e27528e9d8ceb1acda6eeee0a45e6c21cae6a95240ef
 SHA512:
-  metadata.gz: 588e084c2df28c6824fc52f61f03b2a922c29a0dd9d8b4a3321872a90ef4ce9679ec02c746d3b67c3592b9cd57e88786a64a8bc4a04ea91e150b0ae30f30c885
-  data.tar.gz: 9333f074ca9fdd12e8a0d72ec37de12a8605506da317b72baef1326b1ac91c03c1d3f6cd757505e90c94739ac83587ba0ba9f90dbeaf30a0bdf2504df61e1d2f
+  metadata.gz: a6cb7b523b7481b4696242a2addd533cd08c158f6652e8e8ab11b2aa6cbeb262abfbde383a14ad51e3dda8013ff45ba431901fdcd075636aaf48d73c10aac6f8
+  data.tar.gz: 2f5c8b59bf12285100c0cabf7a592a55117a8b6c0e0e9d946141d14c76290c24c2770a8bc519210ac4b58cf3bf7c5b45a73292d570aec7e6f79d97a87f46937e

data/README.md

@@ -1,16 +1,175 @@
-[![Gem Version](https://badge.fury.io/rb/lab42_base.svg)](http://badge.fury.io/rb/lab42_base)
-[![Gem Downloads](https://img.shields.io/gem/dt/lab42_base.svg)](https://rubygems.org/gems/lab42_base)
+[![Gem Version](https://badge.fury.io/rb/with_ease.svg)](http://badge.fury.io/rb/with_ease)
+[![Gem Downloads](https://img.shields.io/gem/dt/with_ease.svg)](https://rubygems.org/gems/with_ease)
 
-# lab42_base
+# WithEase
 
-Finally extracting the minimum code I use literally everywhere...
+Very basic but useful extensions to Ruby.
 
-## Which Are 
+**N.B.:** still in alpha
 
-- [Extensions to `OpenStruct`](spec/open_struct) 
-- [Extensions to `Forwardable`](spec/forwardable)
-- [`WithEase::ClosedStruct`](spec/closed_struct) 
+## Installation
 
+```sh
+  gem install with_ease
+```
+
+With bundler
+
+```ruby
+  gem 'with_ease'
+```
+
+## Usage
+
+```ruby
+  require 'with_ease'
+```
+
+For more sophisticated tools and imports into the current tools look at the [speculations](speculations)
+
+In all the speculations we assume that `require 'with_ease'` has been used in the setup (`spec_helper.rb` or
+ `speculations_helper.rb`)
+
+## Synopsis
+
+What can you do `WithEase`.
+
+#### Have an `OpenStruct` with a complete Hash like API
+
+  - merge, update, slice
+  - pattern matching
+
+#### Have a `ClosedStruct` with the same API but fixed keys
+
+#### Have a lean wrapper `Forward` around `Forwardable` which is actually **readable!**
+
+[c.f. for details](speculations/forward.md)
+
+#### Have an `Iterator` class (and constructor function if you want).
+
+Nothing you cannot do with `Enumerator::Lazy` but so much simpler again.
+
+[c.f for details](speculations/iterator.md)
+
+#### Extend the `&:<method>` cludge from symbols to arrays with `Array#.to_proc`
+
+My philosophy on this, is either use both or hate both
+
+[c.f for details](speculations/array_to_proc.md)
+
+## Quick Start
+
+All functionality is described in detail in the [speculations](speculations) (see links above for
+the specific speculations of a functionality).
+
+But here is a quick overview (also tested with the [speculate_about gem](https://rubygems.org/gems/speculate_about) as all other speculations).
+
+### Context: `OpenStruct`
+
+Given
+```ruby
+    require 'with_ease'
+
+    let(:subject) { OpenStruct.new(a: 1, b: 2) }
+```
+
+Then we can use it mostly like a `Hash` instance.
+```ruby
+    expect(subject.merge(a: 11, c: 31)).to eq(OpenStruct.new(a: 11, b: 2, c:31))
+```
+And we can pattern match
+```ruby
+    subject => {a:, b: 2}
+    expect(a).to eq(1)
+```
+
+### Context: `ClosedStruct`
+
+Given
+```ruby
+    require 'with_ease'
+    ClosedStruct = WithEase::ClosedStruct
+
+    let(:subject) { ClosedStruct.new(a: 1, b: 2) }
+```
+
+Then we can do pretty much the same as with `OpenStruct`
+```ruby
+   subject.update(a: 0)
+   expect(subject).to eq(ClosedStruct.new(a: 0, b: 2))
+    
+```
+
+But you must not add a key
+```ruby
+    expect { subject.update(c: 3) }
+      .to raise_error(KeyError)
+    expect{ subject.merge(c: 3) }
+      .to raise_error(KeyError)
+```
+
+[c.f for details](speculations/closed_struct.md)
+
+### Context: `Iterator`
+
+As mentioned above you can ~easily~ (it's not complicated but it is not easy!) create
+an iterator in Ruby, howver this one is so much simpler.
+
+Given
+```ruby
+    require 'with_ease'
+    Iterator = WithEase::Iterator
+
+    let(:subject) { Iterator.new(0, &:succ) }
+```
+
+Then we can just advance it
+```ruby
+    expect(subject.value).to be_zero
+    expect(subject.advance.value).to eq(1)
+```
+
+It is an `Enumerable` of course and quite lazy, if you are intereted
+[here is more](speculations/iterator.md)
+
+
+
+[c.f for details](speculations/iterator.md)
+
+### Context: `Forward`
+
+Given
+```ruby
+    require 'with_ease'
+    
+    Forward = WithEase::Forward
+```
+
+**N.B.**: We could have used `require 'with_ease/import_all'` instead.
+
+And
+```ruby
+    class Wrapper
+      extend Forward
+      forward :empty?, :size, to: :@array
+      def initialize(array) = @array = array.to_a
+    end
+
+    let(:subject) { Wrapper.new(0..9) }
+```
+
+Then we can see that
+```ruby
+    expect(subject).not_to be_empty
+    expect(subject.size).to eq(10)
+```
+But also
+```ruby
+    expect(Wrapper.new([])).to be_empty
+```
+
+
+[c.f. for details](speculations/forward.md)
 
 ## Author
 

data/lib/with_ease/all.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require_relative 'array_to_proc'
+require_relative 'closed_struct'
+require_relative 'forward'
+require_relative 'iterator'
+require_relative 'open_struct'
+
+ClosedStruct = WithEase::ClosedStruct
+Forward = WithEase::Forward
+Iterator = WithEase::Iterator
+
+require_relative 'constructor_functions'
+# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/with_ease/{forwardable.rb → array_to_proc.rb}

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-module Forwardable
-  def forward *methods, to:
-    def_delegators to, *methods
+class Array
+  def to_proc
+    -> { it.send(*self) }
   end
 end
 # SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/with_ease/closed_struct.rb

@@ -1,12 +1,12 @@
 # frozen_string_literal: true
 
-require_relative 'forwardable'
+require_relative 'forward'
 require_relative 'closed_struct/hash_api'
 
 module WithEase
   class ClosedStruct
 
-    extend Forwardable
+    extend Forward
     include HashApi
 
     forward :deconstruct_keys, :fetch, :to_a, :to_h, to: :@data

data/lib/with_ease/constructor_functions.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require_relative 'closed_struct'
+require_relative 'iterator'
+require_relative 'open_struct'
+
+def ClosedStruct(**k) = WithEase::ClosedStruct.new(**k)
+def Iterator(init, &blk) = WithEase::Iterator.new(init, &blk)
+def OpenStruct(**k) = WithEase::OpenStruct.new(**k)
+# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/with_ease/forward.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module WithEase
+  module Forward
+    def self.extended(into) = into.extend Forwardable
+
+    def forward *methods, to:
+      def_delegators to, *methods
+    end
+  end
+end
+# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/with_ease/iterator.rb

@@ -6,6 +6,11 @@ module WithEase
 
     attr_reader :advancer, :value
 
+    def advance = drop
+    def advance_fn = -> { drop }
+
+    def call = advance
+
     def drop(n=1) 
       n.times do
         @value = @advancer.(value)
@@ -14,14 +19,28 @@ module WithEase
     end
     def drop_fn = -> (n=1) { drop n }
 
+    def drop_while(&blk)
+      loop do
+        return self unless blk.(value)
+        advance
+      end
+    end
+
+    def map(&blk)
+      lazy.map(&blk)
+    end
 
     def each
       loop do
         yield value
-        drop
+        advance
       end
     end
+
     def take_fn = -> (n) { take n }
+    def take_while_fn = -> (&blk) { take_while(&blk) }
+
+    def to_proc = ->(*) { value }
 
     private
     def initialize(value, &advancer)

data/lib/with_ease/open_struct/hash_api.rb

@@ -35,7 +35,7 @@ module WithEase
       end
 
       def _merge_with_blk(key, **keys, &blk)
-        raise ArgumentError, "no **keys arguments allowed in block form" unless keys.empty?
+        raise ArgumentError, "no **keys arguments allowed if block given" unless keys.empty?
         value = fetch(key)
         _merge(key => blk.(value))
       end

data/lib/with_ease/open_struct.rb

@@ -1,10 +1,10 @@
 # frozen_string_literal: true
 
 require 'ostruct'
-require_relative 'forwardable'
+require_relative 'forward'
 require_relative 'open_struct/hash_api'
 class OpenStruct
-  extend Forwardable
+  extend WithEase::Forward
   forward :deconstruct_keys, :fetch, :to_a, to: :to_h
   forward :deconstruct, to: :to_a
 

data/lib/with_ease/version.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
 module WithEase
-    VERSION = "0.0.0"
+    VERSION = "0.0.2"
 end
 # SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/with_ease.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require_relative 'with_ease/closed_struct'
+require_relative 'with_ease/forward'
+require_relative 'with_ease/iterator'
+require_relative 'with_ease/open_struct'
+
+# SPDX-License-Identifier: AGPL-3.0-or-later

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: with_ease
 version: !ruby/object:Gem::Version
-  version: 0.0.0
+  version: 0.0.2
 platform: ruby
 authors:
 - Robert Dober
@@ -33,10 +33,14 @@ extra_rdoc_files: []
 files:
 - LICENSE
 - README.md
+- lib/with_ease.rb
+- lib/with_ease/all.rb
+- lib/with_ease/array_to_proc.rb
 - lib/with_ease/base.rb
 - lib/with_ease/closed_struct.rb
 - lib/with_ease/closed_struct/hash_api.rb
-- lib/with_ease/forwardable.rb
+- lib/with_ease/constructor_functions.rb
+- lib/with_ease/forward.rb
 - lib/with_ease/import_base.rb
 - lib/with_ease/iterator.rb
 - lib/with_ease/open_struct.rb