vedeu 0.0.3 → 0.0.4

data/lib/vedeu/output/directive.rb

@@ -0,0 +1,34 @@
+module Vedeu
+  class InvalidDirective < StandardError; end
+
+  class Directive
+    class << self
+      def enact(directive)
+        new(directive).enact
+      end
+    end
+
+    def initialize(directive)
+      @directive = directive
+    end
+
+    def enact
+      raise InvalidDirective unless valid_directive?
+
+      return Style.set(directive) if directive.is_a?(Symbol)
+
+      if directive.is_a?(Array)
+        return Position.set(*directive) if directive.first.is_a?(Numeric)
+        return Colour.set(directive)    if directive.first.is_a?(Symbol)
+      end
+    end
+
+    private
+
+    attr_reader :directive
+
+    def valid_directive?
+      directive.is_a?(Array) || directive.is_a?(Symbol)
+    end
+  end
+end

data/lib/vedeu/output/esc.rb

@@ -0,0 +1,37 @@
+module Vedeu
+  class Esc
+    class << self
+      def bold
+        [esc, '1m'].join
+      end
+
+      def clear
+        [esc, '2J'].join
+      end
+
+      def esc
+        [27.chr, '['].join
+      end
+
+      def hide_cursor
+        [esc, '?25l'].join
+      end
+
+      def inverse
+        [esc, '7m'].join
+      end
+
+      def reset
+        [esc, '0m'].join
+      end
+
+      def show_cursor
+        [esc, '?25h'].join
+      end
+
+      def underline
+        [esc, '4m'].join
+      end
+    end
+  end
+end

data/lib/vedeu/output/foreground.rb

@@ -0,0 +1,23 @@
+module Vedeu
+  class Foreground < Base
+    private
+
+    def prefix
+      '38;5;'
+    end
+
+    def codes
+      {
+        black:   30,
+        red:     31,
+        green:   32,
+        yellow:  33,
+        blue:    34,
+        magenta: 35,
+        cyan:    36,
+        white:   37,
+        default: 39,
+      }
+    end
+  end
+end

data/lib/vedeu/output/position.rb

@@ -0,0 +1,22 @@
+module Vedeu
+  class Position
+    class << self
+      def set(y = 0, x = 0)
+        new(y, x).set
+      end
+      alias_method :reset, :set
+    end
+
+    def initialize(y = 0, x = 0)
+      @y, @x = y, x
+    end
+
+    def set
+      [Esc.esc, (y + 1), ';', (x + 1), 'H'].join
+    end
+
+    private
+
+    attr_accessor :y, :x
+  end
+end

data/lib/vedeu/output/style.rb

@@ -0,0 +1,32 @@
+module Vedeu
+  class Style
+    class << self
+      def set(style)
+        new(style).set
+      end
+    end
+
+    def initialize(style)
+      @style = style
+    end
+
+    def set
+      case style
+      when :bold        then Esc.bold
+      when :clear       then Esc.clear
+      when :hide_cursor then Esc.hide_cursor
+      when :inverse     then Esc.inverse
+      when :reset       then Esc.reset
+      when :normal      then Esc.reset
+      when :show_cursor then Esc.show_cursor
+      when :underline   then Esc.underline
+      else
+        ""
+      end
+    end
+
+    private
+
+    attr_reader :style
+  end
+end

data/lib/vedeu/output/translator.rb

@@ -0,0 +1,62 @@
+module Vedeu
+  class Translator
+    class << self
+      def translate(html_colour = nil)
+        new(html_colour).translate
+      end
+    end
+
+    def initialize(html_colour = nil)
+      @html_colour = html_colour
+    end
+
+    def translate
+      return unless valid?
+      [term_colour_base, red, green, blue].inject(:+)
+    end
+
+    private
+
+    attr_reader :html_colour
+
+    def red
+      (html_colour[1..2].to_i(16) / colour_divide) * 36
+    end
+
+    def green
+      (html_colour[3..4].to_i(16) / colour_divide) * 6
+    end
+
+    def blue
+      (html_colour[5..6].to_i(16) / colour_divide) * 1
+    end
+
+    def colour_divide
+      source_values / target_values
+    end
+
+    def source_values
+      256
+    end
+
+    def target_values
+      5
+    end
+
+    def term_colour_base
+      16
+    end
+
+    def valid?
+      html_colour && valid_type? && valid_format?
+    end
+
+    def valid_type?
+      html_colour.is_a?(String)
+    end
+
+    def valid_format?
+      html_colour =~ /^#([A-Fa-f0-9]{6})$/
+    end
+  end
+end

data/lib/vedeu/process/command.rb

@@ -0,0 +1,51 @@
+module Vedeu
+  class InvalidCommand < StandardError; end
+
+  class Command
+    class << self
+      def define(name, klass, args = [], options = {})
+        new(name, klass, args, options).define
+      end
+    end
+
+    def initialize(name, klass, args = [], options = {})
+      @name, @klass, @args, @options = name, klass, args, options
+    end
+
+    def define
+      { name => executable } if valid?
+    end
+
+    private
+
+    attr_reader :name, :klass, :args, :options
+
+    def executable
+      Proc.new { klass.dispatch(*args) }
+    end
+
+    def valid?
+      empty_name? || empty_klass? || klass_defined? || dispatch_defined? || true
+    end
+
+    def empty_name?
+      raise InvalidCommand, "Command name is missing." if name.to_s.empty?
+    end
+
+    def empty_klass?
+      raise InvalidCommand, "Command class is missing." if klass.to_s.empty?
+    end
+
+    def klass_defined?
+      unless Object.const_defined?(klass.to_s)
+        raise InvalidCommand, "Command class is not defined."
+      end
+    end
+
+    def dispatch_defined?
+      unless klass.singleton_methods(false).include?(:dispatch)
+        raise InvalidCommand, "Command dispatch method is not defined."
+      end
+    end
+  end
+end

data/lib/vedeu/process/commands.rb

@@ -0,0 +1,58 @@
+module Vedeu
+  class Commands
+    include Singleton
+
+    class << self
+      def instance(&block)
+        @instance ||= new(&block)
+      end
+      alias_method :define, :instance
+
+      # def define(name, klass, args = [], options = {}, &block)
+      #   instance.define(name, klass, args = [], options = {})
+      # end
+
+      def execute(command = "")
+        instance.execute(command)
+      end
+
+      def list
+        instance.list
+      end
+    end
+
+    def initialize(&block)
+      @commands ||= { 'exit' => Proc.new { Exit.dispatch } }
+
+      yield self if block_given?
+    end
+
+    def define(name, klass, args = [], options = {})
+      commands.merge!(Command.define(name, klass, args, options))
+    end
+    alias_method :add, :define
+
+    def execute(command)
+      commands.fetch(command).call if exists?(command)
+    end
+
+    def list
+      commands.inspect
+    end
+
+    private
+
+    attr_accessor :commands
+    attr_accessor :instance
+
+    def exists?(command)
+      commands.fetch(command, false)
+    end
+  end
+
+  class Exit
+    def self.dispatch
+      :stop
+    end
+  end
+end

data/lib/vedeu/process/process.rb

@@ -0,0 +1,31 @@
+module Vedeu
+  class Process
+    class << self
+      def event_loop
+        new.event_loop
+      end
+    end
+
+    def initialize; end
+
+    def event_loop
+      while true do
+        command = evaluate
+
+        break if command == :stop
+
+        Compositor.write(command)
+      end
+    end
+
+    private
+
+    def evaluate
+      Commands.execute(read)
+    end
+
+    def read
+      Terminal.input
+    end
+  end
+end

data/lib/vedeu/support/terminal.rb

@@ -0,0 +1,139 @@
+module Vedeu
+  class Terminal
+    class << self
+      def input
+        console.gets.chomp
+      end
+
+      def output(stream = '')
+        console.puts(stream)
+      end
+
+      def width
+        size.last
+      end
+
+      def height
+        size.first
+      end
+
+      def size
+        console.winsize
+      end
+
+      def open(options = {}, &block)
+        new(options).open(&block)
+      end
+
+      def close
+        clear_screen
+        show_cursor
+        output(Position.reset)
+      end
+
+      def cooked(instance, &block)
+        console.cooked do
+          instance.initial_setup!
+
+          yield
+        end if block_given?
+      end
+      alias_method :open_cooked, :cooked
+
+      def raw(instance, &block)
+        console.raw do
+          instance.initial_setup!
+
+          yield
+        end if block_given?
+      end
+      alias_method :open_raw, :raw
+
+      def console
+        IO.console
+      end
+
+      def clear_screen
+        output(Esc.reset)
+        output(Esc.clear)
+      end
+
+      def clear_line(index)
+        output(Position.set(index, 0))
+        output(" " * width)
+      end
+
+      def show_cursor
+        output(Esc.show_cursor)
+      end
+
+      def hide_cursor
+        output(Esc.hide_cursor)
+      end
+    end
+
+    def initialize(options = {}, &block)
+      @options = options
+
+      yield self if block_given?
+    end
+
+    def open(&block)
+      terminal_mode(&block).fetch(mode, noop).call
+    end
+
+    def initial_setup!
+      Terminal.clear_screen if clear_screen?
+      set_cursor
+      output(Position.reset)
+    end
+
+    private
+
+    def terminal_mode(&block)
+      {
+        cooked: Proc.new { Terminal.cooked(self, &block) },
+        raw:    Proc.new { Terminal.raw(self, &block) }
+      }
+    end
+
+    def cursor_mode
+      {
+        show: Proc.new { Terminal.show_cursor },
+        hide: Proc.new { Terminal.hide_cursor }
+      }
+    end
+
+    def set_cursor
+      cursor_mode.fetch(cursor).call
+    end
+
+    def cursor
+      options.fetch(:cursor, :show)
+    end
+
+    def mode
+      options.fetch(:mode, :cooked)
+    end
+
+    def clear_screen?
+      options.fetch(:clear, true)
+    end
+
+    def noop
+      Proc.new {}
+    end
+
+    def options
+      defaults.merge!(@options)
+    end
+
+    def defaults
+      {
+        mode:   :cooked, # or :raw
+        clear:  true,    # or false (clears the screen if true)
+        cursor: :show,   # or :hide
+      }
+    end
+  end
+end