mtk_framework 0.1.0

data/lib/mtk_framework/active_interaction_mocks/interaction_mocks_helper.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module MtkFramework
+  module ActiveInteractionMocks
+    module InteractionMocksHelper
+      def mock_interaction(
+        klass,
+        methods: nil,
+        failing: false,
+        mandatory: true,
+        expected_params: nil,
+        additional_params: nil,
+        return_proc: nil,
+        call_original: false
+      )
+        stubbed_methods = methods || (mandatory ? [:run] : %i[run run!])
+
+        spec_method = mandatory ? :expect : :allow
+        const_name = failing ? 'Fail' : 'Mocked'
+        mocking_klass = klass.const_get(const_name)
+
+        if block_given? || return_proc.present?
+          mocking_klass = Class.new(mocking_klass)
+          test_scope = self
+
+          mocking_klass.define_method :execute do
+            return_value = yield self if block_given?
+            if return_proc.present?
+              return_value = test_scope.instance_exec(&return_proc)
+            end
+
+            return_value
+          end
+
+          mocking_klass.define_singleton_method :name do
+            "#{klass.name}::#{const_name}"
+          end
+        end
+
+        stubbed_methods.map do |stubbed_method|
+          block = lambda { |*params|
+            mocking_klass.send(stubbed_method, *params, &block)
+          }
+
+          rspec_sentence = receive(stubbed_method, &block)
+
+          if expected_params
+            with = expected_params.respond_to?(:call) ? instance_eval(&expected_params) : expected_params
+            rspec_sentence.with(with, &block)
+          end
+
+          additional_params&.call(rspec_sentence)
+
+          rspec_sentence.and_call_original if call_original
+
+          send(spec_method, klass).to rspec_sentence
+        end
+      end
+    end
+  end
+end

data/lib/mtk_framework/active_interaction_mocks/mocks_loader.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module MtkFramework
+  module ActiveInteractionMocks
+    class MocksLoader
+      def run
+        # force require of all interactions
+        Dir['app/interactions/**/*.rb'].each do |x|
+          require Rails.root.join(x)
+        rescue StandardError
+          false
+        end
+
+        ApplicationInteraction.descendants.each do |klass|
+          mocked = Class.new(ApplicationInteraction) do
+            import_filters klass
+
+            # delegate i18n translation to mocked class
+            define_singleton_method :human_attribute_name do |*args|
+              klass.human_attribute_name(*args)
+            end
+
+            define_singleton_method :model_name do |*args|
+              klass.model_name(*args)
+            end
+
+            define_method :to_model do
+              klass.to_s.split('::').first.singularize.safe_constantize&.new
+            end
+
+            private
+
+            def execute; end
+          end
+
+          failing = Class.new(mocked) do
+            private
+
+            def execute
+              errors.add(:base, 'shit happens')
+            end
+          end
+
+          klass.const_set('Mocked', mocked)
+          klass.const_set('Fail', failing)
+        end
+
+        require_relative 'interaction_mocks_helper.rb'
+        require_relative 'interaction_group_mocks_helper.rb'
+      end
+    end
+  end
+end

data/lib/mtk_framework/active_interaction_params.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative 'active_interaction_params/parametrize_filter.rb'
+
+module MtkFramework
+  module ActiveInteractionParams
+    def params_from_interaction(klass, except: [])
+      params do
+        klass.filters.except(*except).each do |_, filter|
+          ParametrizeFilter.call(filter, self)
+          yield self if block_given?
+        end
+      end
+    end
+  end
+end

data/lib/mtk_framework/active_interaction_params/parametrize_filter.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module MtkFramework
+  module ActiveInteractionParams
+    class ParametrizeFilter
+      TYPES_MAPPING = {
+        'Integer' => Integer,
+        'Float' => Float,
+        'Boolean' => Grape::API::Boolean,
+        'String' => String,
+        'Symbol' => Symbol,
+        'Date' => Date,
+        'DateTime' => DateTime,
+        'Time' => Time,
+        'File' => File,
+        'Hash' => Hash,
+        'Array' => Array,
+        'TzSecretKey' => String,
+        'TzAccount' => String,
+        'TzContractAddress' => String,
+        'TzPublicKey' => String,
+        'TzSignature' => String
+      }.freeze
+
+      class <<self
+        # TODO: handle the case of Object, Record, Interface(?)
+        def call(filter, params_scope)
+          unless nestable_filter?(filter)
+            return params_scope.send(grape_method(filter), filter.name,
+                                     **grape_options(filter))
+          end
+
+          parametrize_nestable(filter, params_scope)
+        end
+
+        def parametrize_nestable(filter, params_scope)
+          current_filter = filter
+
+          params_scope.send(grape_method(current_filter), current_filter.name,
+                            **grape_options(current_filter)) do
+            current_filter.filters.each do |_, child_filter|
+              unless ParametrizeFilter.array_hash_filters?(current_filter, child_filter)
+                ParametrizeFilter.call(child_filter, self)
+              end
+
+              # skip the hash require in the case of an array of hashes (AI and grape handle this case differently)
+              child_filter.filters.each do |_, small_child_filter|
+                ParametrizeFilter.call(small_child_filter, self)
+              end
+            end
+          end
+        end
+
+        def grape_filter_type(filter)
+          if filter.is_a? ActiveInteraction::ArrayFilter
+            return array_grape_filter_type(filter)
+          end
+
+          filter_name = filter.class.name.split('::').second.split('Filter').first
+
+          TYPES_MAPPING.fetch(filter_name)
+        end
+
+        # returns Array[<File | Integer ...>] if not array of hashes
+        # else return Array, because in this case we use nested params with a block
+        def array_grape_filter_type(filter)
+          child_filter = filter.filters.values.first
+
+          unless child_filter.is_a? ActiveInteraction::HashFilter
+            return Array[grape_filter_type(child_filter)]
+          end
+
+          Array
+        end
+
+        def grape_options(filter)
+          grape_options = { desc: filter.options.fetch(:desc, ''), type: grape_filter_type(filter) }
+          if filter.options[:default]
+            grape_options[:default] = filter.options[:default]
+          end
+
+          grape_options
+        end
+
+        def grape_method(filter)
+          filter.options.key?(:default) ? :optional : :requires
+        end
+
+        def array_hash_filters?(filter, child_filter)
+          filter.is_a?(ActiveInteraction::ArrayFilter) && child_filter.is_a?(ActiveInteraction::HashFilter)
+        end
+
+        def nestable_filter?(filter)
+          unless filter.is_a? ActiveInteraction::ArrayFilter
+            return filter.filters.any?
+          end
+
+          # this case is not supposed to happen since ActiveInteraction only allows one type in the case of an Array
+          raise NotImplementedError unless filter.filters.count == 1
+
+          # if it is an array of hashes => we use nested params with a block
+          # else we use types like Array[String] => not nestable
+          filter.filters.values.first.is_a? ActiveInteraction::HashFilter
+        end
+      end
+    end
+  end
+  end

data/lib/mtk_framework/core_extensions/array/except.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class Array
+  def except(*fields)
+    self - fields
+  end
+end

data/lib/mtk_framework/core_extensions/class/virtual_method.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+class Class
+  def virtual_method(*args)
+    args.each do |method_name|
+      define_method(method_name) do
+        raise NotImplementedError, "#{self.class.name}##{method_name} is a virtual method!"
+      end
+    end
+  end
+end

data/lib/mtk_framework/core_extensions/hash/rename_keys.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+class Hash
+  def rename_keys(keys_replacement_hash)
+    transform_keys do |key|
+      next key unless keys_replacement_hash.key?(key)
+
+      keys_replacement_hash[key]
+    end
+  end
+end

data/lib/mtk_framework/gem_extensions/active_interaction/base.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module ActiveInteraction
+  class Base
+    def self.import_filters_optionally(klass, options = {})
+      only = options[:only]
+      except = options[:except]
+      default_value = options[:default_value]
+
+      other_filters = klass.filters.dup
+      other_filters.select! { |k, _| [*only].include?(k) } if only
+      other_filters.reject! { |k, _| [*except].include?(k) } if except
+
+      other_filters.each_value do |filter|
+        filter.options[:default] = default_value
+        initialize_filter(filter)
+      end
+    end
+  end
+end

data/lib/mtk_framework/gem_extensions/active_interaction/filters/abstract_tz_filter.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module ActiveInteraction
+  # @abstract
+  #
+  # Common logic for filters that handle numeric objects.
+  #
+  # @private
+  class AbstractTzFilter < Filter
+    private
+
+    def matches?(value)
+      value.is_a?(String) && valid_tz_entry?(value)
+    rescue NoMethodError # BasicObject
+      false
+    end
+
+    def valid_tz_entry?(value)
+      TezosClient.new.decode_tz(value) do |prefix, _payload|
+        return false unless prefixes.include? prefix
+      end
+
+      true
+    rescue ArgumentError
+      false
+    end
+  end
+end

data/lib/mtk_framework/gem_extensions/active_interaction/filters/hash_filter.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'active_interaction'
+
+# credits to : https://github.com/formigarafa/active_interaction/pull/2
+# This allows to import_filters inside hash. Example :
+# hash :user do
+#   import_filters UserSignup
+# end
+
+module ActiveInteraction
+  class HashFilter < Filter
+    # Import filters from another interaction.
+    #
+    # @param klass [Class] The other interaction.
+    # @param options [Hash]
+    #
+    # @option options [Array<Symbol>, nil] :only Import only these filters.
+    # @option options [Array<Symbol>, nil] :except Import all filters except
+    #   for these.
+    #
+    # @!visibility public
+    def import_filters(klass, options = {}) # rubocop:disable Metrics/AbcSize
+      only = options[:only]
+      except = options[:except]
+      groups = options[:groups] || [klass.to_s.demodulize.underscore.to_sym]
+
+      klass.filters.each do |name, filter|
+        next if only && ![*only].include?(name)
+        next if except && [*except].include?(name)
+
+        options = filter.options.merge(groups: groups)
+        filter_copy = filter.class.new(name, options)
+        filters[name] = filter_copy
+      end
+    end
+  end
+end

data/lib/mtk_framework/gem_extensions/active_interaction/filters/tz_account_filter.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module ActiveInteraction
+  class Base
+    # @!method self.tz_public_key(*attributes, options = {})
+    #   Creates accessors for the attributes and ensures that values passed to
+    #     the attributes are Strings.
+    #
+    #   @example
+    #     tz_public_key :public_key
+  end
+
+  # @private
+  class TzAccountFilter < AbstractTzFilter
+    register :tz_account
+
+    private
+
+    def prefixes
+      %i[tz1 tz2 tz3].freeze
+    end
+  end
+end

data/lib/mtk_framework/gem_extensions/active_interaction/filters/tz_contract_address_filter.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module ActiveInteraction
+  class Base
+    # @!method self.tz_public_key(*attributes, options = {})
+    #   Creates accessors for the attributes and ensures that values passed to
+    #     the attributes are Strings.
+    #
+    #   @example
+    #     tz_public_key :public_key
+  end
+
+  # @private
+  class TzContractAddressFilter < AbstractTzFilter
+    register :tz_contract_address
+
+    private
+
+    def prefixes
+      %i[KT].freeze
+    end
+  end
+end

data/lib/mtk_framework/gem_extensions/active_interaction/filters/tz_operation_filter.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module ActiveInteraction
+  class Base
+    # @!method self.tz_operation(*attributes, options = {})
+    #   Creates accessors for the attributes and ensures that values passed to
+    #     the attributes are Strings.
+    #
+    #   @example
+    #     tz_operation :operation
+  end
+
+  # @private
+  class TzOperationFilter < AbstractTzFilter
+    register :tz_operation
+
+    private
+
+    def prefixes
+      %i[o].freeze
+    end
+  end
+end

data/lib/mtk_framework/gem_extensions/active_interaction/filters/tz_public_key_filter.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module ActiveInteraction
+  class Base
+    # @!method self.tz_public_key(*attributes, options = {})
+    #   Creates accessors for the attributes and ensures that values passed to
+    #     the attributes are Strings.
+    #
+    #   @example
+    #     tz_public_key :public_key
+  end
+
+  # @private
+  class TzPublicKeyFilter < AbstractTzFilter
+    register :tz_public_key
+
+    private
+
+    def prefixes
+      %i[edpk].freeze
+    end
+  end
+end