twins 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 20e9e6421c19c6abccbb7f121b1ba3a36ae56a7e
+  data.tar.gz: 660fdd54b8e6acb0d2a947c329e0293d147919af
+SHA512:
+  metadata.gz: e2dababf31cb5d844ae4ff9588758e27538fad29fd086354a6f43e66640647f0c8339c838a17c34515339bd6191286ea6618e4fd042a82bee70140980c905710
+  data.tar.gz: fd4442cd82dbc5d41df4d605d724c03c3070e8e363dd4b0b97b54454e298b059289de248e1c6284b6109efdb1812f580f2977af6bb48a00dbb1da2c08b05aefc

data/lib/twins.rb

@@ -0,0 +1,52 @@
+require 'active_support/core_ext'
+require 'twins/utilities'
+
+module Twins
+
+  # @param collection [Enumerable] A collection of Hash objects
+  # @param options [Hash]
+  # @return [Hash, Nil]
+  def consolidate(collection, options = {})
+    return nil unless collection.any?
+
+    if collection.all? { |e| e.is_a?(Hash) }
+      # noop
+    elsif collection.all? { |e| e.is_a?(collection.first.class) }
+      collection = collection.map do |element|
+        Hash[element.instance_variables.map { |name| [name.to_s.sub(/\A@/, ''), element.instance_variable_get(name)] }]
+      end
+    else
+      raise ArgumentError, "The collection's elements must all be of the same Class"
+    end
+
+    options = options.with_indifferent_access
+    consolidated = Hash.new
+
+    collection.each do |hash|
+      hash.each_pair do |key, value|
+
+        # Recursively consolidate nested hashes
+        if value.is_a?(Hash) && !consolidated[key]
+          consolidated[key] = consolidate(collection.map { |element| element[key] })
+        else
+          # Filter elements without a given key to avoid unintentionally nil values
+          values = collection.select { |element| element.has_key?(key) }.map { |element| element[key] }
+
+          if options[:priority].try(:[], key)
+            # Compute each element's distance from the given priority
+            distances = values.map { |f| Twins::Utilities.distance(options[:priority][key], f) }
+
+            # The best candidate is the first element with the shortest distance
+            consolidated[key] = values[distances.index(distances.min)]
+          else
+            # The best candidate is the mode or the first one
+            consolidated[key] = Twins::Utilities.mode(values)
+          end
+        end
+      end
+    end
+
+    consolidated.with_indifferent_access
+  end
+  module_function :consolidate
+end

data/lib/twins/utilities.rb

@@ -0,0 +1,46 @@
+require 'amatch'
+
+module Twins
+  module Utilities
+
+    # @param collection [Enumerable]
+    # @return [Object]
+    def mode(collection)
+      collection.group_by { |n| n }.values.max_by(&:size).first
+    end
+    module_function :mode
+
+    # Normalized distance for Strings and Numerics
+    # the lower the result, the shortest the distance
+    #
+    # @param a [String, Numeric]
+    # @param b [String, Numeric]
+    # @return [Float]
+    def distance(a, b)
+      if a.is_a?(String) && b.is_a?(String)
+        Twins::Utilities.string_distance(a, b) * -1
+      elsif a.is_a?(Numeric) && b.is_a?(Numeric)
+        Twins::Utilities.numeric_distance(a, b)
+      else
+        raise StandardError, "Distance can only be determined between two elements of kind 'String' or 'Numeric'"
+      end
+    end
+    module_function :distance
+
+    # @param a [String]
+    # @param b [String]
+    def string_distance(a, b)
+      raise StandardError, "Distance can only be determined between two elements of kind 'String'" unless a.is_a?(String) && b.is_a?(String)
+      Amatch::LongestSubsequence.new(a).match(b)
+    end
+    module_function :string_distance
+
+    # @param a [Numeric]
+    # @param b [Numeric]
+    def numeric_distance(a, b)
+      raise StandardError, "Distance can only be determined between two elements of kind 'Numeric'" unless a.is_a?(Numeric) && b.is_a?(Numeric)
+      (a - b).abs
+    end
+    module_function :numeric_distance
+  end
+end

data/lib/twins/version.rb

@@ -0,0 +1,3 @@
+module Twins
+  VERSION = "0.0.2"
+end

metadata

@@ -0,0 +1,77 @@
+--- !ruby/object:Gem::Specification
+name: twins
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- Philippe Dionne
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-03-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: amatch
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.2.11
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.2.11
+description: Twin sorts through the small differences between multiple objects and
+  smartly consolidate all of them together.
+email:
+- dionne.phil@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/twins.rb
+- lib/twins/utilities.rb
+- lib/twins/version.rb
+homepage: https://github.com/phildionne/twins
+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: '0'
+requirements: []
+rubyforge_project: "[none]"
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Smartly merge multiple objects together.
+test_files: []
+has_rdoc: