abstractivator 0.0.15

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 47647350eb409b2ff52995a8e4f7349134cebb60
+  data.tar.gz: c2a3f24a61450361a6a8ccd6fc1265005970be91
+SHA512:
+  metadata.gz: 9f0c2f1ad23e80a9e3633717456c3338b494b38591b557c58eecab7db713f4cdbc470367dd44d9c7e098d1f35c14e6e1c85e1a41b87ed83952036512343b52be
+  data.tar.gz: 407f9d10c8c0b83ec44ec33375a11cd2d6b1d8369ce664b0041b4dff8a4cf597ca5fcfd58d3dd249de68de8681dba4a86080360cf75caa5e118b4307cd2c6ddf

data/.gitignore

@@ -0,0 +1,23 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+.idea

data/.rspec

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

data/Gemfile

@@ -0,0 +1,10 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in abstractivator.gemspec
+gemspec
+
+group :test do
+  gem 'rspec'
+  gem 'json'
+  gem 'rails'
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Peter Winton
+
+MIT License
+
+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,29 @@
+# Abstractivator
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'abstractivator'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install abstractivator
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/abstractivator/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/abstractivator.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'abstractivator/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'abstractivator'
+  spec.version       = Abstractivator::VERSION
+  spec.authors       = ['Peter Winton']
+  spec.email         = ['pwinton@indigobio.com']
+  spec.summary       = %q{Utilities}
+  spec.description   = %q{Utilities}
+  spec.homepage      = ''
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler', '~> 1.6'
+  spec.add_development_dependency 'rake'
+  spec.add_runtime_dependency 'activesupport', '~> 4.0'
+  spec.add_runtime_dependency 'sourcify', '> 0'
+end

data/lib/abstractivator.rb

@@ -0,0 +1,2 @@
+require 'abstractivator/version'
+require 'abstractivator/trees'

data/lib/abstractivator/collections.rb

@@ -0,0 +1,22 @@
+module Abstractivator
+  module Collections
+    def multizip(enumerables, pad_value=nil)
+      es = enumerables.map(&:each)
+      result = []
+      fail_count = 0
+      while fail_count < es.size do
+        fail_count = 0
+        heads = es.map do |e|
+          begin
+            e.next
+          rescue StopIteration
+            fail_count += 1
+            pad_value
+          end
+        end
+        result << heads if fail_count < es.size
+      end
+      result
+    end
+  end
+end

data/lib/abstractivator/cons.rb

@@ -0,0 +1,58 @@
+module Abstractivator
+  module Cons
+    Nil = Object.new
+
+    def empty_list
+      Nil
+    end
+
+    def cons(h, t)
+      Cell.new(h, t)
+    end
+
+    def head(p)
+      p.first
+    end
+
+    def tail(p)
+      p.last
+    end
+
+    def list_to_enum(list)
+      Enumerator.new do |y|
+        while list != Nil
+          y << head(list)
+          list = tail(list)
+        end
+      end
+    end
+
+    def enum_to_list(enum)
+      e = enum.reverse.each
+      result = Nil
+      begin
+        while true
+          result = cons(e.next, result)
+        end
+      rescue StopIteration
+        result
+      end
+    end
+
+    class Cell < Array
+      def initialize(h, t)
+        super([h, t])
+      end
+
+      def head
+        first
+      end
+
+      def tail
+        last
+      end
+    end
+
+    extend self
+  end
+end

data/lib/abstractivator/enumerable_ext.rb

@@ -0,0 +1,94 @@
+require 'set'
+
+module Enumerable
+
+  # joins items from left with items from right based on their keys.
+  # get_{left,right}_key are callables which, given an item, return the item's key.
+  # the defaults are used to form a pair for items which have no match.
+  # returns an array of 2-element arrays, each of which is a left/right pair.
+  def self.outer_join(left, right, get_left_key, get_right_key, left_default, right_default)
+
+    ls = left.hash_map(get_left_key)
+    rs = right.hash_map(get_right_key)
+
+    raise 'duplicate left keys' if ls.size < left.size
+    raise 'duplicate right keys' if rs.size < right.size
+
+    result = []
+
+    ls.each_pair do |k, l|
+      r = rs[k]
+      if r
+        rs.delete(k)
+      else
+        r = get_default(right_default, l)
+      end
+      result.push [l, r]
+    end
+
+    rs.each_pair do |_, r|
+      result.push [get_default(left_default, r), r]
+    end
+
+    result
+  end
+
+  def self.inner_join(left, right, get_left_key, get_right_key)
+    sentinel = Object.new
+    result = self.outer_join(left, right, get_left_key, get_right_key, sentinel, sentinel)
+    result.reject { |pair| pair.first == sentinel || pair.last == sentinel }
+  end
+
+  def self.get_default(default, other_side_value)
+    proc?(default) ? default.(other_side_value) : default
+  end
+
+  def self.proc?(x)
+    x.respond_to?(:call)
+  end
+
+  def hash_map(get_key, &get_value)
+    Hash[self.map{|x| [get_key.(x), get_value ? get_value.(x) : x]}]
+  end
+
+  def outer_join(right, get_left_key, get_right_key, default_value)
+    Enumerable.outer_join(self, right, get_left_key, get_right_key, default_value, default_value)
+  end
+
+  def inner_join(right, get_left_key, get_right_key)
+    Enumerable.inner_join(self, right, get_left_key, get_right_key)
+  end
+
+  def uniq?
+    seen = Set.new
+    each_with_index do |x, i|
+      seen << (block_given? ? yield(x) : x)
+      return false if seen.size < i + 1
+    end
+    true
+  end
+
+  orig_detect = instance_method(:detect)
+  define_method :detect do |*args, &block|
+    detect = orig_detect.bind(self)
+
+    if args.size == 1 && !args.first.respond_to?(:call) && block
+      value = args.first
+      detect.call {|x| block.call(x) == value}
+    elsif args.size == 2 && !block
+      attr_name, value = args
+      detect.call {|x| x.send(attr_name) == value}
+    else
+      detect.call(*args, &block)
+    end
+  end
+
+  def inject_right(*args, &block)
+    self.reverse_each.inject(*args, &block) # reverse_each to avoid duplicating the enumerable, when possible
+  end
+
+  def pad_right(n, value=nil, &block)
+    block ||= proc { value }
+    self + ([n-self.size, 0].max).times.map(&block)
+  end
+end

data/lib/abstractivator/proc_ext.rb

@@ -0,0 +1,52 @@
+module MethodAndProcExtensions
+  def loosen_args
+    proc do |*args, &block|
+      Proc.loose_call(self, args, &block)
+    end
+  end
+end
+
+class Proc
+  include MethodAndProcExtensions
+
+  def compose(other)
+    proc{|x| self.call(other.call(x))}
+  end
+
+  def self.compose(*procs)
+    procs.inject_right(identity) { |inner, p| p.compose(inner) }
+  end
+
+  def self.identity
+    proc {|x| x}
+  end
+
+  def reverse_args
+    proc do |*args, &block|
+      self.call(*args.reverse, &block)
+    end
+  end
+
+  def self.loose_call(x, args, &block)
+    x.respond_to?(:call) ? x.call(*args.take(x.arity).pad_right(x.arity), &block) : x
+  end
+end
+
+class Method
+  include MethodAndProcExtensions
+end
+
+class UnboundMethod
+  def explicit_receiver
+    proc do |receiver, *args, &block|
+      self.bind(receiver).call(*args, &block)
+    end
+  end
+end
+
+class Array
+  def to_proc
+    raise 'size must be exactly one' unless size == 1
+    proc{|x| x[first]}
+  end
+end

data/lib/abstractivator/trees.rb

@@ -0,0 +1,220 @@
+require 'active_support/core_ext/object/deep_dup'
+require 'abstractivator/trees/block_collector'
+require 'sourcify'
+require 'delegate'
+require 'set'
+
+module Abstractivator
+  module Trees
+
+    SetMask = Struct.new(:items, :get_key)
+    def set_mask(items, get_key)
+      SetMask.new(items, get_key)
+    end
+
+    def tree_compare(tree, mask, path=[], index=nil)
+      if mask == [:*] && tree.is_a?(Enumerable)
+        []
+      elsif mask == :+ && tree != :__missing__
+        []
+      elsif mask == :- && tree != :__missing__
+        [diff(path, tree, :__absent__)]
+      elsif mask.respond_to?(:call)
+        comparable = mask.call(tree)
+        comparable ? [] : [diff(path, tree, mask)]
+      else
+        case mask
+          when Hash
+            if tree.is_a?(Hash)
+              mask.each_pair.flat_map do |k, v|
+                tree_compare(tree.fetch(k, :__missing__), v, push_path(path, k))
+              end
+            else
+              [diff(path, tree, mask)]
+            end
+          when SetMask # must check this before Enumerable because Structs are enumerable
+            if tree.is_a?(Enumerable)
+              # convert the enumerables to hashes, then compare those hashes
+              tree_items = tree
+              mask_items = mask.items.dup
+              get_key = mask.get_key
+
+              be_strict = !mask_items.delete(:*)
+              new_tree = hashify_set(tree_items, get_key)
+              new_mask = hashify_set(mask_items, get_key)
+              tree_keys = Set.new(new_tree.keys)
+              mask_keys = Set.new(new_mask.keys)
+              tree_only = tree_keys - mask_keys
+
+              # report duplicate keys
+              if new_tree.size < tree_items.size
+                diff(path, [:__duplicate_keys__, duplicates(tree_items.map(&get_key))], nil)
+              elsif new_mask.size < mask_items.size
+                diff(path, nil, [:__duplicate_keys__, duplicates(mask_items.map(&get_key))])
+              # hash comparison allows extra values in the tree.
+              # report extra values in the tree unless there was a :* in the mask
+              elsif be_strict && tree_only.any?
+                tree_only.map{|k| diff(push_path(path, k), new_tree[k], :__absent__)}
+              else # compare as hashes
+                tree_compare(new_tree, new_mask, path, index)
+              end
+            else
+              [diff(path, tree, mask.items)]
+            end
+          when Enumerable
+            if tree.is_a?(Enumerable)
+              index ||= 0
+              if !tree.any? && !mask.any?
+                []
+              elsif !tree.any?
+                [diff(push_path(path, index.to_s), :__missing__, mask)]
+              elsif !mask.any?
+                [diff(push_path(path, index.to_s), tree, :__absent__)]
+              else
+                # if the mask is programmatically generated (unlikely), then
+                # the mask might be really big and this could blow the stack.
+                # don't support this case for now.
+                tree_compare(tree.first, mask.first, push_path(path, index.to_s)) +
+                    tree_compare(tree.drop(1), mask.drop(1), path, index + 1)
+              end
+            else
+              [diff(path, tree, mask)]
+            end
+          else
+            tree == mask ? [] : [diff(path, tree, mask)]
+        end
+      end
+    end
+
+    private
+
+    def hashify_set(items, get_key)
+      Hash[items.map{|x| [get_key.call(x), x] }]
+    end
+
+    def duplicates(xs)
+      xs.group_by{|x| x}.each_pair.select{|_k, v| v.size > 1}.map(&:first)
+    end
+
+    def push_path(path, name)
+      path + [name]
+    end
+
+    def path_string(path)
+      path.join('/')
+    end
+
+    def diff(path, tree, mask)
+      {path: path_string(path), tree: tree, mask: massage_mask_for_diff(mask)}
+    end
+
+    def massage_mask_for_diff(mask)
+      if mask.respond_to?(:call)
+        massaged = :__predicate__
+        begin
+          massaged = mask.to_source
+        rescue Exception => e
+          raise unless e.class.name.start_with?('Sourcify')
+        end
+        massaged
+      else
+        mask
+      end
+    end
+
+    public
+
+    def tree_map(h)
+      raise ArgumentError.new('Must provide a transformer block') unless block_given?
+      config = BlockCollector.new
+      yield(config)
+      TransformTreeClosure.new.do_obj(h, config.get_path_tree)
+    end
+
+    class TransformTreeClosure
+      def initialize
+        @bias = 0 # symbol = +, string = -
+      end
+
+      def do_obj(obj, path_tree)
+        case obj
+          when nil; nil
+          when Array; do_array(obj, path_tree)
+          else; do_hash(obj, path_tree)
+        end
+      end
+
+      private
+
+      def do_hash(h, path_tree)
+        h = h.dup
+        path_tree.each_pair do |name, path_tree|
+          if path_tree.respond_to?(:call)
+            if (hash_name = try_get_hash_name(name))
+              hash_name, old_fh = get_key_and_value(h, hash_name)
+              unless old_fh.nil?
+                h[hash_name] = old_fh.each_with_object(old_fh.dup) do |(key, value), fh|
+                  fh[key] = path_tree.call(value.deep_dup)
+                end
+              end
+            elsif (array_name = try_get_array_name(name))
+              array_name, value = get_key_and_value(h, array_name)
+              unless value.nil?
+                h[array_name] = value.map(&:deep_dup).map(&path_tree)
+              end
+            else
+              name, value = get_key_and_value(h, name)
+              h[name] = path_tree.call(value.deep_dup)
+            end
+          else
+            name, value = get_key_and_value(h, name)
+            h[name] = do_obj(value, path_tree)
+          end
+        end
+        h
+      end
+
+      def get_key_and_value(h, string_key)
+        tried_symbol = @bias >= 0
+        trial_key = tried_symbol ? string_key.to_sym : string_key
+        value = h[trial_key]
+
+        if value.nil? # failed
+          @bias += (tried_symbol ? -1 : 1)
+          key = tried_symbol ? string_key : string_key.to_sym
+          [key, h[key]]
+        else
+          @bias += (tried_symbol ? 1 : -1)
+          [trial_key, value]
+        end
+      end
+
+      def do_array(a, path_tree)
+        a.map{|x| do_obj(x, path_tree)}
+      end
+
+      def try_get_hash_name(p)
+        p =~ /(.+)\{\}$/ ? $1 : nil
+      end
+
+      def try_get_array_name(p)
+        p =~ /(.+)\[\]$/ ? $1 : nil
+      end
+    end
+
+    public
+
+    def recursive_delete!(hash, keys)
+      x = hash # hash is named 'hash' for documentation purposes but may be anything
+      case x
+        when Hash
+          keys.each{|k| x.delete(k)}
+          x.each_value{|v| recursive_delete!(v, keys)}
+        when Array
+          x.each{|v| recursive_delete!(v, keys)}
+      end
+      x
+    end
+
+  end
+end