with_ease 0.0.0 → 0.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: eb2fe2e40c1ff0b1a90a49ac10de9b1ce58265af246dbf5827be968979cf9b7c
-  data.tar.gz: 2339362eba09d95578f6335e747e3afe5b018f919160e7282ca5431836bc0ba9
+  metadata.gz: b82599593f37f0f889da475eff808db8fb46259754cd245d11ea842f6e454325
+  data.tar.gz: 3bf87be2c1b028d522205597c7d952a055bab0907ccc8f2d805ac40902a148ba
 SHA512:
-  metadata.gz: 588e084c2df28c6824fc52f61f03b2a922c29a0dd9d8b4a3321872a90ef4ce9679ec02c746d3b67c3592b9cd57e88786a64a8bc4a04ea91e150b0ae30f30c885
-  data.tar.gz: 9333f074ca9fdd12e8a0d72ec37de12a8605506da317b72baef1326b1ac91c03c1d3f6cd757505e90c94739ac83587ba0ba9f90dbeaf30a0bdf2504df61e1d2f
+  metadata.gz: ab419bec4a95ac73a27eed1746a9c231d6c381f318449a92fdba9b77be68a8ebf42a94c855a20fcc627e11f8415f7a5889116e50fb4f1c1d2ae517018d9b5abe
+  data.tar.gz: aea48838989fd9360f3054eea73c7aee0d5968ab43089bb612e2342656b30e81deecb530cc4ebeac2cae390cdb2111e5949c52c7cf3a8e3f1cfe50439a7028ad

data/README.md

@@ -1,16 +1,170 @@
-[![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)
+
+
+## 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/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/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,8 @@ module WithEase
 
     attr_reader :advancer, :value
 
+    def advance = drop(1)
+
     def drop(n=1) 
       n.times do
         @value = @advancer.(value)

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.1"
 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.1
 platform: ruby
 authors:
 - Robert Dober
@@ -33,10 +33,11 @@ extra_rdoc_files: []
 files:
 - LICENSE
 - README.md
+- lib/with_ease.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/forward.rb
 - lib/with_ease/import_base.rb
 - lib/with_ease/iterator.rb
 - lib/with_ease/open_struct.rb

data/lib/with_ease/forwardable.rb

@@ -1,8 +0,0 @@
-# frozen_string_literal: true
-
-module Forwardable
-  def forward *methods, to:
-    def_delegators to, *methods
-  end
-end
-# SPDX-License-Identifier: AGPL-3.0-or-later