xprint 0.9.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 72c5d81ad083539ab972c38b51405d5275034ce535f4014696257dbec0d6e5ab
+  data.tar.gz: 950f5d948e5098902d02d25eea8a62c1ec146a0dd58bb052bed139df50d06512
+SHA512:
+  metadata.gz: 33fb5f501119a0cb8015797c93f72516276eb332a03b9dba5f01696965a2ab2b8d06659724c8e12dcb3c9dd287df0311a6a11b48e9bef51fdf5bc329e9d114b5
+  data.tar.gz: 11492f4674dcd327edf54cfe909c1c830236ce798f34c830a8ac5f74b36e860ea3548d44af465a72a5ca73af90c8ff5ce3d92f8f8fc429baff92e8d0c2bafaa4

data/lib/version.rb

@@ -0,0 +1,3 @@
+module XPrint
+    VERSION = '0.9.1'
+end

data/lib/xprint.rb

@@ -0,0 +1,363 @@
+require 'bigdecimal'
+require 'date'
+require 'yaml'
+
+module XPrint
+    @data_classes = [
+        String, Integer, Float, TrueClass, FalseClass, NilClass,
+        Symbol, Date, Time, DateTime, BigDecimal, Rational
+    ]
+    @hash_name_classes = @data_classes + [Proc]
+    @tab = "  "
+    @indexes = true
+    @full_proc_path = false
+    @braces = true
+    @date_format = '%F'
+    @time_format = '%c'
+    @datetime_format = '%FT%T%:z'
+    @color = true
+    @colors = {
+        attribute:   :blue,
+        bigdecimal:  :darkcyan,
+        classname:   :darkgreen,
+        classobject: :green,
+        date:        :red,
+        datetime:    :purple,
+        false:       :darkred,
+        float:       :cyan,
+        index:       :darkgrey,
+        integer:     :cyan,
+        module:      :green,
+        nil:         :darkpurple,
+        proc:        :darkyellow,
+        rational:    :darkcyan,
+        string:      :yellow,
+        struct:      :green,
+        symbol:      :darkblue,
+        time:        :darkblue,
+        true:        :darkgreen
+    }
+    @color_codes = {
+        black:      "\e[30m",
+        blue:       "\e[94m",
+        darkblue:   "\e[34m",
+        cyan:       "\e[96m",
+        darkcyan:   "\e[36m",
+        green:      "\e[92m",
+        darkgreen:  "\e[32m",
+        grey:       "\e[37m",
+        darkgrey:   "\e[90m",
+        red:        "\e[91m",
+        darkred:    "\e[31m",
+        purple:     "\e[95m",
+        darkpurple: "\e[35m",
+        yellow:     "\e[93m",
+        darkyellow: "\e[33m",
+        reset:      "\e[0m"
+    }
+
+    def self.set(**kwargs)
+        set_vars = {
+            tab:             ->(data) { @tab             = data },
+            indexes:         ->(data) { @indexes         = data },
+            full_proc_path:  ->(data) { @full_proc_path  = data },
+            braces:          ->(data) { @braces          = data },
+            date_format:     ->(data) { @date_format     = data },
+            time_format:     ->(data) { @time_format     = data },
+            datetime_format: ->(data) { @datetime_format = data },
+            color:           ->(data) { @color           = data }
+        }
+    
+        kwargs.each do |keyword, arg|
+            if set_vars.key? keyword
+                set_vars[keyword].(arg)
+            end
+        end
+    
+        return
+    end
+
+    def self.load_file(config)
+        config_data = YAML.load( File.read config )
+        config_data = self.symbolize_keys(config_data)
+
+        if config_data.key? :general
+            self.set **config_data[:general]
+        end
+
+        if config_data.key? :colors
+            color_data = config_data[:colors]
+
+            color_data.each do |name, color|
+                color_data[name] = color.to_sym
+            end
+
+            self.set_color_for **config_data[:colors]
+        end
+
+        if config_data.key? :'color codes'
+            self.set_color_code_for **config_data[:'color codes']
+        end
+    end
+
+    def self.load(config)
+        calling_file = caller_locations.first.absolute_path
+        base_dir = File.dirname calling_file
+        relative_config = File.expand_path config, base_dir
+
+        self.load_file relative_config
+    end
+
+    private_class_method def self.symbolize_keys(hash)
+        hash.inject({}) do |result, (key, value)|
+            new_key = key.to_sym
+            new_value = value.is_a?(Hash) ? symbolize_keys(value) : value
+
+            result[new_key] = new_value
+            
+            result
+        end
+    end
+
+    def self.set_color_for(**kwargs)
+        kwargs.each do |keyword, arg|
+            @colors[keyword] = arg
+        end
+    end
+
+    def self.set_color_code_for(**kwargs)
+        kwargs.each do |keyword, arg|
+            @color_codes[keyword] = arg
+        end
+    end
+
+    def self.xp(*args)
+        args.each do |arg|
+            xpanded_text = self.xpand(arg, tab: @tab)
+
+            unless @braces
+                xpanded_text = self.shift_indentation_down(xpanded_text).lstrip()
+            end
+
+            puts xpanded_text
+        end
+    end
+
+    private_class_method def self.color_for(colorname)
+        @color_codes[colorname]
+    end
+
+    private_class_method def self.reset_color()
+        @color_codes[:reset]
+    end
+
+    private_class_method def self.colorize(text, type)
+        if @color
+            item_color = color_for @colors[type]
+            "#{item_color}#{text}#{reset_color}"
+        else
+            text
+        end
+    end
+
+    private_class_method def self.shift_indentation_down(text)
+        # Only shift if no 
+        return text if text.match?(/^\S/)
+        result = ''
+
+        text.each_line do |line|
+            result += (
+                if line.start_with? @tab
+                    line[@tab.length..-1]
+                else
+                    line
+                end
+            )
+        end
+
+        return result
+    end
+
+    def self.xpand(x, indent: '', tab: '  ')
+
+        _indent = "#{tab}#{indent}"
+
+        # X is a "primitive" kind of data that has no subitems, so
+        # we can just print it.
+        if x.class == String
+            return colorize(x.inspect, :string)
+        elsif x.class == Integer
+            return colorize(x.inspect, :integer)
+        elsif x.class == Float
+            return colorize(x.inspect, :float)
+        elsif x.class == TrueClass
+            return colorize(x.inspect, :true)
+        elsif x.class == FalseClass
+            return colorize(x.inspect, :false)
+        elsif x.class == NilClass
+            return colorize(x.inspect, :nil)
+        elsif x.class == Symbol
+            return colorize(x.inspect, :symbol)
+        
+        # X is a Proc, print more compact version of standard Proc.inspect
+        # text.
+        elsif x.class == Proc
+            type = x.lambda? ? 'Lambda' : 'Proc'
+            source, line = x.source_location
+            source = source.gsub('\\', '/')
+            
+            unless @full_proc_path
+                source = source.split('/')[-2..-1].join('/')
+            end
+            
+            return colorize("<#{type} @ #{source} [Line #{line}]>", :proc)
+        
+        elsif x.class == Class
+            return colorize("<Class #{x}>", :classobject)
+        
+        # X is an Array, print list of all items.
+        elsif x.class == Array
+            result = "#{@braces ? '[' : ''}\n"
+    
+            x.each_with_index do |item, index|
+                data = xpand(item, indent: _indent, tab: tab)
+                
+                result += "#{_indent}"
+                if @indexes
+                    adjustment = x.length.to_s.length + 3
+                    # Account for characters used for color coding.
+                    adjustment += 9 if @color
+
+                    result += "#{colorize("[#{index}]", :index)} ".
+                                ljust(adjustment)
+                end
+                result += "#{data}"
+    
+                unless index + 1 == x.length
+                    result += "#{@braces ? ', ' : ''} \n"
+                end
+            end
+    
+            result += "\n#{indent}]" if @braces
+            return result
+        
+        # X is a Hash, print all keys and values.
+        elsif x.class == Hash
+            result = "#{@braces ? '{' : ''}\n"
+
+            longest_key = (
+                x.keys.filter do |k, v|
+                    @hash_name_classes.include? k.class
+                end.
+                map do |k, v| 
+                    k.to_s.length 
+                end.
+                max()
+            )
+
+            longest_key = 0 if longest_key.nil?
+
+            # Color codes throw the text length, so we need to add the
+            # length of the color code and the code to reset the color
+            # that wrap around the colored word.
+            # The color code is like "\e[99m" and the reset "\e[0m",
+            # so the total length to add when using color is 9.
+            longest_key += 9 if @color
+    
+            x.each_with_index do |(key, value), index|
+                data_key   = "#{xpand(key, indent: _indent, tab: tab)}"
+
+                data_key = (
+                    if @hash_name_classes.include? key.class
+                        data_key.ljust(longest_key + 1)
+                    else
+                        data_key.ljust(data_key.length + longest_key)
+                    end
+                )
+
+                data_value = xpand(value, indent: _indent, tab: tab)
+
+                result += "#{_indent}#{data_key} => #{data_value}"
+
+                unless index + 1 == x.length
+                    result += "#{@braces ? ', ' : ''} \n"
+                end
+            end
+
+            result += "\n#{indent}}" if @braces
+    
+            return result
+
+        # X is a commonly used special kind of object.
+        elsif x.class == DateTime
+            datetime = x.strftime @datetime_format
+            return colorize("DateTime(#{datetime})", :datetime)
+        
+        elsif x.class == Date
+            date = x.strftime @date_format
+            return colorize("Date(#{date})", :date)
+        
+        elsif x.class == Time
+            time = x.strftime @time_format
+            return colorize("Time(#{time})", :time)
+        
+        elsif x.class == BigDecimal
+            return colorize("BigDecimal(#{x.to_s('f')})", :bigdecimal)
+        
+        elsif x.class == Rational
+            return colorize("Rational(#{x})", :rational)
+        
+        # X is a Structure; essentially a special case of X being an object.
+        elsif x.is_a? Struct
+            struct_word = colorize('Struct', :struct)
+            classname = colorize(x.class, :struct)
+            result = "#{struct_word} #{classname}#{@braces ? '(' : ''}\n"
+            longest_item = x.members.map { |m| m.to_s.length }.max()
+
+            x.each_pair do |name, value|
+                attr_name = colorize(name.to_s.ljust(longest_item), :attribute)
+                attr_data = xpand(value, indent: _indent, tab: tab)
+
+                result += "#{_indent}#{attr_name} = #{attr_data}\n"
+            end
+
+            result += "#{indent})" if @braces
+
+            return result
+        
+        # X is any arbitrary object; print all instance variables.
+        else
+            is_module = x.class == Module
+            classname = is_module ? "Module #{x}" : x.class
+            classname = colorize(classname, is_module ? :module : :classname)
+            result = "#{classname}#{@braces ? '(' : ''}"
+            ivars = x.instance_variables
+            result += "\n" if ivars.length > 0
+            longest_var = ivars.map { |v| v.to_s.length }.max()
+    
+            ivars.each_with_index do |var, index|
+                attr_name = var.to_s.ljust(longest_var)
+                attr_name = colorize(attr_name, :attribute)
+                attr_data = xpand(
+                    x.instance_variable_get(var),
+                    indent: _indent,
+                    tab: tab
+                )
+
+                result += "#{_indent}#{attr_name} = #{attr_data}\n"
+            end
+    
+            result += "#{ivars.length > 0 ? indent: ''})" if @braces
+    
+            return result
+        end
+    end    
+end
+
+def xp(*args)
+    XPrint::xp(*args)
+end
+
+def xpand(item, tab: "\t")
+    XPrint::xpand(item, tab: tab)
+end

metadata

@@ -0,0 +1,47 @@
+--- !ruby/object:Gem::Specification
+name: xprint
+version: !ruby/object:Gem::Version
+  version: 0.9.1
+platform: ruby
+authors:
+- JCabr
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2020-07-21 00:00:00.000000000 Z
+dependencies: []
+description: Gem that allows for pretty printing data over multiple lines and with
+  indentation, and works with objects as well as basic data types. Also allows color,
+  and loading settings via a YAML config file.
+email:
+- jcabr.dev@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/version.rb
+- lib/xprint.rb
+homepage: https://github.com/JCabr/xprint.rb
+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: []
+rubygems_version: 3.1.2
+signing_key: 
+specification_version: 4
+summary: Gem for pretty printing any kind of object.
+test_files: []