layouter 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 1fcb645c443a118766c615a471ccfda1577ca686391ebab9085a52bb82fa8401
+  data.tar.gz: 83514b4eef2fd89f7685ea9fdc61b16203d0c0c3b648f568132bd0116a545ac7
+SHA512:
+  metadata.gz: d0f23593d4f7ab1eec56ea70cf048f82ebb84a0157400718acd210fdd1bcdefce0902d439b97b7f01dae3b3a1327d1ca8f11f93dec1342022bbacda6bf485f25
+  data.tar.gz: cbb5abd09375ab153d1b0d6894f124049effa7136a11b0050bbaf2a265e47b82fc2ece1f57e11452829a7b3f382ee76d7e10962359c4feca2175e0b69db556dd

data/mnt/stuff/projects/layouter/lib/layouter.rb

@@ -0,0 +1,67 @@
+require_relative 'layouter/version'
+require_relative 'layouter/errors'
+require_relative 'layouter/element'
+require_relative 'layouter/parent'
+require_relative 'layouter/leaf/base'
+require_relative 'layouter/leaf/spacer'
+require_relative 'layouter/leaf/annotation'
+require_relative 'layouter/leaf/custom'
+
+module Layouter
+  class << self
+    def rows(*children)
+      Parent.new(:rows, children)
+    end
+
+    def cols(*children)
+      Parent.new(:cols, children)
+    end
+
+    def spacer(*args)
+      Leaf::Spacer.new(*args)
+    end
+
+    def annotation(*args)
+      Leaf::Annotation.new(*args)
+    end
+
+    def literal(content)
+      annotation(content, trim: false)
+    end
+
+    def custom(*args, &block)
+      Leaf::Custom.new(*args, &block)
+    end
+
+    def horizontal(char)
+      raise(ArgumentError.new("Must pass single character")) if char.length != 1
+      custom(height: 1) { |w, h| char * w }
+    end
+
+    def vertical(char)
+      raise(ArgumentError.new("Must pass single character")) if char.length != 1
+      custom(width: 1) { |w, h| ([char] * h).join("\n") }
+    end
+
+    def bordered(chars, *args, &block)
+      rows(
+        cols(
+          literal(chars[:tl]),
+          horizontal(chars[:t]),
+          literal(chars[:tr]),
+        ),
+        cols(
+          vertical(chars[:l]),
+          custom(*args, &block),
+          vertical(chars[:r]),
+        ),
+        cols(
+          literal(chars[:bl]),
+          horizontal(chars[:b]),
+          literal(chars[:br]),
+        )
+      )
+    end
+
+  end
+end

data/mnt/stuff/projects/layouter/lib/layouter/element.rb

@@ -0,0 +1,30 @@
+module Layouter
+  class Element
+
+    attr_reader :calculated_width, :calculated_height
+
+    def initialize
+      @calculated_width = @calculated_height = nil
+    end
+
+    [
+      :min_width, :max_width, :min_height, :max_height,
+       :importance, :layout, :render
+    ].each do |m|
+      define_method(m) do
+        raise(NotImplementedError, "Implemented by subclasses")
+      end
+    end
+
+    def layout?
+      !!@calculated_width && !!@calculated_height
+    end
+
+    private
+
+    def layout!
+      raise(StateError.new("Must layout first")) unless layout?
+    end
+
+  end
+end

data/mnt/stuff/projects/layouter/lib/layouter/errors.rb

@@ -0,0 +1,25 @@
+module Layouter
+
+  # Root error, never raised.
+  class GenericError < StandardError; end
+
+  # Raised if the state of an object is inconsistent with the called method.
+  class StateError < GenericError; end
+
+  # Should never be raised, unless our code is buggy.
+  class AssertionError < GenericError; end
+
+  # Only raised while laying out, if it is not possible to layout.
+  class LayoutError < GenericError
+
+    attr_reader :dimension, :reason
+
+    def initialize(dimension, reason)
+      @dimension, @reason = dimension, reason
+      msg = "#{dimension.to_s.capitalize} is #{reason.to_s.gsub("_", " ")}"
+      super(msg)
+    end
+
+  end
+
+end

data/mnt/stuff/projects/layouter/lib/layouter/leaf/annotation.rb

@@ -0,0 +1,49 @@
+module Layouter
+  module Leaf
+    class Annotation < Base
+
+      ALMOST = "~"
+      ELLIPSIS = "\u2026"
+
+      attr_accessor :min_height, :max_height
+
+      def initialize(content, importance: 1, trim: true)
+        super(importance: importance)
+        unless content.is_a?(Numeric) || content.is_a?(String)
+          raise(ArgumentError, "Must be a number or strings") 
+        end
+        @content = content
+        @trim = trim
+        @min_width = @max_width = @content.to_s.length # TODO: make smarter.
+        @min_height = @max_height = 1
+      end
+
+      def min_width
+        if @trim && @content.is_a?(String)
+          2
+        elsif @trim && @content.is_a?(Numeric)
+          dot = @content.to_s.index(".")
+          dot ? dot + 1 : @content.to_s.length
+        else
+          @content.to_s.length
+        end
+      end
+
+      def max_width
+        @content.to_s.length
+      end
+
+      def render
+        layout!
+        if @calculated_width == @content.to_s.length
+          @content.to_s
+        elsif @content.is_a?(String)
+          @content[0...(@calculated_width - 1)] + ELLIPSIS
+        elsif @content.is_a?(Numeric)
+          ALMOST + @content.to_s[0...(@calculated_width - 1)]
+        end
+      end
+
+    end
+  end
+end

data/mnt/stuff/projects/layouter/lib/layouter/leaf/base.rb

@@ -0,0 +1,30 @@
+module Layouter
+  module Leaf
+    class Base < Element
+
+      INF = Float::INFINITY
+      EPS = Float::EPSILON
+
+      attr_reader :importance
+
+      def initialize(importance:)
+        super()
+        if !importance.is_a?(Numeric) || importance < 0
+          raise(ArgumentError, "Invalid importance")
+        end
+        @importance = importance == 0 ? EPS : importance
+      end
+
+      def layout(width, height)
+        # These layout errors could occur in the dimension not being
+        # distributed by the parent, or if the leaf is layed our directly.
+        raise(LayoutError.new(:width, :too_small)) if width < min_width
+        raise(LayoutError.new(:width, :too_big)) if width > max_width
+        raise(LayoutError.new(:height, :too_small)) if height < min_height
+        raise(LayoutError.new(:height, :too_big)) if height > max_height
+        @calculated_width, @calculated_height = width, height
+      end
+
+    end
+  end
+end

data/mnt/stuff/projects/layouter/lib/layouter/leaf/custom.rb

@@ -0,0 +1,41 @@
+module Layouter
+  module Leaf
+    class Custom < Base
+
+      attr_reader :min_width, :max_width, :min_height, :max_height
+
+      def initialize(width: (0..INF), height: (0..INF), importance: 1, &block)
+        super(importance: importance)
+        [:width, :height].each do |dim|
+          eval <<-CODE, binding, __FILE__ , __LINE__ + 1
+            if #{dim}.is_a?(Integer)
+              @min_#{dim} = @max_#{dim} = #{dim}
+            elsif #{dim}.is_a?(Range) && #{dim}.first.is_a?(Integer)
+              @min_#{dim} = #{dim}.first
+              @max_#{dim} = #{dim}.exclude_end? ? #{dim}.last - 1 : #{dim}.last
+            else
+              raise(ArgumentError.new("Invalid #{dim}"))
+            end
+            if @min_#{dim} > @max_#{dim}
+              raise(ArgumentError.new("Inconsistent minimum and maximum #{dim}"))
+            end
+          CODE
+        end
+        raise(ArgumentError.new("Must pass block")) unless block_given?
+        @block = block
+      end
+
+      def render
+        layout!
+        w, h = @calculated_width, @calculated_height
+        res = @block.call(w, h)
+        lines = res.split("\n")
+        if lines.length != h || !lines.all? { |l| l.length == w }
+          raise(ArgumentError.new("Custom render has incorrect dimensions"))
+        end
+        res
+      end
+
+    end
+  end
+end

data/mnt/stuff/projects/layouter/lib/layouter/leaf/spacer.rb

@@ -0,0 +1,24 @@
+module Layouter
+  module Leaf
+    class Spacer < Base
+
+      attr_accessor :min_width, :max_width, :min_height, :max_height
+
+      def initialize(weight: 1)
+        unless weight.is_a?(Numeric)
+          raise(ArgumentError, "Weight must be a number")
+        end
+        raise(ArgumentError, "Weight must more than 1") if weight < 1
+        super(importance: EPS * weight)
+        @min_width = @min_height = 0
+        @max_width = @max_height = INF
+      end
+
+      def render
+        layout!
+        ([" " * @calculated_width] * @calculated_height).join("\n")
+      end
+
+    end
+  end
+end

data/mnt/stuff/projects/layouter/lib/layouter/parent.rb

@@ -0,0 +1,111 @@
+module Layouter
+  class Parent < Element
+
+    DIM = {
+      rows: :height,
+      cols: :width,
+    }.freeze
+
+    def initialize(orientation, children)
+      super()
+      unless DIM.keys.include?(orientation)
+        raise(ArgumentError.new("Invalid orientation"))
+      end
+      unless children.is_a?(Array) && children.all? { |c| c.is_a?(Element) }
+        raise(ArgumentError.new("Invalid children"))
+      end
+      @orientation = orientation
+      @children = children
+    end
+
+    def [](index)
+      @children[index]
+    end
+
+    def layout(width, height)
+      dim = DIM[@orientation]
+      value = binding.local_variable_get(dim)
+      min, max = send(:"min_#{dim}"), send(:"max_#{dim}")
+      raise(AssertionError) if min > max
+      raise(LayoutError.new(dim, :too_small)) unless value >= min
+      raise(LayoutError.new(dim, :too_big)) unless value <= max
+      importances = @children.map(&:importance)
+      maxs = @children.map { |c| c.send(:"max_#{dim}") - c.send(:"min_#{dim}") }
+      extras = self.class.distribute(value - min, importances, maxs)
+      @children.zip(extras).each do |child, extra|
+        child.layout(
+          dim == :width ? child.min_width + extra : width,
+          dim == :height ? child.min_height + extra : height,
+        )
+      end
+      @calculated_width, @calculated_height = width, height
+      self
+    end
+
+    [:width, :height].each do |dim|
+      define_method(:"min_#{dim}") do
+        mins = @children.map(&:"min_#{dim}")
+        DIM[@orientation] == dim ? mins.sum : mins.max
+      end
+      define_method(:"max_#{dim}") do
+        maxs = @children.map(&:"max_#{dim}")
+        DIM[@orientation] == dim ? maxs.sum : maxs.min
+      end
+    end
+
+    def importance
+      @children.map(&:importance).max
+    end
+
+    def render
+      layout!
+      if @orientation == :rows
+        @children.map(&:render).join("\n")
+      elsif @orientation == :cols
+        tmp = @children.map { |child| child.render.split("\n") }
+        tmp[0].zip(*tmp[1..-1]).map(&:join).join("\n")
+      end
+    end
+
+    def self.distribute(value, importances, maxs)
+      raise(AssertionError) unless value.is_a?(Integer) # Avoid endless loops.
+      raise(AssertionError) unless value <= maxs.sum # Avoid endless loops.
+      raise(AssertionError) unless importances.length == maxs.length
+      unless maxs.all? { |v| v.is_a?(Integer) || v == Float::INFINITY }
+        raise(AssertionError)
+      end
+      data = importances.zip(maxs).map.with_index do |(importance, max), i|
+        { index: i, value: 0, importance: importance, max: max }
+      end
+      while true # Distribute based on the importance, adhering to the maxs.
+        extra = value - data.map { |h| h[:value] }.sum
+        break if extra <= Float::EPSILON * data.length
+        candidates = data.select { |h| h[:value] < h[:max] }
+        denominator = candidates.map { |h| h[:importance] }.sum.to_f
+        candidates.each do |h|
+          share = extra * h[:importance] / denominator
+          h[:value] = h[:value] + share > h[:max] ? h[:max] : h[:value] + share
+        end
+      end
+      data.each { |h| h[:value] = h[:value].round }
+      while true # Fill up any extra or missing value from turning to integers.
+        extra = value - data.map { |h| h[:value] }.sum
+        break if extra == 0
+        delta = extra > 0 ? 1 : -1
+        data = data.sort_by { |h| h[:importance] }
+        data = data.reverse if extra > 0
+        data.cycle do |h|
+          if h[:max] > h[:value] && h[:value] > 0
+            h[:value] += delta
+            extra -= delta
+            break if extra == 0
+          end
+        end
+      end
+      raise(AssertionError) unless data.map { |h| h[:value] }.sum == value
+      raise(AssertionError) unless data.all? { |h| h[:value] <= h[:max] }
+      data.sort_by { |h| h[:index] }.map { |h| h[:value] }
+    end
+
+  end
+end

data/mnt/stuff/projects/layouter/lib/layouter/version.rb

@@ -0,0 +1,3 @@
+module Layouter
+  VERSION = "0.1.0"
+end

metadata

@@ -0,0 +1,66 @@
+--- !ruby/object:Gem::Specification
+name: layouter
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Sinan Taifour
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-12-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.0'
+description: A layout engine for terminals.
+email: sinan@taifour.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- "/mnt/stuff/projects/layouter/lib/layouter.rb"
+- "/mnt/stuff/projects/layouter/lib/layouter/element.rb"
+- "/mnt/stuff/projects/layouter/lib/layouter/errors.rb"
+- "/mnt/stuff/projects/layouter/lib/layouter/leaf/annotation.rb"
+- "/mnt/stuff/projects/layouter/lib/layouter/leaf/base.rb"
+- "/mnt/stuff/projects/layouter/lib/layouter/leaf/custom.rb"
+- "/mnt/stuff/projects/layouter/lib/layouter/leaf/spacer.rb"
+- "/mnt/stuff/projects/layouter/lib/layouter/parent.rb"
+- "/mnt/stuff/projects/layouter/lib/layouter/version.rb"
+homepage: 
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.6
+signing_key: 
+specification_version: 4
+summary: A layout engine for terminals.
+test_files: []