sums_up 1.0.0

data/Rakefile

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+require 'rubocop/rake_task'
+
+RuboCop::RakeTask.new(:rubocop)
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: %i[spec rubocop]

data/bin/console

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'sums_up'
+require 'pry'
+
+Pry.start

data/bin/setup

@@ -0,0 +1,6 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install

data/lib/sums_up.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+
+require 'sums_up/core'
+require 'sums_up/version'
+
+# UI-level functions for the gem.
+module SumsUp
+  Error = Class.new(StandardError)
+
+  MatchError = Class.new(Error)
+  UnmatchedVariantError = Class.new(MatchError)
+  MatchAfterWildcardError = Class.new(MatchError)
+  DuplicateMatchError = Class.new(MatchError)
+  UnknownVariantError = Class.new(MatchError)
+
+  ParserError = Class.new(Error)
+  VariantNameError = Class.new(ParserError)
+  VariantArgsError = Class.new(ParserError)
+  DuplicateNameError = Class.new(ParserError)
+
+  class << self
+    extend Forwardable
+
+    def_delegators(Core, :define)
+  end
+end
+
+require 'sums_up/maybe'
+require 'sums_up/result'

data/lib/sums_up/CHANGELOG.md

@@ -0,0 +1,5 @@
+# Changelog
+
+## v1.0.0
+
+* Initial release of the gem

data/lib/sums_up/core.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'sums_up/core/functions'
+require 'sums_up/core/matcher'
+require 'sums_up/core/parser'
+require 'sums_up/core/strings'
+require 'sums_up/core/sum_type'
+require 'sums_up/core/variant'
+
+module SumsUp
+  # Core functionality which builds modules for sum types and classes for
+  # variants.
+  module Core
+    module_function
+
+    def define(*no_arg_variants, **arg_variants, &block)
+      variant_specs = Parser.parse_variant_specs!(no_arg_variants, arg_variants)
+      variant_names = variant_specs.keys
+
+      variant_classes = variant_specs.map do |name, members|
+        others = variant_names - [name]
+        matcher_class = Matcher.build_matcher_class(name, others)
+
+        Variant.build_variant_class(name, others, members, matcher_class)
+      end
+
+      SumType
+        .build(variant_classes)
+        .tap { |sum_type| sum_type.module_eval(&block) if block }
+    end
+  end
+end

data/lib/sums_up/core/functions.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module SumsUp
+  module Core
+    # Helpers for functions.
+    module Functions
+      module_function
+
+      def const(value)
+        proc { value }
+      end
+    end
+  end
+end

data/lib/sums_up/core/matcher.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+module SumsUp
+  module Core
+    # Matching DSL for sum type variants. Methods in this class are prefixed
+    # with an _ so as not to conflict with the names of user-defined variant
+    # names. Use .build_matcher_class to generate a new subclass for a variant
+    # given the other variant names.
+    class Matcher
+      def self.build_matcher_class(variant, other_variants)
+        Class.new(self) do
+          const_set(:VARIANT, variant)
+          const_set(:ALL_VARIANTS, [variant, *other_variants].freeze)
+          const_set(:IncorrectMatcher, incorrect_matcher_module(other_variants))
+
+          include(const_get(:IncorrectMatcher))
+
+          alias_method(variant, :_correct_variant_matcher)
+        end
+      end
+
+      def self.incorrect_matcher_module(variants)
+        Module.new do
+          variants.each do |variant|
+            define_method(variant) do |_value = nil|
+              _ensure_wildcard_not_matched!(variant)
+              _ensure_no_duplicate_match!(variant)
+
+              @matched_variants << variant
+
+              self
+            end
+          end
+        end
+      end
+
+      def initialize(variant_instance)
+        @variant_instance = variant_instance
+
+        @matched = false
+        @matched_variants = []
+        @wildcard_matched = false
+        @result = nil
+      end
+
+      def _(value = nil)
+        _ensure_wildcard_not_matched!(:_)
+
+        @wildcard_matched = true
+
+        return self if @matched
+
+        @result = block_given? ? yield(@variant_instance) : value
+
+        self
+      end
+
+      def _match_hash(hash)
+        variants = self.class::ALL_VARIANTS
+        unknown_variants = hash
+          .each_key
+          .reject { |key| (key == :_) || variants.include?(key) }
+
+        if unknown_variants.any?
+          raise(
+            UnknownVariantError,
+            "Unknown variant(s): #{unknown_variants.join(', ')}; " \
+            "valid variant(s) are: #{variants.join(', ')}"
+          )
+        end
+
+        hash.each do |variant, value|
+          public_send(variant, value)
+        end
+
+        self
+      end
+
+      def _fetch_result
+        variants = self.class::ALL_VARIANTS
+
+        return @result if @wildcard_matched
+        return @result if @matched_variants.length == variants.length
+
+        unmatched_variants = (variants - @matched_variants).join(', ')
+
+        raise(
+          UnmatchedVariantError,
+          "Did not match the following variants: #{unmatched_variants}"
+        )
+      end
+
+      # Defining #_correct_variant_matcher "statically" allows us to use yield
+      # instead of block.call, which is much faster in most ruby versions.
+      # https://github.com/JuanitoFatas/fast-ruby/blob/256fa4916b577befb40ba5ffaa22af08dc16565c/README.md#proc--block
+      def _correct_variant_matcher(value = nil)
+        variant = self.class::VARIANT
+
+        _ensure_wildcard_not_matched!(variant)
+        _ensure_no_duplicate_match!(variant)
+
+        @matched_variants << variant
+        @matched = true
+
+        @result =
+          if block_given?
+            yield(*@variant_instance.members(dup: false))
+          else
+            value
+          end
+
+        self
+      end
+
+      private
+
+      def _ensure_wildcard_not_matched!(variant)
+        return unless @wildcard_matched
+
+        raise(
+          MatchAfterWildcardError,
+          "Attempted to match variant after wildcard (_): #{variant}"
+        )
+      end
+
+      def _ensure_no_duplicate_match!(variant)
+        return unless @matched_variants.include?(variant)
+
+        raise(DuplicateMatchError, "Duplicated match for variant: #{variant}")
+      end
+    end
+  end
+end

data/lib/sums_up/core/parser.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module SumsUp
+  module Core
+    # Validates and normalizes arguments passed to SumsUp.define.
+    module Parser
+      LOWER_SNAKE_CASE_REGEXP = /\A[[:lower:]]+(_[[:lower:]]+)*\z/.freeze
+
+      module_function
+
+      def parse_variant_specs!(no_arg_variants, arg_variants)
+        variant_names = no_arg_variants + arg_variants.keys
+
+        validate_unique!(variant_names)
+        variant_names.each(&method(:validate_name_format!))
+        arg_variants.each_value(&method(:validate_variant_args!))
+
+        no_arg_variants
+          .map { |variant| [variant, []] }
+          .to_h
+          .merge(arg_variants.transform_values { |ary| [*ary] })
+      end
+
+      def validate_unique!(variant_names)
+        duplicates = variant_names
+          .group_by(&:itself)
+          .select { |_, values| values.length > 1 }
+          .keys
+
+        return if duplicates.empty?
+
+        raise(
+          DuplicateNameError,
+          "Duplicated names: #{duplicates.join(', ')}"
+        )
+      end
+
+      def validate_name_format!(variant_name)
+        unless variant_name.is_a?(Symbol)
+          raise(VariantNameError, "Expected a Symbol, got: #{variant_name}")
+        end
+
+        return if LOWER_SNAKE_CASE_REGEXP.match?(variant_name.to_s)
+
+        raise(
+          VariantNameError,
+          "Name is not lower_snake_case: #{variant_name}"
+        )
+      end
+
+      def validate_variant_args!(variant_args)
+        case variant_args
+        when Symbol
+          validate_name_format!(variant_args)
+        when Array
+          variant_args.each(&method(:validate_name_format!))
+
+          validate_unique!(variant_args)
+        else
+          raise(
+            VariantArgsError,
+            "Expected a Symbol or Array, got: #{variant_args}"
+          )
+        end
+      end
+    end
+  end
+end

data/lib/sums_up/core/strings.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module SumsUp
+  module Core
+    # Helpers for Strings.
+    module Strings
+      module_function
+
+      def snake_to_class(snake_case_name)
+        snake_case_name
+          .split('_')
+          .map(&:capitalize)
+          .join
+      end
+    end
+  end
+end

data/lib/sums_up/core/sum_type.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module SumsUp
+  module Core
+    # SumTypes are just modules with a meta-programmed methods to construct
+    # variants. Use SumType.build to define a new one.
+    #
+    # Each variant class must have the following constants defined:
+    #
+    # * VARIANT - Symbol name of the variant
+    # * MEMBERS - Array of Symbols which enumerate the variant's arguments
+    #
+    class SumType < Module
+      private_class_method :new
+
+      def self.build(variant_classes)
+        new do
+          const_set(:VARIANTS, variant_classes.freeze)
+
+          variant_classes.each do |variant_class|
+            variant_name = variant_class.const_get(:VARIANT)
+            class_name = SumType.variant_class_name(variant_name)
+            initializer = SumType.variant_initializer(variant_class)
+
+            const_set(class_name, variant_class)
+            define_singleton_method(variant_name, &initializer)
+
+            variant_class.include(self)
+          end
+        end
+      end
+
+      def self.variant_class_name(variant_name)
+        Strings
+          .snake_to_class(variant_name.to_s)
+          .to_sym
+      end
+
+      # Variants without any members are frozen by default for performance.
+      # Pass `memo: false` to its initializer to opt out of this behavior:
+      #
+      #   Maybe = SumsUp.define(:nothing, just: :value)
+      #
+      #   frozen_nothing = Maybe.nothing
+      #   unfrozen_nothing = Maybe.nothing(memo: false)
+      #
+      #   # Variants with members are never frozen.
+      #   unfrozen_just = Maybe.just(1)
+      #
+      def self.variant_initializer(variant_class)
+        if variant_class.const_get(:MEMBERS).empty?
+          dup_if_overridden(variant_class.new.freeze)
+        else
+          variant_class.method(:new)
+        end
+      end
+
+      def self.dup_if_overridden(frozen)
+        proc do |memo: true|
+          memo ? frozen : frozen.dup
+        end
+      end
+    end
+  end
+end

data/lib/sums_up/core/variant.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+module SumsUp
+  module Core
+    # Represents a variant of a sumtype. Use build_variant_class to generate
+    # a new subclass for a given variant.
+    class Variant
+      def self.build_variant_class(name, other_names, members, matcher_class)
+        Class.new(self) do
+          const_set(:VARIANT, name)
+          const_set(:MEMBERS, members.freeze)
+
+          const_set(:Accessors, accessors_module(members))
+          const_set(:Matcher, matcher_class)
+          const_set(:Predicates, predicates_module(name, other_names))
+
+          include(const_get(:Accessors))
+          include(const_get(:Predicates))
+        end
+      end
+
+      def self.accessors_module(members)
+        Module.new do
+          members.each_with_index do |member, idx|
+            define_method(member) { @values[idx] }
+
+            define_method(:"#{member}=") { |val| @values[idx] = val }
+          end
+        end
+      end
+
+      def self.predicates_module(correct_name, incorrect_names)
+        Module.new do
+          define_method(:"#{correct_name}?", &Functions.const(true))
+
+          incorrect_names.each do |incorrect_name|
+            define_method(:"#{incorrect_name}?", &Functions.const(false))
+          end
+        end
+      end
+
+      def initialize(*values)
+        given = values.length
+        expected = self.class::MEMBERS.length
+
+        if given != expected
+          raise(
+            ArgumentError,
+            "wrong number of arguments (given #{given}, expected #{expected})"
+          )
+        end
+
+        @values = values
+      end
+
+      def [](key)
+        idx = index_for_key(key)
+
+        @values[idx]
+      end
+
+      def []=(key, val)
+        idx = index_for_key(key)
+
+        @values[idx] = val
+      end
+
+      def match(**kwargs)
+        matcher = self.class::Matcher.new(self)
+
+        if block_given?
+          yield(matcher)
+        else
+          matcher._match_hash(kwargs)
+        end
+
+        matcher._fetch_result
+      end
+
+      def members(dup: true)
+        if dup
+          @values.dup
+        else
+          @values
+        end
+      end
+
+      alias to_a members
+
+      def attributes
+        self.class::MEMBERS.zip(@values).to_h
+      end
+
+      def to_h(include_root: true)
+        if include_root
+          { self.class::VARIANT => attributes }
+        else
+          attributes
+        end
+      end
+
+      def inspect
+        # If a sum type is defined but not assigned to a constant, Class.name
+        # name will return nil in Ruby 2.
+        variant = self.class.name || self.class::VARIANT
+
+        attrs = self.class::MEMBERS
+          .zip(@values)
+          .map { |member, value| "#{member}=#{value.inspect}" }
+          .join(', ')
+
+        if attrs.empty?
+          "#<variant #{variant}>"
+        else
+          "#<variant #{variant} #{attrs}>"
+        end
+      end
+
+      alias to_s inspect
+
+      def ==(other)
+        other.is_a?(self.class) &&
+          (other.to_a(dup: false) == @values)
+      end
+
+      private
+
+      def index_for_key(key)
+        idx = self.class::MEMBERS.index(key.to_sym)
+
+        return idx if idx
+
+        raise(NameError, "No member '#{key}' in variant #{self.class::VARIANT}")
+      end
+    end
+  end
+end