tukey 0.9.0RC

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a8d2baa0a928708c6c82a545a3f80fc50981fd23
+  data.tar.gz: b32cc0bce8639763a04b532bfde06455c69302f1
+SHA512:
+  metadata.gz: a787e0c9d891cbbcb66a566118194f90c20278865ba45c50506979baeb6e6da68473541d0c35c132d487b88bbe29c91fba793e8b41701e8a3084d1f12d46c5c9
+  data.tar.gz: 08803af0c3dc11cd02ebac3c32456af1b52dd691e6156e8398b16b65fb96a1b6160e0ff95046bde73bbb7b32cc2e1c327d6d45e53520fdecc0532aefc2f87a4c

data/.gitignore

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

data/.rspec

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

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.3.1
+before_install: gem install bundler -v 1.13.6

data/Gemfile

@@ -0,0 +1,7 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in tukey.gemspec
+gemspec
+
+gem 'pry', '~> 0.10.4'
+gem 'pry-coolline', '~> 0.2.5'

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 Achilleas Buisman
+
+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,98 @@
+![John Tukey - Statistician and inventor of the 'bit'](John_Tukey.jpg)
+
+*John Tukey - Statistician and inventor of the 'bit'*
+
+# Tukey
+
+Tukey is provides DataSets which can be put in a tree. This way you can store partial results of calculations or other data and, for example, create charts, tables or other presentations.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'tukey'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install tukey
+
+# Usage
+
+First a quick demonstration:
+
+![screencast](Tukey.gif)
+
+
+Then a quick example:
+
+```ruby
+    report = DataSet.new(label: 'Year star report')
+
+    report << DataSet.new(label: "January", data: 0)
+    report << DataSet.new(label: "February", data: 30)
+    report << DataSet.new(label: "March", data: 40)
+    report << DataSet.new(label: "April", data: 50)
+
+    # Get a total:
+    report.sum # => 120
+    report.average # => 30.0
+
+    # Labels of all leafs
+    # (useful when creating tables and charts, more on that later):
+    report.leaf_labels.map(&:name) # => ["January", "February", "March", "April"]
+
+    # Value of single children:
+    report.children.first.value # => 0
+
+    # Useful development output:
+    puts report.pretty_inspect
+    #=> * Year star report
+    #    |- January: 0
+    #    |- February: 30
+    #    |- March: 40
+    #    |- April: 50
+
+    # Filtering:
+    # (can be far more advances, more on that later)
+    report.filter { |p, set| set.value >= 40 }
+    #=> * Year star report
+    #  |- March: 40
+    #  |- April: 50
+
+    # Combining:
+    report2 = DataSet.new(label: "Yearly star report")
+    report2 << DataSet.new(label: 'January', data: 10)
+    report2 << DataSet.new(label: 'May', data: 60)
+    report2 << DataSet.new(label: 'June', data: 70)
+
+    report.combine(report2, :+)
+    #  * Year star report
+    # |- January: 10     # <= Note the added 10
+    # |- February: 30
+    # |- March: 40
+    # |- April: 50
+    # |- May: 60
+    # |- June: 70
+```
+
+## 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/abuisman/tukey.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+

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/console

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "tukey"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+require "pry"
+Pry.start

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/lib/tukey.rb

@@ -0,0 +1,2 @@
+require File.join(File.dirname(__FILE__), "tukey", "version")
+require File.join(File.dirname(__FILE__), "tukey", "data_set")

data/lib/tukey/data_set.rb

@@ -0,0 +1,294 @@
+require 'securerandom'
+require File.join(File.dirname(__FILE__), "data_set", "label")
+
+class DataSet
+  include Enumerable
+
+  attr_accessor :label
+
+  attr_accessor :data
+  attr_accessor :parent
+  attr_reader :id
+
+  def initialize(data: nil, label: nil, parent: nil, id: nil)
+    self.data = data # We have to use `self` here because we have a custom setter for `data`
+    @parent = parent
+    @id = id || SecureRandom.uuid
+
+    return unless label
+
+    if label.is_a?(DataSet::Label)
+      @label = label
+    elsif label.is_a?(String)
+      @label = DataSet::Label.new(label)
+    elsif label.is_a?(Hash)
+      @label = DataSet::Label.new(label.delete(:name), **label)
+    else
+      fail ArgumentError, 'Given unsupported label type to DataSet initialize'
+    end
+  end
+
+  def <<(item)
+    self.data ||= []
+    fail(CannotAddToNonEnumerableData, parent: self, item: item) unless data_array?
+    item.parent = self
+    data.push(item)
+  end
+  alias_method :add_item, :<<
+
+  def data=(items)
+    items.each { |item| item.parent = self if item.is_a? DataSet } if items.is_a? Enumerable
+    @data = items
+  end
+
+  def children
+    return data if data_array?
+    []
+  end
+
+  def siblings
+    return [] if parent.nil?
+    parent.children.reject { |c| c == self }
+  end
+
+  def oneling?
+    siblings.none?
+  end
+
+  def compact_onelings
+    filter(orphan_strategy: :adopt, keep_leafs: true) { |p, d| false if d.oneling? && !d.root? }
+  end
+
+  def root?
+    parent.nil?
+  end
+
+  def empty?
+    if data_array?
+      data.all?(&:empty?)
+    else
+      data.respond_to?(:empty?) ? !!data.empty? : !data
+    end
+  end
+
+  def branch?
+    children.any?
+  end
+
+  def child_branches
+    children.select(&:branch?)
+  end
+
+  def twig?
+    !leaf? && children.all?(&:leaf?)
+  end
+
+  def leaf?
+    children.none?
+  end
+
+  def leaf_labels
+    return [] if leaf?
+    return [] if children.none?
+    return children.map(&:label) if twig?
+    children.map(&:leaf_labels).flatten.uniq
+  end
+
+  def filter(leaf_label_id = nil, keep_leafs: false, orphan_strategy: :destroy, &block)
+    fail ArgumentError, 'No block and no leaf_label_id passed' if !block_given? && leaf_label_id.nil?
+    self.data.each_with_object(DataSet.new(id: id, label: label.deep_dup)) do |set, parent_set|
+      if block_given?
+        condition_met = yield(parent_set, set)
+      else
+        condition_met = set.leaf? ? (set.label.id == leaf_label_id) : nil
+      end
+
+      if condition_met == true
+        parent_set.add_item(set.deep_dup)
+      elsif condition_met.nil? && set.data_array?
+        deep_filter_result = set.deep_dup.filter(leaf_label_id, keep_leafs: keep_leafs, orphan_strategy: orphan_strategy, &block)
+        parent_set.add_item(deep_filter_result) if deep_filter_result.data
+      elsif condition_met == false && set.data_array?
+        if orphan_strategy == :adopt
+          deep_filter_result = set.deep_dup.filter(leaf_label_id, keep_leafs: keep_leafs, orphan_strategy: orphan_strategy, &block)
+          deep_filter_result.children.each { |c| parent_set.add_item(c) } if deep_filter_result.data
+        end
+      elsif condition_met.nil? && set.leaf?
+        parent_set.add_item(set) if keep_leafs
+      end
+
+      parent_set
+    end
+  end
+
+  def find(subtree_id)
+    if id == subtree_id
+      self
+    elsif data_array?
+      data.each do |child|
+        match = child.find(subtree_id)
+        return match if match
+      end
+
+      nil
+    end
+  end
+
+  def <=>(other)
+    return 0 if data == other.data && label == other.label
+    return 1 if data && other.data.nil?
+    return -1 if data.nil? && other.data
+    return label.id <=> other.label.id if label.id <=> other.label.id
+    return data <=> other.data if data.is_a?(Numeric) && other.data.is_a?(Numeric)
+    data.size <=> other.data.size
+  end
+
+  # == is used for comparison of two instances directly
+  def ==(other)
+    other_data = other.data.nil? ? nil : (other.data.is_a?(Enumerable) ? other.data.sort : other.data )
+    own_data = data.nil? ? nil : (data.is_a?(Enumerable) ? data.sort : data )
+    other.label == label && other_data == own_data
+  end
+
+  # eql? and hash are both used for comparisons when you
+  # call `.uniq` on an array of data sets.
+  def eql?(other)
+    self == other
+  end
+
+  def hash
+    "#{data.hash}#{label.hash}".to_i
+  end
+
+  def deep_dup
+    new_set = DataSet.new(id: id)
+    new_set.label = DataSet::Label.new(dup_value(label.name), id: dup_value(label.id), meta: label.meta.marshal_dump) if label
+
+    if data_array?
+      new_set.data = children.map(&:deep_dup)
+    else
+      new_set.data = data
+    end
+
+    new_set
+  end
+
+  def value
+    fail NotImplementedError, 'DataSet is not a leaf and thus has no value' unless leaf?
+    data
+  end
+
+  def reduce
+    yield reducable_values
+  end
+
+  def sum
+    values = [reducable_values].flatten.compact
+    return nil if values.empty?
+    values.inject(&:+)
+  end
+
+  def average
+    values = [reducable_values].flatten.compact
+    return nil if values.empty?
+    (values.inject(&:+).to_f / values.size).to_f
+  end
+
+  def reducable_values(set = nil)
+    set ||= self
+    return set.children.map { |c| reducable_values(c) } if set.data_array?
+    set.data
+  end
+
+  def combine(other_data_set, operator)
+    combined_data_set = dup
+    if data_array? && other_data_set.data_array?
+      combined_data_set.data = combine_data_array(other_data_set.children, operator)
+    elsif !data_array? && !other_data_set.data_array?
+      combined_data_set.data = combine_data_value(other_data_set.value, operator)
+    else
+      fail ArgumentError, "Can't combine array DataSet with value DataSet"
+    end
+    combined_data_set
+  end
+
+  def data_array?
+    data.is_a? Array
+  end
+
+  def pretty_inspect(level = 0, final_s: '')
+    prefix = ''
+
+    if root?
+      prefix << '* '
+    else
+      prefix << (' ' * (level) * 3) + '|- '
+    end
+
+    if label
+      node_s = "#{prefix}#{label.name}"
+    else
+      node_s = "#{prefix} (no label)"
+    end
+    node_s += ": #{value}" if leaf?
+    final_s += "#{node_s} \n"
+
+    return final_s if children.none?
+
+    children.each { |c| final_s << c.pretty_inspect(level + 1) }
+    final_s
+  end
+
+  def each(&block)
+    yield self
+    children.each { |member| member.each(&block) } if data_array?
+    self
+  end
+
+  private
+
+  def dup_value(value)
+    value.is_a?(Numeric) ? value : value.dup
+  end
+
+  def combine_data_array(other_children, operator)
+    other_children = other_children.dup
+    result = children.map do |child|
+      other_child = other_children.find { |ods| ods.label == child.label }
+      if other_child
+        other_children.delete(other_child)
+        child.combine(other_child, operator)
+      else
+        child
+      end
+    end
+    result += other_children # The remaining other children (without matching child in this data set)
+    result
+  end
+
+  def combine_data_value(other_value, operator)
+    own_value = value
+
+    # Always return nil if both values are nil (prevents summed data sets of being wrongly considered unempty and thus not hidden)
+    return nil if own_value.nil? && other_value.nil?
+
+    case operator.to_sym
+    when :+, :-
+      # When adding or subtracting treat nil (unknown) values as zero, instead of returning nil as summation result
+      own_value ||= 0.0
+      other_value ||= 0.0
+    when :/
+      # Prevent division by zero resulting in NaN/Infinity values
+      other_value = nil if other_value&.zero?
+    end
+
+    return nil if own_value.nil? || other_value.nil?
+    own_value.send(operator, other_value)
+  end
+end
+
+class CannotAddToNonEnumerableData < StandardError
+  def initialize(data = nil)
+    @data = data
+  end
+end

data/lib/tukey/data_set/label.rb

@@ -0,0 +1,39 @@
+require 'ostruct'
+
+class DataSet
+  class Label
+    attr_accessor :id
+    attr_accessor :name
+    attr_accessor :meta
+
+    def initialize(name, id: nil, meta: {})
+      @name = name
+      @id = id || name
+      fail ArgumentError, 'DataSet::Label meta must be a Hash' unless meta.is_a?(Hash)
+      @meta = OpenStruct.new(meta)
+    end
+
+    # == is used for comparison of two instances directly
+    def ==(other)
+      other.id == id
+    end
+
+    # eql? and hash are both used for comparisons when you
+    # call `.uniq` on an array of labels.
+    def eql?(other)
+      self == other
+    end
+
+    def hash
+      id.hash
+    end
+
+    def deep_dup
+      label = dup
+      id = id.dup if id
+      name = name.dup if name
+      meta = meta.dup if meta
+      label
+    end
+  end
+end

data/lib/tukey/version.rb

@@ -0,0 +1,3 @@
+module Tukey
+  VERSION = "0.9.0RC"
+end

data/tukey.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'tukey/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "tukey"
+  spec.version       = Tukey::VERSION
+  spec.authors       = ["Achilleas Buisman"]
+  spec.email         = ["tukey@abuisman.nl"]
+
+  spec.summary       = "DataSets for putting data in a tree of sets"
+  spec.description   = "Tukey is provides DataSets which can be put in a tree. This way you can store partial results of calculations or other data and, for example, create charts, tables or other presentations."
+  spec.homepage      = "https://github.com/abuisman/tukey"
+  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.add_development_dependency "bundler", "~> 1.13"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+end

metadata

@@ -0,0 +1,104 @@
+--- !ruby/object:Gem::Specification
+name: tukey
+version: !ruby/object:Gem::Version
+  version: 0.9.0RC
+platform: ruby
+authors:
+- Achilleas Buisman
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2017-01-20 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: Tukey is provides DataSets which can be put in a tree. This way you can
+  store partial results of calculations or other data and, for example, create charts,
+  tables or other presentations.
+email:
+- tukey@abuisman.nl
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- John_Tukey.jpg
+- LICENSE.txt
+- README.md
+- Rakefile
+- Tukey.gif
+- bin/console
+- bin/setup
+- lib/tukey.rb
+- lib/tukey/data_set.rb
+- lib/tukey/data_set/label.rb
+- lib/tukey/version.rb
+- tukey.gemspec
+homepage: https://github.com/abuisman/tukey
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">"
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: DataSets for putting data in a tree of sets
+test_files: []