tree_support 0.1.0

data/lib/tree_support/inspector.rb

@@ -0,0 +1,116 @@
+require "kconv"
+require "active_support/concern"
+require "active_support/core_ext/module/attribute_accessors" # mattr_accessor
+
+module TreeSupport
+  mattr_accessor :name_methods
+  self.name_methods = [:to_s_tree_name, :name, :subject, :title]
+
+  def self.tree(*args, &block)
+    Inspector.tree(*args, &block)
+  end
+
+  def self.node_name(object)
+    object.send(name_methods.find {|e| object.respond_to?(e)} || :to_s)
+  end
+
+  class Inspector
+    def self.tree(object, *args, &block)
+      new(*args, &block).tree(object)
+    end
+
+    def initialize(**options, &block)
+      @options = {
+        take: 256,       # Up to depth N (for when the tree can not be displayed because it is huge)
+        drop: 0,         # From the depth N (when set to 1 you can hide the route)
+        root_label: nil, # A valid alternative label for displaying the route
+        tab_space: 4,    # Indent width from halfway
+        connect_char: "├",
+        tab_visible_char: "│",
+        edge_char: "└",
+        branch_char: "─",
+        debug: false,
+      }.merge(options)
+
+      @block = block
+    end
+
+    # 木構造の可視化
+    #
+    #   必要なメソッド
+    #     parent.children
+    #     name
+    #
+    def tree(object, **locals)
+      locals = {
+        depth: [],
+      }.merge(locals)
+
+      if locals[:depth].size > @options[:drop]
+        if object == object.parent.children.last
+          prefix_char = @options[:edge_char]
+        else
+          prefix_char = @options[:connect_char]
+        end
+      else
+        prefix_char = ""
+      end
+
+      indents = locals[:depth].each.with_index.collect {|e, i|
+        if i > @options[:drop]
+          tab = e ? @options[:tab_visible_char] : ""
+          tab.toeuc.ljust(@options[:tab_space]).toutf8
+        end
+      }.join
+
+      if @block
+        label = @block.call(object, locals)
+      else
+        if locals[:depth].empty? && @options[:root_label] # Change if there is root and alternative label
+          label = @options[:root_label]
+        else
+          label = TreeSupport.node_name(object)
+        end
+      end
+
+      buffer = ""
+      branch_char = nil
+
+      if locals[:depth].size > @options[:drop]
+        branch_char = @options[:branch_char]
+      end
+      if locals[:depth].size < @options[:take]
+        if locals[:depth].size >= @options[:drop]
+          buffer = "#{indents}#{prefix_char}#{branch_char}#{label}#{@options[:debug] ? locals[:depth].inspect : ""}\n"
+        end
+      end
+
+      flag = false
+      if object.parent
+        flag = (object != object.parent.children.last)
+      end
+
+      locals[:depth].push(flag)
+      if locals[:depth].size < @options[:take]
+        buffer << object.children.collect {|node| tree(node, locals)}.join
+      end
+      locals[:depth].pop
+
+      buffer
+    end
+  end
+
+  module Stringify
+    def to_s_tree(*args, &block)
+      Inspector.tree(self, *args, &block)
+    end
+  end
+end
+
+if $0 == __FILE__
+  $LOAD_PATH << ".."
+  require "tree_support"
+  puts TreeSupport.example.to_s_tree(take: 0)
+  puts TreeSupport.example.to_s_tree(take: 1)
+  puts TreeSupport.example.to_s_tree(take: 2)
+end

data/lib/tree_support/node.rb

@@ -0,0 +1,124 @@
+require 'active_support/core_ext/module/delegation' # for Module#delegate.
+
+module TreeSupport
+  # Simple node (because it is troublesome to bother to make it on the application side when only wooden structure information is wanted)
+  class Node
+    include Treeable
+    include Stringify
+
+    attr_accessor :attributes, :parent, :children
+
+    alias_method :name, :attributes
+    alias_method :key, :attributes
+
+    delegate :[], :[]=, :to_h, to: :attributes
+
+    def initialize(attributes = nil, &block)
+      @attributes = attributes
+      @children = []
+      if block_given?
+        instance_eval(&block)
+      end
+    end
+
+    def add(*args, &block)
+      tap do
+        children << self.class.new(*args, &block).tap do |v|
+          v.parent = self
+        end
+      end
+    end
+  end
+
+  def self.example
+    Node.new("*root*") do
+      add "Battle" do
+        add "Attack" do
+          add "Shake the sword"
+          add "Attack magic" do
+            add "Summoned Beast X"
+            add "Summoned Beast Y"
+          end
+          add "Repel sword in length"
+        end
+        add "Defense"
+      end
+      add "Withdraw" do
+        add "To stop" do
+          add "Place a trap"
+          add "Shoot a bow and arrow"
+        end
+        add "To escape"
+      end
+      add "Break" do
+        add "Stop"
+        add "Recover" do
+          add "Recovery magic"
+          add "Drink recovery medicine"
+        end
+      end
+    end
+  end
+
+  # Methods for easily making trees from data like CSV
+  class << self
+    # Array -> Tree
+    #
+    # records = [
+    #   {key: :a, parent: nil},
+    #   {key: :b, parent: :a},
+    #   {key: :c, parent: :b},
+    # ]
+    #
+    # puts TreeSupport.records_to_tree(records).to_s_tree
+    # a
+    # └─b
+    #      └─c
+    #          └─d
+    #
+    # Be sure to have one route
+    #
+    def records_to_tree(records, key: :key, parent_key: :parent, root_key: nil)
+      # Once hashed
+      source_hash = records.inject({}) { |a, e| a.merge(e[key] => e) }
+      # The node also makes it a hash of only the node having the key
+      node_hash = records.inject({}) { |a, e| a.merge(e[key] => Node.new(e[key])) }
+      # Link nodes
+      node_hash.each_value do |node|
+        if parent = source_hash[node.key][parent_key]
+          parent_node = node_hash[parent]
+          node.parent = parent_node
+          parent_node.children << node
+        end
+      end
+
+      # If the node whose parent was not set is the root (s)
+      roots = node_hash.each_value.find_all {|e| e.parent.nil? }
+
+      # Specify root_key when there are multiple routes and you are in trouble. Then create a new route and hang it.
+      if root_key
+        Node.new(root_key).tap do |root|
+          roots.each do |e|
+            e.parent = root
+            root.children << e
+          end
+        end
+      else
+        roots
+      end
+    end
+
+    # Tree -> Array
+    #
+    # p TreeSupport.tree_to_records(tree)
+    # [
+    #   {key: :a, parent: nil},
+    #   {key: :b, parent: :a},
+    #   {key: :c, parent: :b},
+    # ]
+    #
+    def tree_to_records(root, key: :key, parent_key: :parent)
+      root.each_node.collect {|e| {key => e.key, parent_key => e.parent&.key} }
+    end
+  end
+end

data/lib/tree_support/railtie.rb

@@ -0,0 +1,9 @@
+module TreeSupport
+  class Railtie < Rails::Railtie
+    initializer 'tree_support.acts_as_tree.insert_into_active_record' do
+      ActiveSupport.on_load :active_record do
+        ActiveRecord::Base.include(ArTreeModel)
+      end
+    end
+  end
+end

data/lib/tree_support/tree_support.rb

@@ -0,0 +1,28 @@
+# Tree structure visualization library
+#
+#   root = TreeSupport::Node.new("ROOT") do
+#     add "A" do
+#       add "B" do
+#         add "C"
+#       end
+#     end
+#   end
+#
+#   puts TreeSupport.tree(root)
+#   > ROOT
+#   > └─A
+#   >     └─B
+#   >         └─C
+
+require "tree_support/treeable"
+require "tree_support/inspector"
+require "tree_support/node"
+require "tree_support/ar_tree_model" if defined?(ActiveRecord)
+require "tree_support/railtie" if defined?(Rails)
+
+# Do not put gviz when you do not use it to touch Object
+begin
+  require "gviz"
+  require "tree_support/graphviz_builder"
+rescue LoadError
+end

data/lib/tree_support/treeable.rb

@@ -0,0 +1,52 @@
+# Definition of methods that are common in tree-structured interfaces
+#
+# All you need is parent and children methods
+#
+
+require "active_support/core_ext/module/concerning"
+
+module TreeSupport
+  concern :Treeable do
+    def root
+      parent ? parent.root : self
+    end
+
+    def root?
+      !parent
+    end
+
+    def leaf?
+      children.empty?
+    end
+
+    def each_node(&block)
+      return enum_for(__method__) unless block_given?
+      yield self
+      children.each { |e| e.each_node(&block) }
+    end
+
+    def descendants
+      children.flat_map { |e| [e] + e.descendants }
+    end
+
+    def self_and_descendants
+      [self] + descendants
+    end
+
+    def ancestors
+      self_and_ancestors - [self]
+    end
+
+    def self_and_ancestors
+      [self] + (parent ? parent.self_and_ancestors : [])
+    end
+
+    def siblings
+      self_and_siblings - [self]
+    end
+
+    def self_and_siblings
+      parent ? parent.children : []
+    end
+  end
+end

data/lib/tree_support/version.rb

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

data/lib/tree_support.rb

@@ -0,0 +1,2 @@
+require "tree_support/version"
+require "tree_support/tree_support"

data/spec/ar_tree_model_spec.rb

@@ -0,0 +1,82 @@
+require "spec_helper"
+
+require "rails"
+require "tree_support/ar_tree_model"
+require "tree_support/railtie"
+require "active_record"
+
+Class.new(Rails::Application){config.eager_load = true}.initialize!
+
+RSpec.describe "ArTreeModel" do
+  before do
+    ActiveRecord::Base.establish_connection(adapter: "sqlite3", database: ":memory:")
+    ActiveRecord::Migration.verbose = false
+
+    ActiveRecord::Schema.define do
+      create_table :nodes do |t|
+        t.belongs_to :parent
+        t.string :name
+      end
+    end
+
+    class Node < ActiveRecord::Base
+      ar_tree_model order: "name"
+
+      def add(name, &block)
+        tap do
+          child = children.create!(name: name)
+          if block_given?
+            child.instance_eval(&block)
+          end
+        end
+      end
+    end
+
+    @node = Node.create!(name: "*root*").tap do |n|
+      n.instance_eval do
+        add "Battle" do
+          add "Attack" do
+            add "Shake the sword"
+            add "Attack magic" do
+              add "Summoned Beast X"
+              add "Summoned Beast Y"
+            end
+            add "Repel sword in length"
+          end
+          add "Defense"
+        end
+        add "Withdraw" do
+          add "To stop" do
+            add "Place a trap"
+            add "Shoot a bow and arrow"
+          end
+          add "To escape"
+        end
+        add "Break" do
+          add "Stop"
+          add "Recover" do
+            add "Recovery magic"
+            add "Drink recovery medicine"
+          end
+        end
+      end
+    end
+  end
+
+  it "roots" do
+    Node.roots.should == [@node]
+  end
+
+  it "root" do
+    Node.root.should == @node
+  end
+
+  it "to_s_tree" do
+    @node.to_s_tree
+  end
+
+  it "safe_destroy_all" do
+    Node.safe_destroy_all
+    Node.count.should == 0
+  end
+end

data/spec/node_spec.rb

@@ -0,0 +1,52 @@
+require "spec_helper"
+
+RSpec.describe "Node" do
+  before do
+    @records = [
+      {key: :a0, parent: nil},
+      {key: :a1, parent: :a0},
+      {key: :a2, parent: :a1},
+      {key: :b0, parent: nil},
+      {key: :b1, parent: :b0},
+      {key: :b2, parent: :b1},
+    ]
+  end
+
+  it "Array -> Tree(s)" do
+    TreeSupport.records_to_tree(@records).collect(&:to_s_tree).join.should == <<-EOT
+a0
+└─a1
+    └─a2
+b0
+└─b1
+    └─b2
+EOT
+
+  end
+
+  it "Array -> Tree(1)" do
+    TreeSupport.records_to_tree(@records, root_key: :root).to_s_tree.should == <<-EOT
+root
+├─a0
+│   └─a1
+│       └─a2
+└─b0
+    └─b1
+        └─b2
+EOT
+  end
+
+  it "Tree -> Array" do
+    root = TreeSupport.records_to_tree(@records, root_key: :root)
+    records = TreeSupport.tree_to_records(root)
+    records.should == [
+      {key: :root, parent: nil   },
+      {key: :a0,   parent: :root },
+      {key: :a1,   parent: :a0   },
+      {key: :a2,   parent: :a1   },
+      {key: :b0,   parent: :root },
+      {key: :b1,   parent: :b0   },
+      {key: :b2,   parent: :b1   },
+    ]
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,8 @@
+$LOAD_PATH.unshift File.expand_path("../../lib", __FILE__)
+require "tree_support"
+
+RSpec.configure do |config|
+  config.expect_with :rspec do |expectations|
+    expectations.syntax = [:should, :expect]
+  end
+end

data/spec/tree_support_spec.rb

@@ -0,0 +1,28 @@
+require "spec_helper"
+
+RSpec.describe "TreeSupport" do
+  it "tree" do
+    expected = <<-EOT
+*root*
+├─Battle
+│   ├─Attack
+│   │   ├─Shake the sword
+│   │   ├─Attack magic
+│   │   │   ├─Summoned Beast X
+│   │   │   └─Summoned Beast Y
+│   │   └─Repel sword in length
+│   └─Defense
+├─Withdraw
+│   ├─To stop
+│   │   ├─Place a trap
+│   │   └─Shoot a bow and arrow
+│   └─To escape
+└─Break
+    ├─Stop
+    └─Recover
+        ├─Recovery magic
+        └─Drink recovery medicine
+EOT
+    TreeSupport.example.to_s_tree.should == expected
+  end
+end

data/spec/treeable_spec.rb

@@ -0,0 +1,59 @@
+require "spec_helper"
+
+RSpec.describe "Treeable" do
+  before do
+    @root = TreeSupport::Node.new("*root*") do
+      add "a" do
+        add "a1"
+        add "a2" do
+          add "x"
+        end
+        add "a3"
+      end
+    end
+    @a2 = @root.each_node.find {|e| e.name == "a2"}
+    @leaf = @root.each_node.find {|e| e.name == "x"}
+  end
+
+  it "root" do
+    @a2.root.name.should == "*root*"
+  end
+
+  it "root?" do
+    @root.root?.should == true
+    @leaf.root?.should == false
+  end
+
+  it "leaf?" do
+    @root.leaf?.should == false
+    @leaf.leaf?.should == true
+  end
+
+  it "each_node" do
+    @root.each_node.collect(&:name).should == ["*root*", "a", "a1", "a2", "x", "a3"]
+  end
+
+  it "descendants" do
+    @root.descendants.collect(&:name).should == ["a", "a1", "a2", "x", "a3"]
+  end
+
+  it "self_and_descendants" do
+    @root.self_and_descendants.collect(&:name).should == ["*root*", "a", "a1", "a2", "x", "a3"]
+  end
+
+  it "ancestors" do
+    @a2.ancestors.collect(&:name).should == ["a", "*root*"]
+  end
+
+  it "self_and_ancestors" do
+    @a2.self_and_ancestors.collect(&:name).should == ["a2", "a", "*root*"]
+  end
+
+  it "siblings" do
+    @a2.siblings.collect(&:name).should == ["a1", "a3"]
+  end
+
+  it "self_and_siblings" do
+    @a2.self_and_siblings.collect(&:name).should == ["a1", "a2", "a3"]
+  end
+end

data/tree_support.gemspec

@@ -0,0 +1,30 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'tree_support/version'
+
+Gem::Specification.new do |s|
+  s.name         = "tree_support"
+  s.version      = TreeSupport::VERSION
+  s.author       = "akicho8"
+  s.email        = "akicho8@gmail.com"
+  s.homepage     = "https://github.com/akicho8/tree_support"
+  s.summary      = "Tree structure visualization function library"
+  s.description  = "Tree structure visualization function library"
+  s.platform     = Gem::Platform::RUBY
+
+  s.files        = `git ls-files`.split("\n")
+  s.test_files   = `git ls-files -- {spec,features}/*`.split("\n")
+  s.executables  = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+  s.rdoc_options = ["--line-numbers", "--inline-source", "--charset=UTF-8", "--diagram", "--image-format=jpg"]
+
+  s.add_dependency "activesupport"
+
+  s.add_development_dependency "rake"
+  s.add_development_dependency "rspec"
+  s.add_development_dependency "rails"
+  s.add_development_dependency "activerecord"
+  s.add_development_dependency "sqlite3"
+  s.add_development_dependency "gviz"
+end