ascii_tree 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: edd4a091f0389f3142009d7f90e2f92e28bda572
+  data.tar.gz: afb677ecd9caa5908a140a1a80d359d3c92bd790
+SHA512:
+  metadata.gz: d3955dee1d7ae9b8478a464b933520b0a6b665a3c66c45ef3cadd1295c16e09a65108ba9e2bcaf88433fac05df014e99885527bbcfe4c6510929f78e5e1d6f87
+  data.tar.gz: 2570e3503e783e753716ee586b476367963250e93a75e32ac2196807ed5da5eb03b49958ea147eca13ce654401b03149aaec2a39d68e98efef9fff9813139929

data/README.md

@@ -0,0 +1,75 @@
+## Ascii Tree
+
+Parses a usable tree from ASCII art.
+
+Ascii Tree turns something humans understand into something computers
+understand. It is an expressive and efficient way to define trees.
+
+## Usage
+
+```ruby
+root = AsciiTree.parse('
+
+      # Christmas themed tree:
+
+              chestnuts
+              /     |  \
+          roasting  on  an
+            /   \         \
+        open   fire       jack
+               /   \
+            frost  nipping
+                    /  |  \
+                  on  your nose   # Ouch!
+
+')
+
+root.id
+#=> "chestnuts"
+
+root.parent
+#=> nil
+
+root.children
+#=> [#<AsciiTree::Node @id="roasting">, ...]
+```
+
+## Multiple words
+
+Use parenthesis to group words into a single node:
+
+```ruby
+root = AsciiTree.parse('
+
+          (this is a single node)
+              /    |    |    |   \
+    (so is this)  but these are separate
+
+')
+
+root.id
+#=> "this is a single node"
+```
+
+## Values
+
+You can set arbitrary values on nodes:
+
+```ruby
+root = AsciiTree.parse('
+
+        root{123}
+         /    \
+     a{"foo"}  b
+       / \
+      c   d{[1,2,3].reverse}
+
+')
+
+root.value
+#=> 123
+```
+
+## Contribution
+
+If you'd like to contribute, please open an issue or submit a pull request.

data/lib/ascii_tree.rb

@@ -0,0 +1,15 @@
+require "ascii_tree/base"
+
+require "ascii_tree/coordinate"
+require "ascii_tree/parenthesis_toggle"
+require "ascii_tree/word"
+require "ascii_tree/edge"
+require "ascii_tree/relationship"
+require "ascii_tree/node"
+
+require "ascii_tree/comment_stripper"
+require "ascii_tree/edge_parser"
+require "ascii_tree/word_parser"
+require "ascii_tree/scanner"
+require "ascii_tree/relationships_builder"
+require "ascii_tree/node_builder"

data/lib/ascii_tree/base.rb

@@ -0,0 +1,10 @@
+module AsciiTree
+  def self.parse(string)
+    string        = CommentStripper.strip(string)
+    words         = WordParser.parse(string)
+    edges         = EdgeParser.parse(string)
+    relationships = RelationshipsBuilder.build(words, edges)
+
+    NodeBuilder.build(relationships)
+  end
+end

data/lib/ascii_tree/comment_stripper.rb

@@ -0,0 +1,9 @@
+module AsciiTree
+  module CommentStripper
+
+    def self.strip(string)
+      string.gsub(/#[^\n]*/, "").gsub(/\s+\n/, "\n")
+    end
+
+  end
+end

data/lib/ascii_tree/coordinate.rb

@@ -0,0 +1,13 @@
+class AsciiTree::Coordinate
+
+  attr_reader :x, :y
+
+  def initialize(x:, y:)
+    @x, @y = x, y
+  end
+
+  def ==(other)
+    x == other.x && y == other.y
+  end
+
+end

data/lib/ascii_tree/edge.rb

@@ -0,0 +1,19 @@
+class AsciiTree::Edge
+
+  attr_reader :character, :coordinate, :parent_coordinate, :child_coordinate
+
+  def initialize(character:, coordinate:, parent_coordinate:, child_coordinate:)
+    @character         = character
+    @coordinate        = coordinate
+    @parent_coordinate = parent_coordinate
+    @child_coordinate  = child_coordinate
+  end
+
+  def ==(other)
+    character == other.character &&
+      coordinate == other.coordinate &&
+      parent_coordinate == other.parent_coordinate &&
+      child_coordinate == other.child_coordinate
+  end
+
+end

data/lib/ascii_tree/edge_parser.rb

@@ -0,0 +1,42 @@
+module AsciiTree
+  module EdgeParser
+    class << self
+
+      def parse(string)
+        edge_chars_with_coordinates(string).map do |char, coordinate|
+          offsets = edge_offsets[char]
+
+          Edge.new(
+            character: char,
+            coordinate: coordinate,
+            parent_coordinate: Coordinate.new(
+              x: coordinate.x + offsets[:parent][:x],
+              y: coordinate.y + offsets[:parent][:y]
+            ),
+            child_coordinate: Coordinate.new(
+              x: coordinate.x + offsets[:child][:x],
+              y: coordinate.y + offsets[:child][:y]
+            )
+          )
+        end
+      end
+
+      private
+
+      def edge_offsets
+        {
+          "/"  => { parent: { x: +1, y: -1 }, child: { x: -1, y: +1 } },
+          "|"  => { parent: { x:  0, y: -1 }, child: { x:  0, y: +1 } },
+          "\\" => { parent: { x: -1, y: -1 }, child: { x: +1, y: +1 } }
+        }
+      end
+
+      def edge_chars_with_coordinates(string)
+        Scanner.scan(string).select do |char, _|
+          edge_offsets.keys.include?(char)
+        end
+      end
+
+    end
+  end
+end

data/lib/ascii_tree/node.rb

@@ -0,0 +1,21 @@
+module AsciiTree
+  class Node
+
+    attr_reader :id, :value, :parent, :children
+
+    def initialize(id:, value:, parent:, children:)
+      @id       = id
+      @value    = value
+      @parent   = parent
+      @children = children
+    end
+
+    def ==(other)
+      id == other.id &&
+        value == other.value &&
+        parent == other.parent &&
+        children == other.children
+    end
+
+  end
+end

data/lib/ascii_tree/node_builder.rb

@@ -0,0 +1,50 @@
+module AsciiTree
+  class NodeBuilder
+
+    def self.build(*args)
+      new(*args).build
+    end
+
+    def initialize(relationships)
+      @relationships = relationships
+    end
+
+    def build
+      build_for(root_word, nil)
+    end
+
+    private
+
+    attr_reader :relationships
+
+    def root_word
+      relationships.first.parent_word
+    end
+
+    def build_for(word, parent)
+      node = Node.new(
+        id: word.id,
+        value: word.value,
+        parent: parent,
+        children: []
+      )
+
+      children_for(word, node).each do |child|
+        node.children << child
+      end
+
+      node
+    end
+
+    def children_for(word, parent)
+      child_relationships = relationships.select do |r|
+        r.parent_word == word
+      end
+
+      child_relationships.map do |r|
+        build_for(r.child_word, parent)
+      end
+    end
+
+  end
+end

data/lib/ascii_tree/parenthesis_toggle.rb

@@ -0,0 +1,38 @@
+module AsciiTree
+  class ParenthesisToggle
+
+    def initialize
+      @on, @count = false, 0
+    end
+
+    def read(char)
+      if char == "("
+        @on = true
+      elsif char == ")"
+        @on = false
+      end
+
+      if char == "("
+        @count += 1
+      elsif char == ")"
+        @count -= 1
+        @count = 0 if @count < 0
+      end
+
+      @on = @count > 0
+    end
+
+    def on?
+      @on
+    end
+
+    def off?
+      !@on
+    end
+
+    private
+
+    attr_reader :on
+
+  end
+end

data/lib/ascii_tree/relationship.rb

@@ -0,0 +1,19 @@
+module AsciiTree
+  class Relationship
+
+    attr_reader :parent_word, :edge, :child_word
+
+    def initialize(parent_word:, edge:, child_word:)
+      @parent_word = parent_word
+      @edge        = edge
+      @child_word  = child_word
+    end
+
+    def ==(other)
+      parent_word == other.parent_word &&
+        edge == other.edge &&
+        child_word == other.child_word
+    end
+
+  end
+end

data/lib/ascii_tree/relationships_builder.rb

@@ -0,0 +1,68 @@
+module AsciiTree
+  module RelationshipsBuilder
+    class << self
+
+      def build(words, edges)
+        relationships = edges.map do |edge|
+          parent = words.detect { |w| w.include?(edge.parent_coordinate) }
+          child  = words.detect { |w| w.include?(edge.child_coordinate) }
+
+          validate_presence(parent, child, edge)
+
+          Relationship.new(parent_word: parent, edge: edge, child_word: child)
+        end
+
+        validate_one_parent(relationships)
+        relationships
+      end
+
+      private
+
+      def validate_presence(parent, child, edge)
+        if parent.nil? && child.nil?
+          error = "No parent or child"
+        elsif parent.nil?
+          error = "No parent for child '#{child.id}'"
+        elsif child.nil?
+          error = "No child for parent '#{parent.id}'"
+        end
+
+        if error
+          c = edge.coordinate
+          error += " for edge '#{edge.character}' at line #{c.y}, column #{c.x}"
+          raise ::AsciiTree::RelationshipError, error
+        end
+      end
+
+      def validate_one_parent(relationships)
+        multiple_parents = relationships.select do |relationship|
+          count = relationships.count do |r|
+            r.child_word == relationship.child_word
+          end
+
+          count > 1
+        end
+
+        groups = multiple_parents.group_by { |r| r.child_word }
+
+        maps = groups.map do |child_word, relationships|
+          parent_words = relationships.map(&:parent_word)
+          [child_word.id, parent_words.map(&:id)]
+        end
+
+        if maps.any?
+          error = ""
+
+          maps.each do |child_word, parent_words|
+            parents = parent_words.join("' and '")
+            error += "'#{child_word}' has more than one parent: '#{parents}'.\n"
+          end
+        end
+
+        raise ::AsciiTree::RelationshipError, error if error
+      end
+
+      class ::AsciiTree::RelationshipError < StandardError; end
+    end
+  end
+end

data/lib/ascii_tree/scanner.rb

@@ -0,0 +1,35 @@
+module AsciiTree
+  module Scanner
+    class << self
+
+      def scan(string)
+        Enumerator.new do |yielder|
+          indexed_lines(string).each do |line, y|
+            indexed_chars(line).each do |char, x|
+              yielder.yield [char, Coordinate.new(x: x, y: y)]
+            end
+          end
+        end
+      end
+
+      private
+
+      def indexed_lines(string)
+        lines(string).each.with_index.to_a
+      end
+
+      def lines(string)
+        string.split("\n")
+      end
+
+      def indexed_chars(line)
+        chars(line).each_with_index.to_a
+      end
+
+      def chars(line)
+        line.split("")
+      end
+
+    end
+  end
+end

data/lib/ascii_tree/word.rb

@@ -0,0 +1,35 @@
+module AsciiTree
+  class Word
+
+    attr_reader :id, :value, :start_coordinate, :end_coordinate
+
+    def initialize(id:, value:, start_coordinate:, end_coordinate:)
+      @id               = id
+      @value            = value
+      @start_coordinate = start_coordinate
+      @end_coordinate   = end_coordinate
+    end
+
+    def ==(other)
+      id == other.id &&
+        value == other.value &&
+        start_coordinate == other.start_coordinate &&
+        end_coordinate == other.end_coordinate
+    end
+
+    def include?(coordinate)
+      same_line?(coordinate.y) && inside?(coordinate.x)
+    end
+
+    private
+
+    def same_line?(y)
+      y == start_coordinate.y && y == end_coordinate.y
+    end
+
+    def inside?(x)
+      (start_coordinate.x..end_coordinate.x).include?(x)
+    end
+
+  end
+end

data/lib/ascii_tree/word_parser.rb

@@ -0,0 +1,90 @@
+module AsciiTree
+  module WordParser
+    class << self
+
+      def parse(string)
+        chars = word_chars_with_coordinates(string)
+        group_contiguous(chars).map do |word_with_coords|
+          id, value = id_value(word_with_coords)
+
+          Word.new(
+            id: id,
+            value: value,
+            start_coordinate: word_with_coords.first.last,
+            end_coordinate: word_with_coords.last.last
+          )
+        end
+      end
+
+      private
+
+      def word_chars_with_coordinates(string)
+        toggle = ParenthesisToggle.new
+
+        Scanner.scan(string).reject do |char, coordinate|
+          toggle.read(char)
+          toggle.off? && (edge?(char) || whitespace?(char))
+        end
+      end
+
+      def edge?(char)
+        ["/", "|", "\\"].include?(char)
+      end
+
+      def whitespace?(char)
+        char.match(/\s/)
+      end
+
+      def id_value(word_with_coords)
+        chars = word_with_coords.map(&:first)
+        chars = remove_parentheses(chars)
+
+        word = chars.join
+
+        if word.end_with?("}")
+          id, tail = word.split("{", 2)
+          expression = tail[0..-2]
+          value = eval(expression)
+          [id, value]
+        else
+          [word, nil]
+        end
+      end
+
+      def remove_parentheses(chars)
+        if chars.first == "(" && chars.last == ")"
+          chars[1..-2]
+        else
+          chars
+        end
+      end
+
+      def group_contiguous(chars)
+        chars.inject([]) do |array, (char, coord)|
+          prev = previous_coordinate(array)
+
+          if contigous?(prev, coord)
+            array.last << [char, coord]
+          else
+            array << [[char, coord]]
+          end
+
+          array
+        end
+      end
+
+      def previous_coordinate(array)
+        previous_array = array.last
+        previous_tuple = previous_array.last if previous_array
+        previous_tuple.last if previous_tuple
+      end
+
+      def contigous?(previous_coordinate, coordinate)
+        previous_coordinate &&
+          previous_coordinate.y == coordinate.y &&
+          previous_coordinate.x == coordinate.x - 1
+      end
+
+    end
+  end
+end

metadata

@@ -0,0 +1,72 @@
+--- !ruby/object:Gem::Specification
+name: ascii_tree
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Chris Patuzzo
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-01-31 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: Parses a usable tree from ASCII art.
+email: chris@patuzzo.co.uk
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/ascii_tree.rb
+- lib/ascii_tree/base.rb
+- lib/ascii_tree/comment_stripper.rb
+- lib/ascii_tree/coordinate.rb
+- lib/ascii_tree/edge.rb
+- lib/ascii_tree/edge_parser.rb
+- lib/ascii_tree/node.rb
+- lib/ascii_tree/node_builder.rb
+- lib/ascii_tree/parenthesis_toggle.rb
+- lib/ascii_tree/relationship.rb
+- lib/ascii_tree/relationships_builder.rb
+- lib/ascii_tree/scanner.rb
+- lib/ascii_tree/word.rb
+- lib/ascii_tree/word_parser.rb
+homepage: https://github.com/tuzz/ascii_tree
+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.2.2
+signing_key: 
+specification_version: 4
+summary: Ascii Tree
+test_files: []