vedeu 0.2.12 → 0.3.0

data/lib/vedeu/{support → repositories}/repository.rb

@@ -1,11 +1,35 @@
+require 'vedeu/exceptions'
+require 'vedeu/models/all'
+require 'vedeu/support/common'
+
 module Vedeu
 
   # Provides common methods for accessing the various repositories Vedeu uses.
   #
+  # @example
+  #   { 'models' => [Model, Model, Model] }
+  #
+  #   { 'models' => [Model] }
+  #
   # @api private
-  module Repository
+  class Repository
 
-    include Common
+    include Vedeu::Common
+    include Enumerable
+
+    attr_reader :model, :storage
+
+    def initialize(model = nil, storage = {})
+      @model   = model
+      @storage = storage
+    end
+
+    # Returns log friendly output.
+    #
+    # @return [String]
+    def inspect
+      "<#{self.class.name} (#{storage.size})>"
+    end
 
     # Return the whole repository.
     #
@@ -14,6 +38,17 @@ module Vedeu
       storage
     end
 
+    # Return the model for the interface currently in focus.
+    #
+    # @return [String|NilClass]
+    def current
+      find_or_create(Vedeu.focus) if Vedeu.focus
+    end
+
+    def each(&block)
+      storage.each(&block)
+    end
+
     # Return a boolean indicating whether the storage is empty.
     #
     # @return [Boolean]
@@ -24,22 +59,29 @@ module Vedeu
     # Find the model attributes by name.
     #
     # @param name [String]
+    # @raise [ModelNotFound] When the model cannot be found with this name.
     # @return [Hash]
     def find(name)
-      storage.fetch(name) { not_found(name) }
+      storage.fetch(name) do
+        fail ModelNotFound, "Cannot find model by name: '#{name}'"
+      end
     end
 
     # Find a model by name, registers the model by name if not found.
     #
     # @param name [String]
-    # @return [Cursor|Offset]
+    # @return []
     def find_or_create(name)
-      storage.fetch(name) do
+      if registered?(name)
+        find(name)
+
+      else
         Vedeu.log("Model (#{model}) not found, registering: '#{name}'")
 
-        model.new({ name: name }).store
+        model.new(name).store
       end
     end
+    alias_method :by_name, :find_or_create
 
     # Returns a collection of the names of all the registered entities.
     #
@@ -58,6 +100,7 @@ module Vedeu
     # @param name [String]
     # @return [Boolean]
     def registered?(name)
+      return false if name.nil? || name.empty?
       return false if empty?
 
       storage.include?(name)
@@ -87,7 +130,7 @@ module Vedeu
     #
     # @return [Array|Hash|Set]
     def reset
-      @_storage = in_memory
+      @storage = in_memory
     end
 
     # Stores the model instance by name in the repository of the model.
@@ -95,53 +138,47 @@ module Vedeu
     # @param model [void] A model instance.
     # @return [void] The model instance which was stored.
     def store(model)
+      fail MissingRequired, "Cannot store model '#{model.class}' without a " \
+                            "name attribute." unless defined_value?(model.name)
+
+      Vedeu.log(_log_store(model))
+
       storage[model.name] = model
     end
+    alias_method :register, :store
 
-    private
+    # Access a model by name.
+    #
+    # @param name [String]
+    # @return [|NilClass]
+    def use(name)
+      if registered?(name)
+        find(name)
 
-    # @param method [Symbol]
-    # @return [String]
-    def action(method)
-      return 'Registering' if method == :add
+      else
+        nil
 
-      'Updating'
+      end
     end
 
-    # @param name [String]
-    # @raise [ModelNotFound] When the model cannot be found with this name.
-    # @return [ModelNotFound]
-    def not_found(name)
-      fail ModelNotFound, "Cannot find model by name: '#{name}'"
-    end
+    private
 
-    # Access to the storage for this repository.
-    #
     # @return [Hash]
-    def storage
-      @_storage ||= in_memory
+    def in_memory
+      {}
     end
 
-    # At present, validates that attributes has a `:name` key that is not nil or
-    # empty.
-    #
-    # @param attributes [Hash]
-    # @return [TrueClass|MissingRequired]
-    def validate_attributes!(attributes)
-      return missing_required unless attributes.key?(:name)
-      return missing_required unless defined_value?(attributes[:name])
+    # @return [String]
+    def _log_store(model)
+      message = "Storing #{model.class.name}: '#{model.name}' "
 
-      true
-    end
+      if registered?(model.name)
+        message + '(updating)'
 
-    # Raises the MissingRequired exception.
-    #
-    # @param attr [String] A textual representation of the attribute.
-    # @raise [MissingRequired] When an attribute, defined by the attr parameter
-    #   is missing.
-    # @return [MissingRequired]
-    def missing_required(attr = 'name')
-      fail MissingRequired, "Cannot store data without a #{attr} attribute."
+      else
+        message + '(creating)'
+
+      end
     end
 
   end # Repository

data/lib/vedeu/support/all.rb

@@ -0,0 +1,22 @@
+require 'vedeu/support/bounding_area'
+require 'vedeu/support/coercions'
+require 'vedeu/support/common'
+require 'vedeu/support/console'
+require 'vedeu/support/content_geometry'
+require 'vedeu/support/coordinate'
+require 'vedeu/support/esc'
+require 'vedeu/support/grid'
+require 'vedeu/support/log'
+require 'vedeu/support/position'
+require 'vedeu/support/position_validator'
+require 'vedeu/support/read'
+require 'vedeu/support/refresh'
+require 'vedeu/support/sentence'
+require 'vedeu/support/terminal'
+require 'vedeu/support/text'
+require 'vedeu/support/trace'
+require 'vedeu/support/visible'
+require 'vedeu/support/write'
+
+module Vedeu
+end # Vedeu

data/lib/vedeu/support/bounding_area.rb

@@ -2,7 +2,8 @@ module Vedeu
 
   class BoundingArea
 
-    attr_reader :height, :width
+    attr_reader :height,
+      :width
 
     # Returns an instance of BoundingArea.
     #

data/lib/vedeu/support/coercions.rb

@@ -1,3 +1,5 @@
+require 'vedeu/support/common'
+
 module Vedeu
 
   # Provides means to convert attributes into the correct model.
@@ -7,6 +9,21 @@ module Vedeu
 
     include Vedeu::Common
 
+    # Produces new objects of the correct class from the value, ignores objects
+    # that have already been coerced.
+    def coerce(value)
+      if value.is_a?(self)
+        value
+
+      elsif value.nil?
+        new
+
+      else
+        new(value)
+
+      end
+    end
+
     # Produces new objects of the correct class from attributes hashes,
     # ignores objects that have already been coerced.
     #
@@ -20,7 +37,7 @@ module Vedeu
           value
 
         else
-          self.new(value)
+          new(value)
 
         end
       end

data/lib/vedeu/support/console.rb

@@ -0,0 +1,73 @@
+require 'vedeu/support/read'
+require 'vedeu/support/write'
+
+module Vedeu
+
+  class Console
+
+    attr_reader :height,
+      :width
+
+    alias_method :yn, :height
+    alias_method :xn, :width
+
+    # @param height [Fixnum]
+    # @param width [Fixnum]
+    def initialize(height = 25, width = 80)
+      @height = height || 25
+      @width  = width  || 80
+    end
+
+    # @param data [String|NilClass]
+    # @return [String]
+    def input(data = nil)
+      Vedeu::Read.from(self, data)
+    end
+    alias_method :read, :input
+
+    # @param data [Array<Array<Char>>|Array<String>|String|NilClass]
+    # @return [Array]
+    def output(data = nil)
+      Vedeu::Write.to(self, data)
+    end
+    alias_method :write, :output
+
+    # Returns a coordinate tuple of the format [y, x], where `y` is the row/line
+    # and `x` is the column/character.
+    #
+    # @return [Array]
+    def centre
+      [(height / 2), (width / 2)]
+    end
+
+    # Returns the `y` (row/line) component of the coordinate tuple provided by
+    # {Vedeu::Terminal.centre}
+    #
+    # @return [Fixnum]
+    def centre_y
+      centre.first
+    end
+
+    # Returns the `x` (column/character) component of the coodinate tuple
+    # provided by {Vedeu::Terminal.centre}
+    #
+    # @return [Fixnum]
+    def centre_x
+      centre.last
+    end
+
+    # @return [Fixnum]
+    def origin
+      1
+    end
+    alias_method :x, :origin
+    alias_method :y, :origin
+
+    # @return [Array]
+    def size
+      [height, width]
+    end
+
+  end # Console
+
+end # Vedeu

data/lib/vedeu/support/content_geometry.rb

@@ -0,0 +1,69 @@
+module Vedeu
+
+  class ContentGeometry
+
+    extend Forwardable
+
+    def_delegators :interface,
+      :lines?,
+      :lines,
+      :geometry
+
+    def_delegators :geometry,
+      :height,
+      :width,
+      :x,
+      :y
+
+    def initialize(interface)
+      @interface = interface
+    end
+
+    # Returns log friendly output.
+    #
+    # @return [String]
+    def inspect
+      "<#{self.class.name} (y:#{y} x:#{x} yn:#{yn} xn:#{xn})>"
+    end
+
+    # Returns the height of the content, or when no content, the visible height
+    # of the interface.
+    #
+    # @return [Fixnum]
+    def yn
+      [rows, height].max
+    end
+
+    # Returns the width of the content, or when no content, the visible width of
+    # the interface.
+    #
+    # @return [Fixnum]
+    def xn
+      [columns, width].max
+    end
+
+    private
+
+    attr_reader :interface
+
+    # Returns the number of lines of content for this interface.
+    #
+    # @return [Fixnum]
+    def rows
+      return height unless lines?
+
+      lines.size
+    end
+
+    # Returns the character length of the longest line for this interface.
+    #
+    # @return [Fixnum]
+    def columns
+      return width unless lines?
+
+      lines.map { |line| line.size }.max
+    end
+
+  end # ContentGeometry
+
+end # Vedeu

data/lib/vedeu/support/coordinate.rb

@@ -0,0 +1,246 @@
+module Vedeu
+
+  # Crudely corrects out of range values.
+  class Coordinate
+
+    attr_reader :height,
+                :width,
+                :x,
+                :y
+
+    def initialize(height, width, x, y)
+      @height = height
+      @width  = width
+      @x      = x
+      @y      = y
+    end
+
+    # Returns log friendly output.
+    #
+    # @return [String]
+    def inspect
+      "<#{self.class.name} ( " \
+        "height:#{height} " \
+        "width:#{width} " \
+        "x:#{x} " \
+        "xn:#{xn} " \
+        "y:#{y} " \
+        "yn:#{yn} " \
+        ")>"
+    end
+
+    # Returns the maximum y coordinate for an area.
+    #
+    # @example
+    #   # y = 2
+    #   # height = 4
+    #   yn # => 6
+    #
+    # @return [Fixnum]
+    def yn
+      if height <= 0
+        0
+
+      else
+        y + height
+
+      end
+    end
+
+    # Returns the maximum x coordinate for an area.
+    #
+    # @example
+    #   # x = 5
+    #   # width = 20
+    #   xn # => 25
+    #
+    # @return [Fixnum]
+    def xn
+      if width <= 0
+        0
+
+      else
+        x + width
+
+      end
+    end
+
+    # Returns the index for a given y position.
+    #
+    # @example
+    #   # y_range  = [7, 8, 9, 10]
+    #   # y = 8
+    #   y_index     # => 1 # because (y_range[1] = 8)
+    #   y_index(10) # => 3
+    #   y_index(5)  # => 0
+    #   y_index(15) # => 3
+    #
+    # @param position [Fixnum]
+    # @return [Fixnum]
+    def y_index(position = y)
+      if height <= 0 || position <= y
+        0
+
+      elsif position >= yn
+        yn_index
+
+      else
+        y_range.index(position)
+
+      end
+    end
+
+    # Returns the index for a given x position.
+    #
+    # @example
+    #   # x_range = [4, 5, 6, 7, 8, 9, 10, 11, 12, 13]
+    #   # x = 8
+    #   x_index     # => 4 # because (x_range[4] = 8)
+    #   x_index(11) # => 7
+    #   x_index(2)  # => 0
+    #   x_index(15) # => 9
+    #
+    # @param position [Fixnum]
+    # @return [Fixnum]
+    def x_index(position = x)
+      if width <= 0 || position <= x
+        0
+
+      elsif position >= xn
+        xn_index
+
+      else
+        x_range.index(position)
+
+      end
+    end
+
+    # Returns the y coordinate for a given index.
+    #
+    # @example
+    #   # y_range = [7, 8, 9, 10, 11]
+    #   y_position     # => 7
+    #   y_position(-2) # => 7
+    #   y_position(2)  # => 9
+    #   y_position(7)  # => 11
+    #
+    # @param index [Fixnum]
+    # @return [Fixnum]
+    def y_position(index = 0)
+      if index <= 0
+        y
+
+      elsif index > yn_index
+        yn
+
+      else
+        y_range[index]
+
+      end
+    end
+
+    # Returns the x coordinate for a given index.
+    #
+    # @example
+    #   # x_range = [4, 5, 6, 7, 8, 9, 10, 11, 12, 13]
+    #   x_position     # => 4
+    #   x_position(-2) # => 4
+    #   x_position(2)  # => 6
+    #   x_position(15) # => 13
+    #
+    # @param index [Fixnum]
+    # @return [Fixnum]
+    def x_position(index = 0)
+      if index <= 0
+        x
+
+      elsif index > xn_index
+        xn
+
+      else
+        x_range[index]
+
+      end
+    end
+
+    private
+
+    attr_reader :height, :width
+
+    # Returns the maximum y index for an area.
+    #
+    # @example
+    #   # height = 3
+    #   yn_index # => 2
+    #
+    # @return [Fixnum]
+    def yn_index
+      return 0 if y_indices.empty?
+
+      y_indices.last
+    end
+
+    # Returns the maximum x index for an area.
+    #
+    # @example
+    #   # width = 6
+    #   xn_index # => 5
+    #
+    # @return [Fixnum]
+    def xn_index
+      return 0 if x_indices.empty?
+
+      x_indices.last
+    end
+
+    # Returns the same as #y_range, except as indices of an array.
+    #
+    # @example
+    #   # height = 4
+    #   y_indices # => [0, 1, 2, 3]
+    #
+    # @return [Array]
+    def y_indices
+      (0...height).to_a
+    end
+
+    # Returns the same as #x_range, except as indices of an array.
+    #
+    # @example
+    #   # width = 10
+    #   x_indices # => [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+    #
+    # @return [Array]
+    def x_indices
+      (0...width).to_a
+    end
+
+    # Returns an array with all coordinates from x to xn.
+    #
+    # @example
+    #   # width = 10
+    #   # x = 4
+    #   # xn = 14
+    #   x_range # => [4, 5, 6, 7, 8, 9, 10, 11, 12, 13]
+    #
+    # @return [Array]
+    def x_range
+      (x...xn).to_a
+    end
+
+    # Returns an array with all coordinates from y to yn.
+    #
+    # @example
+    #   # height = 4
+    #   # y  = 7
+    #   # yn  = 11
+    #   y_range # => [7, 8, 9, 10]
+    #
+    # @return [Array]
+    def y_range
+      (y...yn).to_a
+    end
+
+  end # Coordinate
+
+end # Vedeu

data/lib/vedeu/support/esc.rb

@@ -8,6 +8,8 @@ module Vedeu
 
     extend self
 
+    # Produces the foreground named colour escape sequence hash.
+    #
     # @return [Hash]
     def codes
       {
@@ -22,6 +24,15 @@ module Vedeu
         default: 39,
       }
     end
+    alias_method :foreground_codes, :codes
+
+    # Produces the background named colour escape sequence hash from the
+    # foreground escape sequence hash.
+    #
+    # @return [Hash]
+    def background_codes
+      Esc.codes.inject({}) { |h, (k, v)| h.merge(k => v + 10) }
+    end
 
     # Dynamically creates methods for each terminal named colour. When a block
     # is given, then the colour is reset to 'default' once the block is called.
@@ -36,15 +47,31 @@ module Vedeu
     #   Esc.on_blue { 'some text' } # => "\e[44msome text\e[49m"
     #
     # @return [String]
-    codes.each do |key, code|
+    foreground_codes.each do |key, code|
       define_method(key) do |&blk|
         "\e[#{code}m" + (blk ? blk.call + "\e[39m" : '')
       end
+    end
+
+    background_codes.each do |key, code|
       define_method('on_' + key.to_s) do |&blk|
-        "\e[#{code + 10}m" + (blk ? blk.call + "\e[49m" : '')
+        "\e[#{code}m" + (blk ? blk.call + "\e[49m" : '')
       end
     end
 
+    # Return the stream with the escape sequences escaped so that they can be
+    # printed to the terminal instead of being interpreted by the terminal which
+    # will render them. This way we can see what escape sequences are being sent
+    # along with the content.
+    #
+    # @param stream [String]
+    # @return [String]
+    def escape(stream = '')
+      return stream if stream.nil? || stream.empty?
+
+      stream.gsub(/\e/, '\\e')
+    end
+
     # Return the escape sequence required to position the cursor at a particular
     # point on the screen. When passed a block, will do the aforementioned,
     # call the block and then reposition to this location.