squeeze 0.1.0

data/LICENSE

@@ -0,0 +1,8 @@
+Copyright (c) 2012 Matthew King
+
+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/lib/squeeze.rb

@@ -0,0 +1,121 @@
+require "squeeze/hash_tree"
+
+module Squeezable
+  def self.included(mod)
+    mod.module_eval do
+      extend ClassMethods
+      include InstanceMethods
+    end
+  end
+
+  module ClassMethods
+    def squeezable(options=nil)
+      if options
+        @squeeze_spec = options
+      else
+        @squeeze_spec || superclass.squeezable rescue nil
+      end
+    end
+  end
+
+  module InstanceMethods
+    def squeeze(dataset=nil)
+      unless dataset
+        if meth = self.class.squeezable[:dataset_method]
+          dataset ||= self.send(meth)
+        else
+          raise ArgumentError, "Must give #squeeze a dataset"
+        end
+      end
+      squeezer.reduce(dataset)
+    end
+
+    def squeezer
+      @squeezer ||= Squeeze.new(:fields => self.class.squeezable[:fields])
+    end
+  end
+
+  module Sequel
+    def self.included(mod)
+      mod.module_eval do
+        include Squeezable
+        def_dataset_method(:squeeze) do
+          squeezer = Squeeze.new(:fields => mod.squeezable[:fields])
+          squeezer.reduce(self)
+        end 
+      end
+    end
+  end
+end
+
+class Squeeze
+
+  attr_reader :output
+  attr_accessor :reports, :derived
+
+  def self.fields(spec=nil)
+    @fields ||= {}
+    spec ? @fields = spec : @fields
+  end
+
+  def initialize(options={})
+    f = options[:fields] || {}
+    @fields = self.class.fields.merge(f)
+    @derived = options[:derived] || {}
+    @output = HashTree.new
+  end
+
+  # Takes an array of hashes, keyed with Symbols
+  def reduce(records)
+    records.each do |record|
+      process(record, @fields)
+    end
+    @output
+  end
+
+  def process(record, fields, sig=[])
+    case fields
+    when Hash
+      fields.each do |field, subfields|
+        process_field(record, field, subfields, sig)
+      end
+    when Array
+      fields.each do |field|
+        process_field(record, field, true, sig)
+      end
+    end
+  end
+
+  def process_field(record, field, subfields, sig)
+    return unless key = resolve(field, record)
+    case subfields
+    when true
+      output.increment(sig + [field, key])
+      output.increment(sig + [field, :_count])
+    when Symbol
+      output.increment(sig + [field, key, :_count])
+      value = resolve(subfields, record)
+      output.increment(sig + [field, key, subfields, value])
+    when Array
+      subfields.each do |subfield|
+        process(record, {field => subfield}, sig )
+      end
+    when Hash
+      output.increment(sig + [field, key, :_count])
+      process(record, subfields, sig + [field, key])
+    end
+  end
+
+  def resolve(name, record)
+    result = if v = record[name]
+      v
+    elsif p = @derived[name]
+      p.call(record)
+    elsif record.respond_to?(name)
+      record.send(name)
+    else
+      :_unknown
+    end
+  end
+
+end

data/lib/squeeze/hash_tree.rb

@@ -0,0 +1,153 @@
+require "squeeze/traversable"
+
+# A Hash subclass with a default proc that creates another HashTree
+# on attempts to access missing keys.
+class HashTree < Hash
+  include Squeeze::Traversable
+
+  # Override the constructor to provide a default_proc
+  # NOTE: there's a better way to do this in 1.9.2, it seems.
+  # See Hash#default_proc=
+  def self.new()
+    hash = Hash.new { |h,k| h[k] = HashTree.new }
+    super.replace(hash)
+  end
+
+  def self.[](hash)
+    ht = self.new
+    ht << hash
+    ht
+  end
+
+  def _dump(depth)
+    h = Hash[self]
+    h.delete_if {|k,v| v.is_a? Proc }
+    Marshal.dump(h)
+  end
+
+  def self._load(*args)
+    h = Marshal.load(*args)
+    ht = self.new
+    ht.replace(h)
+    ht
+  end
+
+  # Follow the path specified, creating new nodes where necessary.
+  # Returns the value at the end of the path. If a block is supplied,
+  # it will be called with the last node and the last key as parameters,
+  # analogous to Hash.new's default proc. This is necessary to allow
+  # setting a value at the end of the path.  See the implementation of #insert.
+  def create_path(sig)
+    final_key = sig.pop
+    hash = self
+    sig.each do |a|
+      hash = hash[a]
+    end
+    yield(hash, final_key) if block_given?
+    hash[final_key]
+  end
+
+  # Attempt to retrieve the value at the end of the path specified,
+  # without creating new nodes.  Returns nil on failure.
+  # TODO: consider whether splatting the signature is wise.
+  def find(*sig)
+    stage = self
+    sig.each do |a|
+      if stage.has_key?(a)
+        stage = stage[a]
+      else
+        return nil
+      end
+    end
+    stage
+  end
+
+  def children(matcher=true)
+    next_keys = self.keys.select do |key|
+      match?(matcher, key)
+    end
+    self.values_at(*next_keys)
+  end
+
+  def +(other)
+    out = HashTree.new
+    _plus(other, out)
+    out
+  end
+
+  def _plus(ht2, out)
+    self.each do |k1,v1|
+      v1 = v1.respond_to?(:dup) ? v1 : v1.dup
+      if ht2.has_key?(k1)
+        v2 = ht2[k1]
+        if v1.respond_to?(:_plus)
+          out[k1] = v1
+          v1._plus(v2, out[k1])
+        elsif v2.respond_to?(:_plus)
+          raise ArgumentError,
+            "Can't merge leaf with non-leaf:\n#{v1.inspect}\n#{v2.inspect}"
+        else
+          if v2.is_a?(Numeric) && v1.is_a?(Numeric)
+            out[k1] = v1 + v2
+          else
+            out[k1] = [v1, ht2[k1]]
+          end
+        end
+      else
+        # should anything happen here?
+      end
+    end
+    ht2.each do |k,v|
+      if self.has_key?(k)
+        # should anything happen here?
+      else
+        v = v.respond_to?(:dup) ? v : v.dup
+        out[k] = v
+      end
+    end
+  end
+
+  def <<(other)
+    other.each do |k,v1|
+      if self.has_key?(k)
+        v2 = self[k]
+        if v1.respond_to?(:has_key?) && v2.respond_to?(:has_key?)
+          v2 << v1
+        elsif v1.is_a?(Numeric) && v2.is_a?(Numeric)
+          self[k] = v1 + v2
+        else
+          raise ArgumentError,
+            "Can't merge leaf with non-leaf:\n#{v1.inspect}\n#{v2.inspect}"
+        end
+      else
+        if v1.respond_to?(:has_key?)
+          self[k] << v1
+        else
+          self[k] = v1
+        end
+      end
+    end
+  end
+
+  def match?(val, key)
+    case val
+    when true
+      true
+    when String, Symbol
+      key == val
+    when Regexp
+      key =~ val
+    when Proc
+      val.call(key)
+    when nil
+      false
+    else
+      raise ArgumentError, "Unexpected matcher type: #{val.inspect}"
+    end
+  end
+
+end
+
+
+
+

data/lib/squeeze/matcher.rb

@@ -0,0 +1,28 @@
+class Squeeze
+
+  # Matchers are initialized with a pattern, to be used for
+  # retrieval in a HashTree.  What makes Matcher special,
+  # really the only reason it exists, is that it overrides #eql?
+  # and #hash so that Hashes will treat two Matchers as the same
+  # object if their patterns are the same.  This prevents
+  # redundancy when a HashTree creates its internal tree.
+  class Matcher
+    attr_reader :pattern
+    def initialize(pattern)
+      @pattern = pattern || true
+    end
+
+    def call(val)
+      @pattern == val || @pattern == true
+    end
+
+    def eql?(other)
+      other.kind_of?(self.class) && other.pattern == @pattern
+    end
+
+    def hash
+      @pattern.hash
+    end
+  end
+
+end

data/lib/squeeze/traversable.rb

@@ -0,0 +1,128 @@
+class Squeeze
+  # Tree classes including this module must supply these methods:
+  #
+  # * #create_path(path_signature)
+  # * #find(path_signature)
+  # * #children(node_matcher)
+  module Traversable
+
+    # Follow or create the path specified by the signature and assign
+    # the value as a terminating leaf node.
+    #  
+    #  h.set([:a, :b, :c], "This is a retrievable value")
+    #
+    def set(sig, val)
+      raise ArgumentError if sig.empty?
+      create_path(sig) do |node, key|
+        node[key] = val
+      end
+    end
+
+    def reduce(sig, base=0)
+      create_path(sig) do |node, key|
+        node[key] = base unless node.has_key?(key)
+        node[key] = yield node[key]
+      end
+    end
+
+    def increment(sig, val=1)
+      val = yield if block_given?
+      create_path(sig) do |node, key|
+        if node.has_key?(key)
+          node[key] = node[key] + val
+        else
+          node[key] = val
+        end
+      end
+    end
+
+     # Usage:
+    # a = ht.reducer([:a, :b, :c], 0) {|acc, v| acc + v }
+    # a[1]
+    def reducer(sig, base, &block)
+      p = nil
+      create_path(sig) do |node, key|
+        unless node.has_key?(key)
+          node[key] = base
+        end
+        p = lambda do |newval|
+          node[key] = block.call(node[key], newval)
+        end
+      end
+      p
+    end
+
+    def sum(*args)
+      out = 0
+      retrieve(*args) { |v| out += v }
+      out
+    end
+
+    def count(*args)
+      args = args + [:_count]
+      sum(*args)
+    end
+
+    def unique(*args)
+      out = 0
+      filter(*args) { |v| out += v.size }
+      out
+    end
+
+    # like retrieve, but will return any kind of node
+    def filter(*sig)
+      results = []
+      search(sig) do |node|
+        results << node
+        yield(node) if block_given?
+      end
+      results
+    end
+
+    # Given a signature array, attempt to retrieve matching leaf values.
+    def retrieve(*sig)
+      results = []
+      search(sig) do |node|
+        results << node unless node.respond_to?(:children)
+        yield(node) if block_given?
+      end
+      results
+    end
+
+    # Generic tree search method
+    def search(sig)
+      current_nodes = [self]
+
+      while !current_nodes.empty?
+        next_nodes = []
+        matcher = sig.shift
+        if matcher
+          current_nodes.each do |node|
+            if node.respond_to?(:children)
+              next_nodes += node.children(matcher)
+            end
+          end
+        else
+          current_nodes.each {|n| yield(n) }
+        end
+        current_nodes = next_nodes
+      end
+    end
+
+    def traverse
+      current_nodes = [self]
+      while !current_nodes.empty?
+        next_nodes = []
+        current_nodes.each do |node|
+          if node.respond_to?(:children)
+            next_nodes += node.children(true)
+            yield(node)
+          end
+        end
+
+        current_nodes = next_nodes
+      end
+    end
+
+  end
+end

metadata

@@ -0,0 +1,87 @@
+--- !ruby/object:Gem::Specification 
+name: squeeze
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: 
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Matthew King
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-08-30 00:00:00 -05:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: riot
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 37
+        segments: 
+        - 0
+        - 12
+        - 5
+        version: 0.12.5
+  type: :development
+  version_requirements: *id001
+description: 
+email: 
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- LICENSE
+- README.md
+- lib/squeeze/hash_tree.rb
+- lib/squeeze/traversable.rb
+- lib/squeeze/matcher.rb
+- lib/squeeze.rb
+has_rdoc: true
+homepage: https://github.com/automatthew/squeeze
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: Tools for working with nested data structures in Ruby
+test_files: []
+