ioughta 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 9bd946f7ba2d07976031712406bf90ea7c845b6d
+  data.tar.gz: 323d3409b17d8db6c1e64a7c9bbd664f3d524036
+SHA512:
+  metadata.gz: 5efc1fd72d5e450ed3e6ca13022b6d69ded722c9fde75e294bcf5cafc588c2802152b46fef58e651b90f20cb487208692e344f33078072289e9181c78d8069b3
+  data.tar.gz: 162ddfcede4fe8d9b0182f9a020e6ade3aa126fd030978786fa1a9546a6390db689a7e51df4ccff017e8437b2b0bd69d60c6bb3f962578501e918c42d21ddf2e

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,9 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.2.5
+  - 2.3.1
+  - ruby-head
+  - jruby-9.1.5.0
+  - jruby-head
+before_install: gem install bundler -v 1.13.0

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Mike Pastore
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,179 @@
+# Io(ugh)ta
+
+[![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.
+
+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:
+
+```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
+)
+```
+
+Here it is in Ruby, using ioughta:
+
+```ruby
+Object.ioughta_const(
+  :IG_EGGS, ->(ioughta) { 1 << ioughta },
+  :IG_CHOCOLATE,
+  :IG_NUTS,
+  :IG_STRAWBERRIES,
+  :IG_SHELLFISH
+)
+
+IG_STRAWBERRIES # => 8
+```
+
+Or, perhaps a little more Rubyishly:
+
+```ruby
+IG = Object.ioughta_hash(
+  :eggs, ->(i) { 1 << i },
+  :chocolate,
+  :nuts,
+  :strawberries,
+  :shellfish
+).freeze
+
+IG[:strawberries] # => 8
+```
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'ioughta'
+```
+
+And then execute:
+
+```sh
+$ bundle
+```
+
+Or install it yourself as:
+
+```sh
+$ gem install ioughta
+```
+
+## Usage
+
+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:
+
+```ruby
+require 'ioughta'
+include Ioughta
+
+Object.ioughta_const(:FOO, :BAR, :QUX)
+
+QUX # => 2
+```
+
+To skip value(s) in the sequence, use the `:_` symbol:
+
+```ruby
+Object.ioughta_const(:_, :FOO, :BAR, :_, :QUX)
+
+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:
+
+```ruby
+Object.ioughta_const(
+  :A,                   # will use the default lambda  (0 =>   0)
+  :B, ->(i) { i * 2 },  # will multiply by two         (1 =>   2)
+  :C,                   # will also multiply by two    (2 =>   4)
+  :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)
+)
+```
+
+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!
+
+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
+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.
+
+Here is a very contrived and arbitrary example:
+
+```ruby
+require 'ioughta'
+
+module MyFileUtils
+  include Ioughta
+
+  iota_const :EXECUTE, ->(b) { 0b1 << b }, :WRITE, :READ
+  iota_const :TACKY, ->(b) { 0b1 << b }, :SETGID, :SETUID
+
+  SHIFT = iota_hash(:other, ->(d) { d * 3 }, :group, :user, :special).freeze
+  MASK = iota_hash(:other, ->(_o, key) { 07 << SHIFT[key] }, :group, :user, :special).freeze
+
+  def self.mask_and_shift(mode, field)
+    (mode & MASK[field]) >> SHIFT[field]
+  end
+end
+
+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 can take the key at the current iteration as
+an optional second argument.
+
+## 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.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To
+release a new version, update the version number in `version.rb`, and then run
+`bundle exec rake release`, which will create a git tag for the version, push
+git commits and tags, and push the `.gem` file to
+[rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at
+https://github.com/mwpastore/ioughta.
+
+## License
+
+The gem is available as open source under the terms of the [MIT
+License](http://opensource.org/licenses/MIT).
+
+[1]: https://splice.com/blog/iota-elegant-constants-golang/

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/ioughta.gemspec

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+# coding: utf-8
+lib = File.expand_path('lib', __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'ioughta/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'ioughta'
+  spec.version       = Ioughta::VERSION
+  spec.authors       = ['Mike Pastore']
+  spec.email         = ['mike@oobak.org']
+
+  spec.summary       = 'Helpers for defining Go-like constants and hashes using iota'
+  spec.homepage      = 'http://github.com/mwpastore/ioughta'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.required_ruby_version = '>= 2.2.0'
+
+  spec.add_development_dependency 'bundler', '~> 1.13'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rspec', '~> 3.0'
+end

data/lib/ioughta/version.rb

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

data/lib/ioughta.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+require 'ioughta/version'
+
+module Ioughta
+  def self.included(base)
+    class << base
+      def ioughta_const(*data)
+        each_resolved_pair(pair(data)) { |nom, val| const_set(nom, val) }
+      end
+
+      alias_method :iota_const, :ioughta_const
+
+      def ioughta_hash(*data)
+        each_resolved_pair(pair(data)).to_h
+      end
+
+      alias_method :iota_hash, :ioughta_hash
+
+      private
+
+      DEFAULT_LAMBDA = proc(&:itself)
+      SKIP_SYMBOL = :_
+
+      def lazy_iota
+        (0..Float::INFINITY).lazy
+      end
+
+      def pair(data)
+        data, lam = data.dup, DEFAULT_LAMBDA
+        lazy_iota.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
+        end
+        data
+      end
+
+      def each_resolved_pair(data)
+        return enum_for(:each_resolved_pair, data) unless block_given?
+
+        data.each_slice(2).with_object(lazy_iota) do |(nom, lam), iota|
+          val = lam.arity == 2 ? lam.call(iota.next, nom) : lam.call(iota.next)
+          next if nom == SKIP_SYMBOL
+          yield nom, val
+        end
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,97 @@
+--- !ruby/object:Gem::Specification
+name: ioughta
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Mike Pastore
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2016-09-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.13'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.13'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: 
+email:
+- mike@oobak.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/setup
+- ioughta.gemspec
+- lib/ioughta.rb
+- lib/ioughta/version.rb
+homepage: http://github.com/mwpastore/ioughta
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: Helpers for defining Go-like constants and hashes using iota
+test_files: []