twterm 1.3.0 → 2.0.0.beta1

data/lib/twterm/friendship.rb

@@ -9,15 +9,10 @@ module Twterm
 
     attr_reader :status, :from, :to
 
-    @@instances = []
-    @@user_ids = Set.new
-
     def initialize(status, from, to)
-      fail ArgumentError,
-        '' unless STATUSES.include? status
+      fail ArgumentError, '`status` must be one of the following: :blocking, :follwing, :following_requested, or :muting' unless STATUSES.include? status
 
       @status, @from, @to = status, from, to
-      @@instances << self
     end
 
     def blocking?
@@ -36,85 +31,6 @@ module Twterm
       status?(:muting)
     end
 
-    def self.already_looked_up?(user_id)
-      @@user_ids.include?(user_id)
-    end
-
-    def self.block(from, to)
-      new(:blocking, from, to)
-    end
-
-    def self.blocking?(from, to)
-      !find(:blocking, from, to).nil?
-    end
-
-    def self.cancel_follow_request(from, to)
-      new(:following_requested, from, to)
-    end
-
-    def self.delete(status, from, to)
-      cond = -> f { f.status == status && f.from == from && f.to == to }
-      @@instances.delete_if(&cond)
-    end
-    private_class_method :delete
-
-    def self.find(status, from, to)
-      cond = -> f { f.status == status && f.from == from && f.to == to }
-      @@instances.find(&cond)
-    end
-    private_class_method :find
-
-    def self.follow(from, to)
-      new(:following, from, to)
-    end
-
-    def self.following?(from, to)
-      !find(:following, from, to).nil?
-    end
-
-    def self.following_not_requested(from, to)
-      delete(:following_requested, from, to)
-    end
-
-    def self.following_requested(from, to)
-      new(:following_requested, from, to)
-    end
-
-    def self.following_requested?(from, to)
-      !find(:following_requested, from, to).nil?
-    end
-
-    def self.looked_up!(user_id)
-      @@user_ids << user_id
-      user_id
-    end
-
-    def self.mute(from, to)
-      new(:muting, from, to)
-    end
-
-    def self.muting?(from, to)
-      !find(:muting, from, to).nil?
-    end
-
-    def self.new(status, from, to)
-      instance = find(status, from, to)
-      instance.nil? ? super : instance
-    end
-    private_class_method :new
-
-    def self.unblock(from, to)
-      delete(:blocking, from, to)
-    end
-
-    def self.unfollow(from, to)
-      delete(:following, from, to)
-    end
-
-    def self.unmute(from, to)
-      delete(:muting, from, to)
-    end
-
     private
 
     def status?(status)

data/lib/twterm/image/between.rb

@@ -0,0 +1,31 @@
+class Twterm::Image
+  class Between < Twterm::Image
+    def initialize(image, open, close)
+      @image, @open, @close = image, open, close
+    end
+
+    def height
+      1
+    end
+
+    def render(window)
+      open.at(line, column).render(window)
+      image.at(line, column + open.width).render(window)
+      close.at(line, column + open.width + image.width).render(window)
+
+      self
+    end
+
+    def to_s
+      "#{open}#{image}#{close}"
+    end
+
+    def width
+      [open, image, close].map(&:width).reduce(0, :+)
+    end
+
+    private
+
+    attr_reader :open, :close, :image
+  end
+end

data/lib/twterm/image/blank_line.rb

@@ -0,0 +1,21 @@
+module Twterm
+  class Image
+    class BlankLine < Twterm::Image
+      def height
+        1
+      end
+
+      def render(_)
+        self
+      end
+
+      def to_s
+        "\n"
+      end
+
+      def width
+        0
+      end
+    end
+  end
+end

data/lib/twterm/image/bold.rb

@@ -0,0 +1,31 @@
+module Twterm
+  class Image
+    class Bold < Twterm::Image
+      def initialize(image)
+        @image = image
+      end
+
+      def height
+        image.height
+      end
+
+      def render(window)
+        window.attron(Curses::A_BOLD)
+        image.at(line, column).render(window)
+        window.attroff(Curses::A_BOLD)
+      end
+
+      def to_s
+        "\e[1m#{image}\e[0m"
+      end
+
+      def width
+        image.width
+      end
+
+      private
+
+      attr_reader :image
+    end
+  end
+end

data/lib/twterm/image/brackets.rb

@@ -0,0 +1,21 @@
+require 'twterm/image/between'
+
+module Twterm
+  class Image
+    class Brackets < Twterm::Image::Between
+      def initialize(image)
+        super(image, open, close)
+      end
+
+      private
+
+      def open
+        StringImage.new('[')
+      end
+
+      def close
+        StringImage.new(']')
+      end
+    end
+  end
+end

data/lib/twterm/image/color.rb

@@ -0,0 +1,45 @@
+module Twterm
+  class Image
+    class Color < Twterm::Image
+      def initialize(image, fg, bg = :transparent)
+        @image, @fg, @bg = image, fg, bg
+      end
+
+      def height
+        image.height
+      end
+
+      def render(window)
+        window.attron(Curses.color_pair(color_pair_index))
+        image.at(line, column).render(window)
+        window.attroff(Curses.color_pair(color_pair_index))
+      end
+
+      def to_s
+        fg_colors = {
+          black: 30, red: 31, green: 32, yellow: 33,
+          blue: 34, magenta: 35, cyan: 36, white: 37
+        }
+        bg_colors = {
+          black: 40, red: 41, green: 42, yellow: 43,
+          blur: 44, magenta: 45, cyan: 46, white: 47
+        }
+
+        str = "\e[#{fg_colors[@fg]}m#{image}\e[0m"
+        @bg == :transparent ? str : "\e[#{bg_colors[@bg]}m#{str}"
+      end
+
+      def width
+        image.width
+      end
+
+      private
+
+      attr_reader :image
+
+      def color_pair_index
+        Twterm::ColorManager.instance.get_color_pair_index(@fg, @bg)
+      end
+    end
+  end
+end

data/lib/twterm/image/empty.rb

@@ -0,0 +1,21 @@
+module Twterm
+  class Image
+    class Empty < Twterm::Image
+      def height
+        0
+      end
+
+      def render(_)
+        self
+      end
+
+      def to_s
+        ''
+      end
+
+      def width
+        0
+      end
+    end
+  end
+end

data/lib/twterm/image/horizontal_sequential_image.rb

@@ -0,0 +1,48 @@
+module Twterm
+  class Image
+    class HorizontalSequentialImage < Twterm::Image
+      def initialize(images)
+        @images = images
+      end
+
+      def -(other)
+        append(other)
+      end
+
+      def append(image)
+        if image.is_a?(self.class)
+          @images += image.images
+        else
+          images << image
+        end
+
+        self
+      end
+
+      def height
+        images.map(&:height).max
+      end
+
+      def render(window)
+        window.setpos(line, column)
+        images
+          .zip(images.lazy.map(&:width).scan(column, :+))
+          .each { |r, c| r.at(line, c).render(window) }
+
+        self
+      end
+
+      def to_s
+        images.map(&:to_s).join
+      end
+
+      def width
+        images.map(&:width).reduce(0, :+)
+      end
+
+      protected
+
+      attr_reader :images
+    end
+  end
+end

data/lib/twterm/image/parens.rb

@@ -0,0 +1,21 @@
+require 'twterm/image/between'
+
+module Twterm
+  class Image
+    class Parens < Twterm::Image::Between
+      def initialize(image)
+        super(image, open, close)
+      end
+
+      private
+
+      def open
+        StringImage.new('(')
+      end
+
+      def close
+        StringImage.new(')')
+      end
+    end
+  end
+end

data/lib/twterm/image/string_image.rb

@@ -0,0 +1,38 @@
+module Twterm
+  class Image
+    class StringImage < Twterm::Image
+      def initialize(string)
+        @string = string
+      end
+
+      def -(other)
+        if other.is_a?(self.class)
+          self.class.new(string + other.string)
+        else
+          super
+        end
+      end
+
+      def height
+        1
+      end
+
+      def render(window)
+        window.setpos(line, column)
+        window.addstr(string)
+      end
+
+      def to_s
+        @string.dup
+      end
+
+      def width
+        string.width
+      end
+
+      protected
+
+      attr_reader :string
+    end
+  end
+end

data/lib/twterm/image/vertical_sequential_image.rb

@@ -0,0 +1,43 @@
+module Twterm
+  class Image
+    class VerticalSequentialImage < Twterm::Image
+      def initialize(images)
+        @images = images
+      end
+
+      def |(other)
+        append(other)
+      end
+
+      def append(image)
+        images << image
+        self
+      end
+
+      def height
+        images.map(&:height).reduce(0, :+)
+      end
+
+      def render(window)
+        window.setpos(line, column)
+        images
+          .zip(images.lazy.map(&:height).scan(line, :+))
+          .each { |r, l| r.at(l, column).render(window) }
+
+        self
+      end
+
+      def to_s
+        images.map(&:to_s).join("\n")
+      end
+
+      def width
+        images.map(&:width).max
+      end
+
+      protected
+
+      attr_reader :images
+    end
+  end
+end

data/lib/twterm/image.rb

@@ -0,0 +1,107 @@
+require 'twterm/image/between'
+require 'twterm/image/blank_line'
+require 'twterm/image/bold'
+require 'twterm/image/brackets'
+require 'twterm/image/color'
+require 'twterm/image/empty'
+require 'twterm/image/horizontal_sequential_image'
+require 'twterm/image/parens'
+require 'twterm/image/string_image'
+require 'twterm/image/vertical_sequential_image'
+
+class Twterm::Image
+  def initialize(column: 0, line: 0)
+    @column, @line = column, line
+  end
+
+  def !
+    bold
+  end
+
+  def |(other)
+    VerticalSequentialImage.new([self, other])
+  end
+
+  def -(other)
+    HorizontalSequentialImage.new([self, other])
+  end
+
+  def at(line, column)
+    @line, @column = line, column
+
+    self
+  end
+
+  def self.blank_line
+    BlankLine.new
+  end
+
+  def bold
+    Bold.new(self)
+  end
+
+  def brackets
+    Brackets.new(self)
+  end
+
+  def self.checkbox(checked)
+    string(checked ? 'x' : ' ').brackets
+  end
+
+  def color(fg, bg = :transparent)
+    Color.new(self, fg, bg)
+  end
+
+  def column
+    @column || 0
+  end
+
+  def self.cursor(height, current)
+    color = current ? [:black, :magenta] : [:black]
+    VerticalSequentialImage.new([whitespace] * height).color(*color)
+  end
+
+  def self.empty
+    Empty.new
+  end
+
+  def self.remaining_resource(remaining, total, length)
+    ratio = remaining * 100 / total
+    color =
+      if ratio >= 40
+        :green
+      elsif ratio >= 20
+        :yellow
+      else
+        :red
+      end
+
+    bars = string(('|' * (remaining * length / total)).ljust(length)).color(color)
+
+    Between.new(bars, !string('['), !string(']'))
+  end
+
+  def line
+    @line || 0
+  end
+
+  def self.number(n)
+    string(n.to_s.gsub(/(\d)(?=(\d{3})+(?!\d))/, '\1,'))
+  end
+
+  def parens
+    Parens.new(self)
+  end
+
+  def self.plural(n, singular, plural = "#{singular}s")
+    string(n == 1 ? singular : plural)
+  end
+
+  def self.string(str)
+    StringImage.new(str)
+  end
+
+  def self.whitespace
+    string(' ')
+  end
+end

data/lib/twterm/key_mapper/abstract_key_mapper.rb

@@ -0,0 +1,51 @@
+require 'curses'
+require 'twterm/key_mapper/no_such_command'
+require 'twterm/key_mapper/no_such_key'
+
+module Twterm
+  class KeyMapper
+    class AbstractKeyMapper
+      def initialize(mappings)
+        commands = self.class.commands
+
+        mappings.keys.each do |k|
+          raise NoSuchCommand.new(self.class.category, k) unless commands.include?(k)
+        end
+
+        @mappings = Hash[mappings.map { |k, v| [k, translate(v)] }]
+      end
+
+      def [](key)
+        raise NoSuchCommand.new(self.class.category, key) unless @mappings.keys.include?(key)
+        @mappings[key]
+      end
+
+      private
+
+      def translate(key)
+        case key
+        when '!'..'}' then key
+        when /\A\^([A-Z]?)\Z/ then $1.ord - 'A'.ord + 1
+        when 'F1' then Curses::Key::F1
+        when 'F2' then Curses::Key::F2
+        when 'F3' then Curses::Key::F3
+        when 'F4' then Curses::Key::F4
+        when 'F5' then Curses::Key::F5
+        when 'F6' then Curses::Key::F6
+        when 'F7' then Curses::Key::F7
+        when 'F8' then Curses::Key::F8
+        when 'F9' then Curses::Key::F9
+        when 'F10' then Curses::Key::F10
+        when 'F11' then Curses::Key::F11
+        when 'F12' then Curses::Key::F12
+        else
+          raise NoSuchKey.new(key)
+        end
+      end
+
+      def self.commands
+        self::DEFAULT_MAPPINGS.keys
+      end
+    end
+  end
+end

data/lib/twterm/key_mapper/app_key_mapper.rb

@@ -0,0 +1,13 @@
+require 'twterm/key_mapper/abstract_key_mapper'
+
+class Twterm::KeyMapper::AppKeyMapper < Twterm::KeyMapper::AbstractKeyMapper
+  DEFAULT_MAPPINGS = {
+    cheatsheet: 'F1',
+    me: 'm',
+    quit: 'F10',
+  }.freeze
+
+  def self.category
+    'app'.freeze
+  end
+end

data/lib/twterm/key_mapper/cursor_key_mapper.rb

@@ -0,0 +1,13 @@
+require 'twterm/key_mapper/abstract_key_mapper'
+
+class Twterm::KeyMapper::CursorKeyMapper < Twterm::KeyMapper::AbstractKeyMapper
+  DEFAULT_MAPPINGS = {
+    bottom_of_window: 'L',
+    middle_of_window: 'M',
+    top_of_window: 'H',
+  }.freeze
+
+  def self.category
+    'cursor'.freeze
+  end
+end

data/lib/twterm/key_mapper/general_key_mapper.rb

@@ -0,0 +1,18 @@
+require 'twterm/key_mapper/abstract_key_mapper'
+
+class Twterm::KeyMapper::GeneralKeyMapper < Twterm::KeyMapper::AbstractKeyMapper
+  DEFAULT_MAPPINGS = {
+    bottom: 'G',
+    down: 'j',
+    left: 'h',
+    page_down: 'd',
+    page_up: 'u',
+    right: 'l',
+    top: 'g',
+    up: 'k',
+  }.freeze
+
+  def self.category
+    'general'.freeze
+  end
+end

data/lib/twterm/key_mapper/no_such_command.rb

@@ -0,0 +1,20 @@
+module Twterm
+  class KeyMapper
+    class NoSuchCommand < StandardError
+      attr_reader :category, :command
+
+      def initialize(category, command)
+        @category, @command = category, command
+        super(message)
+      end
+
+      def full_command
+        "#{category}.#{command}"
+      end
+
+      def message
+        "No such command: #{full_command}"
+      end
+    end
+  end
+end

data/lib/twterm/key_mapper/no_such_key.rb

@@ -0,0 +1,16 @@
+module Twterm
+  class KeyMapper
+    class NoSuchKey < StandardError
+      attr_reader :key
+
+      def initialize(key)
+        @key = key
+        super(message)
+      end
+
+      def message
+        "No such key: #{key}"
+      end
+    end
+  end
+end

data/lib/twterm/key_mapper/status_key_mapper.rb

@@ -0,0 +1,18 @@
+require 'twterm/key_mapper/abstract_key_mapper'
+
+class Twterm::KeyMapper::StatusKeyMapper < Twterm::KeyMapper::AbstractKeyMapper
+  DEFAULT_MAPPINGS = {
+    compose: '^N',
+    conversation: 'c',
+    destroy: 'D',
+    like: 'L',
+    open_link: 'o',
+    reply: 'r',
+    retweet: 'R',
+    user: 'U',
+  }.freeze
+
+  def self.category
+    'status'.freeze
+  end
+end