pleiades 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 61770f9cbd46a0c7a47fadf3f42f69ec91efa608e7b7adf1c02bad853236c126
-  data.tar.gz: 729ad8ca0d354114894429c5b78eefbb627f2fd1cac55d688b3da4fcbf665002
+  metadata.gz: c303e9dfbed28743e63d0c5d542eb7c7ab357b9e2b7fbf8d0ca2a8ab40a7a551
+  data.tar.gz: 0dd07f1e245f0c56fd8ab7857c92ed2a4c94dbc8213102c643f606ee513132ae
 SHA512:
-  metadata.gz: 968cf11cf8dd04d42a30852b5d05134bc4cc7c48e822fc5b63f58134233255681f48bf64ebfd2acf018c651285f2b59d19b5c64efe137f2d8c11e61938338a58
-  data.tar.gz: eb3d084d1fa7cbbf971956205c26a1d7096a3de12ae3dd9171fa54a14e6c465ccdf56cfac165483bfbe8ffa5755e2633f9064509ff8653c9714610993440c30c
+  metadata.gz: e26d3c12ade048b4ba9e45a170c88d5a837b78af8a2c09893b8da2643ac1c1f10e76841a2942874df72f47e76713450bed3b24d3c4c4c94f802cf1745de021fc
+  data.tar.gz: 84d6fcc5db36955ce9b20532451ef09bd92620e5eafcca39523885392481a996ad43517ce866a1395d2f2f6e020ed4bca4113285e9344d7e1e20b55799093fb3

data/.gitignore

@@ -8,8 +8,8 @@
 !Gemfile
 !LICENSE.txt
 !pleiades.gemspec
-Rakefile
-README.md
+!Rakefile
+!README.md
 
 !/bin/
 !/bin/**/*

data/README.md

@@ -0,0 +1,23 @@
+# Pleiades
+
+RailsでLINEBotを開発するためのgem。
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'pleiades'
+```
+    $ bundle install
+
+## Usage
+Comming soon.....
+
+## Contributing
+
+https://github.com/harukikubota/pleiades
+
+## License
+
+[MIT License](https://opensource.org/licenses/MIT)

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/lib/pleiades/core.rb

@@ -1,3 +1,4 @@
+require 'pleiades/core/client'
 require 'pleiades/core/command'
 require 'pleiades/core/config'
 require 'pleiades/core/constants'

data/lib/pleiades/core/client.rb

@@ -0,0 +1,52 @@
+require 'pleiades/core/client/wrapper'
+
+module Pleiades
+  module Client
+    def self.included(base)
+      include_modules = [Common]
+
+      on_controller_class = ApplicationController.subclasses.include?(base)
+
+      include_modules << Controller if on_controller_class
+
+      include_modules.each do |mod|
+        base.include mod
+      end
+    end
+
+    module Common
+      def self.included(base)
+        base.class_eval <<~RUBY, __FILE__, __LINE__ + 1
+          def client
+            return @client if @client
+
+            channel_secret, channel_token = Pleiades::Config.client_keys
+
+            @client = Line::Bot::Client.new do |config|
+              config.channel_secret = channel_secret
+              config.channel_token = channel_token
+            end
+          end
+        RUBY
+      end
+    end
+
+    module Controller
+      def validate_signature
+        client.validate_signature(body, signature)
+      end
+
+      def signature
+        request.env['HTTP_X_LINE_SIGNATURE']
+      end
+
+      def body
+        @body ||= request.body.read
+      end
+
+      def events
+        client.parse_events_from(body)
+      end
+    end
+  end
+end

data/lib/pleiades/core/client/wrapper.rb

@@ -0,0 +1,55 @@
+module Pleiades
+  module Client
+    class Wrapper
+      attr_reader :histories
+
+      def initialize(client)
+        @obj = client
+        @histories = []
+      end
+
+      private
+
+      def method_missing(method, *args, &block)
+        return super unless @obj.respond_to?(method)
+
+        execute(method, *args)
+      end
+
+      def respond_to_missing?(method, *_, &_)
+        @obj.respond_to?(method) || super
+      end
+
+      def respond_to?(method)
+        @obj.respond_to?(method) || super
+      end
+
+      def execute(method, *args)
+        res = @obj.__send__ method, *args
+        code = res.code
+        body = JSON.parse(res.body)
+
+        @histories << response.new(method, code, body)
+
+        [code, body]
+      end
+
+      def method_assigns(method, *args)
+        return {} if args.empty?
+
+        @obj.method(method)
+            .parameters
+            .map(&:last)
+            .each_with_index
+            .each_with_object({}) do |(arg_name, at), hash|
+              hash.store(arg_name, args[at])
+            end
+      end
+
+      def response
+        attributes = %i[method_name code body]
+        Struct.new(*attributes)
+      end
+    end
+  end
+end

data/lib/pleiades/core/command.rb

@@ -1,18 +1,22 @@
-require 'pleiades/core/command/router'
 require 'pleiades/core/command/base_command'
+require 'pleiades/core/command/executor'
+require 'pleiades/core/command/factory'
+require 'pleiades/core/command/router'
+require 'pleiades/core/command/routing_proxy'
 require 'pleiades/core/config'
 
 module Pleiades
   module Command
     class << self
-      def get event
-        path = Pleiades::Command::Router.find_route event
+      def get(event)
+        event = Pleiades::Util.define_reader(event).freeze
 
-        command_cst = path.split('/')
-                          .map(&:camelize)
-                          .join('::')
+        RoutingProxy.collect_router_file(event).each do |path|
+          Router.find_route(event, path)
+          break if Router.path_found?
+        end
 
-        command_cst.constantize.new(event)
+        Factory.production(event, Router.path_info)
       end
     end
   end

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

@@ -1,26 +1,11 @@
 module Pleiades
   module Command
     class BaseCommand
-      def initialize event
+      def initialize(event)
         @event = event
-        @success = nil
       end
 
       def call; end
-
-      def success?
-        @success
-      end
-
-      protected
-
-      def success!
-        @success = true
-      end
-
-      def fail!
-        @success = false
-      end
     end
   end
 end

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

@@ -0,0 +1,16 @@
+module Pleiades
+  module Command
+    class Executor
+      def initialize(command, method)
+        @to = command
+        @method = method
+      end
+
+      def execute
+        @to.__send__ @method
+        @to
+      end
+      alias :call execute
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+require 'pleiades/core/command/executor'
+
+module Pleiades
+  module Command
+    class Factory
+      def self.production(event, path_info)
+        @factory = new(event, path_info)
+        @factory.operate
+      end
+
+      def initialize(event, path_info)
+        @event = event
+        @path_info = path_info
+      end
+
+      def operate
+        executor_class(decorate_command(command_class))
+      end
+
+      private
+
+      def command_class
+        klass_path = @path_info[:command_path] || Pleiades::Config.command.default
+
+        command_constantize(klass_path).new(@event)
+      end
+
+      def command_constantize(path)
+        path.split('/').map(&:camelize).join('::').constantize
+      end
+
+      def executor_class(command)
+        @path_info[:executor].constantize.new(
+          command,
+          @path_info[:call_method]
+        )
+      end
+
+      def decorate_command(command)
+        concerns = @path_info[:concern].map(&:constantize)
+        command.class_eval do
+          concerns.each do |concern|
+            include concern
+          end
+        end
+        command
+      end
+    end
+  end
+end

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

@@ -1,36 +1,51 @@
 require 'pleiades/core/constants'
 require 'pleiades/core/config'
-require 'pleiades/core/command/nest_blocks'
-require 'pleiades/core/command/event_proccessor'
+require 'pleiades/core/command/routing/event_proccessor'
+require 'pleiades/core/command/routing/nest_blocks'
+require 'pleiades/core/command/routing/path_builder'
+require 'pleiades/core/command/routing/reflection'
+require 'pleiades/core/command/routing/result'
+require 'pleiades/core/command/routing/validator'
 
 module Pleiades
   module Command
     class Router
-      prepend Pleiades::Command::NestBlocks
-      prepend Pleiades::Command::EventProccessor
+      prepend Pleiades::Command::Routing::EventProccessor
+      prepend Pleiades::Command::Routing::NestBlocks
+      prepend Pleiades::Command::Routing::PathBuilder
+      prepend Pleiades::Command::Routing::Reflection
+      prepend Pleiades::Command::Routing::Validator
 
       class << self
-        attr_accessor :path
         attr_reader :event
+        attr_writer :path_info
 
-        def find_route(event)
+        def find_route(event, router_path)
           @event = event
-          @path = nil
+          @path_info = nil
 
-          load Pleiades::Constants::File::ROUTER
-
-          Router.path_found? ? Router.path : 'base_command'
+          load router_path
         end
 
         def route(&block)
           new.instance_eval(&block) if block_given?
         end
 
+        def path_info
+          @path_info || default_path_info
+        end
+
+        def default_path_info
+          new.instance_eval { Pleiades::Command::Routing::Result.create(@options) }
+        end
+
         def path_found?
-          @path ? true : false
+          !!@path_info
         end
       end
 
+      attr_reader :options
+
       def initialize(options = nil)
         @event = Router.event
         @options = options || default_options
@@ -38,22 +53,8 @@ module Pleiades
 
       private
 
-      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
-
-      def talk_type(*callable_types, &block)
-        instance_eval(&block) if callable_type?(callable_types)
-      end
-
-      def callable_type?(types)
-        types.map(&:to_s).include?(@event.source.type)
+      def nest(new_option, &block)
+        self.class.new(new_option).instance_eval(&block)
       end
     end
   end

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

@@ -0,0 +1,51 @@
+module Pleiades
+  module Command
+    module Routing
+      module EventJudgeMethods
+        private
+
+        def judge_method_defined?(method_name)
+          Pleiades::Command::Routing::EventJudgeMethods
+            .private_instance_methods(false)
+            .include?(judge_method(method_name))
+        end
+
+        def judge_method(event)
+          :"judge_#{event}"
+        end
+
+        def judge_text(args)
+          pattern =
+            case args[:pattern]
+            when Regexp
+              args[:pattern]
+            when String
+              /^#{args[:pattern]}$/
+            end
+
+          pattern =~ @event.text
+        end
+
+        def judge_sticker(args)
+          p_id, s_id = @event.sticker_ids
+          convert_to_reg(args[:package_id]) =~ p_id &&
+            convert_to_reg(args[:sticker_id]) =~ s_id
+        end
+
+        def convert_to_reg(id)
+          case id
+          when String, Integer
+            return '*'.eql?(id) ? /^\d+$/ : /^#{id}$/
+          when Array
+            return /^#{id.join('|')}$/
+          end
+          id
+        end
+
+        def judge_postback(args)
+          normalize_path(args[:scope], args[:action]) == @event.action
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,122 @@
+require 'pleiades/core/command/routing/event_judge_methods'
+
+module Pleiades
+  module Command
+    module Routing
+      module EventProccessor
+        extend ActiveSupport::Concern
+        prepend Pleiades::Command::Routing::EventJudgeMethods
+
+        # match 複数のイベントメソッドを実行する。
+        #
+        # EXAMPLE(以下のmatchなし、matchありは同義)
+        #
+        # ## matchなし
+        # scope 'line' do
+        #   action :greet do
+        #     text pattern: 'Hello, world'
+        #     sticker package_id: '1', sticker_id: '1'
+        #   end
+        # end
+        #
+        # ## matchあり
+        # match(
+        #   via: {
+        #     text: {
+        #       pattern: 'Hello, world'
+        #     },
+        #     sticker: {
+        #       package_id: '1',
+        #       sticker_id: '1'
+        #     }
+        #   },
+        #   scope: 'line',
+        #   action: :greet
+        # )
+        #
+        def match(**args)
+          validate_match_keywords(args)
+
+          args.delete(:via).each_pair do |event, val|
+            __send__ event, merge_from_match(val, args)
+          end
+        end
+
+        # イベントクラス名をリフレクションして、イベントメソッドを実行する。
+        #
+        # EXAMPLE
+        # ## 使用しない
+        # text pattern: 'Hello'
+        #
+        # ## 使用する
+        # p __event_name__ # => "text"
+        # event pattern: 'Hello'
+        #
+        def event(**keywords)
+          __send__ __event_name__.to_sym, keywords
+        end
+
+        private
+
+        def method_missing(method, *args, &block)
+          return super unless event_types.include?(method.to_s)
+
+          exe_event_method(args.inject(&:merge).merge(type: method))
+        end
+
+        def respond_to_missing?(method, *args, &block)
+          event_types.include?(method.to_s) || super
+        end
+
+        def exe_event_method(args)
+          on_execute = validate_event_keywords(args) && event_executable?(args)
+          return unless on_execute
+
+          method_name = args[:type]
+
+          if judge_method_defined?(method_name)
+            return unless method(judge_method(method_name)).call(args)
+          end
+
+          route_fix!(args)
+        end
+
+        def event_executable?(args)
+          exe_conditions = [route_unfixid?, matching_events?(args[:type])]
+
+          exe_conditions << callable_talk_type?([args[:talk_type]]) if args.key?(:talk_type)
+
+          exe_conditions.all?
+        end
+
+        def merge_from_match(via, arg)
+          arg.merge(via) do |key, a_val, v_val|
+            case key
+            when :scope, :concern
+              [a_val, v_val].flatten
+            else
+              v_val
+            end
+          end
+        end
+
+        def event_types
+          Pleiades::Constants::Events::TYPES
+        end
+
+        def route_unfixid?
+          !Router.path_found?
+        end
+
+        def matching_events?(method_name)
+          __event_name__ == method_name.to_s
+        end
+
+        def route_fix!(args)
+          Pleiades::Command::Router.path_info =
+            Pleiades::Command::Routing::Result.create(@options, args)
+        end
+      end
+    end
+  end
+end