hashcraft 1.0.0.pre.alpha.1

data/Rakefile

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+#
+# Copyright (c) 2020-present, Blue Marble Payroll, LLC
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+require 'rubocop/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+RuboCop::RakeTask.new
+
+task default: %i[rubocop spec]

data/bin/console

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+#
+# Copyright (c) 2018-present, Blue Marble Payroll, LLC
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+require 'bundler/setup'
+require 'hashcraft'
+require 'pry'
+
+Pry.start

data/hashcraft.gemspec

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require './lib/hashcraft/version'
+
+Gem::Specification.new do |s|
+  s.name        = 'hashcraft'
+  s.version     = Hashcraft::VERSION
+  s.summary     = 'Hash-based Data Contracting Domain Specific Language'
+
+  s.description = <<-DESCRIPTION
+    Provides a DSL for implementing classes which can then be consumed to create pre-defined hashes.
+  DESCRIPTION
+
+  s.authors     = ['Matthew Ruggio']
+  s.email       = ['mruggio@bluemarblepayroll.com']
+  s.files       = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  s.bindir      = 'exe'
+  s.executables = []
+  s.homepage    = 'https://github.com/bluemarblepayroll/hashcraft'
+  s.license     = 'MIT'
+  s.metadata    = {
+    'bug_tracker_uri' => 'https://github.com/bluemarblepayroll/hashcraft/issues',
+    'changelog_uri' => 'https://github.com/bluemarblepayroll/hashcraft/blob/master/CHANGELOG.md',
+    'documentation_uri' => 'https://www.rubydoc.info/gems/hashcraft',
+    'homepage_uri' => s.homepage,
+    'source_code_uri' => s.homepage
+  }
+
+  s.required_ruby_version = '>= 2.5'
+
+  s.add_development_dependency('guard-rspec', '~>4.7')
+  s.add_development_dependency('pry', '~>0')
+  s.add_development_dependency('rake', '~> 13')
+  s.add_development_dependency('rspec')
+  s.add_development_dependency('rubocop', '~>0.79.0')
+  s.add_development_dependency('simplecov', '~>0.17.0')
+  s.add_development_dependency('simplecov-console', '~>0.6.0')
+end

data/lib/hashcraft.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+#
+# Copyright (c) 2020-present, Blue Marble Payroll, LLC
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+require 'forwardable'
+require 'singleton'
+
+# Monkey-patching core libraries
+require_relative 'hashcraft/core_ext/hash'
+Hash.include Hashcraft::CoreExt::Hash
+
+# General tooling
+require_relative 'hashcraft/generic'
+
+require_relative 'hashcraft/base'
+require_relative 'hashcraft/mutator_registry'
+require_relative 'hashcraft/transformer_registry'

data/lib/hashcraft/base.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+#
+# Copyright (c) 2020-present, Blue Marble Payroll, LLC
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+require_relative 'compiler'
+require_relative 'dsl'
+
+module Hashcraft
+  # Super-class for craftable objects.
+  class Base
+    extend Dsl
+    extend Forwardable
+
+    def_delegators :'self.class',
+                   :option?,
+                   :option_set,
+                   :find_option
+
+    def initialize(opts = {}, &block)
+      @data = make_default_data
+
+      load_opts(opts)
+
+      return unless block_given?
+
+      if block.arity == 1
+        yield self
+      else
+        instance_eval(&block)
+      end
+    end
+
+    def to_h(key_transformer: nil, value_transformer: nil)
+      Compiler.new(
+        option_set,
+        key_transformer: key_transformer,
+        value_transformer: value_transformer
+      ).evaluate!(data)
+    end
+
+    private
+
+    attr_reader :data
+
+    def make_default_data
+      option_set.values.each_with_object({}) { |o, memo| o.default!(memo) }
+    end
+
+    def load_opts(opts)
+      (opts || {}).each { |k, v| send(k, v) }
+    end
+
+    def respond_to_missing?(method_name, include_private = false)
+      option?(method_name) || super
+    end
+
+    def method_missing(method_name, *arguments, &block)
+      if option?(method_name)
+        find_option(method_name).value!(data, arguments.first, &block)
+      else
+        super
+      end
+    end
+  end
+end

data/lib/hashcraft/compiler.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+#
+# Copyright (c) 2020-present, Blue Marble Payroll, LLC
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+module Hashcraft
+  # This class understands how to traverse an option chain and output a hash.
+  class Compiler
+    attr_reader :key_transformer, :option_set, :value_transformer
+
+    def initialize(option_set, key_transformer: nil, value_transformer: nil)
+      raise ArgumentError, 'option_set is required' unless option_set
+
+      @option_set        = option_set
+      @key_transformer   = TransformerRegistry.resolve(key_transformer)
+      @value_transformer = TransformerRegistry.resolve(value_transformer)
+
+      freeze
+    end
+
+    def evaluate!(data)
+      data.each_with_object({}) do |(key, value), memo|
+        option = option_set.find(key)
+
+        evaluate_single!(memo, option, value)
+      end
+    end
+
+    private
+
+    attr_reader :data
+
+    def evaluate_single!(data, option, value)
+      key             = option.key.empty? ? option.name : option.key
+      transformed_key = key_transformer.transform(key, option)
+
+      method = value.is_a?(Array) ? :evaluate_values! : :evaluate_value!
+
+      send(method, option, data, transformed_key, value)
+
+      self
+    end
+
+    def evaluate_values!(option, data, key, values)
+      data[key] ||= []
+
+      values.each do |value|
+        data[key] <<
+          if value.is_a?(Hashcraft::Base)
+            value.to_h(
+              key_transformer: key_transformer,
+              value_transformer: value_transformer
+            )
+          else
+            value_transformer.transform(value, option)
+          end
+      end
+
+      self
+    end
+
+    def evaluate_value!(option, data, key, value)
+      data[key] =
+        if value.is_a?(Hashcraft::Base)
+          value.to_h(
+            key_transformer: key_transformer,
+            value_transformer: value_transformer
+          )
+        else
+          value_transformer.transform(value, option)
+        end
+
+      self
+    end
+  end
+end

data/lib/hashcraft/core_ext/hash.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+#
+# Copyright (c) 2020-present, Blue Marble Payroll, LLC
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+module Hashcraft
+  module CoreExt
+    # Monkey-patches for the core Hash class.  These will be manually mixed in separately.
+    module Hash
+      unless method_defined?(:symbolize_keys)
+        def symbolize_keys
+          map { |k, v| [k.to_sym, v] }.to_h
+        end
+      end
+    end
+  end
+end

data/lib/hashcraft/dsl.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+#
+# Copyright (c) 2020-present, Blue Marble Payroll, LLC
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+require_relative 'option'
+
+module Hashcraft
+  # The class API used to define options for a craftable class.  Each class stores its own
+  # OptionSet instance along with materializing one for its
+  # inheritance chain (child has precedence.)
+  module Dsl
+    def option?(name)
+      option_set.exist?(name)
+    end
+
+    def find_option(name)
+      option_set.find(name)
+    end
+
+    def option(*args)
+      opts = args.last.is_a?(Hash) ? args.pop : {}
+
+      args.each do |key|
+        option = Option.new(key, opts)
+
+        local_option_set.add(option)
+      end
+
+      self
+    end
+
+    def option_set
+      @option_set ||=
+        ancestors
+        .reverse
+        .select { |a| a < Base }
+        .each_with_object(Generic::Dictionary.new) { |a, memo| memo.merge!(a.local_option_set) }
+    end
+
+    def local_option_set
+      @local_option_set ||= Generic::Dictionary.new(key: :name)
+    end
+  end
+end

data/lib/hashcraft/generic.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+#
+# Copyright (c) 2020-present, Blue Marble Payroll, LLC
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+require_relative 'generic/dictionary'
+require_relative 'generic/registry'

data/lib/hashcraft/generic/dictionary.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+#
+# Copyright (c) 2020-present, Blue Marble Payroll, LLC
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+module Hashcraft
+  module Generic
+    # Dictionary structure defining how we want to organize objects.  Basically a type-insensitive
+    # hash where each key is the object's value for the specified key.
+    # All keys are #to_s evaluated in order to achieve the type-insensitivity.
+    class Dictionary
+      extend Forwardable
+
+      attr_reader :key, :map
+
+      def_delegators :map, :values
+
+      def initialize(key: :key)
+        raise ArgumentError, 'key is required' if key.to_s.empty?
+
+        @key = key
+        @map = {}
+
+        freeze
+      end
+
+      def exist?(key)
+        !find(key).nil?
+      end
+
+      def find(key)
+        @map[key.to_s]
+      end
+
+      def add(object)
+        object_key = object.send(key)
+
+        @map[object_key] = object
+
+        self
+      end
+
+      def merge!(other)
+        map.merge!(other.map)
+
+        self
+      end
+    end
+  end
+end

data/lib/hashcraft/generic/registry.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+#
+# Copyright (c) 2020-present, Blue Marble Payroll, LLC
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+module Hashcraft
+  module Generic
+    # A general data structure that can register and resolve objects by name.
+    # It also will act as a pass-thru if a non-string or non-symbol is passed through.
+    class Registry
+      include Singleton
+
+      class << self
+        extend Forwardable
+
+        def_delegators :instance,
+                       :register,
+                       :register_all,
+                       :resolve
+      end
+
+      def initialize(map = {})
+        @map = {}
+
+        register_all(map)
+
+        freeze
+      end
+
+      def register_all(map)
+        (map || {}).each { |k, v| register(k, v) }
+
+        self
+      end
+
+      def register(name, value)
+        @map[name.to_s] = value
+
+        self
+      end
+
+      def resolve(value)
+        return value unless lookup?(value)
+
+        mutator = map[value.to_s]
+
+        raise ArgumentError, "registration: #{value} not found" unless mutator
+
+        mutator
+      end
+
+      private
+
+      attr_reader :map
+
+      def lookup?(value)
+        value.is_a?(String) || value.is_a?(Symbol) || value.nil?
+      end
+    end
+  end
+end