termgui 0.0.4

data/src/util/css.rb

@@ -0,0 +1,98 @@
+# css like language parser
+# TODO: move this to its own project
+
+module TermGui
+  # given a string like `foo {bg: red; padding-top: 3} .bar .primary {}`
+  # Rules:
+  #  * values cannot contain any of the following chars: `:;{}`
+  #  * No inmediate children ('>') supported. Example, `a b` is supported. `a>b` is not supported.
+  class CSSParser
+    def parse(code)
+      rules = parse_rules code
+      rules = parse_rules_properties rules
+      rules = parse_rules_selectors rules
+      rules
+    end
+
+    def parse_rules(code)
+      code.split('}').map do |rule|
+        a = rule.split('{')
+        throw "Syntax error in rule '#{rule}'" if a.length != 2
+        {
+          selector: a[0].strip,
+          body: a[1].strip
+        }
+      end
+    end
+
+    # given rules are the output of `parse_rules`. It will return a similar object but for each rule, instead `body` string have name-value `properies`
+    def parse_rules_properties(rules)
+      rules.map do |rule|
+        properties = rule[:body].split(';').map(&:strip)
+        properties = properties.map do |property|
+          a = property.split(':').map(&:strip)
+          throw "Syntax error in property '#{property}', rule: '#{rule}'" if a.length != 2
+          {
+            name: a[0],
+            value: a[1]
+          }
+        end
+        {
+          selector: rule[:selector],
+          properties: properties
+        }
+      end
+    end
+
+    # given rules are the output of `parse_rules_properties`, it returns a similar object but for each rule, instead `selector` string have
+    # a parsed selector object: `Array<Array<{name: string, operator: nil|'>'|' '}>>`
+    def parse_rules_selectors(rules)
+      rules.map do |rule|
+        selectors = rule[:selector].split(',').map(&:strip)
+        selectors = selectors.map do |s|
+          parse_selector s
+        end
+        {
+          selectors: selectors,
+          properies: rule[:properties]
+        }
+      end
+    end
+
+    # independent method to parse string selectors like 'a>b c' to `Array<{name: string, operator: nil|'>'|' '}>`
+    def parse_selector(s)
+      a = s.split(/([\s>])/)
+      i = 0
+      results = []
+      while i < a.length
+        results.push(name: a[i], operator: a[i + 1])
+        i += 2
+      end
+      results = results.reject { |result| result[:name].strip == '' }
+      results
+    end
+  end
+end
+
+CSSParser = TermGui::CSSParser
+
+# p = CSSParser.new
+# # p.parse('foo {bg: red; padding-top: 3} .bar .primary {border: double black}; .sidebar .container { padding: 1}')
+# s = 'a>  b c>d f'
+# p CSSParser.new.parse_selector 'a>  b c>d f'
+# a = s.split(/([\s>])/) # .select{|s|s.strip!=''}
+# p a
+# i = 0
+# results = []
+# while i < a.length
+#   results.push(name: a[i], operator: a[i + 1])
+#   i += 2
+# end
+# results = results.reject { |result| result[:name].strip == '' }
+# p results
+
+# parser = CSSParser.new
+# expected = '[{:selector=>"foo", :properties=>[{:name=>"bg", :value=>"red"}, {:name=>"padding-top", :value=>"3"}]}, {:selector=>".bar .primary", :properties=>[{:name=>"border", :value=>"double black"}]}, {:selector=>"; .sidebar .container", :properties=>[{:name=>"padding", :value=>"1"}]}]'
+# rules = parser.parse_rules_properties(parser.parse_rules('foo {bg: red; padding-top: 3} .bar .primary {border: double black}; .sidebar .container { padding: 1}'))
+# actual = parser.parse_rules_selectors(rules)
+# p actual

data/src/util/css_query.rb

@@ -0,0 +1,23 @@
+# will select descendants from given `root` Node that matches given string selector (like `a>.b c`).
+# The semantic mapping between ' ' and '>' "operators" and Node attributes can be overriden by subclassing
+module NodeSelector
+  # def initialize
+  #   @parser = CSSParser.new
+  # end
+  def css(root, selector)
+    @parser |= CSSParser.new
+    parsed = @parser.parse_selector(selector)
+    results = []
+    css_impl([root], parsed, results)
+  end
+
+  protected
+
+  # actual recursive css() implementation. each recursion will consume the first parsed passing the rest to the next call.
+  # roots will be also updated accordingly to current matches.
+  # The recursion condition is meet when parsed.length==1 (the last match step) which will return total matched elements
+  # flatten storing it on given imput result argument.
+  def css_impl(_roots, _parsed)
+    throw 'TODO'
+  end
+end

data/src/util/easing.rb

@@ -0,0 +1,364 @@
+# module TermGui
+#   module Easing
+#     def self.animate(
+#       duration: 1000,
+#       draw: nil, #  (n: number) => void
+#       timing: nil, # (n: number, c?: number, d?: number, x?: number, y?: number) => number
+#       lapse: 0.1
+#     )
+#     end
+#   end
+# end
+
+# # import { isObject } from 'misc-utils-of-mine-generic'
+
+# # type Timing = (n: number, c?: number, d?: number, x?: number, y?: number) => number
+# # type TimingObject = { fn: (duration: number) => Timing }
+# # export function animate({ duration, draw, timing, lapse }: {
+# #   duration: number
+# #   draw: (n: number) => void
+# #   timing: Timing | TimingObject
+# #   lapse?: number
+# # }) {
+# #   if (isObject(timing)) {
+# #     timing = (timing as any).fn(duration)
+# #   }
+# #   let start = Date.now()
+# #   let progress = 0
+# #   requestAnimationFrame(function anim(time) {
+# #     let timeFraction = (time - start) / duration
+# #     if (timeFraction > 1) timeFraction = 1
+# #     progress = (timing as Timing)(timeFraction, time - start, duration)
+# #     draw(progress)
+# #     if (timeFraction < 1) {
+# #       requestAnimationFrame(anim, lapse)
+# #     }
+# #   })
+# # }
+
+# # function requestAnimationFrame(f: (...args: any[]) => any, lapse = 0) {
+# #   setTimeout(() => f(Date.now()), lapse)
+# # }
+
+# # export namespace easing {
+# #   function makeEaseOut(timing: Timing) {
+# #     return function(timeFraction: any) {
+# #       return 1 - timing(1 - timeFraction)
+# #     }
+# #   }
+
+# #   function bounceFn(timeFraction: number) {
+# #     for (let a = 0, b = 1, result; 1; a += b, b /= 2) {
+# #       if (timeFraction >= (7 - 4 * a) / 11) {
+# #         return -Math.pow((11 - 6 * a - 11 * timeFraction) / 4, 2) + Math.pow(b, 2)
+# #       }
+# #     }
+# #   }
+
+# #   /** Imagine we are dropping a ball. It falls down, then bounces back a few times and stops. The bounce function does the same, but in the reverse order: “bouncing” starts immediately. */
+# #   export const bounceEasyOut: () => Timing = () => makeEaseOut(bounceFn as any)
+
+# #   /** parabolic curve */
+# #   export function quad(timeFraction: number) {
+# #     return Math.pow(timeFraction, 2)
+# #   }
+# #   // export const swing = t => 0.5 - Math.cos(t * Math.PI) / 2
+
+# #   /**
+# #    * “bow shooting”. First we “pull the bowstring”, and then “shoot”.
+# #    * @param x “elasticity coefficient”. The distance of “bowstring pulling” is defined by it. Default value 1.5.
+# #    */
+# #   export const back = (x = 1.5) => (timeFraction: number) => Math.pow(timeFraction, 2) * ((x + 1) * timeFraction - x)
+# #   /**
+# #    * @param x “initial range”
+# #    */
+# #   export const elastic = (x = 1.5) => (timeFraction: number) =>
+# #     Math.pow(2, 10 * (timeFraction - 1)) * Math.cos(((20 * Math.PI * x) / 3) * timeFraction)
+
+# #   function makeEaseInOut(timing: Timing) {
+# #     return function(timeFraction: number) {
+# #       if (timeFraction < 0.5) return timing(2 * timeFraction) / 2
+# #       else return (2 - timing(2 * (1 - timeFraction))) / 2
+# #     }
+# #   }
+
+# #   export const bounceEaseInOut: () => Timing = () => makeEaseInOut(bounceFn as any)
+
+# #   let c = 1,
+# #     b = 0
+# #   export const easeInQuad: () => Timing = () =>
+# #     ({ fn: (d: number) => (x: number, t: number) => c * (t /= d) * t + b } as any)
+
+# #   export const easeOutQuad: () => Timing = () =>
+# #     ({ fn: (d: number) => (x: number, t: number) => -c * (t /= d) * (t - 2) + b } as any)
+# #   export const easeInOutQuad: () => Timing = () =>
+# #     ({
+# #       fn: (d: number) => (x: number, t: number) => {
+# #         if ((t /= d / 2) < 1) return (c / 2) * t * t + b
+# #         return (-c / 2) * (--t * (t - 2) - 1) + b
+# #       }
+# #     } as any)
+# #   export const easeInElastic: () => Timing = () =>
+# #     ({
+# #       fn: (d: number) => (x: number, t: number) => {
+# #         let s = 1.70158
+# #         let p = 0
+# #         let a = c
+# #         if (t == 0) return b
+# #         if ((t /= d) == 1) return b + c
+# #         if (!p) p = d * 0.3
+# #         if (a < Math.abs(c)) {
+# #           a = c
+# #           let s = p / 4
+# #         } else {
+# #           s = (p / (2 * Math.PI)) * Math.asin(c / a)
+# #         }
+# #         return -(a * Math.pow(2, 10 * (t -= 1)) * Math.sin(((t * d - s) * (2 * Math.PI)) / p)) + b
+# #       }
+# #     } as any)
+
+# #   export const easeOutBounce: () => TimingObject = () =>
+# #     ({
+# #       fn: (d: number) => (x: number, t: number) => {
+# #         if ((t /= d) < 1 / 2.75) {
+# #           return c * (7.5625 * t * t) + b
+# #         } else if (t < 2 / 2.75) {
+# #           return c * (7.5625 * (t -= 1.5 / 2.75) * t + 0.75) + b
+# #         } else if (t < 2.5 / 2.75) {
+# #           return c * (7.5625 * (t -= 2.25 / 2.75) * t + 0.9375) + b
+# #         } else {
+# #           return c * (7.5625 * (t -= 2.625 / 2.75) * t + 0.984375) + b
+# #         }
+# #       }
+# #     } as any)
+
+# #   export const easeInCubic: () => Timing = () =>
+# #     ({
+# #       fn: (d: number) => (x: number, t: number) => {
+# #         return c * (t /= d) * t * t + b
+# #       }
+# #     } as any)
+
+# #   export const easeOutCubic: () => Timing = () =>
+# #     ({
+# #       fn: (d: number) => (x: number, t: number) => {
+# #         return c * ((t = t / d - 1) * t * t + 1) + b
+# #       }
+# #     } as any)
+
+# #   export const easeInOutCubic: () => Timing = () =>
+# #     ({
+# #       fn: (d: number) => (x: number, t: number) => {
+# #         if ((t /= d / 2) < 1) return (c / 2) * t * t * t + b
+# #         return (c / 2) * ((t -= 2) * t * t + 2) + b
+# #       }
+# #     } as any)
+
+# #   export const easeInQuart: Timing = () =>
+# #     ({
+# #       fn: (d: number) => (x: number, t: number) => {
+# #         return c * (t /= d) * t * t * t + b
+# #       }
+# #     } as any)
+
+# #   export const easeInOutQuart: Timing = () =>
+# #     ({
+# #       fn: (d: number) => (x: number, t: number) => {
+# #         if ((t /= d / 2) < 1) return (c / 2) * t * t * t * t + b
+# #         return (-c / 2) * ((t -= 2) * t * t * t - 2) + b
+# #       }
+# #     } as any)
+
+# #   export const easeInQuint: Timing = () =>
+# #     ({
+# #       fn: (d: number) => (x: number, t: number) => {
+# #         return c * (t /= d) * t * t * t * t + b
+# #       }
+# #     } as any)
+
+# #   export const easeOutQuint: () => Timing = () =>
+# #     ({
+# #       fn: (d: number) => (x: number, t: number) => {
+# #         return c * ((t = t / d - 1) * t * t * t * t + 1) + b
+# #       }
+# #     } as any)
+
+# #   export const easeInExpo: () => Timing = () =>
+# #     ({
+# #       fn: (d: number) => (x: number, t: number) => {
+# #         return t == 0 ? b : c * Math.pow(2, 10 * (t / d - 1)) + b
+# #       }
+# #     } as any)
+
+# #   export const easeInOutQuint: () => Timing = () =>
+# #     ({
+# #       fn: (d: number) => (x: number, t: number) => {
+# #         if ((t /= d / 2) < 1) return (c / 2) * t * t * t * t * t + b
+# #         return (c / 2) * ((t -= 2) * t * t * t * t + 2) + b
+# #       }
+# #     } as any)
+
+# #   export const easeInSine: () => Timing = () =>
+# #     ({
+# #       fn: (d: number) => (x: number, t: number) => {
+# #         return -c * Math.cos((t / d) * (Math.PI / 2)) + c + b
+# #       }
+# #     } as any)
+# #   export const easeInOutElastic: () => Timing = () =>
+# #     ({
+# #       fn: (d: number) => (x: number, t: number) => {
+# #         let s = 1.70158
+# #         let p = 0
+# #         let a = c
+# #         if (t == 0) return b
+# #         if ((t /= d / 2) == 2) return b + c
+# #         if (!p) p = d * (0.3 * 1.5)
+# #         if (a < Math.abs(c)) {
+# #           a = c
+# #           let s = p / 4
+# #         } else {
+# #           s = (p / (2 * Math.PI)) * Math.asin(c / a)
+# #         }
+# #         if (t < 1) return -0.5 * (a * Math.pow(2, 10 * (t -= 1)) * Math.sin(((t * d - s) * (2 * Math.PI)) / p)) + b
+# #         return a * Math.pow(2, -10 * (t -= 1)) * Math.sin(((t * d - s) * (2 * Math.PI)) / p) * 0.5 + c + b
+# #       }
+# #     } as any)
+
+# #   export const easeOutElastic: () => Timing = () =>
+# #     ({
+# #       fn: (d: number) => (x: number, t: number) => {
+# #         let s = 1.70158
+# #         let p = 0
+# #         let a = c
+# #         if (t == 0) return b
+# #         if ((t /= d) == 1) return b + c
+# #         if (!p) p = d * 0.3
+# #         if (a < Math.abs(c)) {
+# #           a = c
+# #           let s = p / 4
+# #         } else {
+# #           s = (p / (2 * Math.PI)) * Math.asin(c / a)
+# #         }
+# #         return a * Math.pow(2, -10 * t) * Math.sin(((t * d - s) * (2 * Math.PI)) / p) + c + b
+# #       }
+# #     } as any)
+# #   export const easeInOutExpo: () => Timing = () =>
+# #     ({
+# #       fn: (d: number) => (x: number, t: number) => {
+# #         if (t == 0) return b
+# #         if (t == d) return b + c
+# #         if ((t /= d / 2) < 1) return (c / 2) * Math.pow(2, 10 * (t - 1)) + b
+# #         return (c / 2) * (-Math.pow(2, -10 * --t) + 2) + b
+# #       }
+# #     } as any)
+
+# #   export const easeInOutBack: () => Timing = () =>
+# #     ({
+# #       fn: (d: number) => (x: number, t: number) => {
+# #         let s = 1.70158
+# #         if ((t /= d / 2) < 1) return (c / 2) * (t * t * (((s *= 1.525) + 1) * t - s)) + b
+# #         return (c / 2) * ((t -= 2) * t * (((s *= 1.525) + 1) * t + s) + 2) + b
+# #       }
+# #     } as any)
+
+# #   export const easeOutBack: () => Timing = () =>
+# #     ({
+# #       fn: (d: number) => (x: number, t: number, d: number) => {
+# #         let s = 1.70158
+# #         return c * ((t = t / d - 1) * t * ((s + 1) * t + s) + 1) + b
+# #       }
+# #     } as any)
+
+# #   export const easeInBounce: () => TimingObject = () =>
+# #     ({
+# #       fn: (d: number) => (x: number, t: number, d: number) => {
+# #         return c - easeOutBounce().fn(d)(x, d - t, 0, c, d) + b
+# #       }
+# #     } as any)
+
+# #   export const easeInOutBounce: () => Timing = () =>
+# #     ({
+# #       fn: (d: number) => (x: number, t: number, d: number) => {
+# #         if (t < d / 2) return easeInBounce().fn(d)(x, t * 2, 0, c, d) * 0.5 + b
+# #         return easeOutBounce().fn(d)(x, t * 2 - d, 0, c, d) * 0.5 + c * 0.5 + b
+# #       }
+# #     } as any)
+# # }
+
+# # // animate({
+# # //   duration: 2000,
+# # //   timing: easeInQuad(),
+# # //   lapse: 20,
+# # //   draw(progress) {
+# # //   console.log(progress * 100 + '%');
+# # //   }
+# # // });
+
+# # // TODO:
+# # // easeInOutSine: function (x, t, b, c, d) {
+# # //   return -c/2 * (Math.cos(Math.PI*t/d) - 1) + b;
+# # // },
+# # // easeOutExpo: function (x, t, b, c, d) {
+# # //   return (t==d) ? b+c : c * (-Math.pow(2, -10 * t/d) + 1) + b;
+# # // },
+# # // easeInCirc: function (x, t, b, c, d) {
+# # //   return -c * (Math.sqrt(1 - (t/=d)*t) - 1) + b;
+# # // },
+# # // easeOutCirc: function (x, t, b, c, d) {
+# # //   return c * Math.sqrt(1 - (t=t/d-1)*t) + b;
+# # // },
+# # // easeInOutCirc: function (x, t, b, c, d) {
+# # //   if ((t/=d/2) < 1) return -c/2 * (Math.sqrt(1 - t*t) - 1) + b;
+# # //   return c/2 * (Math.sqrt(1 - (t-=2)*t) + 1) + b;
+# # // },
+# # // easeInBack: function (x, t, b, c, d, s) {
+# # //   if (s == undefined) s = 1.70158;
+# # //   return c*(t/=d)*t*((s+1)*t - s) + b;
+# # // },
+# # // easeInBounce: function (x, t, b, c, d) {
+# # //   return c - jQuery.easing.easeOutBounce (x, d-t, 0, c, d) + b;
+# # // },
+# # // easeInOutBounce: function (x, t, b, c, d) {
+# # //   if (t < d/2) return jQuery.easing.easeInBounce (x, t*2, 0, c, d) * .5 + b;
+# # //   return jQuery.easing.easeOutBounce (x, t*2-d, 0, c, d) * .5 + c*.5 + b;
+# # // }
+
+# # // animate({
+# # //   duration: 1000,
+# # //   timing(timeFraction) {
+# # //     return timeFraction;
+# # //   },
+# # //   draw(progress) {
+# # //   console.log(progress * 100 + '%');
+
+# # //   }
+# # // });
+
+# # // setImmediate((t)=>{
+# # //   console.log(t);
+
+# # // })
+
+# # // function requestAnimationFrame(f){
+# # //   setImmediate(()=>f(Date.now()))
+# # // }
+
+# # // function animate({duration, draw, timing}) {
+
+# # //   let start = performance.now();
+
+# # //   requestAnimationFrame(function animate(time) {
+# # //     let timeFraction = (time - start) / duration;
+# # //     if (timeFraction > 1) timeFraction = 1;
+
+# # //     let progress = timing(timeFraction)
+
+# # //     draw(progress);
+
+# # //     if (timeFraction < 1) {
+# # //       requestAnimationFrame(animate);
+# # //     }
+
+# # //   });
+# # // }
+# # // The code for it:

data/src/util/hash_object.rb

@@ -0,0 +1,131 @@
+require_relative '../util'
+
+# Adds hash compatibility using instance_variable
+module HashObject
+  # Assigns this instance's properties from given Hash or HashObject instance.
+  def assign(hash)
+    object_assign(self, hash)
+  end
+
+  # def clone
+  #   new_from_hash(self)
+  # end
+
+  # alias merge assign
+
+  # creates a new empty instance and assign values in given hash or instance.
+  # This could be class method, but we want to be available to user classes.
+  # Warning: since `new` is called variables will be initialized even though not present in given hash.
+  def new_from_hash(hash)
+    if hash == nil
+      self.class.new.assign(self)
+    else
+      hash_obj = hash
+      if hash.instance_of?(Hash)
+        hash_obj = self.class.new
+        merge_hash_into_object(hash, hash_obj)
+      end
+      instance = self.class.new
+      object_assign(instance, hash_obj)
+    end
+  end
+
+  def get(name)
+    get_instance_variable self, name
+  end
+
+  def to_s
+    to_hash.to_s
+  end
+
+  def to_hash
+    object_variables_to_hash self
+  end
+end
+
+def object_variables_to_hash(obj)
+  return obj if obj.is_a?(Hash)
+
+  hash = {}
+  obj.instance_variables.each do |name|
+    s = name.to_s
+    key = s.slice(1, s.length).to_sym
+    hash[key] = obj.instance_variable_get(name)
+  end
+  hash
+end
+
+def merge_hash_into_object(hash, obj)
+  hash.keys.each do |key|
+    name = variable_name key
+    if obj.instance_variable_defined? name
+      value = hash[key]
+      obj.instance_variable_set(name, value) unless value == nil
+    end
+  end
+  obj
+end
+
+# assign properties from `src` to `dest`. by default it ignores nil properties.
+# TODO: option to recurse on object descendants
+def object_assign(dest, src, ignore_nil = true)
+  unless src.nil?
+    dest.instance_variables.each do |name|
+      val = nil
+      if src.instance_of? Hash
+        key = variable_key(name)
+        val = src[key]
+      else
+        val = src.instance_variable_get(name)
+      end
+      dest.instance_variable_set name, val unless ignore_nil && val == nil
+    end
+  end
+  dest
+end
+
+# returns true if given objects have same keys and values (using != for comparisson)
+def object_equal(obj1, obj2)
+  vars1 = obj1.instance_variables
+  vars2 = obj2.instance_variables
+  return false unless vars1.length == vars2.length
+  # if they don't have exactly the same instance_variables names then return false
+  return false unless vars1.map(&:to_s).sort.to_s == vars2.map(&:to_s).sort.to_s
+
+  equal = true
+  some(vars1, proc { |v|
+    val1 = obj1.instance_variable_get(v)
+    val2 = obj2.instance_variable_get(v)
+    if val1 != val2
+      equal = false
+      true
+    else
+      false
+    end
+  })
+  equal
+end
+
+# uses obj.instance_variable_get but supports the variable name in these formats "foo", :foo, :@foo and "@foo"
+def get_instance_variable(obj, name)
+  obj.instance_variable_get(variable_name(name))
+end
+
+# uses obj.instance_variable_set but supports the variable name in these formats "foo", :foo, :@foo and "@foo"
+def set_instance_variable(obj, name)
+  obj.instance_variable_set(variable_name(name))
+end
+
+# given a name in any of these formats "foo", :foo, :@foo and "@foo" it returns a valid instance_variable name (symbol), i.e. :@foo
+def variable_name(name)
+  s = name.to_s
+  s = "@#{s}" unless s.start_with? '@'
+  s.to_sym
+end
+
+# does the opossite as variable_name : given a variable name like "a", "@a", :@a, :a  it will return a valid symbol hash key, like :a
+def variable_key(name)
+  s = name.to_s
+  s = s.slice(1) if s.start_with? '@'
+  s.to_sym
+end

data/src/util/imagemagick.rb

@@ -0,0 +1,27 @@
+def command_error(c)
+  `#{c}`
+  false
+rescue StandardError
+  true
+end
+
+def image_magick_available
+  !command_error('convert --version') && !command_error('identify --version')
+end
+
+require 'fileutils'
+def app_folder(name = 'termgui')
+  folder = File.join ENV['HOME'], ".#{name}"
+  FileUtils.mkdir_p folder unless File.directory?(folder)
+  folder
+end
+
+def convert(input, format = 'png')
+  throw 'Refusing to convert : imagemagick not available' unless image_magick_available
+  output = File.join(app_folder, File.basename(input, '.*') + Time.now.to_i.to_s + '.' + format)
+  throw 'Refusing to convert : input file do not exists or output file exists' if !File.exist?(input) || File.exist?(output)
+  `convert "#{input}" "#{output}"`
+  output
+end
+
+# p convert('probes/assets/brazil.png')

data/src/util/justify.rb

@@ -0,0 +1,20 @@
+# def justify(string, len = 80)
+#   if string.length < len
+#     string
+#   else
+#     words = string.gsub("\n", ' ').scan(/[\w.-]+/)
+#     actual_len = 0
+#     output = []
+#     words.each do |w|
+#       output.push w
+#       actual_len += w.length
+#       if actual_len >= len
+#         output.push "\n"
+#         actual_len = 0
+#       else
+#         output .push ' '
+#       end
+#     end
+#     output.join('')
+#   end
+# end