flumtter 5.0.1

data/lib/flumtter/app/core/command.rb

@@ -0,0 +1,24 @@
+module Flumtter
+  class Command
+    attr_reader :name, :command, :help
+    def initialize(command, help="", &blk)
+      @name = command.is_a?(Regexp) ? command.inspect : command
+      @command = command.is_a?(String) ? command.to_reg : command
+      @help = help
+      @blk = blk
+    end
+
+    def call(*args)
+      @blk.call(*args)
+    end
+
+    def self.list(commands)
+      char_len = commands.max_by{|c|c.name.size}.name.size + 1 rescue 0
+      commands.map do |c|
+        c.name.ljust(char_len) + c.help
+      end.join("\n")
+    end
+  end
+
+  sarastire "core/command"
+end

data/lib/flumtter/app/core/command/dm.rb

@@ -0,0 +1,12 @@
+module Flumtter
+  module Command::DM
+    def add_command(twitter)
+      command("r", "Reply") do |m|
+        error_handler do
+          obj, m2 = parse_index(m[1])
+          twitter.rest.create_direct_message(obj.sender.id, m2)
+        end
+      end
+    end
+  end
+end

data/lib/flumtter/app/core/command/tweet.rb

@@ -0,0 +1,24 @@
+module Flumtter
+  module Command::Tweet
+    def add_command(twitter)
+      command("f", "Favorite") do |m|
+        error_handler do
+          obj, _ = parse_index(m[1])
+          Plugins::Favorite.favorite(obj, twitter)
+        end
+      end
+      command("t", "Retweet") do |m|
+        error_handler do
+          obj, _ = parse_index(m[1])
+          Plugins::Retweet.retweet(obj, twitter)
+        end
+      end
+      command("r", "Reply") do |m|
+        error_handler do
+          obj, m2 = parse_index(m[1])
+          Plugins::Reply.update(obj, m2, twitter)
+        end
+      end
+    end
+  end
+end

data/lib/flumtter/app/core/command/user.rb

@@ -0,0 +1,52 @@
+module Flumtter
+  module Command::User
+    include Util
+
+    def add_command(user, twitter)
+      command("tweet", "Tweet List") do
+        error_handler do
+          Window::Tweet.new(user, twitter).show
+        end
+      end
+      command("follower", "Follower List") do
+        error_handler do
+          Window::Follower.new(user, twitter).show
+        end
+      end
+      command("following", "Following List") do
+        error_handler do
+          Window::Following.new(user, twitter).show
+        end
+      end
+      command("favorite", "Favorite List") do
+        error_handler do
+          Window::Favorite.new(user, twitter).show
+        end
+      end
+      command("follow", "Follow") do
+        error_handler do
+          twitter.rest.follow(user.screen_name)
+          Window::Popup::Success.new("follow success").show
+        end
+      end
+      command("unfollow", "Unfollow") do
+        error_handler do
+          twitter.rest.unfollow(user.screen_name)
+          Window::Popup::Success.new("unfollow success").show
+        end
+      end
+      command("block", "Block") do
+        error_handler do
+          twitter.rest.block(user.screen_name)
+          Window::Popup::Success.new("block success").show
+        end
+      end
+      command("unblock", "UnBlock") do
+        error_handler do
+          twitter.rest.unblock(user.screen_name)
+          Window::Popup::Success.new("unblock success").show
+        end
+      end
+    end
+  end
+end

data/lib/flumtter/app/core/command/userlist.rb

@@ -0,0 +1,8 @@
+module Flumtter
+  module Command::UserList
+    include Util
+
+    def add_command(twitter)
+    end
+  end
+end

data/lib/flumtter/app/core/core.rb

@@ -0,0 +1,58 @@
+require 'pry'
+
+module Flumtter
+  SourcePath = File.expand_path('../../', __FILE__)
+  UserPath = File.expand_path('~/.flumtter')
+  [SourcePath, UserPath].each do |path|
+    def path.join(*args)
+      File.join(self, *args)
+    end
+  end
+  FileUtils.mkdir(UserPath) unless FileTest.exist?(UserPath)
+
+  data_path = UserPath.join("data", "data.bin")
+  Config = Marshal.load(File.read(data_path)) rescue {}
+  at_exit {
+    puts 'data saved'
+    File.write(data_path, Marshal.dump(Config))
+  }
+
+  Thread.abort_on_exception = true
+
+  module_function
+  def sarastire(path, file=nil)
+    path = file.nil? ? SourcePath.join(path, '*.rb') : SourcePath.join(path, file)
+    Dir.glob(path).each{|plugin|require plugin}
+  end
+
+  def sarastire_user(path, file=nil)
+    path = file.nil? ? UserPath.join(path, '*.rb') : UserPath.join(path, file)
+    Dir.glob(path).each{|plugin|require plugin}
+  end
+
+  @events = Hash.new{|h,k|h[k] = []}
+  def on_event(event,&blk)
+    @events[event] << blk
+  end
+
+  def callback(event,object=nil)
+    @events[event].each{|blk|blk.call(object)}
+  end
+
+  TITLE = "Flumtter"
+
+  sarastire 'core', 'util.rb'
+  sarastire_user 'setting'
+  sarastire 'core'
+  sarastire 'plugins'
+  sarastire_user 'plugins'
+
+  TITLE.terminal_title
+
+  def start
+    options = Initializer.optparse
+    Setting.merge!(options)
+    Client.new AccountSelector.select(options)
+  rescue Interrupt
+  end
+end

data/lib/flumtter/app/core/curses.rb

@@ -0,0 +1,90 @@
+require 'dispel'
+module Dispel
+  class CloseWindow < StandardError; end
+  class NoCommandError < StandardError; end
+  class Recall < StandardError; end
+
+  class Window
+    class << self
+      def open(*args)
+        win = Curses::Window.new(*args)
+        win.keypad(true)
+        yield win
+      rescue CloseWindow
+      ensure
+        win.refresh
+        win.close
+      end
+
+      def close
+        raise CloseWindow
+      end
+    end
+  end
+
+  module Util
+    def addstr(win, str)
+      win.setpos(win.cury+1, 1)
+      win.addstr str
+    end
+
+    def add_multiline_str(win, str)
+      str.each_line do |line|
+        addstr(win, line.chomp)
+      end
+    end
+
+    def getstr(win, ex=[])
+      buf = ""
+      x = win.curx
+      loop do
+        input = Dispel::Keyboard.translate_key_to_code(win.getch)
+        ex.each do |k|
+          return input if input == k
+        end
+
+        case input
+        when :"Ctrl+c"
+          raise CloseWindow
+        when :enter
+          return buf
+        when :escape
+          raise CloseWindow
+        when :left
+          if win.curx > x
+            win.setpos(win.cury, win.curx-1)
+          end
+        when :right
+          if win.curx <= buf.size
+            win.setpos(win.cury, win.curx+1)
+          end
+          # TODO: 文字移動して削除入力
+        when :backspace
+          buf.chop!
+          while win.curx > x
+            win.setpos(win.cury, win.curx-1)
+            win.delch()
+            win.insch(" ")
+          end
+          win.addstr(buf)
+        when String
+          buf << input.force_encoding("utf-8")
+          win.setpos(win.cury, win.curx)
+          win.addstr(input)
+        else
+          p input
+        end
+      end
+    rescue NoMethodError => e
+      if e.backtrace.shift =~ /keyboard.rb:210/
+        raise Dispel::Recall
+      else
+        raise e
+      end
+    end
+  end
+end
+
+module Flumtter
+  sarastire 'core/windows'
+end

data/lib/flumtter/app/core/hash.rb

@@ -0,0 +1,29 @@
+class Hash
+  def requires(*args)
+    args.each do |arg|
+      raise ArgumentError, "Parameter is missing a value(#{arg})" if self[arg].nil?
+    end
+  end
+
+  def nest_level(level=0)
+    self.map do |k,v|
+      if v.is_a?(Hash)
+        v.nest_level(level+1)
+      else
+        level+1
+      end
+    end.max
+  end
+
+  def indent(t=0, n=2)
+    self.map do |k,v|
+      if self.nest_level == 1 || !v.is_a?(Hash)
+        between = ": "
+        char_len = self.keys.max_by{|key|key.size}.size + (n * t)
+        k.to_s.shift(t*n).ljust(char_len) + ": " + v.to_s.nshift(char_len + between.size)
+      else
+        [k.to_s.shift(t*n), *v.is_a?(Hash) ? v.indent(t+1, n) : [v.to_s.shift(n*2)]].join("\n")
+      end
+    end.join("\n")
+  end
+end

data/lib/flumtter/app/core/initializer.rb

@@ -0,0 +1,28 @@
+require 'optparse'
+
+module Initializer
+  @args, @events = [], {}
+
+  module_function
+  def add_opt(&blk)
+    @args << blk
+  end
+
+  def run(sym, &blk)
+    @events[sym] = blk
+  end
+
+  def optparse
+    opt = OptionParser.new
+    options = {}
+    opt.on('-n VALUE', '--name VALUE', 'account name'){|v|options[:name] = v}
+    opt.on('-i VALUE', '--index VALUE', 'account index'){|v|options[:id] = v.to_i}
+    opt.on('-s', '--non_stream', 'without stream'){|v|options[:non_stream] = v}
+    opt.on('-d', '--debug', 'debug mode'){|v|options[:debug] = v}
+    opt.on('--args VALUE'){|v|options[:args] = v}
+    @args.each{|args|args.call(opt, options)}
+    opt.parse!(ARGV)
+    options.each{|k,v|@events[k].call(v,options) unless @events[k].nil?}
+    options
+  end
+end

data/lib/flumtter/app/core/keyboard.rb

@@ -0,0 +1,54 @@
+require 'io/console'
+
+module Flumtter
+  class Keyboard
+    extend Util
+
+    class << self
+      @@commands = []
+
+      def input(twitter)
+        loop do
+          input = STDIN.noecho(&:gets)
+          next if input.nil?
+          twitter.pause
+          callback(input.chomp, twitter)
+          twitter.resume
+        end
+      rescue Interrupt
+      end
+
+      def callback(input, twitter)
+        if input == "?"
+          Window::Popup.new("Command List", <<~EOF).show
+            #{Command.list(@@commands)}
+
+            For more information, please see the following Home page.
+            http://github.com/flum1025/flumtter3
+            This software is released under the MIT License
+            Copyright © @flum_ 2016
+          EOF
+        else
+          @@commands.each do |command|
+            if m = input.match(command.command)
+              return command.call(m, twitter)
+            end
+          end
+          puts "Command not found".color
+        end
+      end
+
+      def add(command, help, &blk)
+        @@commands << Command.new(command, help) do |*args|
+          begin
+            blk.call(*args)
+          rescue SystemExit => e
+            raise e
+          rescue Exception => e
+            error e
+          end
+        end
+      end
+    end
+  end
+end

data/lib/flumtter/app/core/plugins.rb

@@ -0,0 +1,27 @@
+require_relative 'Initializer'
+
+module Flumtter
+  module Plugins
+    module Base
+      def add_opt(&blk)
+        Initializer.add_opt(&blk)
+      end
+
+      def run_opt(*args, &blk)
+        Initializer.run(*args, &blk)
+      end
+    end
+
+    module_function
+    def plugin(blk)
+      m = self.const_set(File.basename(blk.source_location[0], '.rb').to_camel.to_sym, Module.new)
+      m.extend(Base)
+      m.extend(Util)
+      m.instance_eval(&blk)
+    end
+  end
+end
+
+def plugin(&blk)
+  Flumtter::Plugins.plugin(blk)
+end

data/lib/flumtter/app/core/string.rb

@@ -0,0 +1,148 @@
+class String
+  def to_camel
+    self.split(/_/).map(&:capitalize).join
+  end
+
+  def terminal_title
+    print "\033];#{self}\007"
+    at_exit{print "\033];\007"}
+  end
+
+  def title
+    "【#{self}】"
+  end
+
+  def color(color=:red)
+    case color
+    when :white       then "\e[1;37m#{self}\e[0m"
+    when :light_gray  then "\e[37m#{self}\e[0m"
+    when :gray        then "\e[1;30m#{self}\e[0m"
+    when :back        then "\e[30m#{self}\e[0m"
+    when :red         then "\e[31m#{self}\e[0m"
+    when :light_red   then "\e[1;31m#{self}\e[0m"
+    when :green       then "\e[32m#{self}\e[0m"
+    when :light_green then "\e[1;32m#{self}\e[0m"
+    when :brown       then "\e[33m#{self}\e[0m"
+    when :yellow      then "\e[1;33m#{self}\e[0m"
+    when :blue        then "\e[34m#{self}\e[0m"
+    when :light_blue  then "\e[1;34m#{self}\e[0m"
+    when :purple      then "\e[35m#{self}\e[0m"
+    when :pink        then "\e[1;35m#{self}\e[0m"
+    when :cyan        then "\e[36m#{self}\e[0m"
+    when :light_cyan  then "\e[1;36m#{self}\e[0m"
+    end
+  end
+
+  def background_color(color=:red)
+    case color
+    when :black
+      "\e[40m#{self}\e[0m"
+    when :red
+      "\e[41m#{self}\e[0m"
+    when :green
+      "\e[42m#{self}\e[0m"
+    when :yellow
+      "\e[43m#{self}\e[0m"
+    when :blue
+      "\e[44m#{self}\e[0m"
+    when :magenta
+      "\e[45m#{self}\e[0m"
+    when :cyan
+      "\e[46m#{self}\e[0m"
+    when :white
+      "\e[47m#{self}\e[0m"
+    end
+  end
+
+  def exact_size
+    self.each_char.map{|c| c.bytesize == 1 ? 1 : 2}.reduce(0, &:+)
+  end
+
+  def nl(i=1)
+    self + "\n"*i
+  end
+
+  def dnl
+    "\n#{self}\n"
+  end
+
+  def has_mb?
+    self.bytes do |b|
+      return true if  (b & 0b10000000) != 0
+    end
+    false
+  end
+
+  alias_method :_ljust, :ljust
+  def ljust(length, padstr=nil, rstr="")
+    length -= (exact_size - 1) if has_mb?
+    length -= rstr.exact_size
+    text = padstr.nil? ? _ljust(length) : _ljust(length, padstr)
+    text << rstr
+  end
+
+  def to_em
+    self.tr('0-9a-zA-Z', '０-９ａ-ｚＡ-Ｚ')
+  end
+
+  def to_en
+    self.tr('０-９ａ-ｚＡ-Ｚ', '0-9a-zA-Z')
+  end
+
+  def to_reg
+    reg = Regexp.union(self, self.to_em)
+    /^#{Regexp.new(reg.source, Regexp::IGNORECASE)}[ |　]*(.*)/
+  end
+
+  def shift(n=2)
+    self.each_line.map do |line|
+      " "*n + line.chomp
+    end.join("\n")
+  end
+
+  def nshift(n=2)
+    self.each_line.map.with_index do |line, i|
+      if i.zero?
+        line.chomp
+      else
+        " "*n + line.chomp
+      end
+    end.join("\n")
+  end
+
+  def split_num(n)
+    text = []
+    tmp = ""
+    self.each_char.each do |char|
+      if tmp.exact_size < n
+        tmp << char
+      else
+        text << tmp
+        tmp = char
+      end
+    end
+    text << tmp
+    text.join("\n")
+  end
+
+  def range?(max)
+    unless 1 <= self.size && self.size <= max
+      raise RangeError
+    end
+  end
+
+  def size_of_lines
+    self.each_line.to_a.size
+  end
+
+  def max_char_of_lines
+    max = self.each_line.max_by{|str|str.size}
+    max.nil? ? 0 : max.size
+  end
+end
+
+if $0 == __FILE__
+  %i(white light_gray gray black red light_red green light_green brown yellow blue light_blue purple pink cyan light_cyan).each do |c|
+    puts "#{c}".color(c)
+  end
+end