functional-light-service 0.2.4

data/lib/functional-light-service/functional/enum.rb

@@ -0,0 +1,254 @@
+module FunctionalLightService
+  module Enum
+    class MatchError < StandardError; end
+  end
+
+  class EnumBuilder
+    def initialize(parent)
+      @parent = parent
+    end
+
+    class DataType
+      module AnyEnum
+        include FunctionalLightService::Monad
+
+        def match(&block)
+          parent.match(self, &block)
+        end
+
+        def to_s
+          value.to_s
+        end
+
+        def name
+          self.class.name.split("::")[-1]
+        end
+
+        # Returns array. Will fail on Nullary objects.
+        # TODO: define a Unary module so we can define this method differently on Unary vs Binary
+        def wrapped_values
+          if is_a?(FunctionalLightService::EnumBuilder::DataType::Binary)
+            value.values
+          else
+            [value]
+          end
+        end
+      end
+
+      module Nullary
+        def initialize(*_args)
+          @value = nil
+        end
+
+        def inspect
+          name
+        end
+      end
+
+      # TODO: this should probably be named Multary
+      module Binary
+        def initialize(*init)
+          unless (init.count == 1 && init[0].is_a?(Hash)) || init.count == args.count
+            raise ArgumentError, "Expected arguments for #{args}, got #{init}"
+          end
+
+          @value = if init.count == 1 && init[0].is_a?(Hash)
+                     Hash[args.zip(init[0].values)]
+                   else
+                     Hash[args.zip(init)]
+                   end
+        end
+
+        def inspect
+          params = value.map { |k, v| "#{k}: #{v.inspect}" }
+          "#{name}(#{params.join(', ')})"
+        end
+      end
+
+      # rubocop:disable Metrics/MethodLength
+      def self.create(parent, args)
+        # rubocop:disable Style/AccessModifierDeclarations
+        if args.include? :value
+          raise ArgumentError, "#{args} may not contain the reserved name :value"
+        end
+
+        dt = Class.new(parent)
+
+        dt.instance_eval do
+          public_class_method :new
+          include AnyEnum
+          define_method(:args) { args }
+
+          define_method(:parent) { parent }
+          private :parent
+        end
+
+        case args.count
+        when 0
+          dt.instance_eval do
+            include Nullary
+            private :value
+          end
+        when 1
+          dt.instance_eval do
+            define_method(args[0].to_sym) { value }
+          end
+        else
+          dt.instance_eval do
+            include Binary
+
+            args.each do |m|
+              define_method(m) do
+                @value[m]
+              end
+            end
+          end
+        end
+
+        dt
+        # rubocop:enable Style/AccessModifierDeclarations
+      end
+      # rubocop:enable Metrics/MethodLength
+
+      class << self
+        # rubocop:disable Style/AccessModifierDeclarations
+        public :new
+        # rubocop:enable Style/AccessModifierDeclarations
+      end
+    end
+
+    def method_missing(m, *args)
+      if @parent.const_defined?(m)
+        super
+      else
+        @parent.const_set(m, DataType.create(@parent, args))
+      end
+    end
+  end
+
+  module_function
+
+  # rubocop:disable Metrics/AbcSize
+  # rubocop:disable Metrics/CyclomaticComplexity
+  # rubocop:disable Metrics/MethodLength
+  # rubocop:disable Metrics/PerceivedComplexity
+  def enum(&block)
+    mod = Class.new do # the enum to be built
+      private_class_method :new
+
+      def self.match(obj, &block)
+        caller_ctx = block.binding.eval 'self'
+
+        matcher = self::Matcher.new(obj)
+        matcher.instance_eval(&block)
+
+        variants_in_match = matcher.matches.collect do |e|
+          e[1].name.split('::')[-1].to_sym
+        end.uniq.sort
+        variants_not_covered = variants - variants_in_match
+        unless variants_not_covered.empty?
+          raise Enum::MatchError, "Match is non-exhaustive, #{variants_not_covered} not covered"
+        end
+
+        type_matches = matcher.matches.select { |r| r[0].is_a?(r[1]) }
+
+        type_matches.each do |match|
+          obj, _type, block, args, guard = match
+
+          return caller_ctx.instance_eval(&block) if args.count.zero?
+
+          if args.count != obj.args.count
+            msg = "Pattern (#{args.join(', ')}) must match (#{obj.args.join(', ')})"
+            raise Enum::MatchError, msg
+          end
+
+          guard_ctx = guard_context(obj, args)
+          return caller_ctx.instance_exec(* obj.wrapped_values, &block) unless guard
+
+          if guard && guard_ctx.instance_exec(obj, &guard)
+            return caller_ctx.instance_exec(* obj.wrapped_values, &block)
+          end
+        end
+
+        raise Enum::MatchError, "No match could be made"
+      end
+
+      def self.variants
+        constants - %i[Matcher MatchError]
+      end
+
+      def self.guard_context(obj, args)
+        if obj.is_a?(FunctionalLightService::EnumBuilder::DataType::Binary)
+          Struct.new(*args).new(*obj.value.values)
+        else
+          Struct.new(*args).new(obj.value)
+        end
+      end
+    end
+    enum = EnumBuilder.new(mod)
+    enum.instance_eval(&block)
+
+    type_variants = mod.constants
+
+    matcher = Class.new do
+      def initialize(obj)
+        @obj = obj
+        @matches = []
+        @vars = []
+      end
+
+      attr_reader :matches, :vars
+
+      def where(&guard)
+        guard
+      end
+
+      type_variants.each do |m|
+        define_method(m) do |guard = nil, &inner_block|
+          raise ArgumentError, "No block given to `#{m}`" if inner_block.nil?
+
+          params_spec = inner_block.parameters
+          if params_spec.any? { |spec| spec.size < 2 }
+            msg = "Unnamed param found in block parameters: #{params_spec.inspect}"
+            raise ArgumentError, msg
+          end
+          if params_spec.any? { |spec| spec[0] != :req && spec[0] != :opt }
+            msg = "Only :req & :opt params allowed; parameters=#{params_spec.inspect}"
+            raise ArgumentError, msg
+          end
+
+          args = params_spec.map { |spec| spec[1] }
+
+          type = Kernel.eval("#{mod.name}::#{m}")
+
+          guard = nil if guard && !guard.is_a?(Proc)
+
+          @matches << [@obj, type, inner_block, args, guard]
+        end
+      end
+    end
+
+    mod.const_set(:Matcher, matcher)
+
+    type_variants.each do |variant|
+      mod.singleton_class.class_exec do
+        define_method(variant) do |*args|
+          const_get(variant).new(*args)
+        end
+      end
+    end
+    mod
+  end
+  # rubocop:enable Metrics/AbcSize
+  # rubocop:enable Metrics/CyclomaticComplexity
+  # rubocop:enable Metrics/MethodLength
+  # rubocop:enable Metrics/PerceivedComplexity
+
+  def impl(enum_type, &block)
+    enum_type.variants.each do |v|
+      name = "#{enum_type.name}::#{v}"
+      type = Kernel.eval(name)
+      type.class_eval(&block)
+    end
+  end
+end

data/lib/functional-light-service/functional/maybe.rb

@@ -0,0 +1,14 @@
+class Object
+  def null?
+    false
+  end
+
+  def some?
+    true
+  end
+end
+# rubocop:disable Naming/MethodName
+def Maybe(obj)
+  obj.nil? ? Null.instance : obj
+end
+# rubocop:enable Naming/MethodName

data/lib/functional-light-service/functional/monad.rb

@@ -0,0 +1,66 @@
+module FunctionalLightService
+  module Monad
+    class NotMonadError < StandardError; end
+
+    # Basicly the `pure` function
+    def initialize(init)
+      @value = join(init)
+    end
+
+    # If the passed value is monad already, get the value to avoid nesting
+    # M[M[A]] is equivalent to M[A]
+    def join(other)
+      if other.is_a? self.class
+        other.value
+      else
+        other
+      end
+    end
+
+    # The functor: takes a function (a -> b) and applies it to the inner value of the monad (Ma),
+    # boxes it back to the same monad (Mb)
+    # fmap :: (a -> b) -> M a -> M b
+    def fmap(proc = nil, &block)
+      result = (proc || block).call(value)
+      self.class.new(result)
+    end
+
+    # The monad: takes a function which returns a monad (of the same type), applies the function
+    # bind :: (a -> Mb) -> M a  -> M b
+    # the self.class, i.e. the containing monad is passed as a second (optional) arg to the function
+    def bind(proc = nil, &block)
+      (proc || block).call(value).tap do |result|
+        # rubocop:disable Style/CaseEquality
+        parent = self.class.superclass === Object ? self.class : self.class.superclass
+        # rubocop:enable Style/CaseEquality
+        unless result.is_a? parent
+          raise NotMonadError, "Expected #{result.inspect} to be an #{parent}"
+        end
+      end
+    end
+    alias :'>>=' :bind
+
+    # Get the underlying value, return in Haskell
+    # return :: M a -> a
+    def value
+      @value
+    end
+
+    def to_s
+      value.to_s
+    end
+
+    # Two monads are equivalent if they are of the same type and when their values are equal
+    def ==(other)
+      return false unless other.is_a? self.class
+
+      @value == other.instance_variable_get(:@value)
+    end
+
+    # Return the string representation of the Monad
+    def inspect
+      pretty_class_name = self.class.name.split('::')[-1]
+      "#{pretty_class_name}(#{value.inspect})"
+    end
+  end
+end

data/lib/functional-light-service/functional/null.rb

@@ -0,0 +1,74 @@
+# The simplest NullObject there can be
+class Null
+  class << self
+    def method_missing(m, *args)
+      if m == :new
+        super
+      else
+        Null.instance
+      end
+    end
+
+    def instance
+      @instance ||= new([])
+    end
+
+    def null?
+      true
+    end
+
+    def some?
+      false
+    end
+
+    def mimic(klas)
+      new(klas.instance_methods(false))
+    end
+
+    def ==(other)
+      other.respond_to?(:null?) && other.null?
+    end
+  end
+  private_class_method :new
+
+  def initialize(methods)
+    @methods = methods
+  end
+
+  # implicit conversions
+  def to_str
+    ''
+  end
+
+  def to_ary
+    []
+  end
+
+  def method_missing(m, *args)
+    return self if respond_to?(m)
+
+    super
+  end
+
+  def null?
+    true
+  end
+
+  def some?
+    false
+  end
+
+  def respond_to?(m, include_private = false)
+    return true if @methods.empty? || @methods.include?(m)
+
+    super
+  end
+
+  def inspect
+    'Null'
+  end
+
+  def ==(other)
+    other.respond_to?(:null?) && other.null?
+  end
+end

data/lib/functional-light-service/functional/option.rb

@@ -0,0 +1,99 @@
+module FunctionalLightService
+  Option = FunctionalLightService.enum do
+    Some(:s)
+    None()
+  end
+
+  class Option
+    class << self
+      def some?(expr)
+        to_option(expr) { expr.nil? }
+      end
+
+      def any?(expr)
+        to_option(expr) { expr.nil? || (expr.respond_to?(:empty?) && expr.empty?) }
+      end
+
+      def to_option(expr)
+        yield(expr) ? None.new : Some.new(expr)
+      end
+
+      def try!
+        yield
+      rescue StandardError
+        None.new
+      end
+    end
+  end
+
+  # rubocop:disable Metrics/BlockLength
+  impl(Option) do
+    class NoneValueError < StandardError; end
+
+    def fmap
+      match do
+        Some() { |s| self.class.new(yield(s)) }
+        None() { self }
+      end
+    end
+
+    def map(&fn)
+      match do
+        Some() { |_s| bind(&fn) }
+        None() { self }
+      end
+    end
+
+    def some?
+      is_a? Option::Some
+    end
+
+    def none?
+      is_a? Option::None
+    end
+
+    alias :empty? :none?
+
+    def value_or(n)
+      match do
+        Some() { |s| s }
+        None() { n }
+      end
+    end
+
+    def value_to_a
+      @value
+    end
+
+    def +(other)
+      match do
+        None() { other }
+        Some(where { !other.is_a?(Option) }) { |_| raise TypeError, "Other must be an #{Option}" }
+        Some(where { other.some? }) { |s| Option::Some.new(s + other.value) }
+        Some() { |_| self }
+      end
+    end
+  end
+  # rubocop:enable Metrics/BlockLength
+
+  module Prelude
+    module Option
+      None = FunctionalLightService::Option::None.new
+      Option = FunctionalLightService::Option
+      # rubocop:disable Naming/MethodName
+      def Some(s)
+        FunctionalLightService::Option::Some.new(s)
+      end
+
+      def None
+        FunctionalLightService::Prelude::Option::None
+      end
+
+      def Option
+        FunctionalLightService::Option
+      end
+      # rubocop:enable Naming/MethodName
+      # include Option
+    end
+  end
+end

data/lib/functional-light-service/functional/result.rb

@@ -0,0 +1,122 @@
+module FunctionalLightService
+  Result = FunctionalLightService.enum do
+    Success(:s)
+    Failure(:f)
+  end
+
+  class Result
+    class << self
+      def try!
+        Success.new(yield)
+      rescue StandardError => err
+        Failure.new(err)
+      end
+    end
+  end
+
+  # rubocop:disable Metrics/BlockLength
+  FunctionalLightService.impl(Result) do
+    def map(proc = nil, &block)
+      match do
+        Success() { |_| bind(proc || block) }
+        Failure() { |_| self }
+      end
+    end
+
+    alias :>> :map
+    alias :and_then :map
+
+    def map_err(proc = nil, &block)
+      match do
+        Success() { |_| self }
+        Failure() { |_| bind(proc || block) }
+      end
+    end
+
+    alias :or_else :map_err
+
+    def pipe(proc = nil, &block)
+      (proc || block).call(self)
+      self
+    end
+
+    alias :<< :pipe
+
+    def success?
+      is_a? Result::Success
+    end
+
+    def failure?
+      is_a? Result::Failure
+    end
+
+    def or(other)
+      unless other.is_a? Result
+        msg = "Expected #{other.inspect} to be a Result"
+        raise FunctionalLightService::Monad::NotMonadError, msg
+      end
+
+      match do
+        Success() { |_| self }
+        Failure() { |_| other }
+      end
+    end
+
+    def and(other)
+      unless other.is_a? Result
+        msg = "Expected #{other.inspect} to be a Result"
+        raise FunctionalLightService::Monad::NotMonadError, msg
+      end
+
+      match do
+        Success() { |_| other }
+        Failure() { |_| self }
+      end
+    end
+
+    def +(other)
+      unless other.is_a? Result
+        msg = "Expected #{other.inspect} to be a Result"
+        raise FunctionalLightService::Monad::NotMonadError, msg
+      end
+
+      match do
+        Success(where { other.success? }) { |s| Result::Success.new(s + other.value) }
+        Failure(where { other.failure? }) { |f| Result::Failure.new(f + other.value) }
+        Success() { |_| other } # implied other.failure?
+        Failure() { |_| self } # implied other.success?
+      end
+    end
+
+    def try(proc = nil, &block)
+      map(proc, &block)
+    rescue StandardError => e
+      Result::Failure.new(e)
+    end
+
+    alias :>= :try
+  end
+  # rubocop:enable Metrics/BlockLength
+end
+
+module FunctionalLightService
+  module Prelude
+    module Result
+      # rubocop:disable Naming/MethodName
+      def try!(&block)
+        FunctionalLightService::Result.try!(&block)
+      end
+
+      def Success(s)
+        FunctionalLightService::Result::Success.new(s)
+      end
+
+      def Failure(f)
+        FunctionalLightService::Result::Failure.new(f)
+      end
+      # rubocop:enable Naming/MethodName
+    end
+
+    include Result
+  end
+end

data/lib/functional-light-service/localization_adapter.rb

@@ -0,0 +1,44 @@
+module FunctionalLightService
+  class LocalizationAdapter
+    def failure(message_or_key, action_class, i18n_options = {})
+      find_translated_message(message_or_key,
+                              action_class,
+                              i18n_options,
+                              :type => :failure)
+    end
+
+    def success(message_or_key, action_class, i18n_options = {})
+      find_translated_message(message_or_key,
+                              action_class,
+                              i18n_options,
+                              :type => :success)
+    end
+
+    private
+
+    def find_translated_message(message_or_key,
+                                action_class,
+                                i18n_options,
+                                type)
+      if message_or_key.is_a?(Symbol)
+        i18n_options.merge!(type)
+        translate(message_or_key, action_class, i18n_options)
+      else
+        message_or_key
+      end
+    end
+
+    def translate(key, action_class, options = {})
+      type = options.delete(:type)
+
+      scope = i18n_scope_from_class(action_class, type)
+      options[:scope] = scope
+
+      I18n.t(key, options)
+    end
+
+    def i18n_scope_from_class(action_class, type)
+      "#{action_class.name.underscore}.light_service.#{type.to_s.pluralize}"
+    end
+  end
+end

data/lib/functional-light-service/organizer/execute.rb

@@ -0,0 +1,14 @@
+module FunctionalLightService
+  module Organizer
+    class Execute
+      def self.run(code_block)
+        ->(ctx) do
+          return ctx if ctx.stop_processing?
+
+          code_block.call(ctx)
+          ctx
+        end
+      end
+    end
+  end
+end

data/lib/functional-light-service/organizer/iterate.rb

@@ -0,0 +1,22 @@
+module FunctionalLightService
+  module Organizer
+    class Iterate
+      extend ScopedReducable
+
+      def self.run(organizer, collection_key, steps)
+        ->(ctx) do
+          return ctx if ctx.stop_processing?
+
+          collection = ctx[collection_key]
+          item_key = collection_key.to_s.singularize.to_sym
+          collection.each do |item|
+            ctx[item_key] = item
+            ctx = scoped_reduce(organizer, ctx, steps)
+          end
+
+          ctx
+        end
+      end
+    end
+  end
+end