ff-tbl-macros 0.1.8

data/lib/macros/base.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Macros
+  # Base class for all the Trbr step macros
+  class Base
+    include Uber::Callable
+
+    # @param args Any arguments that our macro operation supports
+    # @return Single step object that can be used in operation step
+    def initialize(*args)
+      self.args = args
+    end
+
+    # To follow Trbr concept of named steps we have to register class instances
+    # with given class names - this method registers a class so it can be used
+    # with brackets. It will create a method that has a name that has the same name
+    # as a class from which we want to use an object to handle a step
+    #
+    # @param step_name [Symbol] name that we want to use
+    # @param proxy [Boolean] is this just a proxy for Trailblazer built in operation
+    #
+    # @example Register with :create
+    #   register :create #=> Macros::Create()
+    def self.register(step_name, proxy: false)
+      klass = step_name.to_s.split('_').collect(&:capitalize).join
+
+      define_singleton_method klass do |*args|
+        base = "#{self}::#{klass}".constantize
+        proxy ? base.new(*args).call : base.new(*args)
+      end
+    end
+
+    private
+
+    attr_accessor :args
+  end
+end

data/lib/macros/contract.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Macros
+  class Contract < Macros::Base
+    register :extract_params
+    register :prepopulate
+  end
+end

data/lib/macros/contract/extract_params.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Macros
+  class Contract
+    class ExtractParams < Macros::Base
+      # @return [Macros::Contract::ExtractParams] step macro instance
+      # @param from [Hash] key in params
+      # @example scope not passed
+      #   Macros::Contract::ExtractParams(from: :scope)
+
+      def initialize(from:)
+        @from = from
+      end
+
+      def call(ctx, **)
+        return false unless ctx[:params]
+
+        scope = ctx[@from]
+        return false unless scope
+
+        ctx['contract.default.params'] = ctx[:params][scope]
+      end
+    end
+  end
+end

data/lib/macros/contract/prepopulate.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Macros
+  class Contract
+    class Prepopulate < Macros::Base
+      def initialize(options_key: nil)
+        @options_key = options_key
+      end
+
+      def call(ctx, **)
+        options = ctx[@options_key] || {}
+        ctx['contract.default'].prepopulate!(options)
+      end
+    end
+  end
+end

data/lib/macros/ctx.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Macros
+  class Ctx < Macros::Base
+    register :copy
+    register :inspect
+    register :validate_presence
+  end
+end

data/lib/macros/ctx/copy.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Macros
+  class Ctx
+    class Copy < Macros::Base
+      def initialize(origin_key, destination_key)
+        @origin_key = origin_key
+        @destination_key = destination_key
+      end
+
+      def call(ctx, **)
+        return false unless ctx[@origin_key]
+
+        ctx[@destination_key] = ctx[@origin_key]
+      end
+    end
+  end
+end

data/lib/macros/ctx/inspect.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Macros
+  class Ctx
+    # Prints the entire tbl context or just a single resource
+    #
+    # @example prints the entire tbl context
+    #   step Macros::Ctx::Inspect()
+    #
+    # @example prints the :model resource from the tbl context
+    #   step Macros::Ctx::Inspect(key: :model)
+    class Inspect < Macros::Base
+      # @return [Macros::Debug::Ctx] step macro instance
+      # @param key [Symbol or String] ctx key under which is a resource to which we want to assign, optional
+      def initialize(key: nil)
+        @key = key
+      end
+
+      def call(ctx, **)
+        if @key
+          p ctx[@key]
+        else
+          p ctx
+        end
+      end
+    end
+  end
+end

data/lib/macros/ctx/validate_presence.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Macros
+  class Ctx
+    class ValidatePresence < Macros::Base
+      # Check if the key set in the context
+      # @param key [Symbol]
+      # @example key not passed
+      #   Macros::Contract::ExtractParams()
+      def initialize(key)
+        @key = key
+      end
+
+      # @param ctx [Trailblazer::Skill] tbl context hash
+      def call(ctx, **)
+        !!ctx[@key]
+      end
+    end
+  end
+end

data/lib/macros/current_user.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Macros
+  class CurrentUser < Macros::Base
+    register :set
+  end
+end

data/lib/macros/current_user/set.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Macros
+  class CurrentUser
+    VALID_CURRENT_USER_CLASS_NAMES = %w[User Admin].freeze
+
+    # Sets the current_user in the context.
+    #
+    class Set < Macros::Base
+      # @return [Macro::CurrentUser::Set] step macro instance
+      def initialize(key: :model)
+        @key = key
+      end
+
+      # Sets the current user in the context
+      # @param ctx [Trailblazer::Skill] tbl context hash
+      def call(ctx, **)
+        return false unless ctx[@key]
+        return false unless VALID_CURRENT_USER_CLASS_NAMES.include? ctx[@key].class.name.demodulize
+
+        ctx[:current_user] = ctx[@key]
+      end
+    end
+  end
+end

data/lib/macros/error.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Macros
+  class Error < Macros::Base
+    register :set_from_contract
+  end
+end

data/lib/macros/error/set_from_contract.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Macros
+  class Error
+    # Set error messages in the context using contract errors
+    #
+    # @example
+    #   step Macros::Error::SetFromContract
+    class SetFromContract < Macros::Base
+      def call(ctx, **)
+        error_messages = ctx['contract.default']&.errors&.messages
+        return false unless error_messages
+
+        ctx[:error_messages] = error_messages
+        !!ctx[:error_messages]
+      end
+    end
+  end
+end

data/lib/macros/model.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Macros
+  class Model < Macros::Base
+    register :build
+    register :copy
+    register :destroy
+    register :persist
+  end
+end

data/lib/macros/model/build.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Macros
+  class Model
+    class Build < Macros::Base
+      # @return [Macros::Model::Build] step macro instance
+      # @param from [Hash] required attribute, key in the context to build model class from
+      # @example
+      #   Macros::Model::Build(from: :scope)
+      # @param condition [Hash] attribute the model should respond to as the condition to be set.
+      # @example model should respond to :last_sign_in_at
+      #   Macros::Model::Build(from: :scope, respond_to: :last_sign_in_at)
+
+      def initialize(from:, respond_to: nil)
+        @from = from
+        @respond_to = respond_to
+      end
+
+      # Sets the model in the context
+      # @param ctx [Trailblazer::Skill] tbl context hash
+      def call(ctx, **)
+        scope = ctx[@from]
+        return false unless scope
+
+        klass = scope.to_s.classify.constantize
+        return false if @respond_to && !klass.new.respond_to?(@respond_to)
+
+        ctx[:model] = klass.new
+      end
+    end
+  end
+end

data/lib/macros/model/copy.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Macros
+  class Model
+    class Copy < Macros::Base
+      def initialize(ctx_key = nil)
+        @ctx_key = ctx_key
+      end
+
+      def call(ctx, **)
+        return false unless ctx[@ctx_key]
+
+        ctx[:model] = ctx[@ctx_key]
+      end
+    end
+  end
+end

data/lib/macros/model/destroy.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Macros
+  class Model
+    # Destroy step for removing object assigned in ctx['model']
+    # @example
+    #   step Macros::Model::Destroy()
+    class Destroy < Macros::Base
+      # Destroys a given model
+      # @param _ctx [Trailblazer::Skill] context accumulator
+      # @param model [Object] object that we want to destroy
+      def call(_ctx, model:, **)
+        model.destroy
+        model.destroyed?
+      end
+    end
+  end
+end

data/lib/macros/model/persist.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Macros
+  class Model
+    # Persist object from the context
+    # @example
+    #   step Macros::Model::Persist(ctx_key: :weekly_plan_editing)
+    class Persist < Macros::Base
+      def initialize(ctx_key: :model, method: :save!)
+        @ctx_key = ctx_key
+        @method = method
+      end
+
+      def call(ctx, **)
+        return false unless ctx[@ctx_key]
+
+        ctx[@ctx_key].public_send(@method)
+      end
+    end
+  end
+end

data/lib/macros/search.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Macros
+  class Search < Macros::Base
+    register :query
+  end
+end

data/lib/macros/search/query.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Macros
+  class Search
+    class Query < Macros::Base
+      # @return [Macros::Search::Results] step macro instance
+      #
+      # @example searchable is optional
+      #   Macros::Search::Query(searchable: Admin)
+      def initialize(searchable:)
+        @searchable = searchable
+      end
+
+      # @param ctx [Trailblazer::Skill] tbl context hash
+      #
+      # The search params are passed in ctx[:params] and look like this:
+      # `{q: 'the query', page: 2}`
+      #
+      # The orders is passed in ctx[:order] and looks like this:
+      # `{created_at: :desc}`
+      def call(ctx, params:, order: nil, **)
+        return false unless @searchable
+
+        ctx[:searchable] = @searchable
+        ransack_search_result = @searchable.ransack params[:q]
+        ctx[:query] = ransack_search_result
+
+        temp_search_results = ransack_search_result.result
+        search_results = order ? temp_search_results.order(order) : temp_search_results
+        ctx[:search_results] = search_results.page params[:page]
+      end
+    end
+  end
+end

data/lib/macros/verify_params.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Macros
+  class VerifyParams < Macros::Base
+    register :date
+  end
+end

data/lib/macros/verify_params/date.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Macros
+  class VerifyParams
+    class Date < Macros::Base
+      def initialize(params_key: :date)
+        @params_key = params_key
+      end
+
+      def call(ctx, **)
+        return false unless ctx[:params]
+
+        ctx[:params][@params_key].class == ::Date
+      end
+    end
+  end
+end

data/lib/macros/version.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Macros
+  # Current version
+  VERSION = '0.1.8'
+end

data/spec/lib/auth/authenticate_spec.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+RSpec.describe Macros::Auth::Authenticate do
+  include Warden::Test::Mock
+
+  subject(:authenticate_step) { described_class.new }
+
+  before do
+    warden.set_user(user, scope: scope)
+  end
+
+  let(:user) { mock_model('User') }
+  let(:scope) { :user }
+  let(:ctx) { {} }
+
+  it 'expects to authenticate' do
+    authenticate_step.call(ctx, scope: scope, warden: warden)
+
+    expect(ctx[:model]).to eql user
+  end
+end