pleiades 0.1.1 → 0.1.2

data/lib/pleiades/core/command/routing/nest_blocks.rb

@@ -0,0 +1,238 @@
+require 'active_support/core_ext'
+require 'pleiades/core/command/routing/route_refine'
+
+module Pleiades
+  module Command
+    module Routing
+      # ブロック付きメソッド郡。
+      #
+      # イベントメソッドに渡すキーワード引数を、ネストしたリソースとしてまとめて実行する。
+      #
+      module NestBlocks
+        extend ActiveSupport::Concern
+        include Pleiades::Command::Routing::RouteRefine
+
+        # スコープをネストする。
+        #
+        # ## メソッド呼び出し時のメソッド名による処理の違い
+        # scope, scope_append
+        # 引数を後方追加する
+        #
+        # scope_unshift
+        # 引数を前方追加する
+        #
+        # ## EXAMPLE(単一リソースのネスト)
+        # ### 使用しない
+        # postback scope :hoge, action: :fuga
+        # postback scope :hoge, action: :piyo
+        #
+        # ### 使用する
+        # scope :hoge do
+        #   postback action: :fuga
+        #   postback action: :piyo
+        # end
+        #
+        # ## EXAMPLE(複数リソースのネスト)
+        # ### 使用しない
+        # postback scope :hoge, action: :piyo
+        # postback scope :fuga, action: :piyo
+        #
+        # ### 使用する
+        # scope :hoge, :fuga do
+        #   postback action: :piyo
+        # end
+        #
+        def scope(*scopes, &block)
+          scopes.flatten.map { |scp| nest_block __callee__, scp, &block }
+        end
+        alias :scope_append scope
+        alias :scope_unshift scope
+
+        # アクションをネストする。
+        #
+        # EXAMPLE
+        # ## 使用しない
+        # postback scope :hoge, action: :piyo
+        # postback scope :fuga, action: :piyo
+        #
+        # ## 使用する
+        # action :piyo do
+        #   postback scope :hoge
+        #   postback scope :fuga
+        # end
+        #
+        # ## EXAMPLE(単一リソースのネスト)
+        # ### 使用しない
+        # postback scope :hoge, action: :piyo
+        # postback scope :fuga, action: :piyo
+        #
+        # ### 使用する
+        # action :piyo do
+        #   postback scope :hoge
+        #   postback scope :fuga
+        # end
+        #
+        # ## EXAMPLE(複数リソースのネスト)
+        # ### 使用しない
+        # postback scope :piyo, action: :hoge
+        # postback scope :piyo, action: :fuga
+        #
+        # ### 使用する
+        # action :hoge, :fuga do
+        #   postback scope: :piyo
+        # end
+        #
+        def action(*actions, &block)
+          actions.flatten.map { |act| nest_block __method__, act, &block }
+        end
+
+        # Concernsをネストしたリソースに適用する。
+        #
+        # concern HogeModule do
+        #   postback # => HogeModule が include される
+        #   concern FugaModule do
+        #     postback # => HogeModule, FugaModule が include される
+        #   end
+        # end
+        #
+        def concern(*concerns, &block)
+          nest_block __method__, concerns, &block
+        end
+
+        # コマンドクラスへの呼び出すメソッド名をネストしたリソースに適用する。
+        #
+        # ## EXAMPLE
+        # ### 使用しない
+        # postback scope :hoge, action: :fuga, method: :greet
+        # # => Hoge::Fuga#greet が実行される。
+        #
+        # postback scope :hoge, action: :piyo, method: :greet
+        # # => Hoge::Piyo#greet が実行される
+        #
+        # ### 使用する
+        # method: :greet do
+        #   postback scope :hoge, action: :fuga
+        #   postback scope :hoge, action: :piyo
+        # end
+        #
+        alias :_method_ method
+        def method(method_name, &block)
+          if block_given?
+            nest_block __method__, method_name, &block
+          else
+            _method_(method_name)
+          end
+        end
+
+        # 複数のネストメソッドを呼び出す。
+        #
+        # EXAMPLE
+        # ## 使用しない
+        #
+        # scope :hoge do
+        #   action :fuga do
+        #     postback
+        #   end
+        # end
+        #
+        # ## 使用する
+        # nest_blocks scope: :hoge, action: :fuga do
+        #   postback
+        # end
+        #
+        # @param [Hash] key: ネストメソッド名, val: 引数
+        #
+        def nest_blocks(**keywords, &block)
+          validate_event_keywords(keywords.deep_dup.merge(type: ''))
+
+          nested_options = make_nested_options(keywords)
+
+          return if nested_options == false
+
+          nested_options.each do |opt|
+            nest(@options.deep_dup.merge(opt), &block)
+          end
+        end
+
+        private
+
+        def make_nested_options(keywords)
+          nested_options =
+            keywords.each_pair
+                    .each_with_object([[self]]) do |(method_name, arg), arr|
+                      routers = arr.last
+                      break if routers.include?(false)
+
+                      arr << nest_routers(routers) { method(method_name).call(arg) }.flatten
+                    end.last
+
+          nested_options ? nested_options.map(&:options) : false
+        end
+
+        def nest_routers(routers, &proc)
+          routers.map do |router|
+            nest_router = Array.wrap(nest(router.options.deep_dup, &proc))
+
+            break if nest_router.include?(false)
+
+            nest_router
+          end || [false]
+        end
+
+        def callable_nest_methods
+          reject_methods = %i[nest_blocks _method_]
+
+          Pleiades::Command::Routing::NestBlocks.public_instance_methods.without(*reject_methods)
+        end
+
+        def default_options
+          {
+            scope: [],
+            action: '',
+            method: '',
+            concern: []
+          }.merge(Pleiades::Config.router_default_option)
+        end
+
+        def nest_block(method_name, context, &block)
+          @_options = __send__ "merge_#{method_name}", context
+          @_self = Pleiades::Command::Router.new(@_options)
+
+          block_given? ? @_self.instance_eval(&block) : @_self
+        end
+
+        def merge_scope(context)
+          operator =
+            case __callee__
+            when /^merge_scope(_append)?$/
+              :append
+            when /^merge_scope_unshift$/
+              :unshift
+            end
+
+          __merge__ ->(option) { option[:scope].__send__ operator, context }
+        end
+        alias :merge_scope_append merge_scope
+        alias :merge_scope_unshift merge_scope
+
+        def merge_action(action)
+          __merge__ ->(option) { option[:action] = action }
+        end
+
+        def merge_concern(concerns)
+          __merge__ ->(option) { option[:concern].concat(concerns).flatten }
+        end
+
+        def merge_method(method)
+          __merge__ ->(option) { option[:method] = method }
+        end
+
+        def __merge__(proc)
+          dup_options = @options.deep_dup
+          proc.call(dup_options)
+          dup_options
+        end
+      end
+    end
+  end
+end

data/lib/pleiades/core/command/routing/path_builder.rb

@@ -0,0 +1,18 @@
+module Pleiades
+  module Command
+    module Routing
+      module PathBuilder
+        extend ActiveSupport::Concern
+        def normalize_path(scope = nil, action = nil)
+          dirs = []
+
+          dirs << @options[:scope] if @options[:scope].any?
+          dirs << scope if scope
+          dirs << (action || @options[:action])
+
+          dirs.join('/')
+        end
+      end
+    end
+  end
+end

data/lib/pleiades/core/command/routing/reflection.rb

@@ -0,0 +1,13 @@
+module Pleiades
+  module Command
+    module Routing
+      module Reflection
+        extend ActiveSupport::Concern
+
+        def __event_name__
+          @event.type
+        end
+      end
+    end
+  end
+end

data/lib/pleiades/core/command/routing/result.rb

@@ -0,0 +1,47 @@
+module Pleiades
+  module Command
+    module Routing
+      class Result
+        include Pleiades::Command::Routing::PathBuilder
+
+        def self.create(options, event_args = {})
+          new(options, event_args).send :create
+        end
+
+        private
+
+        def initialize(options, event_args)
+          @options = options
+          @event_args = event_args
+        end
+
+        def create
+          attributes.each_with_object({}) do |method_name, result|
+            result.store(method_name, send(method_name))
+          end
+        end
+
+        def attributes
+          rejects = %i[initialize create] << __method__
+          private_methods(false).without(*rejects)
+        end
+
+        def command_path
+          normalize_path(@event_args[:scope], @event_args[:action])
+        end
+
+        def call_method
+          @options[:method]
+        end
+
+        def concern
+          @options[:concern]
+        end
+
+        def executor
+          @options[:executor]
+        end
+      end
+    end
+  end
+end

data/lib/pleiades/core/command/routing/route_refine.rb

@@ -0,0 +1,49 @@
+module Pleiades
+  module Command
+    module Routing
+      module RouteRefine
+        # 指定したイベントの時のみブロックを実行する
+        #
+        # ## EXAMPLE
+        # only_events :postback do
+        #   event scope :hoge, action: :fuga
+        #   # => Hoge::Fuga を postbackイベントとして実行する
+        # end
+        #
+        def only_events(*events, &block)
+          return false unless callable_event_type?(events)
+
+          return self unless block_given?
+
+          instance_eval(&block)
+        end
+
+        # 指定したトークタイプの時のみブロックを実行する
+        #
+        # ## EXAMPLE
+        # talk_type :user do
+        #   p @event.source.type # => "user"
+        #   postback scope :hoge, action: :fuga
+        # end
+        #
+        def talk_type(*talk_types, &block)
+          return false unless callable_talk_type?(talk_types)
+
+          return self unless block_given?
+
+          instance_eval(&block)
+        end
+
+        private
+
+        def callable_talk_type?(types)
+          types.map(&:to_s).include?(@event.source.type)
+        end
+
+        def callable_event_type?(types)
+          types.map(&:to_s).include?(__event_name__)
+        end
+      end
+    end
+  end
+end

data/lib/pleiades/core/command/routing/validator.rb

@@ -0,0 +1,72 @@
+module Pleiades
+  module Command
+    module Routing
+      module Validator
+        extend ActiveSupport::Concern
+
+        private
+
+        # `match` の引数を検証する
+        #
+        # @param [Hash] match_keywords
+        #
+        # @raise 無効なイベント名が存在する場合に送出される
+        #
+        # @return [true] 入力値が妥当な場合
+        #
+        def validate_match_keywords(match_keywords)
+          match_keywords.fetch(:via) do |_|
+            raise ArgumentError, "Make sure to specify keyword `via:' in the `match' method."
+          end
+
+          match_keywords[:via].each_key do |event_name|
+            no_event = -> { raise "Unexpected event method `#{event_name}' specified in keyword `via:'." }
+            event_types.find(no_event) { |event| event_name.to_s == event }
+          end
+
+          true
+        end
+
+        # イベントメソッドの引数を検証する
+        #
+        # @param [Hash] keywords
+        #
+        # @raise [ArgumentError] 無効なキーワード名が存在する場合
+        #
+        # @return [True] 入力値が妥当な場合
+        #
+        def validate_event_keywords(keywords)
+          @_keywords = keywords.deep_dup
+          event_name = @_keywords.delete(:type)
+
+          event_specify_keywords = per_event_specify_keywords(event_name)
+
+          @_keywords.keys.each do |key|
+            next if event_specify_keywords.include?(key)
+
+            raise ArgumentError, <<~MES
+              #{__FILE__}:#{__LINE__}:in `#{__method__}'
+              #{event_name} event, key `#{key}' cannot be specified.
+            MES
+          end
+          true
+        end
+
+        def per_event_specify_keywords(event_name)
+          event_name = event_name.to_sym
+
+          commons = callable_nest_methods
+          per_events =
+            {
+              text: %i[pattern],
+              sticker: %i[package_id sticker_id]
+            }
+
+          extract_keywords = per_events[event_name]
+
+          extract_keywords ? commons.concat(extract_keywords) : commons
+        end
+      end
+    end
+  end
+end

data/lib/pleiades/core/command/routing_proxy.rb

@@ -0,0 +1,126 @@
+require 'pleiades/core/command/routing/route_refine'
+
+module Pleiades
+  module Command
+    class RoutingProxy
+      include Pleiades::Command::Routing::RouteRefine
+
+      class << self
+        def routing(&block)
+          @_ = new(@event)
+
+          block_given? ? @_.instance_eval(&block) : @_.default_routing
+        end
+
+        # 読み込む router_files を決める。
+        #
+        # @param [Line::Bot::Event] Eventクラス
+        #
+        # @return [Array<Pathname, ...>] 読み込むファイル一覧
+        #
+        def collect_router_file(event)
+          @event = event
+          proxy_exists? ? load(proxy_file) : routing
+
+          collect!
+        end
+
+        private
+
+        def proxy_exists?
+          FileTest.exist?(proxy_file)
+        end
+
+        def proxy_file
+          Pleiades::Constants::File::ROUTING_PROXY
+        end
+
+        def collect!
+          @_.routers
+        end
+      end
+
+      attr_reader :routers, :mount_pairs
+
+      def initialize(event)
+        @event = event
+        @routers = []
+        @mount_pairs = {}
+
+        mount default: Pleiades::Constants::File::CONFIG_DIR_PATH
+      end
+
+      def default_routing
+        add default_router
+      end
+
+      def add(router_name, mnt_key: :default)
+        no_keyword_err = lambda { |key|
+          <<~MES
+            from #{__FILE__}:#{__LINE__ - 1}:in `#{__method__}`:
+              Unmounted key `#{key}`. Please call `mount #{key}: 'path/to/router'` before `#{__method__}`.
+          MES
+        }
+        dir = @mount_pairs.fetch(mnt_key) { |key| raise no_keyword_err.call(key) }
+
+        @routers << "#{dir}/#{router_name}.rb"
+      end
+
+      # `add`で指定するキーワードを登録する。
+      #
+      # @param [symbol_name: path, ...]
+      #   symbol_name : キーワード
+      #   path        : プロジェクトホームからの相対パスまたは、絶対パス
+      #
+      # ## EXAMPLE
+      # mount hoge: 'path/to/hoge'
+      # add :fuga, mnt: :hoge
+      # # => path/to/hoge/fuga.rb
+      #
+      def mount(**paths)
+        validate_mount_keys(paths.keys)
+
+        paths.each_pair do |symbol, path|
+          @mount_pairs.store(symbol, path =~ %r{(\S+)/$} ? $1 : path)
+        end
+      end
+
+      def unmount(*mnt_symbols)
+        return @mount_pairs.clear && nil if mnt_symbols.include?(:all)
+
+        warn = ->(key) { "\nWarning from #{__FILE__}:#{__LINE__ - 3}:in `#{__method__}`: `#{key}` is unmounted." }
+
+        mnt_symbols.each do |symbol|
+          @mount_pairs.delete(symbol) { |sym| puts warn.call(sym) }
+        end
+      end
+
+      def unmount_all
+        unmount :all
+      end
+
+      def default_router
+        :router
+      end
+
+      private
+
+      def validate_mount_keys(keys)
+        keys.each do |key|
+          raise "`#{key}` is reserved words. Please specify another key name." if mount_reserved_word?(key)
+
+          raise "`#{key}` is already mounted." if mounted?(key)
+        end
+        true
+      end
+
+      def mount_reserved_word?(word)
+        %i[all].include?(word.to_sym)
+      end
+
+      def mounted?(key)
+        @mount_pairs.key?(key)
+      end
+    end
+  end
+end