ioughta 0.2.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0c12c98fe08970c112e895a81c1a235bfc89c34b
-  data.tar.gz: 69c50f6794139a6ccb84c51630a418ef33381eb0
+  metadata.gz: 7918cd422602dfb4b8d10a0a22a41ecd7385d092
+  data.tar.gz: 529732cd9cfc9f3e8dc9f11422aaaa43dea9a35e
 SHA512:
-  metadata.gz: d8ee63a12106312f5701f9ddc2b7c2ded8b77e8febcb19a16ee94205de2ad4fcf290f75da6b8b1448e92e0a3ebfec5b977d01f3e395e83853b969464d384d6dc
-  data.tar.gz: 1a9382fdfdf9c4a57bdb58eb12e3f373d7db4e42e93922cb85b2e9174ccffb86e8de3341bb6b5a78e59bf042da657d052a41514ba4d8589f44fca975fc9e426b
+  metadata.gz: 9c64d851fb46da155fb80c475ba9ae391cb3deee69106f196e35a5c9c99a45b275ddc4d6f8197cdd98164b2614a44cc58dac40d9f2d33cd2eb3a0204711257a7
+  data.tar.gz: c7ac30fba3192205a238ac82b4fb3833a523b0f7c063611ab5bee3ad3e1baaf85d4e43d8434ab09a26ea401542edaf23710753a52ea2a037189c2eb55e52958b

data/README.md

@@ -3,28 +3,36 @@
 [![Build Status](https://travis-ci.org/mwpastore/ioughta.svg?branch=master)](https://travis-ci.org/mwpastore/ioughta)
 [![Gem Version](https://badge.fury.io/rb/ioughta.svg)](https://badge.fury.io/rb/ioughta)
 
-Helpers for defining Go-like constants and hashes in Ruby using iota.
+Helpers for defining sequences of constants in Ruby using a Go-like syntax.
 
 Go has quite a nice facility for defining constants derived from a sequential
 value using a [simple and elegant syntax][1], so I thought I'd steal it for
 Ruby. Rubyists tend to group constants together in hashes rather than littering
 their programs with countless constants, so there's a mechanism for that, too.
 
-Here's an example, written in Go:
+Although there isn't as strong of a need for sequences of constants in Ruby as
+there is in other languages such as Go, they are still sometimes required when
+working with external systems such as databases and web APIs for which Ruby
+symbols don't map cleanly. For example, a database column might store users'
+privilege levels as 0, 1, or 2, and it would be useful to define constants that
+map to those values. Ruby doesn't have a native expression for this construct
+(other than simply defining them one at a time).
+
+Here's a simple example, written in Go:
 
 ```go
 type Allergen int
 
 const (
-    IgEggs Allergen = 1 << iota   // 1 << 0 which is 00000001
-    IgChocolate                   // 1 << 1 which is 00000010
-    IgNuts                        // 1 << 2 which is 00000100
-    IgStrawberries                // 1 << 3 which is 00001000
-    IgShellfish                   // 1 << 4 which is 00010000
+    IgEggs Allergen = 1 << iota // 1 << 0 which is 00000001
+    IgChocolate                 // 1 << 1 which is 00000010
+    IgNuts                      // 1 << 2 which is 00000100
+    IgStrawberries              // 1 << 3 which is 00001000
+    IgShellfish                 // 1 << 4 which is 00010000
 )
 ```
 
-Here it is in Ruby, using ioughta:
+And here it is in Ruby, using ioughta:
 
 ```ruby
 Object.ioughta_const(
@@ -41,15 +49,15 @@ IG_STRAWBERRIES # => 8
 Or, perhaps a bit more Rubyishly:
 
 ```ruby
-IG = Object.ioughta_hash(->(i) { 1 << i }, %i[
+IG = Object.iota_hash(%i[
   eggs
   chocolate
   nuts
   strawberries
   shellfish
-]).freeze
+]) { |i| 1 << i }.freeze
 
-IG[:strawberries] # => 8
+IG[:shellfish] # => 16
 ```
 
 ## Installation
@@ -76,9 +84,11 @@ $ gem install ioughta
 
 Ioughta works just like `const` and `iota` do in Go, with only a few minor
 differences. You must `include` the module in your program, class, or module in
-order to start using it. The iterator starts at zero (`0`) and increments for
-each constant. The default lambda is simply `:itself`, so you can very easily
-create a sequence of constants with consecutive integer values:
+order to start using it. The iterator starts at zero (0) and increments for
+each constant (or hash key) being defined. A function (any Ruby callable) takes
+the current iteration as input and returns the value to be assigned. The
+default function simply returns the iterator, so you can easily create
+sequences of constants with consecutive integer values:
 
 ```ruby
 require 'ioughta'
@@ -86,6 +96,8 @@ include Ioughta
 
 Object.ioughta_const(:FOO, :BAR, :QUX)
 
+FOO # => 0
+BAR # => 1
 QUX # => 2
 ```
 
@@ -94,13 +106,14 @@ To skip value(s) in the sequence, use the `:_` symbol:
 ```ruby
 Object.ioughta_const(:_, :FOO, :BAR, :_, :QUX)
 
+FOO # => 1
+BAR # => 2
 QUX # => 4
 ```
 
-As soon as Ioughta sees a lambda, it will start using it to generate future
-values from the iterator. In Go parlance, this is (apparently) known as
-*implicit repetition of the last non-empty expression list*. You can redefine
-the lambda as many times as you like:
+As soon as Ioughta sees a lambda (or any Ruby callable), it will start using it
+to generate future values from the iterator. You can redefine the lambda as
+many times as you like:
 
 ```ruby
 Object.ioughta_const(
@@ -110,35 +123,42 @@ Object.ioughta_const(
   :D, ->(j) { j ** 3 }, # will cube                    (3 =>  27)
   :E,                   # will also cube               (4 =>  64)
   :F,                   # cube all the things          (5 => 125)
-  :G, proc(&:itself)    # restore the default behavior (6 =>   6)
+  :G, ->{ 0.5 }         # will use a simple value      (6 => 0.5)
+  :H, proc(&:itself)    # restore the default behavior (7 =>   7)
 )
 ```
 
 You can also pass the lambda as the first argument:
 
 ```ruby
-Object.ioughta_const ->(i) { 1 << (10 * i) }, %i[_ KB MB GB TB PB EB ZB YB]
+Object.Ioughta_const ->(I) { 1 << (10 * I) }, %I[_ KIB MIB GIB TIB PIB EIB ZIB YIB]
 ```
 
 Or even pass a block, instead of a lambda:
 
 ```ruby
-BYTES = Object.ioughta_hash(%i[_ KB MB GB TB PB EB ZB YB]) { |i| 1 << (10 * i) }.freeze
+BYTES = Object.ioughta_hash(%i[_ KB MB GB TB PB EB ZB YB]) { |i| 10 ** (i * 3) }.freeze
 ```
 
+If the first argument is a lambda *and* a block is given, the block will be
+silently ignored.
+
+## Notes
+
 The only major feature missing from the Go implementation is the ability to
 perform parallel assignment in the constant list. We're defining a list of
 terms, not a list of expressions, so it's not possible to do in Ruby without
-resourcing to nasty `eval` tricks. Don't forget to separate your terms with
-commas!
+resourcing to nasty `eval` tricks. **Don't forget to separate your terms with
+commas and freeze your hash constants!**
 
 You've probably noticed that in order to use Ioughta in the top-level
 namespace, we need to explicitly specify the `Object` receiver (just like we
 need to do for `#const_set`). I didn't want to get too crazy with the
-monkeypatching and/or dynamic dispatch. No such limitation exists when
+monkey-patching and/or method delegation. No such limitation exists when
 including Ioughta in a module or class, thanks to the available context. Also,
-if the `ioughta_const` and `ioughta_hash` methods are too ugly for you (I don't
-blame you), they're aliased as `iota_const` and `iota_hash`, respectively.
+if the `ioughta_const` and `ioughta_hash` method names are too ugly for you (I
+don't blame you), they're aliased as `iota_const` and `iota_hash`,
+respectively.
 
 Here is a very contrived and arbitrary example:
 
@@ -163,7 +183,7 @@ MyFileUtils.mask_and_shift(0644, :user) & MyFileUtils::EXECUTE # => 0
 MyFileUtils.mask_and_shift(01777, :special) & MyFileUtils::TACKY # => 1
 ```
 
-One note on the above: the lambda (or block) can take the key at the current
+One note on the above: the lambda (or block) can take the "key" at the current
 iteration as an optional second argument.
 
 ## Development
@@ -177,6 +197,10 @@ release a new version, update the version number in `version.rb`, and then run
 git commits and tags, and push the `.gem` file to
 [rubygems.org](https://rubygems.org).
 
+## Trivium
+
+Pronounced /aɪ ˈɔtə/, as in the English phrase "Why, I oughta...!"
+
 ## Contributing
 
 Bug reports and pull requests are welcome on GitHub at

data/ioughta.gemspec

@@ -10,7 +10,7 @@ Gem::Specification.new do |spec|
   spec.authors       = ['Mike Pastore']
   spec.email         = ['mike@oobak.org']
 
-  spec.summary       = 'Helpers for defining Go-like constants and hashes using iota'
+  spec.summary       = 'Helpers for defining sequences of constants in Ruby using a Go-like syntax'
   spec.homepage      = 'http://github.com/mwpastore/ioughta'
   spec.license       = 'MIT'
 

data/lib/ioughta.rb

@@ -5,7 +5,7 @@ module Ioughta
   def self.included(base)
     class << base
       def ioughta_const(*data, &block)
-        each_resolved_pair(pair(data, &block)) do |nom, val|
+        each_resolved_ipair(data, block) do |nom, val|
           const_set(nom, val)
         end
       end
@@ -13,7 +13,7 @@ module Ioughta
       alias_method :iota_const, :ioughta_const
 
       def ioughta_hash(*data, &block)
-        each_resolved_pair(pair(data, &block)).to_h
+        each_resolved_ipair(data, block).to_h
       end
 
       alias_method :iota_hash, :ioughta_hash
@@ -23,38 +23,20 @@ module Ioughta
       DEFAULT_LAMBDA = proc(&:itself)
       SKIP_SYMBOL = :_
 
-      def pair(data, &block)
-        data = data.flatten
-        lam =
-          if block
-            block
-          elsif data.first.respond_to?(:call)
-            data.shift
-          else
-            DEFAULT_LAMBDA
-          end
-
-        (0..Float::INFINITY).lazy.each do |i|
-          if i % 2 != 0
-            if data[i].respond_to?(:call)
-              lam = data[i]
-            else
-              data.insert(i, lam)
-            end
-          elsif data[i].nil?
-            break
-          end
+      def each_ipair_with_index(data, block = nil)
+        data = data.to_a.flatten(1)
+        lam = (data.shift if data[0].respond_to?(:call)) || block || DEFAULT_LAMBDA
+
+        data.each_with_index do |nom, i, j = i.succ|
+          yield nom, data[j].respond_to?(:call) ? lam = data.slice!(j) : lam, i
         end
-        data
       end
 
-      def each_resolved_pair(data)
-        return enum_for(__method__, data) { data.length / 2 } unless block_given?
+      def each_resolved_ipair(*args)
+        return enum_for(__method__, *args) unless block_given?
 
-        data.each_slice(2).with_index do |(nom, lam), iota|
-          val = lam.call(*[iota, nom].take(lam.arity.abs))
-          next if nom == SKIP_SYMBOL
-          yield nom, val
+        each_ipair_with_index(*args) do |nom, lam, iota|
+          yield nom, lam.call(*[iota, nom].take(lam.arity.abs)) unless nom == SKIP_SYMBOL
         end
       end
     end

data/lib/ioughta/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: false
 module Ioughta
-  VERSION = '0.2.1'.freeze
+  VERSION = '0.3.0'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ioughta
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.3.0
 platform: ruby
 authors:
 - Mike Pastore
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-09-14 00:00:00.000000000 Z
+date: 2016-09-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -93,5 +93,5 @@ rubyforge_project:
 rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
-summary: Helpers for defining Go-like constants and hashes using iota
+summary: Helpers for defining sequences of constants in Ruby using a Go-like syntax
 test_files: []