ansiterm 0.3.1 → 0.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: c7ee1afd97de8627d4106e6d2506c6afeeed80bd
-  data.tar.gz: 902a4d04c8b376286e9da45bc03219e46e6f33c8
+SHA256:
+  metadata.gz: 67a711d64ca029c1b3fb2a2cea32da16996f76ad440e901c4a2edad13564b7fd
+  data.tar.gz: dd675c62ede4b0530ffa53fcd9208f312bc6e44757d62ce3fa01b14d5ac9c392
 SHA512:
-  metadata.gz: 4f0aedde0e2ec57c2ea17cb53c8749d1c144bb78d9f230e98ce215ff7e9daab83e1cf8998a1c2283f53c3ce5f7ea31bf39e5d606e76b600ea859bb518a268ede
-  data.tar.gz: c790e5974e11c75df1216c8966119cf346878b4de6c7accce636729af3b2206e9b9eef028379dcf9b6e003921d0361312834b32f02942774c69b10f275b556ba
+  metadata.gz: 053de29389ed592194707f8406d83f7b56d09932657288d43a679a63bdd14300d73520160d932957c4f61919cfad4e1633519eb583a24a6a765f22f3d0edeca1
+  data.tar.gz: edd85d4d45baed56de37b1637ff4111e8e4687610fb91a4ea2206a4d92b0542899285da0766640b3eda2c8bb1bf0e05228d0473f5f0dc0cc7495251151d557ae

data/ansiterm.gemspec

@@ -21,7 +21,7 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.add_development_dependency "bundler", "~> 1.13"
+  spec.add_development_dependency "bundler"
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "rspec", "~> 3.0"
 end

data/lib/ansiterm/attr.rb

@@ -1,6 +1,7 @@
-
 module AnsiTerm
 
+  # # Attr #
+  #
   # Attr represents the attributes of a given character.
   # It is intended to follow the "Flyweight" GOF pattern
   # in that any object representing a given combination
@@ -10,7 +11,7 @@ module AnsiTerm
   # whether to e.g. encode a string as spans with one Attr,
   # or characters with one Attr per character.
   #
-  # Use Attr#transition(other_attr) to retrieve an ANSI
+  # Use `Attr#transition(other_attr)` to retrieve an ANSI
   # sequence that represents the changes from self to
   # other_attr.
   #
@@ -20,22 +21,45 @@ module AnsiTerm
     ITALICS     = 2
     UNDERLINE   = 4
     CROSSED_OUT = 8
-    
+
     attr_reader :fgcol, :bgcol, :flags
 
-    def initialize(fgcol: nil, bgcol: nil, flags: 0)
+    def initialize(fgcol: nil, bgcol: nil, flags: nil)
       @fgcol = fgcol
       @bgcol = bgcol
-      @flags = flags || 0
+      @flags = flags
       freeze
     end
 
-    def merge(attrs)
-      self.class.new({bgcol: @bgcol, fgcol: @fgcol, flags: @flags}.merge(attrs))
+    def ==(other)
+      return false if !other.kind_of?(self.class)
+      return fgcol == other.fgcol &&
+             bgcol == other.bgcol &&
+             flags == other.flags
     end
-    
-    def add_flag(flags); merge({flags: @flags | flags}); end
-    def clear_flag(flags); merge({flags: @flags & ~BOLD}); end
+
+    def to_h
+      attrs = {}
+      attrs[:bgcol] = @bgcol if @bgcol
+      attrs[:fgcol] = @fgcol if @fgcol
+      attrs[:flags] = @flags if @flags
+      attrs
+    end
+
+    def merge(attrs, ignore: nil)
+      return self if self == attrs
+      if attrs.respond_to?(:to_h)
+        attrs = attrs.to_h
+      end
+      if ignore
+        attrs.delete(ignore)
+      end
+      attrs = to_h.merge(attrs)
+      self.class.new(attrs)
+   end
+
+    def add_flag(flags);   merge({flags: @flags.to_i | flags.to_i}); end
+    def clear_flag(flags); merge({flags: @flags.to_i & ~flags.to_i}); end
 
     def reset;        self.class.new; end
     def normal;       clear_flag(BOLD); end
@@ -43,41 +67,44 @@ module AnsiTerm
     def underline;    add_flag(UNDERLINE); end
     def crossed_out;  add_flag(CROSSED_OUT); end
 
-    def bold?;        (@flags & BOLD) != 0; end
-    def underline?;   (@flags & UNDERLINE) != 0; end
-    def crossed_out?; (@flags & CROSSED_OUT) != 0; end
+    def bold?;        (@flags.to_i & BOLD) != 0; end
+    def underline?;   (@flags.to_i & UNDERLINE) != 0; end
+    def crossed_out?; (@flags.to_i & CROSSED_OUT) != 0; end
 
     def normal?
-      @flags == NORMAL &&
-        @fgcol.nil? &&
-        @bgcol.nil?
+      (@flags == NORMAL || @flags.nil?) &&
+        (@fgcol.nil? || @fgcol == 39) &&
+        (@bgcol.nil? || @bgcol == 49)
     end
 
     def transition_to(other)
       t = []
-      t << [other.fgcol] if other.fgcol != self.fgcol
-      t << [other.bgcol] if other.bgcol != self.bgcol
-      
+      t << [other.fgcol] if other.fgcol != self.fgcol && other.fgcol
+      t << [other.bgcol] if other.bgcol != self.fgcol && other.bgcol
+
       if other.bold? != self.bold?
         t << [other.bold? ? 1 : 22]
       end
-      
+
       if other.underline? != self.underline?
         t << [other.underline? ? 4 : 24]
       end
-      
+
       if other.crossed_out? != self.crossed_out?
         t << [other.crossed_out? ? 9 : 29]
       end
 
       return "\e[0m" if other.normal? && !self.normal? && t.length != 1
-      
+
       if t.empty?
         ""
       else
-        "\e[#{t.join(";")}m"
+        "\e[#{t.flatten.join(";")}m"
       end
     end
   end
 
+  def self.attr(*args)
+    Attr.new(*args)
+  end
 end

data/lib/ansiterm/buffer.rb

@@ -0,0 +1,91 @@
+
+module AnsiTerm
+
+  # # AnsiTerm::Buffer #
+  #
+  # A terminal buffer that will eventually handle ANSI style strings
+  # fully. For now it will handle the sequences AnsiTerm::String handles
+  # but e.g. cursor movement etc. needs to be explicitly handled.
+  #
+  # Extracted out of https://github.com/vidarh/re
+  #
+  # FIXME: Provide method of setting default background color
+  #
+  class Buffer
+    attr_reader :w,:h, :lines
+
+    def initialize(w=80, h=25)
+      @lines = []
+      @x = 0
+      @y = 0
+      @w = w
+      @h = h
+      @cache = []
+    end
+
+    def cls
+      @lines = (1..@h).map { nil }
+    end
+
+    def reset
+      cls
+      @cache=[]
+    end
+
+    def move_cursor(x,y)
+      @x = x
+      @y = y
+      @x = @w-1 if @x >= @w
+      @y = @y-1 if @y >= @h
+    end
+
+    def resize(w,h)
+      if @w != w || @h != h
+        @w, @h = w,h
+        @cache = []
+      end
+    end
+
+    def print *args
+      args.each do |str|
+        @lines[@y] ||= AnsiTerm::String.new
+        l = @lines[@y]
+
+        if l.length < @x
+          l << (" "*(@x - l.length))
+        end
+
+        r=@x..@x+str.length-1
+        #p [r, str]
+        l[r] = str
+      end
+    end
+
+    def to_s
+      out = ""
+      cachehit=0
+      cachemiss=0
+      @lines.each_with_index do |line,y|
+        line ||= ""
+        line = line[0..@w]
+        l = line.length
+        s = line.to_str
+        if @cache[y] != s
+          # Move to start of line; output line; clear to end
+          #if l > 0
+            out << "\e[#{y+1};1H" << s
+            if l < @w
+              out << "\e[0m\e[0K"
+            end
+          #end
+          cachemiss += s.length
+          old = @cache[y]
+          @cache[y] = s
+        else
+          cachehit += @cache[y].length
+        end
+      end
+      out
+    end
+  end
+end

data/lib/ansiterm/string.rb

@@ -1,9 +1,18 @@
-
+# coding: utf-8
 module AnsiTerm
 
   class String
-    def initialize(str="")
-      parse(str)
+    def initialize(str=nil)
+      if str
+        parse(str)
+      else
+        @str = ""
+        @attrs = []
+      end
+    end
+
+    def to_plain_str
+      @str.dup
     end
 
     def to_str
@@ -40,6 +49,55 @@ module AnsiTerm
       @str, @attrs = str,Array(attrs)
     end
 
+    def raw
+      return @str, Array(@attrs)
+    end
+
+    def set_attr(range, attr)
+      min   = [range.first - 1,0].max
+      fattr = @attrs[min]
+      #attr  = fattr.merge(attr)
+      r = Array(@attrs[range]).count # Inefficient, but saves dealing with negative offsets etc. "manually"
+      last = nil
+      @attrs[range] = @attrs[range]&.map do |a|
+        n = a ? a.merge(attr) : attr
+        last == n ? last : n
+      end || []
+      rm = range.last+1
+      if a = @attrs[rm]
+        @attrs[rm] = Attr.new.merge(fattr).merge(a)
+        if !a.bgcol
+          @attrs[rm] = @attrs[rm].merge({bgcol: 49})
+        end
+      end
+    end
+
+    def merge_attr_below(range, attr)
+      min = [0,range.first - 1].max
+      fattr = @attrs[min]
+      r = Array(@attrs[range]).count # Inefficient, but saves dealing with negative offsets etc. "manually"
+      last = nil
+      @attrs[range] = @attrs[range].map do |a|
+        if a.bgcol == 49
+          n = attr.merge(a, ignore: :bgcol)
+        else
+         n = attr.merge(a)
+        end
+         last == n ? last : n
+      end
+      #fattr #@attrs[min+r].merge(fattr)
+    end
+
+    def[]= range, str
+      s = @str.dup
+      a = @attrs.dup
+      parse(str)
+      s[range] = @str
+      @str = s
+      a[range] = @attrs
+      @attrs = a
+    end
+
     def[] i
       str = @str[i]
       if str
@@ -51,8 +109,25 @@ module AnsiTerm
       end
     end
 
+    def char_at(index)
+      @str[index]
+    end
+
+    def attr_at(index)
+      @attrs[index]
+    end
+
     def << str
-      parse(self.to_str + "\e[0m" + str.to_str)
+      return self if str.nil?
+      if !str.kind_of?(self.class)
+        parse(self.to_str + "\e[0m" + str.to_str)
+        return self
+      end
+
+      s,a = str.raw
+      @str.concat(s)
+      @attrs.concat(a)
+      self
     end
 
     private
@@ -64,12 +139,13 @@ module AnsiTerm
         if par == "5"
           col = [col,5,params.shift].join(";")
         elsif par == "2"
-          col = [col,5,params.shift,params.shift, params.shift].join(";")
+          col = [col,2,*params.slice!(0..2)].join(";")
+#          ,params.shift,params.shift, params.shift].join(";")
         end
       end
       a.merge(attr_name => col)
     end
-    
+
     def parse(str)
       @str   = ""
       @attrs = []
@@ -77,20 +153,26 @@ module AnsiTerm
 
       max = str.length
       i   = 0
-      
+
       while i < max
         c = str[i]
         if c == "\e" && str[i+1] == "[" # CSI
-          params = ""
+          params = []
           i += 2
+          par = ""
           while i < max && str[i].ord < 0x40
-            params << str[i]
+            if str[i] == ";"
+              params << par
+              par = ""
+            else
+              par << str[i]
+            end
             i+=1
           end
+          params << par if !par.empty?
           final = str[i]
 
           if final == "m"
-            params = params.split(";")
             while par = params.shift
               par = par.to_i
               case par
@@ -105,12 +187,13 @@ module AnsiTerm
               when 22
                 a = a.normal
               when 24
+                old = a
                 a = a.clear_flag(Attr::UNDERLINE)
               when 29
                 a = a.clear_flag(Attr::CROSSED_OUT)
-              when 30..39
+              when 30..39, 90..98
                 a = parse_color(par, params, a, :fgcol)
-              when 40..49
+              when 40..49, 100..107
                 a = parse_color(par, params, a, :bgcol)
               else
                 @str << "[unknown escape: #{par}]"
@@ -126,4 +209,8 @@ module AnsiTerm
       self
     end
   end
+
+  def self.str(*args)
+    AnsiTerm::String.new(*args)
+  end
 end

data/lib/ansiterm/version.rb

@@ -1,3 +1,3 @@
 module AnsiTerm
-  VERSION = "0.3.1"
+  VERSION = "0.4.1"
 end

data/lib/ansiterm.rb

@@ -1,4 +1,4 @@
 require "ansiterm/version"
 require "ansiterm/attr"
 require "ansiterm/string"
-
+require "ansiterm/buffer"

data/visual-spec/buffer.rb

@@ -0,0 +1,25 @@
+
+$: << File.dirname(__FILE__)+"/../lib"
+
+require 'ansiterm'
+require 'io/console'
+
+h,w = IO.console.winsize
+
+t = AnsiTerm::Buffer.new(w,h)
+
+t.cls
+t.move_cursor(1,1)
+t.print([h,w].inspect)
+t.move_cursor(0,0)
+t.print("UL")
+t.move_cursor(w-2,0)
+t.print("UR")
+t.move_cursor(w-2,h-2)
+t.print("LR")
+t.move_cursor(0,h-2)
+t.print("LL")
+t.move_cursor(1,2)
+t.print ("Hello world")
+print t.to_s
+gets

metadata

@@ -1,29 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: ansiterm
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.4.1
 platform: ruby
 authors:
 - Vidar Hokstad
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-01-30 00:00:00.000000000 Z
+date: 2021-12-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.13'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.13'
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -70,8 +70,10 @@ files:
 - bin/setup
 - lib/ansiterm.rb
 - lib/ansiterm/attr.rb
+- lib/ansiterm/buffer.rb
 - lib/ansiterm/string.rb
 - lib/ansiterm/version.rb
+- visual-spec/buffer.rb
 homepage: https://github.com/vidarh/ansiterm
 licenses:
 - MIT
@@ -91,8 +93,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.5.2
+rubygems_version: 3.1.4
 signing_key: 
 specification_version: 4
 summary: ANSI/VT102 terminal output with windowing