destruct 0.0.0

data/bin/rubocop

@@ -0,0 +1,29 @@
+#!/bin/bash
+
+set -eo pipefail
+
+echo -e "--- \033[33mWhat does this command do?\033[0m"
+echo
+echo "  This script runs our LendingHome platform wide rubocop Docker image"
+echo "  for the gem or service mounted at /app. It uses a configuration file"
+echo "  that has been added directly into the rubocop Docker image itself. This"
+echo "  configuration lives in the lendinghome-dockerfiles repository."
+echo
+echo "  Check out the documentation on rubocop for more information!"
+echo
+echo "    * https://github.com/bbatsov/rubocop"
+echo "    * https://github.com/bbatsov/ruby-style-guide"
+echo
+
+if [ -v REBUILD_CACHE ]; then
+  echo "--- :docker: Pulling latest docker image"
+  docker-compose pull rubocop
+
+  echo "--- :recycle: Updating build cache"
+  echo "The build was triggered with REBUILD_CACHE"
+  echo "Skipping the remaining build steps"
+else
+  echo "--- :docker: Starting docker"
+  docker-compose pull rubocop
+  docker-compose run rubocop $@
+fi

data/bin/test

@@ -0,0 +1,64 @@
+#!/bin/bash
+
+set -eo pipefail
+
+if [[ -z "$DOCKER" ]]; then
+  echo "--- :buildkite: Building destruct"
+  buildkite-agent --version
+
+  echo "branch: $BUILDKITE_BRANCH"
+  echo "commit: $BUILDKITE_COMMIT"
+  echo "image: $DOCKER_IMAGE"
+
+  if [ -v REBUILD_CACHE ]; then
+    echo "--- :minidisc: Pulling images"
+    docker-compose pull --ignore-pull-failures
+  fi
+
+  echo "--- :docker: Starting docker"
+  docker --version
+  docker-compose --version
+
+  echo "Building $DOCKER_IMAGE"
+  docker-compose run app /app/bin/test $@
+
+  if [ -v REBUILD_CACHE ]; then
+    echo "--- :recycle: Updating build cache"
+    echo "The build was triggered with REBUILD_CACHE"
+
+    echo "Generating cache.tar.lz4"
+    tar -c --use-compress-program=lz4 -f cache.tar.lz4 "$BUILD_CACHE" \
+      || echo "Ignoring permission denied failures"
+
+    [ -v BUILDKITE ] && buildkite-agent meta-data set "rebuild-cache" "1"
+  fi
+
+  exit 0
+fi
+
+echo "--- :terminal: Loading environment"
+echo "bash: `bash --version | head -1`"
+echo "git: `git --version`"
+echo "imagemagick: `identify --version | head -1`"
+echo "java: `java -version 2>&1 | head -1`"
+echo "os: `cat /etc/issue | head -1`"
+echo "phantomjs: `phantomjs --version`"
+
+echo "--- :ruby: Installing ruby"
+rbenv install --skip-existing
+ruby --version
+rbenv --version
+
+echo "--- :rubygems: Installing ruby gems"
+echo "gem $(gem --version)"
+bundler --version
+cpus=$(nproc 2>/dev/null || echo 1)
+[[ $cpus -eq 1 ]] && jobs=1 || jobs=$((cpus - 1))
+options="--path vendor/bundle --jobs $jobs --retry 3 --frozen --no-cache --no-prune"
+bundle check || bundle install $options
+
+if [[ -z "$REBUILD_CACHE" ]]; then
+  echo "+++ :rspec: Running rspec tests"
+  echo "rspec $(bundle exec rspec --version)"
+  bundle exec rspec $@
+fi

data/destruct.gemspec

@@ -0,0 +1,15 @@
+Gem::Specification.new do |s|
+  s.author                = "LendingHome"
+  s.email                 = "github@lendinghome.com"
+  s.extra_rdoc_files      = %w(LICENSE)
+  s.files                 = `git ls-files`.split("\n")
+  s.homepage              = "https://github.com/lendinghome/destruct"
+  s.license               = "MIT"
+  s.name                  = "destruct"
+  s.rdoc_options          = %w(--charset=UTF-8 --inline-source --line-numbers --main README.md)
+  s.require_paths         = %w(lib)
+  s.required_ruby_version = ">= 2.3.0"
+  s.summary               = "ES6 style object destructuring in Ruby"
+  s.test_files            = `git ls-files -- spec/*`.split("\n")
+  s.version               = "0.0.0"
+end

data/docker-compose.yml

@@ -0,0 +1,21 @@
+version: "2"
+
+services:
+  app:
+    build:
+      context: "."
+    image: $DOCKER_IMAGE
+    environment:
+      - CI
+      - DOCKER=true
+      - REBUILD_CACHE
+    volumes:
+      - .:/app
+      - $BUILD_CACHE/bundler:/app/vendor/bundle
+
+  rubocop:
+    image: lendinghome/rubocop
+    environment:
+      - RUBOCOP_VERSION=2.3
+    volumes:
+      - .:/app

data/lib/destruct.rb

@@ -0,0 +1,39 @@
+require_relative "destruct/dsl"
+require_relative "destruct/hash"
+require_relative "destruct/object"
+require_relative "destruct/resolver"
+
+Object.send(:include, Destruct::Object)
+
+class Destruct
+  GEMSPEC = File.expand_path("../../destruct.gemspec", __FILE__)
+  VERSION = Gem::Specification.load(GEMSPEC).version.to_s
+
+  def initialize(object, *paths, &block)
+    @object = object
+    @paths = paths
+    @block = block || proc { }
+  end
+
+  def to_h
+    paths.each_with_object(Hash.new) do |path, hash|
+      resolve(path).each do |key, value|
+        hash[key] = value
+      end
+    end
+  end
+
+  private
+
+  def dsl
+    DSL.new(&@block)
+  end
+
+  def paths
+    @paths + dsl.paths
+  end
+
+  def resolve(path)
+    Resolver.new(@object, path).to_h
+  end
+end

data/lib/destruct/dsl.rb

@@ -0,0 +1,32 @@
+class Destruct
+  class DSL
+    def initialize(&block)
+      @paths = []
+      instance_eval(&block) if block
+    end
+
+    def [](path)
+      self.class.new.tap do |dsl|
+        @paths << [path, dsl]
+      end
+    end
+
+    def paths
+      @paths.each_with_object([]) do |(key, dsl), paths|
+        nested = dsl.paths
+        paths << [key] if nested.empty?
+        nested.each { |path| paths << path.unshift(key) }
+      end
+    end
+
+    private
+
+    def method_missing(method, *)
+      self[method]
+    end
+
+    def respond_to_missing?(method, *)
+      true
+    end
+  end
+end

data/lib/destruct/hash.rb

@@ -0,0 +1,32 @@
+class Destruct
+  class Hash < ::Hash
+    def [](key)
+      super(key) || super(key.to_s) || to_ary[key]
+    rescue TypeError
+      nil
+    end
+
+    def []=(key, value)
+      to_ary << value
+      super
+    end
+
+    def key?(key)
+      super(key) || super(key.to_s)
+    end
+
+    def to_ary
+      @to_ary ||= values
+    end
+
+    private
+
+    def method_missing(method, *)
+      key?(method) ? self[method] : super
+    end
+
+    def respond_to_missing?(method, *)
+      key?(method) || super
+    end
+  end
+end

data/lib/destruct/object.rb

@@ -0,0 +1,12 @@
+class Destruct
+  module Object
+    def destruct(*paths, &block)
+      Destruct.new(self, *paths, &block).to_h
+    end
+
+    def dig(method, *paths)
+      object = send(method) if respond_to?(method)
+      paths.any? ? object&.dig(*paths) : object
+    end
+  end
+end

data/lib/destruct/resolver.rb

@@ -0,0 +1,41 @@
+class Destruct
+  class Resolver
+    def initialize(object, path)
+      @object = object
+      @path = path
+    end
+
+    def to_h
+      case @path
+      when Array
+        { @path.last => @object.dig(*@path) }
+      when ::Hash
+        resolve_recursively
+      else
+        self.class.new(@object, paths).to_h
+      end
+    end
+
+    private
+
+    def paths
+      Array(@path)
+    end
+
+    def resolve(key, values)
+      @object.dig(key).tap do |object|
+        Array(values).each do |value|
+          yield self.class.new(object, value)
+        end
+      end
+    end
+
+    def resolve_recursively
+      @path.each_with_object({}) do |(key, values), hash|
+        resolve(key, values) do |resolver|
+          hash.update(resolver.to_h)
+        end
+      end
+    end
+  end
+end

data/spec/destruct/hash_spec.rb

@@ -0,0 +1,94 @@
+RSpec.describe Destruct::Hash do
+  subject { described_class.new.replace(hash) }
+
+  let(:hash) do
+    {
+      status: 200,
+      "multi word" => "example",
+      "test" => "string"
+    }
+  end
+
+  describe "#[]" do
+    it "looks up by key" do
+      expect(subject[:status]).to eq(200)
+      expect(subject["test"]).to eq("string")
+    end
+
+    it "looks up by stringified key" do
+      expect(subject[:test]).to eq("string")
+    end
+
+    it "looks up by multi-word key" do
+      expect(subject["multi word"]).to eq("example")
+    end
+
+    it "looks up by index key" do
+      expect(subject[0]).to eq(200)
+      expect(subject[1]).to eq("example")
+      expect(subject[2]).to eq("string")
+      expect(subject[-1]).to eq("string")
+    end
+
+    it "returns nil when key is not found" do
+      expect(subject[:invalid]).to be_nil
+      expect(subject["invalid"]).to be_nil
+      expect(subject[99]).to be_nil
+      expect(subject[{}]).to be_nil
+    end
+  end
+
+  describe "#key?" do
+    it "looks up by key" do
+      expect(subject).to be_key(:status)
+      expect(subject).to be_key("test")
+    end
+
+    it "looks up by stringified key" do
+      expect(subject).to be_key(:test)
+    end
+
+    it "looks up by multi-word key" do
+      expect(subject).to be_key("multi word")
+    end
+
+    it "returns false when key is not found" do
+      expect(subject).not_to be_key(:invalid)
+      expect(subject).not_to be_key("invalid")
+      expect(subject).not_to be_key(1)
+    end
+  end
+
+  describe "#method_missing" do
+    it "resolves symbol keys" do
+      expect(subject.status).to eq(200)
+      expect(subject.test).to eq("string")
+    end
+
+    it "resolves string keys" do
+      expect(subject.test).to eq("string")
+    end
+
+    it "raises NoMethodError otherwise" do
+      expect { subject.invalid }.to raise_error(NoMethodError)
+    end
+  end
+
+  describe "#respond_to?" do
+    it "returns true if keys exist" do
+      expect(subject).to be_respond_to(:status)
+      expect(subject).to be_respond_to(:test)
+      expect(subject).to be_respond_to("test")
+    end
+
+    it "returns false if keys do not exist" do
+      expect(subject).not_to be_respond_to(:invalid)
+    end
+  end
+
+  describe "#to_ary" do
+    it "returns the subject values" do
+      expect(subject.to_ary).to eq(subject.values)
+    end
+  end
+end

data/spec/destruct/object_spec.rb

@@ -0,0 +1,42 @@
+RSpec.describe Destruct::Object do
+  subject { "test" }
+
+  describe "#destruct" do
+    it "is defined on all objects" do
+      expect(subject).to respond_to(:destruct)
+      expect(Object).to respond_to(:destruct)
+      expect(Object.new).to respond_to(:destruct)
+    end
+  end
+
+  describe "#dig" do
+    it "resolves nested methods" do
+      actual = subject.dig(:upcase, :reverse)
+      expect(actual).to eq("TSET")
+    end
+
+    it "resolves nested hashes" do
+      struct = Struct.new(:hash)
+      object = struct.new(one: { two: 2 })
+      actual = object.dig(:hash, :one, :two)
+      expect(actual).to eq(2)
+    end
+
+    it "resolves nested arrays" do
+      struct = Struct.new(:array)
+      object = struct.new([1, [2, 3]])
+      actual = object.dig(:array, 1, 0)
+      expect(actual).to eq(2)
+    end
+
+    it "returns nil for undefined methods" do
+      actual = subject.dig(:upcase, :undefined, :reverse)
+      expect(actual).to be_nil
+    end
+
+    it "returns nil for invalid methods" do
+      actual = subject.dig(:upcase, "invalid method", :reverse)
+      expect(actual).to be_nil
+    end
+  end
+end

data/spec/destruct/resolver_spec.rb

@@ -0,0 +1,31 @@
+RSpec.describe Destruct::Resolver do
+  subject { described_class.new(object, path) }
+
+  let(:object) { "test" }
+
+  describe "#to_h" do
+    let(:path) { :upcase }
+
+    context "with object argument" do
+      it "parses correctly" do
+        expect(subject.to_h).to eq(upcase: "TEST")
+      end
+    end
+
+    context "with array argument" do
+      let(:path) { %i(upcase reverse) }
+
+      it "parses correctly" do
+        expect(subject.to_h).to eq(reverse: "TSET")
+      end
+    end
+
+    context "with hash argument" do
+      let(:path) { { upcase: :reverse } }
+
+      it "parses correctly" do
+        expect(subject.to_h).to eq(reverse: "TSET")
+      end
+    end
+  end
+end