hash_sieve 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 2d32f4ec95c7b09da473fa9993d2ea66b508c97d
+  data.tar.gz: 0c06ef99d20431c7e7d13bc60c1c969b5070c1f9
+SHA512:
+  metadata.gz: 142608847969ca13b7e51181f5e366dbe83154d1baecdb2cf9220b4b1e58695165e0332c261980a87ca935788660054c26c0136625270da04f228cd832caf538
+  data.tar.gz: e10e2aa65b1046d4645d13bec577550c99a290a26fd3d47fce99e237ffe95918231201d898532346422601603189aa7d24620ce0989f3f7dab82530087e09aeb

data/lib/hash_sieve/sieve.rb

@@ -0,0 +1,43 @@
+module HashSieve
+
+  class Sieve
+
+    def initialize(target_data)
+      @attribute_template = HashSieve::TemplateExtractor.extract(target_data)
+    end
+
+    def strain(actual_data)
+      strain_value(actual_data, @attribute_template)
+    end
+
+    private
+
+    def strain_value(value, attribute_template)
+      if attribute_template
+        class_name = value.class.name.underscore.downcase
+        strain_method = "strain_#{class_name}_value".to_sym
+        self.respond_to?(strain_method, true) ? self.send(strain_method, value, attribute_template) : value
+      else
+        nil
+      end
+    end
+
+    def strain_array_value(value, attribute_template)
+      value.map { |entry| strain_value(entry, attribute_template) }
+    end
+
+    def strain_set_value(value, attribute_template)
+      Set.new(strain_array_value(value, attribute_template))
+    end
+
+    def strain_hash_value(value, attribute_template)
+      value.reduce({}) do |strained_hash, entry|
+        key, value = entry
+        strained_hash[key] = strain_value(value, attribute_template[key]) if attribute_template.include?(key)
+        strained_hash
+      end
+    end
+
+  end
+
+end

data/lib/hash_sieve/template_extractor/array.rb

@@ -0,0 +1,19 @@
+module HashSieve
+  module TemplateExtractor
+
+    class Array
+
+      def self.extract(array)
+        array.reduce({}) do |attributes, element|
+          HashSieve::TemplateExtractor.extract(element).each do |candidate_key, candidate_value|
+            has_no_candidate_key = attributes[candidate_key].nil?
+            attributes[candidate_key] = candidate_value if !candidate_value.empty? || has_no_candidate_key
+          end
+          attributes
+        end
+      end
+
+    end
+
+  end
+end

data/lib/hash_sieve/template_extractor/hash.rb

@@ -0,0 +1,17 @@
+module HashSieve
+  module TemplateExtractor
+
+    class Hash
+
+      def self.extract(hash)
+        hash.reduce({}) do |attributes, entry|
+          key, value = entry
+          attributes[key] = HashSieve::TemplateExtractor.extract(value)
+          attributes
+        end
+      end
+
+    end
+
+  end
+end

data/lib/hash_sieve/template_extractor/set.rb

@@ -0,0 +1 @@
+HashSieve::TemplateExtractor::Set = HashSieve::TemplateExtractor::Array

data/lib/hash_sieve/template_extractor.rb

@@ -0,0 +1,29 @@
+module HashSieve
+
+  module TemplateExtractor
+
+    class << self
+
+      def extract(data)
+        extractor = extractor_for(data)
+        extractor ? extractor.extract(data) : {}
+      end
+
+      private
+
+      def extractor_for(data)
+        extractors = class_hierarchy_of(data.class).map do |candidate_class|
+          "HashSieve::TemplateExtractor::#{candidate_class.name}".constantize rescue nil
+        end
+        extractors.empty? ? nil : extractors.first
+      end
+
+      def class_hierarchy_of(a_class)
+        a_class ? [ a_class ] + class_hierarchy_of(a_class.superclass) : []
+      end
+
+    end
+
+  end
+
+end

data/lib/hash_sieve/version.rb

@@ -0,0 +1,3 @@
+module HashSieve
+  VERSION = "0.0.1".freeze
+end

data/lib/hash_sieve.rb

@@ -0,0 +1,15 @@
+require 'active_support/core_ext/string/inflections'
+
+require 'hash_sieve/template_extractor/array'
+require 'hash_sieve/template_extractor/set'
+require 'hash_sieve/template_extractor/hash'
+require 'hash_sieve/template_extractor'
+require 'hash_sieve/sieve'
+
+module HashSieve
+
+  def self.strain(actual_data, template_args)
+    HashSieve::Sieve.new(template_args[:template]).strain(actual_data)
+  end
+
+end

data/spec/lib/hash_sieve/sieve_spec.rb

@@ -0,0 +1,156 @@
+describe HashSieve::Sieve do
+
+  let(:target_data) { {} }
+
+  let(:sieve) { described_class.new(target_data) }
+
+  describe "constructor" do
+
+    it "extracts a template of the attributes within the target data" do
+      expect(HashSieve::TemplateExtractor).to receive(:extract).with(target_data)
+
+      sieve
+    end
+
+  end
+
+  context "#strain" do
+
+    subject { sieve.strain(actual_data) }
+
+    before(:each) { allow(HashSieve::TemplateExtractor).to receive(:extract).and_return(attribute_template) }
+
+    context "when the template data structure has no attributes" do
+
+      let(:attribute_template) { {} }
+
+      context "and an array of actual data is provided" do
+
+        let(:actual_data) { %w{ first second third } }
+
+        it "returns the actual data" do
+          expect(subject).to eql(actual_data)
+        end
+
+      end
+
+      context "and a set of actual data is provided" do
+
+        let(:actual_data) { Set.new(%w{ first second third }) }
+
+        it "returns the actual data" do
+          expect(subject).to eql(actual_data)
+        end
+
+      end
+
+      context "and a hash of actual data is provided" do
+
+        let(:actual_data) { { key_1: "value_1", key_2: "value_2", key_3:  "value_3" } }
+
+        it "returns an empty hash" do
+          expect(subject).to eql({})
+        end
+
+      end
+
+      [ 1, "two", Object.new ].each do |data|
+
+        context "and actual data of type #{data.class.name.underscore.downcase} is provided" do
+
+          let(:actual_data) { data }
+
+          it "returns the actual data" do
+            expect(subject).to eql(actual_data)
+          end
+
+        end
+
+      end
+
+    end
+
+    context "when the target data structure has attributes" do
+
+      context "that are shallow" do
+
+        let(:attribute_template) { { :key => {}, :another_key => {} } }
+
+        context "and a hash of actual data whose attributes exactly match the templated attributes is provided" do
+
+          let(:actual_data) do
+            {
+              :key         => "value",
+              :another_key => "another value"
+            }
+          end
+
+          it "returns the actual data" do
+            expect(subject).to eql(actual_data)
+          end
+
+        end
+
+        context "and a hash of data whose attributes are a superset of the templated attributes is provided" do
+
+          let(:actual_data) do
+            {
+              :key             => "value",
+              :another_key     => "another value",
+              :yet_another_key => "yet another value"
+            }
+          end
+
+          it "returns a hash containing only those attributes and values that are templated" do
+            expected_data = {
+              :key         => "value",
+              :another_key => "another value"
+            }
+
+            expect(subject).to eql(expected_data)
+          end
+
+        end
+
+      end
+
+      context "that are nested" do
+
+        let(:attribute_template) { { :key => { :nested_key => {}, :another_nested_key => {} } } }
+
+        context "when the nested types match" do
+
+          let(:actual_data) do
+            {
+              :key =>         { :nested_key => [ 1, 2, 3 ], :another_nested_key => Set.new([ 4, 5, 6 ]) },
+              :another_key => "another value"
+            }
+          end
+
+          it "returns the templated attributes" do
+            expected_data = {
+              :key => { :nested_key => [ 1, 2, 3 ], :another_nested_key => Set.new([ 4, 5, 6 ]) }
+            }
+
+            expect(subject).to eql(expected_data)
+          end
+
+        end
+
+        context "when the nested types do not match" do
+
+          let(:actual_data) { { :key => "different type" } }
+
+          it "returns the actual data" do
+            expect(subject).to eql(actual_data)
+          end
+
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/spec/lib/hash_sieve/template_extractor/array_spec.rb

@@ -0,0 +1,113 @@
+describe HashSieve::TemplateExtractor::Array do
+
+  describe "::extract" do
+
+    let(:array) { [] }
+
+    subject { described_class.extract(array) }
+
+    it "returns a hash" do
+      expect(subject).to be_a(Hash)
+    end
+
+    context "when provided an array of strings" do
+
+      let(:array) { %w{ thing_one thing_two thing_three } }
+
+      it "returns an empty hash" do
+        expect(subject.empty?).to be(true)
+      end
+
+    end
+
+    context "when provided an array of hashes" do
+
+      context "that have identical attributes" do
+
+        let(:array) do
+          [
+            { :id => 1, :name => "Travis" },
+            { :id => 2, :name => "Tom"    },
+            { :id => 3, :name => "Mark"   }
+          ]
+        end
+
+        it "returns a hash containing all of the attributes" do
+          expect(subject).to eql({ :id => {}, :name => {} })
+        end
+
+      end
+
+      context "that have different attributes" do
+
+        let(:array) do
+          [
+            { :id   => 1         },
+            { :name => "Travis"  },
+            { :type => "Drummer" }
+          ]
+        end
+
+        it "returns a hash combining attributes from all the hashes" do
+          expect(subject).to eql({ :id => {}, :name => {}, :type => {} })
+        end
+
+      end
+
+      context "that contains nested hashes" do
+
+        let(:array) do
+          [
+            {
+              :id     => 1,
+              :person =>
+                {
+                  :name => "Travis",
+                  :type => "Drummer"
+                }
+            },
+            {
+              :id     => 2,
+              :person =>
+                {
+                  :name => "Tom",
+                  :type => "Guitar"
+                }
+            },
+            {
+              :id     => 3,
+              :person =>
+                {
+                  :name => "Mark",
+                  :type => "Bass"
+                }
+            }
+          ]
+        end
+
+        it "returns a hash containing hashes with the nested attributes" do
+          expect(subject).to eql({ :id => {}, :person => { :name => {}, :type => {} } })
+        end
+
+      end
+
+    end
+
+    context "when provided an array of arrays" do
+
+      let(:array) do
+        [
+          [ 1, 2, 3 ],
+          [ :one, :two, :three ]
+        ]
+      end
+
+      it "returns an empty hash" do
+        expect(subject).to eql({})
+      end
+
+    end
+
+  end
+
+end

data/spec/lib/hash_sieve/template_extractor/hash_spec.rb

@@ -0,0 +1,69 @@
+describe HashSieve::TemplateExtractor::Hash do
+
+  describe "::extract" do
+
+    let(:hash) { {} }
+
+    subject { described_class.extract(hash) }
+
+    it "returns a hash" do
+      expect(subject).to be_a(Hash)
+    end
+
+    context "when provided a hash with simple attributes" do
+
+      let(:hash) do
+        {
+          :id   => 1,
+          :name => "Peter",
+          :type => "Drummer"
+        }
+      end
+
+      it "returns a hash containing the attributes" do
+        expect(subject).to eql({ :id => {}, :name => {}, :type => {} })
+      end
+
+    end
+
+    context "when provided a hash with nested hashes" do
+
+      let(:hash) do
+        {
+          :id     => 1,
+          :person =>
+            {
+              :name => "Travis",
+              :type => "Drummer"
+            }
+        }
+      end
+
+      it "returns a hash containing hashes with nested attributes" do
+        expect(subject).to eql({ :id => {}, :person => { :name => {}, :type => {} } })
+      end
+
+    end
+
+    context "when provided a hash with nested arrays" do
+
+      let(:hash) do
+        {
+          :name => "Orchestra",
+          :instruments => [
+            { :name => "Drum" },
+            { :name => "Guitar", type: "Bass" },
+            { :name => "Violin" }
+          ]
+        }
+      end
+
+      it "returns a hash containing a hash with attributes in the nested array" do
+        expect(subject).to eql({ :name => {}, :instruments => { :name => {}, :type => {} } })
+      end
+
+    end
+
+  end
+
+end

data/spec/lib/hash_sieve/template_extractor/set_spec.rb

@@ -0,0 +1,37 @@
+describe HashSieve::TemplateExtractor::Set do
+
+  it "is identical to the array extractor" do
+    expect(described_class).to eql(HashSieve::TemplateExtractor::Array)
+  end
+
+  describe "::extract" do
+
+    let(:set) { ::Set.new }
+
+    subject { described_class.extract(set) }
+
+    it "returns a hash" do
+      expect(subject).to be_a(Hash)
+    end
+
+    context "when provided an array of hashes" do
+
+      let(:set) do
+        ::Set.new(
+          [
+            { :id => 1, :name => "Travis" },
+            { :id => 2, :name => "Tom"    },
+            { :id => 3, :name => "Mark"   }
+          ]
+        )
+      end
+
+      it "returns a hash containing all of the attributes" do
+        expect(subject).to eql({ :id => {}, :name => {} })
+      end
+
+    end
+
+  end
+
+end

data/spec/lib/hash_sieve/template_extractor_spec.rb

@@ -0,0 +1,44 @@
+describe HashSieve::TemplateExtractor do
+
+  describe "::extract" do
+
+    subject { described_class.extract(data) }
+
+    { Array => HashSieve::TemplateExtractor::Array,
+      Set   => HashSieve::TemplateExtractor::Set,
+      Hash  => HashSieve::TemplateExtractor::Hash }.each do |data_type, extractor|
+
+      context "when provided data that is a #{data_type.name}" do
+
+        let(:data) { data_type.new }
+
+        it "extracts the attribute template using the extractor for that type" do
+          expect(extractor).to receive(:extract).with(data)
+
+          subject
+        end
+
+        it "returns the response from the extractor" do
+          extract_response = { :key => "value" }
+          allow(extractor).to receive(:extract).and_return(extract_response)
+
+          expect(subject).to eql(extract_response)
+        end
+
+      end
+
+    end
+
+    context "when provided data that is another type" do
+
+      let(:data) { "another type" }
+
+      it "returns an empty hash" do
+        expect(subject).to eql({})
+      end
+
+    end
+
+  end
+
+end

data/spec/lib/hash_sieve_spec.rb

@@ -0,0 +1,33 @@
+describe HashSieve do
+
+  describe "::strain" do
+
+    let(:actual_data)   { { actual_key:   "value" } }
+    let(:strained_data) { { strained_key: "value" } }
+    let(:sieve)         { instance_double(HashSieve::Sieve, strain: strained_data) }
+
+    let(:template_data) { { template_key: "value" } }
+
+    before(:example) { allow(HashSieve::Sieve).to receive(:new).and_return(sieve) }
+
+    subject { described_class.strain(actual_data, template: template_data) }
+
+    it "creates a sieve for the template data" do
+      expect(HashSieve::Sieve).to receive(:new).with(template_data)
+
+      subject
+    end
+
+    it "strains the actual data through the sieve" do
+      expect(sieve).to receive(:strain).with(actual_data)
+
+      subject
+    end
+
+    it "returns the strained data" do
+      expect(subject).to eql(strained_data)
+    end
+
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,12 @@
+require 'bundler'
+Bundler.require(:development)
+
+CodeClimate::TestReporter.start
+
+SimpleCov.start do
+  add_filter "/spec/"
+  minimum_coverage 100
+  refuse_coverage_drop
+end if ENV["coverage"]
+
+require 'hash_sieve'

metadata

@@ -0,0 +1,164 @@
+--- !ruby/object:Gem::Specification
+name: hash_sieve
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Andrew King
+- Matthew Ueckerman
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-01-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.4'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.2'
+- !ruby/object:Gem::Dependency
+  name: travis-lint
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.11'
+- !ruby/object:Gem::Dependency
+  name: metric_fu
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.12'
+- !ruby/object:Gem::Dependency
+  name: codeclimate-test-reporter
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.4'
+description: Strains unwanted hash attributes from enumerable objects, a template
+  object forms the Sieve
+email: andrew.king@myob.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- "./lib/hash_sieve.rb"
+- "./lib/hash_sieve/sieve.rb"
+- "./lib/hash_sieve/template_extractor.rb"
+- "./lib/hash_sieve/template_extractor/array.rb"
+- "./lib/hash_sieve/template_extractor/hash.rb"
+- "./lib/hash_sieve/template_extractor/set.rb"
+- "./lib/hash_sieve/version.rb"
+- "./spec/lib/hash_sieve/sieve_spec.rb"
+- "./spec/lib/hash_sieve/template_extractor/array_spec.rb"
+- "./spec/lib/hash_sieve/template_extractor/hash_spec.rb"
+- "./spec/lib/hash_sieve/template_extractor/set_spec.rb"
+- "./spec/lib/hash_sieve/template_extractor_spec.rb"
+- "./spec/lib/hash_sieve_spec.rb"
+- "./spec/spec_helper.rb"
+homepage: http://github.com/MYOB-Technology/hash_sieve
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 1.9.3
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.6
+signing_key: 
+specification_version: 4
+summary: Strains unwanted hash attributes from enumerable objects
+test_files:
+- "./spec/lib/hash_sieve/sieve_spec.rb"
+- "./spec/lib/hash_sieve/template_extractor/array_spec.rb"
+- "./spec/lib/hash_sieve/template_extractor/hash_spec.rb"
+- "./spec/lib/hash_sieve/template_extractor/set_spec.rb"
+- "./spec/lib/hash_sieve/template_extractor_spec.rb"
+- "./spec/lib/hash_sieve_spec.rb"
+- "./spec/spec_helper.rb"