qig 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f92505d2904e0032d3fcd5b33f03540a7ce8d09080bc50a534ede7e2daecf686
-  data.tar.gz: 16caa89894a03819be080591bd729b89ddfb743712122fff401b18e2e2ba0ae9
+  metadata.gz: 56ef9b278c456d21a26c5aa5c4af9c3fd44ac5c5b8ebc6f680d528c2380e1af3
+  data.tar.gz: c5bee04e6937170225b362ae777a7456c488b85afec37695fd5167530d0eaa13
 SHA512:
-  metadata.gz: ab2d2ace58c87bc6117a20d9ca2e6b1d329398cd5ce895fb2f206abb5f66a06782b4f8d3d48716719e2a67f7091f6e938aebc9bc7e329652782583952b82533a
-  data.tar.gz: 9362297e8f6feb6a9f390302ae7d12093877fdd3215f5894b366a05b41330093479b027745b6579ff546bba4f27a79f539d5f985ed89c1a87c07d663acdbe9c7
+  metadata.gz: f01814583296ea94b8839b6fb057b27880c92dc23870d533c192d1ed36a34a6d9650a58390f1c5e85cc2a6d92ed3356678f7bb069419015416087df208890d19
+  data.tar.gz: c4b2a0d910a66ba27e2b6f24963e015b404759c092f1915126d3c7aebccdf50205d6ab96e6ee480ef20709e361e475bf27b9702f0918b7fded24762e12766526

data/CHANGELOG.md

@@ -1,3 +1,19 @@
+# 0.4.0 (Jan 27, 2022)
+
+## Features
+
+- `Qig::Qiggable` mixin for adding chainable `.qig` syntax to subject classes.
+- Allow stepping into enumerables.
+
+## Fixes
+
+- make unboxing (`[]`) compatible with `Enumerable`. Previously in collection-context this used `flatten(1)`, which
+  `Enumerable` does not support. Now uses `flat_map(&:itself)` instead
+
+## Documentation
+
+- Literate spec covering compatibility with lazy enumerators.
+
 # 0.3.0 (January 24, 2022)
 
 ## BREAKING CHANGES

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    qig (0.3.0)
+    qig (0.4.0)
 
 GEM
   remote: https://rubygems.org/

data/README.md

@@ -3,22 +3,37 @@
 [![Gem Version](https://badge.fury.io/rb/qig.svg)](https://badge.fury.io/rb/qig)
 [![CircleCI](https://circleci.com/gh/NAR8789/qig-ruby/tree/main.svg?style=shield)](https://circleci.com/gh/NAR8789/qig-ruby/tree/main)
 
-qig is dig extended with jq's "value iterator" `[]` operator.
+qig is dig extended with jq's "value iterator" `[]` operator and some other goodies.
+
+## Usage
+
+```ruby
+Qig.qig(subject, *path) # => contents of subject at path
+```
+
+examples:
+```ruby
+# dig-like usage
+Qig.qig({a: { b: { c: 1 } } }, :a, :b, :c) # => 1
+
+# dig-like usage augmented with jq's [] operator
+Qig.qig({a: { b: [ { c: 1 }, { c: 2 } ] } }, :a, :b, [], :c) # => [1, 2]
+
+# after expanding values, collect them back into an array for indexing into with `[[]]`
+Qig.qig({ a: { b: [{ c: 1 }, { c: 2 }] } }, :a, :b, [], :c, [[]], 1) # => 2
+```
+
+More documentation in the [literate specs](spec/literate)
 
 ## Features
 
-- [x] compatible with dig
-  - [x] qig into arrays and hashes
-  - [x] qig into structs
-  - [x] qig into OpenStructs
-  - [x] qig into CSV::Tables
-  - [x] qig into CSV::Rows
-- [x] nifty jq extensions
-  - [x] value iteration over arrays
-  - [x] value iteration over hashes
+- [x] compatible with dig (see (dig conformance specs)[spec/literate/qig/02_conformance/dig_conformance_spec.rb])
+- [x] jq-like value iteration (`[]` operator)
 - [x] invoke ruby methods during inside the filter chain
 - [x] value collect: `[[]]`, inverse of the `[]` operator. Collect streamed values back into an array
-- [ ] option to monkey patch this for more dig-like `subject.qig(*path)` syntax
+- [x] `Qig::Qiggable` mixin for more dig-like `subject.qig(*path)` syntax
+- [ ] extensive literate specs
+  - [ ] works with lazy collections
 
 ## Installation
 
@@ -36,18 +51,6 @@ Or install it yourself as:
 
     $ gem install qig
 
-## Usage
-
-```ruby
-Qig.qig(subject, *path) # => contents of subject at path
-```
-
-examples:
-```ruby
-Qig.qig({a: { b: { c: 1 } } }, :a, :b, :c) # => 1
-Qig.qig({a: { b: [ { c: 1 }, { c: 2 } ] } }, :a, :b, [], :c) # => [1, 2]
-```
-
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

data/lib/qig/qiggable.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Qig
+  # mix-in to add a `.qig` method to any class.
+  # NOTE: Target class should support `#[]`, `#map`, and either `#flat_map` or `#values` for full qig functionality
+  # - `#[]`: used for stepping in unit context
+  # - `#map`: used for stepping in collection context
+  # - `#flat_map` or `#values`: used for unboxing in collection context
+  module Qiggable
+    # @param path [Array<String, Symbol, Array, Object>] retrieval path to apply to `subject`
+    #
+    # @return [Object, Array<Object>] the value(s) of `self` located at `path`
+    def qig(*path)
+      Qig.qig(self, *path)
+    end
+
+    # see Enumerable#lazy
+    #
+    # This version extends the underlying lazy enumerable with Qig::Qiggable
+    def lazy
+      super.extend(Qig::Qiggable)
+    end
+  end
+end

data/lib/qig/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Qig
-  VERSION = '0.3.0'
+  VERSION = '0.4.0'
 end

data/lib/qig.rb

@@ -5,6 +5,8 @@ require_relative 'qig/version'
 # Combining the powers of `dig` and `jq`.
 # Qig is dig extended with jq's value iteration `[]` operator.
 module Qig
+  autoload :Qiggable, 'qig/qiggable.rb'
+
   class << self
     # @param subject [Array, Hash, #[]] `subject` to be qug into.
     # @param path [Array<String, Symbol, Array, Object>] retrieval path to apply to `subject`
@@ -50,13 +52,13 @@ module Qig
       end
     end
 
-    def collection_qig(subjects, *path) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+    def collection_qig(subjects, *path) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength, Metrics/CyclomaticComplexity
       head, *rest = path
       case head
       in nil
         subjects
       in []
-        collection_qig(subjects.map(&method(:values)).flatten(1), *rest)
+        collection_qig(subjects.map(&method(:values)).flat_map(&:itself), *rest)
       in [[]]
         unit_qig(subjects, *rest)
       in ['', key]
@@ -79,7 +81,17 @@ module Qig
     end
 
     def step(subject, key)
-      subject&.[](key)
+      case subject
+      in Enumerable unless subject.respond_to?(:[])
+        case key
+        in Integer
+          subject.drop(key).first
+        in Range
+          subject.drop(key.begin).take(key.count)
+        end
+      else
+        subject&.[](key)
+      end
     rescue NameError, IndexError
       # Struct's [] is strict and raises on missing key.
       # TODO: more efficient / prettier way of doing this. How does struct itself implement dig?

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: qig
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Xiao Fan
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-01-24 00:00:00.000000000 Z
+date: 2022-01-27 00:00:00.000000000 Z
 dependencies: []
 description: 
 email:
@@ -30,6 +30,7 @@ files:
 - bin/console
 - bin/setup
 - lib/qig.rb
+- lib/qig/qiggable.rb
 - lib/qig/version.rb
 - qig.gemspec
 - sig/qig.rbs