mobb 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 75d6f6e3f306dcd58cd2bcf5f715d860448c90db93f792e500dbd7b8805ae24b
+  data.tar.gz: 5ab8a6f5af4bfb8e9ea8ea7176c61f7cadcc0b6ceb43766fc0ae78b53f31db0b
+SHA512:
+  metadata.gz: 4881e20aee0c8f698b7e1486f26b7902eff6d945d3ee84d8909ed6e9e532e236093f85abc62dea09807087d2aeaaab70eb22fbfa24d872d016d87fe2bace3475
+  data.tar.gz: '09e34fa992c82bb08f10468fbd8fdd3fab272344c1bf899384727e10a95504dd77be77d19267d8f3d973e576a2f1b2c6641b8df0561f72ffb68ebf937e91a78a'

data/.gitignore

@@ -0,0 +1,10 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+Gemfile.lock

data/Gemfile

@@ -0,0 +1,3 @@
+source "https://rubygems.org"
+gemspec
+

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 kinoppyd
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,71 @@
+# Mobb
+
+Mobb is the simplest, most lightweight, fastest Bot framework written by Ruby.
+
+# Install
+
+you can install Mobb by rubygems like
+
+```
+gem isntall mobb
+```
+
+or you can use a bundler. Writes the following in Gemfile
+
+```
+source "https://rubygems.org"
+
+gem "mobb", "~> 0.1"
+```
+
+and install
+
+```
+bundle install
+```
+
+# Examples
+
+Write your logic in `app.rb` like...
+
+```ruby
+require 'mobb'
+
+set :name, "example bot"
+'
+on "hello" do
+  "hi! i'm #{settings.name}!"
+end
+```
+
+and start mobb application
+
+```
+ruby app.rb
+```
+
+then the shell will start to wait for your input, so you can type 'hello' and hit enter, then you get.
+
+```
+hi! i'm example bot!"
+```
+
+# Service handlers
+
+Mobb is implemented based on [Repp](https://github.com/kinoppyd/repp) Interface.
+Shell and Slack adapter is currently available.
+
+```ruby
+require 'mobb'
+set :serice, 'slack'
+
+on /hey (\w+)/ do |someone|
+  "hey #{someone}, waz up?"
+end
+```
+
+# TODO
+
++ Test, Test, Test
++ Documents
++ Parallel event handling

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/*_test.rb"]
+end
+
+task :default => :test

data/examples/slack_bot.rb

@@ -0,0 +1,23 @@
+require 'mobb'
+
+set :service, 'slack'
+set :name, "example bot"
+
+on "hello" do
+  "Hi! I'm #{settings.name}"
+end
+
+# Warning this is bad implementation
+# inifinity loop happend
+receive "Yo", laziness: true do
+  "Yo"
+end
+
+receive /hey (\w+)/ do |someone|
+  "hey #{someone}, waz up?"
+end
+
+# This function is not implements yet
+#every 1.day, at: '15:30', exclude: :holiday do
+#  'Stund up daily meeting time!'
+#end

data/lib/mobb.rb

@@ -0,0 +1 @@
+require "mobb/main"

data/lib/mobb/base.rb

@@ -0,0 +1,354 @@
+require 'repp'
+require "mobb/version"
+
+module Mobb
+  class Matcher
+    def initialize(pattern, options) @pattern, @options = pattern, options; end
+    def regexp?; pattern.is_a?(Regexp); end
+    def inspect; "pattern: #{@pattern}, options #{@options}"; end
+    def invoke(time = Time.now) @options[:last_invoked] = time; end
+
+    def match?(context)
+      case context
+      when String
+        string_matcher(context)
+      when Time
+        # TODO: do something
+        false
+      when Array
+        context.all? { |c| match?(c) }
+      else
+        false
+      end
+    end
+
+    class Matched
+      attr_reader :pattern, :matched
+      def initialize(pattern, matched) @pattern, @matched = pattern, matched; end
+    end
+
+    def pattern; @pattern; end
+
+    def string_matcher(string)
+      case pattern
+      when Regexp
+        if res = pattern.match(string)
+          Matched.new(pattern, res.captures)
+        else
+          false
+        end
+      when String
+        @options[:laziness] ? string.include?(pattern) : string == pattern
+      else
+        false
+      end
+    end
+  end
+
+  class Base
+    def call(env)
+      dup.call!(env)
+    end
+
+    def tick(env)
+      dup.tick!(env)
+    end
+
+    def call!(env)
+      @env = env
+      invoke { dispatch! }
+      [@body, @attachments]
+    end
+
+    def tick!(env)
+      fail # TODO: write logic here
+    end
+
+    def dispatch!
+      # TODO: encode input messages
+
+      invoke do
+        # TODO: before filters
+        handle_event
+      end
+    ensure
+      # TODO: after fillters
+    end
+
+    def invoke
+      res = catch(:halt) { yield }
+      return if res.nil?
+      
+      res = [res] if String === res
+      if Array === res && String === res.first
+        tmp = res.dup
+        @body = tmp.shift
+        @attachments = tmp.pop
+      else
+        @attachments = res
+      end
+      nil
+    end
+
+    def handle_event(base = settings, passed_block = nil)
+      if responds = base.events[@env.event_type]
+        responds.each do |pattern, block|
+          process_event(pattern) do |*args|
+            event_eval { block[*args] }
+          end
+        end
+      end
+
+      # TODO: Define respond missing if receive reply message
+      nil
+    end
+
+    def process_event(pattern, block = nil, values = [])
+      res = pattern.match?(@env.body)
+      case res
+      when ::Mobb::Matcher::Matched
+        yield(self, *(res.matched))
+      when TrueClass
+        yield self
+      else
+        nil
+      end
+    end
+
+    def event_eval; throw :halt, yield; end
+
+    def settings
+      self.class.settings
+    end
+
+    class << self
+      CALLERS_TO_IGNORE = [
+        /\/mobb(\/(base|main|show_exceptions))?\.rb$/,   # all sinatra code
+        /^\(.*\)$/,                                         # generated code
+        /rubygems\/(custom|core_ext\/kernel)_require\.rb$/, # rubygems require hacks
+        /active_support/,                                   # active_support require hacks
+        /bundler(\/runtime)?\.rb/,                          # bundler require hacks
+        /<internal:/,                                       # internal in ruby >= 1.9.2
+        /src\/kernel\/bootstrap\/[A-Z]/                     # maglev kernel files
+      ]
+
+      attr_reader :events
+
+      def reset!
+        @events = {}
+      end
+
+      def settings
+        self
+      end
+
+      def receive(pattern, options = {}, &block) event(:message, pattern, options, &block); end
+      alias :on :receive
+
+      #def every(pattern, options = {}, &block) event(:cron, pattern, options, &block); end
+
+      def event(type, pattern, options, &block)
+        (@events[type] ||= []) << compile!(type, pattern, options, &block)
+      end
+
+      def compile!(type, pattern, option, &block)
+        matcher = compile(pattern, option)
+        unbound_method = generate_method("#{type}", &block)
+        wrapper = block.arity != 0 ?
+          proc { |instance, args| unbound_method.bind(instance).call(*args) } :
+          proc { |instance, args| unbound_method.bind(instance).call }
+        [matcher, wrapper]
+      end
+
+      def compile(pattern, options) Matcher.new(pattern, options); end
+
+      def generate_method(name, &block)
+        define_method(name, &block)
+        method = instance_method(name)
+        remove_method(name)
+        method
+      end
+
+      def development?; environment == :development; end
+      def production?; environment == :production; end
+      def test?; environment == :test; end
+
+      def set(option, value = (not_set = true), ignore_setter = false, &block)
+        raise ArgumentError if block && !not_set
+        value, not_set = block, false if block
+
+        if not_set
+          raise ArgumentError unless option.respond_to?(:each)
+          option.each { |k,v| set(k,v) }
+          return self
+        end
+
+        setter_name = "#{option}="
+        if respond_to?(setter_name) && ! ignore_setter
+          return __send__(setter_name, value)
+        end
+
+        setter = proc { |val| set(option, val, true) }
+        getter = proc { value }
+
+        case value
+        when Proc
+          getter = value
+        when Symbol, Integer, FalseClass, TrueClass, NilClass
+          getter = value.inspect
+        when Hash
+          setter = proc do |val|
+            val = value.merge(val) if Hash === val
+            set(option, val, true)
+          end
+        end
+
+        define_singleton(setter_name, setter)
+        define_singleton(option, getter)
+        define_singleton("#{option}?", "!!#{option}") unless method_defined?("#{option}?")
+        self
+      end
+
+      def enable(*options) options.each { |option| set(option, true) }; end
+      def disable(*options) options.each { |option| set(option, false) }; end
+      def clear(*options) options.each { |option| set(option, nil) }; end
+
+      def run!(options = {}, &block)
+        return if running?
+
+        set options
+        handler = detect_repp_handler
+        handler_name = handler.name.gsub(/.*::/, '')
+        service_settings = settings.respond_to?(:service_settings) ? settings.service_settings : {}
+        
+        begin
+          start_service(handler, service_settings, handler_name, &block)
+        rescue => e
+          $stderr.puts e.message
+          $stderr.puts e.backtrace
+        ensure
+          quit!
+        end
+      end
+
+      def quit!
+        return unless running?
+        running_service.respond_to?(:stop!) ? running_service.stop! : running_service.stop
+        $stderr.puts "== Great sound Mobb, thank you so much"
+        clear :running_service, :handler_name
+      end
+
+      def running?
+        running_service?
+      end
+
+      private
+
+      def start_service(handler, service_settings, handler_name)
+        handler.run(self, service_settings) do |service|
+          $stderr.puts "== Mobb (v#{Mobb::VERSION}) is in da house with #{handler_name}. Make some noise!"
+
+          setup_traps
+          set running_service: service
+          set handler_name: handler_name
+
+          yield service if block_given?
+        end
+      end
+
+      def setup_traps
+        if traps?
+          at_exit { quit! }
+
+          [:INT, :TERM].each do |signal|
+            old_handler = Signal.trap(signal) do
+              quit!
+              old_handler.respond_to?(:call) ?  old_handler.call : exit
+            end
+          end
+
+          disable :traps
+        end
+      end
+
+      def detect_repp_handler
+        services = Array(service)
+        services.each do |service_name|
+          begin
+            return Repp::Handler.get(service_name.to_s)
+          rescue LoadError, NameError
+          end
+        end
+        fail "Service handler (#{services.join(',')}) not found"
+      end
+
+      def define_singleton(name, content = Proc.new)
+        singleton_class.class_eval do
+          undef_method(name) if method_defined?(name)
+          String === content ? class_eval("def #{name}() #{content}; end") : define_method(name, &content)
+        end
+      end
+
+      def caller_files
+        cleaned_caller(1).flatten
+      end
+
+      def cleaned_caller(keep = 3)
+        caller(1).
+          map!    { |line| line.split(/:(?=\d|in )/, 3)[0,keep] }.
+          reject { |file, *_| CALLERS_TO_IGNORE.any? { |pattern| file =~ pattern } }
+      end
+
+      def inherited(subclass)
+        subclass.reset!
+        subclass.set :app_file, caller_files.first unless subclass.app_file?
+        super
+      end
+    end
+
+    reset!
+
+    set :name, 'mobb'
+    set :environment, (ENV['APP_ENV'] || ENV['REPP_ENV'] || :development).to_sym
+
+    disable :run, :quiet
+    clear :running_service, :handler_name
+    enable :traps
+    set :service, %w[shell]
+
+    clear :app_file
+  end
+
+  class Application < Base
+    set :logging, Proc.new { !test? }
+    set :run, Proc.new { !test? }
+    clear :app_file
+
+    def self.register(*extensions, &block)
+      added_methods = extensions.flat_map(&:public_instance_methods)
+      Delegator.delegate(*added_methods)
+      super(*extensions, &block)
+    end
+  end
+
+  module Delegator #:nodoc:
+    def self.delegate(*methods)
+      methods.each do |method_name|
+        define_method(method_name) do |*args, &block|
+          return super(*args, &block) if respond_to? method_name
+          Delegator.target.send(method_name, *args, &block)
+        end
+        private method_name
+      end
+    end
+
+    delegate :receive, :on, #:every,
+      :set, :enable, :disable, :clear
+
+    class << self
+      attr_accessor :target
+    end
+
+    self.target = Application
+  end
+end

data/lib/mobb/main.rb

@@ -0,0 +1,17 @@
+require 'mobb/base'
+
+module Mobb
+  class Application < Base
+    set app_file: caller_files.first || $0
+
+    set :run, Proc.new { File.expand_path($0) == File.expand_path(app_file) }
+  end
+
+  at_exit { Application.run! if $!.nil? && Application.run? }
+end
+
+extend Mobb::Delegator
+
+#class Repp::Builder
+#  include Mobb::Delegator
+#end

data/lib/mobb/version.rb

@@ -0,0 +1,3 @@
+module Mobb
+  VERSION = "0.1.0"
+end

data/mobb.gemspec

@@ -0,0 +1,27 @@
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "mobb/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "mobb"
+  spec.version       = Mobb::VERSION
+  spec.authors       = ["kinoppyd"]
+  spec.email         = ["WhoIsDissolvedGirl+github@gmail.com"]
+
+  spec.summary       = %q{Mobb is a lightweight Bot framework like Sinatra}
+  spec.description   = %q{Mobb provides bot DSL}
+  spec.homepage      = "https://github.com/kinoppyd/mobb"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.require_paths = ["lib"]
+
+  #spec.add_dependency "repp", "~> 0.1"
+
+  spec.add_development_dependency "bundler", "~> 1.16"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "minitest", "~> 5.0"
+end

metadata

@@ -0,0 +1,97 @@
+--- !ruby/object:Gem::Specification
+name: mobb
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- kinoppyd
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-06-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+description: Mobb provides bot DSL
+email:
+- WhoIsDissolvedGirl+github@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- examples/slack_bot.rb
+- lib/mobb.rb
+- lib/mobb/base.rb
+- lib/mobb/main.rb
+- lib/mobb/version.rb
+- mobb.gemspec
+homepage: https://github.com/kinoppyd/mobb
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.6
+signing_key: 
+specification_version: 4
+summary: Mobb is a lightweight Bot framework like Sinatra
+test_files: []