study 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: df597f9ef5df8f0f8772deef6ba1c2cd163fa3b4
+  data.tar.gz: 206609780a7246e7e966c2fb6cc8923fefc6ffcb
+SHA512:
+  metadata.gz: b26ca74f73016fda6cb5074e95c13d8d25f5a40c3c12cfb8f6685272c9487990978eef2d1f9cedba3b3b8e80b9655d0e21e15a4c102c2bcf365358f3a20c75d5
+  data.tar.gz: b2171cfe86784a5fcb4afe044cb8c183cf8e088dbd949e717578d0b4069503a3e16b55566f5884af4cf3bab51e5c9a552b7a08b109e6e61c680d351d7cea4161

data/lib/study.rb

@@ -0,0 +1,14 @@
+require 'study/text_highlight'
+require 'study/tree_node'
+require 'study/version'
+
+module Study
+  module Methods
+    def study(target, max_depth: 10, plain: false)
+      TreeNode.convert(target).draw(max_depth: max_depth, plain: plain)
+    end
+  end
+end
+
+extend Study::Methods
+include Study::Methods

data/lib/study/text_highlight.rb

@@ -0,0 +1,33 @@
+module Study
+  module TextHighlight
+    class << self
+      def red(string, plain: false)
+        plain ? string.to_s : "\033[1;31;40m#{ string.to_s }\033[0m"
+      end
+
+      def yellow(string, plain: false)
+        plain ? string.to_s : "\033[1;33;40m#{ string.to_s }\033[0m"
+      end
+
+      def blue(string, plain: false)
+        plain ? string.to_s : "\033[1;34;40m#{ string.to_s }\033[0m"
+      end
+
+      def green(string, plain: false)
+        plain ? string.to_s : "\033[1;32;40m#{ string.to_s }\033[0m"
+      end
+
+      def violet(string, plain: false)
+        plain ? string.to_s : "\033[1;35;40m#{ string.to_s }\033[0m"
+      end
+
+      def cyan(string, plain: false)
+        plain ? string.to_s : "\033[1;36;40m#{ string.to_s }\033[0m"
+      end
+
+      def white(string, plain: false)
+        plain ? string.to_s : "\033[1;37;40m#{ string.to_s }\033[0m"
+      end
+    end
+  end
+end

data/lib/study/tree_node.rb

@@ -0,0 +1,200 @@
+module Study
+  class TreeNode
+    attr_accessor :type, :value
+
+    def initialize(type:, value:)
+      @type = type
+      @value = value
+    end
+
+    def ==(other)
+      @type == other.type && @value == other.value
+    end
+
+    def highlight(left: nil, right: nil, nested: false, plain: false)
+      colored_left = left.is_a?(Integer) ? TextHighlight.violet(left, plain: plain) : TextHighlight.cyan(left, plain: plain)
+
+      if nested
+        [
+          colored_left,
+          TextHighlight.green(":", plain: plain),
+          " ",
+          TextHighlight.yellow(right, plain: plain)
+        ].join("")
+      else
+        [
+          colored_left,
+          TextHighlight.green(":", plain: plain),
+          " ",
+          TextHighlight.white(right, plain: plain)
+        ].join("")
+      end     
+    end
+
+    def draw(indent: 0, tree_key: nil, branch_toggle: [], max_depth: 10, plain: false)
+      return if indent > max_depth
+
+      if indent == 0
+        if has_children?
+          draw_line(indent: 0, 
+                    text: TextHighlight.yellow(@type, plain: plain), 
+                    branch_toggle: branch_toggle, 
+                    root: true,
+                    max_depth: max_depth,)
+
+        else
+          draw_line(indent: 0, 
+                    text: [TextHighlight.yellow(@type, plain: plain), TextHighlight.white(@value, plain: plain)].join(" "), 
+                    branch_toggle: branch_toggle, 
+                    root: true,
+                    max_depth: max_depth)
+
+          return
+        end
+      end
+
+      if has_children?
+        if tree_key
+          draw_line(indent: indent, 
+                    text: highlight(left: tree_key, right: @type, nested: true, plain: plain), 
+                    branch_toggle: branch_toggle,
+                    no_children: false,
+                    max_depth: max_depth,
+                    plain: plain)
+        end
+
+        each_child_with_last do |key, value, last|
+          if value.is_a?(TreeNode)
+            value.draw(indent: indent + 1, 
+                       tree_key: key, 
+                       branch_toggle: branch_toggle + [last], 
+                       max_depth: max_depth,
+                       plain: plain)
+          else
+            draw_line(indent: indent + 1,
+                      text: highlight(left: key, right: value, plain: plain), 
+                      branch_toggle: branch_toggle + [last], 
+                      max_depth: max_depth,
+                      plain: plain)
+          end
+        end
+      else
+        draw_line(indent: indent, 
+                  text: highlight(left: tree_key, right: @value, plain: plain), 
+                  branch_toggle: branch_toggle, 
+                  max_depth: max_depth,
+                  plain: plain)
+      end
+
+      nil
+    end
+
+    def each_child_with_last(&block)
+      total_size = @value.size
+      sorted_keys = @value.keys.sort
+
+      sorted_keys.each_with_index do |key, index|
+        value = @value[key]
+
+        block.call(key, value, total_size - 1 == index)
+      end
+    end
+
+    def draw_line(indent: 0, text:, branch_toggle:, root: false, no_children: true, max_depth: 10, plain: false)
+      if root
+        puts text
+      else
+        previous, current = branch_toggle[0..-2], branch_toggle[-1]
+
+        indent_lines = previous.map { |item| item ? "    " : "   │" }.join("")
+
+        current_branch_line = current ? "   └── " : "   ├── "
+
+        branch_lines = TextHighlight.green([indent_lines, current_branch_line].join(""), plain: plain)
+
+        puts [branch_lines, text].join("")
+
+        if current && (no_children || (indent >= max_depth))
+          puts TextHighlight.green([indent_lines].join(""), plain: plain)
+        end
+      end
+    end
+
+    def has_children?
+      ["Hash", "Array"].include?(@value.class.name)
+    end
+
+    def self.convert(target, registered_objects: [])
+      if registered_objects.include?(target.object_id)
+        return TreeNode.new(type: target.class.name, value: "DUPLICATE #{ target.class.name }")
+      else
+        if target.is_a?(Array) || target.is_a?(Hash) || target.instance_variables.size > 0
+          registered_objects << target.object_id
+        end
+      end
+
+      output = {
+        type: nil,
+        value: nil
+      }
+
+      target_class_name = target.class.name
+
+      if target.is_a?(Hash)
+        output_container = {}
+
+        target.each do |hash_key, hash_value|
+          output_container[hash_key] = convert(hash_value, registered_objects: registered_objects)
+        end
+
+        output[:value] = output_container
+
+      elsif target.is_a?(Array)
+        output_container = {}
+
+        target.each_with_index do |array_value, index|
+          output_container[index] = convert(array_value, registered_objects: registered_objects)
+        end
+
+        output[:value] = output_container
+
+      elsif target.instance_variables.size > 0
+        output_container = {}
+
+        target.instance_variables.each do |name|
+          value = target.instance_variable_get(name)
+          key = name.to_s.gsub('@', '').to_sym
+
+          # use getter method instead
+          if target.public_methods(false).include?(key.to_sym)
+            output_container[key] = convert(target.send(key.to_sym), registered_objects: registered_objects)
+          else
+            output_container[key] = convert(value, registered_objects: registered_objects)
+          end
+        end
+
+        output[:value] = output_container
+
+      elsif target_class_name == "NilClass"
+        output[:value] = "nil"
+
+      elsif target_class_name == "IO"
+        output[:value] = "<IO>"
+
+      elsif target_class_name == "Thread::Mutex"
+        output[:value] = "<Thread::Mutex>"
+
+      elsif target_class_name == "Proc"
+        output[:value] = "<Proc>"
+
+      else
+        output[:value] = target
+        
+      end
+
+      output[:type] = target_class_name
+
+      TreeNode.new(type: output[:type], value: output[:value])
+    end
+  end
+end

data/lib/study/version.rb

@@ -0,0 +1,3 @@
+module Study
+  VERSION = '1.0.0'
+end

metadata

@@ -0,0 +1,78 @@
+--- !ruby/object:Gem::Specification
+name: study
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Joshua Arvin Lat
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-01-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Study Ruby objects, hashes, and arrays by exposing their internal structure
+  with trees, colors, and indentation
+email:
+- joshua.arvin.lat@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/study.rb
+- lib/study/text_highlight.rb
+- lib/study/tree_node.rb
+- lib/study/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.6.8
+signing_key: 
+specification_version: 4
+summary: Study Ruby objects, hashes, and arrays by exposing their internal structure
+  with trees, colors, and indentation
+test_files: []